Skip to content

C
ChainGrpcPro
Commit 9234b25c authored by duanjinfei's avatar duanjinfei
Browse files
Options

add meta protocol gen

parent 7d479106
Pipeline #574 failed with stages
      Hide whitespace changes
      Inline Side-by-side
      Showing with 24581 additions and 1 deletion
      MetaProtocol-main/gen/proto/go/base/gogo.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: base/gogo.proto
      package base
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      descriptorpb "google.golang.org/protobuf/types/descriptorpb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      var E_GoprotoEnumPrefix = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.EnumOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 62001,
      Name: "gogoproto.goproto_enum_prefix",
      Tag: "varint,62001,opt,name=goproto_enum_prefix",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoEnumStringer = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.EnumOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 62021,
      Name: "gogoproto.goproto_enum_stringer",
      Tag: "varint,62021,opt,name=goproto_enum_stringer",
      Filename: "base/gogo.proto",
      }
      var E_EnumStringer = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.EnumOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 62022,
      Name: "gogoproto.enum_stringer",
      Tag: "varint,62022,opt,name=enum_stringer",
      Filename: "base/gogo.proto",
      }
      var E_EnumCustomname = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.EnumOptions)(nil),
      ExtensionType: (*string)(nil),
      Field: 62023,
      Name: "gogoproto.enum_customname",
      Tag: "bytes,62023,opt,name=enum_customname",
      Filename: "base/gogo.proto",
      }
      var E_Enumdecl = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.EnumOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 62024,
      Name: "gogoproto.enumdecl",
      Tag: "varint,62024,opt,name=enumdecl",
      Filename: "base/gogo.proto",
      }
      var E_EnumvalueCustomname = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.EnumValueOptions)(nil),
      ExtensionType: (*string)(nil),
      Field: 66001,
      Name: "gogoproto.enumvalue_customname",
      Tag: "bytes,66001,opt,name=enumvalue_customname",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoGettersAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63001,
      Name: "gogoproto.goproto_getters_all",
      Tag: "varint,63001,opt,name=goproto_getters_all",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoEnumPrefixAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63002,
      Name: "gogoproto.goproto_enum_prefix_all",
      Tag: "varint,63002,opt,name=goproto_enum_prefix_all",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoStringerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63003,
      Name: "gogoproto.goproto_stringer_all",
      Tag: "varint,63003,opt,name=goproto_stringer_all",
      Filename: "base/gogo.proto",
      }
      var E_VerboseEqualAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63004,
      Name: "gogoproto.verbose_equal_all",
      Tag: "varint,63004,opt,name=verbose_equal_all",
      Filename: "base/gogo.proto",
      }
      var E_FaceAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63005,
      Name: "gogoproto.face_all",
      Tag: "varint,63005,opt,name=face_all",
      Filename: "base/gogo.proto",
      }
      var E_GostringAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63006,
      Name: "gogoproto.gostring_all",
      Tag: "varint,63006,opt,name=gostring_all",
      Filename: "base/gogo.proto",
      }
      var E_PopulateAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63007,
      Name: "gogoproto.populate_all",
      Tag: "varint,63007,opt,name=populate_all",
      Filename: "base/gogo.proto",
      }
      var E_StringerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63008,
      Name: "gogoproto.stringer_all",
      Tag: "varint,63008,opt,name=stringer_all",
      Filename: "base/gogo.proto",
      }
      var E_OnlyoneAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63009,
      Name: "gogoproto.onlyone_all",
      Tag: "varint,63009,opt,name=onlyone_all",
      Filename: "base/gogo.proto",
      }
      var E_EqualAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63013,
      Name: "gogoproto.equal_all",
      Tag: "varint,63013,opt,name=equal_all",
      Filename: "base/gogo.proto",
      }
      var E_DescriptionAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63014,
      Name: "gogoproto.description_all",
      Tag: "varint,63014,opt,name=description_all",
      Filename: "base/gogo.proto",
      }
      var E_TestgenAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63015,
      Name: "gogoproto.testgen_all",
      Tag: "varint,63015,opt,name=testgen_all",
      Filename: "base/gogo.proto",
      }
      var E_BenchgenAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63016,
      Name: "gogoproto.benchgen_all",
      Tag: "varint,63016,opt,name=benchgen_all",
      Filename: "base/gogo.proto",
      }
      var E_MarshalerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63017,
      Name: "gogoproto.marshaler_all",
      Tag: "varint,63017,opt,name=marshaler_all",
      Filename: "base/gogo.proto",
      }
      var E_UnmarshalerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63018,
      Name: "gogoproto.unmarshaler_all",
      Tag: "varint,63018,opt,name=unmarshaler_all",
      Filename: "base/gogo.proto",
      }
      var E_StableMarshalerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63019,
      Name: "gogoproto.stable_marshaler_all",
      Tag: "varint,63019,opt,name=stable_marshaler_all",
      Filename: "base/gogo.proto",
      }
      var E_SizerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63020,
      Name: "gogoproto.sizer_all",
      Tag: "varint,63020,opt,name=sizer_all",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoEnumStringerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63021,
      Name: "gogoproto.goproto_enum_stringer_all",
      Tag: "varint,63021,opt,name=goproto_enum_stringer_all",
      Filename: "base/gogo.proto",
      }
      var E_EnumStringerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63022,
      Name: "gogoproto.enum_stringer_all",
      Tag: "varint,63022,opt,name=enum_stringer_all",
      Filename: "base/gogo.proto",
      }
      var E_UnsafeMarshalerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63023,
      Name: "gogoproto.unsafe_marshaler_all",
      Tag: "varint,63023,opt,name=unsafe_marshaler_all",
      Filename: "base/gogo.proto",
      }
      var E_UnsafeUnmarshalerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63024,
      Name: "gogoproto.unsafe_unmarshaler_all",
      Tag: "varint,63024,opt,name=unsafe_unmarshaler_all",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoExtensionsMapAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63025,
      Name: "gogoproto.goproto_extensions_map_all",
      Tag: "varint,63025,opt,name=goproto_extensions_map_all",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoUnrecognizedAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63026,
      Name: "gogoproto.goproto_unrecognized_all",
      Tag: "varint,63026,opt,name=goproto_unrecognized_all",
      Filename: "base/gogo.proto",
      }
      var E_GogoprotoImport = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63027,
      Name: "gogoproto.gogoproto_import",
      Tag: "varint,63027,opt,name=gogoproto_import",
      Filename: "base/gogo.proto",
      }
      var E_ProtosizerAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63028,
      Name: "gogoproto.protosizer_all",
      Tag: "varint,63028,opt,name=protosizer_all",
      Filename: "base/gogo.proto",
      }
      var E_CompareAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63029,
      Name: "gogoproto.compare_all",
      Tag: "varint,63029,opt,name=compare_all",
      Filename: "base/gogo.proto",
      }
      var E_TypedeclAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63030,
      Name: "gogoproto.typedecl_all",
      Tag: "varint,63030,opt,name=typedecl_all",
      Filename: "base/gogo.proto",
      }
      var E_EnumdeclAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63031,
      Name: "gogoproto.enumdecl_all",
      Tag: "varint,63031,opt,name=enumdecl_all",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoRegistration = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63032,
      Name: "gogoproto.goproto_registration",
      Tag: "varint,63032,opt,name=goproto_registration",
      Filename: "base/gogo.proto",
      }
      var E_MessagenameAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63033,
      Name: "gogoproto.messagename_all",
      Tag: "varint,63033,opt,name=messagename_all",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoSizecacheAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63034,
      Name: "gogoproto.goproto_sizecache_all",
      Tag: "varint,63034,opt,name=goproto_sizecache_all",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoUnkeyedAll = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FileOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 63035,
      Name: "gogoproto.goproto_unkeyed_all",
      Tag: "varint,63035,opt,name=goproto_unkeyed_all",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoGetters = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64001,
      Name: "gogoproto.goproto_getters",
      Tag: "varint,64001,opt,name=goproto_getters",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoStringer = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64003,
      Name: "gogoproto.goproto_stringer",
      Tag: "varint,64003,opt,name=goproto_stringer",
      Filename: "base/gogo.proto",
      }
      var E_VerboseEqual = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64004,
      Name: "gogoproto.verbose_equal",
      Tag: "varint,64004,opt,name=verbose_equal",
      Filename: "base/gogo.proto",
      }
      var E_Face = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64005,
      Name: "gogoproto.face",
      Tag: "varint,64005,opt,name=face",
      Filename: "base/gogo.proto",
      }
      var E_Gostring = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64006,
      Name: "gogoproto.gostring",
      Tag: "varint,64006,opt,name=gostring",
      Filename: "base/gogo.proto",
      }
      var E_Populate = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64007,
      Name: "gogoproto.populate",
      Tag: "varint,64007,opt,name=populate",
      Filename: "base/gogo.proto",
      }
      var E_Stringer = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 67008,
      Name: "gogoproto.stringer",
      Tag: "varint,67008,opt,name=stringer",
      Filename: "base/gogo.proto",
      }
      var E_Onlyone = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64009,
      Name: "gogoproto.onlyone",
      Tag: "varint,64009,opt,name=onlyone",
      Filename: "base/gogo.proto",
      }
      var E_Equal = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64013,
      Name: "gogoproto.equal",
      Tag: "varint,64013,opt,name=equal",
      Filename: "base/gogo.proto",
      }
      var E_Description = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64014,
      Name: "gogoproto.description",
      Tag: "varint,64014,opt,name=description",
      Filename: "base/gogo.proto",
      }
      var E_Testgen = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64015,
      Name: "gogoproto.testgen",
      Tag: "varint,64015,opt,name=testgen",
      Filename: "base/gogo.proto",
      }
      var E_Benchgen = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64016,
      Name: "gogoproto.benchgen",
      Tag: "varint,64016,opt,name=benchgen",
      Filename: "base/gogo.proto",
      }
      var E_Marshaler = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64017,
      Name: "gogoproto.marshaler",
      Tag: "varint,64017,opt,name=marshaler",
      Filename: "base/gogo.proto",
      }
      var E_Unmarshaler = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64018,
      Name: "gogoproto.unmarshaler",
      Tag: "varint,64018,opt,name=unmarshaler",
      Filename: "base/gogo.proto",
      }
      var E_StableMarshaler = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64019,
      Name: "gogoproto.stable_marshaler",
      Tag: "varint,64019,opt,name=stable_marshaler",
      Filename: "base/gogo.proto",
      }
      var E_Sizer = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64020,
      Name: "gogoproto.sizer",
      Tag: "varint,64020,opt,name=sizer",
      Filename: "base/gogo.proto",
      }
      var E_UnsafeMarshaler = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64023,
      Name: "gogoproto.unsafe_marshaler",
      Tag: "varint,64023,opt,name=unsafe_marshaler",
      Filename: "base/gogo.proto",
      }
      var E_UnsafeUnmarshaler = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64024,
      Name: "gogoproto.unsafe_unmarshaler",
      Tag: "varint,64024,opt,name=unsafe_unmarshaler",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoExtensionsMap = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64025,
      Name: "gogoproto.goproto_extensions_map",
      Tag: "varint,64025,opt,name=goproto_extensions_map",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoUnrecognized = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64026,
      Name: "gogoproto.goproto_unrecognized",
      Tag: "varint,64026,opt,name=goproto_unrecognized",
      Filename: "base/gogo.proto",
      }
      var E_Protosizer = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64028,
      Name: "gogoproto.protosizer",
      Tag: "varint,64028,opt,name=protosizer",
      Filename: "base/gogo.proto",
      }
      var E_Compare = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64029,
      Name: "gogoproto.compare",
      Tag: "varint,64029,opt,name=compare",
      Filename: "base/gogo.proto",
      }
      var E_Typedecl = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64030,
      Name: "gogoproto.typedecl",
      Tag: "varint,64030,opt,name=typedecl",
      Filename: "base/gogo.proto",
      }
      var E_Messagename = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64033,
      Name: "gogoproto.messagename",
      Tag: "varint,64033,opt,name=messagename",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoSizecache = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64034,
      Name: "gogoproto.goproto_sizecache",
      Tag: "varint,64034,opt,name=goproto_sizecache",
      Filename: "base/gogo.proto",
      }
      var E_GoprotoUnkeyed = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.MessageOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 64035,
      Name: "gogoproto.goproto_unkeyed",
      Tag: "varint,64035,opt,name=goproto_unkeyed",
      Filename: "base/gogo.proto",
      }
      var E_Nullable = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 65001,
      Name: "gogoproto.nullable",
      Tag: "varint,65001,opt,name=nullable",
      Filename: "base/gogo.proto",
      }
      var E_Embed = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 65002,
      Name: "gogoproto.embed",
      Tag: "varint,65002,opt,name=embed",
      Filename: "base/gogo.proto",
      }
      var E_Customtype = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*string)(nil),
      Field: 65003,
      Name: "gogoproto.customtype",
      Tag: "bytes,65003,opt,name=customtype",
      Filename: "base/gogo.proto",
      }
      var E_Customname = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*string)(nil),
      Field: 65004,
      Name: "gogoproto.customname",
      Tag: "bytes,65004,opt,name=customname",
      Filename: "base/gogo.proto",
      }
      var E_Jsontag = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*string)(nil),
      Field: 65005,
      Name: "gogoproto.jsontag",
      Tag: "bytes,65005,opt,name=jsontag",
      Filename: "base/gogo.proto",
      }
      var E_Moretags = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*string)(nil),
      Field: 65006,
      Name: "gogoproto.moretags",
      Tag: "bytes,65006,opt,name=moretags",
      Filename: "base/gogo.proto",
      }
      var E_Casttype = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*string)(nil),
      Field: 65007,
      Name: "gogoproto.casttype",
      Tag: "bytes,65007,opt,name=casttype",
      Filename: "base/gogo.proto",
      }
      var E_Castkey = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*string)(nil),
      Field: 65008,
      Name: "gogoproto.castkey",
      Tag: "bytes,65008,opt,name=castkey",
      Filename: "base/gogo.proto",
      }
      var E_Castvalue = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*string)(nil),
      Field: 65009,
      Name: "gogoproto.castvalue",
      Tag: "bytes,65009,opt,name=castvalue",
      Filename: "base/gogo.proto",
      }
      var E_Stdtime = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 65010,
      Name: "gogoproto.stdtime",
      Tag: "varint,65010,opt,name=stdtime",
      Filename: "base/gogo.proto",
      }
      var E_Stdduration = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 65011,
      Name: "gogoproto.stdduration",
      Tag: "varint,65011,opt,name=stdduration",
      Filename: "base/gogo.proto",
      }
      var E_Wktpointer = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*bool)(nil),
      Field: 65012,
      Name: "gogoproto.wktpointer",
      Tag: "varint,65012,opt,name=wktpointer",
      Filename: "base/gogo.proto",
      }
      func init() {
      proto.RegisterExtension(E_GoprotoEnumPrefix)
      proto.RegisterExtension(E_GoprotoEnumStringer)
      proto.RegisterExtension(E_EnumStringer)
      proto.RegisterExtension(E_EnumCustomname)
      proto.RegisterExtension(E_Enumdecl)
      proto.RegisterExtension(E_EnumvalueCustomname)
      proto.RegisterExtension(E_GoprotoGettersAll)
      proto.RegisterExtension(E_GoprotoEnumPrefixAll)
      proto.RegisterExtension(E_GoprotoStringerAll)
      proto.RegisterExtension(E_VerboseEqualAll)
      proto.RegisterExtension(E_FaceAll)
      proto.RegisterExtension(E_GostringAll)
      proto.RegisterExtension(E_PopulateAll)
      proto.RegisterExtension(E_StringerAll)
      proto.RegisterExtension(E_OnlyoneAll)
      proto.RegisterExtension(E_EqualAll)
      proto.RegisterExtension(E_DescriptionAll)
      proto.RegisterExtension(E_TestgenAll)
      proto.RegisterExtension(E_BenchgenAll)
      proto.RegisterExtension(E_MarshalerAll)
      proto.RegisterExtension(E_UnmarshalerAll)
      proto.RegisterExtension(E_StableMarshalerAll)
      proto.RegisterExtension(E_SizerAll)
      proto.RegisterExtension(E_GoprotoEnumStringerAll)
      proto.RegisterExtension(E_EnumStringerAll)
      proto.RegisterExtension(E_UnsafeMarshalerAll)
      proto.RegisterExtension(E_UnsafeUnmarshalerAll)
      proto.RegisterExtension(E_GoprotoExtensionsMapAll)
      proto.RegisterExtension(E_GoprotoUnrecognizedAll)
      proto.RegisterExtension(E_GogoprotoImport)
      proto.RegisterExtension(E_ProtosizerAll)
      proto.RegisterExtension(E_CompareAll)
      proto.RegisterExtension(E_TypedeclAll)
      proto.RegisterExtension(E_EnumdeclAll)
      proto.RegisterExtension(E_GoprotoRegistration)
      proto.RegisterExtension(E_MessagenameAll)
      proto.RegisterExtension(E_GoprotoSizecacheAll)
      proto.RegisterExtension(E_GoprotoUnkeyedAll)
      proto.RegisterExtension(E_GoprotoGetters)
      proto.RegisterExtension(E_GoprotoStringer)
      proto.RegisterExtension(E_VerboseEqual)
      proto.RegisterExtension(E_Face)
      proto.RegisterExtension(E_Gostring)
      proto.RegisterExtension(E_Populate)
      proto.RegisterExtension(E_Stringer)
      proto.RegisterExtension(E_Onlyone)
      proto.RegisterExtension(E_Equal)
      proto.RegisterExtension(E_Description)
      proto.RegisterExtension(E_Testgen)
      proto.RegisterExtension(E_Benchgen)
      proto.RegisterExtension(E_Marshaler)
      proto.RegisterExtension(E_Unmarshaler)
      proto.RegisterExtension(E_StableMarshaler)
      proto.RegisterExtension(E_Sizer)
      proto.RegisterExtension(E_UnsafeMarshaler)
      proto.RegisterExtension(E_UnsafeUnmarshaler)
      proto.RegisterExtension(E_GoprotoExtensionsMap)
      proto.RegisterExtension(E_GoprotoUnrecognized)
      proto.RegisterExtension(E_Protosizer)
      proto.RegisterExtension(E_Compare)
      proto.RegisterExtension(E_Typedecl)
      proto.RegisterExtension(E_Messagename)
      proto.RegisterExtension(E_GoprotoSizecache)
      proto.RegisterExtension(E_GoprotoUnkeyed)
      proto.RegisterExtension(E_Nullable)
      proto.RegisterExtension(E_Embed)
      proto.RegisterExtension(E_Customtype)
      proto.RegisterExtension(E_Customname)
      proto.RegisterExtension(E_Jsontag)
      proto.RegisterExtension(E_Moretags)
      proto.RegisterExtension(E_Casttype)
      proto.RegisterExtension(E_Castkey)
      proto.RegisterExtension(E_Castvalue)
      proto.RegisterExtension(E_Stdtime)
      proto.RegisterExtension(E_Stdduration)
      proto.RegisterExtension(E_Wktpointer)
      }
      func init() { proto.RegisterFile("base/gogo.proto", fileDescriptor_187e1c6763207a24) }
      var fileDescriptor_187e1c6763207a24 = []byte{
      // 1400 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x98, 0xc9, 0x6f, 0x1c, 0x45,
      0x17, 0xc0, 0x95, 0x4d, 0xf1, 0x94, 0xed, 0x38, 0x76, 0x96, 0x2f, 0x5f, 0xf4, 0x7d, 0x22, 0xdc,
      0x38, 0x79, 0x4e, 0x11, 0x4a, 0x5b, 0x51, 0xe4, 0x58, 0x8e, 0x15, 0x84, 0xc3, 0xe0, 0xc4, 0x21,
      0x2c, 0xd2, 0xa8, 0xa6, 0xa7, 0xdc, 0x6e, 0xd2, 0xdd, 0x35, 0x74, 0x55, 0x87, 0x38, 0x37, 0x14,
      0x16, 0x21, 0xc4, 0x8e, 0x04, 0x09, 0x49, 0x20, 0x89, 0xd8, 0xc2, 0x1a, 0xf6, 0xe5, 0xc2, 0x85,
      0x45, 0xdc, 0xf8, 0x17, 0x10, 0x17, 0x82, 0xd9, 0x7d, 0xf3, 0x05, 0xbd, 0xee, 0xf7, 0x7a, 0x6a,
      0xc6, 0x23, 0x55, 0xcd, 0xad, 0x67, 0x5c, 0xbf, 0x9f, 0xab, 0xdf, 0xeb, 0x7a, 0xef, 0x4d, 0xb3,
      0x91, 0x06, 0x57, 0xa2, 0x1a, 0xc8, 0x40, 0x8e, 0xb7, 0x52, 0xa9, 0xe5, 0x58, 0x05, 0xae, 0xf3,
      0xcb, 0xdd, 0x7b, 0x02, 0x29, 0x83, 0x48, 0x54, 0xf3, 0x4f, 0x8d, 0x6c, 0xa1, 0xda, 0x14, 0xca,
      0x4f, 0xc3, 0x96, 0x96, 0x69, 0xb1, 0xd8, 0x3b, 0xc2, 0xb6, 0xe1, 0xe2, 0xba, 0x48, 0xb2, 0xb8,
      0xde, 0x4a, 0xc5, 0x42, 0x78, 0x7a, 0xec, 0x7f, 0xe3, 0x05, 0x39, 0x4e, 0xe4, 0xf8, 0x74, 0x92,
      0xc5, 0x77, 0xb4, 0x74, 0x28, 0x13, 0xb5, 0xeb, 0xfa, 0xcf, 0x1b, 0xf6, 0xac, 0xbb, 0x65, 0x60,
      0x6e, 0x14, 0x51, 0xf8, 0x5b, 0x2d, 0x07, 0xbd, 0x39, 0xb6, 0xa3, 0xc3, 0xa7, 0x74, 0x1a, 0x26,
      0x81, 0x48, 0x2d, 0xc6, 0x6f, 0xd0, 0xb8, 0xcd, 0x30, 0x1e, 0x45, 0xd4, 0x9b, 0x62, 0xc3, 0xfd,
      0xb8, 0xbe, 0x45, 0xd7, 0x90, 0x30, 0x25, 0x33, 0x6c, 0x24, 0x97, 0xf8, 0x99, 0xd2, 0x32, 0x4e,
      0x78, 0x2c, 0x2c, 0x9a, 0xef, 0x72, 0x4d, 0x65, 0x6e, 0x0b, 0x60, 0x53, 0x25, 0xe5, 0x79, 0x6c,
      0x00, 0xbe, 0x69, 0x0a, 0x3f, 0xb2, 0x18, 0xbe, 0xc7, 0x8d, 0x94, 0xeb, 0xbd, 0xe3, 0x6c, 0x3b,
      0x5c, 0x9f, 0xe2, 0x51, 0x26, 0xcc, 0x9d, 0xdc, 0xdc, 0xd3, 0x73, 0x1c, 0x96, 0x91, 0xec, 0xc7,
      0xb3, 0x1b, 0xf3, 0xed, 0x6c, 0x2b, 0x05, 0xc6, 0x9e, 0x8c, 0x2c, 0x06, 0x42, 0x6b, 0x91, 0xaa,
      0x3a, 0x8f, 0x7a, 0x6d, 0xef, 0x50, 0x18, 0x95, 0xc6, 0x73, 0xcb, 0x9d, 0x59, 0x9c, 0x29, 0xc8,
      0xc9, 0x28, 0xf2, 0xe6, 0xd9, 0x7f, 0x7a, 0x3c, 0x15, 0x0e, 0xce, 0xf3, 0xe8, 0xdc, 0xbe, 0xe6,
      0xc9, 0x00, 0x6d, 0x8d, 0xd1, 0xf7, 0x65, 0x2e, 0x1d, 0x9c, 0x2f, 0xa3, 0x73, 0x0c, 0x59, 0x4a,
      0x29, 0x18, 0x6f, 0x63, 0xa3, 0xa7, 0x44, 0xda, 0x90, 0x4a, 0xd4, 0xc5, 0x03, 0x19, 0x8f, 0x1c,
      0x74, 0x17, 0x50, 0x37, 0x82, 0xe0, 0x34, 0x70, 0xe0, 0xda, 0xc7, 0x06, 0x16, 0xb8, 0x2f, 0x1c,
      0x14, 0x17, 0x51, 0xb1, 0x19, 0xd6, 0x03, 0x3a, 0xc9, 0x86, 0x02, 0x59, 0xdc, 0x92, 0x03, 0x7e,
      0x09, 0xf1, 0x41, 0x62, 0x50, 0xd1, 0x92, 0xad, 0x2c, 0xe2, 0xda, 0x65, 0x07, 0xaf, 0x90, 0x82,
      0x18, 0x54, 0xf4, 0x11, 0xd6, 0x57, 0x49, 0xa1, 0x8c, 0x78, 0x1e, 0x60, 0x83, 0x32, 0x89, 0x96,
      0x64, 0xe2, 0xb2, 0x89, 0xcb, 0x68, 0x60, 0x88, 0x80, 0x60, 0x82, 0x55, 0x5c, 0x13, 0xf1, 0xda,
      0x32, 0x1d, 0x0f, 0xca, 0xc0, 0x0c, 0x1b, 0xa1, 0x02, 0x15, 0xca, 0xc4, 0x41, 0xf1, 0x3a, 0x2a,
      0xb6, 0x18, 0x18, 0xde, 0x86, 0x16, 0x4a, 0x07, 0xc2, 0x45, 0xf2, 0x06, 0xdd, 0x06, 0x22, 0x18,
      0xca, 0x86, 0x48, 0xfc, 0x45, 0x37, 0xc3, 0x9b, 0x14, 0x4a, 0x62, 0x40, 0x31, 0xc5, 0x86, 0x63,
      0x9e, 0xaa, 0x45, 0x1e, 0x39, 0xa5, 0xe3, 0x2d, 0x74, 0x0c, 0x95, 0x10, 0x46, 0x24, 0x4b, 0xfa,
      0xd1, 0x5c, 0xa3, 0x88, 0x18, 0x18, 0x1e, 0x3d, 0xa5, 0x79, 0x23, 0x12, 0xf5, 0x7e, 0x6c, 0x6f,
      0xd3, 0xd1, 0x2b, 0xd8, 0x59, 0xd3, 0x38, 0xc1, 0x2a, 0x2a, 0x3c, 0xe3, 0xa4, 0x79, 0x87, 0x32,
      0x9d, 0x03, 0x00, 0xdf, 0xcd, 0xfe, 0xdb, 0xb3, 0x4d, 0x38, 0xc8, 0xde, 0x45, 0xd9, 0xce, 0x1e,
      0xad, 0x02, 0x4b, 0x42, 0xbf, 0xca, 0xf7, 0xa8, 0x24, 0x88, 0x2e, 0x57, 0x8d, 0x6d, 0xcf, 0x12,
      0xc5, 0x17, 0xfa, 0x8b, 0xda, 0xfb, 0x14, 0xb5, 0x82, 0xed, 0x88, 0xda, 0x31, 0xb6, 0x13, 0x8d,
      0xfd, 0xe5, 0xf5, 0x03, 0x2a, 0xac, 0x05, 0x3d, 0xdf, 0x99, 0xdd, 0x7b, 0xd9, 0xee, 0x32, 0x9c,
      0xa7, 0xb5, 0x48, 0x14, 0x30, 0xf5, 0x98, 0xb7, 0x1c, 0xcc, 0xd7, 0xd1, 0x4c, 0x15, 0x7f, 0xba,
      0x14, 0xcc, 0xf2, 0x16, 0xc8, 0x4f, 0xb0, 0x5d, 0x24, 0xcf, 0x92, 0x54, 0xf8, 0x32, 0x48, 0xc2,
      0x33, 0xa2, 0xe9, 0xa0, 0xfe, 0xb0, 0x2b, 0x55, 0xf3, 0x06, 0x0e, 0xe6, 0xc3, 0x6c, 0x6b, 0x39,
      0xab, 0xd4, 0xc3, 0xb8, 0x25, 0x53, 0x6d, 0x31, 0x7e, 0x44, 0x99, 0x2a, 0xb9, 0xc3, 0x39, 0xe6,
      0x4d, 0xb3, 0x2d, 0xf9, 0x47, 0xd7, 0x47, 0xf2, 0x63, 0x14, 0x0d, 0xb7, 0x29, 0x2c, 0x1c, 0xbe,
      0x8c, 0x5b, 0x3c, 0x75, 0xa9, 0x7f, 0x9f, 0x50, 0xe1, 0x40, 0x04, 0x0b, 0x87, 0x5e, 0x6a, 0x09,
      0xe8, 0xf6, 0x0e, 0x86, 0x4f, 0xa9, 0x70, 0x10, 0x83, 0x0a, 0x1a, 0x18, 0x1c, 0x14, 0x9f, 0x91,
      0x82, 0x18, 0x50, 0xdc, 0xd9, 0x6e, 0xb4, 0xa9, 0x08, 0x42, 0xa5, 0x53, 0x0e, 0xab, 0x2d, 0xaa,
      0xcf, 0x97, 0x3b, 0x87, 0xb0, 0x39, 0x03, 0x85, 0x4a, 0x14, 0x0b, 0xa5, 0x78, 0x20, 0x60, 0xe2,
      0x70, 0xd8, 0xd8, 0x17, 0x54, 0x89, 0x0c, 0x0c, 0xf6, 0x66, 0x4c, 0x88, 0x10, 0x76, 0x9f, 0xfb,
      0x8b, 0x2e, 0xba, 0x2f, 0xbb, 0x36, 0x77, 0x94, 0x58, 0x70, 0x1a, 0xf3, 0x4f, 0x96, 0x9c, 0x14,
      0x4b, 0x4e, 0x4f, 0xe7, 0x57, 0x5d, 0xf3, 0xcf, 0x7c, 0x41, 0x16, 0x35, 0x64, 0xa4, 0x6b, 0x9e,
      0x1a, 0xbb, 0x69, 0x8d, 0x6b, 0xb6, 0xb8, 0x2f, 0xd2, 0x3d, 0xb4, 0x82, 0xf7, 0xdb, 0x39, 0x4e,
      0x79, 0xb7, 0xc3, 0x43, 0xde, 0x39, 0xf4, 0xd8, 0x65, 0x67, 0x57, 0xca, 0xe7, 0xbc, 0x63, 0xe6,
      0xf1, 0x0e, 0xb1, 0xe1, 0x8e, 0x81, 0xc7, 0xae, 0x7a, 0x18, 0x55, 0x43, 0xe6, 0xbc, 0xe3, 0xed,
      0x65, 0x1b, 0x61, 0x78, 0xb1, 0xe3, 0x8f, 0x20, 0x9e, 0x2f, 0xf7, 0xf6, 0xb3, 0x01, 0x1a, 0x5a,
      0xec, 0xe8, 0xa3, 0x88, 0x96, 0x08, 0xe0, 0x34, 0xb0, 0xd8, 0xf1, 0xc7, 0x08, 0x27, 0x04, 0x70,
      0xf7, 0x10, 0x7e, 0xfd, 0xc4, 0x46, 0x6c, 0x3a, 0x14, 0xbb, 0x09, 0xb6, 0x19, 0x27, 0x15, 0x3b,
      0xfd, 0x38, 0xfe, 0x73, 0x22, 0xbc, 0x5b, 0xd9, 0x26, 0xc7, 0x80, 0x3f, 0x89, 0x68, 0xb1, 0xde,
      0x9b, 0x62, 0x83, 0xc6, 0x74, 0x62, 0xc7, 0x9f, 0x42, 0xdc, 0xa4, 0x60, 0xeb, 0x38, 0x9d, 0xd8,
      0x05, 0x4f, 0xd3, 0xd6, 0x91, 0x80, 0xb0, 0xd1, 0x60, 0x62, 0xa7, 0x9f, 0xa1, 0xa8, 0x13, 0xe2,
      0x1d, 0x60, 0x95, 0xb2, 0xd9, 0xd8, 0xf9, 0x67, 0x91, 0x6f, 0x33, 0x10, 0x01, 0xa3, 0xd9, 0xd9,
      0x15, 0xcf, 0x51, 0x04, 0x0c, 0x0a, 0x8e, 0x51, 0xf7, 0x00, 0x63, 0x37, 0x3d, 0x4f, 0xc7, 0xa8,
      0x6b, 0x7e, 0x81, 0x6c, 0xe6, 0x35, 0xdf, 0xae, 0x78, 0x81, 0xb2, 0x99, 0xaf, 0x87, 0x6d, 0x74,
      0x4f, 0x04, 0x76, 0xc7, 0x8b, 0xb4, 0x8d, 0xae, 0x81, 0xc0, 0xab, 0xb1, 0xb1, 0xb5, 0xd3, 0x80,
      0xdd, 0xf7, 0x12, 0xfa, 0x46, 0xd7, 0x0c, 0x03, 0xde, 0x5d, 0x6c, 0x67, 0xef, 0x49, 0xc0, 0x6e,
      0x3d, 0xb7, 0xd2, 0xf5, 0xdb, 0xcd, 0x1c, 0x04, 0xbc, 0x63, 0xed, 0x96, 0x62, 0x4e, 0x01, 0x76,
      0xed, 0xf9, 0x95, 0xce, 0xc2, 0x6d, 0x0e, 0x01, 0xde, 0x24, 0x63, 0xed, 0x06, 0x6c, 0x77, 0x5d,
      0x40, 0x97, 0x01, 0xc1, 0xd1, 0xc0, 0xfe, 0x6b, 0xe7, 0x2f, 0xd2, 0xd1, 0x40, 0x02, 0x8e, 0x06,
      0xb5, 0x5e, 0x3b, 0x7d, 0x89, 0x8e, 0x06, 0x21, 0xf0, 0x64, 0x1b, 0xdd, 0xcd, 0x6e, 0xb8, 0x4c,
      0x4f, 0xb6, 0x41, 0x79, 0x47, 0xd8, 0xe8, 0x9a, 0x86, 0x68, 0x57, 0x5d, 0x41, 0xd5, 0xd6, 0xee,
      0x7e, 0x68, 0x36, 0x2f, 0x6c, 0x86, 0x76, 0xdb, 0xd5, 0xae, 0xe6, 0x85, 0xbd, 0xd0, 0x9b, 0x60,
      0x03, 0x49, 0x16, 0x45, 0x70, 0x78, 0xc6, 0xfe, 0xdf, 0xa3, 0x9b, 0x8a, 0xa8, 0x49, 0x8a, 0x5f,
      0x56, 0x31, 0x3a, 0x04, 0x78, 0x7b, 0xd9, 0x26, 0x11, 0x37, 0x44, 0xd3, 0x46, 0xde, 0x58, 0xa5,
      0x82, 0x09, 0xab, 0xbd, 0x03, 0x8c, 0x15, 0xaf, 0x46, 0x20, 0xcc, 0x36, 0xf6, 0xd7, 0xd5, 0xe2,
      0x2d, 0x8d, 0x81, 0xb4, 0x05, 0x79, 0x52, 0x2c, 0x82, 0xe5, 0x4e, 0x41, 0x9e, 0x91, 0x7d, 0x6c,
      0xf3, 0xfd, 0x4a, 0x26, 0x9a, 0x07, 0x36, 0xfa, 0x37, 0xa4, 0x69, 0x3d, 0x04, 0x2c, 0x96, 0xa9,
      0xd0, 0x3c, 0x50, 0x36, 0xf6, 0x77, 0x64, 0x4b, 0x00, 0x60, 0x9f, 0x2b, 0xed, 0x72, 0xdf, 0x7f,
      0x10, 0x4c, 0x00, 0x6c, 0x1a, 0xae, 0x4f, 0x8a, 0x25, 0x1b, 0xfb, 0x27, 0x6d, 0x1a, 0xd7, 0x7b,
      0xfb, 0x59, 0x05, 0x2e, 0xf3, 0xb7, 0x4a, 0x36, 0xf8, 0x2f, 0x84, 0xdb, 0x04, 0xfc, 0x67, 0xa5,
      0x9b, 0x3a, 0xb4, 0x07, 0xfb, 0x6f, 0xcc, 0x34, 0xad, 0xf7, 0x26, 0xd9, 0xa0, 0xd2, 0xcd, 0x66,
      0x86, 0xf3, 0xa9, 0x05, 0xff, 0x67, 0xb5, 0x7c, 0x65, 0x51, 0x32, 0x90, 0xed, 0x07, 0x4f, 0xea,
      0x96, 0x0c, 0x13, 0x2d, 0x52, 0x9b, 0x61, 0x05, 0x0d, 0x06, 0x72, 0xf0, 0xea, 0x3a, 0x36, 0xec,
      0xcb, 0x78, 0xbc, 0xfc, 0x49, 0x71, 0xb0, 0x32, 0x23, 0x03, 0x59, 0x83, 0xcb, 0xda, 0xba, 0x7b,
      0xa6, 0x82, 0x50, 0x2f, 0x66, 0x8d, 0x71, 0x5f, 0xc6, 0xd5, 0x29, 0xde, 0xcc, 0x7c, 0x91, 0xa9,
      0x59, 0xa1, 0xf9, 0x29, 0x91, 0x2a, 0x91, 0x2f, 0xf2, 0x65, 0x54, 0x85, 0x6f, 0xca, 0x0f, 0x81,
      0x48, 0x8a, 0x57, 0xae, 0xd5, 0x40, 0x56, 0x1b, 0x5c, 0x89, 0x2b, 0xeb, 0x37, 0xcc, 0x9c, 0x38,
      0x71, 0x6d, 0x7d, 0x2e, 0xce, 0xff, 0xf2, 0x83, 0x71, 0xfd, 0xd3, 0xfa, 0x1d, 0xe5, 0xf5, 0x7d,
      0x33, 0xb5, 0x83, 0xe0, 0x6a, 0x72, 0xcd, 0x6f, 0x18, 0x6b, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff,
      0xdf, 0x62, 0x8f, 0x52, 0xe7, 0x15, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/base/v1/batchtx.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: base/v1/batchtx.proto
      package basev1
      import (
      fmt "fmt"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base"
      github_com_CaduceusMetaverseProtocol_MetaTypes_types "github.com/CaduceusMetaverseProtocol/MetaTypes/types"
      proto "github.com/gogo/protobuf/proto"
      _ "github.com/gogo/protobuf/types"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      // BatchTx include one batchHash and all original tx contained in batch.
      // it will broadcast to nebula over p2p module, and then save in p2p module.
      // Amount metaprooftx make a batch tx, and generate a batch_hash,
      type BatchTx struct {
      BatchHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,1,opt,name=batch_hash,json=batchHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"batch_hash,omitempty"`
      Txs []*MetaProofTx `protobuf:"bytes,2,rep,name=txs,proto3" json:"txs,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchTx) Reset() { *m = BatchTx{} }
      func (m *BatchTx) String() string { return proto.CompactTextString(m) }
      func (*BatchTx) ProtoMessage() {}
      func (*BatchTx) Descriptor() ([]byte, []int) {
      return fileDescriptor_c9fefc07327b2629, []int{0}
      }
      func (m *BatchTx) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchTx.Unmarshal(m, b)
      }
      func (m *BatchTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchTx.Marshal(b, m, deterministic)
      }
      func (m *BatchTx) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchTx.Merge(m, src)
      }
      func (m *BatchTx) XXX_Size() int {
      return xxx_messageInfo_BatchTx.Size(m)
      }
      func (m *BatchTx) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchTx.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchTx proto.InternalMessageInfo
      func (m *BatchTx) GetTxs() []*MetaProofTx {
      if m != nil {
      return m.Txs
      }
      return nil
      }
      func init() {
      proto.RegisterType((*BatchTx)(nil), "base.v1.BatchTx")
      }
      func init() { proto.RegisterFile("base/v1/batchtx.proto", fileDescriptor_c9fefc07327b2629) }
      var fileDescriptor_c9fefc07327b2629 = []byte{
      // 336 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x90, 0x4f, 0x4b, 0xf3, 0x40,
      0x10, 0xc6, 0x49, 0x0a, 0x6f, 0x5f, 0x53, 0x45, 0x88, 0x7f, 0xa8, 0xbd, 0xb4, 0x78, 0x90, 0x9e,
      0xb2, 0xa4, 0x9e, 0xac, 0x78, 0x59, 0x0f, 0x7a, 0x29, 0x84, 0x52, 0x4a, 0x91, 0x82, 0x6c, 0xd2,
      0xe9, 0xa6, 0xd8, 0x74, 0x4a, 0x76, 0x13, 0xd2, 0x2f, 0xe3, 0xc1, 0x8b, 0xe0, 0x47, 0xf1, 0x23,
      0x78, 0xf0, 0xe0, 0xd1, 0x4f, 0x21, 0xb3, 0x49, 0x7b, 0xf0, 0xe4, 0x65, 0x77, 0xf6, 0xb7, 0xcf,
      0x3c, 0xf3, 0x30, 0xce, 0x49, 0x28, 0x14, 0xb0, 0xdc, 0x67, 0xa1, 0xd0, 0x51, 0xac, 0x0b, 0x6f,
      0x9d, 0xa2, 0x46, 0xb7, 0x4e, 0xd8, 0xcb, 0xfd, 0x56, 0x5b, 0x22, 0xca, 0x25, 0x30, 0x83, 0xc3,
      0x6c, 0xce, 0xf4, 0x22, 0x01, 0xa5, 0x45, 0xb2, 0x2e, 0x95, 0xad, 0xb3, 0xdf, 0x02, 0xb1, 0xda,
      0x54, 0x5f, 0xa7, 0x5b, 0xef, 0x14, 0x14, 0x66, 0x69, 0x04, 0x15, 0x77, 0xb7, 0x3c, 0x01, 0x2d,
      0x2a, 0x76, 0x68, 0x98, 0x44, 0x89, 0x25, 0x38, 0x7f, 0xb6, 0x9c, 0x3a, 0xa7, 0x4c, 0xa3, 0xc2,
      0x7d, 0x72, 0x1c, 0x13, 0xef, 0x31, 0x16, 0x2a, 0x6e, 0x5a, 0x1d, 0xab, 0xdb, 0xe8, 0x1d, 0x78,
      0x55, 0x44, 0xef, 0x5e, 0xa8, 0x98, 0xdf, 0x7c, 0x7c, 0xb6, 0xaf, 0xe4, 0x42, 0xc7, 0x59, 0xe8,
      0x45, 0x98, 0xb0, 0x5b, 0x31, 0xcb, 0x22, 0xc8, 0xd4, 0x00, 0xb4, 0xc8, 0x21, 0x55, 0x10, 0x90,
      0x6b, 0x84, 0x4b, 0x46, 0x64, 0xb4, 0x59, 0x83, 0x62, 0x9a, 0x4e, 0xd3, 0x3e, 0xdc, 0x33, 0xfe,
      0x54, 0xba, 0x17, 0x4e, 0x4d, 0x17, 0xaa, 0x69, 0x77, 0x6a, 0xdd, 0x46, 0xef, 0x78, 0x37, 0x85,
      0xda, 0x82, 0x14, 0x71, 0x3e, 0x2a, 0x86, 0x24, 0xe0, 0xaf, 0x96, 0xd3, 0x88, 0x30, 0xd9, 0x0a,
      0xf8, 0x3e, 0x2f, 0x37, 0x68, 0x06, 0x05, 0xd6, 0xc3, 0xe0, 0xcf, 0x69, 0x76, 0x0f, 0x09, 0xab,
      0x72, 0x8f, 0x4c, 0x22, 0xab, 0x96, 0x74, 0x4d, 0x77, 0xee, 0xbf, 0xd8, 0x35, 0x3e, 0x99, 0xbc,
      0xd9, 0x75, 0x4e, 0xe3, 0xc6, 0xfe, 0x7b, 0x59, 0x4d, 0xc7, 0xfe, 0x97, 0x7d, 0x54, 0x55, 0xd3,
      0xbb, 0x80, 0x93, 0xdf, 0x4c, 0x68, 0xf1, 0x6d, 0xff, 0x27, 0xda, 0xef, 0x8f, 0xfd, 0xf0, 0x9f,
      0xf1, 0xbc, 0xfc, 0x09, 0x00, 0x00, 0xff, 0xff, 0xec, 0xa0, 0x70, 0x96, 0xec, 0x01, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/base/v1/eth_blocks.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: base/v1/eth_blocks.proto
      package basev1
      import (
      fmt "fmt"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base"
      github_com_CaduceusMetaverseProtocol_MetaTypes_types "github.com/CaduceusMetaverseProtocol/MetaTypes/types"
      proto "github.com/gogo/protobuf/proto"
      _ "github.com/gogo/protobuf/types"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type EthBlockHeader struct {
      ParentHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"parent_hash,omitempty"`
      UncleHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,2,opt,name=uncle_hash,json=uncleHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"uncle_hash,omitempty"`
      BlockHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,3,opt,name=block_hash,json=blockHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"block_hash,omitempty"`
      Miner *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,4,opt,name=miner,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"miner,omitempty"`
      StateRoot *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,5,opt,name=state_root,json=stateRoot,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"state_root,omitempty"`
      TxsRoot *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,6,opt,name=txs_root,json=txsRoot,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"txs_root,omitempty"`
      ReceiptsRoot *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,7,opt,name=receipts_root,json=receiptsRoot,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"receipts_root,omitempty"`
      BlockNumber *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,8,opt,name=block_number,json=blockNumber,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"block_number,omitempty"`
      BlockBloom *Bloom `protobuf:"bytes,9,opt,name=block_bloom,json=blockBloom,proto3" json:"block_bloom,omitempty"`
      Difficulty *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,10,opt,name=difficulty,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"difficulty,omitempty"`
      GasLimit uint64 `protobuf:"varint,11,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
      GasUsed uint64 `protobuf:"varint,12,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
      Timestamp uint64 `protobuf:"varint,13,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
      Extra []byte `protobuf:"bytes,14,opt,name=extra,proto3" json:"extra,omitempty"`
      MixHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,15,opt,name=mix_hash,json=mixHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"mix_hash,omitempty"`
      BlockNonce *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,16,opt,name=block_nonce,json=blockNonce,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"block_nonce,omitempty"`
      BaseFee *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,17,opt,name=base_fee,json=baseFee,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"base_fee,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthBlockHeader) Reset() { *m = EthBlockHeader{} }
      func (m *EthBlockHeader) String() string { return proto.CompactTextString(m) }
      func (*EthBlockHeader) ProtoMessage() {}
      func (*EthBlockHeader) Descriptor() ([]byte, []int) {
      return fileDescriptor_a7bd231ebd1789e6, []int{0}
      }
      func (m *EthBlockHeader) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthBlockHeader.Unmarshal(m, b)
      }
      func (m *EthBlockHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthBlockHeader.Marshal(b, m, deterministic)
      }
      func (m *EthBlockHeader) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthBlockHeader.Merge(m, src)
      }
      func (m *EthBlockHeader) XXX_Size() int {
      return xxx_messageInfo_EthBlockHeader.Size(m)
      }
      func (m *EthBlockHeader) XXX_DiscardUnknown() {
      xxx_messageInfo_EthBlockHeader.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthBlockHeader proto.InternalMessageInfo
      func (m *EthBlockHeader) GetBlockBloom() *Bloom {
      if m != nil {
      return m.BlockBloom
      }
      return nil
      }
      func (m *EthBlockHeader) GetGasLimit() uint64 {
      if m != nil {
      return m.GasLimit
      }
      return 0
      }
      func (m *EthBlockHeader) GetGasUsed() uint64 {
      if m != nil {
      return m.GasUsed
      }
      return 0
      }
      func (m *EthBlockHeader) GetTimestamp() uint64 {
      if m != nil {
      return m.Timestamp
      }
      return 0
      }
      func (m *EthBlockHeader) GetExtra() []byte {
      if m != nil {
      return m.Extra
      }
      return nil
      }
      type EthBlockBody struct {
      Txs []*EthTransaction `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
      Uncles []*EthBlockHeader `protobuf:"bytes,2,rep,name=uncles,proto3" json:"uncles,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthBlockBody) Reset() { *m = EthBlockBody{} }
      func (m *EthBlockBody) String() string { return proto.CompactTextString(m) }
      func (*EthBlockBody) ProtoMessage() {}
      func (*EthBlockBody) Descriptor() ([]byte, []int) {
      return fileDescriptor_a7bd231ebd1789e6, []int{1}
      }
      func (m *EthBlockBody) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthBlockBody.Unmarshal(m, b)
      }
      func (m *EthBlockBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthBlockBody.Marshal(b, m, deterministic)
      }
      func (m *EthBlockBody) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthBlockBody.Merge(m, src)
      }
      func (m *EthBlockBody) XXX_Size() int {
      return xxx_messageInfo_EthBlockBody.Size(m)
      }
      func (m *EthBlockBody) XXX_DiscardUnknown() {
      xxx_messageInfo_EthBlockBody.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthBlockBody proto.InternalMessageInfo
      func (m *EthBlockBody) GetTxs() []*EthTransaction {
      if m != nil {
      return m.Txs
      }
      return nil
      }
      func (m *EthBlockBody) GetUncles() []*EthBlockHeader {
      if m != nil {
      return m.Uncles
      }
      return nil
      }
      type EthBlock struct {
      Header *EthBlockHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      Uncles []*EthBlockHeader `protobuf:"bytes,2,rep,name=uncles,proto3" json:"uncles,omitempty"`
      Txs []*EthTransaction `protobuf:"bytes,3,rep,name=txs,proto3" json:"txs,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthBlock) Reset() { *m = EthBlock{} }
      func (m *EthBlock) String() string { return proto.CompactTextString(m) }
      func (*EthBlock) ProtoMessage() {}
      func (*EthBlock) Descriptor() ([]byte, []int) {
      return fileDescriptor_a7bd231ebd1789e6, []int{2}
      }
      func (m *EthBlock) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthBlock.Unmarshal(m, b)
      }
      func (m *EthBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthBlock.Marshal(b, m, deterministic)
      }
      func (m *EthBlock) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthBlock.Merge(m, src)
      }
      func (m *EthBlock) XXX_Size() int {
      return xxx_messageInfo_EthBlock.Size(m)
      }
      func (m *EthBlock) XXX_DiscardUnknown() {
      xxx_messageInfo_EthBlock.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthBlock proto.InternalMessageInfo
      func (m *EthBlock) GetHeader() *EthBlockHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *EthBlock) GetUncles() []*EthBlockHeader {
      if m != nil {
      return m.Uncles
      }
      return nil
      }
      func (m *EthBlock) GetTxs() []*EthTransaction {
      if m != nil {
      return m.Txs
      }
      return nil
      }
      func init() {
      proto.RegisterType((*EthBlockHeader)(nil), "base.v1.EthBlockHeader")
      proto.RegisterType((*EthBlockBody)(nil), "base.v1.EthBlockBody")
      proto.RegisterType((*EthBlock)(nil), "base.v1.EthBlock")
      }
      func init() { proto.RegisterFile("base/v1/eth_blocks.proto", fileDescriptor_a7bd231ebd1789e6) }
      var fileDescriptor_a7bd231ebd1789e6 = []byte{
      // 695 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x95, 0x4f, 0x6f, 0xd3, 0x30,
      0x18, 0xc6, 0x95, 0x76, 0x5b, 0x5b, 0xb7, 0xfb, 0x83, 0x99, 0xc0, 0x1b, 0x48, 0xad, 0x76, 0x2a,
      0x97, 0x46, 0x1d, 0x27, 0x36, 0x10, 0x10, 0x34, 0x18, 0x12, 0x43, 0x53, 0x34, 0xa6, 0x09, 0x4d,
      0xaa, 0xdc, 0xe4, 0x6d, 0x12, 0xd6, 0xc4, 0x9d, 0xed, 0x54, 0xe9, 0x27, 0xe1, 0xce, 0x0d, 0x3e,
      0x0a, 0xdf, 0x80, 0x1d, 0x76, 0xe0, 0xc8, 0xa7, 0x40, 0xb6, 0x93, 0x6e, 0x02, 0x21, 0x60, 0x52,
      0x2e, 0xed, 0xeb, 0xe7, 0x7d, 0xf3, 0xfc, 0x6c, 0xc7, 0xf1, 0x8b, 0xc8, 0x90, 0x0a, 0xb0, 0xa7,
      0x7d, 0x1b, 0x64, 0x38, 0x18, 0x8e, 0x99, 0x77, 0x26, 0x7a, 0x13, 0xce, 0x24, 0xc3, 0x35, 0x95,
      0xe9, 0x4d, 0xfb, 0x9b, 0xed, 0x80, 0xb1, 0x60, 0x0c, 0xb6, 0x96, 0x87, 0xe9, 0xc8, 0x96, 0x51,
      0x0c, 0x42, 0xd2, 0x78, 0x62, 0x2a, 0x37, 0x37, 0x7e, 0x2d, 0xa0, 0xc9, 0x2c, 0x4f, 0xdd, 0x29,
      0xec, 0x39, 0x08, 0x96, 0x72, 0x0f, 0x72, 0x7d, 0xfd, 0x3a, 0x56, 0x66, 0xb9, 0xba, 0xaa, 0xd5,
      0x80, 0x05, 0xcc, 0x08, 0x5b, 0xdf, 0x9a, 0x68, 0x65, 0x4f, 0x86, 0x8e, 0x9a, 0xd7, 0x3e, 0x50,
      0x1f, 0x38, 0x8e, 0x51, 0x73, 0x42, 0x39, 0x24, 0x72, 0x10, 0x52, 0x11, 0x12, 0xab, 0x63, 0x75,
      0x9b, 0xdb, 0xcb, 0xbd, 0x7c, 0xb2, 0xbd, 0x7d, 0x2a, 0x42, 0xe7, 0xc9, 0xc5, 0x65, 0xfb, 0x51,
      0x10, 0xc9, 0x30, 0x1d, 0xf6, 0x3c, 0x16, 0xdb, 0x2f, 0xa8, 0x9f, 0x7a, 0x90, 0x8a, 0x03, 0x90,
      0x74, 0x0a, 0x5c, 0xc0, 0xa1, 0x72, 0xf7, 0xd8, 0xd8, 0x56, 0xca, 0xd1, 0x6c, 0x02, 0xc2, 0x96,
      0xea, 0x57, 0x3f, 0xee, 0x22, 0x03, 0x50, 0x31, 0x3e, 0x43, 0x28, 0x4d, 0xbc, 0x31, 0x18, 0x5a,
      0xa5, 0x04, 0x5a, 0x43, 0xfb, 0x17, 0x30, 0xfd, 0x0a, 0x0c, 0xac, 0x5a, 0x06, 0x4c, 0xfb, 0x6b,
      0x58, 0x88, 0x16, 0xe3, 0x28, 0x01, 0x4e, 0x16, 0x34, 0x67, 0x6d, 0xce, 0x79, 0xee, 0xfb, 0x1c,
      0x84, 0x70, 0x9e, 0x5d, 0x5c, 0xb6, 0x1f, 0xdf, 0x08, 0x95, 0x3b, 0xb8, 0x06, 0xa0, 0x96, 0x25,
      0x24, 0x95, 0x30, 0xe0, 0x8c, 0x49, 0xb2, 0x58, 0xc6, 0xb2, 0xb4, 0xbf, 0xcb, 0x98, 0xc4, 0x01,
      0xaa, 0xcb, 0x4c, 0x18, 0xd4, 0x52, 0x09, 0xa8, 0x9a, 0xcc, 0x84, 0x06, 0x9d, 0xa3, 0x65, 0x0e,
      0x1e, 0x44, 0x13, 0x99, 0xd3, 0x6a, 0x25, 0xd0, 0x5a, 0x05, 0x42, 0x23, 0x05, 0x6a, 0x99, 0xf3,
      0x91, 0xa4, 0xf1, 0x10, 0x38, 0xa9, 0x6b, 0xe2, 0xea, 0x9c, 0xe8, 0x44, 0xc1, 0xeb, 0x44, 0x3a,
      0x4f, 0x2f, 0x2e, 0xdb, 0xbb, 0x37, 0x62, 0x1a, 0x03, 0xb7, 0xa9, 0x29, 0x6f, 0x35, 0x04, 0xdb,
      0xc8, 0x0c, 0xd5, 0xed, 0xc0, 0x62, 0xd2, 0xd0, 0xcc, 0x95, 0x2b, 0xa6, 0x52, 0x5d, 0x73, 0x6e,
      0x75, 0x8c, 0x27, 0x08, 0xf9, 0xd1, 0x68, 0x14, 0x79, 0xe9, 0x58, 0xce, 0x08, 0x2a, 0x69, 0x8e,
      0xd7, 0x18, 0xf8, 0x1e, 0x6a, 0x04, 0x54, 0x0c, 0xc6, 0x51, 0x1c, 0x49, 0xd2, 0xec, 0x58, 0xdd,
      0x05, 0xb7, 0x1e, 0x50, 0xf1, 0x46, 0x8d, 0xf1, 0x06, 0x52, 0xf1, 0x20, 0x15, 0xe0, 0x93, 0x96,
      0xce, 0xd5, 0x02, 0x2a, 0xde, 0x09, 0xf0, 0xf1, 0x7d, 0xd4, 0x98, 0xdf, 0x65, 0x64, 0x59, 0xe7,
      0xae, 0x04, 0xbc, 0x8e, 0x16, 0x21, 0x93, 0x9c, 0x92, 0x95, 0x8e, 0xd5, 0x6d, 0xb9, 0x66, 0xa0,
      0xce, 0x57, 0x1c, 0x65, 0xe6, 0x0b, 0x5d, 0x2d, 0xe3, 0x7c, 0xc5, 0x51, 0xa6, 0xbf, 0xcf, 0xf3,
      0x62, 0xdf, 0x13, 0x96, 0x78, 0x40, 0xd6, 0xca, 0xda, 0x47, 0xf3, 0xae, 0x15, 0x03, 0x9f, 0xa1,
      0xba, 0xb2, 0x1f, 0x8c, 0x00, 0xc8, 0xad, 0x92, 0x78, 0xba, 0xad, 0xbc, 0x04, 0xd8, 0xfa, 0x80,
      0x5a, 0xc5, 0xd5, 0xee, 0x30, 0x7f, 0x86, 0x1f, 0xa0, 0xaa, 0xcc, 0x04, 0xb1, 0x3a, 0xd5, 0x6e,
      0x73, 0xfb, 0xee, 0x9c, 0xbb, 0x27, 0xc3, 0x23, 0x4e, 0x13, 0x41, 0x3d, 0x19, 0xb1, 0xc4, 0x55,
      0x35, 0xd8, 0x46, 0x4b, 0xfa, 0xd2, 0x14, 0xa4, 0xf2, 0x7b, 0xf5, 0xb5, 0x66, 0xe1, 0xe6, 0x65,
      0x5b, 0x1f, 0x2d, 0x54, 0x2f, 0x52, 0xea, 0xe9, 0x50, 0xa7, 0xf3, 0xe6, 0xf1, 0xe7, 0xa7, 0x4d,
      0xd9, 0x7f, 0xe3, 0x8a, 0xa5, 0x54, 0xff, 0xbe, 0x14, 0xe7, 0xb3, 0x85, 0x9a, 0x1e, 0x8b, 0x8b,
      0x1a, 0x67, 0xde, 0xee, 0x84, 0xde, 0xc8, 0x43, 0xeb, 0xfd, 0xc1, 0x3f, 0xef, 0xf6, 0x7c, 0x10,
      0x40, 0x62, 0x9a, 0xb1, 0x1d, 0x30, 0x3b, 0xef, 0xb4, 0xbb, 0xea, 0x7f, 0xda, 0xff, 0x54, 0xa9,
      0x3a, 0x27, 0x27, 0x5f, 0x2a, 0x35, 0x47, 0x01, 0x8f, 0xfb, 0x5f, 0x4d, 0x74, 0x7a, 0xdc, 0xff,
      0x5e, 0xb9, 0x9d, 0x47, 0xa7, 0xaf, 0x0e, 0x1d, 0xe5, 0xe7, 0x53, 0x49, 0x7f, 0x54, 0xea, 0x4a,
      0xdd, 0xd9, 0x39, 0xee, 0x0f, 0x97, 0xb4, 0xe7, 0xc3, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xaa,
      0xa7, 0x77, 0xd8, 0x34, 0x08, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/base/v1/eth_tx.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: base/v1/eth_tx.proto
      package basev1
      import (
      fmt "fmt"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base"
      github_com_CaduceusMetaverseProtocol_MetaTypes_types "github.com/CaduceusMetaverseProtocol/MetaTypes/types"
      proto "github.com/gogo/protobuf/proto"
      types "github.com/gogo/protobuf/types"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type EthTxParam struct {
      From *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,1,opt,name=from,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"from,omitempty"`
      To *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,2,opt,name=to,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"to,omitempty"`
      Gas uint64 `protobuf:"varint,3,opt,name=gas,proto3" json:"gas,omitempty"`
      GasPrice *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,4,opt,name=gas_price,json=gasPrice,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"gas_price,omitempty"`
      MaxFeePerGas *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,5,opt,name=max_fee_per_gas,json=maxFeePerGas,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"max_fee_per_gas,omitempty"`
      MaxPriorityFeePerGas *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,6,opt,name=max_priority_fee_per_gas,json=maxPriorityFeePerGas,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"max_priority_fee_per_gas,omitempty"`
      Value *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,7,opt,name=value,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"value,omitempty"`
      Nonce uint64 `protobuf:"varint,8,opt,name=nonce,proto3" json:"nonce,omitempty"`
      Input []byte `protobuf:"bytes,9,opt,name=input,proto3" json:"input,omitempty"`
      Accesslist *AccessList `protobuf:"bytes,10,opt,name=accesslist,proto3" json:"accesslist,omitempty"`
      ChainId *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,11,opt,name=chain_id,json=chainId,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"chain_id,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthTxParam) Reset() { *m = EthTxParam{} }
      func (m *EthTxParam) String() string { return proto.CompactTextString(m) }
      func (*EthTxParam) ProtoMessage() {}
      func (*EthTxParam) Descriptor() ([]byte, []int) {
      return fileDescriptor_bccd389cdcf04d98, []int{0}
      }
      func (m *EthTxParam) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthTxParam.Unmarshal(m, b)
      }
      func (m *EthTxParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthTxParam.Marshal(b, m, deterministic)
      }
      func (m *EthTxParam) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthTxParam.Merge(m, src)
      }
      func (m *EthTxParam) XXX_Size() int {
      return xxx_messageInfo_EthTxParam.Size(m)
      }
      func (m *EthTxParam) XXX_DiscardUnknown() {
      xxx_messageInfo_EthTxParam.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthTxParam proto.InternalMessageInfo
      func (m *EthTxParam) GetGas() uint64 {
      if m != nil {
      return m.Gas
      }
      return 0
      }
      func (m *EthTxParam) GetNonce() uint64 {
      if m != nil {
      return m.Nonce
      }
      return 0
      }
      func (m *EthTxParam) GetInput() []byte {
      if m != nil {
      return m.Input
      }
      return nil
      }
      func (m *EthTxParam) GetAccesslist() *AccessList {
      if m != nil {
      return m.Accesslist
      }
      return nil
      }
      func (*EthTxParam) XXX_MessageName() string {
      return "base.v1.EthTxParam"
      }
      type EthLegacyTx struct {
      Nonce uint64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
      GasPrice *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,2,opt,name=gas_price,json=gasPrice,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"gas_price,omitempty"`
      Gas uint64 `protobuf:"varint,3,opt,name=gas,proto3" json:"gas,omitempty"`
      To *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,4,opt,name=to,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"to,omitempty"`
      Value *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,5,opt,name=value,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"value,omitempty"`
      Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"`
      V *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,7,opt,name=v,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"v,omitempty"`
      R *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,8,opt,name=r,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"r,omitempty"`
      S *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,9,opt,name=s,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"s,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthLegacyTx) Reset() { *m = EthLegacyTx{} }
      func (m *EthLegacyTx) String() string { return proto.CompactTextString(m) }
      func (*EthLegacyTx) ProtoMessage() {}
      func (*EthLegacyTx) Descriptor() ([]byte, []int) {
      return fileDescriptor_bccd389cdcf04d98, []int{1}
      }
      func (m *EthLegacyTx) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthLegacyTx.Unmarshal(m, b)
      }
      func (m *EthLegacyTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthLegacyTx.Marshal(b, m, deterministic)
      }
      func (m *EthLegacyTx) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthLegacyTx.Merge(m, src)
      }
      func (m *EthLegacyTx) XXX_Size() int {
      return xxx_messageInfo_EthLegacyTx.Size(m)
      }
      func (m *EthLegacyTx) XXX_DiscardUnknown() {
      xxx_messageInfo_EthLegacyTx.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthLegacyTx proto.InternalMessageInfo
      func (m *EthLegacyTx) GetNonce() uint64 {
      if m != nil {
      return m.Nonce
      }
      return 0
      }
      func (m *EthLegacyTx) GetGas() uint64 {
      if m != nil {
      return m.Gas
      }
      return 0
      }
      func (m *EthLegacyTx) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      func (*EthLegacyTx) XXX_MessageName() string {
      return "base.v1.EthLegacyTx"
      }
      type EthAccessListTx struct {
      ChainId *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"chain_id,omitempty"`
      Nonce uint64 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
      GasPrice *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"gas_price,omitempty"`
      Gas uint64 `protobuf:"varint,4,opt,name=gas,proto3" json:"gas,omitempty"`
      To *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,5,opt,name=to,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"to,omitempty"`
      Value *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,6,opt,name=value,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"value,omitempty"`
      Data []byte `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"`
      AccessList *AccessList `protobuf:"bytes,8,opt,name=access_list,json=accessList,proto3" json:"access_list,omitempty"`
      V *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,9,opt,name=v,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"v,omitempty"`
      R *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,10,opt,name=r,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"r,omitempty"`
      S *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,11,opt,name=s,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"s,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthAccessListTx) Reset() { *m = EthAccessListTx{} }
      func (m *EthAccessListTx) String() string { return proto.CompactTextString(m) }
      func (*EthAccessListTx) ProtoMessage() {}
      func (*EthAccessListTx) Descriptor() ([]byte, []int) {
      return fileDescriptor_bccd389cdcf04d98, []int{2}
      }
      func (m *EthAccessListTx) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthAccessListTx.Unmarshal(m, b)
      }
      func (m *EthAccessListTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthAccessListTx.Marshal(b, m, deterministic)
      }
      func (m *EthAccessListTx) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthAccessListTx.Merge(m, src)
      }
      func (m *EthAccessListTx) XXX_Size() int {
      return xxx_messageInfo_EthAccessListTx.Size(m)
      }
      func (m *EthAccessListTx) XXX_DiscardUnknown() {
      xxx_messageInfo_EthAccessListTx.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthAccessListTx proto.InternalMessageInfo
      func (m *EthAccessListTx) GetNonce() uint64 {
      if m != nil {
      return m.Nonce
      }
      return 0
      }
      func (m *EthAccessListTx) GetGas() uint64 {
      if m != nil {
      return m.Gas
      }
      return 0
      }
      func (m *EthAccessListTx) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      func (m *EthAccessListTx) GetAccessList() *AccessList {
      if m != nil {
      return m.AccessList
      }
      return nil
      }
      func (*EthAccessListTx) XXX_MessageName() string {
      return "base.v1.EthAccessListTx"
      }
      type EthDynamicFeeTx struct {
      ChainId *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"chain_id,omitempty"`
      Nonce uint64 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
      GasTipCap *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,3,opt,name=gas_tip_cap,json=gasTipCap,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"gas_tip_cap,omitempty"`
      GasFeeCap *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,4,opt,name=gas_fee_cap,json=gasFeeCap,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"gas_fee_cap,omitempty"`
      Gas uint64 `protobuf:"varint,5,opt,name=gas,proto3" json:"gas,omitempty"`
      To *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,6,opt,name=to,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"to,omitempty"`
      Value *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,7,opt,name=value,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"value,omitempty"`
      Data []byte `protobuf:"bytes,8,opt,name=data,proto3" json:"data,omitempty"`
      AccessList *AccessList `protobuf:"bytes,9,opt,name=access_list,json=accessList,proto3" json:"access_list,omitempty"`
      V *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,10,opt,name=v,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"v,omitempty"`
      R *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,11,opt,name=r,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"r,omitempty"`
      S *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,12,opt,name=s,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"s,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthDynamicFeeTx) Reset() { *m = EthDynamicFeeTx{} }
      func (m *EthDynamicFeeTx) String() string { return proto.CompactTextString(m) }
      func (*EthDynamicFeeTx) ProtoMessage() {}
      func (*EthDynamicFeeTx) Descriptor() ([]byte, []int) {
      return fileDescriptor_bccd389cdcf04d98, []int{3}
      }
      func (m *EthDynamicFeeTx) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthDynamicFeeTx.Unmarshal(m, b)
      }
      func (m *EthDynamicFeeTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthDynamicFeeTx.Marshal(b, m, deterministic)
      }
      func (m *EthDynamicFeeTx) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthDynamicFeeTx.Merge(m, src)
      }
      func (m *EthDynamicFeeTx) XXX_Size() int {
      return xxx_messageInfo_EthDynamicFeeTx.Size(m)
      }
      func (m *EthDynamicFeeTx) XXX_DiscardUnknown() {
      xxx_messageInfo_EthDynamicFeeTx.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthDynamicFeeTx proto.InternalMessageInfo
      func (m *EthDynamicFeeTx) GetNonce() uint64 {
      if m != nil {
      return m.Nonce
      }
      return 0
      }
      func (m *EthDynamicFeeTx) GetGas() uint64 {
      if m != nil {
      return m.Gas
      }
      return 0
      }
      func (m *EthDynamicFeeTx) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      func (m *EthDynamicFeeTx) GetAccessList() *AccessList {
      if m != nil {
      return m.AccessList
      }
      return nil
      }
      func (*EthDynamicFeeTx) XXX_MessageName() string {
      return "base.v1.EthDynamicFeeTx"
      }
      type EthTransaction struct {
      Tx *types.Any `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthTransaction) Reset() { *m = EthTransaction{} }
      func (m *EthTransaction) String() string { return proto.CompactTextString(m) }
      func (*EthTransaction) ProtoMessage() {}
      func (*EthTransaction) Descriptor() ([]byte, []int) {
      return fileDescriptor_bccd389cdcf04d98, []int{4}
      }
      func (m *EthTransaction) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthTransaction.Unmarshal(m, b)
      }
      func (m *EthTransaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthTransaction.Marshal(b, m, deterministic)
      }
      func (m *EthTransaction) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthTransaction.Merge(m, src)
      }
      func (m *EthTransaction) XXX_Size() int {
      return xxx_messageInfo_EthTransaction.Size(m)
      }
      func (m *EthTransaction) XXX_DiscardUnknown() {
      xxx_messageInfo_EthTransaction.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthTransaction proto.InternalMessageInfo
      func (m *EthTransaction) GetTx() *types.Any {
      if m != nil {
      return m.Tx
      }
      return nil
      }
      func (*EthTransaction) XXX_MessageName() string {
      return "base.v1.EthTransaction"
      }
      // EthTxLog reference ethereum Log struct.
      type EthTxLog struct {
      Address *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,1,opt,name=address,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"address,omitempty"`
      Topics []github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,2,rep,name=topics,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"topics,omitempty"`
      Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
      BlockNumber uint64 `protobuf:"varint,4,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
      TxHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,5,opt,name=tx_hash,json=txHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"tx_hash,omitempty"`
      TxIndex uint32 `protobuf:"varint,6,opt,name=tx_index,json=txIndex,proto3" json:"tx_index,omitempty"`
      BlockHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,7,opt,name=block_hash,json=blockHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"block_hash,omitempty"`
      LogIndex uint32 `protobuf:"varint,8,opt,name=log_index,json=logIndex,proto3" json:"log_index,omitempty"`
      Removed bool `protobuf:"varint,9,opt,name=removed,proto3" json:"removed,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthTxLog) Reset() { *m = EthTxLog{} }
      func (m *EthTxLog) String() string { return proto.CompactTextString(m) }
      func (*EthTxLog) ProtoMessage() {}
      func (*EthTxLog) Descriptor() ([]byte, []int) {
      return fileDescriptor_bccd389cdcf04d98, []int{5}
      }
      func (m *EthTxLog) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthTxLog.Unmarshal(m, b)
      }
      func (m *EthTxLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthTxLog.Marshal(b, m, deterministic)
      }
      func (m *EthTxLog) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthTxLog.Merge(m, src)
      }
      func (m *EthTxLog) XXX_Size() int {
      return xxx_messageInfo_EthTxLog.Size(m)
      }
      func (m *EthTxLog) XXX_DiscardUnknown() {
      xxx_messageInfo_EthTxLog.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthTxLog proto.InternalMessageInfo
      func (m *EthTxLog) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      func (m *EthTxLog) GetBlockNumber() uint64 {
      if m != nil {
      return m.BlockNumber
      }
      return 0
      }
      func (m *EthTxLog) GetTxIndex() uint32 {
      if m != nil {
      return m.TxIndex
      }
      return 0
      }
      func (m *EthTxLog) GetLogIndex() uint32 {
      if m != nil {
      return m.LogIndex
      }
      return 0
      }
      func (m *EthTxLog) GetRemoved() bool {
      if m != nil {
      return m.Removed
      }
      return false
      }
      func (*EthTxLog) XXX_MessageName() string {
      return "base.v1.EthTxLog"
      }
      type EthReceipt struct {
      Type uint32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
      Root []byte `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"`
      Status uint64 `protobuf:"varint,3,opt,name=status,proto3" json:"status,omitempty"`
      CumulativeGasUsed uint64 `protobuf:"varint,4,opt,name=cumulative_gas_used,json=cumulativeGasUsed,proto3" json:"cumulative_gas_used,omitempty"`
      Bloom *Bloom `protobuf:"bytes,5,opt,name=bloom,proto3" json:"bloom,omitempty"`
      Logs []*EthTxLog `protobuf:"bytes,6,rep,name=logs,proto3" json:"logs,omitempty"`
      TxHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,7,opt,name=tx_hash,json=txHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"tx_hash,omitempty"`
      ContractAddress *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,8,opt,name=contract_address,json=contractAddress,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"contract_address,omitempty"`
      GasUsed uint64 `protobuf:"varint,9,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
      BlockHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,10,opt,name=block_hash,json=blockHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"block_hash,omitempty"`
      BlockNumber *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,11,opt,name=block_number,json=blockNumber,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"block_number,omitempty"`
      TxIndex uint32 `protobuf:"varint,12,opt,name=tx_index,json=txIndex,proto3" json:"tx_index,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *EthReceipt) Reset() { *m = EthReceipt{} }
      func (m *EthReceipt) String() string { return proto.CompactTextString(m) }
      func (*EthReceipt) ProtoMessage() {}
      func (*EthReceipt) Descriptor() ([]byte, []int) {
      return fileDescriptor_bccd389cdcf04d98, []int{6}
      }
      func (m *EthReceipt) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_EthReceipt.Unmarshal(m, b)
      }
      func (m *EthReceipt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_EthReceipt.Marshal(b, m, deterministic)
      }
      func (m *EthReceipt) XXX_Merge(src proto.Message) {
      xxx_messageInfo_EthReceipt.Merge(m, src)
      }
      func (m *EthReceipt) XXX_Size() int {
      return xxx_messageInfo_EthReceipt.Size(m)
      }
      func (m *EthReceipt) XXX_DiscardUnknown() {
      xxx_messageInfo_EthReceipt.DiscardUnknown(m)
      }
      var xxx_messageInfo_EthReceipt proto.InternalMessageInfo
      func (m *EthReceipt) GetType() uint32 {
      if m != nil {
      return m.Type
      }
      return 0
      }
      func (m *EthReceipt) GetRoot() []byte {
      if m != nil {
      return m.Root
      }
      return nil
      }
      func (m *EthReceipt) GetStatus() uint64 {
      if m != nil {
      return m.Status
      }
      return 0
      }
      func (m *EthReceipt) GetCumulativeGasUsed() uint64 {
      if m != nil {
      return m.CumulativeGasUsed
      }
      return 0
      }
      func (m *EthReceipt) GetBloom() *Bloom {
      if m != nil {
      return m.Bloom
      }
      return nil
      }
      func (m *EthReceipt) GetLogs() []*EthTxLog {
      if m != nil {
      return m.Logs
      }
      return nil
      }
      func (m *EthReceipt) GetGasUsed() uint64 {
      if m != nil {
      return m.GasUsed
      }
      return 0
      }
      func (m *EthReceipt) GetTxIndex() uint32 {
      if m != nil {
      return m.TxIndex
      }
      return 0
      }
      func (*EthReceipt) XXX_MessageName() string {
      return "base.v1.EthReceipt"
      }
      func init() {
      proto.RegisterType((*EthTxParam)(nil), "base.v1.EthTxParam")
      proto.RegisterType((*EthLegacyTx)(nil), "base.v1.EthLegacyTx")
      proto.RegisterType((*EthAccessListTx)(nil), "base.v1.EthAccessListTx")
      proto.RegisterType((*EthDynamicFeeTx)(nil), "base.v1.EthDynamicFeeTx")
      proto.RegisterType((*EthTransaction)(nil), "base.v1.EthTransaction")
      proto.RegisterType((*EthTxLog)(nil), "base.v1.EthTxLog")
      proto.RegisterType((*EthReceipt)(nil), "base.v1.EthReceipt")
      }
      func init() { proto.RegisterFile("base/v1/eth_tx.proto", fileDescriptor_bccd389cdcf04d98) }
      var fileDescriptor_bccd389cdcf04d98 = []byte{
      // 1088 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x98, 0x4d, 0x6f, 0xdc, 0x44,
      0x18, 0xc7, 0x65, 0xef, 0x8b, 0xbd, 0x8f, 0x37, 0x4d, 0x3a, 0x89, 0x2a, 0xb7, 0x48, 0x24, 0x44,
      0x45, 0xca, 0x69, 0x57, 0xdb, 0x22, 0x24, 0x5a, 0x10, 0x74, 0x4b, 0x12, 0x22, 0xa5, 0x68, 0x65,
      0x85, 0xa8, 0x42, 0x15, 0xd6, 0xac, 0x3d, 0xf1, 0x5a, 0xb1, 0x3d, 0x96, 0x67, 0xbc, 0x78, 0x0f,
      0xdc, 0xb9, 0xf3, 0x0d, 0x10, 0x17, 0xf8, 0x0a, 0x5c, 0xb8, 0x81, 0xe0, 0x1b, 0xe4, 0x90, 0x03,
      0xdc, 0xf8, 0x14, 0x68, 0xc6, 0xf6, 0xbe, 0x04, 0x55, 0x40, 0xc5, 0xac, 0x7a, 0xc9, 0xce, 0x3c,
      0xe3, 0x3c, 0xff, 0xc7, 0x9e, 0xff, 0x6f, 0x76, 0x1f, 0xc3, 0xce, 0x18, 0x33, 0xd2, 0x9f, 0x0e,
      0xfa, 0x84, 0x4f, 0x5c, 0x5e, 0xf4, 0xd2, 0x8c, 0x72, 0x8a, 0x0c, 0x11, 0xed, 0x4d, 0x07, 0xf7,
      0x76, 0x03, 0x4a, 0x83, 0x88, 0xf4, 0x65, 0x78, 0x9c, 0x5f, 0xf4, 0x79, 0x18, 0x13, 0xc6, 0x71,
      0x9c, 0x96, 0x57, 0xde, 0xbb, 0x7b, 0xf3, 0x02, 0x9c, 0xcc, 0xaa, 0xa5, 0x3b, 0x75, 0xea, 0x8c,
      0x30, 0x9a, 0x67, 0x1e, 0xa9, 0xe2, 0x9b, 0x32, 0x1e, 0xd0, 0x80, 0x96, 0x81, 0xfd, 0x6f, 0x0c,
      0x80, 0x43, 0x3e, 0x39, 0x2b, 0x46, 0x38, 0xc3, 0x31, 0xba, 0x80, 0xe6, 0x45, 0x46, 0x63, 0x5b,
      0xdb, 0xd3, 0x0e, 0xac, 0x07, 0x5b, 0xbd, 0xaa, 0x96, 0xde, 0x13, 0xdf, 0xcf, 0x08, 0x63, 0xc3,
      0x8f, 0xae, 0xae, 0x77, 0xdf, 0x0f, 0x42, 0x3e, 0xc9, 0xc7, 0x3d, 0x8f, 0xc6, 0xfd, 0xa7, 0xd8,
      0xcf, 0x3d, 0x92, 0xb3, 0x67, 0x84, 0xe3, 0x29, 0xc9, 0x18, 0x19, 0x89, 0xac, 0x1e, 0x8d, 0xfa,
      0x22, 0x72, 0x36, 0x4b, 0x09, 0xeb, 0x73, 0xf1, 0xb7, 0xce, 0xe0, 0xc8, 0xfc, 0x68, 0x0c, 0x3a,
      0xa7, 0xb6, 0xae, 0x4c, 0x45, 0xe7, 0x14, 0x6d, 0x41, 0x23, 0xc0, 0xcc, 0x6e, 0xec, 0x69, 0x07,
      0x4d, 0x47, 0x0c, 0x51, 0x0c, 0x9d, 0x00, 0x33, 0x37, 0xcd, 0x42, 0x8f, 0xd8, 0x4d, 0x29, 0xbe,
      0x39, 0x17, 0x1f, 0x86, 0xc1, 0x49, 0xc2, 0x87, 0x1f, 0x5e, 0x5d, 0xef, 0x3e, 0x7e, 0x25, 0xed,
      0x32, 0x81, 0x63, 0x06, 0x98, 0x8d, 0x84, 0x02, 0xfa, 0x12, 0x36, 0x63, 0x5c, 0xb8, 0x17, 0x84,
      0xb8, 0x29, 0xc9, 0x5c, 0x51, 0x4c, 0x4b, 0x91, 0x68, 0x37, 0xc6, 0xc5, 0x11, 0x21, 0x23, 0x92,
      0x1d, 0x63, 0x86, 0xbe, 0xd6, 0xc0, 0x16, 0xca, 0x69, 0x16, 0xd2, 0x2c, 0xe4, 0xb3, 0x95, 0x12,
      0xda, 0x8a, 0x4a, 0xd8, 0x89, 0x71, 0x31, 0xaa, 0x04, 0x17, 0xa5, 0x5c, 0x40, 0x6b, 0x8a, 0xa3,
      0x9c, 0xd8, 0x86, 0x22, 0xd9, 0x32, 0x3d, 0xda, 0x81, 0x56, 0x42, 0x13, 0x8f, 0xd8, 0xa6, 0xdc,
      0xee, 0x72, 0x22, 0xa2, 0x61, 0x92, 0xe6, 0xdc, 0xee, 0xec, 0x69, 0x07, 0x5d, 0xa7, 0x9c, 0xa0,
      0x87, 0x00, 0xd8, 0xf3, 0x08, 0x63, 0x51, 0xc8, 0xb8, 0x0d, 0xb2, 0xb0, 0xed, 0x85, 0x09, 0xe5,
      0xd2, 0x69, 0xc8, 0xb8, 0xb3, 0x74, 0x19, 0xba, 0x04, 0xd3, 0x9b, 0xe0, 0x30, 0x71, 0x43, 0xdf,
      0xb6, 0x14, 0xdd, 0x8b, 0x21, 0x15, 0x4e, 0xfc, 0xfd, 0xef, 0x5a, 0x60, 0x1d, 0xf2, 0xc9, 0x29,
      0x09, 0xb0, 0x37, 0x3b, 0x2b, 0x16, 0x77, 0xa7, 0x2d, 0xdf, 0xdd, 0x8a, 0x9d, 0x75, 0xe5, 0x76,
      0xfe, 0x3b, 0x4f, 0x25, 0xc5, 0x4d, 0xa5, 0x14, 0xcf, 0x0d, 0xd4, 0x52, 0x6b, 0x20, 0x04, 0x4d,
      0x1f, 0x73, 0x2c, 0xf1, 0xe8, 0x3a, 0x72, 0x8c, 0xbe, 0x00, 0x6d, 0xaa, 0xcc, 0xb8, 0xda, 0x54,
      0xe4, 0xcf, 0xa4, 0x61, 0x95, 0xe4, 0xcf, 0x44, 0x7e, 0x26, 0xad, 0xaf, 0x24, 0x3f, 0xdb, 0xff,
      0xad, 0x0d, 0x9b, 0x87, 0x7c, 0xb2, 0x20, 0xe6, 0xac, 0x58, 0xe1, 0x44, 0x53, 0xcc, 0xc9, 0x82,
      0x0b, 0xfd, 0xa5, 0x5c, 0x34, 0xd6, 0xc5, 0x45, 0xf3, 0x26, 0x17, 0xad, 0xf5, 0x70, 0xd1, 0x5e,
      0x0f, 0x17, 0xc6, 0x12, 0x17, 0xef, 0x80, 0x55, 0x9e, 0x8c, 0xae, 0x3c, 0x41, 0xcd, 0x7f, 0x3c,
      0x41, 0xc5, 0xb8, 0xa4, 0xa9, 0xa3, 0x98, 0x26, 0x50, 0x4c, 0x93, 0xa5, 0x8e, 0xa6, 0x9f, 0x0c,
      0x49, 0xd3, 0xc7, 0xb3, 0x04, 0xc7, 0xa1, 0x77, 0x44, 0xc8, 0xeb, 0x41, 0x53, 0x0a, 0x96, 0xa0,
      0x89, 0x87, 0xa9, 0xeb, 0xe1, 0x54, 0x19, 0x4f, 0x02, 0xd9, 0xb3, 0x30, 0x7d, 0x8a, 0xd3, 0x5a,
      0x51, 0xfc, 0x68, 0x11, 0x8a, 0x4d, 0x85, 0x8a, 0x47, 0x84, 0x08, 0xc5, 0x0a, 0xe1, 0xd6, 0x4d,
      0x84, 0xdb, 0xeb, 0x41, 0xd8, 0x58, 0x0f, 0xc2, 0xe6, 0xcb, 0x11, 0xee, 0xfc, 0x07, 0x84, 0x41,
      0x31, 0xc2, 0x96, 0x62, 0x84, 0xbb, 0xea, 0x10, 0x7e, 0x17, 0x6e, 0x89, 0x66, 0x2a, 0xc3, 0x09,
      0xc3, 0x1e, 0x0f, 0x69, 0x82, 0xee, 0x83, 0xce, 0x8b, 0x0a, 0xdd, 0x9d, 0x5e, 0xd9, 0xb0, 0xf5,
      0xea, 0x86, 0xad, 0xf7, 0x24, 0x99, 0x39, 0x3a, 0x2f, 0xf6, 0x7f, 0x6c, 0x82, 0x29, 0xbb, 0xb0,
      0x53, 0x1a, 0xa0, 0x08, 0x0c, 0x5c, 0xba, 0x44, 0x61, 0x1b, 0x56, 0x4b, 0x20, 0x1f, 0xda, 0x9c,
      0xa6, 0xa1, 0xc7, 0x6c, 0x7d, 0xaf, 0x71, 0x60, 0x3d, 0xd8, 0x98, 0x8b, 0x7d, 0x82, 0xd9, 0x64,
      0xf8, 0xc1, 0xd5, 0xf5, 0xee, 0x7b, 0xaf, 0xa4, 0x24, 0xfe, 0xdd, 0xa9, 0x72, 0xcf, 0x2d, 0xd8,
      0x58, 0xb2, 0xe0, 0x5b, 0xd0, 0x1d, 0x47, 0xd4, 0xbb, 0x74, 0x93, 0x3c, 0x1e, 0x93, 0xac, 0xfa,
      0x02, 0xb5, 0x64, 0xec, 0x53, 0x19, 0x42, 0x04, 0x0c, 0x5e, 0xb8, 0x13, 0xcc, 0x26, 0xd5, 0xb7,
      0xe9, 0xff, 0x5d, 0x5d, 0x21, 0x3e, 0xd1, 0x5d, 0x30, 0x79, 0xe1, 0x86, 0x89, 0x4f, 0x0a, 0x89,
      0xfc, 0x86, 0x63, 0xf0, 0xe2, 0x44, 0x4c, 0xd1, 0x25, 0x40, 0x59, 0xa4, 0x2c, 0xc2, 0x50, 0x50,
      0x44, 0x47, 0xe6, 0x97, 0x75, 0xbc, 0x01, 0x9d, 0x88, 0x06, 0x55, 0x21, 0xa6, 0x2c, 0xc4, 0x8c,
      0x68, 0x50, 0x56, 0x62, 0x83, 0x91, 0x91, 0x98, 0x4e, 0x89, 0x2f, 0x69, 0x35, 0x9d, 0x7a, 0xba,
      0xff, 0x73, 0x4b, 0xf6, 0xf0, 0x0e, 0xf1, 0x48, 0x98, 0x72, 0xf1, 0xac, 0x45, 0x7a, 0x69, 0x9e,
      0x0d, 0x47, 0x8e, 0x45, 0x2c, 0xa3, 0x94, 0xcb, 0x93, 0xbd, 0xeb, 0xc8, 0x31, 0xba, 0x03, 0x6d,
      0xc6, 0x31, 0xcf, 0xeb, 0x9f, 0xf4, 0xd5, 0x0c, 0xf5, 0x60, 0xdb, 0xcb, 0xe3, 0x3c, 0xc2, 0x3c,
      0x9c, 0x12, 0xd1, 0x32, 0xba, 0x39, 0x23, 0x7e, 0xb5, 0x3d, 0xb7, 0x17, 0x4b, 0xc7, 0x98, 0x7d,
      0xc6, 0x88, 0x8f, 0xee, 0x43, 0x6b, 0x1c, 0x51, 0x1a, 0x57, 0x5b, 0x74, 0x6b, 0x01, 0x96, 0x88,
      0x3a, 0xe5, 0x22, 0x7a, 0x1b, 0x9a, 0x11, 0x0d, 0x44, 0xfb, 0x29, 0x5c, 0x76, 0x7b, 0x7e, 0x51,
      0x6d, 0x7b, 0x47, 0x2e, 0x2f, 0xef, 0xb8, 0xa1, 0x70, 0xc7, 0xbf, 0x82, 0x2d, 0x8f, 0x26, 0x3c,
      0xc3, 0x1e, 0x77, 0x6b, 0xd8, 0x4c, 0x65, 0xb0, 0x6d, 0xd6, 0x5a, 0x55, 0x40, 0x18, 0x6e, 0xfe,
      0x5c, 0x3b, 0xf2, 0xb9, 0x1a, 0x41, 0xf5, 0x34, 0x57, 0x0d, 0x07, 0x6a, 0x0d, 0xc7, 0x6e, 0x20,
      0xa8, 0xea, 0xe8, 0x5d, 0x81, 0x7a, 0x99, 0xb6, 0xee, 0x0a, 0x6d, 0xc3, 0xef, 0xb5, 0x5f, 0xfe,
      0x78, 0x53, 0x03, 0xcb, 0xa3, 0x71, 0x5d, 0xc3, 0xb0, 0x7a, 0x3d, 0x25, 0x14, 0x46, 0xda, 0xe7,
      0xcf, 0xfe, 0x75, 0x19, 0xf3, 0x49, 0x40, 0x92, 0xf2, 0x15, 0x59, 0x3f, 0xa0, 0xfd, 0xea, 0xbd,
      0xd8, 0x63, 0xf1, 0x39, 0x1d, 0x7c, 0xab, 0x37, 0x86, 0xcf, 0x9f, 0xff, 0xa0, 0x1b, 0x43, 0x21,
      0x76, 0x3e, 0xf8, 0xb5, 0x1c, 0xbd, 0x38, 0x1f, 0xfc, 0xae, 0x6f, 0x57, 0xa3, 0x17, 0xc7, 0xa3,
      0xa1, 0xc8, 0x27, 0xce, 0xac, 0x3f, 0x75, 0x53, 0x44, 0x1f, 0x3d, 0x3a, 0x1f, 0x8c, 0xdb, 0x32,
      0xe7, 0xc3, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0xcf, 0x78, 0xc1, 0xb9, 0xc6, 0x13, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/base/v1/meta.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: base/v1/meta.proto
      package basev1
      import (
      fmt "fmt"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base"
      github_com_CaduceusMetaverseProtocol_MetaTypes_types "github.com/CaduceusMetaverseProtocol/MetaTypes/types"
      proto "github.com/gogo/protobuf/proto"
      types "github.com/gogo/protobuf/types"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type MetaProof struct {
      Rset []byte `protobuf:"bytes,1,opt,name=rset,proto3" json:"rset,omitempty"`
      Wset []byte `protobuf:"bytes,2,opt,name=wset,proto3" json:"wset,omitempty"`
      Proof []byte `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
      StateBlockNum int64 `protobuf:"varint,4,opt,name=state_block_num,json=stateBlockNum,proto3" json:"state_block_num,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MetaProof) Reset() { *m = MetaProof{} }
      func (m *MetaProof) String() string { return proto.CompactTextString(m) }
      func (*MetaProof) ProtoMessage() {}
      func (*MetaProof) Descriptor() ([]byte, []int) {
      return fileDescriptor_bdc8166c9acdb440, []int{0}
      }
      func (m *MetaProof) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MetaProof.Unmarshal(m, b)
      }
      func (m *MetaProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MetaProof.Marshal(b, m, deterministic)
      }
      func (m *MetaProof) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MetaProof.Merge(m, src)
      }
      func (m *MetaProof) XXX_Size() int {
      return xxx_messageInfo_MetaProof.Size(m)
      }
      func (m *MetaProof) XXX_DiscardUnknown() {
      xxx_messageInfo_MetaProof.DiscardUnknown(m)
      }
      var xxx_messageInfo_MetaProof proto.InternalMessageInfo
      func (m *MetaProof) GetRset() []byte {
      if m != nil {
      return m.Rset
      }
      return nil
      }
      func (m *MetaProof) GetWset() []byte {
      if m != nil {
      return m.Wset
      }
      return nil
      }
      func (m *MetaProof) GetProof() []byte {
      if m != nil {
      return m.Proof
      }
      return nil
      }
      func (m *MetaProof) GetStateBlockNum() int64 {
      if m != nil {
      return m.StateBlockNum
      }
      return 0
      }
      func (*MetaProof) XXX_MessageName() string {
      return "base.v1.MetaProof"
      }
      type MetaTxBase struct {
      // tx_type used to type tx.
      TxType uint32 `protobuf:"varint,1,opt,name=tx_type,json=txType,proto3" json:"tx_type,omitempty"`
      ChainId *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"chain_id,omitempty"`
      Nonce uint64 `protobuf:"varint,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
      GasPrice *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,4,opt,name=gas_price,json=gasPrice,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"gas_price,omitempty"`
      Gas uint64 `protobuf:"varint,5,opt,name=gas,proto3" json:"gas,omitempty"`
      To *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,6,opt,name=to,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"to,omitempty"`
      Value *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,7,opt,name=value,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"value,omitempty"`
      Data []byte `protobuf:"bytes,8,opt,name=data,proto3" json:"data,omitempty"`
      AccessList *AccessList `protobuf:"bytes,9,opt,name=access_list,json=accessList,proto3" json:"access_list,omitempty"`
      V *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,10,opt,name=v,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"v,omitempty"`
      R *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,11,opt,name=r,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"r,omitempty"`
      S *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,12,opt,name=s,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"s,omitempty"`
      From *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,13,opt,name=from,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"from,omitempty"`
      // expire block used to ignore execute tx when it is packaged in expired_block.
      ExpiredBlock *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,15,opt,name=expired_block,json=expiredBlock,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"expired_block,omitempty"`
      TxHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,16,opt,name=tx_hash,json=txHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"tx_hash,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MetaTxBase) Reset() { *m = MetaTxBase{} }
      func (m *MetaTxBase) String() string { return proto.CompactTextString(m) }
      func (*MetaTxBase) ProtoMessage() {}
      func (*MetaTxBase) Descriptor() ([]byte, []int) {
      return fileDescriptor_bdc8166c9acdb440, []int{1}
      }
      func (m *MetaTxBase) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MetaTxBase.Unmarshal(m, b)
      }
      func (m *MetaTxBase) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MetaTxBase.Marshal(b, m, deterministic)
      }
      func (m *MetaTxBase) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MetaTxBase.Merge(m, src)
      }
      func (m *MetaTxBase) XXX_Size() int {
      return xxx_messageInfo_MetaTxBase.Size(m)
      }
      func (m *MetaTxBase) XXX_DiscardUnknown() {
      xxx_messageInfo_MetaTxBase.DiscardUnknown(m)
      }
      var xxx_messageInfo_MetaTxBase proto.InternalMessageInfo
      func (m *MetaTxBase) GetTxType() uint32 {
      if m != nil {
      return m.TxType
      }
      return 0
      }
      func (m *MetaTxBase) GetNonce() uint64 {
      if m != nil {
      return m.Nonce
      }
      return 0
      }
      func (m *MetaTxBase) GetGas() uint64 {
      if m != nil {
      return m.Gas
      }
      return 0
      }
      func (m *MetaTxBase) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      func (m *MetaTxBase) GetAccessList() *AccessList {
      if m != nil {
      return m.AccessList
      }
      return nil
      }
      func (*MetaTxBase) XXX_MessageName() string {
      return "base.v1.MetaTxBase"
      }
      type MetaProofTx struct {
      Base *MetaTxBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
      Proof *MetaProof `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MetaProofTx) Reset() { *m = MetaProofTx{} }
      func (m *MetaProofTx) String() string { return proto.CompactTextString(m) }
      func (*MetaProofTx) ProtoMessage() {}
      func (*MetaProofTx) Descriptor() ([]byte, []int) {
      return fileDescriptor_bdc8166c9acdb440, []int{2}
      }
      func (m *MetaProofTx) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MetaProofTx.Unmarshal(m, b)
      }
      func (m *MetaProofTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MetaProofTx.Marshal(b, m, deterministic)
      }
      func (m *MetaProofTx) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MetaProofTx.Merge(m, src)
      }
      func (m *MetaProofTx) XXX_Size() int {
      return xxx_messageInfo_MetaProofTx.Size(m)
      }
      func (m *MetaProofTx) XXX_DiscardUnknown() {
      xxx_messageInfo_MetaProofTx.DiscardUnknown(m)
      }
      var xxx_messageInfo_MetaProofTx proto.InternalMessageInfo
      func (m *MetaProofTx) GetBase() *MetaTxBase {
      if m != nil {
      return m.Base
      }
      return nil
      }
      func (m *MetaProofTx) GetProof() *MetaProof {
      if m != nil {
      return m.Proof
      }
      return nil
      }
      func (*MetaProofTx) XXX_MessageName() string {
      return "base.v1.MetaProofTx"
      }
      type MetaTransaction struct {
      Tx *types.Any `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MetaTransaction) Reset() { *m = MetaTransaction{} }
      func (m *MetaTransaction) String() string { return proto.CompactTextString(m) }
      func (*MetaTransaction) ProtoMessage() {}
      func (*MetaTransaction) Descriptor() ([]byte, []int) {
      return fileDescriptor_bdc8166c9acdb440, []int{3}
      }
      func (m *MetaTransaction) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MetaTransaction.Unmarshal(m, b)
      }
      func (m *MetaTransaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MetaTransaction.Marshal(b, m, deterministic)
      }
      func (m *MetaTransaction) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MetaTransaction.Merge(m, src)
      }
      func (m *MetaTransaction) XXX_Size() int {
      return xxx_messageInfo_MetaTransaction.Size(m)
      }
      func (m *MetaTransaction) XXX_DiscardUnknown() {
      xxx_messageInfo_MetaTransaction.DiscardUnknown(m)
      }
      var xxx_messageInfo_MetaTransaction proto.InternalMessageInfo
      func (m *MetaTransaction) GetTx() *types.Any {
      if m != nil {
      return m.Tx
      }
      return nil
      }
      func (*MetaTransaction) XXX_MessageName() string {
      return "base.v1.MetaTransaction"
      }
      type MetaBlockHeader struct {
      ParentHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"parent_hash,omitempty"`
      BlockHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,2,opt,name=block_hash,json=blockHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"block_hash,omitempty"`
      Miner *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,3,opt,name=miner,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"miner,omitempty"`
      StateRoot *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,4,opt,name=state_root,json=stateRoot,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"state_root,omitempty"`
      TxsRoot *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,5,opt,name=txs_root,json=txsRoot,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"txs_root,omitempty"`
      ReceiptsRoot *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,6,opt,name=receipts_root,json=receiptsRoot,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"receipts_root,omitempty"`
      BlockNumber *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,7,opt,name=block_number,json=blockNumber,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"block_number,omitempty"`
      BlockBloom *Bloom `protobuf:"bytes,8,opt,name=block_bloom,json=blockBloom,proto3" json:"block_bloom,omitempty"`
      GasLimit uint64 `protobuf:"varint,9,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
      GasUsed uint64 `protobuf:"varint,10,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
      Timestamp uint64 `protobuf:"varint,11,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
      Extra []byte `protobuf:"bytes,12,opt,name=extra,proto3" json:"extra,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MetaBlockHeader) Reset() { *m = MetaBlockHeader{} }
      func (m *MetaBlockHeader) String() string { return proto.CompactTextString(m) }
      func (*MetaBlockHeader) ProtoMessage() {}
      func (*MetaBlockHeader) Descriptor() ([]byte, []int) {
      return fileDescriptor_bdc8166c9acdb440, []int{4}
      }
      func (m *MetaBlockHeader) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MetaBlockHeader.Unmarshal(m, b)
      }
      func (m *MetaBlockHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MetaBlockHeader.Marshal(b, m, deterministic)
      }
      func (m *MetaBlockHeader) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MetaBlockHeader.Merge(m, src)
      }
      func (m *MetaBlockHeader) XXX_Size() int {
      return xxx_messageInfo_MetaBlockHeader.Size(m)
      }
      func (m *MetaBlockHeader) XXX_DiscardUnknown() {
      xxx_messageInfo_MetaBlockHeader.DiscardUnknown(m)
      }
      var xxx_messageInfo_MetaBlockHeader proto.InternalMessageInfo
      func (m *MetaBlockHeader) GetBlockBloom() *Bloom {
      if m != nil {
      return m.BlockBloom
      }
      return nil
      }
      func (m *MetaBlockHeader) GetGasLimit() uint64 {
      if m != nil {
      return m.GasLimit
      }
      return 0
      }
      func (m *MetaBlockHeader) GetGasUsed() uint64 {
      if m != nil {
      return m.GasUsed
      }
      return 0
      }
      func (m *MetaBlockHeader) GetTimestamp() uint64 {
      if m != nil {
      return m.Timestamp
      }
      return 0
      }
      func (m *MetaBlockHeader) GetExtra() []byte {
      if m != nil {
      return m.Extra
      }
      return nil
      }
      func (*MetaBlockHeader) XXX_MessageName() string {
      return "base.v1.MetaBlockHeader"
      }
      type MetaBlockBody struct {
      Txs []*MetaTransaction `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MetaBlockBody) Reset() { *m = MetaBlockBody{} }
      func (m *MetaBlockBody) String() string { return proto.CompactTextString(m) }
      func (*MetaBlockBody) ProtoMessage() {}
      func (*MetaBlockBody) Descriptor() ([]byte, []int) {
      return fileDescriptor_bdc8166c9acdb440, []int{5}
      }
      func (m *MetaBlockBody) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MetaBlockBody.Unmarshal(m, b)
      }
      func (m *MetaBlockBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MetaBlockBody.Marshal(b, m, deterministic)
      }
      func (m *MetaBlockBody) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MetaBlockBody.Merge(m, src)
      }
      func (m *MetaBlockBody) XXX_Size() int {
      return xxx_messageInfo_MetaBlockBody.Size(m)
      }
      func (m *MetaBlockBody) XXX_DiscardUnknown() {
      xxx_messageInfo_MetaBlockBody.DiscardUnknown(m)
      }
      var xxx_messageInfo_MetaBlockBody proto.InternalMessageInfo
      func (m *MetaBlockBody) GetTxs() []*MetaTransaction {
      if m != nil {
      return m.Txs
      }
      return nil
      }
      func (*MetaBlockBody) XXX_MessageName() string {
      return "base.v1.MetaBlockBody"
      }
      type MetaBlock struct {
      Header *MetaBlockHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      Txs []*MetaTransaction `protobuf:"bytes,2,rep,name=txs,proto3" json:"txs,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MetaBlock) Reset() { *m = MetaBlock{} }
      func (m *MetaBlock) String() string { return proto.CompactTextString(m) }
      func (*MetaBlock) ProtoMessage() {}
      func (*MetaBlock) Descriptor() ([]byte, []int) {
      return fileDescriptor_bdc8166c9acdb440, []int{6}
      }
      func (m *MetaBlock) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MetaBlock.Unmarshal(m, b)
      }
      func (m *MetaBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MetaBlock.Marshal(b, m, deterministic)
      }
      func (m *MetaBlock) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MetaBlock.Merge(m, src)
      }
      func (m *MetaBlock) XXX_Size() int {
      return xxx_messageInfo_MetaBlock.Size(m)
      }
      func (m *MetaBlock) XXX_DiscardUnknown() {
      xxx_messageInfo_MetaBlock.DiscardUnknown(m)
      }
      var xxx_messageInfo_MetaBlock proto.InternalMessageInfo
      func (m *MetaBlock) GetHeader() *MetaBlockHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *MetaBlock) GetTxs() []*MetaTransaction {
      if m != nil {
      return m.Txs
      }
      return nil
      }
      func (*MetaBlock) XXX_MessageName() string {
      return "base.v1.MetaBlock"
      }
      type MetaTxLog struct {
      Address *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,1,opt,name=address,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"address,omitempty"`
      Topics []github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,2,rep,name=topics,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"topics,omitempty"`
      Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
      BlockNumber uint64 `protobuf:"varint,4,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
      TxHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,5,opt,name=tx_hash,json=txHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"tx_hash,omitempty"`
      TxIndex uint32 `protobuf:"varint,6,opt,name=tx_index,json=txIndex,proto3" json:"tx_index,omitempty"`
      BlockHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,7,opt,name=block_hash,json=blockHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"block_hash,omitempty"`
      LogIndex uint32 `protobuf:"varint,8,opt,name=log_index,json=logIndex,proto3" json:"log_index,omitempty"`
      Removed bool `protobuf:"varint,9,opt,name=removed,proto3" json:"removed,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MetaTxLog) Reset() { *m = MetaTxLog{} }
      func (m *MetaTxLog) String() string { return proto.CompactTextString(m) }
      func (*MetaTxLog) ProtoMessage() {}
      func (*MetaTxLog) Descriptor() ([]byte, []int) {
      return fileDescriptor_bdc8166c9acdb440, []int{7}
      }
      func (m *MetaTxLog) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MetaTxLog.Unmarshal(m, b)
      }
      func (m *MetaTxLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MetaTxLog.Marshal(b, m, deterministic)
      }
      func (m *MetaTxLog) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MetaTxLog.Merge(m, src)
      }
      func (m *MetaTxLog) XXX_Size() int {
      return xxx_messageInfo_MetaTxLog.Size(m)
      }
      func (m *MetaTxLog) XXX_DiscardUnknown() {
      xxx_messageInfo_MetaTxLog.DiscardUnknown(m)
      }
      var xxx_messageInfo_MetaTxLog proto.InternalMessageInfo
      func (m *MetaTxLog) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      func (m *MetaTxLog) GetBlockNumber() uint64 {
      if m != nil {
      return m.BlockNumber
      }
      return 0
      }
      func (m *MetaTxLog) GetTxIndex() uint32 {
      if m != nil {
      return m.TxIndex
      }
      return 0
      }
      func (m *MetaTxLog) GetLogIndex() uint32 {
      if m != nil {
      return m.LogIndex
      }
      return 0
      }
      func (m *MetaTxLog) GetRemoved() bool {
      if m != nil {
      return m.Removed
      }
      return false
      }
      func (*MetaTxLog) XXX_MessageName() string {
      return "base.v1.MetaTxLog"
      }
      type MetaReceipt struct {
      Type uint32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
      Root []byte `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"`
      Status uint64 `protobuf:"varint,3,opt,name=status,proto3" json:"status,omitempty"`
      CumulativeGasUsed uint64 `protobuf:"varint,4,opt,name=cumulative_gas_used,json=cumulativeGasUsed,proto3" json:"cumulative_gas_used,omitempty"`
      Bloom *Bloom `protobuf:"bytes,5,opt,name=bloom,proto3" json:"bloom,omitempty"`
      Logs []*MetaTxLog `protobuf:"bytes,6,rep,name=logs,proto3" json:"logs,omitempty"`
      TxHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,7,opt,name=tx_hash,json=txHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"tx_hash,omitempty"`
      ContractAddress *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,8,opt,name=contract_address,json=contractAddress,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"contract_address,omitempty"`
      GasUsed uint64 `protobuf:"varint,9,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
      BlockHash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,10,opt,name=block_hash,json=blockHash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"block_hash,omitempty"`
      BlockNumber *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,11,opt,name=block_number,json=blockNumber,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"block_number,omitempty"`
      TxIndex uint32 `protobuf:"varint,12,opt,name=tx_index,json=txIndex,proto3" json:"tx_index,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MetaReceipt) Reset() { *m = MetaReceipt{} }
      func (m *MetaReceipt) String() string { return proto.CompactTextString(m) }
      func (*MetaReceipt) ProtoMessage() {}
      func (*MetaReceipt) Descriptor() ([]byte, []int) {
      return fileDescriptor_bdc8166c9acdb440, []int{8}
      }
      func (m *MetaReceipt) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MetaReceipt.Unmarshal(m, b)
      }
      func (m *MetaReceipt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MetaReceipt.Marshal(b, m, deterministic)
      }
      func (m *MetaReceipt) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MetaReceipt.Merge(m, src)
      }
      func (m *MetaReceipt) XXX_Size() int {
      return xxx_messageInfo_MetaReceipt.Size(m)
      }
      func (m *MetaReceipt) XXX_DiscardUnknown() {
      xxx_messageInfo_MetaReceipt.DiscardUnknown(m)
      }
      var xxx_messageInfo_MetaReceipt proto.InternalMessageInfo
      func (m *MetaReceipt) GetType() uint32 {
      if m != nil {
      return m.Type
      }
      return 0
      }
      func (m *MetaReceipt) GetRoot() []byte {
      if m != nil {
      return m.Root
      }
      return nil
      }
      func (m *MetaReceipt) GetStatus() uint64 {
      if m != nil {
      return m.Status
      }
      return 0
      }
      func (m *MetaReceipt) GetCumulativeGasUsed() uint64 {
      if m != nil {
      return m.CumulativeGasUsed
      }
      return 0
      }
      func (m *MetaReceipt) GetBloom() *Bloom {
      if m != nil {
      return m.Bloom
      }
      return nil
      }
      func (m *MetaReceipt) GetLogs() []*MetaTxLog {
      if m != nil {
      return m.Logs
      }
      return nil
      }
      func (m *MetaReceipt) GetGasUsed() uint64 {
      if m != nil {
      return m.GasUsed
      }
      return 0
      }
      func (m *MetaReceipt) GetTxIndex() uint32 {
      if m != nil {
      return m.TxIndex
      }
      return 0
      }
      func (*MetaReceipt) XXX_MessageName() string {
      return "base.v1.MetaReceipt"
      }
      func init() {
      proto.RegisterType((*MetaProof)(nil), "base.v1.MetaProof")
      proto.RegisterType((*MetaTxBase)(nil), "base.v1.MetaTxBase")
      proto.RegisterType((*MetaProofTx)(nil), "base.v1.MetaProofTx")
      proto.RegisterType((*MetaTransaction)(nil), "base.v1.MetaTransaction")
      proto.RegisterType((*MetaBlockHeader)(nil), "base.v1.MetaBlockHeader")
      proto.RegisterType((*MetaBlockBody)(nil), "base.v1.MetaBlockBody")
      proto.RegisterType((*MetaBlock)(nil), "base.v1.MetaBlock")
      proto.RegisterType((*MetaTxLog)(nil), "base.v1.MetaTxLog")
      proto.RegisterType((*MetaReceipt)(nil), "base.v1.MetaReceipt")
      }
      func init() { proto.RegisterFile("base/v1/meta.proto", fileDescriptor_bdc8166c9acdb440) }
      var fileDescriptor_bdc8166c9acdb440 = []byte{
      // 1174 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xcd, 0x8e, 0x1b, 0x45,
      0x10, 0x96, 0x7f, 0xc7, 0x2e, 0xdb, 0x78, 0xe9, 0x8d, 0xc2, 0x24, 0x41, 0xec, 0x62, 0x45, 0x61,
      0xc5, 0xc1, 0xc6, 0x0b, 0x12, 0x22, 0x0b, 0x82, 0x98, 0x43, 0xb2, 0xd2, 0x06, 0xad, 0x46, 0xcb,
      0x2a, 0x42, 0x11, 0xa6, 0x3d, 0xd3, 0x3b, 0x1e, 0xad, 0x67, 0xda, 0xe9, 0xee, 0x31, 0xe3, 0x03,
      0x2f, 0x83, 0x84, 0x84, 0x38, 0x72, 0xe6, 0x01, 0x80, 0x47, 0xd8, 0xc3, 0x1e, 0xe0, 0xc6, 0x53,
      0xa0, 0xae, 0xee, 0xf1, 0xcf, 0x8a, 0x43, 0x14, 0x65, 0x38, 0x4d, 0x75, 0x75, 0x77, 0x7d, 0xd5,
      0x3d, 0x55, 0x5f, 0x55, 0x03, 0x99, 0x50, 0xc9, 0x06, 0x8b, 0xe1, 0x20, 0x66, 0x8a, 0xf6, 0xe7,
      0x82, 0x2b, 0x4e, 0x1c, 0xad, 0xeb, 0x2f, 0x86, 0x77, 0xf7, 0x42, 0xce, 0xc3, 0x19, 0x1b, 0xa0,
      0x7a, 0x92, 0x5e, 0x0c, 0x54, 0x14, 0x33, 0xa9, 0x68, 0x3c, 0x37, 0x2b, 0xef, 0xde, 0xb9, 0xb9,
      0x80, 0x26, 0x4b, 0x3b, 0x75, 0x3b, 0x37, 0x2c, 0x98, 0xe4, 0xa9, 0xf0, 0x99, 0xd5, 0x77, 0x51,
      0x1f, 0xf2, 0x90, 0x1b, 0x45, 0xef, 0x05, 0x34, 0x9f, 0x32, 0x45, 0x4f, 0x05, 0xe7, 0x17, 0x84,
      0x40, 0x55, 0x48, 0xa6, 0xdc, 0xd2, 0x7e, 0xe9, 0xa0, 0xed, 0xa1, 0xac, 0x75, 0xdf, 0x6b, 0x5d,
      0xd9, 0xe8, 0xb4, 0x4c, 0x6e, 0x41, 0x6d, 0xae, 0x37, 0xb8, 0x15, 0x54, 0x9a, 0x01, 0x79, 0x00,
      0x5d, 0xa9, 0xa8, 0x62, 0xe3, 0xc9, 0x8c, 0xfb, 0x97, 0xe3, 0x24, 0x8d, 0xdd, 0xea, 0x7e, 0xe9,
      0xa0, 0xe2, 0x75, 0x50, 0x3d, 0xd2, 0xda, 0xaf, 0xd2, 0xb8, 0xf7, 0x53, 0x13, 0x40, 0x63, 0x9e,
      0x65, 0x23, 0x2a, 0x19, 0x79, 0x0b, 0x1c, 0x95, 0x8d, 0xd5, 0x72, 0xce, 0x10, 0xb7, 0xe3, 0xd5,
      0x55, 0x76, 0xb6, 0x9c, 0x33, 0x72, 0x09, 0x0d, 0x7f, 0x4a, 0xa3, 0x64, 0x1c, 0x05, 0x88, 0xde,
      0x3a, 0xec, 0xf6, 0xed, 0xdd, 0xf4, 0x47, 0x51, 0x78, 0x9c, 0xa8, 0xd1, 0xe7, 0x57, 0xd7, 0x7b,
      0x47, 0x61, 0xa4, 0xa6, 0xe9, 0xa4, 0xef, 0xf3, 0x78, 0xf0, 0x25, 0x0d, 0x52, 0x9f, 0xa5, 0x52,
      0x9b, 0x5f, 0x30, 0x21, 0xd9, 0xa9, 0x3e, 0xa4, 0xcf, 0x67, 0x03, 0x04, 0x5c, 0xce, 0x99, 0x1c,
      0x68, 0x24, 0x69, 0x0d, 0x78, 0x0e, 0x22, 0x1c, 0x07, 0xfa, 0x48, 0x09, 0x4f, 0x7c, 0x86, 0x47,
      0xaa, 0x7a, 0x66, 0x40, 0x62, 0x68, 0x86, 0x54, 0x8e, 0xe7, 0x22, 0xf2, 0x19, 0x1e, 0xa6, 0x08,
      0x1f, 0x1a, 0x21, 0x95, 0xa7, 0x1a, 0x81, 0xec, 0x40, 0x25, 0xa4, 0xd2, 0xad, 0xa1, 0x0b, 0x5a,
      0x24, 0x13, 0x28, 0x2b, 0xee, 0xd6, 0x11, 0x79, 0x67, 0x85, 0xfc, 0x28, 0x08, 0x04, 0x93, 0x72,
      0xf4, 0xc5, 0xd5, 0xf5, 0xde, 0xa7, 0xaf, 0x04, 0x6d, 0x2d, 0x78, 0x65, 0xc5, 0xc9, 0x05, 0xd4,
      0x16, 0x74, 0x96, 0x32, 0xd7, 0x29, 0xe8, 0x80, 0xc6, 0xbc, 0x8e, 0xa4, 0x80, 0x2a, 0xea, 0x36,
      0x4c, 0x24, 0x69, 0x99, 0x7c, 0x04, 0x2d, 0xea, 0xfb, 0x4c, 0xca, 0xf1, 0x2c, 0x92, 0xca, 0x6d,
      0xa2, 0x07, 0xbb, 0xeb, 0x83, 0xe2, 0xdc, 0x49, 0x24, 0x95, 0x07, 0x74, 0x25, 0x93, 0x6f, 0xa1,
      0xb4, 0x70, 0xa1, 0x20, 0x6f, 0x4b, 0x0b, 0x6d, 0x5f, 0xb8, 0xad, 0xa2, 0xec, 0x0b, 0x6d, 0x5f,
      0xba, 0xed, 0xa2, 0xec, 0x4b, 0x72, 0x01, 0xd5, 0x0b, 0xc1, 0x63, 0xb7, 0x53, 0x58, 0xdc, 0xa0,
      0x7d, 0x92, 0x42, 0x87, 0x65, 0xf3, 0x48, 0xb0, 0xc0, 0xe4, 0xbc, 0xdb, 0x2d, 0xe8, 0x4c, 0x6d,
      0x0b, 0x83, 0x1c, 0x42, 0x18, 0x32, 0xc6, 0x94, 0xca, 0xa9, 0xbb, 0x83, 0x80, 0x9d, 0x15, 0xe0,
      0x13, 0x2a, 0xa7, 0xa3, 0xcf, 0xae, 0xae, 0xf7, 0x3e, 0x79, 0x25, 0x38, 0xbd, 0x5d, 0xf3, 0x8f,
      0xfe, 0xf6, 0xbe, 0x83, 0xd6, 0x8a, 0x1a, 0xcf, 0x32, 0xf2, 0x1e, 0x54, 0x35, 0x0a, 0x92, 0xd4,
      0x66, 0x8c, 0xae, 0xa9, 0xcc, 0xc3, 0x05, 0xe4, 0x20, 0x67, 0x47, 0x43, 0x5a, 0x64, 0x6b, 0x25,
      0x5a, 0xb3, 0x8c, 0xd9, 0xfb, 0x18, 0xba, 0xb8, 0x5b, 0xd0, 0x44, 0x52, 0x5f, 0x45, 0x3c, 0x21,
      0xf7, 0xa1, 0xac, 0x32, 0x8b, 0x71, 0xab, 0x6f, 0x08, 0xbe, 0x9f, 0x13, 0x7c, 0xff, 0x51, 0xb2,
      0xf4, 0xca, 0x2a, 0xeb, 0xfd, 0xea, 0x98, 0x9d, 0x78, 0x1f, 0x4f, 0x18, 0x0d, 0x98, 0x20, 0x31,
      0xb4, 0xe6, 0x54, 0xb0, 0x44, 0x99, 0x9b, 0x29, 0x15, 0x70, 0x33, 0x60, 0x00, 0xb4, 0x4c, 0x2e,
      0x01, 0x0c, 0xcf, 0x23, 0x5a, 0xb9, 0x00, 0xb4, 0x26, 0xda, 0x47, 0xb0, 0x29, 0xd4, 0xe2, 0x28,
      0x61, 0x02, 0xd9, 0xb9, 0x98, 0x88, 0x36, 0x00, 0xfa, 0x58, 0xa6, 0x88, 0x09, 0xce, 0x95, 0xa5,
      0xfc, 0xd7, 0x7c, 0x2c, 0xb4, 0xef, 0x71, 0xae, 0x48, 0x08, 0x0d, 0x95, 0x49, 0x03, 0x55, 0x2b,
      0x00, 0xca, 0x51, 0x99, 0x44, 0xa0, 0x17, 0xd0, 0x11, 0xcc, 0x67, 0xd1, 0x5c, 0x59, 0xb4, 0x7a,
      0x01, 0x68, 0xed, 0x1c, 0x02, 0x21, 0x25, 0xb4, 0x57, 0x7d, 0xc0, 0x84, 0x89, 0xc2, 0x8a, 0x4b,
      0x6b, 0x62, 0xfb, 0x8a, 0x09, 0x13, 0x64, 0x00, 0x66, 0xa8, 0xe9, 0x88, 0xc7, 0x58, 0x69, 0x5a,
      0x87, 0x6f, 0xac, 0x31, 0xb5, 0xd6, 0x33, 0x71, 0x8b, 0x32, 0xb9, 0x67, 0x0a, 0xfc, 0x2c, 0x8a,
      0x23, 0x53, 0x7d, 0xaa, 0x58, 0x8e, 0x4f, 0xf4, 0x98, 0xdc, 0x01, 0x2d, 0x8f, 0x53, 0xc9, 0x02,
      0xac, 0x36, 0x55, 0xcf, 0x09, 0xa9, 0xfc, 0x5a, 0xb2, 0x80, 0xbc, 0x0d, 0xcd, 0x55, 0x37, 0x86,
      0x95, 0xa2, 0xea, 0xad, 0x15, 0xba, 0x99, 0x60, 0x99, 0x12, 0x14, 0x39, 0xbe, 0xed, 0x99, 0x41,
      0xef, 0x08, 0x3a, 0xab, 0x9c, 0x1d, 0xf1, 0x60, 0x49, 0xde, 0x87, 0x8a, 0xca, 0xa4, 0x5b, 0xda,
      0xaf, 0x1c, 0xb4, 0x0e, 0xdd, 0x6d, 0x42, 0x59, 0x53, 0x82, 0xa7, 0x17, 0xf5, 0x22, 0xd3, 0xa7,
      0x19, 0x02, 0xfc, 0x00, 0xea, 0x53, 0x4c, 0x7a, 0x9b, 0xe5, 0xdb, 0x7b, 0x37, 0x48, 0xc1, 0xb3,
      0xeb, 0x72, 0xa8, 0xf2, 0xcb, 0x40, 0xfd, 0x56, 0x35, 0x58, 0x67, 0xd9, 0x09, 0x0f, 0xc9, 0x0c,
      0x1c, 0x6a, 0x52, 0xc4, 0x82, 0x15, 0x91, 0x7c, 0x39, 0x04, 0x09, 0xa0, 0xae, 0xf8, 0x3c, 0xf2,
      0x73, 0x57, 0x5f, 0x37, 0xb3, 0xa3, 0xed, 0x55, 0x27, 0x52, 0xd9, 0xe8, 0x44, 0xde, 0xbd, 0x11,
      0xaf, 0x55, 0xfc, 0xa9, 0x5b, 0xd1, 0xb5, 0x51, 0x77, 0x6a, 0xc5, 0xd5, 0x1d, 0x1d, 0x76, 0x2a,
      0x1b, 0x47, 0x49, 0xc0, 0x32, 0xcc, 0xd3, 0x8e, 0xce, 0xe3, 0x63, 0x3d, 0xbc, 0x41, 0xba, 0x4e,
      0xb1, 0xa4, 0x7b, 0x0f, 0x9a, 0x33, 0x1e, 0x5a, 0x47, 0x1a, 0xe8, 0x48, 0x63, 0xc6, 0x43, 0xe3,
      0x89, 0x0b, 0x8e, 0x60, 0x31, 0x5f, 0xb0, 0x00, 0xd3, 0xa6, 0xe1, 0xe5, 0xc3, 0xde, 0x1f, 0x35,
      0x53, 0x37, 0x3d, 0xc3, 0x06, 0xfa, 0xb2, 0x37, 0x9a, 0x7b, 0x94, 0xf1, 0xa1, 0xa1, 0x69, 0xc8,
      0x3e, 0x2a, 0xb4, 0x4c, 0x6e, 0x43, 0x5d, 0x33, 0x63, 0x2a, 0x6d, 0x0b, 0x6e, 0x47, 0xa4, 0x0f,
      0xbb, 0x7e, 0x1a, 0xa7, 0x33, 0xaa, 0xa2, 0x05, 0x1b, 0xaf, 0x12, 0xd2, 0xfc, 0x9f, 0x37, 0xd7,
      0x53, 0x8f, 0x6d, 0x6a, 0xde, 0x87, 0x9a, 0xc9, 0xfe, 0xda, 0x7f, 0x66, 0xbf, 0x99, 0x24, 0x0f,
      0xa0, 0x3a, 0xe3, 0xa1, 0x74, 0xeb, 0x18, 0x66, 0xe4, 0x46, 0x35, 0x3f, 0xe1, 0xa1, 0x87, 0xf3,
      0x9b, 0xff, 0xdc, 0x29, 0xf0, 0x9f, 0xff, 0x00, 0x3b, 0x3e, 0x4f, 0x94, 0xa0, 0xbe, 0x1a, 0xe7,
      0xe9, 0xd6, 0x28, 0x2c, 0xdd, 0xba, 0x39, 0x96, 0x55, 0x6c, 0x31, 0x5d, 0x73, 0x9b, 0xe9, 0xb6,
      0x43, 0x0e, 0x8a, 0x0d, 0xb9, 0x9b, 0x45, 0xa3, 0xf5, 0x7f, 0x14, 0x8d, 0xcd, 0x7c, 0x6b, 0x6f,
      0xe5, 0xdb, 0xe8, 0xe7, 0xd2, 0xef, 0x7f, 0xbf, 0x53, 0x82, 0x96, 0xcf, 0xe3, 0xdc, 0x87, 0x51,
      0xfe, 0x5e, 0x56, 0xfc, 0xb4, 0xf4, 0xcd, 0xd3, 0x97, 0xf6, 0x62, 0x35, 0x08, 0x59, 0x62, 0x5e,
      0xec, 0x83, 0x90, 0x0f, 0xec, 0x33, 0xfd, 0x48, 0x7f, 0x17, 0xc3, 0x1f, 0xcb, 0x95, 0xd1, 0xb3,
      0x67, 0xbf, 0x94, 0x1d, 0xdd, 0x4d, 0xf6, 0xcf, 0x87, 0x7f, 0x1a, 0xe9, 0xf9, 0xf9, 0xf0, 0xaf,
      0xf2, 0xae, 0x95, 0x9e, 0x3f, 0x3e, 0x1d, 0x69, 0x7b, 0x9a, 0xb4, 0xfe, 0x29, 0x37, 0xb4, 0xf6,
      0xe1, 0xc3, 0xf3, 0xe1, 0xa4, 0x8e, 0x36, 0x3f, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff, 0x78, 0x74,
      0x21, 0x3f, 0x53, 0x10, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/base/v1/options.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: base/v1/options.proto
      package basev1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      descriptorpb "google.golang.org/protobuf/types/descriptorpb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      var E_BytesSize = &proto.ExtensionDesc{
      ExtendedType: (*descriptorpb.FieldOptions)(nil),
      ExtensionType: (*uint32)(nil),
      Field: 50000,
      Name: "base.v1.bytes_size",
      Tag: "varint,50000,opt,name=bytes_size",
      Filename: "base/v1/options.proto",
      }
      func init() {
      proto.RegisterExtension(E_BytesSize)
      }
      func init() { proto.RegisterFile("base/v1/options.proto", fileDescriptor_35190a910ebf5bf3) }
      var fileDescriptor_35190a910ebf5bf3 = []byte{
      // 254 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4d, 0x4a, 0x2c, 0x4e,
      0xd5, 0x2f, 0x33, 0xd4, 0xcf, 0x2f, 0x28, 0xc9, 0xcc, 0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f,
      0xc9, 0x17, 0x62, 0x07, 0x09, 0xeb, 0x95, 0x19, 0x4a, 0x29, 0xa4, 0xe7, 0xe7, 0xa7, 0xe7, 0xa4,
      0xea, 0x83, 0x85, 0x93, 0x4a, 0xd3, 0xf4, 0x53, 0x52, 0x8b, 0x93, 0x8b, 0x32, 0x0b, 0x4a, 0xf2,
      0x8b, 0x20, 0x4a, 0xad, 0xec, 0xb8, 0xb8, 0x92, 0x2a, 0x4b, 0x52, 0x8b, 0xe3, 0x8b, 0x33, 0xab,
      0x52, 0x85, 0x64, 0xf5, 0x20, 0x1a, 0xf4, 0x60, 0x1a, 0xf4, 0xdc, 0x32, 0x53, 0x73, 0x52, 0xfc,
      0x21, 0xa6, 0x4b, 0x5c, 0x68, 0x63, 0x56, 0x60, 0xd4, 0xe0, 0x0d, 0xe2, 0x04, 0x6b, 0x09, 0xce,
      0xac, 0x4a, 0x75, 0x5a, 0xce, 0xc8, 0xc5, 0x9d, 0x9c, 0x9f, 0xab, 0x07, 0xb5, 0xd1, 0x89, 0x07,
      0xaa, 0x36, 0x00, 0x64, 0x40, 0x00, 0x63, 0x94, 0x6f, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e,
      0x72, 0x7e, 0xae, 0xbe, 0x73, 0x62, 0x4a, 0x69, 0x72, 0x6a, 0x69, 0xb1, 0x6f, 0x6a, 0x49, 0x62,
      0x59, 0x6a, 0x51, 0x71, 0x2a, 0x58, 0x51, 0x72, 0x7e, 0x8e, 0x3e, 0x48, 0x04, 0xce, 0x49, 0x4f,
      0xcd, 0x83, 0x38, 0x58, 0x3f, 0x3d, 0x5f, 0x1f, 0xea, 0x41, 0x6b, 0x10, 0x5d, 0x66, 0xb8, 0x88,
      0x89, 0xd9, 0x29, 0x22, 0x62, 0x15, 0x13, 0xbb, 0x13, 0xc8, 0xba, 0x30, 0xc3, 0x53, 0x10, 0x56,
      0x4c, 0x98, 0xe1, 0x23, 0x26, 0x61, 0x28, 0x2b, 0xc6, 0x3d, 0xc0, 0x09, 0x64, 0x5e, 0x4a, 0x62,
      0x49, 0xe2, 0x2b, 0x26, 0x0e, 0x90, 0xa8, 0x95, 0x55, 0x98, 0x61, 0x12, 0x1b, 0xd8, 0x4c, 0x63,
      0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa9, 0xe7, 0x48, 0x7a, 0x34, 0x01, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/base/v1/resource.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: base/v1/resource.proto
      package basev1
      import (
      fmt "fmt"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base"
      github_com_CaduceusMetaverseProtocol_MetaTypes_types "github.com/CaduceusMetaverseProtocol/MetaTypes/types"
      proto "github.com/gogo/protobuf/proto"
      _ "github.com/gogo/protobuf/types"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type Bytes32 struct {
      Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *Bytes32) Reset() { *m = Bytes32{} }
      func (m *Bytes32) String() string { return proto.CompactTextString(m) }
      func (*Bytes32) ProtoMessage() {}
      func (*Bytes32) Descriptor() ([]byte, []int) {
      return fileDescriptor_fc4a30c7a1e70305, []int{0}
      }
      func (m *Bytes32) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_Bytes32.Unmarshal(m, b)
      }
      func (m *Bytes32) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_Bytes32.Marshal(b, m, deterministic)
      }
      func (m *Bytes32) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Bytes32.Merge(m, src)
      }
      func (m *Bytes32) XXX_Size() int {
      return xxx_messageInfo_Bytes32.Size(m)
      }
      func (m *Bytes32) XXX_DiscardUnknown() {
      xxx_messageInfo_Bytes32.DiscardUnknown(m)
      }
      var xxx_messageInfo_Bytes32 proto.InternalMessageInfo
      func (m *Bytes32) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      type BigInt struct {
      Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BigInt) Reset() { *m = BigInt{} }
      func (m *BigInt) String() string { return proto.CompactTextString(m) }
      func (*BigInt) ProtoMessage() {}
      func (*BigInt) Descriptor() ([]byte, []int) {
      return fileDescriptor_fc4a30c7a1e70305, []int{1}
      }
      func (m *BigInt) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BigInt.Unmarshal(m, b)
      }
      func (m *BigInt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BigInt.Marshal(b, m, deterministic)
      }
      func (m *BigInt) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BigInt.Merge(m, src)
      }
      func (m *BigInt) XXX_Size() int {
      return xxx_messageInfo_BigInt.Size(m)
      }
      func (m *BigInt) XXX_DiscardUnknown() {
      xxx_messageInfo_BigInt.DiscardUnknown(m)
      }
      var xxx_messageInfo_BigInt proto.InternalMessageInfo
      func (m *BigInt) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      type Hash struct {
      Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *Hash) Reset() { *m = Hash{} }
      func (m *Hash) String() string { return proto.CompactTextString(m) }
      func (*Hash) ProtoMessage() {}
      func (*Hash) Descriptor() ([]byte, []int) {
      return fileDescriptor_fc4a30c7a1e70305, []int{2}
      }
      func (m *Hash) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_Hash.Unmarshal(m, b)
      }
      func (m *Hash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_Hash.Marshal(b, m, deterministic)
      }
      func (m *Hash) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Hash.Merge(m, src)
      }
      func (m *Hash) XXX_Size() int {
      return xxx_messageInfo_Hash.Size(m)
      }
      func (m *Hash) XXX_DiscardUnknown() {
      xxx_messageInfo_Hash.DiscardUnknown(m)
      }
      var xxx_messageInfo_Hash proto.InternalMessageInfo
      func (m *Hash) GetHash() []byte {
      if m != nil {
      return m.Hash
      }
      return nil
      }
      type Address struct {
      Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *Address) Reset() { *m = Address{} }
      func (m *Address) String() string { return proto.CompactTextString(m) }
      func (*Address) ProtoMessage() {}
      func (*Address) Descriptor() ([]byte, []int) {
      return fileDescriptor_fc4a30c7a1e70305, []int{3}
      }
      func (m *Address) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_Address.Unmarshal(m, b)
      }
      func (m *Address) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_Address.Marshal(b, m, deterministic)
      }
      func (m *Address) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Address.Merge(m, src)
      }
      func (m *Address) XXX_Size() int {
      return xxx_messageInfo_Address.Size(m)
      }
      func (m *Address) XXX_DiscardUnknown() {
      xxx_messageInfo_Address.DiscardUnknown(m)
      }
      var xxx_messageInfo_Address proto.InternalMessageInfo
      func (m *Address) GetAddress() []byte {
      if m != nil {
      return m.Address
      }
      return nil
      }
      type RLPData struct {
      Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *RLPData) Reset() { *m = RLPData{} }
      func (m *RLPData) String() string { return proto.CompactTextString(m) }
      func (*RLPData) ProtoMessage() {}
      func (*RLPData) Descriptor() ([]byte, []int) {
      return fileDescriptor_fc4a30c7a1e70305, []int{4}
      }
      func (m *RLPData) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_RLPData.Unmarshal(m, b)
      }
      func (m *RLPData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_RLPData.Marshal(b, m, deterministic)
      }
      func (m *RLPData) XXX_Merge(src proto.Message) {
      xxx_messageInfo_RLPData.Merge(m, src)
      }
      func (m *RLPData) XXX_Size() int {
      return xxx_messageInfo_RLPData.Size(m)
      }
      func (m *RLPData) XXX_DiscardUnknown() {
      xxx_messageInfo_RLPData.DiscardUnknown(m)
      }
      var xxx_messageInfo_RLPData proto.InternalMessageInfo
      func (m *RLPData) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      type Account struct {
      Address *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,1,opt,name=address,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"address,omitempty"`
      Nonce uint64 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
      Balance *github_com_CaduceusMetaverseProtocol_MetaTypes_types.BigInt `protobuf:"bytes,3,opt,name=balance,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.BigInt" json:"balance,omitempty"`
      StateRoot *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,4,opt,name=state_root,json=stateRoot,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"state_root,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *Account) Reset() { *m = Account{} }
      func (m *Account) String() string { return proto.CompactTextString(m) }
      func (*Account) ProtoMessage() {}
      func (*Account) Descriptor() ([]byte, []int) {
      return fileDescriptor_fc4a30c7a1e70305, []int{5}
      }
      func (m *Account) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_Account.Unmarshal(m, b)
      }
      func (m *Account) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_Account.Marshal(b, m, deterministic)
      }
      func (m *Account) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Account.Merge(m, src)
      }
      func (m *Account) XXX_Size() int {
      return xxx_messageInfo_Account.Size(m)
      }
      func (m *Account) XXX_DiscardUnknown() {
      xxx_messageInfo_Account.DiscardUnknown(m)
      }
      var xxx_messageInfo_Account proto.InternalMessageInfo
      func (m *Account) GetNonce() uint64 {
      if m != nil {
      return m.Nonce
      }
      return 0
      }
      type Bloom struct {
      Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *Bloom) Reset() { *m = Bloom{} }
      func (m *Bloom) String() string { return proto.CompactTextString(m) }
      func (*Bloom) ProtoMessage() {}
      func (*Bloom) Descriptor() ([]byte, []int) {
      return fileDescriptor_fc4a30c7a1e70305, []int{6}
      }
      func (m *Bloom) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_Bloom.Unmarshal(m, b)
      }
      func (m *Bloom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_Bloom.Marshal(b, m, deterministic)
      }
      func (m *Bloom) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Bloom.Merge(m, src)
      }
      func (m *Bloom) XXX_Size() int {
      return xxx_messageInfo_Bloom.Size(m)
      }
      func (m *Bloom) XXX_DiscardUnknown() {
      xxx_messageInfo_Bloom.DiscardUnknown(m)
      }
      var xxx_messageInfo_Bloom proto.InternalMessageInfo
      func (m *Bloom) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      type AccessTuple struct {
      Address *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,1,opt,name=address,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"address,omitempty"`
      StorageKeys []github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,2,rep,name=storage_keys,json=storageKeys,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"storage_keys,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *AccessTuple) Reset() { *m = AccessTuple{} }
      func (m *AccessTuple) String() string { return proto.CompactTextString(m) }
      func (*AccessTuple) ProtoMessage() {}
      func (*AccessTuple) Descriptor() ([]byte, []int) {
      return fileDescriptor_fc4a30c7a1e70305, []int{7}
      }
      func (m *AccessTuple) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_AccessTuple.Unmarshal(m, b)
      }
      func (m *AccessTuple) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_AccessTuple.Marshal(b, m, deterministic)
      }
      func (m *AccessTuple) XXX_Merge(src proto.Message) {
      xxx_messageInfo_AccessTuple.Merge(m, src)
      }
      func (m *AccessTuple) XXX_Size() int {
      return xxx_messageInfo_AccessTuple.Size(m)
      }
      func (m *AccessTuple) XXX_DiscardUnknown() {
      xxx_messageInfo_AccessTuple.DiscardUnknown(m)
      }
      var xxx_messageInfo_AccessTuple proto.InternalMessageInfo
      type AccessList struct {
      AccessList []*AccessTuple `protobuf:"bytes,1,rep,name=access_list,json=accessList,proto3" json:"access_list,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *AccessList) Reset() { *m = AccessList{} }
      func (m *AccessList) String() string { return proto.CompactTextString(m) }
      func (*AccessList) ProtoMessage() {}
      func (*AccessList) Descriptor() ([]byte, []int) {
      return fileDescriptor_fc4a30c7a1e70305, []int{8}
      }
      func (m *AccessList) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_AccessList.Unmarshal(m, b)
      }
      func (m *AccessList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_AccessList.Marshal(b, m, deterministic)
      }
      func (m *AccessList) XXX_Merge(src proto.Message) {
      xxx_messageInfo_AccessList.Merge(m, src)
      }
      func (m *AccessList) XXX_Size() int {
      return xxx_messageInfo_AccessList.Size(m)
      }
      func (m *AccessList) XXX_DiscardUnknown() {
      xxx_messageInfo_AccessList.DiscardUnknown(m)
      }
      var xxx_messageInfo_AccessList proto.InternalMessageInfo
      func (m *AccessList) GetAccessList() []*AccessTuple {
      if m != nil {
      return m.AccessList
      }
      return nil
      }
      func init() {
      proto.RegisterType((*Bytes32)(nil), "base.v1.Bytes32")
      proto.RegisterType((*BigInt)(nil), "base.v1.BigInt")
      proto.RegisterType((*Hash)(nil), "base.v1.Hash")
      proto.RegisterType((*Address)(nil), "base.v1.Address")
      proto.RegisterType((*RLPData)(nil), "base.v1.RLPData")
      proto.RegisterType((*Account)(nil), "base.v1.Account")
      proto.RegisterType((*Bloom)(nil), "base.v1.Bloom")
      proto.RegisterType((*AccessTuple)(nil), "base.v1.AccessTuple")
      proto.RegisterType((*AccessList)(nil), "base.v1.AccessList")
      }
      func init() { proto.RegisterFile("base/v1/resource.proto", fileDescriptor_fc4a30c7a1e70305) }
      var fileDescriptor_fc4a30c7a1e70305 = []byte{
      // 521 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x4f, 0x6b, 0x13, 0x41,
      0x14, 0x67, 0xb7, 0x69, 0x57, 0x5f, 0x5a, 0x2a, 0x6b, 0x91, 0x35, 0x2a, 0x09, 0xf1, 0xd2, 0x53,
      0x96, 0x6d, 0xf1, 0x60, 0xab, 0x68, 0xa6, 0x82, 0x8a, 0x2d, 0x84, 0xa5, 0x84, 0x22, 0x85, 0x30,
      0x99, 0x3c, 0x37, 0xb1, 0x9b, 0x7d, 0x61, 0x67, 0x36, 0x90, 0xaf, 0xe3, 0x49, 0xfc, 0x28, 0x7e,
      0x84, 0x1c, 0x72, 0xf0, 0xe0, 0x41, 0xfc, 0x10, 0x32, 0xb3, 0x7f, 0x8a, 0x92, 0x83, 0x14, 0xf1,
      0x92, 0xbc, 0xf7, 0x7b, 0x6f, 0x7e, 0xbf, 0xdf, 0xbc, 0xc7, 0x2c, 0xdc, 0x1b, 0x72, 0x89, 0xfe,
      0x3c, 0xf0, 0x53, 0x94, 0x94, 0xa5, 0x02, 0x3b, 0xb3, 0x94, 0x14, 0xb9, 0x8e, 0xc6, 0x3b, 0xf3,
      0xa0, 0xd1, 0x8c, 0x88, 0xa2, 0x18, 0x7d, 0x03, 0x0f, 0xb3, 0x0f, 0xbe, 0x9a, 0x4c, 0x51, 0x2a,
      0x3e, 0x9d, 0xe5, 0x9d, 0x8d, 0xfb, 0x7f, 0x36, 0xf0, 0x64, 0x51, 0x94, 0x76, 0x0d, 0x79, 0x44,
      0x11, 0xe5, 0x40, 0xfb, 0x11, 0x38, 0x6c, 0xa1, 0x50, 0x1e, 0x1e, 0xb8, 0x2e, 0xd4, 0x46, 0x5c,
      0x71, 0xcf, 0x6a, 0x59, 0xfb, 0xdb, 0xa1, 0x89, 0xdb, 0x0f, 0x61, 0x8b, 0x4d, 0xa2, 0xb7, 0x89,
      0x5a, 0x5b, 0x6d, 0x40, 0xed, 0x0d, 0x97, 0x63, 0x5d, 0x1b, 0x73, 0x39, 0x2e, 0x6b, 0x3a, 0x6e,
      0x3f, 0x06, 0xa7, 0x3b, 0x1a, 0xa5, 0x28, 0xa5, 0xeb, 0x81, 0xc3, 0xf3, 0xb0, 0xe8, 0x28, 0x53,
      0xad, 0x1e, 0x9e, 0xf6, 0x5e, 0x71, 0xc5, 0xd7, 0xf2, 0x7f, 0xb7, 0xc1, 0xe9, 0x0a, 0x41, 0x59,
      0xa2, 0xdc, 0xf8, 0x77, 0x92, 0xfa, 0xc1, 0x9d, 0x4e, 0x31, 0x90, 0x4e, 0xa1, 0xc3, 0x5e, 0x2e,
      0x57, 0xcd, 0x67, 0xd1, 0x44, 0x8d, 0xb3, 0x61, 0x47, 0xd0, 0xd4, 0x3f, 0xe1, 0xa3, 0x4c, 0x60,
      0x26, 0xcf, 0x50, 0xf1, 0x39, 0xa6, 0x12, 0x7b, 0xfa, 0xca, 0x82, 0x62, 0x5f, 0x23, 0xe7, 0x8b,
      0x19, 0x4a, 0x5f, 0xe9, 0xdf, 0x92, 0xa1, 0x32, 0xe6, 0xee, 0xc1, 0x66, 0x42, 0x89, 0x40, 0xcf,
      0x6e, 0x59, 0xfb, 0xb5, 0x30, 0x4f, 0xdc, 0x8f, 0xe0, 0x0c, 0x79, 0xcc, 0x35, 0xbe, 0x61, 0x3c,
      0xec, 0x56, 0x1e, 0xf2, 0x29, 0xb1, 0x17, 0xcb, 0x55, 0xf3, 0xf8, 0x46, 0x16, 0x72, 0x82, 0xb0,
      0x14, 0x70, 0xaf, 0x00, 0xa4, 0xe2, 0x0a, 0x07, 0x29, 0x91, 0xf2, 0x6a, 0x46, 0x6e, 0xa7, 0x92,
      0xd3, 0x63, 0x67, 0xcf, 0x97, 0xab, 0xe6, 0xd3, 0x1b, 0x89, 0xe9, 0xe3, 0xe1, 0x6d, 0xc3, 0x1f,
      0x12, 0xa9, 0xf6, 0x03, 0xd8, 0x64, 0x31, 0xd1, 0x74, 0xed, 0x16, 0x7e, 0x5a, 0x50, 0xef, 0x0a,
      0x81, 0x52, 0x9e, 0x67, 0xb3, 0x18, 0xff, 0xf3, 0x26, 0x08, 0xb6, 0xa5, 0xa2, 0x94, 0x47, 0x38,
      0xb8, 0xc2, 0x85, 0xf4, 0xec, 0xd6, 0xc6, 0x3f, 0x9f, 0x44, 0xbd, 0x50, 0x78, 0x87, 0x0b, 0xd9,
      0x3e, 0x01, 0xc8, 0x6f, 0x7b, 0x3a, 0x91, 0xca, 0x7d, 0x02, 0x75, 0x6e, 0xb2, 0x41, 0x3c, 0x91,
      0xca, 0xb3, 0x8c, 0xfa, 0xde, 0xf5, 0x85, 0xaf, 0xe7, 0x12, 0x02, 0xaf, 0x8e, 0xb1, 0xcf, 0x16,
      0xd4, 0x05, 0x4d, 0xcb, 0x3e, 0xb6, 0x13, 0x16, 0x8f, 0xd9, 0x18, 0xe9, 0x59, 0xef, 0xcf, 0xfe,
      0xda, 0x6d, 0x95, 0x44, 0x98, 0xe4, 0x4f, 0xda, 0x8f, 0xc8, 0x2f, 0x3e, 0x12, 0xc7, 0xfa, 0x7f,
      0x1e, 0x7c, 0xb2, 0x37, 0xd8, 0xc5, 0xc5, 0x17, 0xdb, 0x61, 0x5a, 0xaf, 0x1f, 0x7c, 0xcd, 0xa3,
      0xcb, 0x7e, 0xf0, 0xcd, 0xbe, 0x5b, 0x44, 0x97, 0xaf, 0x7b, 0x4c, 0xf3, 0xe9, 0x9d, 0xfe, 0xb0,
      0x6f, 0x69, 0xf4, 0xe8, 0xa8, 0x1f, 0x0c, 0xb7, 0x0c, 0xe7, 0xe1, 0xaf, 0x00, 0x00, 0x00, 0xff,
      0xff, 0x38, 0x21, 0x87, 0xeb, 0x78, 0x04, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/crypter/v1/request_response.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: crypter/v1/request_response.proto
      package crypterv1
      import (
      fmt "fmt"
      v1 "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base/v1"
      proto "github.com/gogo/protobuf/proto"
      _ "github.com/gogo/protobuf/types"
      _ "google.golang.org/protobuf/types/known/fieldmaskpb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type BatchSignRequest struct {
      Privk [][]byte `protobuf:"bytes,1,rep,name=privk,proto3" json:"privk,omitempty"`
      Data [][]byte `protobuf:"bytes,2,rep,name=data,proto3" json:"data,omitempty"`
      CryptType CryptType `protobuf:"varint,3,opt,name=crypt_type,json=cryptType,proto3,enum=crypter.v1.CryptType" json:"crypt_type,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchSignRequest) Reset() { *m = BatchSignRequest{} }
      func (m *BatchSignRequest) String() string { return proto.CompactTextString(m) }
      func (*BatchSignRequest) ProtoMessage() {}
      func (*BatchSignRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_c54a21c4b8afb3e6, []int{0}
      }
      func (m *BatchSignRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchSignRequest.Unmarshal(m, b)
      }
      func (m *BatchSignRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchSignRequest.Marshal(b, m, deterministic)
      }
      func (m *BatchSignRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchSignRequest.Merge(m, src)
      }
      func (m *BatchSignRequest) XXX_Size() int {
      return xxx_messageInfo_BatchSignRequest.Size(m)
      }
      func (m *BatchSignRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchSignRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchSignRequest proto.InternalMessageInfo
      func (m *BatchSignRequest) GetPrivk() [][]byte {
      if m != nil {
      return m.Privk
      }
      return nil
      }
      func (m *BatchSignRequest) GetData() [][]byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      func (m *BatchSignRequest) GetCryptType() CryptType {
      if m != nil {
      return m.CryptType
      }
      return CryptType_CRYPT_TYPE_INVALID
      }
      type BatchSignResponse struct {
      Signature [][]byte `protobuf:"bytes,1,rep,name=signature,proto3" json:"signature,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchSignResponse) Reset() { *m = BatchSignResponse{} }
      func (m *BatchSignResponse) String() string { return proto.CompactTextString(m) }
      func (*BatchSignResponse) ProtoMessage() {}
      func (*BatchSignResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_c54a21c4b8afb3e6, []int{1}
      }
      func (m *BatchSignResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchSignResponse.Unmarshal(m, b)
      }
      func (m *BatchSignResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchSignResponse.Marshal(b, m, deterministic)
      }
      func (m *BatchSignResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchSignResponse.Merge(m, src)
      }
      func (m *BatchSignResponse) XXX_Size() int {
      return xxx_messageInfo_BatchSignResponse.Size(m)
      }
      func (m *BatchSignResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchSignResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchSignResponse proto.InternalMessageInfo
      func (m *BatchSignResponse) GetSignature() [][]byte {
      if m != nil {
      return m.Signature
      }
      return nil
      }
      type BatchVerifyRequest struct {
      Pubkey [][]byte `protobuf:"bytes,1,rep,name=pubkey,proto3" json:"pubkey,omitempty"`
      Signature [][]byte `protobuf:"bytes,2,rep,name=signature,proto3" json:"signature,omitempty"`
      CryptType CryptType `protobuf:"varint,3,opt,name=crypt_type,json=cryptType,proto3,enum=crypter.v1.CryptType" json:"crypt_type,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchVerifyRequest) Reset() { *m = BatchVerifyRequest{} }
      func (m *BatchVerifyRequest) String() string { return proto.CompactTextString(m) }
      func (*BatchVerifyRequest) ProtoMessage() {}
      func (*BatchVerifyRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_c54a21c4b8afb3e6, []int{2}
      }
      func (m *BatchVerifyRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchVerifyRequest.Unmarshal(m, b)
      }
      func (m *BatchVerifyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchVerifyRequest.Marshal(b, m, deterministic)
      }
      func (m *BatchVerifyRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchVerifyRequest.Merge(m, src)
      }
      func (m *BatchVerifyRequest) XXX_Size() int {
      return xxx_messageInfo_BatchVerifyRequest.Size(m)
      }
      func (m *BatchVerifyRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchVerifyRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchVerifyRequest proto.InternalMessageInfo
      func (m *BatchVerifyRequest) GetPubkey() [][]byte {
      if m != nil {
      return m.Pubkey
      }
      return nil
      }
      func (m *BatchVerifyRequest) GetSignature() [][]byte {
      if m != nil {
      return m.Signature
      }
      return nil
      }
      func (m *BatchVerifyRequest) GetCryptType() CryptType {
      if m != nil {
      return m.CryptType
      }
      return CryptType_CRYPT_TYPE_INVALID
      }
      type BatchVerifyResponse struct {
      Verified []bool `protobuf:"varint,1,rep,packed,name=verified,proto3" json:"verified,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchVerifyResponse) Reset() { *m = BatchVerifyResponse{} }
      func (m *BatchVerifyResponse) String() string { return proto.CompactTextString(m) }
      func (*BatchVerifyResponse) ProtoMessage() {}
      func (*BatchVerifyResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_c54a21c4b8afb3e6, []int{3}
      }
      func (m *BatchVerifyResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchVerifyResponse.Unmarshal(m, b)
      }
      func (m *BatchVerifyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchVerifyResponse.Marshal(b, m, deterministic)
      }
      func (m *BatchVerifyResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchVerifyResponse.Merge(m, src)
      }
      func (m *BatchVerifyResponse) XXX_Size() int {
      return xxx_messageInfo_BatchVerifyResponse.Size(m)
      }
      func (m *BatchVerifyResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchVerifyResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchVerifyResponse proto.InternalMessageInfo
      func (m *BatchVerifyResponse) GetVerified() []bool {
      if m != nil {
      return m.Verified
      }
      return nil
      }
      type BatchRecoverRequest struct {
      Data [][]byte `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
      Signature [][]byte `protobuf:"bytes,2,rep,name=signature,proto3" json:"signature,omitempty"`
      CryptType CryptType `protobuf:"varint,3,opt,name=crypt_type,json=cryptType,proto3,enum=crypter.v1.CryptType" json:"crypt_type,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchRecoverRequest) Reset() { *m = BatchRecoverRequest{} }
      func (m *BatchRecoverRequest) String() string { return proto.CompactTextString(m) }
      func (*BatchRecoverRequest) ProtoMessage() {}
      func (*BatchRecoverRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_c54a21c4b8afb3e6, []int{4}
      }
      func (m *BatchRecoverRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchRecoverRequest.Unmarshal(m, b)
      }
      func (m *BatchRecoverRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchRecoverRequest.Marshal(b, m, deterministic)
      }
      func (m *BatchRecoverRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchRecoverRequest.Merge(m, src)
      }
      func (m *BatchRecoverRequest) XXX_Size() int {
      return xxx_messageInfo_BatchRecoverRequest.Size(m)
      }
      func (m *BatchRecoverRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchRecoverRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchRecoverRequest proto.InternalMessageInfo
      func (m *BatchRecoverRequest) GetData() [][]byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      func (m *BatchRecoverRequest) GetSignature() [][]byte {
      if m != nil {
      return m.Signature
      }
      return nil
      }
      func (m *BatchRecoverRequest) GetCryptType() CryptType {
      if m != nil {
      return m.CryptType
      }
      return CryptType_CRYPT_TYPE_INVALID
      }
      type BatchRecoverResponse struct {
      Pubkey [][]byte `protobuf:"bytes,1,rep,name=pubkey,proto3" json:"pubkey,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchRecoverResponse) Reset() { *m = BatchRecoverResponse{} }
      func (m *BatchRecoverResponse) String() string { return proto.CompactTextString(m) }
      func (*BatchRecoverResponse) ProtoMessage() {}
      func (*BatchRecoverResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_c54a21c4b8afb3e6, []int{5}
      }
      func (m *BatchRecoverResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchRecoverResponse.Unmarshal(m, b)
      }
      func (m *BatchRecoverResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchRecoverResponse.Marshal(b, m, deterministic)
      }
      func (m *BatchRecoverResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchRecoverResponse.Merge(m, src)
      }
      func (m *BatchRecoverResponse) XXX_Size() int {
      return xxx_messageInfo_BatchRecoverResponse.Size(m)
      }
      func (m *BatchRecoverResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchRecoverResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchRecoverResponse proto.InternalMessageInfo
      func (m *BatchRecoverResponse) GetPubkey() [][]byte {
      if m != nil {
      return m.Pubkey
      }
      return nil
      }
      type BatchRecoverTxRequest struct {
      RawTx []*v1.MetaTxBase `protobuf:"bytes,1,rep,name=raw_tx,json=rawTx,proto3" json:"raw_tx,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchRecoverTxRequest) Reset() { *m = BatchRecoverTxRequest{} }
      func (m *BatchRecoverTxRequest) String() string { return proto.CompactTextString(m) }
      func (*BatchRecoverTxRequest) ProtoMessage() {}
      func (*BatchRecoverTxRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_c54a21c4b8afb3e6, []int{6}
      }
      func (m *BatchRecoverTxRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchRecoverTxRequest.Unmarshal(m, b)
      }
      func (m *BatchRecoverTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchRecoverTxRequest.Marshal(b, m, deterministic)
      }
      func (m *BatchRecoverTxRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchRecoverTxRequest.Merge(m, src)
      }
      func (m *BatchRecoverTxRequest) XXX_Size() int {
      return xxx_messageInfo_BatchRecoverTxRequest.Size(m)
      }
      func (m *BatchRecoverTxRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchRecoverTxRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchRecoverTxRequest proto.InternalMessageInfo
      func (m *BatchRecoverTxRequest) GetRawTx() []*v1.MetaTxBase {
      if m != nil {
      return m.RawTx
      }
      return nil
      }
      type BatchRecoverTxResponse struct {
      RecoverdTx []*v1.MetaTxBase `protobuf:"bytes,1,rep,name=recoverd_tx,json=recoverdTx,proto3" json:"recoverd_tx,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchRecoverTxResponse) Reset() { *m = BatchRecoverTxResponse{} }
      func (m *BatchRecoverTxResponse) String() string { return proto.CompactTextString(m) }
      func (*BatchRecoverTxResponse) ProtoMessage() {}
      func (*BatchRecoverTxResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_c54a21c4b8afb3e6, []int{7}
      }
      func (m *BatchRecoverTxResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchRecoverTxResponse.Unmarshal(m, b)
      }
      func (m *BatchRecoverTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchRecoverTxResponse.Marshal(b, m, deterministic)
      }
      func (m *BatchRecoverTxResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchRecoverTxResponse.Merge(m, src)
      }
      func (m *BatchRecoverTxResponse) XXX_Size() int {
      return xxx_messageInfo_BatchRecoverTxResponse.Size(m)
      }
      func (m *BatchRecoverTxResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchRecoverTxResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchRecoverTxResponse proto.InternalMessageInfo
      func (m *BatchRecoverTxResponse) GetRecoverdTx() []*v1.MetaTxBase {
      if m != nil {
      return m.RecoverdTx
      }
      return nil
      }
      func init() {
      proto.RegisterType((*BatchSignRequest)(nil), "crypter.v1.BatchSignRequest")
      proto.RegisterType((*BatchSignResponse)(nil), "crypter.v1.BatchSignResponse")
      proto.RegisterType((*BatchVerifyRequest)(nil), "crypter.v1.BatchVerifyRequest")
      proto.RegisterType((*BatchVerifyResponse)(nil), "crypter.v1.BatchVerifyResponse")
      proto.RegisterType((*BatchRecoverRequest)(nil), "crypter.v1.BatchRecoverRequest")
      proto.RegisterType((*BatchRecoverResponse)(nil), "crypter.v1.BatchRecoverResponse")
      proto.RegisterType((*BatchRecoverTxRequest)(nil), "crypter.v1.BatchRecoverTxRequest")
      proto.RegisterType((*BatchRecoverTxResponse)(nil), "crypter.v1.BatchRecoverTxResponse")
      }
      func init() { proto.RegisterFile("crypter/v1/request_response.proto", fileDescriptor_c54a21c4b8afb3e6) }
      var fileDescriptor_c54a21c4b8afb3e6 = []byte{
      // 492 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x93, 0xcf, 0x6a, 0xdb, 0x40,
      0x10, 0xc6, 0x91, 0xdc, 0x98, 0x64, 0x5c, 0x42, 0xab, 0x38, 0xc6, 0x35, 0x85, 0xba, 0x3a, 0x85,
      0x1e, 0x24, 0x94, 0xe6, 0x94, 0xde, 0xac, 0x43, 0x4f, 0x2d, 0x46, 0x11, 0x26, 0x94, 0x80, 0x59,
      0x49, 0x63, 0x45, 0xd8, 0xf2, 0xaa, 0xbb, 0x2b, 0x45, 0x3a, 0x14, 0xfa, 0x2c, 0x3d, 0xf6, 0x39,
      0x7a, 0xea, 0x63, 0xf4, 0xd8, 0xa7, 0x28, 0x2b, 0xad, 0xfc, 0x0f, 0x4a, 0xa1, 0x90, 0xdb, 0xcc,
      0x68, 0xe6, 0xfb, 0x7e, 0x3b, 0xda, 0x85, 0xd7, 0x21, 0xab, 0x32, 0x81, 0xcc, 0x2e, 0x1c, 0x9b,
      0xe1, 0xe7, 0x1c, 0xb9, 0x98, 0x33, 0xe4, 0x19, 0x5d, 0x73, 0xb4, 0x32, 0x46, 0x05, 0x35, 0x40,
      0xb5, 0x58, 0x85, 0x33, 0x1a, 0xc7, 0x94, 0xc6, 0x2b, 0xb4, 0xeb, 0x2f, 0x41, 0xbe, 0xb0, 0x17,
      0x09, 0xae, 0xa2, 0x79, 0x4a, 0xf8, 0xb2, 0xe9, 0x1e, 0xbd, 0x3a, 0xec, 0x10, 0x49, 0x8a, 0x5c,
      0x90, 0x34, 0x53, 0x0d, 0x46, 0x40, 0x38, 0x4a, 0xbb, 0x14, 0x05, 0x51, 0xb5, 0x17, 0x7b, 0x14,
      0x9c, 0xe6, 0x2c, 0x54, 0xee, 0x26, 0x83, 0x67, 0x13, 0x22, 0xc2, 0xfb, 0x9b, 0x24, 0x5e, 0x7b,
      0x0d, 0xa0, 0xd1, 0x87, 0xa3, 0x8c, 0x25, 0xc5, 0x72, 0xa8, 0x8d, 0x3b, 0x17, 0x4f, 0xbd, 0x26,
      0x31, 0x0c, 0x78, 0x12, 0x11, 0x41, 0x86, 0x7a, 0x5d, 0xac, 0x63, 0xe3, 0x0a, 0x1a, 0xfa, 0xb9,
      0xa8, 0x32, 0x1c, 0x76, 0xc6, 0xda, 0xc5, 0xe9, 0xe5, 0xb9, 0xb5, 0x3d, 0x90, 0xe5, 0xca, 0xd0,
      0xaf, 0x32, 0xf4, 0x4e, 0xc2, 0x36, 0x34, 0x1d, 0x78, 0xbe, 0xe3, 0xd9, 0x2c, 0xc3, 0x78, 0x09,
      0x27, 0x3c, 0x89, 0xd7, 0x44, 0xe4, 0x0c, 0x95, 0xf1, 0xb6, 0x60, 0x7e, 0xd5, 0xc0, 0xa8, 0x67,
      0x66, 0xc8, 0x92, 0x45, 0xd5, 0x92, 0x0e, 0xa0, 0x9b, 0xe5, 0xc1, 0x12, 0x2b, 0x35, 0xa1, 0xb2,
      0x7d, 0x31, 0xfd, 0x40, 0xec, 0xbf, 0xa9, 0xcf, 0xf6, 0x08, 0x14, 0xf7, 0x08, 0x8e, 0x0b, 0x59,
      0x49, 0x30, 0xaa, 0x21, 0x8e, 0xbd, 0x4d, 0x6e, 0x7e, 0x51, 0x23, 0x1e, 0x86, 0xb4, 0x40, 0xd6,
      0x52, 0xb7, 0x9b, 0xd4, 0x76, 0x36, 0xf9, 0x18, 0xc4, 0x16, 0xf4, 0xf7, 0xed, 0x15, 0xf2, 0x5f,
      0xb6, 0x66, 0xba, 0x70, 0xbe, 0xdb, 0xef, 0x97, 0x2d, 0xf0, 0x1b, 0xe8, 0x32, 0xf2, 0x30, 0x17,
      0x65, 0x3d, 0xd0, 0xbb, 0x3c, 0xb3, 0xe4, 0x25, 0x93, 0xbe, 0x1f, 0x50, 0x10, 0xbf, 0x9c, 0x10,
      0x8e, 0xde, 0x11, 0x23, 0x0f, 0x7e, 0x69, 0x7e, 0x84, 0xc1, 0xa1, 0x88, 0xb2, 0xbd, 0x82, 0x1e,
      0x6b, 0x8a, 0xd1, 0x3f, 0xa4, 0xa0, 0xed, 0xf3, 0xcb, 0xc9, 0x0f, 0x0d, 0x4e, 0x43, 0x9a, 0xee,
      0x1c, 0x76, 0xd2, 0x57, 0x5c, 0xad, 0xf2, 0x54, 0xde, 0xe4, 0xa9, 0xf6, 0xe9, 0x26, 0x4e, 0xc4,
      0x7d, 0x1e, 0x58, 0x21, 0x4d, 0x6d, 0x97, 0x44, 0x79, 0x88, 0x39, 0x97, 0xaa, 0x05, 0x32, 0xd5,
      0x14, 0xd2, 0x95, 0x2d, 0x2b, 0x9b, 0x24, 0xc6, 0x75, 0xf3, 0x94, 0xec, 0x98, 0xda, 0xdb, 0x57,
      0xf2, 0x4e, 0x85, 0x85, 0xf3, 0x4d, 0xef, 0xb8, 0xb7, 0xb7, 0xdf, 0x75, 0x70, 0x95, 0xff, 0xcc,
      0xf9, 0xb9, 0x49, 0xee, 0x66, 0xce, 0x2f, 0x7d, 0xb0, 0x4d, 0xee, 0xde, 0x4f, 0x27, 0x52, 0x5e,
      0xfe, 0xd1, 0xdf, 0x7a, 0x4f, 0x7d, 0xb8, 0xbe, 0x9e, 0x39, 0x41, 0xb7, 0x76, 0x79, 0xfb, 0x27,
      0x00, 0x00, 0xff, 0xff, 0xae, 0xa0, 0xe3, 0xb0, 0x11, 0x04, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/crypter/v1/resource.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: crypter/v1/resource.proto
      package crypterv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type CryptType int32
      const (
      CryptType_CRYPT_TYPE_INVALID CryptType = 0
      CryptType_CRYPT_TYPE_SECP256K1 CryptType = 1
      )
      var CryptType_name = map[int32]string{
      0: "CRYPT_TYPE_INVALID",
      1: "CRYPT_TYPE_SECP256K1",
      }
      var CryptType_value = map[string]int32{
      "CRYPT_TYPE_INVALID": 0,
      "CRYPT_TYPE_SECP256K1": 1,
      }
      func (x CryptType) String() string {
      return proto.EnumName(CryptType_name, int32(x))
      }
      func (CryptType) EnumDescriptor() ([]byte, []int) {
      return fileDescriptor_4b0ea4a37bc29af9, []int{0}
      }
      func init() {
      proto.RegisterEnum("crypter.v1.CryptType", CryptType_name, CryptType_value)
      }
      func init() { proto.RegisterFile("crypter/v1/resource.proto", fileDescriptor_4b0ea4a37bc29af9) }
      var fileDescriptor_4b0ea4a37bc29af9 = []byte{
      // 236 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0x2e, 0xaa, 0x2c,
      0x28, 0x49, 0x2d, 0xd2, 0x2f, 0x33, 0xd4, 0x2f, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5,
      0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x82, 0x4a, 0xe9, 0x95, 0x19, 0x6a, 0xd9, 0x72, 0x71,
      0x3a, 0x83, 0x78, 0x21, 0x95, 0x05, 0xa9, 0x42, 0x62, 0x5c, 0x42, 0xce, 0x41, 0x91, 0x01, 0x21,
      0xf1, 0x21, 0x91, 0x01, 0xae, 0xf1, 0x9e, 0x7e, 0x61, 0x8e, 0x3e, 0x9e, 0x2e, 0x02, 0x0c, 0x42,
      0x12, 0x5c, 0x22, 0x48, 0xe2, 0xc1, 0xae, 0xce, 0x01, 0x46, 0xa6, 0x66, 0xde, 0x86, 0x02, 0x8c,
      0x4e, 0x7b, 0x19, 0xb9, 0xf8, 0x92, 0xf3, 0x73, 0xf5, 0x10, 0x26, 0x3a, 0xf1, 0x06, 0x41, 0x6d,
      0x0b, 0x00, 0x59, 0x16, 0xc0, 0x18, 0x15, 0x9c, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c,
      0x9f, 0xab, 0xef, 0x9c, 0x98, 0x52, 0x9a, 0x9c, 0x5a, 0x5a, 0xec, 0x9b, 0x5a, 0x92, 0x58, 0x96,
      0x5a, 0x54, 0x0c, 0x51, 0x94, 0x9c, 0x9f, 0xa3, 0x0f, 0x12, 0x81, 0x73, 0xd2, 0x53, 0xf3, 0xf4,
      0xc1, 0x6e, 0xd5, 0x4f, 0xcf, 0xd7, 0x47, 0x78, 0xc4, 0x1a, 0xca, 0x2c, 0x33, 0x5c, 0xc4, 0xc4,
      0xec, 0x1c, 0x11, 0xb1, 0x8a, 0x89, 0xcb, 0x19, 0x6a, 0x71, 0x98, 0xe1, 0x29, 0x38, 0x27, 0x26,
      0xcc, 0xf0, 0x11, 0x93, 0x18, 0x82, 0x13, 0xe3, 0x1e, 0xe0, 0x04, 0x32, 0x3e, 0x25, 0xb1, 0x24,
      0xf1, 0x15, 0x13, 0x37, 0x54, 0xc2, 0xca, 0x2a, 0xcc, 0x30, 0x89, 0x0d, 0x6c, 0x8b, 0x31, 0x20,
      0x00, 0x00, 0xff, 0xff, 0xb6, 0xca, 0x79, 0x11, 0x2e, 0x01, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/crypter/v1/service.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: crypter/v1/service.proto
      package crypterv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("crypter/v1/service.proto", fileDescriptor_05ac8b6606ffe814) }
      var fileDescriptor_05ac8b6606ffe814 = []byte{
      // 317 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0x4f, 0x4a, 0xc3, 0x40,
      0x14, 0xc6, 0x6d, 0x04, 0xc1, 0x69, 0xe9, 0x62, 0x16, 0x22, 0xc5, 0x7f, 0xed, 0x01, 0x66, 0x18,
      0xdd, 0xd5, 0x5d, 0xba, 0x10, 0x04, 0x21, 0x34, 0x25, 0x54, 0x29, 0x48, 0x3a, 0x7d, 0xa6, 0x01,
      0xdb, 0xa9, 0x33, 0x93, 0xa1, 0xbd, 0x8e, 0x4b, 0xcf, 0xe0, 0x09, 0x3c, 0x84, 0x0b, 0x97, 0x9e,
      0x42, 0x9a, 0x99, 0xa4, 0x81, 0x12, 0x77, 0x79, 0xef, 0xfb, 0xcd, 0xef, 0x41, 0x3e, 0x74, 0xca,
      0xe5, 0x66, 0xa5, 0x41, 0x52, 0xc3, 0xa8, 0x02, 0x69, 0x52, 0x0e, 0x64, 0x25, 0x85, 0x16, 0x18,
      0xb9, 0x84, 0x18, 0xd6, 0xe9, 0x56, 0x28, 0x09, 0x6f, 0x19, 0x28, 0xfd, 0x2c, 0x41, 0xad, 0xc4,
      0x52, 0x39, 0xfc, 0xfa, 0xdb, 0x43, 0xed, 0x81, 0xa5, 0x42, 0xeb, 0xc1, 0xf7, 0xe8, 0xd8, 0x8f,
      0x35, 0x9f, 0x87, 0x69, 0xb2, 0xc4, 0x67, 0x64, 0xe7, 0x23, 0xe5, 0x7a, 0x68, 0x65, 0x9d, 0xf3,
      0x9a, 0xd4, 0x9e, 0xe8, 0x1d, 0xe0, 0x00, 0x35, 0xf3, 0x75, 0x04, 0x32, 0x7d, 0xd9, 0xe0, 0x8b,
      0x3d, 0xde, 0x06, 0x85, 0xef, 0xb2, 0x36, 0x2f, 0x8d, 0x21, 0x6a, 0xe5, 0xc1, 0x10, 0xb8, 0x30,
      0x20, 0xf1, 0xfe, 0x13, 0x97, 0x14, 0xce, 0xab, 0x7a, 0xa0, 0x94, 0x3e, 0xa2, 0x76, 0x35, 0x19,
      0xad, 0x71, 0xb7, 0xee, 0xd5, 0x68, 0x5d, 0x88, 0x7b, 0xff, 0x21, 0x85, 0xda, 0xff, 0x6c, 0xa0,
      0x36, 0x17, 0x8b, 0x0a, 0xeb, 0xb7, 0xdc, 0x9f, 0x0e, 0xb6, 0x0d, 0x04, 0x8d, 0xa7, 0x30, 0x49,
      0xf5, 0x3c, 0x9b, 0x12, 0x2e, 0x16, 0x74, 0x10, 0xcf, 0x32, 0x0e, 0x99, 0x7a, 0x00, 0x1d, 0x1b,
      0x90, 0xca, 0x42, 0x5c, 0xbc, 0xd2, 0xed, 0xa6, 0x1c, 0x12, 0x58, 0xd2, 0xbc, 0x40, 0x9a, 0x08,
      0xba, 0x6b, 0xf9, 0xd6, 0x7d, 0x1a, 0xf6, 0xee, 0x1d, 0x0e, 0xc6, 0xe3, 0x0f, 0x0f, 0xb9, 0x72,
      0x49, 0xc4, 0xbe, 0xca, 0x61, 0x12, 0xb1, 0x1f, 0xef, 0x64, 0x37, 0x4c, 0xee, 0x02, 0x7f, 0xab,
      0x9f, 0xc5, 0x3a, 0xfe, 0xf5, 0x9a, 0x2e, 0xe8, 0xf7, 0x23, 0x36, 0x3d, 0xca, 0xaf, 0xdc, 0xfc,
      0x05, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x94, 0xc4, 0x24, 0x71, 0x02, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/crypter/v1/service_grpc.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
      // versions:
      // - protoc-gen-go-grpc v1.2.0
      // - protoc (unknown)
      // source: crypter/v1/service.proto
      package crypterv1
      import (
      context "context"
      grpc "google.golang.org/grpc"
      codes "google.golang.org/grpc/codes"
      status "google.golang.org/grpc/status"
      )
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the grpc package it is being compiled against.
      // Requires gRPC-Go v1.32.0 or later.
      const _ = grpc.SupportPackageIsVersion7
      // CrypterServiceClient is the client API for CrypterService service.
      //
      // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
      type CrypterServiceClient interface {
      BatchSign(ctx context.Context, in *BatchSignRequest, opts ...grpc.CallOption) (*BatchSignResponse, error)
      BatchVerify(ctx context.Context, in *BatchVerifyRequest, opts ...grpc.CallOption) (*BatchVerifyResponse, error)
      BatchRecover(ctx context.Context, in *BatchRecoverRequest, opts ...grpc.CallOption) (*BatchRecoverResponse, error)
      BatchRecoverTx(ctx context.Context, in *BatchRecoverTxRequest, opts ...grpc.CallOption) (*BatchRecoverTxResponse, error)
      }
      type crypterServiceClient struct {
      cc grpc.ClientConnInterface
      }
      func NewCrypterServiceClient(cc grpc.ClientConnInterface) CrypterServiceClient {
      return &crypterServiceClient{cc}
      }
      func (c *crypterServiceClient) BatchSign(ctx context.Context, in *BatchSignRequest, opts ...grpc.CallOption) (*BatchSignResponse, error) {
      out := new(BatchSignResponse)
      err := c.cc.Invoke(ctx, "/crypter.v1.CrypterService/BatchSign", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *crypterServiceClient) BatchVerify(ctx context.Context, in *BatchVerifyRequest, opts ...grpc.CallOption) (*BatchVerifyResponse, error) {
      out := new(BatchVerifyResponse)
      err := c.cc.Invoke(ctx, "/crypter.v1.CrypterService/BatchVerify", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *crypterServiceClient) BatchRecover(ctx context.Context, in *BatchRecoverRequest, opts ...grpc.CallOption) (*BatchRecoverResponse, error) {
      out := new(BatchRecoverResponse)
      err := c.cc.Invoke(ctx, "/crypter.v1.CrypterService/BatchRecover", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *crypterServiceClient) BatchRecoverTx(ctx context.Context, in *BatchRecoverTxRequest, opts ...grpc.CallOption) (*BatchRecoverTxResponse, error) {
      out := new(BatchRecoverTxResponse)
      err := c.cc.Invoke(ctx, "/crypter.v1.CrypterService/BatchRecoverTx", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      // CrypterServiceServer is the server API for CrypterService service.
      // All implementations must embed UnimplementedCrypterServiceServer
      // for forward compatibility
      type CrypterServiceServer interface {
      BatchSign(context.Context, *BatchSignRequest) (*BatchSignResponse, error)
      BatchVerify(context.Context, *BatchVerifyRequest) (*BatchVerifyResponse, error)
      BatchRecover(context.Context, *BatchRecoverRequest) (*BatchRecoverResponse, error)
      BatchRecoverTx(context.Context, *BatchRecoverTxRequest) (*BatchRecoverTxResponse, error)
      mustEmbedUnimplementedCrypterServiceServer()
      }
      // UnimplementedCrypterServiceServer must be embedded to have forward compatible implementations.
      type UnimplementedCrypterServiceServer struct {
      }
      func (UnimplementedCrypterServiceServer) BatchSign(context.Context, *BatchSignRequest) (*BatchSignResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BatchSign not implemented")
      }
      func (UnimplementedCrypterServiceServer) BatchVerify(context.Context, *BatchVerifyRequest) (*BatchVerifyResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BatchVerify not implemented")
      }
      func (UnimplementedCrypterServiceServer) BatchRecover(context.Context, *BatchRecoverRequest) (*BatchRecoverResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BatchRecover not implemented")
      }
      func (UnimplementedCrypterServiceServer) BatchRecoverTx(context.Context, *BatchRecoverTxRequest) (*BatchRecoverTxResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BatchRecoverTx not implemented")
      }
      func (UnimplementedCrypterServiceServer) mustEmbedUnimplementedCrypterServiceServer() {}
      // UnsafeCrypterServiceServer may be embedded to opt out of forward compatibility for this service.
      // Use of this interface is not recommended, as added methods to CrypterServiceServer will
      // result in compilation errors.
      type UnsafeCrypterServiceServer interface {
      mustEmbedUnimplementedCrypterServiceServer()
      }
      func RegisterCrypterServiceServer(s grpc.ServiceRegistrar, srv CrypterServiceServer) {
      s.RegisterService(&CrypterService_ServiceDesc, srv)
      }
      func _CrypterService_BatchSign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BatchSignRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(CrypterServiceServer).BatchSign(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/crypter.v1.CrypterService/BatchSign",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(CrypterServiceServer).BatchSign(ctx, req.(*BatchSignRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _CrypterService_BatchVerify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BatchVerifyRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(CrypterServiceServer).BatchVerify(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/crypter.v1.CrypterService/BatchVerify",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(CrypterServiceServer).BatchVerify(ctx, req.(*BatchVerifyRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _CrypterService_BatchRecover_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BatchRecoverRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(CrypterServiceServer).BatchRecover(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/crypter.v1.CrypterService/BatchRecover",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(CrypterServiceServer).BatchRecover(ctx, req.(*BatchRecoverRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _CrypterService_BatchRecoverTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BatchRecoverTxRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(CrypterServiceServer).BatchRecoverTx(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/crypter.v1.CrypterService/BatchRecoverTx",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(CrypterServiceServer).BatchRecoverTx(ctx, req.(*BatchRecoverTxRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      // CrypterService_ServiceDesc is the grpc.ServiceDesc for CrypterService service.
      // It's only intended for direct use with grpc.RegisterService,
      // and not to be introspected or modified (even as a copy)
      var CrypterService_ServiceDesc = grpc.ServiceDesc{
      ServiceName: "crypter.v1.CrypterService",
      HandlerType: (*CrypterServiceServer)(nil),
      Methods: []grpc.MethodDesc{
      {
      MethodName: "BatchSign",
      Handler: _CrypterService_BatchSign_Handler,
      },
      {
      MethodName: "BatchVerify",
      Handler: _CrypterService_BatchVerify_Handler,
      },
      {
      MethodName: "BatchRecover",
      Handler: _CrypterService_BatchRecover_Handler,
      },
      {
      MethodName: "BatchRecoverTx",
      Handler: _CrypterService_BatchRecoverTx_Handler,
      },
      },
      Streams: []grpc.StreamDesc{},
      Metadata: "crypter/v1/service.proto",
      }
      MetaProtocol-main/gen/proto/go/ethrpc/v1/account_req_res.pb.go 0 → 100644
      View file @ 9234b25c
      This source diff could not be displayed because it is too large. You can view the blob instead.
      MetaProtocol-main/gen/proto/go/ethrpc/v1/request_response.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: ethrpc/v1/request_response.proto
      package ethrpcv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      _ "github.com/gogo/protobuf/types"
      _ "google.golang.org/protobuf/types/known/fieldmaskpb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("ethrpc/v1/request_response.proto", fileDescriptor_eab3e970b3fc4905) }
      var fileDescriptor_eab3e970b3fc4905 = []byte{
      // 245 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x48, 0x2d, 0xc9, 0x28,
      0x2a, 0x48, 0xd6, 0x2f, 0x33, 0xd4, 0x2f, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x89, 0x2f, 0x4a,
      0x2d, 0x2e, 0xc8, 0xcf, 0x2b, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0xa8,
      0xd0, 0x2b, 0x33, 0x94, 0x52, 0x48, 0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0xd5, 0x07, 0x4b, 0x24, 0x95,
      0xa6, 0xe9, 0xa7, 0x65, 0xa6, 0xe6, 0xa4, 0xc4, 0xe7, 0x26, 0x16, 0x67, 0x43, 0x14, 0x4b, 0xc9,
      0xa3, 0xab, 0x28, 0xc9, 0xcc, 0x4d, 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0x80, 0x2a, 0x90, 0x40, 0xb6,
      0xaf, 0x38, 0xbf, 0xb4, 0x28, 0x19, 0x6a, 0x8f, 0xd3, 0x5e, 0x46, 0x2e, 0xde, 0xe4, 0xfc, 0x5c,
      0x3d, 0xb8, 0x75, 0x4e, 0x22, 0x41, 0x10, 0x17, 0x05, 0x41, 0x1d, 0x14, 0x00, 0x52, 0x17, 0xc0,
      0x18, 0x15, 0x98, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0xef, 0x9c, 0x98,
      0x52, 0x9a, 0x9c, 0x5a, 0x5a, 0xec, 0x9b, 0x5a, 0x92, 0x58, 0x96, 0x5a, 0x04, 0x55, 0x94, 0x9c,
      0x9f, 0xa3, 0x0f, 0x12, 0x81, 0x73, 0xd2, 0x53, 0xf3, 0x20, 0x6e, 0xd2, 0x4f, 0xcf, 0xd7, 0x87,
      0x3b, 0xc1, 0x1a, 0xc2, 0x2a, 0x33, 0x5c, 0xc4, 0xc4, 0xec, 0x1a, 0x11, 0xb1, 0x8a, 0x89, 0xd3,
      0x15, 0x62, 0x79, 0x98, 0xe1, 0x29, 0x18, 0x3b, 0x26, 0xcc, 0xf0, 0x11, 0x93, 0x28, 0x9c, 0x1d,
      0xe3, 0x1e, 0xe0, 0x04, 0x32, 0x39, 0x25, 0xb1, 0x24, 0xf1, 0x15, 0x13, 0x17, 0x44, 0xdc, 0xca,
      0x2a, 0xcc, 0x30, 0x89, 0x0d, 0x6c, 0xbe, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xae, 0xdc, 0x16,
      0x31, 0x52, 0x01, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/ethrpc/v1/resource.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: ethrpc/v1/resource.proto
      package ethrpcv1
      import (
      fmt "fmt"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base/v1"
      github_com_CaduceusMetaverseProtocol_MetaTypes_types "github.com/CaduceusMetaverseProtocol/MetaTypes/types"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type Tx struct {
      Address *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Address `protobuf:"bytes,1,opt,name=address,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Address" json:"address,omitempty"`
      Hash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,2,opt,name=hash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"hash,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *Tx) Reset() { *m = Tx{} }
      func (m *Tx) String() string { return proto.CompactTextString(m) }
      func (*Tx) ProtoMessage() {}
      func (*Tx) Descriptor() ([]byte, []int) {
      return fileDescriptor_036849992e4c155c, []int{0}
      }
      func (m *Tx) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_Tx.Unmarshal(m, b)
      }
      func (m *Tx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_Tx.Marshal(b, m, deterministic)
      }
      func (m *Tx) XXX_Merge(src proto.Message) {
      xxx_messageInfo_Tx.Merge(m, src)
      }
      func (m *Tx) XXX_Size() int {
      return xxx_messageInfo_Tx.Size(m)
      }
      func (m *Tx) XXX_DiscardUnknown() {
      xxx_messageInfo_Tx.DiscardUnknown(m)
      }
      var xxx_messageInfo_Tx proto.InternalMessageInfo
      func init() {
      proto.RegisterType((*Tx)(nil), "ethrpc.v1.Tx")
      }
      func init() { proto.RegisterFile("ethrpc/v1/resource.proto", fileDescriptor_036849992e4c155c) }
      var fileDescriptor_036849992e4c155c = []byte{
      // 295 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x48, 0x2d, 0xc9, 0x28,
      0x2a, 0x48, 0xd6, 0x2f, 0x33, 0xd4, 0x2f, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5, 0x2b,
      0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0xc8, 0xe8, 0x95, 0x19, 0x4a, 0x89, 0x25, 0x25, 0x16,
      0xa7, 0x62, 0x2a, 0x91, 0xe2, 0x07, 0x8b, 0xa7, 0xe7, 0xa7, 0xe7, 0x43, 0x04, 0x94, 0xae, 0x30,
      0x72, 0x31, 0x85, 0x54, 0x08, 0xe5, 0x70, 0xb1, 0x27, 0xa6, 0xa4, 0x14, 0xa5, 0x16, 0x17, 0x4b,
      0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe8, 0x81, 0x54, 0xea, 0x95, 0x19, 0xea, 0x39, 0x42,
      0xc4, 0x9d, 0x1c, 0x6e, 0xdd, 0x93, 0xb7, 0x49, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce,
      0xcf, 0xd5, 0x77, 0x4e, 0x4c, 0x29, 0x4d, 0x4e, 0x2d, 0x2d, 0xf6, 0x4d, 0x2d, 0x49, 0x2c, 0x4b,
      0x2d, 0x2a, 0x4e, 0x0d, 0x00, 0x19, 0x98, 0x9c, 0x9f, 0xa3, 0x0f, 0x12, 0x09, 0xa9, 0x2c, 0x48,
      0x2d, 0xd6, 0x2f, 0x01, 0x91, 0x30, 0x13, 0x82, 0x60, 0x56, 0x08, 0x25, 0x70, 0xb1, 0x64, 0x24,
      0x16, 0x67, 0x48, 0x30, 0x81, 0xad, 0xe2, 0x85, 0x5b, 0xe5, 0x91, 0x58, 0x9c, 0xe1, 0x64, 0x7b,
      0xeb, 0x9e, 0xbc, 0x25, 0x59, 0xf6, 0x80, 0xb4, 0x07, 0x81, 0x4d, 0x76, 0xda, 0xc6, 0xc8, 0xc5,
      0x9b, 0x9c, 0x9f, 0xab, 0x07, 0x0f, 0x11, 0x27, 0xde, 0x20, 0x68, 0x48, 0x80, 0xb5, 0x07, 0x30,
      0x46, 0x05, 0x12, 0x6d, 0x07, 0x9c, 0x93, 0x9e, 0x9a, 0xa7, 0x0f, 0x0e, 0x36, 0xfd, 0xf4, 0x7c,
      0x7d, 0x78, 0x34, 0x58, 0x43, 0x58, 0x65, 0x86, 0x8b, 0x98, 0x98, 0x5d, 0x23, 0x22, 0x56, 0x31,
      0x71, 0xba, 0x42, 0x6c, 0x0d, 0x33, 0x3c, 0x05, 0x63, 0xc7, 0x84, 0x19, 0x3e, 0x62, 0x12, 0x85,
      0xb3, 0x63, 0xdc, 0x03, 0x9c, 0x40, 0x26, 0xa7, 0x24, 0x96, 0x24, 0xbe, 0x62, 0xe2, 0x82, 0x88,
      0x5b, 0x59, 0x85, 0x19, 0x26, 0xb1, 0x81, 0xcd, 0x37, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x2c,
      0x40, 0xd5, 0x14, 0xe6, 0x01, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/ethrpc/v1/service.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: ethrpc/v1/service.proto
      package ethrpcv1
      import (
      fmt "fmt"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base/v1"
      proto "github.com/gogo/protobuf/proto"
      _ "google.golang.org/protobuf/types/known/emptypb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("ethrpc/v1/service.proto", fileDescriptor_9a361d118a8cc4c1) }
      var fileDescriptor_9a361d118a8cc4c1 = []byte{
      // 1140 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x98, 0xdd, 0x72, 0x1b, 0x35,
      0x14, 0xc7, 0x49, 0x80, 0x96, 0xaa, 0x1f, 0x81, 0x1d, 0x48, 0x82, 0x43, 0x3e, 0x69, 0x6f, 0x80,
      0xae, 0xeb, 0xe6, 0x8a, 0x02, 0xc3, 0xc4, 0x9e, 0x90, 0x74, 0x70, 0x8c, 0xb1, 0xdb, 0xd0, 0xe9,
      0x94, 0x29, 0xca, 0xee, 0x61, 0xbd, 0xc3, 0x5a, 0x72, 0x77, 0xe5, 0xa4, 0x19, 0x66, 0xb8, 0x62,
      0x86, 0x2b, 0x6e, 0x79, 0x00, 0x2e, 0xb9, 0xe7, 0x25, 0x78, 0x0c, 0x2e, 0x79, 0x0a, 0x66, 0x57,
      0x1f, 0x39, 0xda, 0xd5, 0x3a, 0xee, 0x9d, 0x73, 0xfe, 0xff, 0xf3, 0xd3, 0x91, 0x22, 0xe9, 0xc8,
      0x26, 0x2b, 0x20, 0x46, 0xe9, 0x24, 0x68, 0x9e, 0xb6, 0x9a, 0x19, 0xa4, 0xa7, 0x71, 0x00, 0xfe,
      0x24, 0xe5, 0x82, 0x7b, 0xd7, 0xa4, 0xe0, 0x9f, 0xb6, 0x1a, 0x6b, 0x11, 0xe7, 0x51, 0x02, 0xcd,
      0x42, 0x38, 0x99, 0xfe, 0xd8, 0x84, 0xf1, 0x44, 0x9c, 0x4b, 0x5f, 0x63, 0xeb, 0x02, 0x90, 0xc2,
      0x8b, 0x29, 0x64, 0xe2, 0x79, 0x0a, 0xd9, 0x84, 0xb3, 0x4c, 0x91, 0x1a, 0x9b, 0x17, 0x0e, 0x1a,
      0x04, 0x7c, 0xca, 0x72, 0xc7, 0x8b, 0xdc, 0xa5, 0x0c, 0xef, 0x9e, 0xd0, 0x0c, 0x72, 0x19, 0xc4,
      0xe8, 0xb9, 0x78, 0xa9, 0xa2, 0xcb, 0x3a, 0x9a, 0x42, 0xc6, 0xa7, 0xa9, 0x2e, 0xec, 0xfe, 0x1f,
      0x9b, 0x84, 0x0c, 0x26, 0xc1, 0x50, 0x56, 0xeb, 0x7d, 0x4a, 0xde, 0x18, 0x8e, 0xe8, 0xae, 0xb7,
      0xec, 0x9b, 0x82, 0xfd, 0x3c, 0x30, 0x90, 0xc5, 0x34, 0x56, 0x2a, 0x71, 0x59, 0xdc, 0xce, 0x6b,
      0xde, 0x01, 0xb9, 0xde, 0xe3, 0x21, 0x1c, 0x43, 0x9a, 0xc5, 0x9c, 0x79, 0xcb, 0xbe, 0x9c, 0xa7,
      0xaf, 0xe7, 0xe9, 0xef, 0xe7, 0xf3, 0x6c, 0x6c, 0x20, 0x02, 0xf2, 0x23, 0xd0, 0x3e, 0x21, 0x3d,
      0x10, 0x97, 0x71, 0xd6, 0x31, 0xc7, 0xd8, 0x11, 0xe6, 0x21, 0xb9, 0xd1, 0x03, 0xd1, 0x07, 0x48,
      0x3b, 0xf9, 0x2a, 0xd5, 0x82, 0x36, 0x6d, 0x90, 0x49, 0x40, 0xa8, 0x6f, 0xc8, 0x52, 0x3f, 0x4f,
      0x0a, 0x78, 0x72, 0x59, 0x59, 0x3b, 0x88, 0x56, 0xca, 0x41, 0xc0, 0x2f, 0xc9, 0xd5, 0xe1, 0x39,
      0x0b, 0x62, 0x16, 0xd5, 0x82, 0x1a, 0x78, 0xa5, 0xa5, 0x17, 0x01, 0xf6, 0xc8, 0x5b, 0x1d, 0x1e,
      0xb3, 0xfc, 0x9f, 0x5a, 0x4b, 0x58, 0x43, 0x04, 0x6d, 0x46, 0x88, 0x2f, 0xc8, 0x95, 0xa3, 0x98,
      0xcd, 0x2a, 0xe1, 0x7d, 0x04, 0x90, 0x56, 0xbb, 0x82, 0x43, 0x9a, 0x8d, 0x06, 0x54, 0xcc, 0x57,
      0x81, 0x36, 0xdb, 0x88, 0x3d, 0xb9, 0x85, 0xb3, 0xb9, 0x10, 0xda, 0x6c, 0x23, 0x0e, 0x68, 0xd6,
      0x4f, 0xf3, 0xbd, 0x3b, 0x0f, 0x42, 0x9b, 0x11, 0xa2, 0x4d, 0xae, 0xb7, 0x13, 0x1e, 0xfc, 0xd4,
      0x9b, 0x8e, 0x4f, 0x20, 0x9d, 0x6b, 0x31, 0x0e, 0x21, 0x8e, 0x46, 0x78, 0x83, 0xf4, 0x14, 0xa3,
      0x7d, 0x9e, 0x4f, 0xd3, 0xc3, 0x7b, 0x13, 0xc5, 0xf5, 0x21, 0xda, 0xa8, 0x93, 0x0d, 0xef, 0x11,
      0xb9, 0xa9, 0x04, 0x55, 0xd5, 0x66, 0x35, 0x45, 0x2a, 0x9a, 0xb9, 0x55, 0x6f, 0x30, 0xd4, 0x5f,
      0xc8, 0x5a, 0x21, 0x3d, 0x4a, 0x29, 0xcb, 0x68, 0x20, 0x62, 0xce, 0x8a, 0x9d, 0xae, 0xaa, 0xbe,
      0x5b, 0x46, 0xb8, 0x7d, 0x7a, 0x44, 0x7f, 0x5e, 0xbb, 0x19, 0xff, 0xd7, 0x05, 0xb2, 0x5e, 0xe3,
      0x54, 0xd3, 0x6c, 0x5e, 0xce, 0xb4, 0xa7, 0x7d, 0x6f, 0xfe, 0x04, 0x53, 0xc6, 0xf7, 0xe4, 0xed,
      0xc7, 0x2c, 0x48, 0x00, 0xcf, 0x1d, 0x1f, 0xdb, 0xb2, 0xa8, 0xc7, 0xfa, 0x70, 0xa6, 0xc7, 0xe0,
      0x03, 0xe2, 0x61, 0x55, 0xcd, 0xec, 0x76, 0x4d, 0xb2, 0x3d, 0x9d, 0x3b, 0x97, 0xb8, 0xcc, 0x20,
      0x53, 0xb2, 0x5a, 0xe8, 0xed, 0xf3, 0x62, 0xd6, 0x79, 0x09, 0x7b, 0x2c, 0x7c, 0xc8, 0x42, 0x78,
      0xe9, 0x7d, 0x54, 0x86, 0x38, 0x4c, 0x7a, 0xc0, 0x8f, 0xe7, 0xf2, 0x9a, 0x61, 0x7f, 0x26, 0x0d,
      0xec, 0x92, 0x65, 0x99, 0x81, 0x3f, 0xa9, 0x81, 0xd9, 0x36, 0x3d, 0xf4, 0xdd, 0x39, 0xdd, 0x66,
      0xf0, 0x43, 0x72, 0xad, 0xc3, 0xc7, 0x93, 0x38, 0x81, 0x34, 0xf3, 0xec, 0xcb, 0x4d, 0x45, 0x35,
      0xfa, 0x03, 0xb7, 0x68, 0x48, 0x4f, 0xc9, 0x92, 0x0a, 0x0f, 0x79, 0x12, 0x87, 0xb1, 0x38, 0xf7,
      0xb6, 0xab, 0x29, 0x5a, 0xd3, 0xd4, 0x9d, 0x59, 0x16, 0xc3, 0xfe, 0x9a, 0x10, 0x25, 0x76, 0xbb,
      0x5d, 0xcf, 0x51, 0x49, 0xb7, 0xdb, 0xd5, 0xc4, 0xf5, 0x1a, 0xd5, 0xc0, 0xbe, 0x23, 0xb7, 0xf4,
      0x48, 0x90, 0x4e, 0x80, 0x09, 0x6f, 0xcb, 0x51, 0x84, 0x94, 0x34, 0x74, 0x7b, 0x86, 0x03, 0x5f,
      0x58, 0xfb, 0x99, 0x88, 0xc7, 0x54, 0xc0, 0x01, 0xcd, 0xac, 0x0b, 0x0b, 0xc5, 0x5d, 0x17, 0x96,
      0x25, 0x1b, 0xde, 0x0f, 0xe4, 0x1d, 0x74, 0xf2, 0xd4, 0xa1, 0xc2, 0x07, 0xa6, 0xa2, 0x6a, 0xf6,
      0xed, 0xd9, 0x26, 0x33, 0xc2, 0x6f, 0x0b, 0x64, 0xc3, 0xd2, 0xab, 0x1b, 0xff, 0x5e, 0x1d, 0xaa,
      0x76, 0xfb, 0xb7, 0x5e, 0x21, 0xc3, 0x54, 0xf2, 0xfb, 0x02, 0xd9, 0xaa, 0x9a, 0x4b, 0x67, 0xe1,
      0xfe, 0x4c, 0xb2, 0xfb, 0x44, 0xec, 0xbe, 0x52, 0x0e, 0xbe, 0x70, 0x90, 0x7b, 0x00, 0x01, 0xc4,
      0x13, 0xe1, 0xd5, 0xac, 0xab, 0x92, 0x5d, 0x17, 0x8e, 0xcb, 0x85, 0xba, 0xe4, 0xd5, 0x36, 0x4d,
      0x28, 0x0b, 0xc0, 0xc3, 0x9d, 0x50, 0xc5, 0x34, 0xae, 0xe1, 0x92, 0x30, 0x63, 0x28, 0x78, 0x4a,
      0x23, 0x9b, 0xa1, 0x62, 0x2e, 0x86, 0x91, 0x0c, 0xe3, 0x73, 0xf2, 0x66, 0x8f, 0xe7, 0x55, 0xac,
      0x58, 0xef, 0x48, 0x54, 0xc3, 0x6a, 0x55, 0xc0, 0x7d, 0x75, 0x00, 0x13, 0xa0, 0x02, 0x42, 0x49,
      0xc1, 0x7d, 0xd5, 0x52, 0x5c, 0x7d, 0xb5, 0x64, 0xc0, 0x0d, 0xa5, 0xdc, 0x76, 0xac, 0x86, 0x52,
      0x16, 0x5d, 0x0d, 0xa5, 0xea, 0xc1, 0xcb, 0x76, 0x00, 0xa2, 0xc3, 0x43, 0x7b, 0xd9, 0x54, 0xcc,
      0xb5, 0x6c, 0x46, 0x32, 0x8c, 0xfc, 0x5d, 0x1f, 0x47, 0xcc, 0x7e, 0xd7, 0xc7, 0x11, 0x73, 0xbe,
      0xeb, 0x8b, 0x38, 0xbe, 0x2c, 0xf3, 0x08, 0x2a, 0xd0, 0xba, 0x2c, 0x4b, 0x9a, 0xeb, 0xb2, 0xac,
      0x58, 0x0c, 0xbb, 0x4f, 0x96, 0x86, 0xc0, 0x42, 0xcc, 0x5e, 0xf1, 0xf3, 0x77, 0x6a, 0x71, 0xd3,
      0x88, 0x11, 0x12, 0x6c, 0xa2, 0x9d, 0x84, 0x88, 0xc7, 0xc4, 0xcb, 0xc5, 0x01, 0x3d, 0x9b, 0x0b,
      0x7a, 0xa7, 0x04, 0xb5, 0xf3, 0xec, 0x05, 0xec, 0xd0, 0x24, 0xb1, 0x16, 0x30, 0x0f, 0xb8, 0x16,
      0x50, 0xc6, 0x71, 0xdf, 0xea, 0xc1, 0xd9, 0x57, 0x71, 0x22, 0x20, 0xb5, 0xfa, 0x96, 0x89, 0xba,
      0xfa, 0x16, 0x12, 0x0d, 0xe9, 0x88, 0xdc, 0xea, 0xc1, 0x59, 0x71, 0x1b, 0x28, 0x5c, 0xdd, 0x6b,
      0x75, 0xdb, 0x26, 0xa1, 0x14, 0x84, 0xa3, 0x64, 0xb5, 0x0f, 0x2c, 0x8c, 0x59, 0x84, 0xe6, 0x7c,
      0x09, 0x18, 0x3f, 0x18, 0xea, 0x92, 0xed, 0xcd, 0xf3, 0x98, 0xc5, 0x2c, 0x13, 0x34, 0x49, 0x14,
      0x79, 0xdb, 0xea, 0xfb, 0x96, 0xe6, 0xda, 0x3c, 0x15, 0x0b, 0x3e, 0xcc, 0x32, 0xd6, 0x19, 0x51,
      0x16, 0x41, 0x66, 0x1d, 0x66, 0x4b, 0x71, 0x1d, 0xe6, 0x92, 0x01, 0xf7, 0x6f, 0x29, 0x75, 0x79,
      0x94, 0x59, 0xfd, 0xfb, 0x22, 0xec, 0xea, 0xdf, 0x58, 0xc5, 0xbb, 0xa6, 0xc0, 0xe0, 0x5d, 0x83,
      0x01, 0x2b, 0x95, 0xb8, 0x4e, 0x6d, 0xff, 0xbd, 0x40, 0x6e, 0x06, 0x7c, 0x7c, 0x61, 0x68, 0xdf,
      0x50, 0x5f, 0xd2, 0x8b, 0xaf, 0x95, 0xfd, 0x85, 0xa7, 0xdf, 0x46, 0xb1, 0x18, 0x4d, 0x4f, 0xfc,
      0x80, 0x8f, 0x9b, 0x1d, 0x1a, 0x4e, 0x03, 0x98, 0x66, 0x47, 0x20, 0xe8, 0x29, 0xa4, 0x19, 0xe8,
      0xef, 0x9e, 0xcd, 0x3c, 0x62, 0xfe, 0x88, 0x80, 0xc9, 0xdf, 0x1d, 0x9a, 0x11, 0x6f, 0x9a, 0x1f,
      0x12, 0x3e, 0x93, 0x9f, 0x4e, 0x5b, 0x7f, 0x2e, 0xbe, 0xbe, 0xff, 0xe4, 0xc9, 0x5f, 0x8b, 0xd7,
      0xf6, 0xe5, 0xa0, 0xc7, 0xad, 0x7f, 0xf4, 0xe7, 0x67, 0xc7, 0xad, 0x7f, 0x17, 0xdf, 0x33, 0x9f,
      0x9f, 0x1d, 0xf4, 0xdb, 0x39, 0x39, 0xa4, 0x82, 0xfe, 0xb7, 0x48, 0x64, 0xfc, 0xc1, 0x83, 0xe3,
      0xd6, 0xc9, 0x95, 0x82, 0xbf, 0xfb, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x23, 0xad, 0xfa, 0x97,
      0x0b, 0x11, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/ethrpc/v1/service_grpc.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
      // versions:
      // - protoc-gen-go-grpc v1.2.0
      // - protoc (unknown)
      // source: ethrpc/v1/service.proto
      package ethrpcv1
      import (
      context "context"
      v1 "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base/v1"
      grpc "google.golang.org/grpc"
      codes "google.golang.org/grpc/codes"
      status "google.golang.org/grpc/status"
      emptypb "google.golang.org/protobuf/types/known/emptypb"
      )
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the grpc package it is being compiled against.
      // Requires gRPC-Go v1.32.0 or later.
      const _ = grpc.SupportPackageIsVersion7
      // RpcServiceClient is the client API for RpcService service.
      //
      // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
      type RpcServiceClient interface {
      // web3
      Sha3(ctx context.Context, in *Sha3Request, opts ...grpc.CallOption) (*Sha3Response, error)
      NodeVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NodeVersionResponse, error)
      // network info service
      NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error)
      NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error)
      // node status
      ProtocolVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ProtocolVersionResponse, error)
      Syncing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SyncingResponse, error)
      Coinbase(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CoinbaseResponse, error)
      Mining(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*MiningResponse, error)
      HashRate(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HashRateResponse, error)
      Accounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AccountsResponse, error)
      // tx operatoration
      GasPrice(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GasPriceResponse, error)
      // block info service
      BlockNumber(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HeightResponse, error)
      BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (*BlockByHashResponse, error)
      BlockByNumber(ctx context.Context, in *BlockByNumberRequest, opts ...grpc.CallOption) (*BlockByNumberResponse, error)
      BlockTransactionCountByHash(ctx context.Context, in *BlockTransactionCountByHashRequest, opts ...grpc.CallOption) (*BlockTransactionCountByHashResponse, error)
      BlockTransactionCountByNumber(ctx context.Context, in *BlockTransactionCountByNumberRequest, opts ...grpc.CallOption) (*BlockTransactionCountByNumberResponse, error)
      UncleCountByHash(ctx context.Context, in *UncleCountByHashRequest, opts ...grpc.CallOption) (*UncleCountByHashResponse, error)
      UncleCountByNumber(ctx context.Context, in *UncleCountByNumberRequest, opts ...grpc.CallOption) (*UncleCountByNumberResponse, error)
      UncleByBlockHashAndIndex(ctx context.Context, in *UncleByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockHashAndIndexResponse, error)
      UncleByBlockNumberAndIndex(ctx context.Context, in *UncleByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockNumberAndIndexResponse, error)
      // compiler
      Compilers(ctx context.Context, in *CompilersRequest, opts ...grpc.CallOption) (*CompilersResponse, error)
      CompileSolidity(ctx context.Context, in *CompileSolidityRequest, opts ...grpc.CallOption) (*CompileSolidityResponse, error)
      CompileLLL(ctx context.Context, in *CompileLLLRequest, opts ...grpc.CallOption) (*CompileLLLResponse, error)
      CompileSerpent(ctx context.Context, in *CompileSerpentRequest, opts ...grpc.CallOption) (*CompileSerpentResponse, error)
      // transaction info service
      EstimateGas(ctx context.Context, in *EstimateGasRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error)
      TransactionByHash(ctx context.Context, in *TransactionByHashRequest, opts ...grpc.CallOption) (*TransactionByHashResponse, error)
      TransactionByBlockHashAndIndex(ctx context.Context, in *TransactionByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockHashAndIndexResponse, error)
      TransactionByBlockNumberAndIndex(ctx context.Context, in *TransactionByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockNumberAndIndexResponse, error)
      TransactionReceipt(ctx context.Context, in *TransactionReceiptRequest, opts ...grpc.CallOption) (*TransactionReceiptResponse, error)
      // account info service
      Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error)
      Storage(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error)
      Nonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResponse, error)
      RepeatedNonce(ctx context.Context, in *RepeatedNonceRequest, opts ...grpc.CallOption) (*RepeatedNonceResponse, error)
      TransactionCount(ctx context.Context, in *TransactionCountRequest, opts ...grpc.CallOption) (*TransactionCountResponse, error)
      GetCode(ctx context.Context, in *GetCodeRequest, opts ...grpc.CallOption) (*GetCodeResponse, error)
      Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
      SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error)
      SendTransaction(ctx context.Context, in *v1.EthTransaction, opts ...grpc.CallOption) (*SendTransactionResponse, error)
      SendRawTransaction(ctx context.Context, in *v1.EthTransaction, opts ...grpc.CallOption) (*SendRawTransactionResponse, error)
      Call(ctx context.Context, in *CallRequest, opts ...grpc.CallOption) (*CallResponse, error)
      // filter
      NewFilter(ctx context.Context, in *NewFilterRequest, opts ...grpc.CallOption) (*NewFilterResponse, error)
      NewBlockFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NewBlockFilterResponse, error)
      PendingTransactionFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PendingTransactionFilterResponse, error)
      UninstallFilter(ctx context.Context, in *UninstallFilterRequest, opts ...grpc.CallOption) (*UninstallFilterResponse, error)
      FilterChanges(ctx context.Context, in *FilterChangesRequest, opts ...grpc.CallOption) (*FilterChangesResponse, error)
      FilterLogs(ctx context.Context, in *FilterLogsRequest, opts ...grpc.CallOption) (*FilterLogsResponse, error)
      Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (*LogsResponse, error)
      }
      type rpcServiceClient struct {
      cc grpc.ClientConnInterface
      }
      func NewRpcServiceClient(cc grpc.ClientConnInterface) RpcServiceClient {
      return &rpcServiceClient{cc}
      }
      func (c *rpcServiceClient) Sha3(ctx context.Context, in *Sha3Request, opts ...grpc.CallOption) (*Sha3Response, error) {
      out := new(Sha3Response)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Sha3", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) NodeVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NodeVersionResponse, error) {
      out := new(NodeVersionResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/NodeVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error) {
      out := new(NetVersionResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/NetVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error) {
      out := new(NetPeerCountResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/NetPeerCount", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) ProtocolVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ProtocolVersionResponse, error) {
      out := new(ProtocolVersionResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/ProtocolVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Syncing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SyncingResponse, error) {
      out := new(SyncingResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Syncing", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Coinbase(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CoinbaseResponse, error) {
      out := new(CoinbaseResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Coinbase", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Mining(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*MiningResponse, error) {
      out := new(MiningResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Mining", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) HashRate(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HashRateResponse, error) {
      out := new(HashRateResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/HashRate", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Accounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AccountsResponse, error) {
      out := new(AccountsResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Accounts", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) GasPrice(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GasPriceResponse, error) {
      out := new(GasPriceResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/GasPrice", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) BlockNumber(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HeightResponse, error) {
      out := new(HeightResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/BlockNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (*BlockByHashResponse, error) {
      out := new(BlockByHashResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/BlockByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) BlockByNumber(ctx context.Context, in *BlockByNumberRequest, opts ...grpc.CallOption) (*BlockByNumberResponse, error) {
      out := new(BlockByNumberResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/BlockByNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) BlockTransactionCountByHash(ctx context.Context, in *BlockTransactionCountByHashRequest, opts ...grpc.CallOption) (*BlockTransactionCountByHashResponse, error) {
      out := new(BlockTransactionCountByHashResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/BlockTransactionCountByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) BlockTransactionCountByNumber(ctx context.Context, in *BlockTransactionCountByNumberRequest, opts ...grpc.CallOption) (*BlockTransactionCountByNumberResponse, error) {
      out := new(BlockTransactionCountByNumberResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/BlockTransactionCountByNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) UncleCountByHash(ctx context.Context, in *UncleCountByHashRequest, opts ...grpc.CallOption) (*UncleCountByHashResponse, error) {
      out := new(UncleCountByHashResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/UncleCountByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) UncleCountByNumber(ctx context.Context, in *UncleCountByNumberRequest, opts ...grpc.CallOption) (*UncleCountByNumberResponse, error) {
      out := new(UncleCountByNumberResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/UncleCountByNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) UncleByBlockHashAndIndex(ctx context.Context, in *UncleByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockHashAndIndexResponse, error) {
      out := new(UncleByBlockHashAndIndexResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/UncleByBlockHashAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) UncleByBlockNumberAndIndex(ctx context.Context, in *UncleByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockNumberAndIndexResponse, error) {
      out := new(UncleByBlockNumberAndIndexResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/UncleByBlockNumberAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Compilers(ctx context.Context, in *CompilersRequest, opts ...grpc.CallOption) (*CompilersResponse, error) {
      out := new(CompilersResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Compilers", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) CompileSolidity(ctx context.Context, in *CompileSolidityRequest, opts ...grpc.CallOption) (*CompileSolidityResponse, error) {
      out := new(CompileSolidityResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/CompileSolidity", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) CompileLLL(ctx context.Context, in *CompileLLLRequest, opts ...grpc.CallOption) (*CompileLLLResponse, error) {
      out := new(CompileLLLResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/CompileLLL", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) CompileSerpent(ctx context.Context, in *CompileSerpentRequest, opts ...grpc.CallOption) (*CompileSerpentResponse, error) {
      out := new(CompileSerpentResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/CompileSerpent", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) EstimateGas(ctx context.Context, in *EstimateGasRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error) {
      out := new(EstimateGasResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/EstimateGas", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) TransactionByHash(ctx context.Context, in *TransactionByHashRequest, opts ...grpc.CallOption) (*TransactionByHashResponse, error) {
      out := new(TransactionByHashResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/TransactionByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) TransactionByBlockHashAndIndex(ctx context.Context, in *TransactionByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockHashAndIndexResponse, error) {
      out := new(TransactionByBlockHashAndIndexResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/TransactionByBlockHashAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) TransactionByBlockNumberAndIndex(ctx context.Context, in *TransactionByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockNumberAndIndexResponse, error) {
      out := new(TransactionByBlockNumberAndIndexResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/TransactionByBlockNumberAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) TransactionReceipt(ctx context.Context, in *TransactionReceiptRequest, opts ...grpc.CallOption) (*TransactionReceiptResponse, error) {
      out := new(TransactionReceiptResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/TransactionReceipt", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error) {
      out := new(BalanceResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Balance", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Storage(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error) {
      out := new(StorageResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Storage", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Nonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResponse, error) {
      out := new(NonceResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Nonce", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) RepeatedNonce(ctx context.Context, in *RepeatedNonceRequest, opts ...grpc.CallOption) (*RepeatedNonceResponse, error) {
      out := new(RepeatedNonceResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/RepeatedNonce", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) TransactionCount(ctx context.Context, in *TransactionCountRequest, opts ...grpc.CallOption) (*TransactionCountResponse, error) {
      out := new(TransactionCountResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/TransactionCount", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) GetCode(ctx context.Context, in *GetCodeRequest, opts ...grpc.CallOption) (*GetCodeResponse, error) {
      out := new(GetCodeResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/GetCode", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
      out := new(SignResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Sign", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error) {
      out := new(SignTransactionResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/SignTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) SendTransaction(ctx context.Context, in *v1.EthTransaction, opts ...grpc.CallOption) (*SendTransactionResponse, error) {
      out := new(SendTransactionResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/SendTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) SendRawTransaction(ctx context.Context, in *v1.EthTransaction, opts ...grpc.CallOption) (*SendRawTransactionResponse, error) {
      out := new(SendRawTransactionResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/SendRawTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Call(ctx context.Context, in *CallRequest, opts ...grpc.CallOption) (*CallResponse, error) {
      out := new(CallResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Call", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) NewFilter(ctx context.Context, in *NewFilterRequest, opts ...grpc.CallOption) (*NewFilterResponse, error) {
      out := new(NewFilterResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/NewFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) NewBlockFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NewBlockFilterResponse, error) {
      out := new(NewBlockFilterResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/NewBlockFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) PendingTransactionFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PendingTransactionFilterResponse, error) {
      out := new(PendingTransactionFilterResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/PendingTransactionFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) UninstallFilter(ctx context.Context, in *UninstallFilterRequest, opts ...grpc.CallOption) (*UninstallFilterResponse, error) {
      out := new(UninstallFilterResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/UninstallFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) FilterChanges(ctx context.Context, in *FilterChangesRequest, opts ...grpc.CallOption) (*FilterChangesResponse, error) {
      out := new(FilterChangesResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/FilterChanges", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) FilterLogs(ctx context.Context, in *FilterLogsRequest, opts ...grpc.CallOption) (*FilterLogsResponse, error) {
      out := new(FilterLogsResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/FilterLogs", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *rpcServiceClient) Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (*LogsResponse, error) {
      out := new(LogsResponse)
      err := c.cc.Invoke(ctx, "/ethrpc.v1.RpcService/Logs", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      // RpcServiceServer is the server API for RpcService service.
      // All implementations must embed UnimplementedRpcServiceServer
      // for forward compatibility
      type RpcServiceServer interface {
      // web3
      Sha3(context.Context, *Sha3Request) (*Sha3Response, error)
      NodeVersion(context.Context, *emptypb.Empty) (*NodeVersionResponse, error)
      // network info service
      NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error)
      NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error)
      // node status
      ProtocolVersion(context.Context, *emptypb.Empty) (*ProtocolVersionResponse, error)
      Syncing(context.Context, *emptypb.Empty) (*SyncingResponse, error)
      Coinbase(context.Context, *emptypb.Empty) (*CoinbaseResponse, error)
      Mining(context.Context, *emptypb.Empty) (*MiningResponse, error)
      HashRate(context.Context, *emptypb.Empty) (*HashRateResponse, error)
      Accounts(context.Context, *emptypb.Empty) (*AccountsResponse, error)
      // tx operatoration
      GasPrice(context.Context, *emptypb.Empty) (*GasPriceResponse, error)
      // block info service
      BlockNumber(context.Context, *emptypb.Empty) (*HeightResponse, error)
      BlockByHash(context.Context, *BlockByHashRequest) (*BlockByHashResponse, error)
      BlockByNumber(context.Context, *BlockByNumberRequest) (*BlockByNumberResponse, error)
      BlockTransactionCountByHash(context.Context, *BlockTransactionCountByHashRequest) (*BlockTransactionCountByHashResponse, error)
      BlockTransactionCountByNumber(context.Context, *BlockTransactionCountByNumberRequest) (*BlockTransactionCountByNumberResponse, error)
      UncleCountByHash(context.Context, *UncleCountByHashRequest) (*UncleCountByHashResponse, error)
      UncleCountByNumber(context.Context, *UncleCountByNumberRequest) (*UncleCountByNumberResponse, error)
      UncleByBlockHashAndIndex(context.Context, *UncleByBlockHashAndIndexRequest) (*UncleByBlockHashAndIndexResponse, error)
      UncleByBlockNumberAndIndex(context.Context, *UncleByBlockNumberAndIndexRequest) (*UncleByBlockNumberAndIndexResponse, error)
      // compiler
      Compilers(context.Context, *CompilersRequest) (*CompilersResponse, error)
      CompileSolidity(context.Context, *CompileSolidityRequest) (*CompileSolidityResponse, error)
      CompileLLL(context.Context, *CompileLLLRequest) (*CompileLLLResponse, error)
      CompileSerpent(context.Context, *CompileSerpentRequest) (*CompileSerpentResponse, error)
      // transaction info service
      EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error)
      TransactionByHash(context.Context, *TransactionByHashRequest) (*TransactionByHashResponse, error)
      TransactionByBlockHashAndIndex(context.Context, *TransactionByBlockHashAndIndexRequest) (*TransactionByBlockHashAndIndexResponse, error)
      TransactionByBlockNumberAndIndex(context.Context, *TransactionByBlockNumberAndIndexRequest) (*TransactionByBlockNumberAndIndexResponse, error)
      TransactionReceipt(context.Context, *TransactionReceiptRequest) (*TransactionReceiptResponse, error)
      // account info service
      Balance(context.Context, *BalanceRequest) (*BalanceResponse, error)
      Storage(context.Context, *StorageRequest) (*StorageResponse, error)
      Nonce(context.Context, *NonceRequest) (*NonceResponse, error)
      RepeatedNonce(context.Context, *RepeatedNonceRequest) (*RepeatedNonceResponse, error)
      TransactionCount(context.Context, *TransactionCountRequest) (*TransactionCountResponse, error)
      GetCode(context.Context, *GetCodeRequest) (*GetCodeResponse, error)
      Sign(context.Context, *SignRequest) (*SignResponse, error)
      SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error)
      SendTransaction(context.Context, *v1.EthTransaction) (*SendTransactionResponse, error)
      SendRawTransaction(context.Context, *v1.EthTransaction) (*SendRawTransactionResponse, error)
      Call(context.Context, *CallRequest) (*CallResponse, error)
      // filter
      NewFilter(context.Context, *NewFilterRequest) (*NewFilterResponse, error)
      NewBlockFilter(context.Context, *emptypb.Empty) (*NewBlockFilterResponse, error)
      PendingTransactionFilter(context.Context, *emptypb.Empty) (*PendingTransactionFilterResponse, error)
      UninstallFilter(context.Context, *UninstallFilterRequest) (*UninstallFilterResponse, error)
      FilterChanges(context.Context, *FilterChangesRequest) (*FilterChangesResponse, error)
      FilterLogs(context.Context, *FilterLogsRequest) (*FilterLogsResponse, error)
      Logs(context.Context, *LogsRequest) (*LogsResponse, error)
      mustEmbedUnimplementedRpcServiceServer()
      }
      // UnimplementedRpcServiceServer must be embedded to have forward compatible implementations.
      type UnimplementedRpcServiceServer struct {
      }
      func (UnimplementedRpcServiceServer) Sha3(context.Context, *Sha3Request) (*Sha3Response, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Sha3 not implemented")
      }
      func (UnimplementedRpcServiceServer) NodeVersion(context.Context, *emptypb.Empty) (*NodeVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NodeVersion not implemented")
      }
      func (UnimplementedRpcServiceServer) NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NetVersion not implemented")
      }
      func (UnimplementedRpcServiceServer) NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NetPeerCount not implemented")
      }
      func (UnimplementedRpcServiceServer) ProtocolVersion(context.Context, *emptypb.Empty) (*ProtocolVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method ProtocolVersion not implemented")
      }
      func (UnimplementedRpcServiceServer) Syncing(context.Context, *emptypb.Empty) (*SyncingResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Syncing not implemented")
      }
      func (UnimplementedRpcServiceServer) Coinbase(context.Context, *emptypb.Empty) (*CoinbaseResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Coinbase not implemented")
      }
      func (UnimplementedRpcServiceServer) Mining(context.Context, *emptypb.Empty) (*MiningResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Mining not implemented")
      }
      func (UnimplementedRpcServiceServer) HashRate(context.Context, *emptypb.Empty) (*HashRateResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method HashRate not implemented")
      }
      func (UnimplementedRpcServiceServer) Accounts(context.Context, *emptypb.Empty) (*AccountsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Accounts not implemented")
      }
      func (UnimplementedRpcServiceServer) GasPrice(context.Context, *emptypb.Empty) (*GasPriceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GasPrice not implemented")
      }
      func (UnimplementedRpcServiceServer) BlockNumber(context.Context, *emptypb.Empty) (*HeightResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockNumber not implemented")
      }
      func (UnimplementedRpcServiceServer) BlockByHash(context.Context, *BlockByHashRequest) (*BlockByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockByHash not implemented")
      }
      func (UnimplementedRpcServiceServer) BlockByNumber(context.Context, *BlockByNumberRequest) (*BlockByNumberResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockByNumber not implemented")
      }
      func (UnimplementedRpcServiceServer) BlockTransactionCountByHash(context.Context, *BlockTransactionCountByHashRequest) (*BlockTransactionCountByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockTransactionCountByHash not implemented")
      }
      func (UnimplementedRpcServiceServer) BlockTransactionCountByNumber(context.Context, *BlockTransactionCountByNumberRequest) (*BlockTransactionCountByNumberResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockTransactionCountByNumber not implemented")
      }
      func (UnimplementedRpcServiceServer) UncleCountByHash(context.Context, *UncleCountByHashRequest) (*UncleCountByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleCountByHash not implemented")
      }
      func (UnimplementedRpcServiceServer) UncleCountByNumber(context.Context, *UncleCountByNumberRequest) (*UncleCountByNumberResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleCountByNumber not implemented")
      }
      func (UnimplementedRpcServiceServer) UncleByBlockHashAndIndex(context.Context, *UncleByBlockHashAndIndexRequest) (*UncleByBlockHashAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleByBlockHashAndIndex not implemented")
      }
      func (UnimplementedRpcServiceServer) UncleByBlockNumberAndIndex(context.Context, *UncleByBlockNumberAndIndexRequest) (*UncleByBlockNumberAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleByBlockNumberAndIndex not implemented")
      }
      func (UnimplementedRpcServiceServer) Compilers(context.Context, *CompilersRequest) (*CompilersResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Compilers not implemented")
      }
      func (UnimplementedRpcServiceServer) CompileSolidity(context.Context, *CompileSolidityRequest) (*CompileSolidityResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CompileSolidity not implemented")
      }
      func (UnimplementedRpcServiceServer) CompileLLL(context.Context, *CompileLLLRequest) (*CompileLLLResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CompileLLL not implemented")
      }
      func (UnimplementedRpcServiceServer) CompileSerpent(context.Context, *CompileSerpentRequest) (*CompileSerpentResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CompileSerpent not implemented")
      }
      func (UnimplementedRpcServiceServer) EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method EstimateGas not implemented")
      }
      func (UnimplementedRpcServiceServer) TransactionByHash(context.Context, *TransactionByHashRequest) (*TransactionByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionByHash not implemented")
      }
      func (UnimplementedRpcServiceServer) TransactionByBlockHashAndIndex(context.Context, *TransactionByBlockHashAndIndexRequest) (*TransactionByBlockHashAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionByBlockHashAndIndex not implemented")
      }
      func (UnimplementedRpcServiceServer) TransactionByBlockNumberAndIndex(context.Context, *TransactionByBlockNumberAndIndexRequest) (*TransactionByBlockNumberAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionByBlockNumberAndIndex not implemented")
      }
      func (UnimplementedRpcServiceServer) TransactionReceipt(context.Context, *TransactionReceiptRequest) (*TransactionReceiptResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionReceipt not implemented")
      }
      func (UnimplementedRpcServiceServer) Balance(context.Context, *BalanceRequest) (*BalanceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented")
      }
      func (UnimplementedRpcServiceServer) Storage(context.Context, *StorageRequest) (*StorageResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Storage not implemented")
      }
      func (UnimplementedRpcServiceServer) Nonce(context.Context, *NonceRequest) (*NonceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Nonce not implemented")
      }
      func (UnimplementedRpcServiceServer) RepeatedNonce(context.Context, *RepeatedNonceRequest) (*RepeatedNonceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method RepeatedNonce not implemented")
      }
      func (UnimplementedRpcServiceServer) TransactionCount(context.Context, *TransactionCountRequest) (*TransactionCountResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionCount not implemented")
      }
      func (UnimplementedRpcServiceServer) GetCode(context.Context, *GetCodeRequest) (*GetCodeResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GetCode not implemented")
      }
      func (UnimplementedRpcServiceServer) Sign(context.Context, *SignRequest) (*SignResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented")
      }
      func (UnimplementedRpcServiceServer) SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SignTransaction not implemented")
      }
      func (UnimplementedRpcServiceServer) SendTransaction(context.Context, *v1.EthTransaction) (*SendTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SendTransaction not implemented")
      }
      func (UnimplementedRpcServiceServer) SendRawTransaction(context.Context, *v1.EthTransaction) (*SendRawTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SendRawTransaction not implemented")
      }
      func (UnimplementedRpcServiceServer) Call(context.Context, *CallRequest) (*CallResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Call not implemented")
      }
      func (UnimplementedRpcServiceServer) NewFilter(context.Context, *NewFilterRequest) (*NewFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NewFilter not implemented")
      }
      func (UnimplementedRpcServiceServer) NewBlockFilter(context.Context, *emptypb.Empty) (*NewBlockFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NewBlockFilter not implemented")
      }
      func (UnimplementedRpcServiceServer) PendingTransactionFilter(context.Context, *emptypb.Empty) (*PendingTransactionFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method PendingTransactionFilter not implemented")
      }
      func (UnimplementedRpcServiceServer) UninstallFilter(context.Context, *UninstallFilterRequest) (*UninstallFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UninstallFilter not implemented")
      }
      func (UnimplementedRpcServiceServer) FilterChanges(context.Context, *FilterChangesRequest) (*FilterChangesResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method FilterChanges not implemented")
      }
      func (UnimplementedRpcServiceServer) FilterLogs(context.Context, *FilterLogsRequest) (*FilterLogsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method FilterLogs not implemented")
      }
      func (UnimplementedRpcServiceServer) Logs(context.Context, *LogsRequest) (*LogsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Logs not implemented")
      }
      func (UnimplementedRpcServiceServer) mustEmbedUnimplementedRpcServiceServer() {}
      // UnsafeRpcServiceServer may be embedded to opt out of forward compatibility for this service.
      // Use of this interface is not recommended, as added methods to RpcServiceServer will
      // result in compilation errors.
      type UnsafeRpcServiceServer interface {
      mustEmbedUnimplementedRpcServiceServer()
      }
      func RegisterRpcServiceServer(s grpc.ServiceRegistrar, srv RpcServiceServer) {
      s.RegisterService(&RpcService_ServiceDesc, srv)
      }
      func _RpcService_Sha3_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(Sha3Request)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Sha3(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Sha3",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Sha3(ctx, req.(*Sha3Request))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_NodeVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).NodeVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/NodeVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).NodeVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_NetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).NetVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/NetVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).NetVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_NetPeerCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).NetPeerCount(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/NetPeerCount",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).NetPeerCount(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_ProtocolVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).ProtocolVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/ProtocolVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).ProtocolVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Syncing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Syncing(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Syncing",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Syncing(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Coinbase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Coinbase(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Coinbase",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Coinbase(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Mining_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Mining(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Mining",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Mining(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_HashRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).HashRate(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/HashRate",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).HashRate(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Accounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Accounts(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Accounts",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Accounts(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_GasPrice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).GasPrice(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/GasPrice",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).GasPrice(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_BlockNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).BlockNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/BlockNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).BlockNumber(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_BlockByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).BlockByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/BlockByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).BlockByHash(ctx, req.(*BlockByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_BlockByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockByNumberRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).BlockByNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/BlockByNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).BlockByNumber(ctx, req.(*BlockByNumberRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_BlockTransactionCountByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockTransactionCountByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).BlockTransactionCountByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/BlockTransactionCountByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).BlockTransactionCountByHash(ctx, req.(*BlockTransactionCountByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_BlockTransactionCountByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockTransactionCountByNumberRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).BlockTransactionCountByNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/BlockTransactionCountByNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).BlockTransactionCountByNumber(ctx, req.(*BlockTransactionCountByNumberRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_UncleCountByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleCountByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).UncleCountByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/UncleCountByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).UncleCountByHash(ctx, req.(*UncleCountByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_UncleCountByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleCountByNumberRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).UncleCountByNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/UncleCountByNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).UncleCountByNumber(ctx, req.(*UncleCountByNumberRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_UncleByBlockHashAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleByBlockHashAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).UncleByBlockHashAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/UncleByBlockHashAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).UncleByBlockHashAndIndex(ctx, req.(*UncleByBlockHashAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_UncleByBlockNumberAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleByBlockNumberAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).UncleByBlockNumberAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/UncleByBlockNumberAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).UncleByBlockNumberAndIndex(ctx, req.(*UncleByBlockNumberAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Compilers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompilersRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Compilers(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Compilers",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Compilers(ctx, req.(*CompilersRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_CompileSolidity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompileSolidityRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).CompileSolidity(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/CompileSolidity",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).CompileSolidity(ctx, req.(*CompileSolidityRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_CompileLLL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompileLLLRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).CompileLLL(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/CompileLLL",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).CompileLLL(ctx, req.(*CompileLLLRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_CompileSerpent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompileSerpentRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).CompileSerpent(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/CompileSerpent",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).CompileSerpent(ctx, req.(*CompileSerpentRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_EstimateGas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(EstimateGasRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).EstimateGas(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/EstimateGas",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).EstimateGas(ctx, req.(*EstimateGasRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_TransactionByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).TransactionByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/TransactionByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).TransactionByHash(ctx, req.(*TransactionByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_TransactionByBlockHashAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionByBlockHashAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).TransactionByBlockHashAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/TransactionByBlockHashAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).TransactionByBlockHashAndIndex(ctx, req.(*TransactionByBlockHashAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_TransactionByBlockNumberAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionByBlockNumberAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).TransactionByBlockNumberAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/TransactionByBlockNumberAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).TransactionByBlockNumberAndIndex(ctx, req.(*TransactionByBlockNumberAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_TransactionReceipt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionReceiptRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).TransactionReceipt(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/TransactionReceipt",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).TransactionReceipt(ctx, req.(*TransactionReceiptRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BalanceRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Balance(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Balance",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Balance(ctx, req.(*BalanceRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Storage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(StorageRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Storage(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Storage",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Storage(ctx, req.(*StorageRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Nonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(NonceRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Nonce(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Nonce",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Nonce(ctx, req.(*NonceRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_RepeatedNonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(RepeatedNonceRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).RepeatedNonce(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/RepeatedNonce",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).RepeatedNonce(ctx, req.(*RepeatedNonceRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_TransactionCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionCountRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).TransactionCount(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/TransactionCount",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).TransactionCount(ctx, req.(*TransactionCountRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_GetCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(GetCodeRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).GetCode(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/GetCode",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).GetCode(ctx, req.(*GetCodeRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SignRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Sign(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Sign",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Sign(ctx, req.(*SignRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_SignTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SignTransactionRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).SignTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/SignTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).SignTransaction(ctx, req.(*SignTransactionRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_SendTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(v1.EthTransaction)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).SendTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/SendTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).SendTransaction(ctx, req.(*v1.EthTransaction))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_SendRawTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(v1.EthTransaction)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).SendRawTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/SendRawTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).SendRawTransaction(ctx, req.(*v1.EthTransaction))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Call_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CallRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Call(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Call",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Call(ctx, req.(*CallRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_NewFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(NewFilterRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).NewFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/NewFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).NewFilter(ctx, req.(*NewFilterRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_NewBlockFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).NewBlockFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/NewBlockFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).NewBlockFilter(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_PendingTransactionFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).PendingTransactionFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/PendingTransactionFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).PendingTransactionFilter(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_UninstallFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UninstallFilterRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).UninstallFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/UninstallFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).UninstallFilter(ctx, req.(*UninstallFilterRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_FilterChanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(FilterChangesRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).FilterChanges(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/FilterChanges",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).FilterChanges(ctx, req.(*FilterChangesRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_FilterLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(FilterLogsRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).FilterLogs(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/FilterLogs",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).FilterLogs(ctx, req.(*FilterLogsRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RpcService_Logs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(LogsRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RpcServiceServer).Logs(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ethrpc.v1.RpcService/Logs",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RpcServiceServer).Logs(ctx, req.(*LogsRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      // RpcService_ServiceDesc is the grpc.ServiceDesc for RpcService service.
      // It's only intended for direct use with grpc.RegisterService,
      // and not to be introspected or modified (even as a copy)
      var RpcService_ServiceDesc = grpc.ServiceDesc{
      ServiceName: "ethrpc.v1.RpcService",
      HandlerType: (*RpcServiceServer)(nil),
      Methods: []grpc.MethodDesc{
      {
      MethodName: "Sha3",
      Handler: _RpcService_Sha3_Handler,
      },
      {
      MethodName: "NodeVersion",
      Handler: _RpcService_NodeVersion_Handler,
      },
      {
      MethodName: "NetVersion",
      Handler: _RpcService_NetVersion_Handler,
      },
      {
      MethodName: "NetPeerCount",
      Handler: _RpcService_NetPeerCount_Handler,
      },
      {
      MethodName: "ProtocolVersion",
      Handler: _RpcService_ProtocolVersion_Handler,
      },
      {
      MethodName: "Syncing",
      Handler: _RpcService_Syncing_Handler,
      },
      {
      MethodName: "Coinbase",
      Handler: _RpcService_Coinbase_Handler,
      },
      {
      MethodName: "Mining",
      Handler: _RpcService_Mining_Handler,
      },
      {
      MethodName: "HashRate",
      Handler: _RpcService_HashRate_Handler,
      },
      {
      MethodName: "Accounts",
      Handler: _RpcService_Accounts_Handler,
      },
      {
      MethodName: "GasPrice",
      Handler: _RpcService_GasPrice_Handler,
      },
      {
      MethodName: "BlockNumber",
      Handler: _RpcService_BlockNumber_Handler,
      },
      {
      MethodName: "BlockByHash",
      Handler: _RpcService_BlockByHash_Handler,
      },
      {
      MethodName: "BlockByNumber",
      Handler: _RpcService_BlockByNumber_Handler,
      },
      {
      MethodName: "BlockTransactionCountByHash",
      Handler: _RpcService_BlockTransactionCountByHash_Handler,
      },
      {
      MethodName: "BlockTransactionCountByNumber",
      Handler: _RpcService_BlockTransactionCountByNumber_Handler,
      },
      {
      MethodName: "UncleCountByHash",
      Handler: _RpcService_UncleCountByHash_Handler,
      },
      {
      MethodName: "UncleCountByNumber",
      Handler: _RpcService_UncleCountByNumber_Handler,
      },
      {
      MethodName: "UncleByBlockHashAndIndex",
      Handler: _RpcService_UncleByBlockHashAndIndex_Handler,
      },
      {
      MethodName: "UncleByBlockNumberAndIndex",
      Handler: _RpcService_UncleByBlockNumberAndIndex_Handler,
      },
      {
      MethodName: "Compilers",
      Handler: _RpcService_Compilers_Handler,
      },
      {
      MethodName: "CompileSolidity",
      Handler: _RpcService_CompileSolidity_Handler,
      },
      {
      MethodName: "CompileLLL",
      Handler: _RpcService_CompileLLL_Handler,
      },
      {
      MethodName: "CompileSerpent",
      Handler: _RpcService_CompileSerpent_Handler,
      },
      {
      MethodName: "EstimateGas",
      Handler: _RpcService_EstimateGas_Handler,
      },
      {
      MethodName: "TransactionByHash",
      Handler: _RpcService_TransactionByHash_Handler,
      },
      {
      MethodName: "TransactionByBlockHashAndIndex",
      Handler: _RpcService_TransactionByBlockHashAndIndex_Handler,
      },
      {
      MethodName: "TransactionByBlockNumberAndIndex",
      Handler: _RpcService_TransactionByBlockNumberAndIndex_Handler,
      },
      {
      MethodName: "TransactionReceipt",
      Handler: _RpcService_TransactionReceipt_Handler,
      },
      {
      MethodName: "Balance",
      Handler: _RpcService_Balance_Handler,
      },
      {
      MethodName: "Storage",
      Handler: _RpcService_Storage_Handler,
      },
      {
      MethodName: "Nonce",
      Handler: _RpcService_Nonce_Handler,
      },
      {
      MethodName: "RepeatedNonce",
      Handler: _RpcService_RepeatedNonce_Handler,
      },
      {
      MethodName: "TransactionCount",
      Handler: _RpcService_TransactionCount_Handler,
      },
      {
      MethodName: "GetCode",
      Handler: _RpcService_GetCode_Handler,
      },
      {
      MethodName: "Sign",
      Handler: _RpcService_Sign_Handler,
      },
      {
      MethodName: "SignTransaction",
      Handler: _RpcService_SignTransaction_Handler,
      },
      {
      MethodName: "SendTransaction",
      Handler: _RpcService_SendTransaction_Handler,
      },
      {
      MethodName: "SendRawTransaction",
      Handler: _RpcService_SendRawTransaction_Handler,
      },
      {
      MethodName: "Call",
      Handler: _RpcService_Call_Handler,
      },
      {
      MethodName: "NewFilter",
      Handler: _RpcService_NewFilter_Handler,
      },
      {
      MethodName: "NewBlockFilter",
      Handler: _RpcService_NewBlockFilter_Handler,
      },
      {
      MethodName: "PendingTransactionFilter",
      Handler: _RpcService_PendingTransactionFilter_Handler,
      },
      {
      MethodName: "UninstallFilter",
      Handler: _RpcService_UninstallFilter_Handler,
      },
      {
      MethodName: "FilterChanges",
      Handler: _RpcService_FilterChanges_Handler,
      },
      {
      MethodName: "FilterLogs",
      Handler: _RpcService_FilterLogs_Handler,
      },
      {
      MethodName: "Logs",
      Handler: _RpcService_Logs_Handler,
      },
      },
      Streams: []grpc.StreamDesc{},
      Metadata: "ethrpc/v1/service.proto",
      }
      MetaProtocol-main/gen/proto/go/nebula/v1/account_req_res.pb.go 0 → 100644
      View file @ 9234b25c
      This source diff could not be displayed because it is too large. You can view the blob instead.
      MetaProtocol-main/gen/proto/go/nebula/v1/request_response.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: nebula/v1/request_response.proto
      package nebulav1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      _ "github.com/gogo/protobuf/types"
      _ "google.golang.org/protobuf/types/known/fieldmaskpb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("nebula/v1/request_response.proto", fileDescriptor_4c600a7b006f1b4e) }
      var fileDescriptor_4c600a7b006f1b4e = []byte{
      // 245 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xc8, 0x4b, 0x4d, 0x2a,
      0xcd, 0x49, 0xd4, 0x2f, 0x33, 0xd4, 0x2f, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x89, 0x2f, 0x4a,
      0x2d, 0x2e, 0xc8, 0xcf, 0x2b, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0xa8,
      0xd0, 0x2b, 0x33, 0x94, 0x52, 0x48, 0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0xd5, 0x07, 0x4b, 0x24, 0x95,
      0xa6, 0xe9, 0xa7, 0x65, 0xa6, 0xe6, 0xa4, 0xc4, 0xe7, 0x26, 0x16, 0x67, 0x43, 0x14, 0x4b, 0xc9,
      0xa3, 0xab, 0x28, 0xc9, 0xcc, 0x4d, 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0x80, 0x2a, 0x90, 0x40, 0xb6,
      0xaf, 0x38, 0xbf, 0xb4, 0x28, 0x19, 0x6a, 0x8f, 0xd3, 0x5e, 0x46, 0x2e, 0xde, 0xe4, 0xfc, 0x5c,
      0x3d, 0xb8, 0x75, 0x4e, 0x22, 0x41, 0x10, 0x17, 0x05, 0x41, 0x1d, 0x14, 0x00, 0x52, 0x17, 0xc0,
      0x18, 0x15, 0x98, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0xef, 0x9c, 0x98,
      0x52, 0x9a, 0x9c, 0x5a, 0x5a, 0xec, 0x9b, 0x5a, 0x92, 0x58, 0x96, 0x5a, 0x04, 0x55, 0x94, 0x9c,
      0x9f, 0xa3, 0x0f, 0x12, 0x81, 0x73, 0xd2, 0x53, 0xf3, 0x20, 0x6e, 0xd2, 0x4f, 0xcf, 0xd7, 0x87,
      0x3b, 0xc1, 0x1a, 0xc2, 0x2a, 0x33, 0x5c, 0xc4, 0xc4, 0xec, 0x17, 0x11, 0xb1, 0x8a, 0x89, 0xd3,
      0x0f, 0x62, 0x79, 0x98, 0xe1, 0x29, 0x18, 0x3b, 0x26, 0xcc, 0xf0, 0x11, 0x93, 0x28, 0x9c, 0x1d,
      0xe3, 0x1e, 0xe0, 0x04, 0x32, 0x39, 0x25, 0xb1, 0x24, 0xf1, 0x15, 0x13, 0x17, 0x44, 0xdc, 0xca,
      0x2a, 0xcc, 0x30, 0x89, 0x0d, 0x6c, 0xbe, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xfd, 0x29, 0xf8,
      0x97, 0x52, 0x01, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/nebula/v1/resource.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: nebula/v1/resource.proto
      package nebulav1
      import (
      fmt "fmt"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base/v1"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("nebula/v1/resource.proto", fileDescriptor_77da30a6e0efe5d2) }
      var fileDescriptor_77da30a6e0efe5d2 = []byte{
      // 191 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xc8, 0x4b, 0x4d, 0x2a,
      0xcd, 0x49, 0xd4, 0x2f, 0x33, 0xd4, 0x2f, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5, 0x2b,
      0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0xc8, 0xe8, 0x95, 0x19, 0x4a, 0x89, 0x25, 0x25, 0x16,
      0xa7, 0x62, 0x2a, 0x71, 0xda, 0xc6, 0xc8, 0xc5, 0x9b, 0x9c, 0x9f, 0xab, 0x07, 0x57, 0xe9, 0xc4,
      0x1b, 0x04, 0x55, 0x11, 0x00, 0x52, 0x10, 0xc0, 0x18, 0x15, 0x98, 0x9e, 0x59, 0x92, 0x51, 0x9a,
      0xa4, 0x97, 0x9c, 0x9f, 0xab, 0xef, 0x9c, 0x98, 0x52, 0x9a, 0x9c, 0x5a, 0x5a, 0xec, 0x9b, 0x5a,
      0x92, 0x58, 0x96, 0x5a, 0x54, 0x0c, 0x51, 0x94, 0x9c, 0x9f, 0xa3, 0x0f, 0x12, 0x81, 0x73, 0xd2,
      0x53, 0xf3, 0xf4, 0xc1, 0xe6, 0xeb, 0xa7, 0xe7, 0xeb, 0xc3, 0x9d, 0x67, 0x0d, 0x61, 0x95, 0x19,
      0x2e, 0x62, 0x62, 0xf6, 0x8b, 0x88, 0x58, 0xc5, 0xc4, 0xe9, 0x07, 0xb1, 0x35, 0xcc, 0xf0, 0x14,
      0x8c, 0x1d, 0x13, 0x66, 0xf8, 0x88, 0x49, 0x14, 0xce, 0x8e, 0x71, 0x0f, 0x70, 0x02, 0x99, 0x9c,
      0x92, 0x58, 0x92, 0xf8, 0x8a, 0x89, 0x0b, 0x22, 0x6e, 0x65, 0x15, 0x66, 0x98, 0xc4, 0x06, 0x36,
      0xdf, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x40, 0xfc, 0xf1, 0x0d, 0xfe, 0x00, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/nebula/v1/service.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: nebula/v1/service.proto
      package nebulav1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      _ "google.golang.org/protobuf/types/known/emptypb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("nebula/v1/service.proto", fileDescriptor_95d7c4e681b05ee0) }
      var fileDescriptor_95d7c4e681b05ee0 = []byte{
      // 1130 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x98, 0xcf, 0x73, 0xdb, 0x44,
      0x14, 0xc7, 0x49, 0x80, 0x96, 0x6c, 0x9b, 0x16, 0xc4, 0xd0, 0x04, 0x87, 0xfc, 0x24, 0x70, 0x00,
      0x2a, 0xd7, 0xcd, 0x89, 0x02, 0xc3, 0xc4, 0x9e, 0x90, 0x74, 0x70, 0x84, 0x49, 0xd2, 0xd0, 0xe9,
      0x94, 0x81, 0xb5, 0xf4, 0xaa, 0x68, 0x90, 0x77, 0x5d, 0x69, 0xed, 0xe0, 0x61, 0x86, 0x13, 0x33,
      0x9c, 0xb8, 0x73, 0xe6, 0xc8, 0x9d, 0x7f, 0x82, 0x3f, 0x83, 0x23, 0x7f, 0x45, 0x47, 0x5a, 0xed,
      0xe6, 0xad, 0xb4, 0xb2, 0xdd, 0x9b, 0xf3, 0xbe, 0xdf, 0xf7, 0xd9, 0xb7, 0x3b, 0xbb, 0x6f, 0x37,
      0x22, 0x2b, 0x0c, 0xfa, 0xa3, 0x98, 0x36, 0xc7, 0xad, 0x66, 0x0a, 0xc9, 0x38, 0xf2, 0xc1, 0x1d,
      0x26, 0x5c, 0x70, 0x67, 0x49, 0x0a, 0xee, 0xb8, 0xd5, 0x58, 0x0b, 0x39, 0x0f, 0x63, 0x68, 0xe6,
      0x42, 0x7f, 0xf4, 0xac, 0x09, 0x83, 0xa1, 0x98, 0x48, 0x5f, 0x63, 0xeb, 0x0a, 0x90, 0xc0, 0xf3,
      0x11, 0xa4, 0xe2, 0x87, 0x04, 0xd2, 0x21, 0x67, 0x69, 0x41, 0x6a, 0x6c, 0x5e, 0x39, 0xa8, 0xef,
      0xf3, 0x11, 0xcb, 0x1c, 0xcf, 0x33, 0x97, 0x34, 0xdc, 0xff, 0x73, 0x8b, 0x2c, 0x7b, 0xb9, 0xe7,
      0x54, 0x96, 0xe0, 0x7c, 0x4a, 0x5e, 0x3b, 0xbd, 0xa0, 0x7b, 0xce, 0x1d, 0x57, 0x57, 0xe1, 0x66,
      0x81, 0x13, 0x39, 0x42, 0x63, 0xa5, 0x12, 0x97, 0x23, 0xee, 0xbc, 0xe2, 0x1c, 0x92, 0x1b, 0x1e,
      0x0f, 0xe0, 0x1c, 0x92, 0x34, 0xe2, 0xcc, 0xb9, 0xe3, 0xca, 0xe2, 0x5d, 0x55, 0xbc, 0x7b, 0x90,
      0x15, 0xdf, 0xd8, 0x40, 0x04, 0xe4, 0x47, 0xa0, 0x03, 0x42, 0x3c, 0x10, 0xb3, 0x38, 0xeb, 0x98,
      0xa3, 0xed, 0x08, 0xf3, 0x90, 0xdc, 0xf4, 0x40, 0xf4, 0x00, 0x92, 0x4e, 0x36, 0xf5, 0x5a, 0xd0,
      0xa6, 0x09, 0xd2, 0x09, 0x08, 0xf5, 0x0d, 0xb9, 0xdd, 0xcb, 0x92, 0x7c, 0x1e, 0xcf, 0x2a, 0x6b,
      0x07, 0xd1, 0x4a, 0x39, 0x08, 0xf8, 0x25, 0xb9, 0x7e, 0x3a, 0x61, 0x7e, 0xc4, 0xc2, 0x5a, 0x50,
      0x03, 0xaf, 0xb4, 0xf4, 0x22, 0xc0, 0x3e, 0x79, 0xa3, 0xc3, 0x23, 0xd6, 0xa7, 0x29, 0xd4, 0x12,
      0xd6, 0x10, 0x41, 0x99, 0x11, 0xe2, 0x0b, 0x72, 0xed, 0x38, 0x62, 0xd3, 0x4a, 0x78, 0x17, 0x01,
      0xa4, 0xd5, 0xac, 0xe0, 0x88, 0xa6, 0x17, 0x27, 0x54, 0xcc, 0x57, 0x81, 0x32, 0x9b, 0x88, 0x7d,
      0xb9, 0x2f, 0xd3, 0xb9, 0x10, 0xca, 0x6c, 0x22, 0x0e, 0x69, 0xda, 0x4b, 0xb2, 0xbd, 0x3b, 0x0f,
      0x42, 0x99, 0x11, 0xa2, 0x4d, 0x6e, 0xb4, 0x63, 0xee, 0xff, 0xe4, 0x8d, 0x06, 0x7d, 0x48, 0xe6,
      0x5a, 0x8c, 0x23, 0x88, 0xc2, 0x0b, 0xbc, 0x41, 0xbc, 0x82, 0xd1, 0x9e, 0x64, 0xd3, 0x74, 0xf0,
      0xde, 0x44, 0x71, 0x75, 0x88, 0x36, 0xea, 0x64, 0xcd, 0x3b, 0x23, 0xcb, 0x85, 0x50, 0x54, 0xb5,
      0x59, 0x4d, 0x91, 0x8a, 0x62, 0x6e, 0xd5, 0x1b, 0x34, 0xf5, 0x57, 0xb2, 0x96, 0x4b, 0x67, 0x09,
      0x65, 0x29, 0xf5, 0x45, 0xc4, 0x59, 0xbe, 0xd3, 0x8b, 0xaa, 0xef, 0x96, 0x11, 0x76, 0x9f, 0x1a,
      0xd1, 0x9d, 0xd7, 0xae, 0xc7, 0xff, 0x6d, 0x81, 0xac, 0xd7, 0x38, 0x8b, 0x69, 0x36, 0x67, 0x33,
      0xcd, 0x69, 0xdf, 0x9b, 0x3f, 0x41, 0x97, 0xf1, 0x3d, 0x79, 0xf3, 0x11, 0xf3, 0x63, 0xc0, 0x73,
      0xc7, 0xc7, 0xb6, 0x2c, 0xaa, 0xb1, 0xde, 0x9f, 0xea, 0xd1, 0x78, 0x9f, 0x38, 0x58, 0x2d, 0x66,
      0xb6, 0x5b, 0x93, 0x6c, 0x4e, 0xe7, 0x83, 0x19, 0x2e, 0x3d, 0xc8, 0x88, 0xac, 0xe6, 0x7a, 0x7b,
      0x92, 0xcf, 0x3a, 0x2b, 0x61, 0x9f, 0x05, 0x0f, 0x59, 0x00, 0x3f, 0x3b, 0x1f, 0x95, 0x21, 0x16,
      0x93, 0x1a, 0xf0, 0xe3, 0xb9, 0xbc, 0x7a, 0xd8, 0x5f, 0x48, 0x03, 0xbb, 0x64, 0x59, 0x7a, 0xe0,
      0x4f, 0x6a, 0x60, 0xa6, 0x4d, 0x0d, 0x7d, 0x77, 0x4e, 0xb7, 0x1e, 0xfc, 0x88, 0x2c, 0x75, 0xf8,
      0x60, 0x18, 0xc5, 0x90, 0xa4, 0x8e, 0xd9, 0xdc, 0x8a, 0xa8, 0x42, 0xbf, 0x67, 0x17, 0x35, 0xe9,
      0x09, 0xb9, 0x5d, 0x84, 0x4f, 0x79, 0x1c, 0x05, 0x91, 0x98, 0x38, 0xdb, 0xd5, 0x14, 0xa5, 0x29,
      0xea, 0xce, 0x34, 0x8b, 0x66, 0x7f, 0x4d, 0x48, 0x21, 0x76, 0xbb, 0x5d, 0xc7, 0x52, 0x49, 0xb7,
      0xdb, 0x55, 0xc4, 0xf5, 0x1a, 0x55, 0xc3, 0xbe, 0x23, 0xb7, 0xd4, 0x48, 0x90, 0x0c, 0x81, 0x09,
      0x67, 0xcb, 0x52, 0x84, 0x94, 0x14, 0x74, 0x7b, 0x8a, 0x03, 0x37, 0xac, 0x83, 0x54, 0x44, 0x03,
      0x2a, 0xe0, 0x90, 0xa6, 0x46, 0xc3, 0x42, 0x71, 0x5b, 0xc3, 0x32, 0x64, 0xcd, 0xfb, 0x91, 0xbc,
      0x85, 0x4e, 0x5e, 0x71, 0xa8, 0xf0, 0x81, 0xa9, 0xa8, 0x8a, 0xbd, 0x3b, 0xdd, 0xa4, 0x47, 0xf8,
      0x7d, 0x81, 0x6c, 0x18, 0x7a, 0x75, 0xe3, 0xdf, 0xab, 0x43, 0xd5, 0x6e, 0xff, 0xd6, 0x4b, 0x64,
      0xe8, 0x4a, 0xfe, 0x58, 0x20, 0x5b, 0x55, 0x73, 0xe9, 0x2c, 0xdc, 0x9f, 0x4a, 0xb6, 0x9f, 0x88,
      0xbd, 0x97, 0xca, 0xc1, 0x0d, 0x07, 0xb9, 0x4f, 0xc0, 0x87, 0x68, 0x28, 0x9c, 0x9a, 0x75, 0x2d,
      0x64, 0x5b, 0xc3, 0xb1, 0xb9, 0xd0, 0x2d, 0x79, 0xbd, 0x4d, 0x63, 0xca, 0x7c, 0x70, 0xf0, 0x4d,
      0x58, 0xc4, 0x14, 0xae, 0x61, 0x93, 0x30, 0xe3, 0x54, 0xf0, 0x84, 0x86, 0x26, 0xa3, 0x88, 0xd9,
      0x18, 0x5a, 0xd2, 0x8c, 0xcf, 0xc9, 0xeb, 0x1e, 0xcf, 0xaa, 0x58, 0x31, 0xde, 0x91, 0xa8, 0x86,
      0xd5, 0xaa, 0x80, 0xef, 0xd5, 0x13, 0x18, 0x02, 0x15, 0x10, 0x48, 0x0a, 0xbe, 0x57, 0x0d, 0xc5,
      0x76, 0xaf, 0x96, 0x0c, 0xf8, 0x42, 0x29, 0x5f, 0x3b, 0xc6, 0x85, 0x52, 0x16, 0x6d, 0x17, 0x4a,
      0xd5, 0x83, 0x97, 0xed, 0x10, 0x44, 0x87, 0x07, 0xe6, 0xb2, 0x15, 0x31, 0xdb, 0xb2, 0x69, 0x49,
      0x33, 0xb2, 0x77, 0x7d, 0x14, 0x32, 0xf3, 0x5d, 0x1f, 0x85, 0xcc, 0xfa, 0xae, 0xcf, 0xe3, 0xb8,
      0x59, 0x66, 0x11, 0x54, 0xa0, 0xd1, 0x2c, 0x4b, 0x9a, 0xad, 0x59, 0x56, 0x2c, 0x06, 0x1b, 0x58,
      0x50, 0xcb, 0x36, 0x35, 0x2b, 0xbb, 0x6c, 0xc1, 0xc7, 0x22, 0x13, 0x4f, 0xe8, 0x25, 0xc6, 0xef,
      0x96, 0x72, 0x4d, 0xd9, 0x76, 0x2c, 0x6c, 0x2e, 0xbc, 0xae, 0x1d, 0x1a, 0xc7, 0xc6, 0xba, 0x66,
      0x01, 0xdb, 0xba, 0xca, 0xb8, 0x4e, 0x7d, 0x46, 0xde, 0x3e, 0x83, 0x54, 0x94, 0xe7, 0x6f, 0x9c,
      0xc8, 0xaa, 0xae, 0xc0, 0x1f, 0xce, 0xb2, 0xe1, 0x6b, 0xd3, 0x83, 0xcb, 0xaf, 0xa2, 0x58, 0x40,
      0x62, 0x5c, 0x9b, 0x3a, 0x6a, 0xbb, 0x36, 0x91, 0xa8, 0x49, 0xc7, 0xe4, 0x96, 0x07, 0x97, 0x79,
      0x33, 0x2a, 0x70, 0x75, 0x8f, 0xe5, 0x6d, 0x93, 0x84, 0x52, 0x10, 0x8e, 0x92, 0xd5, 0x1e, 0xb0,
      0x20, 0x62, 0x21, 0x2a, 0x7c, 0x06, 0x18, 0xbf, 0x57, 0xea, 0x92, 0xcd, 0xfd, 0xf5, 0x88, 0x45,
      0x2c, 0x15, 0x34, 0x8e, 0x0b, 0xf2, 0xb6, 0xf1, 0xec, 0x30, 0x34, 0xdb, 0xfe, 0xaa, 0x58, 0x70,
      0x2f, 0x91, 0xb1, 0xce, 0x05, 0x65, 0x21, 0xa4, 0x46, 0x2f, 0x31, 0x14, 0x5b, 0x2f, 0x29, 0x19,
      0xf0, 0xf3, 0x41, 0x4a, 0x5d, 0x1e, 0xa6, 0xc6, 0xf3, 0xe1, 0x2a, 0x6c, 0x7b, 0x3e, 0x60, 0x15,
      0xef, 0xce, 0x1c, 0x83, 0x77, 0x27, 0x06, 0xac, 0x54, 0xe2, 0x2a, 0xb5, 0xfd, 0xcf, 0x02, 0x59,
      0xf6, 0xf9, 0xe0, 0xca, 0xd0, 0xbe, 0x59, 0x7c, 0x23, 0xc8, 0xff, 0xab, 0xed, 0x2d, 0x3c, 0xf9,
      0x36, 0x8c, 0xc4, 0xc5, 0xa8, 0xef, 0xfa, 0x7c, 0xd0, 0xec, 0xd0, 0x60, 0xe4, 0xc3, 0x28, 0x3d,
      0x06, 0x41, 0xc7, 0x90, 0xa4, 0xa0, 0xfe, 0xf5, 0x6d, 0x66, 0x11, 0xfd, 0x47, 0x08, 0x4c, 0x7e,
      0xcb, 0x68, 0x86, 0xbc, 0xa9, 0x3f, 0x4e, 0x7c, 0x26, 0x7f, 0x8d, 0x5b, 0x7f, 0x2d, 0xbe, 0xea,
      0x3d, 0x7e, 0xfc, 0xf7, 0xe2, 0x92, 0xfc, 0x26, 0xe1, 0x9e, 0xb7, 0xfe, 0x55, 0xbf, 0x9f, 0x9e,
      0xb7, 0xfe, 0x5b, 0x7c, 0x47, 0xff, 0x7e, 0x7a, 0xd8, 0x6b, 0x67, 0xe4, 0x80, 0x0a, 0xfa, 0xff,
      0x22, 0x91, 0xf1, 0x07, 0x0f, 0xce, 0x5b, 0xfd, 0x6b, 0x39, 0x7f, 0xef, 0x45, 0x00, 0x00, 0x00,
      0xff, 0xff, 0x01, 0x64, 0xc6, 0x58, 0x5f, 0x11, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/nebula/v1/service_grpc.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
      // versions:
      // - protoc-gen-go-grpc v1.2.0
      // - protoc (unknown)
      // source: nebula/v1/service.proto
      package nebulav1
      import (
      context "context"
      grpc "google.golang.org/grpc"
      codes "google.golang.org/grpc/codes"
      status "google.golang.org/grpc/status"
      emptypb "google.golang.org/protobuf/types/known/emptypb"
      )
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the grpc package it is being compiled against.
      // Requires gRPC-Go v1.32.0 or later.
      const _ = grpc.SupportPackageIsVersion7
      // NebulaServiceClient is the client API for NebulaService service.
      //
      // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
      type NebulaServiceClient interface {
      // web3
      Sha3(ctx context.Context, in *Sha3Request, opts ...grpc.CallOption) (*Sha3Response, error)
      NodeVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NodeVersionResponse, error)
      // network info service
      NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error)
      NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error)
      // node status
      ProtocolVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ProtocolVersionResponse, error)
      Syncing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SyncingResponse, error)
      Coinbase(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CoinbaseResponse, error)
      Mining(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*MiningResponse, error)
      HashRate(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HashRateResponse, error)
      Accounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AccountsResponse, error)
      // tx operatoration
      GasPrice(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GasPriceResponse, error)
      // block info service
      BlockNumber(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HeightResponse, error)
      BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (*BlockByHashResponse, error)
      BlockByNumber(ctx context.Context, in *BlockByNumberRequest, opts ...grpc.CallOption) (*BlockByNumberResponse, error)
      BlockTransactionCountByHash(ctx context.Context, in *BlockTransactionCountByHashRequest, opts ...grpc.CallOption) (*BlockTransactionCountByHashResponse, error)
      BlockTransactionCountByNumber(ctx context.Context, in *BlockTransactionCountByNumberRequest, opts ...grpc.CallOption) (*BlockTransactionCountByNumberResponse, error)
      UncleCountByHash(ctx context.Context, in *UncleCountByHashRequest, opts ...grpc.CallOption) (*UncleCountByHashResponse, error)
      UncleCountByNumber(ctx context.Context, in *UncleCountByNumberRequest, opts ...grpc.CallOption) (*UncleCountByNumberResponse, error)
      UncleByBlockHashAndIndex(ctx context.Context, in *UncleByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockHashAndIndexResponse, error)
      UncleByBlockNumberAndIndex(ctx context.Context, in *UncleByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockNumberAndIndexResponse, error)
      // compiler
      Compilers(ctx context.Context, in *CompilersRequest, opts ...grpc.CallOption) (*CompilersResponse, error)
      CompileSolidity(ctx context.Context, in *CompileSolidityRequest, opts ...grpc.CallOption) (*CompileSolidityResponse, error)
      CompileLLL(ctx context.Context, in *CompileLLLRequest, opts ...grpc.CallOption) (*CompileLLLResponse, error)
      CompileSerpent(ctx context.Context, in *CompileSerpentRequest, opts ...grpc.CallOption) (*CompileSerpentResponse, error)
      // transaction info service
      EstimateGas(ctx context.Context, in *EstimateGasRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error)
      TransactionByHash(ctx context.Context, in *TransactionByHashRequest, opts ...grpc.CallOption) (*TransactionByHashResponse, error)
      TransactionByBlockHashAndIndex(ctx context.Context, in *TransactionByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockHashAndIndexResponse, error)
      TransactionByBlockNumberAndIndex(ctx context.Context, in *TransactionByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockNumberAndIndexResponse, error)
      TransactionReceipt(ctx context.Context, in *TransactionReceiptRequest, opts ...grpc.CallOption) (*TransactionReceiptResponse, error)
      // account info service
      Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error)
      Storage(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error)
      Nonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResponse, error)
      RepeatedNonce(ctx context.Context, in *RepeatedNonceRequest, opts ...grpc.CallOption) (*RepeatedNonceResponse, error)
      TransactionCount(ctx context.Context, in *TransactionCountRequest, opts ...grpc.CallOption) (*TransactionCountResponse, error)
      GetCode(ctx context.Context, in *GetCodeRequest, opts ...grpc.CallOption) (*GetCodeResponse, error)
      Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
      SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error)
      SendTransaction(ctx context.Context, in *SendTransactionRequest, opts ...grpc.CallOption) (*SendTransactionResponse, error)
      SendRawTransaction(ctx context.Context, in *SendRawTransactionRequest, opts ...grpc.CallOption) (*SendRawTransactionResponse, error)
      Call(ctx context.Context, in *CallRequest, opts ...grpc.CallOption) (*CallResponse, error)
      TestSendTransaction(ctx context.Context, in *TestSendTransactionRequest, opts ...grpc.CallOption) (*TestSendTransactionResponse, error)
      // filter
      NewFilter(ctx context.Context, in *NewFilterRequest, opts ...grpc.CallOption) (*NewFilterResponse, error)
      NewBlockFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NewBlockFilterResponse, error)
      PendingTransactionFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PendingTransactionFilterResponse, error)
      UninstallFilter(ctx context.Context, in *UninstallFilterRequest, opts ...grpc.CallOption) (*UninstallFilterResponse, error)
      FilterChanges(ctx context.Context, in *FilterChangesRequest, opts ...grpc.CallOption) (*FilterChangesResponse, error)
      FilterLogs(ctx context.Context, in *FilterLogsRequest, opts ...grpc.CallOption) (*FilterLogsResponse, error)
      Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (*LogsResponse, error)
      }
      type nebulaServiceClient struct {
      cc grpc.ClientConnInterface
      }
      func NewNebulaServiceClient(cc grpc.ClientConnInterface) NebulaServiceClient {
      return &nebulaServiceClient{cc}
      }
      func (c *nebulaServiceClient) Sha3(ctx context.Context, in *Sha3Request, opts ...grpc.CallOption) (*Sha3Response, error) {
      out := new(Sha3Response)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Sha3", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) NodeVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NodeVersionResponse, error) {
      out := new(NodeVersionResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NodeVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error) {
      out := new(NetVersionResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NetVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error) {
      out := new(NetPeerCountResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NetPeerCount", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) ProtocolVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ProtocolVersionResponse, error) {
      out := new(ProtocolVersionResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/ProtocolVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Syncing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SyncingResponse, error) {
      out := new(SyncingResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Syncing", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Coinbase(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CoinbaseResponse, error) {
      out := new(CoinbaseResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Coinbase", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Mining(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*MiningResponse, error) {
      out := new(MiningResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Mining", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) HashRate(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HashRateResponse, error) {
      out := new(HashRateResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/HashRate", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Accounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AccountsResponse, error) {
      out := new(AccountsResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Accounts", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) GasPrice(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GasPriceResponse, error) {
      out := new(GasPriceResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/GasPrice", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) BlockNumber(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HeightResponse, error) {
      out := new(HeightResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (*BlockByHashResponse, error) {
      out := new(BlockByHashResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) BlockByNumber(ctx context.Context, in *BlockByNumberRequest, opts ...grpc.CallOption) (*BlockByNumberResponse, error) {
      out := new(BlockByNumberResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockByNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) BlockTransactionCountByHash(ctx context.Context, in *BlockTransactionCountByHashRequest, opts ...grpc.CallOption) (*BlockTransactionCountByHashResponse, error) {
      out := new(BlockTransactionCountByHashResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockTransactionCountByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) BlockTransactionCountByNumber(ctx context.Context, in *BlockTransactionCountByNumberRequest, opts ...grpc.CallOption) (*BlockTransactionCountByNumberResponse, error) {
      out := new(BlockTransactionCountByNumberResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockTransactionCountByNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) UncleCountByHash(ctx context.Context, in *UncleCountByHashRequest, opts ...grpc.CallOption) (*UncleCountByHashResponse, error) {
      out := new(UncleCountByHashResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UncleCountByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) UncleCountByNumber(ctx context.Context, in *UncleCountByNumberRequest, opts ...grpc.CallOption) (*UncleCountByNumberResponse, error) {
      out := new(UncleCountByNumberResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UncleCountByNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) UncleByBlockHashAndIndex(ctx context.Context, in *UncleByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockHashAndIndexResponse, error) {
      out := new(UncleByBlockHashAndIndexResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UncleByBlockHashAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) UncleByBlockNumberAndIndex(ctx context.Context, in *UncleByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockNumberAndIndexResponse, error) {
      out := new(UncleByBlockNumberAndIndexResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UncleByBlockNumberAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Compilers(ctx context.Context, in *CompilersRequest, opts ...grpc.CallOption) (*CompilersResponse, error) {
      out := new(CompilersResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Compilers", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) CompileSolidity(ctx context.Context, in *CompileSolidityRequest, opts ...grpc.CallOption) (*CompileSolidityResponse, error) {
      out := new(CompileSolidityResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/CompileSolidity", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) CompileLLL(ctx context.Context, in *CompileLLLRequest, opts ...grpc.CallOption) (*CompileLLLResponse, error) {
      out := new(CompileLLLResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/CompileLLL", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) CompileSerpent(ctx context.Context, in *CompileSerpentRequest, opts ...grpc.CallOption) (*CompileSerpentResponse, error) {
      out := new(CompileSerpentResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/CompileSerpent", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) EstimateGas(ctx context.Context, in *EstimateGasRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error) {
      out := new(EstimateGasResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/EstimateGas", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) TransactionByHash(ctx context.Context, in *TransactionByHashRequest, opts ...grpc.CallOption) (*TransactionByHashResponse, error) {
      out := new(TransactionByHashResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) TransactionByBlockHashAndIndex(ctx context.Context, in *TransactionByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockHashAndIndexResponse, error) {
      out := new(TransactionByBlockHashAndIndexResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionByBlockHashAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) TransactionByBlockNumberAndIndex(ctx context.Context, in *TransactionByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockNumberAndIndexResponse, error) {
      out := new(TransactionByBlockNumberAndIndexResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionByBlockNumberAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) TransactionReceipt(ctx context.Context, in *TransactionReceiptRequest, opts ...grpc.CallOption) (*TransactionReceiptResponse, error) {
      out := new(TransactionReceiptResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionReceipt", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error) {
      out := new(BalanceResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Balance", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Storage(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error) {
      out := new(StorageResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Storage", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Nonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResponse, error) {
      out := new(NonceResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Nonce", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) RepeatedNonce(ctx context.Context, in *RepeatedNonceRequest, opts ...grpc.CallOption) (*RepeatedNonceResponse, error) {
      out := new(RepeatedNonceResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/RepeatedNonce", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) TransactionCount(ctx context.Context, in *TransactionCountRequest, opts ...grpc.CallOption) (*TransactionCountResponse, error) {
      out := new(TransactionCountResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionCount", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) GetCode(ctx context.Context, in *GetCodeRequest, opts ...grpc.CallOption) (*GetCodeResponse, error) {
      out := new(GetCodeResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/GetCode", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
      out := new(SignResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Sign", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error) {
      out := new(SignTransactionResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/SignTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) SendTransaction(ctx context.Context, in *SendTransactionRequest, opts ...grpc.CallOption) (*SendTransactionResponse, error) {
      out := new(SendTransactionResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/SendTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) SendRawTransaction(ctx context.Context, in *SendRawTransactionRequest, opts ...grpc.CallOption) (*SendRawTransactionResponse, error) {
      out := new(SendRawTransactionResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/SendRawTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Call(ctx context.Context, in *CallRequest, opts ...grpc.CallOption) (*CallResponse, error) {
      out := new(CallResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Call", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) TestSendTransaction(ctx context.Context, in *TestSendTransactionRequest, opts ...grpc.CallOption) (*TestSendTransactionResponse, error) {
      out := new(TestSendTransactionResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TestSendTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) NewFilter(ctx context.Context, in *NewFilterRequest, opts ...grpc.CallOption) (*NewFilterResponse, error) {
      out := new(NewFilterResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NewFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) NewBlockFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NewBlockFilterResponse, error) {
      out := new(NewBlockFilterResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NewBlockFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) PendingTransactionFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PendingTransactionFilterResponse, error) {
      out := new(PendingTransactionFilterResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/PendingTransactionFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) UninstallFilter(ctx context.Context, in *UninstallFilterRequest, opts ...grpc.CallOption) (*UninstallFilterResponse, error) {
      out := new(UninstallFilterResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UninstallFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) FilterChanges(ctx context.Context, in *FilterChangesRequest, opts ...grpc.CallOption) (*FilterChangesResponse, error) {
      out := new(FilterChangesResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/FilterChanges", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) FilterLogs(ctx context.Context, in *FilterLogsRequest, opts ...grpc.CallOption) (*FilterLogsResponse, error) {
      out := new(FilterLogsResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/FilterLogs", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *nebulaServiceClient) Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (*LogsResponse, error) {
      out := new(LogsResponse)
      err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Logs", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      // NebulaServiceServer is the server API for NebulaService service.
      // All implementations must embed UnimplementedNebulaServiceServer
      // for forward compatibility
      type NebulaServiceServer interface {
      // web3
      Sha3(context.Context, *Sha3Request) (*Sha3Response, error)
      NodeVersion(context.Context, *emptypb.Empty) (*NodeVersionResponse, error)
      // network info service
      NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error)
      NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error)
      // node status
      ProtocolVersion(context.Context, *emptypb.Empty) (*ProtocolVersionResponse, error)
      Syncing(context.Context, *emptypb.Empty) (*SyncingResponse, error)
      Coinbase(context.Context, *emptypb.Empty) (*CoinbaseResponse, error)
      Mining(context.Context, *emptypb.Empty) (*MiningResponse, error)
      HashRate(context.Context, *emptypb.Empty) (*HashRateResponse, error)
      Accounts(context.Context, *emptypb.Empty) (*AccountsResponse, error)
      // tx operatoration
      GasPrice(context.Context, *emptypb.Empty) (*GasPriceResponse, error)
      // block info service
      BlockNumber(context.Context, *emptypb.Empty) (*HeightResponse, error)
      BlockByHash(context.Context, *BlockByHashRequest) (*BlockByHashResponse, error)
      BlockByNumber(context.Context, *BlockByNumberRequest) (*BlockByNumberResponse, error)
      BlockTransactionCountByHash(context.Context, *BlockTransactionCountByHashRequest) (*BlockTransactionCountByHashResponse, error)
      BlockTransactionCountByNumber(context.Context, *BlockTransactionCountByNumberRequest) (*BlockTransactionCountByNumberResponse, error)
      UncleCountByHash(context.Context, *UncleCountByHashRequest) (*UncleCountByHashResponse, error)
      UncleCountByNumber(context.Context, *UncleCountByNumberRequest) (*UncleCountByNumberResponse, error)
      UncleByBlockHashAndIndex(context.Context, *UncleByBlockHashAndIndexRequest) (*UncleByBlockHashAndIndexResponse, error)
      UncleByBlockNumberAndIndex(context.Context, *UncleByBlockNumberAndIndexRequest) (*UncleByBlockNumberAndIndexResponse, error)
      // compiler
      Compilers(context.Context, *CompilersRequest) (*CompilersResponse, error)
      CompileSolidity(context.Context, *CompileSolidityRequest) (*CompileSolidityResponse, error)
      CompileLLL(context.Context, *CompileLLLRequest) (*CompileLLLResponse, error)
      CompileSerpent(context.Context, *CompileSerpentRequest) (*CompileSerpentResponse, error)
      // transaction info service
      EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error)
      TransactionByHash(context.Context, *TransactionByHashRequest) (*TransactionByHashResponse, error)
      TransactionByBlockHashAndIndex(context.Context, *TransactionByBlockHashAndIndexRequest) (*TransactionByBlockHashAndIndexResponse, error)
      TransactionByBlockNumberAndIndex(context.Context, *TransactionByBlockNumberAndIndexRequest) (*TransactionByBlockNumberAndIndexResponse, error)
      TransactionReceipt(context.Context, *TransactionReceiptRequest) (*TransactionReceiptResponse, error)
      // account info service
      Balance(context.Context, *BalanceRequest) (*BalanceResponse, error)
      Storage(context.Context, *StorageRequest) (*StorageResponse, error)
      Nonce(context.Context, *NonceRequest) (*NonceResponse, error)
      RepeatedNonce(context.Context, *RepeatedNonceRequest) (*RepeatedNonceResponse, error)
      TransactionCount(context.Context, *TransactionCountRequest) (*TransactionCountResponse, error)
      GetCode(context.Context, *GetCodeRequest) (*GetCodeResponse, error)
      Sign(context.Context, *SignRequest) (*SignResponse, error)
      SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error)
      SendTransaction(context.Context, *SendTransactionRequest) (*SendTransactionResponse, error)
      SendRawTransaction(context.Context, *SendRawTransactionRequest) (*SendRawTransactionResponse, error)
      Call(context.Context, *CallRequest) (*CallResponse, error)
      TestSendTransaction(context.Context, *TestSendTransactionRequest) (*TestSendTransactionResponse, error)
      // filter
      NewFilter(context.Context, *NewFilterRequest) (*NewFilterResponse, error)
      NewBlockFilter(context.Context, *emptypb.Empty) (*NewBlockFilterResponse, error)
      PendingTransactionFilter(context.Context, *emptypb.Empty) (*PendingTransactionFilterResponse, error)
      UninstallFilter(context.Context, *UninstallFilterRequest) (*UninstallFilterResponse, error)
      FilterChanges(context.Context, *FilterChangesRequest) (*FilterChangesResponse, error)
      FilterLogs(context.Context, *FilterLogsRequest) (*FilterLogsResponse, error)
      Logs(context.Context, *LogsRequest) (*LogsResponse, error)
      mustEmbedUnimplementedNebulaServiceServer()
      }
      // UnimplementedNebulaServiceServer must be embedded to have forward compatible implementations.
      type UnimplementedNebulaServiceServer struct {
      }
      func (UnimplementedNebulaServiceServer) Sha3(context.Context, *Sha3Request) (*Sha3Response, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Sha3 not implemented")
      }
      func (UnimplementedNebulaServiceServer) NodeVersion(context.Context, *emptypb.Empty) (*NodeVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NodeVersion not implemented")
      }
      func (UnimplementedNebulaServiceServer) NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NetVersion not implemented")
      }
      func (UnimplementedNebulaServiceServer) NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NetPeerCount not implemented")
      }
      func (UnimplementedNebulaServiceServer) ProtocolVersion(context.Context, *emptypb.Empty) (*ProtocolVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method ProtocolVersion not implemented")
      }
      func (UnimplementedNebulaServiceServer) Syncing(context.Context, *emptypb.Empty) (*SyncingResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Syncing not implemented")
      }
      func (UnimplementedNebulaServiceServer) Coinbase(context.Context, *emptypb.Empty) (*CoinbaseResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Coinbase not implemented")
      }
      func (UnimplementedNebulaServiceServer) Mining(context.Context, *emptypb.Empty) (*MiningResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Mining not implemented")
      }
      func (UnimplementedNebulaServiceServer) HashRate(context.Context, *emptypb.Empty) (*HashRateResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method HashRate not implemented")
      }
      func (UnimplementedNebulaServiceServer) Accounts(context.Context, *emptypb.Empty) (*AccountsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Accounts not implemented")
      }
      func (UnimplementedNebulaServiceServer) GasPrice(context.Context, *emptypb.Empty) (*GasPriceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GasPrice not implemented")
      }
      func (UnimplementedNebulaServiceServer) BlockNumber(context.Context, *emptypb.Empty) (*HeightResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockNumber not implemented")
      }
      func (UnimplementedNebulaServiceServer) BlockByHash(context.Context, *BlockByHashRequest) (*BlockByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockByHash not implemented")
      }
      func (UnimplementedNebulaServiceServer) BlockByNumber(context.Context, *BlockByNumberRequest) (*BlockByNumberResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockByNumber not implemented")
      }
      func (UnimplementedNebulaServiceServer) BlockTransactionCountByHash(context.Context, *BlockTransactionCountByHashRequest) (*BlockTransactionCountByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockTransactionCountByHash not implemented")
      }
      func (UnimplementedNebulaServiceServer) BlockTransactionCountByNumber(context.Context, *BlockTransactionCountByNumberRequest) (*BlockTransactionCountByNumberResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockTransactionCountByNumber not implemented")
      }
      func (UnimplementedNebulaServiceServer) UncleCountByHash(context.Context, *UncleCountByHashRequest) (*UncleCountByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleCountByHash not implemented")
      }
      func (UnimplementedNebulaServiceServer) UncleCountByNumber(context.Context, *UncleCountByNumberRequest) (*UncleCountByNumberResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleCountByNumber not implemented")
      }
      func (UnimplementedNebulaServiceServer) UncleByBlockHashAndIndex(context.Context, *UncleByBlockHashAndIndexRequest) (*UncleByBlockHashAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleByBlockHashAndIndex not implemented")
      }
      func (UnimplementedNebulaServiceServer) UncleByBlockNumberAndIndex(context.Context, *UncleByBlockNumberAndIndexRequest) (*UncleByBlockNumberAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleByBlockNumberAndIndex not implemented")
      }
      func (UnimplementedNebulaServiceServer) Compilers(context.Context, *CompilersRequest) (*CompilersResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Compilers not implemented")
      }
      func (UnimplementedNebulaServiceServer) CompileSolidity(context.Context, *CompileSolidityRequest) (*CompileSolidityResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CompileSolidity not implemented")
      }
      func (UnimplementedNebulaServiceServer) CompileLLL(context.Context, *CompileLLLRequest) (*CompileLLLResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CompileLLL not implemented")
      }
      func (UnimplementedNebulaServiceServer) CompileSerpent(context.Context, *CompileSerpentRequest) (*CompileSerpentResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CompileSerpent not implemented")
      }
      func (UnimplementedNebulaServiceServer) EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method EstimateGas not implemented")
      }
      func (UnimplementedNebulaServiceServer) TransactionByHash(context.Context, *TransactionByHashRequest) (*TransactionByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionByHash not implemented")
      }
      func (UnimplementedNebulaServiceServer) TransactionByBlockHashAndIndex(context.Context, *TransactionByBlockHashAndIndexRequest) (*TransactionByBlockHashAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionByBlockHashAndIndex not implemented")
      }
      func (UnimplementedNebulaServiceServer) TransactionByBlockNumberAndIndex(context.Context, *TransactionByBlockNumberAndIndexRequest) (*TransactionByBlockNumberAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionByBlockNumberAndIndex not implemented")
      }
      func (UnimplementedNebulaServiceServer) TransactionReceipt(context.Context, *TransactionReceiptRequest) (*TransactionReceiptResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionReceipt not implemented")
      }
      func (UnimplementedNebulaServiceServer) Balance(context.Context, *BalanceRequest) (*BalanceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented")
      }
      func (UnimplementedNebulaServiceServer) Storage(context.Context, *StorageRequest) (*StorageResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Storage not implemented")
      }
      func (UnimplementedNebulaServiceServer) Nonce(context.Context, *NonceRequest) (*NonceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Nonce not implemented")
      }
      func (UnimplementedNebulaServiceServer) RepeatedNonce(context.Context, *RepeatedNonceRequest) (*RepeatedNonceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method RepeatedNonce not implemented")
      }
      func (UnimplementedNebulaServiceServer) TransactionCount(context.Context, *TransactionCountRequest) (*TransactionCountResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionCount not implemented")
      }
      func (UnimplementedNebulaServiceServer) GetCode(context.Context, *GetCodeRequest) (*GetCodeResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GetCode not implemented")
      }
      func (UnimplementedNebulaServiceServer) Sign(context.Context, *SignRequest) (*SignResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented")
      }
      func (UnimplementedNebulaServiceServer) SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SignTransaction not implemented")
      }
      func (UnimplementedNebulaServiceServer) SendTransaction(context.Context, *SendTransactionRequest) (*SendTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SendTransaction not implemented")
      }
      func (UnimplementedNebulaServiceServer) SendRawTransaction(context.Context, *SendRawTransactionRequest) (*SendRawTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SendRawTransaction not implemented")
      }
      func (UnimplementedNebulaServiceServer) Call(context.Context, *CallRequest) (*CallResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Call not implemented")
      }
      func (UnimplementedNebulaServiceServer) TestSendTransaction(context.Context, *TestSendTransactionRequest) (*TestSendTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TestSendTransaction not implemented")
      }
      func (UnimplementedNebulaServiceServer) NewFilter(context.Context, *NewFilterRequest) (*NewFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NewFilter not implemented")
      }
      func (UnimplementedNebulaServiceServer) NewBlockFilter(context.Context, *emptypb.Empty) (*NewBlockFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NewBlockFilter not implemented")
      }
      func (UnimplementedNebulaServiceServer) PendingTransactionFilter(context.Context, *emptypb.Empty) (*PendingTransactionFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method PendingTransactionFilter not implemented")
      }
      func (UnimplementedNebulaServiceServer) UninstallFilter(context.Context, *UninstallFilterRequest) (*UninstallFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UninstallFilter not implemented")
      }
      func (UnimplementedNebulaServiceServer) FilterChanges(context.Context, *FilterChangesRequest) (*FilterChangesResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method FilterChanges not implemented")
      }
      func (UnimplementedNebulaServiceServer) FilterLogs(context.Context, *FilterLogsRequest) (*FilterLogsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method FilterLogs not implemented")
      }
      func (UnimplementedNebulaServiceServer) Logs(context.Context, *LogsRequest) (*LogsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Logs not implemented")
      }
      func (UnimplementedNebulaServiceServer) mustEmbedUnimplementedNebulaServiceServer() {}
      // UnsafeNebulaServiceServer may be embedded to opt out of forward compatibility for this service.
      // Use of this interface is not recommended, as added methods to NebulaServiceServer will
      // result in compilation errors.
      type UnsafeNebulaServiceServer interface {
      mustEmbedUnimplementedNebulaServiceServer()
      }
      func RegisterNebulaServiceServer(s grpc.ServiceRegistrar, srv NebulaServiceServer) {
      s.RegisterService(&NebulaService_ServiceDesc, srv)
      }
      func _NebulaService_Sha3_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(Sha3Request)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Sha3(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Sha3",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Sha3(ctx, req.(*Sha3Request))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_NodeVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).NodeVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/NodeVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).NodeVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_NetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).NetVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/NetVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).NetVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_NetPeerCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).NetPeerCount(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/NetPeerCount",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).NetPeerCount(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_ProtocolVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).ProtocolVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/ProtocolVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).ProtocolVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Syncing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Syncing(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Syncing",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Syncing(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Coinbase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Coinbase(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Coinbase",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Coinbase(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Mining_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Mining(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Mining",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Mining(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_HashRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).HashRate(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/HashRate",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).HashRate(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Accounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Accounts(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Accounts",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Accounts(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_GasPrice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).GasPrice(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/GasPrice",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).GasPrice(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_BlockNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).BlockNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/BlockNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).BlockNumber(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_BlockByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).BlockByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/BlockByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).BlockByHash(ctx, req.(*BlockByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_BlockByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockByNumberRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).BlockByNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/BlockByNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).BlockByNumber(ctx, req.(*BlockByNumberRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_BlockTransactionCountByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockTransactionCountByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).BlockTransactionCountByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/BlockTransactionCountByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).BlockTransactionCountByHash(ctx, req.(*BlockTransactionCountByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_BlockTransactionCountByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockTransactionCountByNumberRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).BlockTransactionCountByNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/BlockTransactionCountByNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).BlockTransactionCountByNumber(ctx, req.(*BlockTransactionCountByNumberRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_UncleCountByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleCountByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).UncleCountByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/UncleCountByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).UncleCountByHash(ctx, req.(*UncleCountByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_UncleCountByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleCountByNumberRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).UncleCountByNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/UncleCountByNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).UncleCountByNumber(ctx, req.(*UncleCountByNumberRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_UncleByBlockHashAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleByBlockHashAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).UncleByBlockHashAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/UncleByBlockHashAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).UncleByBlockHashAndIndex(ctx, req.(*UncleByBlockHashAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_UncleByBlockNumberAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleByBlockNumberAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).UncleByBlockNumberAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/UncleByBlockNumberAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).UncleByBlockNumberAndIndex(ctx, req.(*UncleByBlockNumberAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Compilers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompilersRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Compilers(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Compilers",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Compilers(ctx, req.(*CompilersRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_CompileSolidity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompileSolidityRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).CompileSolidity(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/CompileSolidity",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).CompileSolidity(ctx, req.(*CompileSolidityRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_CompileLLL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompileLLLRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).CompileLLL(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/CompileLLL",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).CompileLLL(ctx, req.(*CompileLLLRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_CompileSerpent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompileSerpentRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).CompileSerpent(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/CompileSerpent",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).CompileSerpent(ctx, req.(*CompileSerpentRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_EstimateGas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(EstimateGasRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).EstimateGas(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/EstimateGas",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).EstimateGas(ctx, req.(*EstimateGasRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_TransactionByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).TransactionByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/TransactionByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).TransactionByHash(ctx, req.(*TransactionByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_TransactionByBlockHashAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionByBlockHashAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).TransactionByBlockHashAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/TransactionByBlockHashAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).TransactionByBlockHashAndIndex(ctx, req.(*TransactionByBlockHashAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_TransactionByBlockNumberAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionByBlockNumberAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).TransactionByBlockNumberAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/TransactionByBlockNumberAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).TransactionByBlockNumberAndIndex(ctx, req.(*TransactionByBlockNumberAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_TransactionReceipt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionReceiptRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).TransactionReceipt(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/TransactionReceipt",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).TransactionReceipt(ctx, req.(*TransactionReceiptRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BalanceRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Balance(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Balance",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Balance(ctx, req.(*BalanceRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Storage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(StorageRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Storage(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Storage",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Storage(ctx, req.(*StorageRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Nonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(NonceRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Nonce(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Nonce",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Nonce(ctx, req.(*NonceRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_RepeatedNonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(RepeatedNonceRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).RepeatedNonce(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/RepeatedNonce",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).RepeatedNonce(ctx, req.(*RepeatedNonceRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_TransactionCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionCountRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).TransactionCount(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/TransactionCount",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).TransactionCount(ctx, req.(*TransactionCountRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_GetCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(GetCodeRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).GetCode(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/GetCode",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).GetCode(ctx, req.(*GetCodeRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SignRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Sign(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Sign",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Sign(ctx, req.(*SignRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_SignTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SignTransactionRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).SignTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/SignTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).SignTransaction(ctx, req.(*SignTransactionRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_SendTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SendTransactionRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).SendTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/SendTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).SendTransaction(ctx, req.(*SendTransactionRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_SendRawTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SendRawTransactionRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).SendRawTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/SendRawTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).SendRawTransaction(ctx, req.(*SendRawTransactionRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Call_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CallRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Call(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Call",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Call(ctx, req.(*CallRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_TestSendTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TestSendTransactionRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).TestSendTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/TestSendTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).TestSendTransaction(ctx, req.(*TestSendTransactionRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_NewFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(NewFilterRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).NewFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/NewFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).NewFilter(ctx, req.(*NewFilterRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_NewBlockFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).NewBlockFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/NewBlockFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).NewBlockFilter(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_PendingTransactionFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).PendingTransactionFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/PendingTransactionFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).PendingTransactionFilter(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_UninstallFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UninstallFilterRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).UninstallFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/UninstallFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).UninstallFilter(ctx, req.(*UninstallFilterRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_FilterChanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(FilterChangesRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).FilterChanges(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/FilterChanges",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).FilterChanges(ctx, req.(*FilterChangesRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_FilterLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(FilterLogsRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).FilterLogs(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/FilterLogs",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).FilterLogs(ctx, req.(*FilterLogsRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _NebulaService_Logs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(LogsRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(NebulaServiceServer).Logs(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/nebula.v1.NebulaService/Logs",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(NebulaServiceServer).Logs(ctx, req.(*LogsRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      // NebulaService_ServiceDesc is the grpc.ServiceDesc for NebulaService service.
      // It's only intended for direct use with grpc.RegisterService,
      // and not to be introspected or modified (even as a copy)
      var NebulaService_ServiceDesc = grpc.ServiceDesc{
      ServiceName: "nebula.v1.NebulaService",
      HandlerType: (*NebulaServiceServer)(nil),
      Methods: []grpc.MethodDesc{
      {
      MethodName: "Sha3",
      Handler: _NebulaService_Sha3_Handler,
      },
      {
      MethodName: "NodeVersion",
      Handler: _NebulaService_NodeVersion_Handler,
      },
      {
      MethodName: "NetVersion",
      Handler: _NebulaService_NetVersion_Handler,
      },
      {
      MethodName: "NetPeerCount",
      Handler: _NebulaService_NetPeerCount_Handler,
      },
      {
      MethodName: "ProtocolVersion",
      Handler: _NebulaService_ProtocolVersion_Handler,
      },
      {
      MethodName: "Syncing",
      Handler: _NebulaService_Syncing_Handler,
      },
      {
      MethodName: "Coinbase",
      Handler: _NebulaService_Coinbase_Handler,
      },
      {
      MethodName: "Mining",
      Handler: _NebulaService_Mining_Handler,
      },
      {
      MethodName: "HashRate",
      Handler: _NebulaService_HashRate_Handler,
      },
      {
      MethodName: "Accounts",
      Handler: _NebulaService_Accounts_Handler,
      },
      {
      MethodName: "GasPrice",
      Handler: _NebulaService_GasPrice_Handler,
      },
      {
      MethodName: "BlockNumber",
      Handler: _NebulaService_BlockNumber_Handler,
      },
      {
      MethodName: "BlockByHash",
      Handler: _NebulaService_BlockByHash_Handler,
      },
      {
      MethodName: "BlockByNumber",
      Handler: _NebulaService_BlockByNumber_Handler,
      },
      {
      MethodName: "BlockTransactionCountByHash",
      Handler: _NebulaService_BlockTransactionCountByHash_Handler,
      },
      {
      MethodName: "BlockTransactionCountByNumber",
      Handler: _NebulaService_BlockTransactionCountByNumber_Handler,
      },
      {
      MethodName: "UncleCountByHash",
      Handler: _NebulaService_UncleCountByHash_Handler,
      },
      {
      MethodName: "UncleCountByNumber",
      Handler: _NebulaService_UncleCountByNumber_Handler,
      },
      {
      MethodName: "UncleByBlockHashAndIndex",
      Handler: _NebulaService_UncleByBlockHashAndIndex_Handler,
      },
      {
      MethodName: "UncleByBlockNumberAndIndex",
      Handler: _NebulaService_UncleByBlockNumberAndIndex_Handler,
      },
      {
      MethodName: "Compilers",
      Handler: _NebulaService_Compilers_Handler,
      },
      {
      MethodName: "CompileSolidity",
      Handler: _NebulaService_CompileSolidity_Handler,
      },
      {
      MethodName: "CompileLLL",
      Handler: _NebulaService_CompileLLL_Handler,
      },
      {
      MethodName: "CompileSerpent",
      Handler: _NebulaService_CompileSerpent_Handler,
      },
      {
      MethodName: "EstimateGas",
      Handler: _NebulaService_EstimateGas_Handler,
      },
      {
      MethodName: "TransactionByHash",
      Handler: _NebulaService_TransactionByHash_Handler,
      },
      {
      MethodName: "TransactionByBlockHashAndIndex",
      Handler: _NebulaService_TransactionByBlockHashAndIndex_Handler,
      },
      {
      MethodName: "TransactionByBlockNumberAndIndex",
      Handler: _NebulaService_TransactionByBlockNumberAndIndex_Handler,
      },
      {
      MethodName: "TransactionReceipt",
      Handler: _NebulaService_TransactionReceipt_Handler,
      },
      {
      MethodName: "Balance",
      Handler: _NebulaService_Balance_Handler,
      },
      {
      MethodName: "Storage",
      Handler: _NebulaService_Storage_Handler,
      },
      {
      MethodName: "Nonce",
      Handler: _NebulaService_Nonce_Handler,
      },
      {
      MethodName: "RepeatedNonce",
      Handler: _NebulaService_RepeatedNonce_Handler,
      },
      {
      MethodName: "TransactionCount",
      Handler: _NebulaService_TransactionCount_Handler,
      },
      {
      MethodName: "GetCode",
      Handler: _NebulaService_GetCode_Handler,
      },
      {
      MethodName: "Sign",
      Handler: _NebulaService_Sign_Handler,
      },
      {
      MethodName: "SignTransaction",
      Handler: _NebulaService_SignTransaction_Handler,
      },
      {
      MethodName: "SendTransaction",
      Handler: _NebulaService_SendTransaction_Handler,
      },
      {
      MethodName: "SendRawTransaction",
      Handler: _NebulaService_SendRawTransaction_Handler,
      },
      {
      MethodName: "Call",
      Handler: _NebulaService_Call_Handler,
      },
      {
      MethodName: "TestSendTransaction",
      Handler: _NebulaService_TestSendTransaction_Handler,
      },
      {
      MethodName: "NewFilter",
      Handler: _NebulaService_NewFilter_Handler,
      },
      {
      MethodName: "NewBlockFilter",
      Handler: _NebulaService_NewBlockFilter_Handler,
      },
      {
      MethodName: "PendingTransactionFilter",
      Handler: _NebulaService_PendingTransactionFilter_Handler,
      },
      {
      MethodName: "UninstallFilter",
      Handler: _NebulaService_UninstallFilter_Handler,
      },
      {
      MethodName: "FilterChanges",
      Handler: _NebulaService_FilterChanges_Handler,
      },
      {
      MethodName: "FilterLogs",
      Handler: _NebulaService_FilterLogs_Handler,
      },
      {
      MethodName: "Logs",
      Handler: _NebulaService_Logs_Handler,
      },
      },
      Streams: []grpc.StreamDesc{},
      Metadata: "nebula/v1/service.proto",
      }
      MetaProtocol-main/gen/proto/go/p2p/v1/request_response.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: p2p/v1/request_response.proto
      package p2pv1
      import (
      fmt "fmt"
      _ "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base"
      v1 "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base/v1"
      github_com_CaduceusMetaverseProtocol_MetaTypes_types "github.com/CaduceusMetaverseProtocol/MetaTypes/types"
      proto "github.com/gogo/protobuf/proto"
      _ "github.com/gogo/protobuf/types"
      _ "google.golang.org/protobuf/types/known/fieldmaskpb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type BroadCastRequest struct {
      Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BroadCastRequest) Reset() { *m = BroadCastRequest{} }
      func (m *BroadCastRequest) String() string { return proto.CompactTextString(m) }
      func (*BroadCastRequest) ProtoMessage() {}
      func (*BroadCastRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{0}
      }
      func (m *BroadCastRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BroadCastRequest.Unmarshal(m, b)
      }
      func (m *BroadCastRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BroadCastRequest.Marshal(b, m, deterministic)
      }
      func (m *BroadCastRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BroadCastRequest.Merge(m, src)
      }
      func (m *BroadCastRequest) XXX_Size() int {
      return xxx_messageInfo_BroadCastRequest.Size(m)
      }
      func (m *BroadCastRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_BroadCastRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_BroadCastRequest proto.InternalMessageInfo
      func (m *BroadCastRequest) GetHeader() *MessageHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *BroadCastRequest) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      type BroadCastResponse struct {
      Status bool `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BroadCastResponse) Reset() { *m = BroadCastResponse{} }
      func (m *BroadCastResponse) String() string { return proto.CompactTextString(m) }
      func (*BroadCastResponse) ProtoMessage() {}
      func (*BroadCastResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{1}
      }
      func (m *BroadCastResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BroadCastResponse.Unmarshal(m, b)
      }
      func (m *BroadCastResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BroadCastResponse.Marshal(b, m, deterministic)
      }
      func (m *BroadCastResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BroadCastResponse.Merge(m, src)
      }
      func (m *BroadCastResponse) XXX_Size() int {
      return xxx_messageInfo_BroadCastResponse.Size(m)
      }
      func (m *BroadCastResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_BroadCastResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_BroadCastResponse proto.InternalMessageInfo
      func (m *BroadCastResponse) GetStatus() bool {
      if m != nil {
      return m.Status
      }
      return false
      }
      type BroadCastTxsRequest struct {
      Txs []*v1.BatchTx `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BroadCastTxsRequest) Reset() { *m = BroadCastTxsRequest{} }
      func (m *BroadCastTxsRequest) String() string { return proto.CompactTextString(m) }
      func (*BroadCastTxsRequest) ProtoMessage() {}
      func (*BroadCastTxsRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{2}
      }
      func (m *BroadCastTxsRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BroadCastTxsRequest.Unmarshal(m, b)
      }
      func (m *BroadCastTxsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BroadCastTxsRequest.Marshal(b, m, deterministic)
      }
      func (m *BroadCastTxsRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BroadCastTxsRequest.Merge(m, src)
      }
      func (m *BroadCastTxsRequest) XXX_Size() int {
      return xxx_messageInfo_BroadCastTxsRequest.Size(m)
      }
      func (m *BroadCastTxsRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_BroadCastTxsRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_BroadCastTxsRequest proto.InternalMessageInfo
      func (m *BroadCastTxsRequest) GetTxs() []*v1.BatchTx {
      if m != nil {
      return m.Txs
      }
      return nil
      }
      type BroadCastTxsResponse struct {
      Status []bool `protobuf:"varint,1,rep,packed,name=status,proto3" json:"status,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BroadCastTxsResponse) Reset() { *m = BroadCastTxsResponse{} }
      func (m *BroadCastTxsResponse) String() string { return proto.CompactTextString(m) }
      func (*BroadCastTxsResponse) ProtoMessage() {}
      func (*BroadCastTxsResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{3}
      }
      func (m *BroadCastTxsResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BroadCastTxsResponse.Unmarshal(m, b)
      }
      func (m *BroadCastTxsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BroadCastTxsResponse.Marshal(b, m, deterministic)
      }
      func (m *BroadCastTxsResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BroadCastTxsResponse.Merge(m, src)
      }
      func (m *BroadCastTxsResponse) XXX_Size() int {
      return xxx_messageInfo_BroadCastTxsResponse.Size(m)
      }
      func (m *BroadCastTxsResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_BroadCastTxsResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_BroadCastTxsResponse proto.InternalMessageInfo
      func (m *BroadCastTxsResponse) GetStatus() []bool {
      if m != nil {
      return m.Status
      }
      return nil
      }
      type BatchTxsHashRequest struct {
      Hash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,1,opt,name=hash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"hash,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchTxsHashRequest) Reset() { *m = BatchTxsHashRequest{} }
      func (m *BatchTxsHashRequest) String() string { return proto.CompactTextString(m) }
      func (*BatchTxsHashRequest) ProtoMessage() {}
      func (*BatchTxsHashRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{4}
      }
      func (m *BatchTxsHashRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchTxsHashRequest.Unmarshal(m, b)
      }
      func (m *BatchTxsHashRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchTxsHashRequest.Marshal(b, m, deterministic)
      }
      func (m *BatchTxsHashRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchTxsHashRequest.Merge(m, src)
      }
      func (m *BatchTxsHashRequest) XXX_Size() int {
      return xxx_messageInfo_BatchTxsHashRequest.Size(m)
      }
      func (m *BatchTxsHashRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchTxsHashRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchTxsHashRequest proto.InternalMessageInfo
      type BatchTxsHashResponse struct {
      Hash *github_com_CaduceusMetaverseProtocol_MetaTypes_types.Hash `protobuf:"bytes,1,opt,name=hash,proto3,customtype=github.com/CaduceusMetaverseProtocol/MetaTypes/types.Hash" json:"hash,omitempty"`
      Txs []*v1.MetaProofTx `protobuf:"bytes,2,rep,name=txs,proto3" json:"txs,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchTxsHashResponse) Reset() { *m = BatchTxsHashResponse{} }
      func (m *BatchTxsHashResponse) String() string { return proto.CompactTextString(m) }
      func (*BatchTxsHashResponse) ProtoMessage() {}
      func (*BatchTxsHashResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{5}
      }
      func (m *BatchTxsHashResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchTxsHashResponse.Unmarshal(m, b)
      }
      func (m *BatchTxsHashResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchTxsHashResponse.Marshal(b, m, deterministic)
      }
      func (m *BatchTxsHashResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchTxsHashResponse.Merge(m, src)
      }
      func (m *BatchTxsHashResponse) XXX_Size() int {
      return xxx_messageInfo_BatchTxsHashResponse.Size(m)
      }
      func (m *BatchTxsHashResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchTxsHashResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchTxsHashResponse proto.InternalMessageInfo
      func (m *BatchTxsHashResponse) GetTxs() []*v1.MetaProofTx {
      if m != nil {
      return m.Txs
      }
      return nil
      }
      type SendDataRequest struct {
      Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *SendDataRequest) Reset() { *m = SendDataRequest{} }
      func (m *SendDataRequest) String() string { return proto.CompactTextString(m) }
      func (*SendDataRequest) ProtoMessage() {}
      func (*SendDataRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{6}
      }
      func (m *SendDataRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_SendDataRequest.Unmarshal(m, b)
      }
      func (m *SendDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_SendDataRequest.Marshal(b, m, deterministic)
      }
      func (m *SendDataRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_SendDataRequest.Merge(m, src)
      }
      func (m *SendDataRequest) XXX_Size() int {
      return xxx_messageInfo_SendDataRequest.Size(m)
      }
      func (m *SendDataRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_SendDataRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_SendDataRequest proto.InternalMessageInfo
      func (m *SendDataRequest) GetHeader() *MessageHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *SendDataRequest) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      type SendDataResponse struct {
      Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *SendDataResponse) Reset() { *m = SendDataResponse{} }
      func (m *SendDataResponse) String() string { return proto.CompactTextString(m) }
      func (*SendDataResponse) ProtoMessage() {}
      func (*SendDataResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{7}
      }
      func (m *SendDataResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_SendDataResponse.Unmarshal(m, b)
      }
      func (m *SendDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_SendDataResponse.Marshal(b, m, deterministic)
      }
      func (m *SendDataResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_SendDataResponse.Merge(m, src)
      }
      func (m *SendDataResponse) XXX_Size() int {
      return xxx_messageInfo_SendDataResponse.Size(m)
      }
      func (m *SendDataResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_SendDataResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_SendDataResponse proto.InternalMessageInfo
      func (m *SendDataResponse) GetSuccess() bool {
      if m != nil {
      return m.Success
      }
      return false
      }
      type SubscribeNewBatchtxRequest struct {
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *SubscribeNewBatchtxRequest) Reset() { *m = SubscribeNewBatchtxRequest{} }
      func (m *SubscribeNewBatchtxRequest) String() string { return proto.CompactTextString(m) }
      func (*SubscribeNewBatchtxRequest) ProtoMessage() {}
      func (*SubscribeNewBatchtxRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{8}
      }
      func (m *SubscribeNewBatchtxRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_SubscribeNewBatchtxRequest.Unmarshal(m, b)
      }
      func (m *SubscribeNewBatchtxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_SubscribeNewBatchtxRequest.Marshal(b, m, deterministic)
      }
      func (m *SubscribeNewBatchtxRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_SubscribeNewBatchtxRequest.Merge(m, src)
      }
      func (m *SubscribeNewBatchtxRequest) XXX_Size() int {
      return xxx_messageInfo_SubscribeNewBatchtxRequest.Size(m)
      }
      func (m *SubscribeNewBatchtxRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_SubscribeNewBatchtxRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_SubscribeNewBatchtxRequest proto.InternalMessageInfo
      type SubscribeNewBatchtxResponse struct {
      BatchTx []*v1.BatchTx `protobuf:"bytes,1,rep,name=batch_tx,json=batchTx,proto3" json:"batch_tx,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *SubscribeNewBatchtxResponse) Reset() { *m = SubscribeNewBatchtxResponse{} }
      func (m *SubscribeNewBatchtxResponse) String() string { return proto.CompactTextString(m) }
      func (*SubscribeNewBatchtxResponse) ProtoMessage() {}
      func (*SubscribeNewBatchtxResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{9}
      }
      func (m *SubscribeNewBatchtxResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_SubscribeNewBatchtxResponse.Unmarshal(m, b)
      }
      func (m *SubscribeNewBatchtxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_SubscribeNewBatchtxResponse.Marshal(b, m, deterministic)
      }
      func (m *SubscribeNewBatchtxResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_SubscribeNewBatchtxResponse.Merge(m, src)
      }
      func (m *SubscribeNewBatchtxResponse) XXX_Size() int {
      return xxx_messageInfo_SubscribeNewBatchtxResponse.Size(m)
      }
      func (m *SubscribeNewBatchtxResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_SubscribeNewBatchtxResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_SubscribeNewBatchtxResponse proto.InternalMessageInfo
      func (m *SubscribeNewBatchtxResponse) GetBatchTx() []*v1.BatchTx {
      if m != nil {
      return m.BatchTx
      }
      return nil
      }
      type SubscribeMsgRequest struct {
      MsgTypes P2PMsgType `protobuf:"varint,1,opt,name=msg_types,json=msgTypes,proto3,enum=p2p.v1.P2PMsgType" json:"msg_types,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *SubscribeMsgRequest) Reset() { *m = SubscribeMsgRequest{} }
      func (m *SubscribeMsgRequest) String() string { return proto.CompactTextString(m) }
      func (*SubscribeMsgRequest) ProtoMessage() {}
      func (*SubscribeMsgRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{10}
      }
      func (m *SubscribeMsgRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_SubscribeMsgRequest.Unmarshal(m, b)
      }
      func (m *SubscribeMsgRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_SubscribeMsgRequest.Marshal(b, m, deterministic)
      }
      func (m *SubscribeMsgRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_SubscribeMsgRequest.Merge(m, src)
      }
      func (m *SubscribeMsgRequest) XXX_Size() int {
      return xxx_messageInfo_SubscribeMsgRequest.Size(m)
      }
      func (m *SubscribeMsgRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_SubscribeMsgRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_SubscribeMsgRequest proto.InternalMessageInfo
      func (m *SubscribeMsgRequest) GetMsgTypes() P2PMsgType {
      if m != nil {
      return m.MsgTypes
      }
      return P2PMsgType_P2P_MSG_TYPE_INVALID
      }
      type SubscribeMsgResponse struct {
      Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *SubscribeMsgResponse) Reset() { *m = SubscribeMsgResponse{} }
      func (m *SubscribeMsgResponse) String() string { return proto.CompactTextString(m) }
      func (*SubscribeMsgResponse) ProtoMessage() {}
      func (*SubscribeMsgResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{11}
      }
      func (m *SubscribeMsgResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_SubscribeMsgResponse.Unmarshal(m, b)
      }
      func (m *SubscribeMsgResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_SubscribeMsgResponse.Marshal(b, m, deterministic)
      }
      func (m *SubscribeMsgResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_SubscribeMsgResponse.Merge(m, src)
      }
      func (m *SubscribeMsgResponse) XXX_Size() int {
      return xxx_messageInfo_SubscribeMsgResponse.Size(m)
      }
      func (m *SubscribeMsgResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_SubscribeMsgResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_SubscribeMsgResponse proto.InternalMessageInfo
      func (m *SubscribeMsgResponse) GetData() []byte {
      if m != nil {
      return m.Data
      }
      return nil
      }
      type NetVersionRequest struct {
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *NetVersionRequest) Reset() { *m = NetVersionRequest{} }
      func (m *NetVersionRequest) String() string { return proto.CompactTextString(m) }
      func (*NetVersionRequest) ProtoMessage() {}
      func (*NetVersionRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{12}
      }
      func (m *NetVersionRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_NetVersionRequest.Unmarshal(m, b)
      }
      func (m *NetVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_NetVersionRequest.Marshal(b, m, deterministic)
      }
      func (m *NetVersionRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_NetVersionRequest.Merge(m, src)
      }
      func (m *NetVersionRequest) XXX_Size() int {
      return xxx_messageInfo_NetVersionRequest.Size(m)
      }
      func (m *NetVersionRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_NetVersionRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_NetVersionRequest proto.InternalMessageInfo
      type NetVersionResponse struct {
      Version []byte `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *NetVersionResponse) Reset() { *m = NetVersionResponse{} }
      func (m *NetVersionResponse) String() string { return proto.CompactTextString(m) }
      func (*NetVersionResponse) ProtoMessage() {}
      func (*NetVersionResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{13}
      }
      func (m *NetVersionResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_NetVersionResponse.Unmarshal(m, b)
      }
      func (m *NetVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_NetVersionResponse.Marshal(b, m, deterministic)
      }
      func (m *NetVersionResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_NetVersionResponse.Merge(m, src)
      }
      func (m *NetVersionResponse) XXX_Size() int {
      return xxx_messageInfo_NetVersionResponse.Size(m)
      }
      func (m *NetVersionResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_NetVersionResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_NetVersionResponse proto.InternalMessageInfo
      func (m *NetVersionResponse) GetVersion() []byte {
      if m != nil {
      return m.Version
      }
      return nil
      }
      type NetPeerCountRequest struct {
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *NetPeerCountRequest) Reset() { *m = NetPeerCountRequest{} }
      func (m *NetPeerCountRequest) String() string { return proto.CompactTextString(m) }
      func (*NetPeerCountRequest) ProtoMessage() {}
      func (*NetPeerCountRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{14}
      }
      func (m *NetPeerCountRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_NetPeerCountRequest.Unmarshal(m, b)
      }
      func (m *NetPeerCountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_NetPeerCountRequest.Marshal(b, m, deterministic)
      }
      func (m *NetPeerCountRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_NetPeerCountRequest.Merge(m, src)
      }
      func (m *NetPeerCountRequest) XXX_Size() int {
      return xxx_messageInfo_NetPeerCountRequest.Size(m)
      }
      func (m *NetPeerCountRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_NetPeerCountRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_NetPeerCountRequest proto.InternalMessageInfo
      type NetPeerCountResponse struct {
      PeerCount uint32 `protobuf:"varint,1,opt,name=peer_count,json=peerCount,proto3" json:"peer_count,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *NetPeerCountResponse) Reset() { *m = NetPeerCountResponse{} }
      func (m *NetPeerCountResponse) String() string { return proto.CompactTextString(m) }
      func (*NetPeerCountResponse) ProtoMessage() {}
      func (*NetPeerCountResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{15}
      }
      func (m *NetPeerCountResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_NetPeerCountResponse.Unmarshal(m, b)
      }
      func (m *NetPeerCountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_NetPeerCountResponse.Marshal(b, m, deterministic)
      }
      func (m *NetPeerCountResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_NetPeerCountResponse.Merge(m, src)
      }
      func (m *NetPeerCountResponse) XXX_Size() int {
      return xxx_messageInfo_NetPeerCountResponse.Size(m)
      }
      func (m *NetPeerCountResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_NetPeerCountResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_NetPeerCountResponse proto.InternalMessageInfo
      func (m *NetPeerCountResponse) GetPeerCount() uint32 {
      if m != nil {
      return m.PeerCount
      }
      return 0
      }
      // PublishRequest is passed when publishing
      type PublishRequest struct {
      Topic string `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
      Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *PublishRequest) Reset() { *m = PublishRequest{} }
      func (m *PublishRequest) String() string { return proto.CompactTextString(m) }
      func (*PublishRequest) ProtoMessage() {}
      func (*PublishRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{16}
      }
      func (m *PublishRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_PublishRequest.Unmarshal(m, b)
      }
      func (m *PublishRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_PublishRequest.Marshal(b, m, deterministic)
      }
      func (m *PublishRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_PublishRequest.Merge(m, src)
      }
      func (m *PublishRequest) XXX_Size() int {
      return xxx_messageInfo_PublishRequest.Size(m)
      }
      func (m *PublishRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_PublishRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_PublishRequest proto.InternalMessageInfo
      func (m *PublishRequest) GetTopic() string {
      if m != nil {
      return m.Topic
      }
      return ""
      }
      func (m *PublishRequest) GetPayload() []byte {
      if m != nil {
      return m.Payload
      }
      return nil
      }
      // SubscribeRequest is passed when subscribing
      type SubscribeRequest struct {
      Topic string `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *SubscribeRequest) Reset() { *m = SubscribeRequest{} }
      func (m *SubscribeRequest) String() string { return proto.CompactTextString(m) }
      func (*SubscribeRequest) ProtoMessage() {}
      func (*SubscribeRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{17}
      }
      func (m *SubscribeRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_SubscribeRequest.Unmarshal(m, b)
      }
      func (m *SubscribeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_SubscribeRequest.Marshal(b, m, deterministic)
      }
      func (m *SubscribeRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_SubscribeRequest.Merge(m, src)
      }
      func (m *SubscribeRequest) XXX_Size() int {
      return xxx_messageInfo_SubscribeRequest.Size(m)
      }
      func (m *SubscribeRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_SubscribeRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_SubscribeRequest proto.InternalMessageInfo
      func (m *SubscribeRequest) GetTopic() string {
      if m != nil {
      return m.Topic
      }
      return ""
      }
      // SubscribeResponse object
      type SubscribeResponse struct {
      Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *SubscribeResponse) Reset() { *m = SubscribeResponse{} }
      func (m *SubscribeResponse) String() string { return proto.CompactTextString(m) }
      func (*SubscribeResponse) ProtoMessage() {}
      func (*SubscribeResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_0dfe7f18d497a164, []int{18}
      }
      func (m *SubscribeResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_SubscribeResponse.Unmarshal(m, b)
      }
      func (m *SubscribeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_SubscribeResponse.Marshal(b, m, deterministic)
      }
      func (m *SubscribeResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_SubscribeResponse.Merge(m, src)
      }
      func (m *SubscribeResponse) XXX_Size() int {
      return xxx_messageInfo_SubscribeResponse.Size(m)
      }
      func (m *SubscribeResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_SubscribeResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_SubscribeResponse proto.InternalMessageInfo
      func (m *SubscribeResponse) GetPayload() []byte {
      if m != nil {
      return m.Payload
      }
      return nil
      }
      func init() {
      proto.RegisterType((*BroadCastRequest)(nil), "p2p.v1.BroadCastRequest")
      proto.RegisterType((*BroadCastResponse)(nil), "p2p.v1.BroadCastResponse")
      proto.RegisterType((*BroadCastTxsRequest)(nil), "p2p.v1.BroadCastTxsRequest")
      proto.RegisterType((*BroadCastTxsResponse)(nil), "p2p.v1.BroadCastTxsResponse")
      proto.RegisterType((*BatchTxsHashRequest)(nil), "p2p.v1.BatchTxsHashRequest")
      proto.RegisterType((*BatchTxsHashResponse)(nil), "p2p.v1.BatchTxsHashResponse")
      proto.RegisterType((*SendDataRequest)(nil), "p2p.v1.SendDataRequest")
      proto.RegisterType((*SendDataResponse)(nil), "p2p.v1.SendDataResponse")
      proto.RegisterType((*SubscribeNewBatchtxRequest)(nil), "p2p.v1.SubscribeNewBatchtxRequest")
      proto.RegisterType((*SubscribeNewBatchtxResponse)(nil), "p2p.v1.SubscribeNewBatchtxResponse")
      proto.RegisterType((*SubscribeMsgRequest)(nil), "p2p.v1.SubscribeMsgRequest")
      proto.RegisterType((*SubscribeMsgResponse)(nil), "p2p.v1.SubscribeMsgResponse")
      proto.RegisterType((*NetVersionRequest)(nil), "p2p.v1.NetVersionRequest")
      proto.RegisterType((*NetVersionResponse)(nil), "p2p.v1.NetVersionResponse")
      proto.RegisterType((*NetPeerCountRequest)(nil), "p2p.v1.NetPeerCountRequest")
      proto.RegisterType((*NetPeerCountResponse)(nil), "p2p.v1.NetPeerCountResponse")
      proto.RegisterType((*PublishRequest)(nil), "p2p.v1.PublishRequest")
      proto.RegisterType((*SubscribeRequest)(nil), "p2p.v1.SubscribeRequest")
      proto.RegisterType((*SubscribeResponse)(nil), "p2p.v1.SubscribeResponse")
      }
      func init() { proto.RegisterFile("p2p/v1/request_response.proto", fileDescriptor_0dfe7f18d497a164) }
      var fileDescriptor_0dfe7f18d497a164 = []byte{
      // 716 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xdd, 0x4e, 0xe3, 0x46,
      0x14, 0x96, 0x13, 0x1a, 0xe0, 0x50, 0x20, 0x38, 0x01, 0x21, 0x5a, 0x04, 0xf2, 0x45, 0x15, 0x95,
      0x62, 0x2b, 0xae, 0x7a, 0x01, 0x55, 0xa5, 0x2a, 0x54, 0x2d, 0x6a, 0x15, 0x64, 0x99, 0x34, 0x42,
      0x15, 0x52, 0x3a, 0x76, 0x0e, 0x4e, 0xd4, 0x38, 0x33, 0xf5, 0x8c, 0x43, 0x78, 0x9b, 0xd5, 0x5e,
      0xad, 0xf6, 0x51, 0xf6, 0x11, 0xf6, 0x62, 0x2f, 0xf6, 0x72, 0x9f, 0x62, 0x35, 0xe3, 0x99, 0xfc,
      0x20, 0x76, 0xb5, 0x17, 0xbb, 0x37, 0xd1, 0x9c, 0x6f, 0xbe, 0xf3, 0x9d, 0x73, 0xbe, 0x9c, 0x31,
      0x1c, 0x32, 0x9f, 0x79, 0x93, 0xa6, 0x97, 0xe1, 0xff, 0x39, 0x72, 0xd1, 0xcb, 0x90, 0x33, 0x3a,
      0xe6, 0xe8, 0xb2, 0x8c, 0x0a, 0x6a, 0x57, 0x98, 0xcf, 0xdc, 0x49, 0xf3, 0xe0, 0x38, 0xa1, 0x34,
      0x19, 0xa1, 0xa7, 0xd0, 0x28, 0xbf, 0xf3, 0xee, 0x86, 0x38, 0xea, 0xf7, 0x52, 0xc2, 0xff, 0x2b,
      0x98, 0x07, 0x47, 0x8f, 0x19, 0x62, 0x98, 0x22, 0x17, 0x24, 0x65, 0x9a, 0xb0, 0x3b, 0xab, 0xc4,
      0x69, 0x9e, 0xc5, 0x68, 0xe0, 0x88, 0x70, 0x94, 0x78, 0x44, 0x44, 0x3c, 0x10, 0x53, 0x0d, 0xdb,
      0x06, 0x4e, 0x51, 0x10, 0x8d, 0xed, 0x19, 0xec, 0x91, 0xc4, 0xb6, 0xc2, 0x13, 0x9a, 0xd0, 0x02,
      0x70, 0xfe, 0x86, 0x6a, 0x2b, 0xa3, 0xa4, 0x7f, 0x41, 0xb8, 0x08, 0x8b, 0xc1, 0xec, 0x53, 0xa8,
      0x0c, 0x90, 0xf4, 0x31, 0xdb, 0xb7, 0x8e, 0xad, 0xc6, 0x86, 0xbf, 0xeb, 0x16, 0xa3, 0xb9, 0x6d,
      0xe4, 0x9c, 0x24, 0x78, 0xa9, 0x2e, 0x43, 0x4d, 0xb2, 0x6d, 0x58, 0xe9, 0x13, 0x41, 0xf6, 0x4b,
      0xc7, 0x56, 0xe3, 0xeb, 0x50, 0x9d, 0x9d, 0x13, 0xd8, 0x59, 0x90, 0x2d, 0x7c, 0xb2, 0xf7, 0xa0,
      0xc2, 0x05, 0x11, 0x39, 0x57, 0xba, 0x6b, 0xa1, 0x8e, 0x9c, 0x33, 0xa8, 0xcd, 0xc8, 0x9d, 0x29,
      0x37, 0x6d, 0x38, 0x50, 0x16, 0x53, 0xc9, 0x2d, 0x37, 0x36, 0xfc, 0xaa, 0x2b, 0x3b, 0x97, 0x4d,
      0xb4, 0xe4, 0xf0, 0x9d, 0x69, 0x28, 0x2f, 0x1d, 0x17, 0xea, 0xcb, 0xa9, 0x4f, 0x94, 0x2a, 0x2f,
      0x94, 0xba, 0x87, 0x9a, 0xce, 0xe7, 0x97, 0x84, 0x0f, 0x4c, 0xa9, 0x7f, 0x61, 0x65, 0x40, 0xf8,
      0x40, 0xcf, 0xbb, 0x39, 0xab, 0x25, 0x39, 0xad, 0x5f, 0x5e, 0xbf, 0x39, 0x3a, 0x4b, 0x86, 0x62,
      0x90, 0x47, 0x6e, 0x4c, 0x53, 0xef, 0x82, 0xf4, 0xf3, 0x18, 0x73, 0xde, 0x46, 0x41, 0x26, 0x98,
      0x71, 0x0c, 0xa4, 0x93, 0x31, 0x1d, 0x79, 0x12, 0xe9, 0x3c, 0x30, 0xe4, 0x9e, 0x90, 0xbf, 0x2a,
      0x3d, 0x54, 0xca, 0xce, 0x33, 0x0b, 0xea, 0xcb, 0x95, 0x75, 0xa7, 0x5f, 0xbc, 0xb4, 0xfd, 0x5d,
      0xe1, 0x63, 0x49, 0xf9, 0x58, 0x9f, 0x15, 0x90, 0x19, 0x41, 0x46, 0xe9, 0x9d, 0xf1, 0xb2, 0x03,
      0xdb, 0xd7, 0x38, 0xee, 0xff, 0x46, 0x04, 0xf9, 0x8c, 0x9b, 0xf0, 0x03, 0x54, 0xe7, 0xaa, 0x7a,
      0xe6, 0x7d, 0x58, 0xe5, 0x79, 0x1c, 0x23, 0x37, 0x9b, 0x60, 0x42, 0xe7, 0x5b, 0x38, 0xb8, 0xce,
      0x23, 0x1e, 0x67, 0xc3, 0x08, 0xaf, 0xf0, 0xbe, 0x55, 0x2c, 0xba, 0x6e, 0xc7, 0xf9, 0x13, 0xbe,
      0x79, 0xf2, 0x56, 0xcb, 0x9e, 0xc0, 0x9a, 0x7a, 0x19, 0x3d, 0x31, 0xfd, 0xe0, 0xd6, 0xac, 0x46,
      0xc5, 0xc1, 0xf9, 0x1d, 0x6a, 0x33, 0xad, 0x36, 0x4f, 0xcc, 0xc4, 0x1e, 0xac, 0xa7, 0x3c, 0xe9,
      0x29, 0x13, 0x55, 0x73, 0x5b, 0xbe, 0x6d, 0x86, 0x0e, 0xfc, 0xa0, 0xcd, 0x13, 0xe9, 0x72, 0xb8,
      0x96, 0x16, 0x07, 0xee, 0x7c, 0x0f, 0xf5, 0x65, 0x1d, 0xdd, 0x8c, 0xf1, 0xc2, 0x5a, 0xf0, 0xa2,
      0x06, 0x3b, 0x57, 0x28, 0xba, 0x98, 0xf1, 0x21, 0x1d, 0x9b, 0xa1, 0x5c, 0xb0, 0x17, 0xc1, 0xb9,
      0x45, 0x93, 0x02, 0xd2, 0x0a, 0x26, 0x74, 0x76, 0xa1, 0x76, 0x85, 0x22, 0x40, 0xcc, 0x2e, 0x68,
      0x3e, 0x36, 0x8f, 0xd6, 0xf9, 0x09, 0xea, 0xcb, 0xb0, 0x16, 0x3a, 0x04, 0x60, 0x88, 0x59, 0x2f,
      0x96, 0xa8, 0xd2, 0xda, 0x0c, 0xd7, 0x99, 0xa1, 0x39, 0xbf, 0xc2, 0x56, 0x90, 0x47, 0xa3, 0xe1,
      0xfc, 0x2d, 0xd4, 0xe1, 0x2b, 0x41, 0xd9, 0x30, 0x56, 0xdc, 0xf5, 0xb0, 0x08, 0x64, 0x3f, 0x8c,
      0x3c, 0x8c, 0x28, 0xe9, 0xeb, 0x7f, 0xd7, 0x84, 0x4e, 0x03, 0xaa, 0x33, 0x03, 0x3e, 0xaa, 0xe1,
      0x9c, 0xc2, 0xce, 0x02, 0x73, 0x3e, 0xa8, 0x11, 0xb6, 0x96, 0x84, 0x5b, 0x2f, 0x2c, 0x80, 0x98,
      0xa6, 0xda, 0xfd, 0x56, 0x5d, 0x8b, 0x9b, 0x4c, 0xb5, 0xfa, 0x81, 0xf5, 0xcf, 0x5f, 0x9f, 0xfc,
      0x3e, 0x66, 0x41, 0x82, 0xe3, 0xe2, 0xe3, 0xeb, 0x25, 0xd4, 0x2b, 0xbe, 0xb5, 0x3f, 0x33, 0x9f,
      0x4d, 0x9a, 0xcf, 0x4b, 0xe5, 0xe0, 0xe6, 0xe6, 0x65, 0xa9, 0x12, 0xf8, 0xcc, 0xed, 0x36, 0x5f,
      0xa9, 0xc3, 0x6d, 0xb7, 0xf9, 0xb6, 0x64, 0x17, 0x87, 0xdb, 0x3f, 0x82, 0x96, 0x94, 0x92, 0x7f,
      0xe7, 0xbb, 0xd2, 0x6a, 0xe0, 0xb3, 0xf3, 0xf3, 0x6e, 0x33, 0xaa, 0x28, 0xb5, 0x1f, 0xdf, 0x07,
      0x00, 0x00, 0xff, 0xff, 0x26, 0xd3, 0xfa, 0xe7, 0x23, 0x06, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/p2p/v1/resource.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: p2p/v1/resource.proto
      package p2pv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      types "github.com/gogo/protobuf/types"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type P2PMsgType int32
      const (
      P2PMsgType_P2P_MSG_TYPE_INVALID P2PMsgType = 0
      P2PMsgType_P2P_MSG_TYPE_PING P2PMsgType = 1
      P2PMsgType_P2P_MSG_TYPE_PONG P2PMsgType = 2
      )
      var P2PMsgType_name = map[int32]string{
      0: "P2P_MSG_TYPE_INVALID",
      1: "P2P_MSG_TYPE_PING",
      2: "P2P_MSG_TYPE_PONG",
      }
      var P2PMsgType_value = map[string]int32{
      "P2P_MSG_TYPE_INVALID": 0,
      "P2P_MSG_TYPE_PING": 1,
      "P2P_MSG_TYPE_PONG": 2,
      }
      func (x P2PMsgType) String() string {
      return proto.EnumName(P2PMsgType_name, int32(x))
      }
      func (P2PMsgType) EnumDescriptor() ([]byte, []int) {
      return fileDescriptor_84ae7440beef4c05, []int{0}
      }
      // shared between all p2p package
      type MessageHeader struct {
      // client protocol version
      ClientVersion string `protobuf:"bytes,1,opt,name=client_version,json=clientVersion,proto3" json:"client_version,omitempty"`
      // client type
      ClientType int32 `protobuf:"varint,2,opt,name=client_type,json=clientType,proto3" json:"client_type,omitempty"`
      // allows requesters to use request data when processing a response
      Id string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
      // package create time.
      CreateTime *types.Timestamp `protobuf:"bytes,4,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
      // id of node that created the message (not the peer that may have sent it). =base58(multihash(nodePubKey))
      NodeId string `protobuf:"bytes,5,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
      Gossip bool `protobuf:"varint,6,opt,name=gossip,proto3" json:"gossip,omitempty"`
      // Authoring node Secp256k1 public key (32bytes) - protobufs serielized
      NodePubkey []byte `protobuf:"bytes,7,opt,name=node_pubkey,json=nodePubkey,proto3" json:"node_pubkey,omitempty"`
      // signature of full message data.
      Sign []byte `protobuf:"bytes,8,opt,name=sign,proto3" json:"sign,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MessageHeader) Reset() { *m = MessageHeader{} }
      func (m *MessageHeader) String() string { return proto.CompactTextString(m) }
      func (*MessageHeader) ProtoMessage() {}
      func (*MessageHeader) Descriptor() ([]byte, []int) {
      return fileDescriptor_84ae7440beef4c05, []int{0}
      }
      func (m *MessageHeader) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MessageHeader.Unmarshal(m, b)
      }
      func (m *MessageHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MessageHeader.Marshal(b, m, deterministic)
      }
      func (m *MessageHeader) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MessageHeader.Merge(m, src)
      }
      func (m *MessageHeader) XXX_Size() int {
      return xxx_messageInfo_MessageHeader.Size(m)
      }
      func (m *MessageHeader) XXX_DiscardUnknown() {
      xxx_messageInfo_MessageHeader.DiscardUnknown(m)
      }
      var xxx_messageInfo_MessageHeader proto.InternalMessageInfo
      func (m *MessageHeader) GetClientVersion() string {
      if m != nil {
      return m.ClientVersion
      }
      return ""
      }
      func (m *MessageHeader) GetClientType() int32 {
      if m != nil {
      return m.ClientType
      }
      return 0
      }
      func (m *MessageHeader) GetId() string {
      if m != nil {
      return m.Id
      }
      return ""
      }
      func (m *MessageHeader) GetCreateTime() *types.Timestamp {
      if m != nil {
      return m.CreateTime
      }
      return nil
      }
      func (m *MessageHeader) GetNodeId() string {
      if m != nil {
      return m.NodeId
      }
      return ""
      }
      func (m *MessageHeader) GetGossip() bool {
      if m != nil {
      return m.Gossip
      }
      return false
      }
      func (m *MessageHeader) GetNodePubkey() []byte {
      if m != nil {
      return m.NodePubkey
      }
      return nil
      }
      func (m *MessageHeader) GetSign() []byte {
      if m != nil {
      return m.Sign
      }
      return nil
      }
      // HandShake used for check info when peer connect
      type HandShakeRequest struct {
      Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *HandShakeRequest) Reset() { *m = HandShakeRequest{} }
      func (m *HandShakeRequest) String() string { return proto.CompactTextString(m) }
      func (*HandShakeRequest) ProtoMessage() {}
      func (*HandShakeRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_84ae7440beef4c05, []int{1}
      }
      func (m *HandShakeRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_HandShakeRequest.Unmarshal(m, b)
      }
      func (m *HandShakeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_HandShakeRequest.Marshal(b, m, deterministic)
      }
      func (m *HandShakeRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_HandShakeRequest.Merge(m, src)
      }
      func (m *HandShakeRequest) XXX_Size() int {
      return xxx_messageInfo_HandShakeRequest.Size(m)
      }
      func (m *HandShakeRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_HandShakeRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_HandShakeRequest proto.InternalMessageInfo
      func (m *HandShakeRequest) GetHeader() *MessageHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *HandShakeRequest) GetMessage() string {
      if m != nil {
      return m.Message
      }
      return ""
      }
      type HandShakeResponse struct {
      Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *HandShakeResponse) Reset() { *m = HandShakeResponse{} }
      func (m *HandShakeResponse) String() string { return proto.CompactTextString(m) }
      func (*HandShakeResponse) ProtoMessage() {}
      func (*HandShakeResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_84ae7440beef4c05, []int{2}
      }
      func (m *HandShakeResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_HandShakeResponse.Unmarshal(m, b)
      }
      func (m *HandShakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_HandShakeResponse.Marshal(b, m, deterministic)
      }
      func (m *HandShakeResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_HandShakeResponse.Merge(m, src)
      }
      func (m *HandShakeResponse) XXX_Size() int {
      return xxx_messageInfo_HandShakeResponse.Size(m)
      }
      func (m *HandShakeResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_HandShakeResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_HandShakeResponse proto.InternalMessageInfo
      func (m *HandShakeResponse) GetHeader() *MessageHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *HandShakeResponse) GetMessage() string {
      if m != nil {
      return m.Message
      }
      return ""
      }
      // PingRequest used for peer keep alive.
      type PingRequest struct {
      Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *PingRequest) Reset() { *m = PingRequest{} }
      func (m *PingRequest) String() string { return proto.CompactTextString(m) }
      func (*PingRequest) ProtoMessage() {}
      func (*PingRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_84ae7440beef4c05, []int{3}
      }
      func (m *PingRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_PingRequest.Unmarshal(m, b)
      }
      func (m *PingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_PingRequest.Marshal(b, m, deterministic)
      }
      func (m *PingRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_PingRequest.Merge(m, src)
      }
      func (m *PingRequest) XXX_Size() int {
      return xxx_messageInfo_PingRequest.Size(m)
      }
      func (m *PingRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_PingRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_PingRequest proto.InternalMessageInfo
      func (m *PingRequest) GetHeader() *MessageHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *PingRequest) GetMessage() string {
      if m != nil {
      return m.Message
      }
      return ""
      }
      type PongResponse struct {
      Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *PongResponse) Reset() { *m = PongResponse{} }
      func (m *PongResponse) String() string { return proto.CompactTextString(m) }
      func (*PongResponse) ProtoMessage() {}
      func (*PongResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_84ae7440beef4c05, []int{4}
      }
      func (m *PongResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_PongResponse.Unmarshal(m, b)
      }
      func (m *PongResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_PongResponse.Marshal(b, m, deterministic)
      }
      func (m *PongResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_PongResponse.Merge(m, src)
      }
      func (m *PongResponse) XXX_Size() int {
      return xxx_messageInfo_PongResponse.Size(m)
      }
      func (m *PongResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_PongResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_PongResponse proto.InternalMessageInfo
      func (m *PongResponse) GetHeader() *MessageHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *PongResponse) GetMessage() string {
      if m != nil {
      return m.Message
      }
      return ""
      }
      // Disconnect used for disconnect a peer and give a reason.
      type DisconnectRequest struct {
      Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *DisconnectRequest) Reset() { *m = DisconnectRequest{} }
      func (m *DisconnectRequest) String() string { return proto.CompactTextString(m) }
      func (*DisconnectRequest) ProtoMessage() {}
      func (*DisconnectRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_84ae7440beef4c05, []int{5}
      }
      func (m *DisconnectRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_DisconnectRequest.Unmarshal(m, b)
      }
      func (m *DisconnectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_DisconnectRequest.Marshal(b, m, deterministic)
      }
      func (m *DisconnectRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_DisconnectRequest.Merge(m, src)
      }
      func (m *DisconnectRequest) XXX_Size() int {
      return xxx_messageInfo_DisconnectRequest.Size(m)
      }
      func (m *DisconnectRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_DisconnectRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_DisconnectRequest proto.InternalMessageInfo
      func (m *DisconnectRequest) GetHeader() *MessageHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *DisconnectRequest) GetReason() string {
      if m != nil {
      return m.Reason
      }
      return ""
      }
      type MessageRequest struct {
      Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      MessageType int32 `protobuf:"varint,2,opt,name=message_type,json=messageType,proto3" json:"message_type,omitempty"`
      MessageData []byte `protobuf:"bytes,3,opt,name=message_data,json=messageData,proto3" json:"message_data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MessageRequest) Reset() { *m = MessageRequest{} }
      func (m *MessageRequest) String() string { return proto.CompactTextString(m) }
      func (*MessageRequest) ProtoMessage() {}
      func (*MessageRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_84ae7440beef4c05, []int{6}
      }
      func (m *MessageRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MessageRequest.Unmarshal(m, b)
      }
      func (m *MessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MessageRequest.Marshal(b, m, deterministic)
      }
      func (m *MessageRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MessageRequest.Merge(m, src)
      }
      func (m *MessageRequest) XXX_Size() int {
      return xxx_messageInfo_MessageRequest.Size(m)
      }
      func (m *MessageRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_MessageRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_MessageRequest proto.InternalMessageInfo
      func (m *MessageRequest) GetHeader() *MessageHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *MessageRequest) GetMessageType() int32 {
      if m != nil {
      return m.MessageType
      }
      return 0
      }
      func (m *MessageRequest) GetMessageData() []byte {
      if m != nil {
      return m.MessageData
      }
      return nil
      }
      type MessageResponse struct {
      Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
      MessageType int32 `protobuf:"varint,2,opt,name=message_type,json=messageType,proto3" json:"message_type,omitempty"`
      MessageData []byte `protobuf:"bytes,3,opt,name=message_data,json=messageData,proto3" json:"message_data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *MessageResponse) Reset() { *m = MessageResponse{} }
      func (m *MessageResponse) String() string { return proto.CompactTextString(m) }
      func (*MessageResponse) ProtoMessage() {}
      func (*MessageResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_84ae7440beef4c05, []int{7}
      }
      func (m *MessageResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_MessageResponse.Unmarshal(m, b)
      }
      func (m *MessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_MessageResponse.Marshal(b, m, deterministic)
      }
      func (m *MessageResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_MessageResponse.Merge(m, src)
      }
      func (m *MessageResponse) XXX_Size() int {
      return xxx_messageInfo_MessageResponse.Size(m)
      }
      func (m *MessageResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_MessageResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_MessageResponse proto.InternalMessageInfo
      func (m *MessageResponse) GetHeader() *MessageHeader {
      if m != nil {
      return m.Header
      }
      return nil
      }
      func (m *MessageResponse) GetMessageType() int32 {
      if m != nil {
      return m.MessageType
      }
      return 0
      }
      func (m *MessageResponse) GetMessageData() []byte {
      if m != nil {
      return m.MessageData
      }
      return nil
      }
      func init() {
      proto.RegisterEnum("p2p.v1.P2PMsgType", P2PMsgType_name, P2PMsgType_value)
      proto.RegisterType((*MessageHeader)(nil), "p2p.v1.MessageHeader")
      proto.RegisterType((*HandShakeRequest)(nil), "p2p.v1.HandShakeRequest")
      proto.RegisterType((*HandShakeResponse)(nil), "p2p.v1.HandShakeResponse")
      proto.RegisterType((*PingRequest)(nil), "p2p.v1.PingRequest")
      proto.RegisterType((*PongResponse)(nil), "p2p.v1.PongResponse")
      proto.RegisterType((*DisconnectRequest)(nil), "p2p.v1.DisconnectRequest")
      proto.RegisterType((*MessageRequest)(nil), "p2p.v1.MessageRequest")
      proto.RegisterType((*MessageResponse)(nil), "p2p.v1.MessageResponse")
      }
      func init() { proto.RegisterFile("p2p/v1/resource.proto", fileDescriptor_84ae7440beef4c05) }
      var fileDescriptor_84ae7440beef4c05 = []byte{
      // 584 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xc1, 0x4e, 0xdb, 0x4c,
      0x10, 0xfe, 0x6d, 0xc0, 0x81, 0x49, 0xe0, 0x0f, 0xab, 0x42, 0x2d, 0x2e, 0xa4, 0x91, 0x2a, 0x45,
      0x95, 0x6a, 0x2b, 0xee, 0x0d, 0x4e, 0xa5, 0x54, 0x21, 0x6a, 0x43, 0x57, 0x26, 0x4a, 0x29, 0x45,
      0xb2, 0x36, 0xf6, 0xd4, 0x58, 0x10, 0xef, 0xd6, 0xbb, 0x8e, 0xc4, 0x03, 0xb4, 0x87, 0xbe, 0x45,
      0x7b, 0xec, 0xa3, 0xf4, 0x31, 0x7a, 0xec, 0x53, 0x54, 0xde, 0x35, 0x08, 0xd4, 0x1b, 0xca, 0x6d,
      0xe7, 0x9b, 0x6f, 0x3e, 0x7d, 0xfe, 0x34, 0x1e, 0xd8, 0x12, 0x81, 0xf0, 0xe7, 0x7d, 0xbf, 0x40,
      0xc9, 0xcb, 0x22, 0x46, 0x4f, 0x14, 0x5c, 0x71, 0xe2, 0x88, 0x40, 0x78, 0xf3, 0xfe, 0xce, 0x6e,
      0xca, 0x79, 0x7a, 0x85, 0xbe, 0x46, 0xa7, 0xe5, 0x27, 0x5f, 0x65, 0x33, 0x94, 0x8a, 0xcd, 0x84,
      0x21, 0x76, 0xbf, 0xd9, 0xb0, 0x3e, 0x42, 0x29, 0x59, 0x8a, 0x47, 0xc8, 0x12, 0x2c, 0xc8, 0x53,
      0xd8, 0x88, 0xaf, 0x32, 0xcc, 0x55, 0x34, 0xc7, 0x42, 0x66, 0x3c, 0x77, 0xad, 0x8e, 0xd5, 0x5b,
      0x0b, 0xd7, 0x0d, 0x3a, 0x31, 0x20, 0xd9, 0x85, 0x66, 0x4d, 0x53, 0xd7, 0x02, 0x5d, 0xbb, 0x63,
      0xf5, 0x56, 0x42, 0x30, 0xd0, 0xf8, 0x5a, 0x20, 0xd9, 0x00, 0x3b, 0x4b, 0xdc, 0x25, 0x3d, 0x6b,
      0x67, 0x09, 0xd9, 0x87, 0x66, 0x5c, 0x20, 0x53, 0x18, 0x55, 0x1e, 0xdc, 0xe5, 0x8e, 0xd5, 0x6b,
      0x06, 0x3b, 0x9e, 0x31, 0xe8, 0xdd, 0x18, 0xf4, 0xc6, 0x37, 0x06, 0x43, 0x30, 0xf4, 0x0a, 0x20,
      0x8f, 0xa1, 0x91, 0xf3, 0x04, 0xa3, 0x2c, 0x71, 0x57, 0xb4, 0xa2, 0x53, 0x95, 0xc3, 0x84, 0x6c,
      0x83, 0x93, 0x72, 0x29, 0x33, 0xe1, 0x3a, 0x1d, 0xab, 0xb7, 0x1a, 0xd6, 0x55, 0x65, 0x4f, 0x0f,
      0x88, 0x72, 0x7a, 0x89, 0xd7, 0x6e, 0xa3, 0x63, 0xf5, 0x5a, 0x21, 0x54, 0x10, 0xd5, 0x08, 0x21,
      0xb0, 0x2c, 0xb3, 0x34, 0x77, 0x57, 0x75, 0x47, 0xbf, 0xbb, 0x1f, 0xa1, 0x7d, 0xc4, 0xf2, 0xe4,
      0xe4, 0x82, 0x5d, 0x62, 0x88, 0x9f, 0x4b, 0x94, 0x8a, 0x3c, 0x07, 0xe7, 0x42, 0x07, 0xa3, 0x63,
      0x68, 0x06, 0x5b, 0x9e, 0x89, 0xd6, 0xbb, 0x97, 0x5a, 0x58, 0x93, 0x88, 0x0b, 0x8d, 0x99, 0x69,
      0xe8, 0x48, 0xd6, 0xc2, 0x9b, 0xb2, 0x7b, 0x0e, 0x9b, 0x77, 0xc4, 0xa5, 0xe0, 0xb9, 0xc4, 0xc5,
      0xa9, 0x4f, 0xa0, 0x49, 0xb3, 0x3c, 0x5d, 0xb8, 0xeb, 0xf7, 0xd0, 0xa2, 0xbc, 0xd2, 0x5d, 0xb4,
      0xe1, 0x33, 0xd8, 0x3c, 0xcc, 0x64, 0xcc, 0xf3, 0x1c, 0x63, 0xf5, 0x40, 0xdb, 0xdb, 0xe0, 0x14,
      0xc8, 0x24, 0xcf, 0x6b, 0xf1, 0xba, 0xea, 0x7e, 0xb1, 0x60, 0xa3, 0x9e, 0x78, 0xa0, 0xf2, 0x13,
      0x68, 0xd5, 0x46, 0xef, 0xae, 0x77, 0xb3, 0xc6, 0xf4, 0x7e, 0xdf, 0xa1, 0x24, 0x4c, 0x31, 0xbd,
      0xe9, 0xad, 0x5b, 0xca, 0x21, 0x53, 0xac, 0xfb, 0xd5, 0x82, 0xff, 0x6f, 0x7d, 0x3c, 0x2c, 0xc0,
      0x85, 0x18, 0x79, 0x36, 0x06, 0xa0, 0x01, 0x1d, 0xc9, 0x54, 0x0f, 0xb8, 0xf0, 0x88, 0x06, 0x34,
      0x1a, 0x9d, 0x0c, 0xa2, 0xf1, 0x07, 0xfa, 0x3a, 0x1a, 0x1e, 0x4f, 0x5e, 0xbe, 0x1d, 0x1e, 0xb6,
      0xff, 0x23, 0x5b, 0xb0, 0x79, 0xaf, 0x43, 0x87, 0xc7, 0x83, 0xb6, 0xf5, 0x2f, 0xfc, 0xee, 0x78,
      0xd0, 0xb6, 0x0f, 0xbe, 0x5b, 0x00, 0x31, 0x9f, 0xd5, 0x1f, 0x70, 0xb0, 0x1e, 0xd6, 0x37, 0x88,
      0x56, 0xff, 0x32, 0xb5, 0xce, 0xde, 0xa4, 0x99, 0xba, 0x28, 0xa7, 0x5e, 0xcc, 0x67, 0xfe, 0x2b,
      0x96, 0x94, 0x31, 0x96, 0x72, 0x84, 0x8a, 0x55, 0x77, 0xc5, 0x90, 0x62, 0x7e, 0xe5, 0x57, 0xc8,
      0x6d, 0x91, 0x62, 0x6e, 0x6e, 0x95, 0x9f, 0x72, 0xdf, 0x9c, 0xb6, 0x7d, 0x11, 0x88, 0x79, 0xff,
      0x87, 0xbd, 0x44, 0x4f, 0x4f, 0x7f, 0xda, 0x0e, 0x0d, 0x84, 0x37, 0xe9, 0xff, 0xd2, 0x8f, 0xf3,
      0x49, 0xff, 0xb7, 0x4d, 0xcc, 0xe3, 0x7c, 0x40, 0x0f, 0x2a, 0xa9, 0x2a, 0x82, 0x3f, 0x76, 0x83,
      0x06, 0x62, 0x6f, 0x6f, 0xd2, 0x9f, 0x3a, 0x5a, 0xed, 0xc5, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff,
      0xd8, 0x76, 0xea, 0xb8, 0x28, 0x05, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/p2p/v1/service.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: p2p/v1/service.proto
      package p2pv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      _ "google.golang.org/protobuf/types/known/emptypb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("p2p/v1/service.proto", fileDescriptor_44cb8ccd8d1336f3) }
      var fileDescriptor_44cb8ccd8d1336f3 = []byte{
      // 472 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xd1, 0x6e, 0xd3, 0x30,
      0x14, 0x86, 0x69, 0x11, 0xad, 0x30, 0x95, 0x90, 0x0c, 0x1a, 0xa3, 0x83, 0x9b, 0x71, 0xef, 0x2c,
      0xe1, 0x8a, 0x21, 0x71, 0x91, 0x32, 0x40, 0xa0, 0x56, 0x16, 0xad, 0xaa, 0x09, 0x4d, 0x42, 0x4e,
      0x7a, 0x48, 0x23, 0xb5, 0xb1, 0xf1, 0x71, 0x42, 0x79, 0x1b, 0xc4, 0x25, 0x8f, 0xc2, 0x63, 0x70,
      0x89, 0xc4, 0x3b, 0xa0, 0xd4, 0x89, 0x97, 0x90, 0x8d, 0x3b, 0xfb, 0xff, 0xff, 0x7c, 0xe7, 0xf8,
      0xc4, 0x26, 0xf7, 0x55, 0xa0, 0xbc, 0xc2, 0xf7, 0x10, 0x74, 0x91, 0xc6, 0xc0, 0x94, 0x96, 0x46,
      0xd2, 0x81, 0x0a, 0x14, 0x2b, 0xfc, 0xf1, 0xe3, 0xca, 0xd5, 0xf0, 0x39, 0x07, 0x34, 0x1f, 0x35,
      0xa0, 0x92, 0x19, 0x56, 0xb1, 0xf1, 0x51, 0x22, 0x65, 0xb2, 0x01, 0x6f, 0xbf, 0x8b, 0xf2, 0x4f,
      0x1e, 0x6c, 0x95, 0xf9, 0x6a, 0xcd, 0xe0, 0xcf, 0x2d, 0x42, 0x78, 0xc0, 0xe7, 0x16, 0x4c, 0xcf,
      0xc8, 0x28, 0xd4, 0x52, 0xac, 0x62, 0x81, 0x66, 0x8a, 0x09, 0x3d, 0x64, 0xb6, 0x06, 0xdb, 0xab,
      0x13, 0x81, 0xe6, 0xbd, 0x2d, 0x32, 0x7e, 0x78, 0x85, 0x63, 0xcb, 0x1e, 0xdf, 0xa0, 0x33, 0x72,
      0xd7, 0x61, 0x16, 0x3b, 0x2c, 0x49, 0x47, 0x9d, 0xfc, 0x62, 0x87, 0x35, 0xec, 0xd1, 0xd5, 0xa6,
      0xe3, 0xbd, 0x25, 0x77, 0x42, 0x61, 0xe2, 0xf5, 0x62, 0x87, 0xdb, 0x16, 0xab, 0x12, 0xdf, 0x08,
      0x5c, 0x77, 0x59, 0x2d, 0xd3, 0xb1, 0x5e, 0x90, 0xe1, 0x1c, 0xb2, 0x55, 0xd9, 0xd3, 0x83, 0x3a,
      0x5a, 0x0a, 0x2f, 0x85, 0x11, 0x35, 0xe3, 0xb0, 0x6b, 0xb8, 0xef, 0x5f, 0x91, 0xd1, 0x0c, 0x0c,
      0x07, 0xd0, 0x13, 0x99, 0x67, 0x86, 0x1e, 0x30, 0x3b, 0x5f, 0x56, 0xcf, 0x97, 0x9d, 0x95, 0xf3,
      0xbd, 0xec, 0xa3, 0x99, 0x6e, 0x70, 0x42, 0x42, 0x66, 0x60, 0x96, 0xa0, 0x31, 0x95, 0xd9, 0xb5,
      0x94, 0x71, 0x83, 0x52, 0x65, 0x1b, 0x8c, 0x88, 0xdc, 0x9b, 0xe7, 0x11, 0xc6, 0x3a, 0x8d, 0x60,
      0x06, 0x5f, 0xaa, 0x13, 0xd3, 0x63, 0xd7, 0xfe, 0xbf, 0xa6, 0xd9, 0xd5, 0x47, 0x7c, 0xf2, 0xdf,
      0x4c, 0x5d, 0xe1, 0xa4, 0x47, 0xa7, 0x64, 0xe4, 0x22, 0xad, 0x1f, 0xd9, 0x54, 0x3b, 0xc3, 0x6f,
      0x9b, 0x0d, 0xdc, 0x33, 0x32, 0xe4, 0x79, 0xb4, 0x49, 0x71, 0x4d, 0x0f, 0xea, 0x70, 0x25, 0xd4,
      0x90, 0x6b, 0x66, 0x41, 0x43, 0x72, 0xdb, 0x61, 0x2f, 0x6f, 0xa6, 0x93, 0x3a, 0x37, 0xb3, 0xe1,
      0xd8, 0x06, 0x4e, 0x7a, 0xe1, 0xb7, 0x1e, 0x21, 0xb1, 0xdc, 0x56, 0x91, 0x70, 0x54, 0x5d, 0x7c,
      0x5e, 0x56, 0xe2, 0xbd, 0x0f, 0xef, 0x92, 0xd4, 0xac, 0xf3, 0x88, 0xc5, 0x72, 0xeb, 0x4d, 0xc4,
      0x2a, 0x8f, 0x21, 0xc7, 0x29, 0x18, 0x51, 0x80, 0x46, 0x1b, 0x8a, 0xe5, 0xc6, 0x2b, 0x15, 0xb7,
      0x49, 0x20, 0xb3, 0x4f, 0xcb, 0x4b, 0xa4, 0x67, 0x5f, 0xe2, 0x73, 0x15, 0xa8, 0xc2, 0xff, 0xde,
      0xbf, 0xc9, 0xcf, 0xcf, 0x7f, 0xf4, 0x07, 0x3c, 0x50, 0x6c, 0xe9, 0xff, 0xdc, 0x2f, 0x2e, 0x96,
      0xfe, 0xaf, 0x3e, 0xb5, 0x8b, 0x8b, 0xd7, 0x3c, 0x2c, 0x51, 0x2b, 0x61, 0xc4, 0xef, 0xfe, 0x90,
      0x07, 0xea, 0xf4, 0x74, 0xe9, 0x47, 0x83, 0x3d, 0xed, 0xe9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff,
      0xda, 0xcb, 0x41, 0x4e, 0xf5, 0x03, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/p2p/v1/service_grpc.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
      // versions:
      // - protoc-gen-go-grpc v1.2.0
      // - protoc (unknown)
      // source: p2p/v1/service.proto
      package p2pv1
      import (
      context "context"
      grpc "google.golang.org/grpc"
      codes "google.golang.org/grpc/codes"
      status "google.golang.org/grpc/status"
      emptypb "google.golang.org/protobuf/types/known/emptypb"
      )
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the grpc package it is being compiled against.
      // Requires gRPC-Go v1.32.0 or later.
      const _ = grpc.SupportPackageIsVersion7
      // P2PServiceClient is the client API for P2PService service.
      //
      // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
      type P2PServiceClient interface {
      BroadcastMsg(ctx context.Context, in *BroadCastRequest, opts ...grpc.CallOption) (*BroadCastResponse, error)
      BroadcastTxsMsg(ctx context.Context, in *BroadCastTxsRequest, opts ...grpc.CallOption) (*BroadCastTxsResponse, error)
      BatchTxsmsg(ctx context.Context, in *BatchTxsHashRequest, opts ...grpc.CallOption) (*BatchTxsHashResponse, error)
      SendMsg(ctx context.Context, in *SendDataRequest, opts ...grpc.CallOption) (*SendDataResponse, error)
      // network info service
      NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error)
      NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error)
      SubscribeNewBatchTx(ctx context.Context, in *SubscribeNewBatchtxRequest, opts ...grpc.CallOption) (P2PService_SubscribeNewBatchTxClient, error)
      SubscribeMsg(ctx context.Context, in *SubscribeMsgRequest, opts ...grpc.CallOption) (P2PService_SubscribeMsgClient, error)
      Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
      Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (P2PService_SubscribeClient, error)
      }
      type p2PServiceClient struct {
      cc grpc.ClientConnInterface
      }
      func NewP2PServiceClient(cc grpc.ClientConnInterface) P2PServiceClient {
      return &p2PServiceClient{cc}
      }
      func (c *p2PServiceClient) BroadcastMsg(ctx context.Context, in *BroadCastRequest, opts ...grpc.CallOption) (*BroadCastResponse, error) {
      out := new(BroadCastResponse)
      err := c.cc.Invoke(ctx, "/p2p.v1.P2PService/BroadcastMsg", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *p2PServiceClient) BroadcastTxsMsg(ctx context.Context, in *BroadCastTxsRequest, opts ...grpc.CallOption) (*BroadCastTxsResponse, error) {
      out := new(BroadCastTxsResponse)
      err := c.cc.Invoke(ctx, "/p2p.v1.P2PService/BroadcastTxsMsg", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *p2PServiceClient) BatchTxsmsg(ctx context.Context, in *BatchTxsHashRequest, opts ...grpc.CallOption) (*BatchTxsHashResponse, error) {
      out := new(BatchTxsHashResponse)
      err := c.cc.Invoke(ctx, "/p2p.v1.P2PService/BatchTxsmsg", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *p2PServiceClient) SendMsg(ctx context.Context, in *SendDataRequest, opts ...grpc.CallOption) (*SendDataResponse, error) {
      out := new(SendDataResponse)
      err := c.cc.Invoke(ctx, "/p2p.v1.P2PService/SendMsg", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *p2PServiceClient) NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error) {
      out := new(NetPeerCountResponse)
      err := c.cc.Invoke(ctx, "/p2p.v1.P2PService/NetPeerCount", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *p2PServiceClient) NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error) {
      out := new(NetVersionResponse)
      err := c.cc.Invoke(ctx, "/p2p.v1.P2PService/NetVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *p2PServiceClient) SubscribeNewBatchTx(ctx context.Context, in *SubscribeNewBatchtxRequest, opts ...grpc.CallOption) (P2PService_SubscribeNewBatchTxClient, error) {
      stream, err := c.cc.NewStream(ctx, &P2PService_ServiceDesc.Streams[0], "/p2p.v1.P2PService/SubscribeNewBatchTx", opts...)
      if err != nil {
      return nil, err
      }
      x := &p2PServiceSubscribeNewBatchTxClient{stream}
      if err := x.ClientStream.SendMsg(in); err != nil {
      return nil, err
      }
      if err := x.ClientStream.CloseSend(); err != nil {
      return nil, err
      }
      return x, nil
      }
      type P2PService_SubscribeNewBatchTxClient interface {
      Recv() (*SubscribeNewBatchtxResponse, error)
      grpc.ClientStream
      }
      type p2PServiceSubscribeNewBatchTxClient struct {
      grpc.ClientStream
      }
      func (x *p2PServiceSubscribeNewBatchTxClient) Recv() (*SubscribeNewBatchtxResponse, error) {
      m := new(SubscribeNewBatchtxResponse)
      if err := x.ClientStream.RecvMsg(m); err != nil {
      return nil, err
      }
      return m, nil
      }
      func (c *p2PServiceClient) SubscribeMsg(ctx context.Context, in *SubscribeMsgRequest, opts ...grpc.CallOption) (P2PService_SubscribeMsgClient, error) {
      stream, err := c.cc.NewStream(ctx, &P2PService_ServiceDesc.Streams[1], "/p2p.v1.P2PService/SubscribeMsg", opts...)
      if err != nil {
      return nil, err
      }
      x := &p2PServiceSubscribeMsgClient{stream}
      if err := x.ClientStream.SendMsg(in); err != nil {
      return nil, err
      }
      if err := x.ClientStream.CloseSend(); err != nil {
      return nil, err
      }
      return x, nil
      }
      type P2PService_SubscribeMsgClient interface {
      Recv() (*SubscribeMsgResponse, error)
      grpc.ClientStream
      }
      type p2PServiceSubscribeMsgClient struct {
      grpc.ClientStream
      }
      func (x *p2PServiceSubscribeMsgClient) Recv() (*SubscribeMsgResponse, error) {
      m := new(SubscribeMsgResponse)
      if err := x.ClientStream.RecvMsg(m); err != nil {
      return nil, err
      }
      return m, nil
      }
      func (c *p2PServiceClient) Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
      out := new(emptypb.Empty)
      err := c.cc.Invoke(ctx, "/p2p.v1.P2PService/Publish", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *p2PServiceClient) Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (P2PService_SubscribeClient, error) {
      stream, err := c.cc.NewStream(ctx, &P2PService_ServiceDesc.Streams[2], "/p2p.v1.P2PService/Subscribe", opts...)
      if err != nil {
      return nil, err
      }
      x := &p2PServiceSubscribeClient{stream}
      if err := x.ClientStream.SendMsg(in); err != nil {
      return nil, err
      }
      if err := x.ClientStream.CloseSend(); err != nil {
      return nil, err
      }
      return x, nil
      }
      type P2PService_SubscribeClient interface {
      Recv() (*SubscribeResponse, error)
      grpc.ClientStream
      }
      type p2PServiceSubscribeClient struct {
      grpc.ClientStream
      }
      func (x *p2PServiceSubscribeClient) Recv() (*SubscribeResponse, error) {
      m := new(SubscribeResponse)
      if err := x.ClientStream.RecvMsg(m); err != nil {
      return nil, err
      }
      return m, nil
      }
      // P2PServiceServer is the server API for P2PService service.
      // All implementations must embed UnimplementedP2PServiceServer
      // for forward compatibility
      type P2PServiceServer interface {
      BroadcastMsg(context.Context, *BroadCastRequest) (*BroadCastResponse, error)
      BroadcastTxsMsg(context.Context, *BroadCastTxsRequest) (*BroadCastTxsResponse, error)
      BatchTxsmsg(context.Context, *BatchTxsHashRequest) (*BatchTxsHashResponse, error)
      SendMsg(context.Context, *SendDataRequest) (*SendDataResponse, error)
      // network info service
      NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error)
      NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error)
      SubscribeNewBatchTx(*SubscribeNewBatchtxRequest, P2PService_SubscribeNewBatchTxServer) error
      SubscribeMsg(*SubscribeMsgRequest, P2PService_SubscribeMsgServer) error
      Publish(context.Context, *PublishRequest) (*emptypb.Empty, error)
      Subscribe(*SubscribeRequest, P2PService_SubscribeServer) error
      mustEmbedUnimplementedP2PServiceServer()
      }
      // UnimplementedP2PServiceServer must be embedded to have forward compatible implementations.
      type UnimplementedP2PServiceServer struct {
      }
      func (UnimplementedP2PServiceServer) BroadcastMsg(context.Context, *BroadCastRequest) (*BroadCastResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BroadcastMsg not implemented")
      }
      func (UnimplementedP2PServiceServer) BroadcastTxsMsg(context.Context, *BroadCastTxsRequest) (*BroadCastTxsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BroadcastTxsMsg not implemented")
      }
      func (UnimplementedP2PServiceServer) BatchTxsmsg(context.Context, *BatchTxsHashRequest) (*BatchTxsHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BatchTxsmsg not implemented")
      }
      func (UnimplementedP2PServiceServer) SendMsg(context.Context, *SendDataRequest) (*SendDataResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SendMsg not implemented")
      }
      func (UnimplementedP2PServiceServer) NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NetPeerCount not implemented")
      }
      func (UnimplementedP2PServiceServer) NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NetVersion not implemented")
      }
      func (UnimplementedP2PServiceServer) SubscribeNewBatchTx(*SubscribeNewBatchtxRequest, P2PService_SubscribeNewBatchTxServer) error {
      return status.Errorf(codes.Unimplemented, "method SubscribeNewBatchTx not implemented")
      }
      func (UnimplementedP2PServiceServer) SubscribeMsg(*SubscribeMsgRequest, P2PService_SubscribeMsgServer) error {
      return status.Errorf(codes.Unimplemented, "method SubscribeMsg not implemented")
      }
      func (UnimplementedP2PServiceServer) Publish(context.Context, *PublishRequest) (*emptypb.Empty, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Publish not implemented")
      }
      func (UnimplementedP2PServiceServer) Subscribe(*SubscribeRequest, P2PService_SubscribeServer) error {
      return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
      }
      func (UnimplementedP2PServiceServer) mustEmbedUnimplementedP2PServiceServer() {}
      // UnsafeP2PServiceServer may be embedded to opt out of forward compatibility for this service.
      // Use of this interface is not recommended, as added methods to P2PServiceServer will
      // result in compilation errors.
      type UnsafeP2PServiceServer interface {
      mustEmbedUnimplementedP2PServiceServer()
      }
      func RegisterP2PServiceServer(s grpc.ServiceRegistrar, srv P2PServiceServer) {
      s.RegisterService(&P2PService_ServiceDesc, srv)
      }
      func _P2PService_BroadcastMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BroadCastRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(P2PServiceServer).BroadcastMsg(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/p2p.v1.P2PService/BroadcastMsg",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(P2PServiceServer).BroadcastMsg(ctx, req.(*BroadCastRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _P2PService_BroadcastTxsMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BroadCastTxsRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(P2PServiceServer).BroadcastTxsMsg(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/p2p.v1.P2PService/BroadcastTxsMsg",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(P2PServiceServer).BroadcastTxsMsg(ctx, req.(*BroadCastTxsRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _P2PService_BatchTxsmsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BatchTxsHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(P2PServiceServer).BatchTxsmsg(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/p2p.v1.P2PService/BatchTxsmsg",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(P2PServiceServer).BatchTxsmsg(ctx, req.(*BatchTxsHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _P2PService_SendMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SendDataRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(P2PServiceServer).SendMsg(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/p2p.v1.P2PService/SendMsg",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(P2PServiceServer).SendMsg(ctx, req.(*SendDataRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _P2PService_NetPeerCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(P2PServiceServer).NetPeerCount(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/p2p.v1.P2PService/NetPeerCount",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(P2PServiceServer).NetPeerCount(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _P2PService_NetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(P2PServiceServer).NetVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/p2p.v1.P2PService/NetVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(P2PServiceServer).NetVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _P2PService_SubscribeNewBatchTx_Handler(srv interface{}, stream grpc.ServerStream) error {
      m := new(SubscribeNewBatchtxRequest)
      if err := stream.RecvMsg(m); err != nil {
      return err
      }
      return srv.(P2PServiceServer).SubscribeNewBatchTx(m, &p2PServiceSubscribeNewBatchTxServer{stream})
      }
      type P2PService_SubscribeNewBatchTxServer interface {
      Send(*SubscribeNewBatchtxResponse) error
      grpc.ServerStream
      }
      type p2PServiceSubscribeNewBatchTxServer struct {
      grpc.ServerStream
      }
      func (x *p2PServiceSubscribeNewBatchTxServer) Send(m *SubscribeNewBatchtxResponse) error {
      return x.ServerStream.SendMsg(m)
      }
      func _P2PService_SubscribeMsg_Handler(srv interface{}, stream grpc.ServerStream) error {
      m := new(SubscribeMsgRequest)
      if err := stream.RecvMsg(m); err != nil {
      return err
      }
      return srv.(P2PServiceServer).SubscribeMsg(m, &p2PServiceSubscribeMsgServer{stream})
      }
      type P2PService_SubscribeMsgServer interface {
      Send(*SubscribeMsgResponse) error
      grpc.ServerStream
      }
      type p2PServiceSubscribeMsgServer struct {
      grpc.ServerStream
      }
      func (x *p2PServiceSubscribeMsgServer) Send(m *SubscribeMsgResponse) error {
      return x.ServerStream.SendMsg(m)
      }
      func _P2PService_Publish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(PublishRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(P2PServiceServer).Publish(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/p2p.v1.P2PService/Publish",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(P2PServiceServer).Publish(ctx, req.(*PublishRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _P2PService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
      m := new(SubscribeRequest)
      if err := stream.RecvMsg(m); err != nil {
      return err
      }
      return srv.(P2PServiceServer).Subscribe(m, &p2PServiceSubscribeServer{stream})
      }
      type P2PService_SubscribeServer interface {
      Send(*SubscribeResponse) error
      grpc.ServerStream
      }
      type p2PServiceSubscribeServer struct {
      grpc.ServerStream
      }
      func (x *p2PServiceSubscribeServer) Send(m *SubscribeResponse) error {
      return x.ServerStream.SendMsg(m)
      }
      // P2PService_ServiceDesc is the grpc.ServiceDesc for P2PService service.
      // It's only intended for direct use with grpc.RegisterService,
      // and not to be introspected or modified (even as a copy)
      var P2PService_ServiceDesc = grpc.ServiceDesc{
      ServiceName: "p2p.v1.P2PService",
      HandlerType: (*P2PServiceServer)(nil),
      Methods: []grpc.MethodDesc{
      {
      MethodName: "BroadcastMsg",
      Handler: _P2PService_BroadcastMsg_Handler,
      },
      {
      MethodName: "BroadcastTxsMsg",
      Handler: _P2PService_BroadcastTxsMsg_Handler,
      },
      {
      MethodName: "BatchTxsmsg",
      Handler: _P2PService_BatchTxsmsg_Handler,
      },
      {
      MethodName: "SendMsg",
      Handler: _P2PService_SendMsg_Handler,
      },
      {
      MethodName: "NetPeerCount",
      Handler: _P2PService_NetPeerCount_Handler,
      },
      {
      MethodName: "NetVersion",
      Handler: _P2PService_NetVersion_Handler,
      },
      {
      MethodName: "Publish",
      Handler: _P2PService_Publish_Handler,
      },
      },
      Streams: []grpc.StreamDesc{
      {
      StreamName: "SubscribeNewBatchTx",
      Handler: _P2PService_SubscribeNewBatchTx_Handler,
      ServerStreams: true,
      },
      {
      StreamName: "SubscribeMsg",
      Handler: _P2PService_SubscribeMsg_Handler,
      ServerStreams: true,
      },
      {
      StreamName: "Subscribe",
      Handler: _P2PService_Subscribe_Handler,
      ServerStreams: true,
      },
      },
      Metadata: "p2p/v1/service.proto",
      }
      MetaProtocol-main/gen/proto/go/ring/v1/account_req_res.pb.go 0 → 100644
      View file @ 9234b25c
      This source diff could not be displayed because it is too large. You can view the blob instead.
      MetaProtocol-main/gen/proto/go/ring/v1/request_response.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: ring/v1/request_response.proto
      package ringv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("ring/v1/request_response.proto", fileDescriptor_a0728241cb087019) }
      var fileDescriptor_a0728241cb087019 = []byte{
      // 190 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2b, 0xca, 0xcc, 0x4b,
      0xd7, 0x2f, 0x33, 0xd4, 0x2f, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x89, 0x2f, 0x4a, 0x2d, 0x2e,
      0xc8, 0xcf, 0x2b, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x07, 0xc9, 0xeb, 0x95,
      0x19, 0x3a, 0xad, 0x67, 0xe4, 0xe2, 0x4e, 0xce, 0xcf, 0xd5, 0x83, 0xf1, 0x45, 0x82, 0x20, 0x1a,
      0x82, 0xa0, 0xea, 0x03, 0x40, 0xca, 0x03, 0x18, 0xa3, 0x7c, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93,
      0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x9d, 0x13, 0x53, 0x4a, 0x93, 0x53, 0x4b, 0x8b, 0x7d, 0x53, 0x4b,
      0x12, 0xcb, 0x52, 0x8b, 0xa0, 0x8a, 0x92, 0xf3, 0x73, 0xf4, 0x41, 0x22, 0x70, 0x4e, 0x7a, 0x6a,
      0x9e, 0x3e, 0xd8, 0x36, 0xfd, 0xf4, 0x7c, 0x7d, 0xa8, 0x7b, 0xac, 0x41, 0x74, 0x99, 0xe1, 0x22,
      0x26, 0xe6, 0xa0, 0x88, 0x88, 0x55, 0x4c, 0xec, 0x41, 0x20, 0x6b, 0xc3, 0x0c, 0x4f, 0x41, 0x58,
      0x31, 0x61, 0x86, 0x8f, 0x98, 0x84, 0xa1, 0xac, 0x18, 0xf7, 0x00, 0x27, 0x90, 0x79, 0x29, 0x89,
      0x25, 0x89, 0xaf, 0x98, 0x38, 0x40, 0xa2, 0x56, 0x56, 0x61, 0x86, 0x49, 0x6c, 0x60, 0x33, 0x8d,
      0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x59, 0x47, 0xac, 0x53, 0xe3, 0x00, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/ring/v1/resource.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: ring/v1/resource.proto
      package ringv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("ring/v1/resource.proto", fileDescriptor_679f4f17385494fd) }
      var fileDescriptor_679f4f17385494fd = []byte{
      // 180 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2b, 0xca, 0xcc, 0x4b,
      0xd7, 0x2f, 0x33, 0xd4, 0x2f, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5, 0x2b, 0x28, 0xca,
      0x2f, 0xc9, 0x17, 0x62, 0x07, 0x89, 0xeb, 0x95, 0x19, 0x3a, 0xad, 0x60, 0xe4, 0xe2, 0x4e, 0xce,
      0xcf, 0xd5, 0x83, 0xf1, 0x79, 0x83, 0xa0, 0x0a, 0x03, 0x40, 0xea, 0x02, 0x18, 0xa3, 0x7c, 0xd3,
      0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x9d, 0x13, 0x53, 0x4a, 0x93, 0x53,
      0x4b, 0x8b, 0x7d, 0x53, 0x4b, 0x12, 0xcb, 0x52, 0x8b, 0x8a, 0x21, 0x8a, 0x92, 0xf3, 0x73, 0xf4,
      0x41, 0x22, 0x70, 0x4e, 0x7a, 0x6a, 0x9e, 0x3e, 0xd8, 0x1a, 0xfd, 0xf4, 0x7c, 0x7d, 0xa8, 0x03,
      0xac, 0x41, 0x74, 0x99, 0xe1, 0x22, 0x26, 0xe6, 0xa0, 0x88, 0x88, 0x55, 0x4c, 0xec, 0x41, 0x20,
      0xfb, 0xc2, 0x0c, 0x4f, 0x41, 0x58, 0x31, 0x61, 0x86, 0x8f, 0x98, 0x84, 0xa1, 0xac, 0x18, 0xf7,
      0x00, 0x27, 0x90, 0x79, 0x29, 0x89, 0x25, 0x89, 0xaf, 0x98, 0x38, 0x40, 0xa2, 0x56, 0x56, 0x61,
      0x86, 0x49, 0x6c, 0x60, 0x33, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x52, 0x00, 0x7b, 0xfe,
      0xd4, 0x00, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/ring/v1/service.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: ring/v1/service.proto
      package ringv1
      import (
      fmt "fmt"
      v1 "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base/v1"
      proto "github.com/gogo/protobuf/proto"
      _ "google.golang.org/protobuf/types/known/emptypb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type BroadcastEthTxWithFromRequest struct {
      EthTx *v1.EthTransaction `protobuf:"bytes,1,opt,name=ethTx,proto3" json:"ethTx,omitempty"`
      From string `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BroadcastEthTxWithFromRequest) Reset() { *m = BroadcastEthTxWithFromRequest{} }
      func (m *BroadcastEthTxWithFromRequest) String() string { return proto.CompactTextString(m) }
      func (*BroadcastEthTxWithFromRequest) ProtoMessage() {}
      func (*BroadcastEthTxWithFromRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_2dc67120507b0009, []int{0}
      }
      func (m *BroadcastEthTxWithFromRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BroadcastEthTxWithFromRequest.Unmarshal(m, b)
      }
      func (m *BroadcastEthTxWithFromRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BroadcastEthTxWithFromRequest.Marshal(b, m, deterministic)
      }
      func (m *BroadcastEthTxWithFromRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BroadcastEthTxWithFromRequest.Merge(m, src)
      }
      func (m *BroadcastEthTxWithFromRequest) XXX_Size() int {
      return xxx_messageInfo_BroadcastEthTxWithFromRequest.Size(m)
      }
      func (m *BroadcastEthTxWithFromRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_BroadcastEthTxWithFromRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_BroadcastEthTxWithFromRequest proto.InternalMessageInfo
      func (m *BroadcastEthTxWithFromRequest) GetEthTx() *v1.EthTransaction {
      if m != nil {
      return m.EthTx
      }
      return nil
      }
      func (m *BroadcastEthTxWithFromRequest) GetFrom() string {
      if m != nil {
      return m.From
      }
      return ""
      }
      type RequestPing struct {
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *RequestPing) Reset() { *m = RequestPing{} }
      func (m *RequestPing) String() string { return proto.CompactTextString(m) }
      func (*RequestPing) ProtoMessage() {}
      func (*RequestPing) Descriptor() ([]byte, []int) {
      return fileDescriptor_2dc67120507b0009, []int{1}
      }
      func (m *RequestPing) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_RequestPing.Unmarshal(m, b)
      }
      func (m *RequestPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_RequestPing.Marshal(b, m, deterministic)
      }
      func (m *RequestPing) XXX_Merge(src proto.Message) {
      xxx_messageInfo_RequestPing.Merge(m, src)
      }
      func (m *RequestPing) XXX_Size() int {
      return xxx_messageInfo_RequestPing.Size(m)
      }
      func (m *RequestPing) XXX_DiscardUnknown() {
      xxx_messageInfo_RequestPing.DiscardUnknown(m)
      }
      var xxx_messageInfo_RequestPing proto.InternalMessageInfo
      type ResponsePing struct {
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *ResponsePing) Reset() { *m = ResponsePing{} }
      func (m *ResponsePing) String() string { return proto.CompactTextString(m) }
      func (*ResponsePing) ProtoMessage() {}
      func (*ResponsePing) Descriptor() ([]byte, []int) {
      return fileDescriptor_2dc67120507b0009, []int{2}
      }
      func (m *ResponsePing) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_ResponsePing.Unmarshal(m, b)
      }
      func (m *ResponsePing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_ResponsePing.Marshal(b, m, deterministic)
      }
      func (m *ResponsePing) XXX_Merge(src proto.Message) {
      xxx_messageInfo_ResponsePing.Merge(m, src)
      }
      func (m *ResponsePing) XXX_Size() int {
      return xxx_messageInfo_ResponsePing.Size(m)
      }
      func (m *ResponsePing) XXX_DiscardUnknown() {
      xxx_messageInfo_ResponsePing.DiscardUnknown(m)
      }
      var xxx_messageInfo_ResponsePing proto.InternalMessageInfo
      type RequestBroadcastTx struct {
      Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *RequestBroadcastTx) Reset() { *m = RequestBroadcastTx{} }
      func (m *RequestBroadcastTx) String() string { return proto.CompactTextString(m) }
      func (*RequestBroadcastTx) ProtoMessage() {}
      func (*RequestBroadcastTx) Descriptor() ([]byte, []int) {
      return fileDescriptor_2dc67120507b0009, []int{3}
      }
      func (m *RequestBroadcastTx) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_RequestBroadcastTx.Unmarshal(m, b)
      }
      func (m *RequestBroadcastTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_RequestBroadcastTx.Marshal(b, m, deterministic)
      }
      func (m *RequestBroadcastTx) XXX_Merge(src proto.Message) {
      xxx_messageInfo_RequestBroadcastTx.Merge(m, src)
      }
      func (m *RequestBroadcastTx) XXX_Size() int {
      return xxx_messageInfo_RequestBroadcastTx.Size(m)
      }
      func (m *RequestBroadcastTx) XXX_DiscardUnknown() {
      xxx_messageInfo_RequestBroadcastTx.DiscardUnknown(m)
      }
      var xxx_messageInfo_RequestBroadcastTx proto.InternalMessageInfo
      func (m *RequestBroadcastTx) GetTx() []byte {
      if m != nil {
      return m.Tx
      }
      return nil
      }
      type ResponseBroadcastTx struct {
      Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *ResponseBroadcastTx) Reset() { *m = ResponseBroadcastTx{} }
      func (m *ResponseBroadcastTx) String() string { return proto.CompactTextString(m) }
      func (*ResponseBroadcastTx) ProtoMessage() {}
      func (*ResponseBroadcastTx) Descriptor() ([]byte, []int) {
      return fileDescriptor_2dc67120507b0009, []int{4}
      }
      func (m *ResponseBroadcastTx) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_ResponseBroadcastTx.Unmarshal(m, b)
      }
      func (m *ResponseBroadcastTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_ResponseBroadcastTx.Marshal(b, m, deterministic)
      }
      func (m *ResponseBroadcastTx) XXX_Merge(src proto.Message) {
      xxx_messageInfo_ResponseBroadcastTx.Merge(m, src)
      }
      func (m *ResponseBroadcastTx) XXX_Size() int {
      return xxx_messageInfo_ResponseBroadcastTx.Size(m)
      }
      func (m *ResponseBroadcastTx) XXX_DiscardUnknown() {
      xxx_messageInfo_ResponseBroadcastTx.DiscardUnknown(m)
      }
      var xxx_messageInfo_ResponseBroadcastTx proto.InternalMessageInfo
      func (m *ResponseBroadcastTx) GetHash() []byte {
      if m != nil {
      return m.Hash
      }
      return nil
      }
      func init() {
      proto.RegisterType((*BroadcastEthTxWithFromRequest)(nil), "ring.v1.broadcastEthTxWithFromRequest")
      proto.RegisterType((*RequestPing)(nil), "ring.v1.RequestPing")
      proto.RegisterType((*ResponsePing)(nil), "ring.v1.ResponsePing")
      proto.RegisterType((*RequestBroadcastTx)(nil), "ring.v1.RequestBroadcastTx")
      proto.RegisterType((*ResponseBroadcastTx)(nil), "ring.v1.ResponseBroadcastTx")
      }
      func init() { proto.RegisterFile("ring/v1/service.proto", fileDescriptor_2dc67120507b0009) }
      var fileDescriptor_2dc67120507b0009 = []byte{
      // 1270 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x58, 0xdd, 0x6e, 0x1b, 0x45,
      0x14, 0xc6, 0x26, 0x6d, 0xda, 0x71, 0x9a, 0xc2, 0xb6, 0x49, 0x8d, 0x83, 0x93, 0x60, 0x10, 0x4a,
      0x29, 0x5d, 0xe3, 0x46, 0x48, 0xa8, 0x15, 0x3f, 0xb5, 0x49, 0x53, 0xc0, 0xb1, 0x2c, 0xbb, 0x0d,
      0x05, 0x45, 0x8a, 0xc6, 0xeb, 0xe9, 0x7a, 0xc5, 0x7a, 0xc6, 0xd9, 0x1d, 0x3b, 0x09, 0x57, 0x48,
      0x5c, 0xf1, 0x02, 0x3c, 0x00, 0x37, 0x48, 0x3c, 0x0a, 0x8f, 0xc1, 0x25, 0x4f, 0x81, 0x66, 0x77,
      0x66, 0x7c, 0x76, 0x67, 0xd7, 0x31, 0x57, 0xd9, 0xfd, 0xbe, 0xef, 0x7c, 0x67, 0x66, 0x7c, 0x66,
      0xce, 0x6c, 0xd0, 0x46, 0xe0, 0x51, 0xb7, 0x3e, 0x6b, 0xd4, 0x43, 0x12, 0xcc, 0x3c, 0x87, 0xd8,
      0x93, 0x80, 0x71, 0x66, 0xad, 0x0a, 0xd8, 0x9e, 0x35, 0x2a, 0x5b, 0x2e, 0x63, 0xae, 0x4f, 0xea,
      0x11, 0x3c, 0x98, 0xbe, 0xae, 0x93, 0xf1, 0x84, 0x5f, 0xc6, 0xaa, 0xca, 0xb6, 0x0a, 0x0e, 0xc8,
      0xd9, 0x94, 0x84, 0xfc, 0x34, 0x20, 0xe1, 0x84, 0xd1, 0x50, 0xba, 0x54, 0xaa, 0x8a, 0xc7, 0x8e,
      0xc3, 0xa6, 0x54, 0xf0, 0x67, 0x42, 0x23, 0xe9, 0xcd, 0x01, 0x0e, 0x49, 0x1c, 0x1e, 0xb2, 0x69,
      0xa0, 0x92, 0x57, 0xee, 0x2a, 0x9c, 0xf0, 0xd1, 0x29, 0xbf, 0x88, 0xd1, 0xda, 0x00, 0x55, 0x07,
      0x01, 0xc3, 0x43, 0x07, 0x87, 0xfc, 0x80, 0x8f, 0x5e, 0x5c, 0x7c, 0xef, 0xf1, 0xd1, 0xb3, 0x80,
      0x8d, 0x7b, 0x71, 0x72, 0xeb, 0x21, 0xba, 0x46, 0x04, 0x5e, 0x2e, 0xec, 0x16, 0xf6, 0x4a, 0x8f,
      0xee, 0xd9, 0xc2, 0xc6, 0x9e, 0x35, 0x6c, 0xa1, 0x0e, 0x30, 0x0d, 0xb1, 0xc3, 0x3d, 0x46, 0x7b,
      0xb1, 0xca, 0xb2, 0xd0, 0xca, 0xeb, 0x80, 0x8d, 0xcb, 0xc5, 0xdd, 0xc2, 0xde, 0xcd, 0x5e, 0xf4,
      0x5c, 0xbb, 0x85, 0x4a, 0xd2, 0xad, 0xeb, 0x51, 0xb7, 0xb6, 0x8e, 0xd6, 0x7a, 0x72, 0x46, 0xd1,
      0xfb, 0x07, 0xc8, 0x92, 0x74, 0x53, 0x8d, 0xe4, 0xc5, 0x85, 0xb5, 0x8e, 0x8a, 0x3c, 0x4e, 0xba,
      0xd6, 0x2b, 0xf2, 0x8b, 0xda, 0x7d, 0x74, 0x47, 0x45, 0x41, 0x99, 0x85, 0x56, 0x46, 0x38, 0x1c,
      0x49, 0x61, 0xf4, 0xfc, 0xe8, 0xf7, 0x1d, 0x54, 0xea, 0x79, 0xd4, 0xed, 0xc7, 0x8b, 0x6f, 0xed,
      0xa3, 0x15, 0x91, 0xc8, 0xba, 0x6b, 0xcb, 0xf5, 0xb7, 0xc1, 0x70, 0x2a, 0x1b, 0x00, 0x9d, 0x8f,
      0xca, 0xea, 0xa3, 0x12, 0xcc, 0xf3, 0xa1, 0x56, 0x2d, 0x5c, 0xae, 0xca, 0xbb, 0x86, 0x1b, 0x74,
      0xf9, 0x14, 0xad, 0xf4, 0x47, 0x78, 0x1f, 0x8c, 0x44, 0xbc, 0xaa, 0xd8, 0x8d, 0x14, 0x1a, 0xc7,
      0xd7, 0xde, 0xb0, 0x0e, 0x50, 0xa9, 0xc3, 0x86, 0xe4, 0x98, 0x04, 0xa1, 0xc7, 0xa8, 0xb5, 0x69,
      0xc7, 0xe5, 0x63, 0xab, 0xf2, 0xb1, 0x0f, 0x44, 0xf9, 0x80, 0xdc, 0x40, 0x0d, 0x6c, 0x5a, 0x08,
      0x75, 0x08, 0xbf, 0xca, 0x65, 0x6b, 0xee, 0xa2, 0xc5, 0xc0, 0xe4, 0x10, 0xad, 0x75, 0x08, 0xef,
      0x12, 0x12, 0xb4, 0x44, 0xf1, 0xe5, 0xda, 0x54, 0xa1, 0x8d, 0x96, 0x03, 0xa3, 0x23, 0x74, 0xbb,
      0x2b, 0x42, 0x1c, 0xe6, 0x5f, 0x35, 0xa4, 0x5d, 0xed, 0x95, 0x8a, 0x00, 0x76, 0x9f, 0xa3, 0xd5,
      0xfe, 0x25, 0x75, 0xc4, 0x4f, 0x97, 0x67, 0x53, 0x9e, 0xaf, 0x6f, 0xac, 0x04, 0xe1, 0x5f, 0xa2,
      0x1b, 0x2d, 0xe6, 0x51, 0x51, 0xdc, 0xb9, 0xf1, 0xef, 0xe8, 0x78, 0x25, 0x05, 0x06, 0x4f, 0xd0,
      0xf5, 0x23, 0x8f, 0x2e, 0x4a, 0x7f, 0x4f, 0x87, 0xc7, 0xc2, 0x64, 0xf6, 0xe7, 0x38, 0x1c, 0xf5,
      0x30, 0x5f, 0x26, 0xbb, 0x92, 0x26, 0x0d, 0x9e, 0xc6, 0xa7, 0x41, 0xb8, 0x84, 0x81, 0x92, 0x26,
      0x0d, 0x0e, 0x71, 0xd8, 0x0d, 0xc4, 0x7e, 0xb9, 0xda, 0x40, 0x49, 0x81, 0xc1, 0x57, 0xa8, 0xd4,
      0xf4, 0x99, 0xf3, 0x53, 0x67, 0x3a, 0x1e, 0x90, 0x60, 0x89, 0x45, 0x78, 0x4e, 0x3c, 0x77, 0x04,
      0x0b, 0xe2, 0x5b, 0xe9, 0xd0, 0xbc, 0x14, 0x13, 0xb4, 0xe6, 0x75, 0x08, 0x50, 0x73, 0x9b, 0x25,
      0x48, 0xed, 0xd5, 0x45, 0xb7, 0x24, 0x21, 0xc7, 0x53, 0x4d, 0x07, 0xc4, 0xb8, 0xf2, 0xdb, 0xce,
      0xa3, 0xb5, 0xe3, 0xcf, 0x68, 0x2b, 0xa2, 0xc0, 0x99, 0x17, 0x55, 0xb4, 0x1c, 0xed, 0x83, 0xa4,
      0x41, 0xb6, 0x4a, 0x65, 0xfb, 0x78, 0x39, 0xb1, 0xce, 0xfd, 0x4b, 0x01, 0x55, 0x73, 0x94, 0x72,
      0x7a, 0x0f, 0xaf, 0x72, 0x4c, 0x4e, 0xd7, 0x5e, 0x56, 0xae, 0x87, 0xf0, 0x03, 0x7a, 0xeb, 0x25,
      0x75, 0x7c, 0x02, 0xe7, 0x3c, 0xdf, 0x96, 0x69, 0x4a, 0xe5, 0x79, 0x6f, 0x81, 0x42, 0x5b, 0x9f,
      0x22, 0x0b, 0xb2, 0x72, 0x46, 0xb5, 0xcc, 0xd0, 0xe4, 0x34, 0xde, 0x5f, 0xa8, 0xd1, 0x09, 0xce,
      0x50, 0x39, 0xe2, 0x9b, 0x97, 0xd1, 0x6c, 0x45, 0xfa, 0xa7, 0x74, 0xf8, 0x0d, 0x1d, 0x92, 0x0b,
      0x6b, 0x2f, 0x69, 0x91, 0x21, 0x51, 0xc9, 0xee, 0x2f, 0xa1, 0xd4, 0x29, 0xcf, 0x51, 0x05, 0xaa,
      0xe2, 0x21, 0xe9, 0xa4, 0x1f, 0x65, 0x5a, 0x25, 0x45, 0x2a, 0xed, 0x83, 0xa5, 0xb4, 0x3a, 0xf1,
      0xd7, 0xe8, 0x66, 0x8b, 0x8d, 0x27, 0x9e, 0x4f, 0x82, 0xd0, 0x82, 0x07, 0x96, 0xc4, 0x94, 0x6d,
      0x25, 0x8b, 0xd2, 0x2e, 0xc7, 0xe8, 0xb6, 0x84, 0xfb, 0xcc, 0xf7, 0x86, 0x1e, 0xbf, 0xb4, 0x76,
      0xd2, 0x01, 0x8a, 0x51, 0x8e, 0xbb, 0xf9, 0x02, 0xd0, 0x3c, 0x90, 0x24, 0xdb, 0xed, 0xb6, 0x65,
      0x8c, 0xa1, 0xdd, 0x6e, 0x2b, 0xb7, 0xad, 0x4c, 0x4e, 0x1b, 0xf5, 0xd1, 0xba, 0xca, 0x42, 0x82,
      0x09, 0xa1, 0xdc, 0xda, 0x36, 0xd2, 0xc7, 0x84, 0x32, 0xdc, 0xc9, 0xe5, 0xe1, 0x01, 0x74, 0x10,
      0x72, 0x6f, 0x8c, 0x39, 0x39, 0xc4, 0x21, 0x38, 0x80, 0x00, 0x6a, 0x1e, 0x40, 0x09, 0x52, 0x7b,
      0x9d, 0xa0, 0xb7, 0xc1, 0xae, 0x92, 0x1b, 0x66, 0xbe, 0x1d, 0x0c, 0x4e, 0xf9, 0xd6, 0x16, 0x49,
      0xb4, 0xfb, 0xaf, 0x05, 0xb4, 0x9d, 0xe0, 0xcd, 0xc2, 0xb6, 0xb3, 0x8d, 0x72, 0xcb, 0xbb, 0xbe,
      0xb4, 0x5e, 0x8f, 0xe2, 0xb7, 0x02, 0xda, 0x35, 0xc5, 0xa9, 0x5a, 0xff, 0x64, 0x81, 0x6f, 0x76,
      0xc5, 0x37, 0xfe, 0x47, 0x04, 0x3c, 0x44, 0xe0, 0x6d, 0x94, 0x38, 0xc4, 0x9b, 0x70, 0x2b, 0x73,
      0x35, 0x25, 0x69, 0x1e, 0x22, 0x59, 0x1a, 0x9d, 0xe0, 0x0b, 0xb4, 0xda, 0xc4, 0x3e, 0xa6, 0x0e,
      0xb1, 0xe6, 0x3d, 0x4c, 0x22, 0xca, 0xaa, 0x6c, 0x12, 0x30, 0xbe, 0xcf, 0x59, 0x80, 0x5d, 0x18,
      0x2f, 0x11, 0x33, 0x5e, 0x13, 0x3a, 0xfe, 0x33, 0x74, 0xad, 0xc3, 0x44, 0xf6, 0x0d, 0x70, 0xcb,
      0x03, 0xb9, 0x37, 0xd3, 0x30, 0xec, 0x85, 0x3d, 0x32, 0x21, 0x98, 0x93, 0x61, 0xec, 0x50, 0x05,
      0x77, 0x54, 0x80, 0x9b, 0xbd, 0x30, 0x45, 0xc3, 0x66, 0x90, 0x6e, 0x19, 0xa0, 0x19, 0xa4, 0x29,
      0xb3, 0x19, 0x98, 0x0a, 0xb8, 0x4c, 0x87, 0x84, 0xb7, 0xd8, 0x10, 0x2e, 0x93, 0x44, 0xcc, 0x65,
      0xd2, 0x84, 0x8e, 0x17, 0x37, 0x6c, 0xcf, 0xa5, 0xf0, 0x86, 0xed, 0xb9, 0x34, 0xe3, 0x86, 0x1d,
      0xa1, 0xf0, 0xc0, 0x13, 0x08, 0x18, 0x18, 0x38, 0xf0, 0x52, 0x8c, 0x79, 0xe0, 0x19, 0x82, 0x84,
      0x2f, 0xa1, 0xc3, 0x1c, 0xdf, 0x24, 0x93, 0xe1, 0x9b, 0x16, 0xc0, 0x72, 0x17, 0x64, 0x0f, 0x9f,
      0x43, 0xeb, 0x5a, 0x22, 0x32, 0x49, 0x9a, 0xe5, 0x9e, 0xa5, 0x81, 0xeb, 0xd8, 0xc2, 0xbe, 0x0f,
      0xd6, 0x51, 0xbc, 0x9a, 0xeb, 0x18, 0xa3, 0xb0, 0xfd, 0x74, 0xc8, 0xf9, 0x33, 0xcf, 0xe7, 0x24,
      0x00, 0xed, 0x47, 0x63, 0x66, 0xfb, 0x01, 0x94, 0x76, 0xf9, 0x0e, 0xad, 0x77, 0xc8, 0x79, 0xb4,
      0xe1, 0xa5, 0x55, 0xde, 0x75, 0x72, 0x07, 0xfa, 0x80, 0x80, 0xc4, 0x52, 0x95, 0xbb, 0x84, 0x0e,
      0x3d, 0xea, 0x82, 0x99, 0x5e, 0x61, 0x3b, 0xef, 0xf5, 0x79, 0xa1, 0xc9, 0xdf, 0xf8, 0x25, 0xf5,
      0x68, 0xc8, 0xb1, 0xef, 0x4b, 0xdf, 0x1d, 0xd0, 0xb4, 0x13, 0x8c, 0xf9, 0x1b, 0x1b, 0x02, 0xb8,
      0x6f, 0x63, 0xac, 0x35, 0xc2, 0xd4, 0x25, 0x21, 0xd8, 0xb7, 0x09, 0xdc, 0xdc, 0xb7, 0x29, 0x1a,
      0xb6, 0xdf, 0x98, 0x6a, 0x33, 0x37, 0x04, 0xed, 0x77, 0x0e, 0x9a, 0xed, 0x17, 0x72, 0xb0, 0x3a,
      0x22, 0x8b, 0x79, 0x75, 0xc0, 0xe0, 0x8d, 0x14, 0xaa, 0xc2, 0x9a, 0x7f, 0x16, 0x50, 0xc9, 0x61,
      0x63, 0x45, 0x37, 0xd7, 0xe4, 0x17, 0x7a, 0xf4, 0x55, 0xd7, 0x2d, 0xfc, 0x78, 0xe4, 0x7a, 0x7c,
      0x34, 0x1d, 0xd8, 0x0e, 0x1b, 0xd7, 0x5b, 0x78, 0x38, 0x75, 0xc8, 0x34, 0x3c, 0x22, 0x1c, 0xcf,
      0x48, 0x10, 0x12, 0xf5, 0xe9, 0x57, 0x17, 0x88, 0x7e, 0x71, 0x09, 0x8d, 0xff, 0x8b, 0x52, 0x77,
      0x59, 0x5d, 0xfe, 0x63, 0xe4, 0x89, 0xf8, 0x3b, 0x6b, 0xfc, 0x51, 0x7c, 0xb3, 0xf7, 0xea, 0xd5,
      0x5f, 0xc5, 0xd5, 0x9e, 0x48, 0x77, 0xdc, 0xf8, 0x3b, 0x7e, 0x3a, 0x39, 0x6e, 0xfc, 0x53, 0xbc,
      0x23, 0x9f, 0x4e, 0x0e, 0xbb, 0x4d, 0xe1, 0x37, 0xc4, 0x1c, 0xff, 0x5b, 0xbc, 0x21, 0xd0, 0xc7,
      0x8f, 0x8f, 0x1b, 0x83, 0xeb, 0x91, 0xe7, 0xfe, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x3f, 0x4d,
      0xc5, 0xfa, 0xc9, 0x11, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/ring/v1/service_grpc.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
      // versions:
      // - protoc-gen-go-grpc v1.2.0
      // - protoc (unknown)
      // source: ring/v1/service.proto
      package ringv1
      import (
      context "context"
      grpc "google.golang.org/grpc"
      codes "google.golang.org/grpc/codes"
      status "google.golang.org/grpc/status"
      emptypb "google.golang.org/protobuf/types/known/emptypb"
      )
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the grpc package it is being compiled against.
      // Requires gRPC-Go v1.32.0 or later.
      const _ = grpc.SupportPackageIsVersion7
      // RingServiceClient is the client API for RingService service.
      //
      // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
      type RingServiceClient interface {
      Ping(ctx context.Context, in *RequestPing, opts ...grpc.CallOption) (*ResponsePing, error)
      //rpc BroadcastTx(RequestBroadcastTx) returns (ResponseBroadcastTx);
      BroadcastTx(ctx context.Context, in *BroadcastEthTxWithFromRequest, opts ...grpc.CallOption) (*ResponseBroadcastTx, error)
      // web3
      Sha3(ctx context.Context, in *Sha3Request, opts ...grpc.CallOption) (*Sha3Response, error)
      NodeVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NodeVersionResponse, error)
      // network info service
      NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error)
      NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error)
      // node status
      ProtocolVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ProtocolVersionResponse, error)
      Syncing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SyncingResponse, error)
      Coinbase(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CoinbaseResponse, error)
      Mining(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*MiningResponse, error)
      HashRate(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HashRateResponse, error)
      Accounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AccountsResponse, error)
      // tx operatoration
      GasPrice(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GasPriceResponse, error)
      // block info service
      BlockNumber(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HeightResponse, error)
      BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (*BlockByHashResponse, error)
      BlockByNumber(ctx context.Context, in *BlockByNumberRequest, opts ...grpc.CallOption) (*BlockByNumberResponse, error)
      BlockTransactionCountByHash(ctx context.Context, in *BlockTransactionCountByHashRequest, opts ...grpc.CallOption) (*BlockTransactionCountByHashResponse, error)
      BlockTransactionCountByNumber(ctx context.Context, in *BlockTransactionCountByNumberRequest, opts ...grpc.CallOption) (*BlockTransactionCountByNumberResponse, error)
      UncleCountByHash(ctx context.Context, in *UncleCountByHashRequest, opts ...grpc.CallOption) (*UncleCountByHashResponse, error)
      UncleCountByNumber(ctx context.Context, in *UncleCountByNumberRequest, opts ...grpc.CallOption) (*UncleCountByNumberResponse, error)
      UncleByBlockHashAndIndex(ctx context.Context, in *UncleByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockHashAndIndexResponse, error)
      UncleByBlockNumberAndIndex(ctx context.Context, in *UncleByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockNumberAndIndexResponse, error)
      // compiler
      Compilers(ctx context.Context, in *CompilersRequest, opts ...grpc.CallOption) (*CompilersResponse, error)
      CompileSolidity(ctx context.Context, in *CompileSolidityRequest, opts ...grpc.CallOption) (*CompileSolidityResponse, error)
      CompileLLL(ctx context.Context, in *CompileLLLRequest, opts ...grpc.CallOption) (*CompileLLLResponse, error)
      CompileSerpent(ctx context.Context, in *CompileSerpentRequest, opts ...grpc.CallOption) (*CompileSerpentResponse, error)
      // transaction info service
      EstimateGas(ctx context.Context, in *EstimateGasRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error)
      TransactionByHash(ctx context.Context, in *TransactionByHashRequest, opts ...grpc.CallOption) (*TransactionByHashResponse, error)
      TransactionByBlockHashAndIndex(ctx context.Context, in *TransactionByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockHashAndIndexResponse, error)
      TransactionByBlockNumberAndIndex(ctx context.Context, in *TransactionByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockNumberAndIndexResponse, error)
      TransactionReceipt(ctx context.Context, in *TransactionReceiptRequest, opts ...grpc.CallOption) (*TransactionReceiptResponse, error)
      // account info service
      Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error)
      Storage(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error)
      Nonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResponse, error)
      RepeatedNonce(ctx context.Context, in *RepeatedNonceRequest, opts ...grpc.CallOption) (*RepeatedNonceResponse, error)
      TransactionCount(ctx context.Context, in *TransactionCountRequest, opts ...grpc.CallOption) (*TransactionCountResponse, error)
      GetCode(ctx context.Context, in *GetCodeRequest, opts ...grpc.CallOption) (*GetCodeResponse, error)
      Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
      SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error)
      SendTransaction(ctx context.Context, in *SendTransactionRequest, opts ...grpc.CallOption) (*SendTransactionResponse, error)
      SendRawTransaction(ctx context.Context, in *SendRawTransactionRequest, opts ...grpc.CallOption) (*SendRawTransactionResponse, error)
      Call(ctx context.Context, in *CallRequest, opts ...grpc.CallOption) (*CallResponse, error)
      // filter
      NewFilter(ctx context.Context, in *NewFilterRequest, opts ...grpc.CallOption) (*NewFilterResponse, error)
      NewBlockFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NewBlockFilterResponse, error)
      PendingTransactionFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PendingTransactionFilterResponse, error)
      UninstallFilter(ctx context.Context, in *UninstallFilterRequest, opts ...grpc.CallOption) (*UninstallFilterResponse, error)
      FilterChanges(ctx context.Context, in *FilterChangesRequest, opts ...grpc.CallOption) (*FilterChangesResponse, error)
      FilterLogs(ctx context.Context, in *FilterLogsRequest, opts ...grpc.CallOption) (*FilterLogsResponse, error)
      Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (*LogsResponse, error)
      }
      type ringServiceClient struct {
      cc grpc.ClientConnInterface
      }
      func NewRingServiceClient(cc grpc.ClientConnInterface) RingServiceClient {
      return &ringServiceClient{cc}
      }
      func (c *ringServiceClient) Ping(ctx context.Context, in *RequestPing, opts ...grpc.CallOption) (*ResponsePing, error) {
      out := new(ResponsePing)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Ping", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) BroadcastTx(ctx context.Context, in *BroadcastEthTxWithFromRequest, opts ...grpc.CallOption) (*ResponseBroadcastTx, error) {
      out := new(ResponseBroadcastTx)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/BroadcastTx", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Sha3(ctx context.Context, in *Sha3Request, opts ...grpc.CallOption) (*Sha3Response, error) {
      out := new(Sha3Response)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Sha3", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) NodeVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NodeVersionResponse, error) {
      out := new(NodeVersionResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/NodeVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error) {
      out := new(NetVersionResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/NetVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error) {
      out := new(NetPeerCountResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/NetPeerCount", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) ProtocolVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ProtocolVersionResponse, error) {
      out := new(ProtocolVersionResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/ProtocolVersion", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Syncing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SyncingResponse, error) {
      out := new(SyncingResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Syncing", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Coinbase(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CoinbaseResponse, error) {
      out := new(CoinbaseResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Coinbase", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Mining(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*MiningResponse, error) {
      out := new(MiningResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Mining", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) HashRate(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HashRateResponse, error) {
      out := new(HashRateResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/HashRate", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Accounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AccountsResponse, error) {
      out := new(AccountsResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Accounts", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) GasPrice(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GasPriceResponse, error) {
      out := new(GasPriceResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/GasPrice", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) BlockNumber(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HeightResponse, error) {
      out := new(HeightResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/BlockNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (*BlockByHashResponse, error) {
      out := new(BlockByHashResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/BlockByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) BlockByNumber(ctx context.Context, in *BlockByNumberRequest, opts ...grpc.CallOption) (*BlockByNumberResponse, error) {
      out := new(BlockByNumberResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/BlockByNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) BlockTransactionCountByHash(ctx context.Context, in *BlockTransactionCountByHashRequest, opts ...grpc.CallOption) (*BlockTransactionCountByHashResponse, error) {
      out := new(BlockTransactionCountByHashResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/BlockTransactionCountByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) BlockTransactionCountByNumber(ctx context.Context, in *BlockTransactionCountByNumberRequest, opts ...grpc.CallOption) (*BlockTransactionCountByNumberResponse, error) {
      out := new(BlockTransactionCountByNumberResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/BlockTransactionCountByNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) UncleCountByHash(ctx context.Context, in *UncleCountByHashRequest, opts ...grpc.CallOption) (*UncleCountByHashResponse, error) {
      out := new(UncleCountByHashResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/UncleCountByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) UncleCountByNumber(ctx context.Context, in *UncleCountByNumberRequest, opts ...grpc.CallOption) (*UncleCountByNumberResponse, error) {
      out := new(UncleCountByNumberResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/UncleCountByNumber", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) UncleByBlockHashAndIndex(ctx context.Context, in *UncleByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockHashAndIndexResponse, error) {
      out := new(UncleByBlockHashAndIndexResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/UncleByBlockHashAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) UncleByBlockNumberAndIndex(ctx context.Context, in *UncleByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockNumberAndIndexResponse, error) {
      out := new(UncleByBlockNumberAndIndexResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/UncleByBlockNumberAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Compilers(ctx context.Context, in *CompilersRequest, opts ...grpc.CallOption) (*CompilersResponse, error) {
      out := new(CompilersResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Compilers", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) CompileSolidity(ctx context.Context, in *CompileSolidityRequest, opts ...grpc.CallOption) (*CompileSolidityResponse, error) {
      out := new(CompileSolidityResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/CompileSolidity", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) CompileLLL(ctx context.Context, in *CompileLLLRequest, opts ...grpc.CallOption) (*CompileLLLResponse, error) {
      out := new(CompileLLLResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/CompileLLL", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) CompileSerpent(ctx context.Context, in *CompileSerpentRequest, opts ...grpc.CallOption) (*CompileSerpentResponse, error) {
      out := new(CompileSerpentResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/CompileSerpent", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) EstimateGas(ctx context.Context, in *EstimateGasRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error) {
      out := new(EstimateGasResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/EstimateGas", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) TransactionByHash(ctx context.Context, in *TransactionByHashRequest, opts ...grpc.CallOption) (*TransactionByHashResponse, error) {
      out := new(TransactionByHashResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/TransactionByHash", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) TransactionByBlockHashAndIndex(ctx context.Context, in *TransactionByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockHashAndIndexResponse, error) {
      out := new(TransactionByBlockHashAndIndexResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/TransactionByBlockHashAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) TransactionByBlockNumberAndIndex(ctx context.Context, in *TransactionByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockNumberAndIndexResponse, error) {
      out := new(TransactionByBlockNumberAndIndexResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/TransactionByBlockNumberAndIndex", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) TransactionReceipt(ctx context.Context, in *TransactionReceiptRequest, opts ...grpc.CallOption) (*TransactionReceiptResponse, error) {
      out := new(TransactionReceiptResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/TransactionReceipt", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error) {
      out := new(BalanceResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Balance", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Storage(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error) {
      out := new(StorageResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Storage", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Nonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResponse, error) {
      out := new(NonceResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Nonce", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) RepeatedNonce(ctx context.Context, in *RepeatedNonceRequest, opts ...grpc.CallOption) (*RepeatedNonceResponse, error) {
      out := new(RepeatedNonceResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/RepeatedNonce", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) TransactionCount(ctx context.Context, in *TransactionCountRequest, opts ...grpc.CallOption) (*TransactionCountResponse, error) {
      out := new(TransactionCountResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/TransactionCount", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) GetCode(ctx context.Context, in *GetCodeRequest, opts ...grpc.CallOption) (*GetCodeResponse, error) {
      out := new(GetCodeResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/GetCode", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
      out := new(SignResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Sign", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error) {
      out := new(SignTransactionResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/SignTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) SendTransaction(ctx context.Context, in *SendTransactionRequest, opts ...grpc.CallOption) (*SendTransactionResponse, error) {
      out := new(SendTransactionResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/SendTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) SendRawTransaction(ctx context.Context, in *SendRawTransactionRequest, opts ...grpc.CallOption) (*SendRawTransactionResponse, error) {
      out := new(SendRawTransactionResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/SendRawTransaction", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Call(ctx context.Context, in *CallRequest, opts ...grpc.CallOption) (*CallResponse, error) {
      out := new(CallResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Call", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) NewFilter(ctx context.Context, in *NewFilterRequest, opts ...grpc.CallOption) (*NewFilterResponse, error) {
      out := new(NewFilterResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/NewFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) NewBlockFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NewBlockFilterResponse, error) {
      out := new(NewBlockFilterResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/NewBlockFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) PendingTransactionFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PendingTransactionFilterResponse, error) {
      out := new(PendingTransactionFilterResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/PendingTransactionFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) UninstallFilter(ctx context.Context, in *UninstallFilterRequest, opts ...grpc.CallOption) (*UninstallFilterResponse, error) {
      out := new(UninstallFilterResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/UninstallFilter", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) FilterChanges(ctx context.Context, in *FilterChangesRequest, opts ...grpc.CallOption) (*FilterChangesResponse, error) {
      out := new(FilterChangesResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/FilterChanges", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) FilterLogs(ctx context.Context, in *FilterLogsRequest, opts ...grpc.CallOption) (*FilterLogsResponse, error) {
      out := new(FilterLogsResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/FilterLogs", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *ringServiceClient) Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (*LogsResponse, error) {
      out := new(LogsResponse)
      err := c.cc.Invoke(ctx, "/ring.v1.RingService/Logs", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      // RingServiceServer is the server API for RingService service.
      // All implementations must embed UnimplementedRingServiceServer
      // for forward compatibility
      type RingServiceServer interface {
      Ping(context.Context, *RequestPing) (*ResponsePing, error)
      //rpc BroadcastTx(RequestBroadcastTx) returns (ResponseBroadcastTx);
      BroadcastTx(context.Context, *BroadcastEthTxWithFromRequest) (*ResponseBroadcastTx, error)
      // web3
      Sha3(context.Context, *Sha3Request) (*Sha3Response, error)
      NodeVersion(context.Context, *emptypb.Empty) (*NodeVersionResponse, error)
      // network info service
      NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error)
      NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error)
      // node status
      ProtocolVersion(context.Context, *emptypb.Empty) (*ProtocolVersionResponse, error)
      Syncing(context.Context, *emptypb.Empty) (*SyncingResponse, error)
      Coinbase(context.Context, *emptypb.Empty) (*CoinbaseResponse, error)
      Mining(context.Context, *emptypb.Empty) (*MiningResponse, error)
      HashRate(context.Context, *emptypb.Empty) (*HashRateResponse, error)
      Accounts(context.Context, *emptypb.Empty) (*AccountsResponse, error)
      // tx operatoration
      GasPrice(context.Context, *emptypb.Empty) (*GasPriceResponse, error)
      // block info service
      BlockNumber(context.Context, *emptypb.Empty) (*HeightResponse, error)
      BlockByHash(context.Context, *BlockByHashRequest) (*BlockByHashResponse, error)
      BlockByNumber(context.Context, *BlockByNumberRequest) (*BlockByNumberResponse, error)
      BlockTransactionCountByHash(context.Context, *BlockTransactionCountByHashRequest) (*BlockTransactionCountByHashResponse, error)
      BlockTransactionCountByNumber(context.Context, *BlockTransactionCountByNumberRequest) (*BlockTransactionCountByNumberResponse, error)
      UncleCountByHash(context.Context, *UncleCountByHashRequest) (*UncleCountByHashResponse, error)
      UncleCountByNumber(context.Context, *UncleCountByNumberRequest) (*UncleCountByNumberResponse, error)
      UncleByBlockHashAndIndex(context.Context, *UncleByBlockHashAndIndexRequest) (*UncleByBlockHashAndIndexResponse, error)
      UncleByBlockNumberAndIndex(context.Context, *UncleByBlockNumberAndIndexRequest) (*UncleByBlockNumberAndIndexResponse, error)
      // compiler
      Compilers(context.Context, *CompilersRequest) (*CompilersResponse, error)
      CompileSolidity(context.Context, *CompileSolidityRequest) (*CompileSolidityResponse, error)
      CompileLLL(context.Context, *CompileLLLRequest) (*CompileLLLResponse, error)
      CompileSerpent(context.Context, *CompileSerpentRequest) (*CompileSerpentResponse, error)
      // transaction info service
      EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error)
      TransactionByHash(context.Context, *TransactionByHashRequest) (*TransactionByHashResponse, error)
      TransactionByBlockHashAndIndex(context.Context, *TransactionByBlockHashAndIndexRequest) (*TransactionByBlockHashAndIndexResponse, error)
      TransactionByBlockNumberAndIndex(context.Context, *TransactionByBlockNumberAndIndexRequest) (*TransactionByBlockNumberAndIndexResponse, error)
      TransactionReceipt(context.Context, *TransactionReceiptRequest) (*TransactionReceiptResponse, error)
      // account info service
      Balance(context.Context, *BalanceRequest) (*BalanceResponse, error)
      Storage(context.Context, *StorageRequest) (*StorageResponse, error)
      Nonce(context.Context, *NonceRequest) (*NonceResponse, error)
      RepeatedNonce(context.Context, *RepeatedNonceRequest) (*RepeatedNonceResponse, error)
      TransactionCount(context.Context, *TransactionCountRequest) (*TransactionCountResponse, error)
      GetCode(context.Context, *GetCodeRequest) (*GetCodeResponse, error)
      Sign(context.Context, *SignRequest) (*SignResponse, error)
      SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error)
      SendTransaction(context.Context, *SendTransactionRequest) (*SendTransactionResponse, error)
      SendRawTransaction(context.Context, *SendRawTransactionRequest) (*SendRawTransactionResponse, error)
      Call(context.Context, *CallRequest) (*CallResponse, error)
      // filter
      NewFilter(context.Context, *NewFilterRequest) (*NewFilterResponse, error)
      NewBlockFilter(context.Context, *emptypb.Empty) (*NewBlockFilterResponse, error)
      PendingTransactionFilter(context.Context, *emptypb.Empty) (*PendingTransactionFilterResponse, error)
      UninstallFilter(context.Context, *UninstallFilterRequest) (*UninstallFilterResponse, error)
      FilterChanges(context.Context, *FilterChangesRequest) (*FilterChangesResponse, error)
      FilterLogs(context.Context, *FilterLogsRequest) (*FilterLogsResponse, error)
      Logs(context.Context, *LogsRequest) (*LogsResponse, error)
      mustEmbedUnimplementedRingServiceServer()
      }
      // UnimplementedRingServiceServer must be embedded to have forward compatible implementations.
      type UnimplementedRingServiceServer struct {
      }
      func (UnimplementedRingServiceServer) Ping(context.Context, *RequestPing) (*ResponsePing, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
      }
      func (UnimplementedRingServiceServer) BroadcastTx(context.Context, *BroadcastEthTxWithFromRequest) (*ResponseBroadcastTx, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BroadcastTx not implemented")
      }
      func (UnimplementedRingServiceServer) Sha3(context.Context, *Sha3Request) (*Sha3Response, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Sha3 not implemented")
      }
      func (UnimplementedRingServiceServer) NodeVersion(context.Context, *emptypb.Empty) (*NodeVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NodeVersion not implemented")
      }
      func (UnimplementedRingServiceServer) NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NetVersion not implemented")
      }
      func (UnimplementedRingServiceServer) NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NetPeerCount not implemented")
      }
      func (UnimplementedRingServiceServer) ProtocolVersion(context.Context, *emptypb.Empty) (*ProtocolVersionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method ProtocolVersion not implemented")
      }
      func (UnimplementedRingServiceServer) Syncing(context.Context, *emptypb.Empty) (*SyncingResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Syncing not implemented")
      }
      func (UnimplementedRingServiceServer) Coinbase(context.Context, *emptypb.Empty) (*CoinbaseResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Coinbase not implemented")
      }
      func (UnimplementedRingServiceServer) Mining(context.Context, *emptypb.Empty) (*MiningResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Mining not implemented")
      }
      func (UnimplementedRingServiceServer) HashRate(context.Context, *emptypb.Empty) (*HashRateResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method HashRate not implemented")
      }
      func (UnimplementedRingServiceServer) Accounts(context.Context, *emptypb.Empty) (*AccountsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Accounts not implemented")
      }
      func (UnimplementedRingServiceServer) GasPrice(context.Context, *emptypb.Empty) (*GasPriceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GasPrice not implemented")
      }
      func (UnimplementedRingServiceServer) BlockNumber(context.Context, *emptypb.Empty) (*HeightResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockNumber not implemented")
      }
      func (UnimplementedRingServiceServer) BlockByHash(context.Context, *BlockByHashRequest) (*BlockByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockByHash not implemented")
      }
      func (UnimplementedRingServiceServer) BlockByNumber(context.Context, *BlockByNumberRequest) (*BlockByNumberResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockByNumber not implemented")
      }
      func (UnimplementedRingServiceServer) BlockTransactionCountByHash(context.Context, *BlockTransactionCountByHashRequest) (*BlockTransactionCountByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockTransactionCountByHash not implemented")
      }
      func (UnimplementedRingServiceServer) BlockTransactionCountByNumber(context.Context, *BlockTransactionCountByNumberRequest) (*BlockTransactionCountByNumberResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BlockTransactionCountByNumber not implemented")
      }
      func (UnimplementedRingServiceServer) UncleCountByHash(context.Context, *UncleCountByHashRequest) (*UncleCountByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleCountByHash not implemented")
      }
      func (UnimplementedRingServiceServer) UncleCountByNumber(context.Context, *UncleCountByNumberRequest) (*UncleCountByNumberResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleCountByNumber not implemented")
      }
      func (UnimplementedRingServiceServer) UncleByBlockHashAndIndex(context.Context, *UncleByBlockHashAndIndexRequest) (*UncleByBlockHashAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleByBlockHashAndIndex not implemented")
      }
      func (UnimplementedRingServiceServer) UncleByBlockNumberAndIndex(context.Context, *UncleByBlockNumberAndIndexRequest) (*UncleByBlockNumberAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UncleByBlockNumberAndIndex not implemented")
      }
      func (UnimplementedRingServiceServer) Compilers(context.Context, *CompilersRequest) (*CompilersResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Compilers not implemented")
      }
      func (UnimplementedRingServiceServer) CompileSolidity(context.Context, *CompileSolidityRequest) (*CompileSolidityResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CompileSolidity not implemented")
      }
      func (UnimplementedRingServiceServer) CompileLLL(context.Context, *CompileLLLRequest) (*CompileLLLResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CompileLLL not implemented")
      }
      func (UnimplementedRingServiceServer) CompileSerpent(context.Context, *CompileSerpentRequest) (*CompileSerpentResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CompileSerpent not implemented")
      }
      func (UnimplementedRingServiceServer) EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method EstimateGas not implemented")
      }
      func (UnimplementedRingServiceServer) TransactionByHash(context.Context, *TransactionByHashRequest) (*TransactionByHashResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionByHash not implemented")
      }
      func (UnimplementedRingServiceServer) TransactionByBlockHashAndIndex(context.Context, *TransactionByBlockHashAndIndexRequest) (*TransactionByBlockHashAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionByBlockHashAndIndex not implemented")
      }
      func (UnimplementedRingServiceServer) TransactionByBlockNumberAndIndex(context.Context, *TransactionByBlockNumberAndIndexRequest) (*TransactionByBlockNumberAndIndexResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionByBlockNumberAndIndex not implemented")
      }
      func (UnimplementedRingServiceServer) TransactionReceipt(context.Context, *TransactionReceiptRequest) (*TransactionReceiptResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionReceipt not implemented")
      }
      func (UnimplementedRingServiceServer) Balance(context.Context, *BalanceRequest) (*BalanceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented")
      }
      func (UnimplementedRingServiceServer) Storage(context.Context, *StorageRequest) (*StorageResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Storage not implemented")
      }
      func (UnimplementedRingServiceServer) Nonce(context.Context, *NonceRequest) (*NonceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Nonce not implemented")
      }
      func (UnimplementedRingServiceServer) RepeatedNonce(context.Context, *RepeatedNonceRequest) (*RepeatedNonceResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method RepeatedNonce not implemented")
      }
      func (UnimplementedRingServiceServer) TransactionCount(context.Context, *TransactionCountRequest) (*TransactionCountResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method TransactionCount not implemented")
      }
      func (UnimplementedRingServiceServer) GetCode(context.Context, *GetCodeRequest) (*GetCodeResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GetCode not implemented")
      }
      func (UnimplementedRingServiceServer) Sign(context.Context, *SignRequest) (*SignResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented")
      }
      func (UnimplementedRingServiceServer) SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SignTransaction not implemented")
      }
      func (UnimplementedRingServiceServer) SendTransaction(context.Context, *SendTransactionRequest) (*SendTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SendTransaction not implemented")
      }
      func (UnimplementedRingServiceServer) SendRawTransaction(context.Context, *SendRawTransactionRequest) (*SendRawTransactionResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method SendRawTransaction not implemented")
      }
      func (UnimplementedRingServiceServer) Call(context.Context, *CallRequest) (*CallResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Call not implemented")
      }
      func (UnimplementedRingServiceServer) NewFilter(context.Context, *NewFilterRequest) (*NewFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NewFilter not implemented")
      }
      func (UnimplementedRingServiceServer) NewBlockFilter(context.Context, *emptypb.Empty) (*NewBlockFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method NewBlockFilter not implemented")
      }
      func (UnimplementedRingServiceServer) PendingTransactionFilter(context.Context, *emptypb.Empty) (*PendingTransactionFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method PendingTransactionFilter not implemented")
      }
      func (UnimplementedRingServiceServer) UninstallFilter(context.Context, *UninstallFilterRequest) (*UninstallFilterResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method UninstallFilter not implemented")
      }
      func (UnimplementedRingServiceServer) FilterChanges(context.Context, *FilterChangesRequest) (*FilterChangesResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method FilterChanges not implemented")
      }
      func (UnimplementedRingServiceServer) FilterLogs(context.Context, *FilterLogsRequest) (*FilterLogsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method FilterLogs not implemented")
      }
      func (UnimplementedRingServiceServer) Logs(context.Context, *LogsRequest) (*LogsResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method Logs not implemented")
      }
      func (UnimplementedRingServiceServer) mustEmbedUnimplementedRingServiceServer() {}
      // UnsafeRingServiceServer may be embedded to opt out of forward compatibility for this service.
      // Use of this interface is not recommended, as added methods to RingServiceServer will
      // result in compilation errors.
      type UnsafeRingServiceServer interface {
      mustEmbedUnimplementedRingServiceServer()
      }
      func RegisterRingServiceServer(s grpc.ServiceRegistrar, srv RingServiceServer) {
      s.RegisterService(&RingService_ServiceDesc, srv)
      }
      func _RingService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(RequestPing)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Ping(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Ping",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Ping(ctx, req.(*RequestPing))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_BroadcastTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BroadcastEthTxWithFromRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).BroadcastTx(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/BroadcastTx",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).BroadcastTx(ctx, req.(*BroadcastEthTxWithFromRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Sha3_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(Sha3Request)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Sha3(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Sha3",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Sha3(ctx, req.(*Sha3Request))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_NodeVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).NodeVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/NodeVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).NodeVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_NetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).NetVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/NetVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).NetVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_NetPeerCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).NetPeerCount(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/NetPeerCount",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).NetPeerCount(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_ProtocolVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).ProtocolVersion(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/ProtocolVersion",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).ProtocolVersion(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Syncing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Syncing(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Syncing",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Syncing(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Coinbase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Coinbase(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Coinbase",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Coinbase(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Mining_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Mining(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Mining",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Mining(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_HashRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).HashRate(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/HashRate",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).HashRate(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Accounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Accounts(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Accounts",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Accounts(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_GasPrice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).GasPrice(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/GasPrice",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).GasPrice(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_BlockNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).BlockNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/BlockNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).BlockNumber(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_BlockByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).BlockByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/BlockByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).BlockByHash(ctx, req.(*BlockByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_BlockByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockByNumberRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).BlockByNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/BlockByNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).BlockByNumber(ctx, req.(*BlockByNumberRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_BlockTransactionCountByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockTransactionCountByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).BlockTransactionCountByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/BlockTransactionCountByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).BlockTransactionCountByHash(ctx, req.(*BlockTransactionCountByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_BlockTransactionCountByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BlockTransactionCountByNumberRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).BlockTransactionCountByNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/BlockTransactionCountByNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).BlockTransactionCountByNumber(ctx, req.(*BlockTransactionCountByNumberRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_UncleCountByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleCountByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).UncleCountByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/UncleCountByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).UncleCountByHash(ctx, req.(*UncleCountByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_UncleCountByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleCountByNumberRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).UncleCountByNumber(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/UncleCountByNumber",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).UncleCountByNumber(ctx, req.(*UncleCountByNumberRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_UncleByBlockHashAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleByBlockHashAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).UncleByBlockHashAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/UncleByBlockHashAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).UncleByBlockHashAndIndex(ctx, req.(*UncleByBlockHashAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_UncleByBlockNumberAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UncleByBlockNumberAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).UncleByBlockNumberAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/UncleByBlockNumberAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).UncleByBlockNumberAndIndex(ctx, req.(*UncleByBlockNumberAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Compilers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompilersRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Compilers(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Compilers",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Compilers(ctx, req.(*CompilersRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_CompileSolidity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompileSolidityRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).CompileSolidity(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/CompileSolidity",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).CompileSolidity(ctx, req.(*CompileSolidityRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_CompileLLL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompileLLLRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).CompileLLL(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/CompileLLL",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).CompileLLL(ctx, req.(*CompileLLLRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_CompileSerpent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CompileSerpentRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).CompileSerpent(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/CompileSerpent",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).CompileSerpent(ctx, req.(*CompileSerpentRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_EstimateGas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(EstimateGasRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).EstimateGas(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/EstimateGas",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).EstimateGas(ctx, req.(*EstimateGasRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_TransactionByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionByHashRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).TransactionByHash(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/TransactionByHash",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).TransactionByHash(ctx, req.(*TransactionByHashRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_TransactionByBlockHashAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionByBlockHashAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).TransactionByBlockHashAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/TransactionByBlockHashAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).TransactionByBlockHashAndIndex(ctx, req.(*TransactionByBlockHashAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_TransactionByBlockNumberAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionByBlockNumberAndIndexRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).TransactionByBlockNumberAndIndex(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/TransactionByBlockNumberAndIndex",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).TransactionByBlockNumberAndIndex(ctx, req.(*TransactionByBlockNumberAndIndexRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_TransactionReceipt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionReceiptRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).TransactionReceipt(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/TransactionReceipt",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).TransactionReceipt(ctx, req.(*TransactionReceiptRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BalanceRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Balance(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Balance",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Balance(ctx, req.(*BalanceRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Storage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(StorageRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Storage(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Storage",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Storage(ctx, req.(*StorageRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Nonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(NonceRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Nonce(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Nonce",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Nonce(ctx, req.(*NonceRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_RepeatedNonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(RepeatedNonceRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).RepeatedNonce(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/RepeatedNonce",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).RepeatedNonce(ctx, req.(*RepeatedNonceRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_TransactionCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(TransactionCountRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).TransactionCount(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/TransactionCount",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).TransactionCount(ctx, req.(*TransactionCountRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_GetCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(GetCodeRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).GetCode(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/GetCode",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).GetCode(ctx, req.(*GetCodeRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SignRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Sign(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Sign",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Sign(ctx, req.(*SignRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_SignTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SignTransactionRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).SignTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/SignTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).SignTransaction(ctx, req.(*SignTransactionRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_SendTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SendTransactionRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).SendTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/SendTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).SendTransaction(ctx, req.(*SendTransactionRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_SendRawTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(SendRawTransactionRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).SendRawTransaction(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/SendRawTransaction",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).SendRawTransaction(ctx, req.(*SendRawTransactionRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Call_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CallRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Call(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Call",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Call(ctx, req.(*CallRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_NewFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(NewFilterRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).NewFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/NewFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).NewFilter(ctx, req.(*NewFilterRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_NewBlockFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).NewBlockFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/NewBlockFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).NewBlockFilter(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_PendingTransactionFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(emptypb.Empty)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).PendingTransactionFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/PendingTransactionFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).PendingTransactionFilter(ctx, req.(*emptypb.Empty))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_UninstallFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(UninstallFilterRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).UninstallFilter(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/UninstallFilter",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).UninstallFilter(ctx, req.(*UninstallFilterRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_FilterChanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(FilterChangesRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).FilterChanges(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/FilterChanges",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).FilterChanges(ctx, req.(*FilterChangesRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_FilterLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(FilterLogsRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).FilterLogs(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/FilterLogs",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).FilterLogs(ctx, req.(*FilterLogsRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _RingService_Logs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(LogsRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(RingServiceServer).Logs(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/ring.v1.RingService/Logs",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(RingServiceServer).Logs(ctx, req.(*LogsRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      // RingService_ServiceDesc is the grpc.ServiceDesc for RingService service.
      // It's only intended for direct use with grpc.RegisterService,
      // and not to be introspected or modified (even as a copy)
      var RingService_ServiceDesc = grpc.ServiceDesc{
      ServiceName: "ring.v1.RingService",
      HandlerType: (*RingServiceServer)(nil),
      Methods: []grpc.MethodDesc{
      {
      MethodName: "Ping",
      Handler: _RingService_Ping_Handler,
      },
      {
      MethodName: "BroadcastTx",
      Handler: _RingService_BroadcastTx_Handler,
      },
      {
      MethodName: "Sha3",
      Handler: _RingService_Sha3_Handler,
      },
      {
      MethodName: "NodeVersion",
      Handler: _RingService_NodeVersion_Handler,
      },
      {
      MethodName: "NetVersion",
      Handler: _RingService_NetVersion_Handler,
      },
      {
      MethodName: "NetPeerCount",
      Handler: _RingService_NetPeerCount_Handler,
      },
      {
      MethodName: "ProtocolVersion",
      Handler: _RingService_ProtocolVersion_Handler,
      },
      {
      MethodName: "Syncing",
      Handler: _RingService_Syncing_Handler,
      },
      {
      MethodName: "Coinbase",
      Handler: _RingService_Coinbase_Handler,
      },
      {
      MethodName: "Mining",
      Handler: _RingService_Mining_Handler,
      },
      {
      MethodName: "HashRate",
      Handler: _RingService_HashRate_Handler,
      },
      {
      MethodName: "Accounts",
      Handler: _RingService_Accounts_Handler,
      },
      {
      MethodName: "GasPrice",
      Handler: _RingService_GasPrice_Handler,
      },
      {
      MethodName: "BlockNumber",
      Handler: _RingService_BlockNumber_Handler,
      },
      {
      MethodName: "BlockByHash",
      Handler: _RingService_BlockByHash_Handler,
      },
      {
      MethodName: "BlockByNumber",
      Handler: _RingService_BlockByNumber_Handler,
      },
      {
      MethodName: "BlockTransactionCountByHash",
      Handler: _RingService_BlockTransactionCountByHash_Handler,
      },
      {
      MethodName: "BlockTransactionCountByNumber",
      Handler: _RingService_BlockTransactionCountByNumber_Handler,
      },
      {
      MethodName: "UncleCountByHash",
      Handler: _RingService_UncleCountByHash_Handler,
      },
      {
      MethodName: "UncleCountByNumber",
      Handler: _RingService_UncleCountByNumber_Handler,
      },
      {
      MethodName: "UncleByBlockHashAndIndex",
      Handler: _RingService_UncleByBlockHashAndIndex_Handler,
      },
      {
      MethodName: "UncleByBlockNumberAndIndex",
      Handler: _RingService_UncleByBlockNumberAndIndex_Handler,
      },
      {
      MethodName: "Compilers",
      Handler: _RingService_Compilers_Handler,
      },
      {
      MethodName: "CompileSolidity",
      Handler: _RingService_CompileSolidity_Handler,
      },
      {
      MethodName: "CompileLLL",
      Handler: _RingService_CompileLLL_Handler,
      },
      {
      MethodName: "CompileSerpent",
      Handler: _RingService_CompileSerpent_Handler,
      },
      {
      MethodName: "EstimateGas",
      Handler: _RingService_EstimateGas_Handler,
      },
      {
      MethodName: "TransactionByHash",
      Handler: _RingService_TransactionByHash_Handler,
      },
      {
      MethodName: "TransactionByBlockHashAndIndex",
      Handler: _RingService_TransactionByBlockHashAndIndex_Handler,
      },
      {
      MethodName: "TransactionByBlockNumberAndIndex",
      Handler: _RingService_TransactionByBlockNumberAndIndex_Handler,
      },
      {
      MethodName: "TransactionReceipt",
      Handler: _RingService_TransactionReceipt_Handler,
      },
      {
      MethodName: "Balance",
      Handler: _RingService_Balance_Handler,
      },
      {
      MethodName: "Storage",
      Handler: _RingService_Storage_Handler,
      },
      {
      MethodName: "Nonce",
      Handler: _RingService_Nonce_Handler,
      },
      {
      MethodName: "RepeatedNonce",
      Handler: _RingService_RepeatedNonce_Handler,
      },
      {
      MethodName: "TransactionCount",
      Handler: _RingService_TransactionCount_Handler,
      },
      {
      MethodName: "GetCode",
      Handler: _RingService_GetCode_Handler,
      },
      {
      MethodName: "Sign",
      Handler: _RingService_Sign_Handler,
      },
      {
      MethodName: "SignTransaction",
      Handler: _RingService_SignTransaction_Handler,
      },
      {
      MethodName: "SendTransaction",
      Handler: _RingService_SendTransaction_Handler,
      },
      {
      MethodName: "SendRawTransaction",
      Handler: _RingService_SendRawTransaction_Handler,
      },
      {
      MethodName: "Call",
      Handler: _RingService_Call_Handler,
      },
      {
      MethodName: "NewFilter",
      Handler: _RingService_NewFilter_Handler,
      },
      {
      MethodName: "NewBlockFilter",
      Handler: _RingService_NewBlockFilter_Handler,
      },
      {
      MethodName: "PendingTransactionFilter",
      Handler: _RingService_PendingTransactionFilter_Handler,
      },
      {
      MethodName: "UninstallFilter",
      Handler: _RingService_UninstallFilter_Handler,
      },
      {
      MethodName: "FilterChanges",
      Handler: _RingService_FilterChanges_Handler,
      },
      {
      MethodName: "FilterLogs",
      Handler: _RingService_FilterLogs_Handler,
      },
      {
      MethodName: "Logs",
      Handler: _RingService_Logs_Handler,
      },
      },
      Streams: []grpc.StreamDesc{},
      Metadata: "ring/v1/service.proto",
      }
      MetaProtocol-main/gen/proto/go/sentry/v1/request_response.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: sentry/v1/request_response.proto
      package sentryv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      _ "github.com/gogo/protobuf/types"
      _ "google.golang.org/protobuf/types/known/fieldmaskpb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      type LimitInfoRequest struct {
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *LimitInfoRequest) Reset() { *m = LimitInfoRequest{} }
      func (m *LimitInfoRequest) String() string { return proto.CompactTextString(m) }
      func (*LimitInfoRequest) ProtoMessage() {}
      func (*LimitInfoRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{0}
      }
      func (m *LimitInfoRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_LimitInfoRequest.Unmarshal(m, b)
      }
      func (m *LimitInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_LimitInfoRequest.Marshal(b, m, deterministic)
      }
      func (m *LimitInfoRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_LimitInfoRequest.Merge(m, src)
      }
      func (m *LimitInfoRequest) XXX_Size() int {
      return xxx_messageInfo_LimitInfoRequest.Size(m)
      }
      func (m *LimitInfoRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_LimitInfoRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_LimitInfoRequest proto.InternalMessageInfo
      type LimitInfoResponse struct {
      // tx count in one batchTx.
      BatchTxCount uint32 `protobuf:"varint,1,opt,name=batch_tx_count,json=batchTxCount,proto3" json:"batch_tx_count,omitempty"`
      // batchTx count in one block.
      BlockBatchCount uint32 `protobuf:"varint,2,opt,name=block_batch_count,json=blockBatchCount,proto3" json:"block_batch_count,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *LimitInfoResponse) Reset() { *m = LimitInfoResponse{} }
      func (m *LimitInfoResponse) String() string { return proto.CompactTextString(m) }
      func (*LimitInfoResponse) ProtoMessage() {}
      func (*LimitInfoResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{1}
      }
      func (m *LimitInfoResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_LimitInfoResponse.Unmarshal(m, b)
      }
      func (m *LimitInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_LimitInfoResponse.Marshal(b, m, deterministic)
      }
      func (m *LimitInfoResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_LimitInfoResponse.Merge(m, src)
      }
      func (m *LimitInfoResponse) XXX_Size() int {
      return xxx_messageInfo_LimitInfoResponse.Size(m)
      }
      func (m *LimitInfoResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_LimitInfoResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_LimitInfoResponse proto.InternalMessageInfo
      func (m *LimitInfoResponse) GetBatchTxCount() uint32 {
      if m != nil {
      return m.BatchTxCount
      }
      return 0
      }
      func (m *LimitInfoResponse) GetBlockBatchCount() uint32 {
      if m != nil {
      return m.BlockBatchCount
      }
      return 0
      }
      type CommitBatchTxRequest struct {
      Txdata []byte `protobuf:"bytes,1,opt,name=txdata,proto3" json:"txdata,omitempty"`
      Sizem int64 `protobuf:"varint,2,opt,name=sizem,proto3" json:"sizem,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *CommitBatchTxRequest) Reset() { *m = CommitBatchTxRequest{} }
      func (m *CommitBatchTxRequest) String() string { return proto.CompactTextString(m) }
      func (*CommitBatchTxRequest) ProtoMessage() {}
      func (*CommitBatchTxRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{2}
      }
      func (m *CommitBatchTxRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_CommitBatchTxRequest.Unmarshal(m, b)
      }
      func (m *CommitBatchTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_CommitBatchTxRequest.Marshal(b, m, deterministic)
      }
      func (m *CommitBatchTxRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_CommitBatchTxRequest.Merge(m, src)
      }
      func (m *CommitBatchTxRequest) XXX_Size() int {
      return xxx_messageInfo_CommitBatchTxRequest.Size(m)
      }
      func (m *CommitBatchTxRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_CommitBatchTxRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_CommitBatchTxRequest proto.InternalMessageInfo
      func (m *CommitBatchTxRequest) GetTxdata() []byte {
      if m != nil {
      return m.Txdata
      }
      return nil
      }
      func (m *CommitBatchTxRequest) GetSizem() int64 {
      if m != nil {
      return m.Sizem
      }
      return 0
      }
      type CommitBatchTxResponse struct {
      Txhash string `protobuf:"bytes,1,opt,name=txhash,proto3" json:"txhash,omitempty"`
      ErrMsg string `protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *CommitBatchTxResponse) Reset() { *m = CommitBatchTxResponse{} }
      func (m *CommitBatchTxResponse) String() string { return proto.CompactTextString(m) }
      func (*CommitBatchTxResponse) ProtoMessage() {}
      func (*CommitBatchTxResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{3}
      }
      func (m *CommitBatchTxResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_CommitBatchTxResponse.Unmarshal(m, b)
      }
      func (m *CommitBatchTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_CommitBatchTxResponse.Marshal(b, m, deterministic)
      }
      func (m *CommitBatchTxResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_CommitBatchTxResponse.Merge(m, src)
      }
      func (m *CommitBatchTxResponse) XXX_Size() int {
      return xxx_messageInfo_CommitBatchTxResponse.Size(m)
      }
      func (m *CommitBatchTxResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_CommitBatchTxResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_CommitBatchTxResponse proto.InternalMessageInfo
      func (m *CommitBatchTxResponse) GetTxhash() string {
      if m != nil {
      return m.Txhash
      }
      return ""
      }
      func (m *CommitBatchTxResponse) GetErrMsg() string {
      if m != nil {
      return m.ErrMsg
      }
      return ""
      }
      type GetReceiptRequest struct {
      Txhash string `protobuf:"bytes,1,opt,name=txhash,proto3" json:"txhash,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *GetReceiptRequest) Reset() { *m = GetReceiptRequest{} }
      func (m *GetReceiptRequest) String() string { return proto.CompactTextString(m) }
      func (*GetReceiptRequest) ProtoMessage() {}
      func (*GetReceiptRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{4}
      }
      func (m *GetReceiptRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_GetReceiptRequest.Unmarshal(m, b)
      }
      func (m *GetReceiptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_GetReceiptRequest.Marshal(b, m, deterministic)
      }
      func (m *GetReceiptRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_GetReceiptRequest.Merge(m, src)
      }
      func (m *GetReceiptRequest) XXX_Size() int {
      return xxx_messageInfo_GetReceiptRequest.Size(m)
      }
      func (m *GetReceiptRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_GetReceiptRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_GetReceiptRequest proto.InternalMessageInfo
      func (m *GetReceiptRequest) GetTxhash() string {
      if m != nil {
      return m.Txhash
      }
      return ""
      }
      type GetReceiptResponse struct {
      ReceiptData []byte `protobuf:"bytes,1,opt,name=receipt_data,json=receiptData,proto3" json:"receipt_data,omitempty"`
      ErrMsg string `protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *GetReceiptResponse) Reset() { *m = GetReceiptResponse{} }
      func (m *GetReceiptResponse) String() string { return proto.CompactTextString(m) }
      func (*GetReceiptResponse) ProtoMessage() {}
      func (*GetReceiptResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{5}
      }
      func (m *GetReceiptResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_GetReceiptResponse.Unmarshal(m, b)
      }
      func (m *GetReceiptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_GetReceiptResponse.Marshal(b, m, deterministic)
      }
      func (m *GetReceiptResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_GetReceiptResponse.Merge(m, src)
      }
      func (m *GetReceiptResponse) XXX_Size() int {
      return xxx_messageInfo_GetReceiptResponse.Size(m)
      }
      func (m *GetReceiptResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_GetReceiptResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_GetReceiptResponse proto.InternalMessageInfo
      func (m *GetReceiptResponse) GetReceiptData() []byte {
      if m != nil {
      return m.ReceiptData
      }
      return nil
      }
      func (m *GetReceiptResponse) GetErrMsg() string {
      if m != nil {
      return m.ErrMsg
      }
      return ""
      }
      type GetNewBlockRequest struct {
      LastBlock uint32 `protobuf:"varint,1,opt,name=last_block,json=lastBlock,proto3" json:"last_block,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *GetNewBlockRequest) Reset() { *m = GetNewBlockRequest{} }
      func (m *GetNewBlockRequest) String() string { return proto.CompactTextString(m) }
      func (*GetNewBlockRequest) ProtoMessage() {}
      func (*GetNewBlockRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{6}
      }
      func (m *GetNewBlockRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_GetNewBlockRequest.Unmarshal(m, b)
      }
      func (m *GetNewBlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_GetNewBlockRequest.Marshal(b, m, deterministic)
      }
      func (m *GetNewBlockRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_GetNewBlockRequest.Merge(m, src)
      }
      func (m *GetNewBlockRequest) XXX_Size() int {
      return xxx_messageInfo_GetNewBlockRequest.Size(m)
      }
      func (m *GetNewBlockRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_GetNewBlockRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_GetNewBlockRequest proto.InternalMessageInfo
      func (m *GetNewBlockRequest) GetLastBlock() uint32 {
      if m != nil {
      return m.LastBlock
      }
      return 0
      }
      type GetNewBlockResponse struct {
      BlockNum uint32 `protobuf:"varint,1,opt,name=block_num,json=blockNum,proto3" json:"block_num,omitempty"`
      BlockTime uint64 `protobuf:"varint,2,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"`
      BatchTxs string `protobuf:"bytes,3,opt,name=batch_txs,json=batchTxs,proto3" json:"batch_txs,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *GetNewBlockResponse) Reset() { *m = GetNewBlockResponse{} }
      func (m *GetNewBlockResponse) String() string { return proto.CompactTextString(m) }
      func (*GetNewBlockResponse) ProtoMessage() {}
      func (*GetNewBlockResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{7}
      }
      func (m *GetNewBlockResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_GetNewBlockResponse.Unmarshal(m, b)
      }
      func (m *GetNewBlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_GetNewBlockResponse.Marshal(b, m, deterministic)
      }
      func (m *GetNewBlockResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_GetNewBlockResponse.Merge(m, src)
      }
      func (m *GetNewBlockResponse) XXX_Size() int {
      return xxx_messageInfo_GetNewBlockResponse.Size(m)
      }
      func (m *GetNewBlockResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_GetNewBlockResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_GetNewBlockResponse proto.InternalMessageInfo
      func (m *GetNewBlockResponse) GetBlockNum() uint32 {
      if m != nil {
      return m.BlockNum
      }
      return 0
      }
      func (m *GetNewBlockResponse) GetBlockTime() uint64 {
      if m != nil {
      return m.BlockTime
      }
      return 0
      }
      func (m *GetNewBlockResponse) GetBatchTxs() string {
      if m != nil {
      return m.BatchTxs
      }
      return ""
      }
      type CommitBlockRequest struct {
      Validator string `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
      BlockNumber uint64 `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
      BlockData []byte `protobuf:"bytes,3,opt,name=block_data,json=blockData,proto3" json:"block_data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *CommitBlockRequest) Reset() { *m = CommitBlockRequest{} }
      func (m *CommitBlockRequest) String() string { return proto.CompactTextString(m) }
      func (*CommitBlockRequest) ProtoMessage() {}
      func (*CommitBlockRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{8}
      }
      func (m *CommitBlockRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_CommitBlockRequest.Unmarshal(m, b)
      }
      func (m *CommitBlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_CommitBlockRequest.Marshal(b, m, deterministic)
      }
      func (m *CommitBlockRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_CommitBlockRequest.Merge(m, src)
      }
      func (m *CommitBlockRequest) XXX_Size() int {
      return xxx_messageInfo_CommitBlockRequest.Size(m)
      }
      func (m *CommitBlockRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_CommitBlockRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_CommitBlockRequest proto.InternalMessageInfo
      func (m *CommitBlockRequest) GetValidator() string {
      if m != nil {
      return m.Validator
      }
      return ""
      }
      func (m *CommitBlockRequest) GetBlockNumber() uint64 {
      if m != nil {
      return m.BlockNumber
      }
      return 0
      }
      func (m *CommitBlockRequest) GetBlockData() []byte {
      if m != nil {
      return m.BlockData
      }
      return nil
      }
      type CommitBlockResponse struct {
      Txhash string `protobuf:"bytes,1,opt,name=txhash,proto3" json:"txhash,omitempty"`
      ErrMsg string `protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *CommitBlockResponse) Reset() { *m = CommitBlockResponse{} }
      func (m *CommitBlockResponse) String() string { return proto.CompactTextString(m) }
      func (*CommitBlockResponse) ProtoMessage() {}
      func (*CommitBlockResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{9}
      }
      func (m *CommitBlockResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_CommitBlockResponse.Unmarshal(m, b)
      }
      func (m *CommitBlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_CommitBlockResponse.Marshal(b, m, deterministic)
      }
      func (m *CommitBlockResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_CommitBlockResponse.Merge(m, src)
      }
      func (m *CommitBlockResponse) XXX_Size() int {
      return xxx_messageInfo_CommitBlockResponse.Size(m)
      }
      func (m *CommitBlockResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_CommitBlockResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_CommitBlockResponse proto.InternalMessageInfo
      func (m *CommitBlockResponse) GetTxhash() string {
      if m != nil {
      return m.Txhash
      }
      return ""
      }
      func (m *CommitBlockResponse) GetErrMsg() string {
      if m != nil {
      return m.ErrMsg
      }
      return ""
      }
      type GetConsensusedBlockRequest struct {
      BlockNumber uint64 `protobuf:"varint,1,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *GetConsensusedBlockRequest) Reset() { *m = GetConsensusedBlockRequest{} }
      func (m *GetConsensusedBlockRequest) String() string { return proto.CompactTextString(m) }
      func (*GetConsensusedBlockRequest) ProtoMessage() {}
      func (*GetConsensusedBlockRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{10}
      }
      func (m *GetConsensusedBlockRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_GetConsensusedBlockRequest.Unmarshal(m, b)
      }
      func (m *GetConsensusedBlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_GetConsensusedBlockRequest.Marshal(b, m, deterministic)
      }
      func (m *GetConsensusedBlockRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_GetConsensusedBlockRequest.Merge(m, src)
      }
      func (m *GetConsensusedBlockRequest) XXX_Size() int {
      return xxx_messageInfo_GetConsensusedBlockRequest.Size(m)
      }
      func (m *GetConsensusedBlockRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_GetConsensusedBlockRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_GetConsensusedBlockRequest proto.InternalMessageInfo
      func (m *GetConsensusedBlockRequest) GetBlockNumber() uint64 {
      if m != nil {
      return m.BlockNumber
      }
      return 0
      }
      type GetConsensusedBlockResponse struct {
      BlockNumber uint64 `protobuf:"varint,1,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
      BlockData []byte `protobuf:"bytes,2,opt,name=block_data,json=blockData,proto3" json:"block_data,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *GetConsensusedBlockResponse) Reset() { *m = GetConsensusedBlockResponse{} }
      func (m *GetConsensusedBlockResponse) String() string { return proto.CompactTextString(m) }
      func (*GetConsensusedBlockResponse) ProtoMessage() {}
      func (*GetConsensusedBlockResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_2589e4ceb3230fa4, []int{11}
      }
      func (m *GetConsensusedBlockResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_GetConsensusedBlockResponse.Unmarshal(m, b)
      }
      func (m *GetConsensusedBlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_GetConsensusedBlockResponse.Marshal(b, m, deterministic)
      }
      func (m *GetConsensusedBlockResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_GetConsensusedBlockResponse.Merge(m, src)
      }
      func (m *GetConsensusedBlockResponse) XXX_Size() int {
      return xxx_messageInfo_GetConsensusedBlockResponse.Size(m)
      }
      func (m *GetConsensusedBlockResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_GetConsensusedBlockResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_GetConsensusedBlockResponse proto.InternalMessageInfo
      func (m *GetConsensusedBlockResponse) GetBlockNumber() uint64 {
      if m != nil {
      return m.BlockNumber
      }
      return 0
      }
      func (m *GetConsensusedBlockResponse) GetBlockData() []byte {
      if m != nil {
      return m.BlockData
      }
      return nil
      }
      func init() {
      proto.RegisterType((*LimitInfoRequest)(nil), "sentry.v1.LimitInfoRequest")
      proto.RegisterType((*LimitInfoResponse)(nil), "sentry.v1.LimitInfoResponse")
      proto.RegisterType((*CommitBatchTxRequest)(nil), "sentry.v1.CommitBatchTxRequest")
      proto.RegisterType((*CommitBatchTxResponse)(nil), "sentry.v1.CommitBatchTxResponse")
      proto.RegisterType((*GetReceiptRequest)(nil), "sentry.v1.GetReceiptRequest")
      proto.RegisterType((*GetReceiptResponse)(nil), "sentry.v1.GetReceiptResponse")
      proto.RegisterType((*GetNewBlockRequest)(nil), "sentry.v1.GetNewBlockRequest")
      proto.RegisterType((*GetNewBlockResponse)(nil), "sentry.v1.GetNewBlockResponse")
      proto.RegisterType((*CommitBlockRequest)(nil), "sentry.v1.CommitBlockRequest")
      proto.RegisterType((*CommitBlockResponse)(nil), "sentry.v1.CommitBlockResponse")
      proto.RegisterType((*GetConsensusedBlockRequest)(nil), "sentry.v1.GetConsensusedBlockRequest")
      proto.RegisterType((*GetConsensusedBlockResponse)(nil), "sentry.v1.GetConsensusedBlockResponse")
      }
      func init() { proto.RegisterFile("sentry/v1/request_response.proto", fileDescriptor_2589e4ceb3230fa4) }
      var fileDescriptor_2589e4ceb3230fa4 = []byte{
      // 595 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0xcd, 0x6e, 0xd3, 0x4c,
      0x14, 0x55, 0x9c, 0xef, 0x2b, 0xf5, 0x6d, 0x0b, 0xd4, 0x6d, 0x21, 0x4a, 0x41, 0x04, 0x8b, 0x05,
      0x02, 0x29, 0x96, 0xd5, 0x5d, 0x59, 0x20, 0x39, 0x15, 0x01, 0x89, 0x56, 0xc1, 0xad, 0xa2, 0x0a,
      0x55, 0xb2, 0x6c, 0xe7, 0xc6, 0xb1, 0xea, 0xf1, 0x84, 0x99, 0x71, 0x08, 0x3c, 0x0e, 0x4b, 0xde,
      0x81, 0x17, 0xe0, 0x31, 0x58, 0xf2, 0x14, 0x68, 0x7e, 0xf2, 0x5b, 0x10, 0x12, 0xbb, 0x99, 0x33,
      0x67, 0xce, 0x39, 0xf7, 0x5e, 0x7b, 0xa0, 0xc5, 0xb1, 0x14, 0xec, 0x93, 0x37, 0xf1, 0x3d, 0x86,
      0x1f, 0x2a, 0xe4, 0x22, 0x62, 0xc8, 0xc7, 0xb4, 0xe4, 0xd8, 0x1e, 0x33, 0x2a, 0xa8, 0x63, 0x6b,
      0x46, 0x7b, 0xe2, 0x37, 0x5b, 0x19, 0xa5, 0x59, 0x81, 0x9e, 0x3a, 0x48, 0xaa, 0xa1, 0x37, 0xcc,
      0xb1, 0x18, 0x44, 0x24, 0xe6, 0xd7, 0x9a, 0xdc, 0x7c, 0xb4, 0xce, 0x10, 0x39, 0x41, 0x2e, 0x62,
      0x32, 0x36, 0x84, 0xc6, 0xb2, 0x1f, 0xa7, 0x15, 0x4b, 0x8d, 0x8f, 0xeb, 0xc0, 0xdd, 0xb7, 0x39,
      0xc9, 0xc5, 0x9b, 0x72, 0x48, 0x43, 0x1d, 0xc5, 0x45, 0xd8, 0x5d, 0xc2, 0x74, 0x2c, 0xe7, 0x09,
      0xdc, 0x4e, 0x62, 0x91, 0x8e, 0x22, 0x31, 0x8d, 0x52, 0x5a, 0x95, 0xa2, 0x51, 0x6b, 0xd5, 0x9e,
      0xee, 0x84, 0xdb, 0x0a, 0xbd, 0x98, 0x76, 0x24, 0xe6, 0x3c, 0x83, 0xdd, 0xa4, 0xa0, 0xe9, 0x75,
      0xa4, 0xb9, 0x9a, 0x68, 0x29, 0xe2, 0x1d, 0x75, 0x10, 0x48, 0x5c, 0x71, 0xdd, 0x13, 0xd8, 0xef,
      0x50, 0x42, 0x72, 0x11, 0x68, 0x05, 0x63, 0xef, 0xdc, 0x83, 0x0d, 0x31, 0x1d, 0xc4, 0x22, 0x56,
      0x0e, 0xdb, 0xa1, 0xd9, 0x39, 0xfb, 0xf0, 0x3f, 0xcf, 0x3f, 0x23, 0x51, 0x7a, 0xf5, 0x50, 0x6f,
      0xdc, 0xd7, 0x70, 0xb0, 0xa6, 0x62, 0x02, 0x2b, 0x99, 0x51, 0xcc, 0x47, 0x4a, 0xc6, 0x0e, 0xcd,
      0xce, 0xb9, 0x0f, 0xb7, 0x90, 0xb1, 0x88, 0xf0, 0x4c, 0x09, 0xd9, 0xe1, 0x06, 0x32, 0x76, 0xca,
      0x33, 0xf7, 0x39, 0xec, 0x76, 0x51, 0x84, 0x98, 0x62, 0x3e, 0x16, 0x2b, 0x61, 0x6e, 0xaa, 0xb8,
      0x3d, 0x70, 0x96, 0xc9, 0xc6, 0xf3, 0x31, 0x6c, 0x33, 0x0d, 0x45, 0x4b, 0x05, 0x6c, 0x19, 0xec,
      0x44, 0x56, 0xf1, 0x47, 0xfb, 0x23, 0xa5, 0x78, 0x86, 0x1f, 0x03, 0xd9, 0xa7, 0x99, 0xff, 0x43,
      0x80, 0x22, 0xe6, 0x22, 0x52, 0xcd, 0x33, 0x2d, 0xb7, 0x25, 0xa2, 0x58, 0x6e, 0x09, 0x7b, 0x2b,
      0x97, 0x4c, 0x8e, 0x43, 0xb0, 0xf5, 0x18, 0xca, 0x8a, 0x98, 0x4b, 0x9b, 0x0a, 0x38, 0xab, 0x88,
      0x94, 0xd4, 0x87, 0xf2, 0x2b, 0x51, 0x21, 0xfe, 0x0b, 0x35, 0xfd, 0x22, 0x27, 0xfa, 0xae, 0x19,
      0x34, 0x6f, 0xd4, 0x55, 0xc4, 0x4d, 0x33, 0x63, 0xee, 0x0a, 0x70, 0x4c, 0xb7, 0x97, 0x43, 0x3e,
      0x00, 0x7b, 0x12, 0x17, 0xf9, 0x20, 0x16, 0x94, 0x99, 0x3e, 0x2d, 0x00, 0xd9, 0x94, 0x79, 0x98,
      0x04, 0x99, 0x71, 0xdc, 0x9a, 0xe5, 0x49, 0x90, 0x2d, 0x22, 0xa9, 0xae, 0xd5, 0x55, 0xd7, 0x74,
      0x24, 0xd9, 0x33, 0xf7, 0x15, 0xec, 0xad, 0xb8, 0xfe, 0xeb, 0x84, 0x5f, 0x42, 0xb3, 0x8b, 0xa2,
      0x23, 0x2f, 0x97, 0xbc, 0xe2, 0x38, 0x58, 0xa9, 0x62, 0x3d, 0x67, 0xed, 0x46, 0x4e, 0x37, 0x82,
      0xc3, 0xdf, 0x0a, 0x2c, 0xc6, 0xff, 0x17, 0x85, 0xb5, 0x4a, 0xad, 0xb5, 0x4a, 0x83, 0x6f, 0x35,
      0xd8, 0x49, 0x29, 0x69, 0xcf, 0xff, 0xfe, 0x60, 0xdf, 0xc4, 0x9b, 0x99, 0xf4, 0xe4, 0x6f, 0xdb,
      0xab, 0xbd, 0x7f, 0x97, 0xe5, 0x62, 0x54, 0x25, 0xed, 0x94, 0x12, 0xaf, 0x13, 0x0f, 0xaa, 0x14,
      0x2b, 0x7e, 0x8a, 0x22, 0x9e, 0x20, 0x33, 0xa4, 0x94, 0x16, 0x9e, 0x44, 0xe6, 0x9b, 0x0c, 0x4b,
      0xfd, 0x44, 0x78, 0x19, 0xf5, 0xe6, 0x2f, 0xc2, 0x0b, 0xbd, 0x9a, 0xf8, 0x5f, 0xac, 0xfa, 0xf9,
      0xe5, 0xe5, 0x57, 0xcb, 0x3e, 0xd7, 0xe6, 0x7d, 0xff, 0xfb, 0x6c, 0x7d, 0xd5, 0xf7, 0x7f, 0x58,
      0x07, 0xf3, 0xf5, 0x55, 0xb7, 0x17, 0x48, 0x65, 0x59, 0xc3, 0x4f, 0x0b, 0x34, 0x7e, 0x7c, 0xdc,
      0xf7, 0x93, 0x0d, 0xa5, 0x7f, 0xf4, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x86, 0x4a, 0x26, 0x55, 0xe1,
      0x04, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/sentry/v1/resource.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: sentry/v1/resource.proto
      package sentryv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("sentry/v1/resource.proto", fileDescriptor_9d29b21b77d30ba1) }
      var fileDescriptor_9d29b21b77d30ba1 = []byte{
      // 182 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x28, 0x4e, 0xcd, 0x2b,
      0x29, 0xaa, 0xd4, 0x2f, 0x33, 0xd4, 0x2f, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5, 0x2b,
      0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0xc8, 0xe8, 0x95, 0x19, 0x3a, 0x6d, 0x63, 0xe4, 0xe2,
      0x4d, 0xce, 0xcf, 0xd5, 0x43, 0x88, 0xf0, 0x06, 0x41, 0x15, 0x07, 0x80, 0xd4, 0x06, 0x30, 0x46,
      0x05, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x3b, 0x27, 0xa6, 0x94,
      0x26, 0xa7, 0x96, 0x16, 0xfb, 0xa6, 0x96, 0x24, 0x96, 0xa5, 0x16, 0x15, 0x43, 0x14, 0x25, 0xe7,
      0xe7, 0xe8, 0x83, 0x44, 0xe0, 0x9c, 0xf4, 0xd4, 0x3c, 0x7d, 0xb0, 0x55, 0xfa, 0xe9, 0xf9, 0xfa,
      0x70, 0x67, 0x58, 0x43, 0x58, 0x65, 0x86, 0x8b, 0x98, 0x98, 0x83, 0x23, 0x22, 0x56, 0x31, 0x71,
      0x06, 0x43, 0x6c, 0x0d, 0x33, 0x3c, 0x05, 0x63, 0xc7, 0x84, 0x19, 0x3e, 0x62, 0x12, 0x85, 0xb3,
      0x63, 0xdc, 0x03, 0x9c, 0x40, 0x26, 0xa7, 0x24, 0x96, 0x24, 0xbe, 0x62, 0xe2, 0x82, 0x88, 0x5b,
      0x59, 0x85, 0x19, 0x26, 0xb1, 0x81, 0xcd, 0x37, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x73, 0x89,
      0xbf, 0xff, 0xe6, 0x00, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/sentry/v1/service.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: sentry/v1/service.proto
      package sentryv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      _ "google.golang.org/protobuf/types/known/emptypb"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("sentry/v1/service.proto", fileDescriptor_5e573e003b2c29f6) }
      var fileDescriptor_5e573e003b2c29f6 = []byte{
      // 396 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0xcd, 0x6a, 0xdb, 0x40,
      0x14, 0x85, 0x6b, 0xb5, 0x14, 0x3c, 0xb5, 0xa1, 0x15, 0x94, 0x82, 0xdd, 0x1f, 0x53, 0x68, 0x97,
      0x1a, 0xd4, 0xee, 0xdc, 0x9d, 0xb4, 0x10, 0xa5, 0xad, 0xf1, 0x1f, 0xc6, 0x14, 0x43, 0x90, 0x47,
      0xd7, 0xb2, 0x88, 0xa4, 0x51, 0x34, 0x57, 0x4a, 0xfc, 0x0c, 0x79, 0x8b, 0x2c, 0xb3, 0xcf, 0x4b,
      0xe4, 0x31, 0xb2, 0xcc, 0x53, 0x04, 0x79, 0xa4, 0xb1, 0x9c, 0xd8, 0x64, 0x77, 0xe7, 0x9c, 0x33,
      0xdf, 0xbd, 0x8b, 0x43, 0x3e, 0x08, 0x88, 0x31, 0xdd, 0xd0, 0xdc, 0xa4, 0x02, 0xd2, 0x3c, 0x60,
      0x60, 0x24, 0x29, 0x47, 0xae, 0x37, 0xa5, 0x61, 0xe4, 0x66, 0xa7, 0xb7, 0xcb, 0xa4, 0x70, 0x96,
      0x81, 0xc0, 0x93, 0x14, 0x44, 0xc2, 0x63, 0x51, 0x86, 0x3b, 0x5d, 0x9f, 0x73, 0x3f, 0x04, 0xba,
      0x7d, 0x2d, 0xb3, 0x15, 0x85, 0x28, 0xc1, 0x8d, 0x34, 0x7f, 0x5c, 0xbe, 0x22, 0xed, 0xc9, 0x96,
      0x30, 0x91, 0x1b, 0xf4, 0x3f, 0xa4, 0xe5, 0x00, 0xfe, 0x0d, 0xa2, 0x00, 0x7f, 0xc7, 0x2b, 0xae,
      0x77, 0x0d, 0xb5, 0xcc, 0x50, 0xea, 0x58, 0xae, 0xea, 0x7c, 0x3c, 0x6c, 0xca, 0xfd, 0x5f, 0x5f,
      0xe8, 0x53, 0xd2, 0xb6, 0x79, 0x14, 0x05, 0x68, 0xb9, 0xc8, 0xd6, 0xd3, 0x0b, 0xfd, 0x4b, 0xed,
      0xc3, 0x9e, 0x53, 0x11, 0x7b, 0xc7, 0x03, 0x8a, 0x3a, 0x22, 0x6f, 0x1d, 0xa8, 0xe9, 0x59, 0x88,
      0x7a, 0xfd, 0x12, 0x07, 0x70, 0x0c, 0x0c, 0x82, 0x04, 0x2b, 0xea, 0xa7, 0x23, 0xae, 0x42, 0x0e,
      0xc8, 0x1b, 0x07, 0x70, 0x00, 0xe7, 0x56, 0xc8, 0xd9, 0xa9, 0xfe, 0x28, 0x5f, 0xe9, 0x15, 0xee,
      0xf3, 0x31, 0xbb, 0xce, 0x2b, 0xaf, 0x7f, 0xc2, 0xab, 0xe9, 0x87, 0x78, 0x7b, 0xb6, 0xe2, 0x79,
      0xe4, 0x9d, 0x03, 0x68, 0xf3, 0x78, 0x15, 0xa4, 0x11, 0x78, 0x92, 0xfa, 0x6d, 0xff, 0x0c, 0xbb,
      0xc8, 0xc6, 0x22, 0x13, 0xa5, 0x5f, 0xd1, 0xbf, 0x3f, 0x17, 0xab, 0xb6, 0x58, 0x37, 0x0d, 0xd2,
      0x66, 0x3c, 0xda, 0xe5, 0xad, 0x56, 0x59, 0x8b, 0x61, 0xd1, 0x96, 0x61, 0xe3, 0xff, 0xc8, 0x0f,
      0x70, 0x9d, 0x2d, 0x0d, 0xc6, 0x23, 0x6a, 0xbb, 0x5e, 0xc6, 0x20, 0x13, 0xff, 0x00, 0xdd, 0x1c,
      0x52, 0x21, 0x43, 0x8c, 0x87, 0xb4, 0x50, 0xd4, 0xc3, 0x87, 0x58, 0x76, 0x8f, 0xfa, 0x9c, 0xaa,
      0xb6, 0xfe, 0x92, 0x53, 0x6e, 0x5e, 0x69, 0x2f, 0x27, 0xf3, 0xf9, 0xb5, 0xd6, 0x94, 0x35, 0x34,
      0x66, 0xe6, 0x6d, 0x35, 0x2f, 0x66, 0xe6, 0x9d, 0xf6, 0x5e, 0xcd, 0x0b, 0x67, 0x68, 0x15, 0x64,
      0xcf, 0x45, 0xf7, 0x5e, 0x23, 0x52, 0xef, 0xf7, 0x67, 0xe6, 0xf2, 0xf5, 0x96, 0xff, 0xf3, 0x21,
      0x00, 0x00, 0xff, 0xff, 0x9a, 0xb4, 0xa9, 0xda, 0x31, 0x03, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/sentry/v1/service_grpc.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
      // versions:
      // - protoc-gen-go-grpc v1.2.0
      // - protoc (unknown)
      // source: sentry/v1/service.proto
      package sentryv1
      import (
      context "context"
      grpc "google.golang.org/grpc"
      codes "google.golang.org/grpc/codes"
      status "google.golang.org/grpc/status"
      )
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the grpc package it is being compiled against.
      // Requires gRPC-Go v1.32.0 or later.
      const _ = grpc.SupportPackageIsVersion7
      // SentryServiceClient is the client API for SentryService service.
      //
      // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
      type SentryServiceClient interface {
      // for ring
      // LimitInfo get latest param for make batch tx.
      GetLimitInfo(ctx context.Context, in *LimitInfoRequest, opts ...grpc.CallOption) (*LimitInfoResponse, error)
      // CommitBatchTx used to commit batch tx to tx-sort-network
      CommitBatchTx(ctx context.Context, in *CommitBatchTxRequest, opts ...grpc.CallOption) (*CommitBatchTxResponse, error)
      // GetTxReceipt from tx-sort-network with txhash
      GetBatchTxResult(ctx context.Context, in *GetReceiptRequest, opts ...grpc.CallOption) (*GetReceiptResponse, error)
      //for validator
      // GetNewBlock used for nebula get new virtual block info from contract with lastblock.
      GetNewBlock(ctx context.Context, in *GetNewBlockRequest, opts ...grpc.CallOption) (*GetNewBlockResponse, error)
      // CommitBlock used for nebula commit new block and state info to contract.
      CommitBlock(ctx context.Context, in *CommitBlockRequest, opts ...grpc.CallOption) (*CommitBlockResponse, error)
      // GetConsensusedBlock used for nebula get special block consensus result.
      GetConfirmedBlock(ctx context.Context, in *GetConsensusedBlockRequest, opts ...grpc.CallOption) (*GetConsensusedBlockResponse, error)
      }
      type sentryServiceClient struct {
      cc grpc.ClientConnInterface
      }
      func NewSentryServiceClient(cc grpc.ClientConnInterface) SentryServiceClient {
      return &sentryServiceClient{cc}
      }
      func (c *sentryServiceClient) GetLimitInfo(ctx context.Context, in *LimitInfoRequest, opts ...grpc.CallOption) (*LimitInfoResponse, error) {
      out := new(LimitInfoResponse)
      err := c.cc.Invoke(ctx, "/sentry.v1.SentryService/GetLimitInfo", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *sentryServiceClient) CommitBatchTx(ctx context.Context, in *CommitBatchTxRequest, opts ...grpc.CallOption) (*CommitBatchTxResponse, error) {
      out := new(CommitBatchTxResponse)
      err := c.cc.Invoke(ctx, "/sentry.v1.SentryService/CommitBatchTx", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *sentryServiceClient) GetBatchTxResult(ctx context.Context, in *GetReceiptRequest, opts ...grpc.CallOption) (*GetReceiptResponse, error) {
      out := new(GetReceiptResponse)
      err := c.cc.Invoke(ctx, "/sentry.v1.SentryService/GetBatchTxResult", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *sentryServiceClient) GetNewBlock(ctx context.Context, in *GetNewBlockRequest, opts ...grpc.CallOption) (*GetNewBlockResponse, error) {
      out := new(GetNewBlockResponse)
      err := c.cc.Invoke(ctx, "/sentry.v1.SentryService/GetNewBlock", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *sentryServiceClient) CommitBlock(ctx context.Context, in *CommitBlockRequest, opts ...grpc.CallOption) (*CommitBlockResponse, error) {
      out := new(CommitBlockResponse)
      err := c.cc.Invoke(ctx, "/sentry.v1.SentryService/CommitBlock", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      func (c *sentryServiceClient) GetConfirmedBlock(ctx context.Context, in *GetConsensusedBlockRequest, opts ...grpc.CallOption) (*GetConsensusedBlockResponse, error) {
      out := new(GetConsensusedBlockResponse)
      err := c.cc.Invoke(ctx, "/sentry.v1.SentryService/GetConfirmedBlock", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      // SentryServiceServer is the server API for SentryService service.
      // All implementations must embed UnimplementedSentryServiceServer
      // for forward compatibility
      type SentryServiceServer interface {
      // for ring
      // LimitInfo get latest param for make batch tx.
      GetLimitInfo(context.Context, *LimitInfoRequest) (*LimitInfoResponse, error)
      // CommitBatchTx used to commit batch tx to tx-sort-network
      CommitBatchTx(context.Context, *CommitBatchTxRequest) (*CommitBatchTxResponse, error)
      // GetTxReceipt from tx-sort-network with txhash
      GetBatchTxResult(context.Context, *GetReceiptRequest) (*GetReceiptResponse, error)
      //for validator
      // GetNewBlock used for nebula get new virtual block info from contract with lastblock.
      GetNewBlock(context.Context, *GetNewBlockRequest) (*GetNewBlockResponse, error)
      // CommitBlock used for nebula commit new block and state info to contract.
      CommitBlock(context.Context, *CommitBlockRequest) (*CommitBlockResponse, error)
      // GetConsensusedBlock used for nebula get special block consensus result.
      GetConfirmedBlock(context.Context, *GetConsensusedBlockRequest) (*GetConsensusedBlockResponse, error)
      mustEmbedUnimplementedSentryServiceServer()
      }
      // UnimplementedSentryServiceServer must be embedded to have forward compatible implementations.
      type UnimplementedSentryServiceServer struct {
      }
      func (UnimplementedSentryServiceServer) GetLimitInfo(context.Context, *LimitInfoRequest) (*LimitInfoResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GetLimitInfo not implemented")
      }
      func (UnimplementedSentryServiceServer) CommitBatchTx(context.Context, *CommitBatchTxRequest) (*CommitBatchTxResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CommitBatchTx not implemented")
      }
      func (UnimplementedSentryServiceServer) GetBatchTxResult(context.Context, *GetReceiptRequest) (*GetReceiptResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GetBatchTxResult not implemented")
      }
      func (UnimplementedSentryServiceServer) GetNewBlock(context.Context, *GetNewBlockRequest) (*GetNewBlockResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GetNewBlock not implemented")
      }
      func (UnimplementedSentryServiceServer) CommitBlock(context.Context, *CommitBlockRequest) (*CommitBlockResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method CommitBlock not implemented")
      }
      func (UnimplementedSentryServiceServer) GetConfirmedBlock(context.Context, *GetConsensusedBlockRequest) (*GetConsensusedBlockResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method GetConfirmedBlock not implemented")
      }
      func (UnimplementedSentryServiceServer) mustEmbedUnimplementedSentryServiceServer() {}
      // UnsafeSentryServiceServer may be embedded to opt out of forward compatibility for this service.
      // Use of this interface is not recommended, as added methods to SentryServiceServer will
      // result in compilation errors.
      type UnsafeSentryServiceServer interface {
      mustEmbedUnimplementedSentryServiceServer()
      }
      func RegisterSentryServiceServer(s grpc.ServiceRegistrar, srv SentryServiceServer) {
      s.RegisterService(&SentryService_ServiceDesc, srv)
      }
      func _SentryService_GetLimitInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(LimitInfoRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(SentryServiceServer).GetLimitInfo(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/sentry.v1.SentryService/GetLimitInfo",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(SentryServiceServer).GetLimitInfo(ctx, req.(*LimitInfoRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _SentryService_CommitBatchTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CommitBatchTxRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(SentryServiceServer).CommitBatchTx(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/sentry.v1.SentryService/CommitBatchTx",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(SentryServiceServer).CommitBatchTx(ctx, req.(*CommitBatchTxRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _SentryService_GetBatchTxResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(GetReceiptRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(SentryServiceServer).GetBatchTxResult(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/sentry.v1.SentryService/GetBatchTxResult",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(SentryServiceServer).GetBatchTxResult(ctx, req.(*GetReceiptRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _SentryService_GetNewBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(GetNewBlockRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(SentryServiceServer).GetNewBlock(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/sentry.v1.SentryService/GetNewBlock",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(SentryServiceServer).GetNewBlock(ctx, req.(*GetNewBlockRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _SentryService_CommitBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(CommitBlockRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(SentryServiceServer).CommitBlock(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/sentry.v1.SentryService/CommitBlock",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(SentryServiceServer).CommitBlock(ctx, req.(*CommitBlockRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      func _SentryService_GetConfirmedBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(GetConsensusedBlockRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(SentryServiceServer).GetConfirmedBlock(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/sentry.v1.SentryService/GetConfirmedBlock",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(SentryServiceServer).GetConfirmedBlock(ctx, req.(*GetConsensusedBlockRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      // SentryService_ServiceDesc is the grpc.ServiceDesc for SentryService service.
      // It's only intended for direct use with grpc.RegisterService,
      // and not to be introspected or modified (even as a copy)
      var SentryService_ServiceDesc = grpc.ServiceDesc{
      ServiceName: "sentry.v1.SentryService",
      HandlerType: (*SentryServiceServer)(nil),
      Methods: []grpc.MethodDesc{
      {
      MethodName: "GetLimitInfo",
      Handler: _SentryService_GetLimitInfo_Handler,
      },
      {
      MethodName: "CommitBatchTx",
      Handler: _SentryService_CommitBatchTx_Handler,
      },
      {
      MethodName: "GetBatchTxResult",
      Handler: _SentryService_GetBatchTxResult_Handler,
      },
      {
      MethodName: "GetNewBlock",
      Handler: _SentryService_GetNewBlock_Handler,
      },
      {
      MethodName: "CommitBlock",
      Handler: _SentryService_CommitBlock_Handler,
      },
      {
      MethodName: "GetConfirmedBlock",
      Handler: _SentryService_GetConfirmedBlock_Handler,
      },
      },
      Streams: []grpc.StreamDesc{},
      Metadata: "sentry/v1/service.proto",
      }
      MetaProtocol-main/gen/proto/go/txchecker/v1/request_response.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: txchecker/v1/request_response.proto
      package txcheckerv1
      import (
      fmt "fmt"
      v1 "github.com/CaduceusMetaverseProtocol/MetaProtocol/gen/proto/go/base/v1"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      // The standard BatchGet request definition.
      type BatchCheckTxRequest struct {
      Txs []*v1.MetaTxBase `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchCheckTxRequest) Reset() { *m = BatchCheckTxRequest{} }
      func (m *BatchCheckTxRequest) String() string { return proto.CompactTextString(m) }
      func (*BatchCheckTxRequest) ProtoMessage() {}
      func (*BatchCheckTxRequest) Descriptor() ([]byte, []int) {
      return fileDescriptor_06c2bcfcfa17b24a, []int{0}
      }
      func (m *BatchCheckTxRequest) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchCheckTxRequest.Unmarshal(m, b)
      }
      func (m *BatchCheckTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchCheckTxRequest.Marshal(b, m, deterministic)
      }
      func (m *BatchCheckTxRequest) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchCheckTxRequest.Merge(m, src)
      }
      func (m *BatchCheckTxRequest) XXX_Size() int {
      return xxx_messageInfo_BatchCheckTxRequest.Size(m)
      }
      func (m *BatchCheckTxRequest) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchCheckTxRequest.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchCheckTxRequest proto.InternalMessageInfo
      func (m *BatchCheckTxRequest) GetTxs() []*v1.MetaTxBase {
      if m != nil {
      return m.Txs
      }
      return nil
      }
      // The standard BatchGet response definition.
      type BatchCheckTxResponse struct {
      // The retrieved shelves.
      CheckedTxs []*v1.MetaProofTx `protobuf:"bytes,1,rep,name=checked_txs,json=checkedTxs,proto3" json:"checked_txs,omitempty"`
      XXX_NoUnkeyedLiteral struct{} `json:"-"`
      XXX_unrecognized []byte `json:"-"`
      XXX_sizecache int32 `json:"-"`
      }
      func (m *BatchCheckTxResponse) Reset() { *m = BatchCheckTxResponse{} }
      func (m *BatchCheckTxResponse) String() string { return proto.CompactTextString(m) }
      func (*BatchCheckTxResponse) ProtoMessage() {}
      func (*BatchCheckTxResponse) Descriptor() ([]byte, []int) {
      return fileDescriptor_06c2bcfcfa17b24a, []int{1}
      }
      func (m *BatchCheckTxResponse) XXX_Unmarshal(b []byte) error {
      return xxx_messageInfo_BatchCheckTxResponse.Unmarshal(m, b)
      }
      func (m *BatchCheckTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
      return xxx_messageInfo_BatchCheckTxResponse.Marshal(b, m, deterministic)
      }
      func (m *BatchCheckTxResponse) XXX_Merge(src proto.Message) {
      xxx_messageInfo_BatchCheckTxResponse.Merge(m, src)
      }
      func (m *BatchCheckTxResponse) XXX_Size() int {
      return xxx_messageInfo_BatchCheckTxResponse.Size(m)
      }
      func (m *BatchCheckTxResponse) XXX_DiscardUnknown() {
      xxx_messageInfo_BatchCheckTxResponse.DiscardUnknown(m)
      }
      var xxx_messageInfo_BatchCheckTxResponse proto.InternalMessageInfo
      func (m *BatchCheckTxResponse) GetCheckedTxs() []*v1.MetaProofTx {
      if m != nil {
      return m.CheckedTxs
      }
      return nil
      }
      func init() {
      proto.RegisterType((*BatchCheckTxRequest)(nil), "txchecker.v1.BatchCheckTxRequest")
      proto.RegisterType((*BatchCheckTxResponse)(nil), "txchecker.v1.BatchCheckTxResponse")
      }
      func init() {
      proto.RegisterFile("txchecker/v1/request_response.proto", fileDescriptor_06c2bcfcfa17b24a)
      }
      var fileDescriptor_06c2bcfcfa17b24a = []byte{
      // 292 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xcf, 0x4a, 0xc3, 0x30,
      0x1c, 0xc7, 0x59, 0x07, 0x1e, 0xb2, 0x09, 0xd2, 0xf5, 0x30, 0x3c, 0xc9, 0x44, 0xf0, 0x94, 0x10,
      0xc5, 0xcb, 0xf4, 0xd4, 0x1d, 0x3c, 0x0d, 0x4a, 0x09, 0x75, 0xc8, 0x60, 0xa4, 0xe9, 0xcf, 0x56,
      0xb4, 0xcb, 0x4c, 0xd2, 0x92, 0xe7, 0xf1, 0xe8, 0xa3, 0x78, 0xf4, 0x11, 0x3c, 0xfa, 0x14, 0x92,
      0xb5, 0xd6, 0xee, 0xf8, 0xe5, 0xf7, 0xf9, 0xfe, 0x49, 0xd0, 0xb9, 0xb1, 0xa2, 0x00, 0xf1, 0x02,
      0x8a, 0xd4, 0x94, 0x28, 0x78, 0xab, 0x40, 0x9b, 0x8d, 0x02, 0xbd, 0x93, 0x5b, 0x0d, 0x78, 0xa7,
      0xa4, 0x91, 0xfe, 0xb8, 0x83, 0x70, 0x4d, 0x4f, 0xfd, 0x94, 0x6b, 0x70, 0x74, 0x09, 0x86, 0x37,
      0xc4, 0xec, 0x0e, 0x4d, 0x42, 0x6e, 0x44, 0xb1, 0x70, 0x18, 0xb3, 0x71, 0x93, 0xe3, 0x5f, 0xa0,
      0xa1, 0xb1, 0x7a, 0x3a, 0x38, 0x1b, 0x5e, 0x8e, 0xae, 0x26, 0xd8, 0x19, 0x71, 0x4d, 0xf1, 0x12,
      0x0c, 0x67, 0x36, 0xe4, 0x1a, 0x62, 0x77, 0x9f, 0x2d, 0x51, 0x70, 0xe8, 0x6e, 0xda, 0xfd, 0x1b,
      0x34, 0x6a, 0x7a, 0xb3, 0xcd, 0x7f, 0x4c, 0x70, 0x10, 0x13, 0x29, 0x29, 0x9f, 0x98, 0x8d, 0x51,
      0x0b, 0x32, 0xab, 0xc3, 0xaf, 0x01, 0x3a, 0x11, 0xb2, 0xc4, 0xfd, 0xd5, 0x61, 0xd0, 0x6e, 0xfa,
      0x0b, 0x8f, 0xdc, 0xee, 0x68, 0xf0, 0xf8, 0x90, 0x3f, 0x9b, 0xa2, 0x4a, 0xb1, 0x90, 0x25, 0x59,
      0xf0, 0xac, 0x12, 0x50, 0x69, 0x17, 0x5c, 0x83, 0x6a, 0x21, 0x21, 0x5f, 0x49, 0x5b, 0xd5, 0x88,
      0x1c, 0xb6, 0x64, 0xff, 0x6c, 0x92, 0x4b, 0xd2, 0xff, 0xbf, 0xdb, 0x4e, 0xd4, 0xf4, 0xdd, 0x1b,
      0xb2, 0xd5, 0xea, 0xc3, 0x1b, 0xb3, 0x6e, 0x45, 0x42, 0x3f, 0x7b, 0x72, 0x9d, 0xd0, 0x6f, 0x6f,
      0xda, 0x97, 0xeb, 0xfb, 0x28, 0x74, 0x45, 0x19, 0x37, 0xfc, 0xc7, 0x3b, 0xee, 0x4e, 0xf3, 0x79,
      0x42, 0xd3, 0xa3, 0x7d, 0xe3, 0xf5, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf6, 0xd4, 0x5a, 0x76,
      0xb1, 0x01, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/txchecker/v1/resource.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: txchecker/v1/resource.proto
      package txcheckerv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("txchecker/v1/resource.proto", fileDescriptor_9d5e09e8fd871530) }
      var fileDescriptor_9d5e09e8fd871530 = []byte{
      // 186 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2e, 0xa9, 0x48, 0xce,
      0x48, 0x4d, 0xce, 0x4e, 0x2d, 0xd2, 0x2f, 0x33, 0xd4, 0x2f, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a,
      0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x81, 0x4b, 0xea, 0x95, 0x19, 0x3a, 0x9d,
      0x66, 0xe4, 0x12, 0x48, 0xce, 0xcf, 0xd5, 0x43, 0x11, 0xe4, 0x0d, 0x82, 0x6a, 0x09, 0x00, 0xe9,
      0x08, 0x60, 0x8c, 0x0a, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x77,
      0x4e, 0x4c, 0x29, 0x4d, 0x4e, 0x2d, 0x2d, 0xf6, 0x4d, 0x2d, 0x49, 0x2c, 0x4b, 0x2d, 0x2a, 0x86,
      0x28, 0x4a, 0xce, 0xcf, 0xd1, 0x07, 0x89, 0xc0, 0x39, 0xe9, 0xa9, 0x79, 0xfa, 0x60, 0x0b, 0xf5,
      0xd3, 0xf3, 0xf5, 0x91, 0xdd, 0x63, 0x0d, 0xe7, 0x94, 0x19, 0x2e, 0x62, 0x62, 0x0e, 0x89, 0x88,
      0x58, 0xc5, 0xc4, 0x13, 0x02, 0xb7, 0x3e, 0xcc, 0xf0, 0x14, 0x12, 0x37, 0x26, 0xcc, 0xf0, 0x11,
      0x93, 0x04, 0x32, 0x37, 0xc6, 0x3d, 0xc0, 0x09, 0x64, 0x51, 0x4a, 0x62, 0x49, 0xe2, 0x2b, 0x26,
      0x5e, 0xb8, 0x94, 0x95, 0x55, 0x98, 0x61, 0x12, 0x1b, 0xd8, 0x46, 0x63, 0x40, 0x00, 0x00, 0x00,
      0xff, 0xff, 0x0d, 0x12, 0x33, 0x32, 0x01, 0x01, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/txchecker/v1/service.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-gogo. DO NOT EDIT.
      // source: txchecker/v1/service.proto
      package txcheckerv1
      import (
      fmt "fmt"
      proto "github.com/gogo/protobuf/proto"
      math "math"
      )
      // Reference imports to suppress errors if they are not otherwise used.
      var _ = proto.Marshal
      var _ = fmt.Errorf
      var _ = math.Inf
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the proto package it is being compiled against.
      // A compilation error at this line likely means your copy of the
      // proto package needs to be updated.
      const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
      func init() { proto.RegisterFile("txchecker/v1/service.proto", fileDescriptor_879a31c9059be40b) }
      var fileDescriptor_879a31c9059be40b = []byte{
      // 250 bytes of a gzipped FileDescriptorProto
      0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2a, 0xa9, 0x48, 0xce,
      0x48, 0x4d, 0xce, 0x4e, 0x2d, 0xd2, 0x2f, 0x33, 0xd4, 0x2f, 0x4e, 0x2d, 0x2a, 0xcb, 0x4c, 0x4e,
      0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x81, 0xcb, 0xe9, 0x95, 0x19, 0x4a, 0x29, 0xa3,
      0xa8, 0x2c, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x89, 0x2f, 0x4a, 0x2d, 0x2e, 0xc8, 0xcf, 0x2b,
      0x86, 0x6a, 0x31, 0xca, 0xe6, 0x12, 0x08, 0xa9, 0x70, 0x86, 0x28, 0x0b, 0x86, 0x18, 0x26, 0x14,
      0xce, 0xc5, 0xe3, 0x94, 0x58, 0x92, 0x9c, 0x01, 0x16, 0x0e, 0xa9, 0x10, 0x52, 0xd4, 0x43, 0x36,
      0x57, 0x0f, 0x59, 0x2e, 0x08, 0x62, 0xaa, 0x94, 0x12, 0x3e, 0x25, 0x10, 0x0b, 0x95, 0x18, 0x9c,
      0x4e, 0x31, 0x72, 0x09, 0x24, 0xe7, 0xe7, 0xa2, 0xa8, 0x75, 0xe2, 0x81, 0x5a, 0x1b, 0x00, 0x72,
      0x4f, 0x00, 0x63, 0x54, 0x78, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0xbe,
      0x73, 0x62, 0x4a, 0x69, 0x72, 0x6a, 0x69, 0xb1, 0x6f, 0x6a, 0x49, 0x62, 0x59, 0x6a, 0x51, 0x31,
      0x44, 0x51, 0x72, 0x7e, 0x8e, 0x3e, 0x48, 0x04, 0xce, 0x49, 0x4f, 0xcd, 0xd3, 0x07, 0x7b, 0x47,
      0x3f, 0x3d, 0x5f, 0x1f, 0xd9, 0xd7, 0xd6, 0x70, 0x4e, 0x99, 0xe1, 0x22, 0x26, 0xe6, 0x90, 0x88,
      0x88, 0x55, 0x4c, 0x3c, 0x21, 0x70, 0xdb, 0xc3, 0x0c, 0x4f, 0x21, 0x71, 0x63, 0xc2, 0x0c, 0x1f,
      0x31, 0x49, 0x20, 0x73, 0x63, 0xdc, 0x03, 0x9c, 0x40, 0x16, 0xa5, 0x24, 0x96, 0x24, 0xbe, 0x62,
      0xe2, 0x85, 0x4b, 0x59, 0x59, 0x85, 0x19, 0x26, 0xb1, 0x81, 0x6d, 0x34, 0x06, 0x04, 0x00, 0x00,
      0xff, 0xff, 0x3f, 0xfc, 0x46, 0x30, 0x91, 0x01, 0x00, 0x00,
      }
      MetaProtocol-main/gen/proto/go/txchecker/v1/service_grpc.pb.go 0 → 100644
      View file @ 9234b25c
      // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
      // versions:
      // - protoc-gen-go-grpc v1.2.0
      // - protoc (unknown)
      // source: txchecker/v1/service.proto
      package txcheckerv1
      import (
      context "context"
      grpc "google.golang.org/grpc"
      codes "google.golang.org/grpc/codes"
      status "google.golang.org/grpc/status"
      )
      // This is a compile-time assertion to ensure that this generated file
      // is compatible with the grpc package it is being compiled against.
      // Requires gRPC-Go v1.32.0 or later.
      const _ = grpc.SupportPackageIsVersion7
      // TxCheckerServiceClient is the client API for TxCheckerService service.
      //
      // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
      type TxCheckerServiceClient interface {
      BatchCheckTx(ctx context.Context, in *BatchCheckTxRequest, opts ...grpc.CallOption) (*BatchCheckTxResponse, error)
      }
      type txCheckerServiceClient struct {
      cc grpc.ClientConnInterface
      }
      func NewTxCheckerServiceClient(cc grpc.ClientConnInterface) TxCheckerServiceClient {
      return &txCheckerServiceClient{cc}
      }
      func (c *txCheckerServiceClient) BatchCheckTx(ctx context.Context, in *BatchCheckTxRequest, opts ...grpc.CallOption) (*BatchCheckTxResponse, error) {
      out := new(BatchCheckTxResponse)
      err := c.cc.Invoke(ctx, "/txchecker.v1.TxCheckerService/BatchCheckTx", in, out, opts...)
      if err != nil {
      return nil, err
      }
      return out, nil
      }
      // TxCheckerServiceServer is the server API for TxCheckerService service.
      // All implementations must embed UnimplementedTxCheckerServiceServer
      // for forward compatibility
      type TxCheckerServiceServer interface {
      BatchCheckTx(context.Context, *BatchCheckTxRequest) (*BatchCheckTxResponse, error)
      mustEmbedUnimplementedTxCheckerServiceServer()
      }
      // UnimplementedTxCheckerServiceServer must be embedded to have forward compatible implementations.
      type UnimplementedTxCheckerServiceServer struct {
      }
      func (UnimplementedTxCheckerServiceServer) BatchCheckTx(context.Context, *BatchCheckTxRequest) (*BatchCheckTxResponse, error) {
      return nil, status.Errorf(codes.Unimplemented, "method BatchCheckTx not implemented")
      }
      func (UnimplementedTxCheckerServiceServer) mustEmbedUnimplementedTxCheckerServiceServer() {}
      // UnsafeTxCheckerServiceServer may be embedded to opt out of forward compatibility for this service.
      // Use of this interface is not recommended, as added methods to TxCheckerServiceServer will
      // result in compilation errors.
      type UnsafeTxCheckerServiceServer interface {
      mustEmbedUnimplementedTxCheckerServiceServer()
      }
      func RegisterTxCheckerServiceServer(s grpc.ServiceRegistrar, srv TxCheckerServiceServer) {
      s.RegisterService(&TxCheckerService_ServiceDesc, srv)
      }
      func _TxCheckerService_BatchCheckTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
      in := new(BatchCheckTxRequest)
      if err := dec(in); err != nil {
      return nil, err
      }
      if interceptor == nil {
      return srv.(TxCheckerServiceServer).BatchCheckTx(ctx, in)
      }
      info := &grpc.UnaryServerInfo{
      Server: srv,
      FullMethod: "/txchecker.v1.TxCheckerService/BatchCheckTx",
      }
      handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(TxCheckerServiceServer).BatchCheckTx(ctx, req.(*BatchCheckTxRequest))
      }
      return interceptor(ctx, in, info, handler)
      }
      // TxCheckerService_ServiceDesc is the grpc.ServiceDesc for TxCheckerService service.
      // It's only intended for direct use with grpc.RegisterService,
      // and not to be introspected or modified (even as a copy)
      var TxCheckerService_ServiceDesc = grpc.ServiceDesc{
      ServiceName: "txchecker.v1.TxCheckerService",
      HandlerType: (*TxCheckerServiceServer)(nil),
      Methods: []grpc.MethodDesc{
      {
      MethodName: "BatchCheckTx",
      Handler: _TxCheckerService_BatchCheckTx_Handler,
      },
      },
      Streams: []grpc.StreamDesc{},
      Metadata: "txchecker/v1/service.proto",
      }
      Markdown is supported
      0% or
      You are about to add 0 people to the discussion. Proceed with caution.
      Finish editing this message first!
      Please register or to comment