diff --git a/CHANGELOG.md b/CHANGELOG.md index 36dbb5e4f..1583c19f5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -31,6 +31,9 @@ Types of changes (Stanzas): Ref: https://keepachangelog.com/en/1.0.0/ --> # Changelog +## [Unreleased] +### Bug fixes +* (wasm) [#259](https://github.com/classic-terra/core/pull/259) add legacy wasm types ## [v2.1.1](https://github.com/classic-terra/core/releases/tag/v2.1.1) - Jun 10, 2023 ### State Machine Breaking diff --git a/contrib/localnet/simulation/misc/cw721_base.wasm b/contrib/localnet/simulation/misc/cw721_base.wasm index 19b1743ab..52721d549 100644 Binary files a/contrib/localnet/simulation/misc/cw721_base.wasm and b/contrib/localnet/simulation/misc/cw721_base.wasm differ diff --git a/custom/auth/tx/service.pb.go b/custom/auth/tx/service.pb.go index c1a66334c..72f0375d3 100644 --- a/custom/auth/tx/service.pb.go +++ b/custom/auth/tx/service.pb.go @@ -6,6 +6,10 @@ package tx import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" types "github.com/cosmos/cosmos-sdk/types" tx "github.com/cosmos/cosmos-sdk/types/tx" @@ -17,16 +21,15 @@ import ( grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = golang_proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = golang_proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -50,9 +53,11 @@ func (*ComputeTaxRequest) ProtoMessage() {} func (*ComputeTaxRequest) Descriptor() ([]byte, []int) { return fileDescriptor_0b3c73e5d85273f4, []int{0} } + func (m *ComputeTaxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ComputeTaxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ComputeTaxRequest.Marshal(b, m, deterministic) @@ -65,12 +70,15 @@ func (m *ComputeTaxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } + func (m *ComputeTaxRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ComputeTaxRequest.Merge(m, src) } + func (m *ComputeTaxRequest) XXX_Size() int { return m.Size() } + func (m *ComputeTaxRequest) XXX_DiscardUnknown() { xxx_messageInfo_ComputeTaxRequest.DiscardUnknown(m) } @@ -105,9 +113,11 @@ func (*ComputeTaxResponse) ProtoMessage() {} func (*ComputeTaxResponse) Descriptor() ([]byte, []int) { return fileDescriptor_0b3c73e5d85273f4, []int{1} } + func (m *ComputeTaxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ComputeTaxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ComputeTaxResponse.Marshal(b, m, deterministic) @@ -120,12 +130,15 @@ func (m *ComputeTaxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *ComputeTaxResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ComputeTaxResponse.Merge(m, src) } + func (m *ComputeTaxResponse) XXX_Size() int { return m.Size() } + func (m *ComputeTaxResponse) XXX_DiscardUnknown() { xxx_messageInfo_ComputeTaxResponse.DiscardUnknown(m) } @@ -182,8 +195,10 @@ var fileDescriptor_0b3c73e5d85273f4 = []byte{ } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ grpc.ClientConn +) // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. @@ -221,8 +236,7 @@ type ServiceServer interface { } // UnimplementedServiceServer can be embedded to have forward compatible implementations. -type UnimplementedServiceServer struct { -} +type UnimplementedServiceServer struct{} func (*UnimplementedServiceServer) ComputeTax(ctx context.Context, req *ComputeTaxRequest) (*ComputeTaxResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ComputeTax not implemented") @@ -353,6 +367,7 @@ func encodeVarintService(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *ComputeTaxRequest) Size() (n int) { if m == nil { return 0 @@ -388,9 +403,11 @@ func (m *ComputeTaxResponse) Size() (n int) { func sovService(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozService(x uint64) (n int) { return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *ComputeTaxRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -511,6 +528,7 @@ func (m *ComputeTaxRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *ComputeTaxResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -595,6 +613,7 @@ func (m *ComputeTaxResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipService(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/custom/auth/tx/service.pb.gw.go b/custom/auth/tx/service.pb.gw.go index 5aee1553a..0c636666e 100644 --- a/custom/auth/tx/service.pb.gw.go +++ b/custom/auth/tx/service.pb.gw.go @@ -25,13 +25,15 @@ import ( ) // Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = descriptor.ForMessage -var _ = metadata.Join +var ( + _ codes.Code + _ io.Reader + _ status.Status + _ = runtime.String + _ = utilities.NewDoubleArray + _ = descriptor.ForMessage + _ = metadata.Join +) func request_Service_ComputeTax_0(ctx context.Context, marshaler runtime.Marshaler, client ServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq ComputeTaxRequest @@ -47,7 +49,6 @@ func request_Service_ComputeTax_0(ctx context.Context, marshaler runtime.Marshal msg, err := client.ComputeTax(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Service_ComputeTax_0(ctx context.Context, marshaler runtime.Marshaler, server ServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -64,7 +65,6 @@ func local_request_Service_ComputeTax_0(ctx context.Context, marshaler runtime.M msg, err := server.ComputeTax(ctx, &protoReq) return msg, metadata, err - } // RegisterServiceHandlerServer registers the http handlers for service Service to "mux". @@ -72,7 +72,6 @@ func local_request_Service_ComputeTax_0(ctx context.Context, marshaler runtime.M // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServiceHandlerFromEndpoint instead. func RegisterServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServiceServer) error { - mux.Handle("POST", pattern_Service_ComputeTax_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -93,7 +92,6 @@ func RegisterServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, se } forward_Service_ComputeTax_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil @@ -136,7 +134,6 @@ func RegisterServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *gr // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in // "ServiceClient" to call the correct interceptors. func RegisterServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServiceClient) error { - mux.Handle("POST", pattern_Service_ComputeTax_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -154,16 +151,11 @@ func RegisterServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, cl } forward_Service_ComputeTax_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil } -var ( - pattern_Service_ComputeTax_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"terra", "tx", "v1beta1", "compute_tax"}, "", runtime.AssumeColonVerbOpt(false))) -) +var pattern_Service_ComputeTax_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"terra", "tx", "v1beta1", "compute_tax"}, "", runtime.AssumeColonVerbOpt(false))) -var ( - forward_Service_ComputeTax_0 = runtime.ForwardResponseMessage -) +var forward_Service_ComputeTax_0 = runtime.ForwardResponseMessage diff --git a/custom/wasm/module.go b/custom/wasm/module.go index e777cc51a..0705c5b19 100644 --- a/custom/wasm/module.go +++ b/custom/wasm/module.go @@ -3,17 +3,19 @@ package wasm import ( "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" + cdctypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/types/module" "github.com/gorilla/mux" "github.com/spf13/cobra" "github.com/CosmWasm/wasmd/x/wasm" "github.com/CosmWasm/wasmd/x/wasm/keeper" + "github.com/CosmWasm/wasmd/x/wasm/simulation" + "github.com/CosmWasm/wasmd/x/wasm/types" customcli "github.com/classic-terra/core/v2/custom/wasm/client/cli" customrest "github.com/classic-terra/core/v2/custom/wasm/client/rest" - "github.com/classic-terra/core/v2/custom/wasm/simulation" - "github.com/classic-terra/core/v2/x/market/types" + customtypes "github.com/classic-terra/core/v2/custom/wasm/types/legacy" ) var _ module.AppModuleBasic = AppModuleBasic{} @@ -28,6 +30,13 @@ func (AppModuleBasic) RegisterRESTRoutes(cliCtx client.Context, rtr *mux.Router) customrest.RegisterRoutes(cliCtx, rtr) } +// RegisterInterfaces implements InterfaceModule +func (b AppModuleBasic) RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + // register canonical wasm types + types.RegisterInterfaces(registry) + customtypes.RegisterInterfaces(registry) +} + // GetTxCmd returns the root tx command for the wasm module. func (b AppModuleBasic) GetTxCmd() *cobra.Command { return customcli.GetTxCmd() diff --git a/custom/wasm/types/legacy/codec.go b/custom/wasm/types/legacy/codec.go new file mode 100644 index 000000000..23f1ab6da --- /dev/null +++ b/custom/wasm/types/legacy/codec.go @@ -0,0 +1,48 @@ +package legacy + +import ( + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/codec/types" + cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +// RegisterLegacyAminoCodec registers the wasm types and interface +func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgStoreCode{}, "wasm/MsgStoreCode", nil) + cdc.RegisterConcrete(&MsgMigrateCode{}, "wasm/MsgMigrateCode", nil) + cdc.RegisterConcrete(&MsgInstantiateContract{}, "wasm/MsgInstantiateContract", nil) + cdc.RegisterConcrete(&MsgExecuteContract{}, "wasm/MsgExecuteContract", nil) + cdc.RegisterConcrete(&MsgMigrateContract{}, "wasm/MsgMigrateContract", nil) + cdc.RegisterConcrete(&MsgUpdateContractAdmin{}, "wasm/MsgUpdateContractAdmin", nil) + cdc.RegisterConcrete(&MsgClearContractAdmin{}, "wasm/MsgClearContractAdmin", nil) +} + +func RegisterInterfaces(registry types.InterfaceRegistry) { + // register legacy wasm msgs (to be used in archives) + registry.RegisterInterface("terra.wasm.v1beta1.MsgInstantiateContract", (*sdk.Msg)(nil), &MsgInstantiateContract{}) + registry.RegisterInterface("terra.wasm.v1beta1.MsgExecuteContract", (*sdk.Msg)(nil), &MsgExecuteContract{}) + registry.RegisterInterface("terra.wasm.v1beta1.MsgStoreCode", (*sdk.Msg)(nil), &MsgStoreCode{}) + registry.RegisterInterface("terra.wasm.v1beta1.MsgExecuteContract", (*sdk.Msg)(nil), &MsgMigrateCode{}) + registry.RegisterInterface("terra.wasm.v1beta1.MsgMigrateCode", (*sdk.Msg)(nil), &MsgMigrateContract{}) + registry.RegisterInterface("terra.wasm.v1beta1.MsgUpdateContractAdmin", (*sdk.Msg)(nil), &MsgUpdateContractAdmin{}) + registry.RegisterInterface("terra.wasm.v1beta1.MsgClearContractAdmin", (*sdk.Msg)(nil), &MsgClearContractAdmin{}) +} + +var ( + amino = codec.NewLegacyAmino() + + // ModuleCdc references the global x/market module codec. Note, the codec should + // ONLY be used in certain instances of tests and for JSON encoding as Amino is + // still used for that purpose. + // + // The actual codec used for serialization should be provided to x/staking and + // defined at the application level. + ModuleCdc = codec.NewAminoCodec(amino) +) + +func init() { + RegisterLegacyAminoCodec(amino) + cryptocodec.RegisterCrypto(amino) + amino.Seal() +} diff --git a/custom/wasm/types/legacy/genesis.pb.go b/custom/wasm/types/legacy/genesis.pb.go new file mode 100644 index 000000000..c99a6afa5 --- /dev/null +++ b/custom/wasm/types/legacy/genesis.pb.go @@ -0,0 +1,867 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: terra/wasm/v1beta1/genesis.proto + +package legacy + +import ( + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/gogo/protobuf/proto" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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 + +// Model is a struct that holds a KV pair +type Model struct { + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *Model) Reset() { *m = Model{} } +func (m *Model) String() string { return proto.CompactTextString(m) } +func (*Model) ProtoMessage() {} +func (*Model) Descriptor() ([]byte, []int) { + return fileDescriptor_bd15c5bc3571c951, []int{0} +} + +func (m *Model) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *Model) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Model.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *Model) XXX_Merge(src proto.Message) { + xxx_messageInfo_Model.Merge(m, src) +} + +func (m *Model) XXX_Size() int { + return m.Size() +} + +func (m *Model) XXX_DiscardUnknown() { + xxx_messageInfo_Model.DiscardUnknown(m) +} + +var xxx_messageInfo_Model proto.InternalMessageInfo + +func (m *Model) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func (m *Model) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// Code struct encompasses CodeInfo and CodeBytes +type Code struct { + CodeInfo LegacyCodeInfo `protobuf:"bytes,1,opt,name=code_info,json=codeInfo,proto3" json:"code_info"` + CodeBytes []byte `protobuf:"bytes,2,opt,name=code_bytes,json=codeBytes,proto3" json:"code_bytes,omitempty"` +} + +func (m *Code) Reset() { *m = Code{} } +func (m *Code) String() string { return proto.CompactTextString(m) } +func (*Code) ProtoMessage() {} +func (*Code) Descriptor() ([]byte, []int) { + return fileDescriptor_bd15c5bc3571c951, []int{1} +} + +func (m *Code) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *Code) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Code.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *Code) XXX_Merge(src proto.Message) { + xxx_messageInfo_Code.Merge(m, src) +} + +func (m *Code) XXX_Size() int { + return m.Size() +} + +func (m *Code) XXX_DiscardUnknown() { + xxx_messageInfo_Code.DiscardUnknown(m) +} + +var xxx_messageInfo_Code proto.InternalMessageInfo + +func (m *Code) GetCodeInfo() LegacyCodeInfo { + if m != nil { + return m.CodeInfo + } + return LegacyCodeInfo{} +} + +func (m *Code) GetCodeBytes() []byte { + if m != nil { + return m.CodeBytes + } + return nil +} + +// Contract struct encompasses ContractAddress, ContractInfo, and ContractState +type Contract struct { + ContractInfo LegacyContractInfo `protobuf:"bytes,1,opt,name=contract_info,json=contractInfo,proto3" json:"contract_info"` + ContractStore []Model `protobuf:"bytes,2,rep,name=contract_store,json=contractStore,proto3" json:"contract_store"` +} + +func (m *Contract) Reset() { *m = Contract{} } +func (m *Contract) String() string { return proto.CompactTextString(m) } +func (*Contract) ProtoMessage() {} +func (*Contract) Descriptor() ([]byte, []int) { + return fileDescriptor_bd15c5bc3571c951, []int{2} +} + +func (m *Contract) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *Contract) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Contract.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *Contract) XXX_Merge(src proto.Message) { + xxx_messageInfo_Contract.Merge(m, src) +} + +func (m *Contract) XXX_Size() int { + return m.Size() +} + +func (m *Contract) XXX_DiscardUnknown() { + xxx_messageInfo_Contract.DiscardUnknown(m) +} + +var xxx_messageInfo_Contract proto.InternalMessageInfo + +func (m *Contract) GetContractInfo() LegacyContractInfo { + if m != nil { + return m.ContractInfo + } + return LegacyContractInfo{} +} + +func (m *Contract) GetContractStore() []Model { + if m != nil { + return m.ContractStore + } + return nil +} + +func init() { + proto.RegisterType((*Model)(nil), "terra.wasm.v1beta1.Model") + proto.RegisterType((*Code)(nil), "terra.wasm.v1beta1.Code") + proto.RegisterType((*Contract)(nil), "terra.wasm.v1beta1.Contract") +} + +func init() { proto.RegisterFile("terra/wasm/v1beta1/genesis.proto", fileDescriptor_bd15c5bc3571c951) } + +var fileDescriptor_bd15c5bc3571c951 = []byte{ + // 336 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x51, 0xcb, 0x4e, 0xf2, 0x40, + 0x14, 0x6e, 0x7f, 0xe0, 0x0f, 0x0e, 0x68, 0xcc, 0x84, 0x05, 0x92, 0x50, 0x49, 0x17, 0x86, 0x8d, + 0x9d, 0x80, 0x2b, 0xb7, 0x10, 0x4d, 0x4c, 0x74, 0x21, 0xec, 0xdc, 0x98, 0xe9, 0x70, 0xa8, 0x8d, + 0xa5, 0x87, 0xcc, 0x0c, 0x98, 0xbe, 0x85, 0x2f, 0xe1, 0xbb, 0xb0, 0x64, 0xe9, 0xca, 0x18, 0x78, + 0x11, 0x33, 0xd3, 0x86, 0x90, 0x48, 0xdc, 0x9d, 0xcb, 0x77, 0x39, 0x33, 0x1f, 0xe9, 0x68, 0x90, + 0x92, 0xb3, 0x37, 0xae, 0x66, 0x6c, 0xd9, 0x0b, 0x41, 0xf3, 0x1e, 0x8b, 0x20, 0x05, 0x15, 0xab, + 0x60, 0x2e, 0x51, 0x23, 0xa5, 0x16, 0x11, 0x18, 0x44, 0x50, 0x20, 0x5a, 0x8d, 0x08, 0x23, 0xb4, + 0x6b, 0x66, 0xaa, 0x1c, 0xd9, 0x6a, 0x1f, 0xd0, 0xb2, 0x34, 0xbb, 0xf6, 0x19, 0xa9, 0x3c, 0xe0, + 0x04, 0x12, 0x7a, 0x4a, 0x4a, 0xaf, 0x90, 0x35, 0xdd, 0x8e, 0xdb, 0xad, 0x8f, 0x4c, 0x49, 0x1b, + 0xa4, 0xb2, 0xe4, 0xc9, 0x02, 0x9a, 0xff, 0xec, 0x2c, 0x6f, 0xfc, 0x84, 0x94, 0x87, 0x38, 0x01, + 0x7a, 0x43, 0x8e, 0x04, 0x4e, 0xe0, 0x39, 0x4e, 0xa7, 0x68, 0x59, 0xb5, 0xbe, 0x1f, 0xfc, 0xbe, + 0x2a, 0xb8, 0x87, 0x88, 0x8b, 0xcc, 0x50, 0xee, 0xd2, 0x29, 0x0e, 0xca, 0xab, 0xaf, 0x73, 0x67, + 0x54, 0x15, 0x45, 0x4f, 0xdb, 0x84, 0x58, 0x99, 0x30, 0xd3, 0xa0, 0x0a, 0x27, 0x2b, 0x3c, 0x30, + 0x03, 0xff, 0xc3, 0x25, 0xd5, 0x21, 0xa6, 0x5a, 0x72, 0xa1, 0xe9, 0x23, 0x39, 0x16, 0x45, 0xbd, + 0x6f, 0x7b, 0xf1, 0x97, 0x6d, 0x0e, 0xdf, 0xb3, 0xae, 0x8b, 0xbd, 0x19, 0xbd, 0x25, 0x27, 0x3b, + 0x49, 0xa5, 0x51, 0x9a, 0xc7, 0x96, 0xba, 0xb5, 0xfe, 0xd9, 0x21, 0x4d, 0xfb, 0x51, 0x85, 0xcc, + 0xee, 0x92, 0xb1, 0x61, 0x0d, 0xc6, 0xab, 0x8d, 0xe7, 0xae, 0x37, 0x9e, 0xfb, 0xbd, 0xf1, 0xdc, + 0xf7, 0xad, 0xe7, 0xac, 0xb7, 0x9e, 0xf3, 0xb9, 0xf5, 0x9c, 0xa7, 0xeb, 0x28, 0xd6, 0x2f, 0x8b, + 0x30, 0x10, 0x38, 0x63, 0x22, 0xe1, 0x4a, 0xc5, 0xe2, 0x32, 0x8f, 0x44, 0xa0, 0x04, 0xb6, 0xec, + 0x33, 0xb1, 0x50, 0x1a, 0x67, 0x79, 0x42, 0x3a, 0x9b, 0x83, 0x62, 0x89, 0x3d, 0x3e, 0xfc, 0x6f, + 0x23, 0xba, 0xfa, 0x09, 0x00, 0x00, 0xff, 0xff, 0x21, 0x1c, 0x42, 0xea, 0x0f, 0x02, 0x00, 0x00, +} + +func (m *Model) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Model) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Model) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Code) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Code) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Code) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.CodeBytes) > 0 { + i -= len(m.CodeBytes) + copy(dAtA[i:], m.CodeBytes) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.CodeBytes))) + i-- + dAtA[i] = 0x12 + } + { + size, err := m.CodeInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Contract) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Contract) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Contract) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ContractStore) > 0 { + for iNdEx := len(m.ContractStore) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ContractStore[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.ContractInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} + +func (m *Model) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + return n +} + +func (m *Code) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.CodeInfo.Size() + n += 1 + l + sovGenesis(uint64(l)) + l = len(m.CodeBytes) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + return n +} + +func (m *Contract) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ContractInfo.Size() + n += 1 + l + sovGenesis(uint64(l)) + if len(m.ContractStore) > 0 { + for _, e := range m.ContractStore { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} + +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func (m *Model) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Model: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Model: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *Code) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Code: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Code: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CodeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CodeBytes = append(m.CodeBytes[:0], dAtA[iNdEx:postIndex]...) + if m.CodeBytes == nil { + m.CodeBytes = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *Contract) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Contract: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Contract: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ContractInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractStore", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractStore = append(m.ContractStore, Model{}) + if err := m.ContractStore[len(m.ContractStore)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func skipGenesis(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/custom/wasm/types/legacy/msgs.go b/custom/wasm/types/legacy/msgs.go new file mode 100644 index 000000000..e6b5879d9 --- /dev/null +++ b/custom/wasm/types/legacy/msgs.go @@ -0,0 +1,429 @@ +package legacy + +import ( + "encoding/json" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + + wasm "github.com/CosmWasm/wasmd/x/wasm" +) + +// ensure Msg interface compliance at compile time +var ( + _ sdk.Msg = &MsgStoreCode{} + _ sdk.Msg = &MsgMigrateCode{} + _ sdk.Msg = &MsgInstantiateContract{} + _ sdk.Msg = &MsgExecuteContract{} + _ sdk.Msg = &MsgMigrateContract{} + _ sdk.Msg = &MsgUpdateContractAdmin{} + _ sdk.Msg = &MsgClearContractAdmin{} +) + +// wasm message types +const ( + TypeMsgStoreCode = "store_code" + TypeMsgMigrateCode = "migrate_code" + TypeMsgInstantiateContract = "instantiate_contract" + TypeMsgExecuteContract = "execute_contract" + TypeMsgMigrateContract = "migrate_contract" + TypeMsgUpdateContractAdmin = "update_contract_admin" + TypeMsgClearContractAdmin = "clear_contract_admin" +) + +// from legacy x/wasm/types/params.go +const ( + EnforcedMaxContractSize = uint64(3000 * 1024) // 3MB + EnforcedMaxContractGas = uint64(100_000_000) // 100,000,000 + EnforcedMaxContractMsgSize = uint64(20 * 1024) // 10KB +) + +// NewMsgStoreCode creates a MsgStoreCode instance +func NewMsgStoreCode(sender sdk.AccAddress, wasmByteCode []byte) *MsgStoreCode { + return &MsgStoreCode{ + Sender: sender.String(), + WASMByteCode: wasmByteCode, + } +} + +// Route implements sdk.Msg +func (msg MsgStoreCode) Route() string { return wasm.RouterKey } + +// Type implements sdk.Msg +func (msg MsgStoreCode) Type() string { return TypeMsgStoreCode } + +// GetSignBytes Implements Msg +func (msg MsgStoreCode) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners Implements Msg +func (msg MsgStoreCode) GetSigners() []sdk.AccAddress { + sender, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + panic(err) + } + + return []sdk.AccAddress{sender} +} + +// ValidateBasic Implements sdk.Msg +func (msg MsgStoreCode) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err) + } + + if len(msg.WASMByteCode) == 0 { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "empty wasm code") + } + + if uint64(len(msg.WASMByteCode)) > EnforcedMaxContractSize { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "wasm code too large") + } + + return nil +} + +// NewMsgMigrateCode creates a MsgMigrateCode instance +// TODO - remove after columbus-5 update +func NewMsgMigrateCode(codeID uint64, sender sdk.AccAddress, wasmByteCode []byte) *MsgMigrateCode { + return &MsgMigrateCode{ + CodeID: codeID, + Sender: sender.String(), + WASMByteCode: wasmByteCode, + } +} + +// Route implements sdk.Msg +func (msg MsgMigrateCode) Route() string { return wasm.RouterKey } + +// Type implements sdk.Msg +func (msg MsgMigrateCode) Type() string { return TypeMsgMigrateCode } + +// GetSignBytes Implements Msg +func (msg MsgMigrateCode) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners Implements Msg +func (msg MsgMigrateCode) GetSigners() []sdk.AccAddress { + sender, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + panic(err) + } + + return []sdk.AccAddress{sender} +} + +// ValidateBasic Implements sdk.Msg +func (msg MsgMigrateCode) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err) + } + + if len(msg.WASMByteCode) == 0 { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "empty wasm code") + } + + if uint64(len(msg.WASMByteCode)) > EnforcedMaxContractSize { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "wasm code too large") + } + + return nil +} + +// NewMsgInstantiateContract creates a MsgInstantiateContract instance +func NewMsgInstantiateContract(sender, admin sdk.AccAddress, codeID uint64, initMsg []byte, initCoins sdk.Coins) *MsgInstantiateContract { + var adminAddr string + if !admin.Empty() { + adminAddr = admin.String() + } + + return &MsgInstantiateContract{ + Sender: sender.String(), + Admin: adminAddr, + CodeID: codeID, + InitMsg: initMsg, + InitCoins: initCoins, + } +} + +// Route implements sdk.Msg +func (msg MsgInstantiateContract) Route() string { + return wasm.RouterKey +} + +// Type implements sdk.Msg +func (msg MsgInstantiateContract) Type() string { + return TypeMsgInstantiateContract +} + +// ValidateBasic implements sdk.Msg +func (msg MsgInstantiateContract) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err) + } + + if len(msg.Admin) != 0 { + _, err := sdk.AccAddressFromBech32(msg.Admin) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid admin address (%s)", err) + } + } + + if !msg.InitCoins.IsValid() { + return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, msg.InitCoins.String()) + } + + if uint64(len(msg.InitMsg)) > EnforcedMaxContractMsgSize { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "wasm msg byte size is too huge") + } + + if !json.Valid(msg.InitMsg) { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "wasm msg byte format is invalid json") + } + + return nil +} + +// GetSignBytes implements sdk.Msg +func (msg MsgInstantiateContract) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners implements sdk.Msg +func (msg MsgInstantiateContract) GetSigners() []sdk.AccAddress { + sender, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + panic(err) + } + + return []sdk.AccAddress{sender} +} + +// NewMsgExecuteContract creates a NewMsgExecuteContract instance +func NewMsgExecuteContract(sender sdk.AccAddress, contract sdk.AccAddress, execMsg []byte, coins sdk.Coins) *MsgExecuteContract { + return &MsgExecuteContract{ + Sender: sender.String(), + Contract: contract.String(), + ExecuteMsg: execMsg, + Coins: coins, + } +} + +// Route implements sdk.Msg +func (msg MsgExecuteContract) Route() string { + return wasm.RouterKey +} + +// Type implements sdk.Msg +func (msg MsgExecuteContract) Type() string { + return TypeMsgExecuteContract +} + +// ValidateBasic implements sdk.Msg +func (msg MsgExecuteContract) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err) + } + + _, err = sdk.AccAddressFromBech32(msg.Contract) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid contract address (%s)", err) + } + + if !msg.Coins.IsValid() { + return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, msg.Coins.String()) + } + + if uint64(len(msg.ExecuteMsg)) > EnforcedMaxContractMsgSize { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "wasm msg byte size is too huge") + } + + if !json.Valid(msg.ExecuteMsg) { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "wasm msg byte format is invalid json") + } + + return nil +} + +// GetSignBytes implements sdk.Msg +func (msg MsgExecuteContract) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners implements sdk.Msg +func (msg MsgExecuteContract) GetSigners() []sdk.AccAddress { + sender, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + panic(err) + } + + return []sdk.AccAddress{sender} +} + +// NewMsgMigrateContract creates a MsgMigrateContract instance +func NewMsgMigrateContract(admin, contract sdk.AccAddress, newCodeID uint64, migrateMsg json.RawMessage) *MsgMigrateContract { + return &MsgMigrateContract{ + Admin: admin.String(), + Contract: contract.String(), + NewCodeID: newCodeID, + MigrateMsg: migrateMsg, + } +} + +// Route implements sdk.Msg +func (msg MsgMigrateContract) Route() string { + return wasm.RouterKey +} + +// Type implements sdk.Msg +func (msg MsgMigrateContract) Type() string { + return TypeMsgMigrateContract +} + +// ValidateBasic implements sdk.Msg +func (msg MsgMigrateContract) ValidateBasic() error { + if msg.NewCodeID == 0 { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "missing new_code_id") + } + + _, err := sdk.AccAddressFromBech32(msg.Admin) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid admin address (%s)", err) + } + + _, err = sdk.AccAddressFromBech32(msg.Contract) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid contract address (%s)", err) + } + + if uint64(len(msg.MigrateMsg)) > EnforcedMaxContractMsgSize { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "wasm msg byte size is too huge") + } + + if !json.Valid(msg.MigrateMsg) { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "wasm msg byte format is invalid json") + } + + return nil +} + +// GetSignBytes implements sdk.Msg +func (msg MsgMigrateContract) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners implements sdk.Msg +func (msg MsgMigrateContract) GetSigners() []sdk.AccAddress { + admin, err := sdk.AccAddressFromBech32(msg.Admin) + if err != nil { + panic(err) + } + + return []sdk.AccAddress{admin} +} + +// NewMsgUpdateContractAdmin creates a MsgUpdateContractAdmin instance +func NewMsgUpdateContractAdmin(admin, newAdmin, contract sdk.AccAddress) *MsgUpdateContractAdmin { + return &MsgUpdateContractAdmin{ + Admin: admin.String(), + NewAdmin: newAdmin.String(), + Contract: contract.String(), + } +} + +// Route implements sdk.Msg +func (msg MsgUpdateContractAdmin) Route() string { + return wasm.RouterKey +} + +// Type implements sdk.Msg +func (msg MsgUpdateContractAdmin) Type() string { + return TypeMsgUpdateContractAdmin +} + +// ValidateBasic implements sdk.Msg +func (msg MsgUpdateContractAdmin) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Admin) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid admin address (%s)", err) + } + + _, err = sdk.AccAddressFromBech32(msg.NewAdmin) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid new admin address (%s)", err) + } + + _, err = sdk.AccAddressFromBech32(msg.Contract) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid contract address (%s)", err) + } + + return nil +} + +// GetSignBytes implements sdk.Msg +func (msg MsgUpdateContractAdmin) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners implements sdk.Msg +func (msg MsgUpdateContractAdmin) GetSigners() []sdk.AccAddress { + owner, err := sdk.AccAddressFromBech32(msg.Admin) + if err != nil { + panic(err) + } + return []sdk.AccAddress{owner} +} + +// NewMsgClearContractAdmin creates a MsgClearContractAdmin instance +func NewMsgClearContractAdmin(admin, contract sdk.AccAddress) *MsgClearContractAdmin { + return &MsgClearContractAdmin{ + Admin: admin.String(), + Contract: contract.String(), + } +} + +// Route implements sdk.Msg +func (msg MsgClearContractAdmin) Route() string { + return wasm.RouterKey +} + +// Type implements sdk.Msg +func (msg MsgClearContractAdmin) Type() string { + return TypeMsgClearContractAdmin +} + +// ValidateBasic implements sdk.Msg +func (msg MsgClearContractAdmin) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Admin) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid owner address (%s)", err) + } + + _, err = sdk.AccAddressFromBech32(msg.Contract) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid contract address (%s)", err) + } + + return nil +} + +// GetSignBytes implements sdk.Msg +func (msg MsgClearContractAdmin) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners implements sdk.Msg +func (msg MsgClearContractAdmin) GetSigners() []sdk.AccAddress { + owner, err := sdk.AccAddressFromBech32(msg.Admin) + if err != nil { + panic(err) + } + return []sdk.AccAddress{owner} +} diff --git a/custom/wasm/types/legacy/tx.pb.go b/custom/wasm/types/legacy/tx.pb.go new file mode 100644 index 000000000..023ace758 --- /dev/null +++ b/custom/wasm/types/legacy/tx.pb.go @@ -0,0 +1,3564 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: terra/wasm/v1beta1/tx.proto + +package legacy + +import ( + context "context" + encoding_json "encoding/json" + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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 + +// MsgStoreCode represents a message to submit +// Wasm code to the system +type MsgStoreCode struct { + // Sender is the that actor that signed the messages + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` + // WASMByteCode can be raw or gzip compressed + WASMByteCode []byte `protobuf:"bytes,2,opt,name=wasm_byte_code,json=wasmByteCode,proto3" json:"wasm_byte_code,omitempty" yaml:"wasm_byte_code"` +} + +func (m *MsgStoreCode) Reset() { *m = MsgStoreCode{} } +func (m *MsgStoreCode) String() string { return proto.CompactTextString(m) } +func (*MsgStoreCode) ProtoMessage() {} +func (*MsgStoreCode) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{0} +} + +func (m *MsgStoreCode) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgStoreCode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgStoreCode.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgStoreCode) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgStoreCode.Merge(m, src) +} + +func (m *MsgStoreCode) XXX_Size() int { + return m.Size() +} + +func (m *MsgStoreCode) XXX_DiscardUnknown() { + xxx_messageInfo_MsgStoreCode.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgStoreCode proto.InternalMessageInfo + +// MsgStoreCodeResponse defines the Msg/StoreCode response type. +type MsgStoreCodeResponse struct { + // CodeID is the reference to the stored WASM code + CodeID uint64 `protobuf:"varint,1,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty" yaml:"code_id"` +} + +func (m *MsgStoreCodeResponse) Reset() { *m = MsgStoreCodeResponse{} } +func (m *MsgStoreCodeResponse) String() string { return proto.CompactTextString(m) } +func (*MsgStoreCodeResponse) ProtoMessage() {} +func (*MsgStoreCodeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{1} +} + +func (m *MsgStoreCodeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgStoreCodeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgStoreCodeResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgStoreCodeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgStoreCodeResponse.Merge(m, src) +} + +func (m *MsgStoreCodeResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgStoreCodeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgStoreCodeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgStoreCodeResponse proto.InternalMessageInfo + +func (m *MsgStoreCodeResponse) GetCodeID() uint64 { + if m != nil { + return m.CodeID + } + return 0 +} + +// MsgMigrateCode represents a message to submit +// Wasm code to the system +type MsgMigrateCode struct { + // CodeID is the migration target code id + CodeID uint64 `protobuf:"varint,1,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty" yaml:"code_id"` + // Sender is the that actor that signed the messages + Sender string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` + // WASMByteCode can be raw or gzip compressed + WASMByteCode []byte `protobuf:"bytes,3,opt,name=wasm_byte_code,json=wasmByteCode,proto3" json:"wasm_byte_code,omitempty" yaml:"wasm_byte_code"` +} + +func (m *MsgMigrateCode) Reset() { *m = MsgMigrateCode{} } +func (m *MsgMigrateCode) String() string { return proto.CompactTextString(m) } +func (*MsgMigrateCode) ProtoMessage() {} +func (*MsgMigrateCode) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{2} +} + +func (m *MsgMigrateCode) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgMigrateCode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgMigrateCode.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgMigrateCode) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgMigrateCode.Merge(m, src) +} + +func (m *MsgMigrateCode) XXX_Size() int { + return m.Size() +} + +func (m *MsgMigrateCode) XXX_DiscardUnknown() { + xxx_messageInfo_MsgMigrateCode.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgMigrateCode proto.InternalMessageInfo + +// MsgMigrateCodeResponse defines the Msg/MigrateCode response type. +type MsgMigrateCodeResponse struct{} + +func (m *MsgMigrateCodeResponse) Reset() { *m = MsgMigrateCodeResponse{} } +func (m *MsgMigrateCodeResponse) String() string { return proto.CompactTextString(m) } +func (*MsgMigrateCodeResponse) ProtoMessage() {} +func (*MsgMigrateCodeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{3} +} + +func (m *MsgMigrateCodeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgMigrateCodeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgMigrateCodeResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgMigrateCodeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgMigrateCodeResponse.Merge(m, src) +} + +func (m *MsgMigrateCodeResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgMigrateCodeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgMigrateCodeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgMigrateCodeResponse proto.InternalMessageInfo + +// MsgInstantiateContract represents a message to create +// a new smart contract instance for the given +// code id. +type MsgInstantiateContract struct { + // Sender is an sender address + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` + // Admin is an optional admin address who can migrate the contract + Admin string `protobuf:"bytes,2,opt,name=admin,proto3" json:"admin,omitempty" yaml:"admin"` + // CodeID is the reference to the stored WASM code + CodeID uint64 `protobuf:"varint,3,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty" yaml:"code_id"` + // InitMsg json encoded message to be passed to the contract on instantiation + InitMsg encoding_json.RawMessage `protobuf:"bytes,4,opt,name=init_msg,json=initMsg,proto3,casttype=encoding/json.RawMessage" json:"init_msg,omitempty" yaml:"init_msg"` + // InitCoins that are transferred to the contract on execution + InitCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,5,rep,name=init_coins,json=initCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"init_coins" yaml:"init_coins"` +} + +func (m *MsgInstantiateContract) Reset() { *m = MsgInstantiateContract{} } +func (m *MsgInstantiateContract) String() string { return proto.CompactTextString(m) } +func (*MsgInstantiateContract) ProtoMessage() {} +func (*MsgInstantiateContract) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{4} +} + +func (m *MsgInstantiateContract) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgInstantiateContract) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgInstantiateContract.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgInstantiateContract) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgInstantiateContract.Merge(m, src) +} + +func (m *MsgInstantiateContract) XXX_Size() int { + return m.Size() +} + +func (m *MsgInstantiateContract) XXX_DiscardUnknown() { + xxx_messageInfo_MsgInstantiateContract.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgInstantiateContract proto.InternalMessageInfo + +// MsgInstantiateContractResponse defines the Msg/InstantiateContract response type. +type MsgInstantiateContractResponse struct { + // ContractAddress is the bech32 address of the new contract instance. + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty" yaml:"contract_address"` + // Data contains base64-encoded bytes to returned from the contract + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty" yaml:"data"` +} + +func (m *MsgInstantiateContractResponse) Reset() { *m = MsgInstantiateContractResponse{} } +func (m *MsgInstantiateContractResponse) String() string { return proto.CompactTextString(m) } +func (*MsgInstantiateContractResponse) ProtoMessage() {} +func (*MsgInstantiateContractResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{5} +} + +func (m *MsgInstantiateContractResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgInstantiateContractResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgInstantiateContractResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgInstantiateContractResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgInstantiateContractResponse.Merge(m, src) +} + +func (m *MsgInstantiateContractResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgInstantiateContractResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgInstantiateContractResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgInstantiateContractResponse proto.InternalMessageInfo + +func (m *MsgInstantiateContractResponse) GetContractAddress() string { + if m != nil { + return m.ContractAddress + } + return "" +} + +func (m *MsgInstantiateContractResponse) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +// MsgExecuteContract represents a message to +// submits the given message data to a smart contract. +type MsgExecuteContract struct { + // Sender is the that actor that signed the messages + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` + // Contract is the address of the smart contract + Contract string `protobuf:"bytes,2,opt,name=contract,proto3" json:"contract,omitempty" yaml:"contract"` + // ExecuteMsg json encoded message to be passed to the contract + ExecuteMsg encoding_json.RawMessage `protobuf:"bytes,3,opt,name=execute_msg,json=executeMsg,proto3,casttype=encoding/json.RawMessage" json:"execute_msg,omitempty" yaml:"execute_msg"` + // Coins that are transferred to the contract on execution + Coins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,5,rep,name=coins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"coins" yaml:"coins"` +} + +func (m *MsgExecuteContract) Reset() { *m = MsgExecuteContract{} } +func (m *MsgExecuteContract) String() string { return proto.CompactTextString(m) } +func (*MsgExecuteContract) ProtoMessage() {} +func (*MsgExecuteContract) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{6} +} + +func (m *MsgExecuteContract) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgExecuteContract) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgExecuteContract.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgExecuteContract) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgExecuteContract.Merge(m, src) +} + +func (m *MsgExecuteContract) XXX_Size() int { + return m.Size() +} + +func (m *MsgExecuteContract) XXX_DiscardUnknown() { + xxx_messageInfo_MsgExecuteContract.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgExecuteContract proto.InternalMessageInfo + +// MsgExecuteContractResponse defines the Msg/ExecuteContract response type. +type MsgExecuteContractResponse struct { + // Data contains base64-encoded bytes to returned from the contract + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" yaml:"data"` +} + +func (m *MsgExecuteContractResponse) Reset() { *m = MsgExecuteContractResponse{} } +func (m *MsgExecuteContractResponse) String() string { return proto.CompactTextString(m) } +func (*MsgExecuteContractResponse) ProtoMessage() {} +func (*MsgExecuteContractResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{7} +} + +func (m *MsgExecuteContractResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgExecuteContractResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgExecuteContractResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgExecuteContractResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgExecuteContractResponse.Merge(m, src) +} + +func (m *MsgExecuteContractResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgExecuteContractResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgExecuteContractResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgExecuteContractResponse proto.InternalMessageInfo + +func (m *MsgExecuteContractResponse) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +// MsgMigrateContract represents a message to +// runs a code upgrade/ downgrade for a smart contract +type MsgMigrateContract struct { + // Admin is the current contract admin + Admin string `protobuf:"bytes,1,opt,name=admin,proto3" json:"admin,omitempty" yaml:"admin"` + // Contract is the address of the smart contract + Contract string `protobuf:"bytes,2,opt,name=contract,proto3" json:"contract,omitempty" yaml:"contract"` + // NewCodeID references the new WASM code + NewCodeID uint64 `protobuf:"varint,3,opt,name=new_code_id,json=newCodeId,proto3" json:"new_code_id,omitempty" yaml:"new_code_id"` + // MigrateMsg is json encoded message to be passed to the contract on migration + MigrateMsg encoding_json.RawMessage `protobuf:"bytes,4,opt,name=migrate_msg,json=migrateMsg,proto3,casttype=encoding/json.RawMessage" json:"migrate_msg,omitempty" yaml:"migrate_msg"` +} + +func (m *MsgMigrateContract) Reset() { *m = MsgMigrateContract{} } +func (m *MsgMigrateContract) String() string { return proto.CompactTextString(m) } +func (*MsgMigrateContract) ProtoMessage() {} +func (*MsgMigrateContract) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{8} +} + +func (m *MsgMigrateContract) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgMigrateContract) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgMigrateContract.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgMigrateContract) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgMigrateContract.Merge(m, src) +} + +func (m *MsgMigrateContract) XXX_Size() int { + return m.Size() +} + +func (m *MsgMigrateContract) XXX_DiscardUnknown() { + xxx_messageInfo_MsgMigrateContract.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgMigrateContract proto.InternalMessageInfo + +// MsgMigrateContractResponse defines the Msg/MigrateContract response type. +type MsgMigrateContractResponse struct { + // Data contains base64-encoded bytes to returned from the contract + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" yaml:"data"` +} + +func (m *MsgMigrateContractResponse) Reset() { *m = MsgMigrateContractResponse{} } +func (m *MsgMigrateContractResponse) String() string { return proto.CompactTextString(m) } +func (*MsgMigrateContractResponse) ProtoMessage() {} +func (*MsgMigrateContractResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{9} +} + +func (m *MsgMigrateContractResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgMigrateContractResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgMigrateContractResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgMigrateContractResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgMigrateContractResponse.Merge(m, src) +} + +func (m *MsgMigrateContractResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgMigrateContractResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgMigrateContractResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgMigrateContractResponse proto.InternalMessageInfo + +func (m *MsgMigrateContractResponse) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +// MsgUpdateContractAdmin represents a message to +// sets a new admin for a smart contract +type MsgUpdateContractAdmin struct { + // Admin is the current contract admin + Admin string `protobuf:"bytes,1,opt,name=admin,proto3" json:"admin,omitempty" yaml:"admin"` + // NewAdmin is the new contract admin + NewAdmin string `protobuf:"bytes,2,opt,name=new_admin,json=newAdmin,proto3" json:"new_admin,omitempty" yaml:"new_admin"` + // Contract is the address of the smart contract + Contract string `protobuf:"bytes,3,opt,name=contract,proto3" json:"contract,omitempty" yaml:"contract"` +} + +func (m *MsgUpdateContractAdmin) Reset() { *m = MsgUpdateContractAdmin{} } +func (m *MsgUpdateContractAdmin) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateContractAdmin) ProtoMessage() {} +func (*MsgUpdateContractAdmin) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{10} +} + +func (m *MsgUpdateContractAdmin) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgUpdateContractAdmin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateContractAdmin.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgUpdateContractAdmin) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateContractAdmin.Merge(m, src) +} + +func (m *MsgUpdateContractAdmin) XXX_Size() int { + return m.Size() +} + +func (m *MsgUpdateContractAdmin) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateContractAdmin.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateContractAdmin proto.InternalMessageInfo + +// MsgUpdateContractAdminResponse defines the Msg/UpdateContractAdmin response type. +type MsgUpdateContractAdminResponse struct{} + +func (m *MsgUpdateContractAdminResponse) Reset() { *m = MsgUpdateContractAdminResponse{} } +func (m *MsgUpdateContractAdminResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateContractAdminResponse) ProtoMessage() {} +func (*MsgUpdateContractAdminResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{11} +} + +func (m *MsgUpdateContractAdminResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgUpdateContractAdminResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateContractAdminResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgUpdateContractAdminResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateContractAdminResponse.Merge(m, src) +} + +func (m *MsgUpdateContractAdminResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgUpdateContractAdminResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateContractAdminResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateContractAdminResponse proto.InternalMessageInfo + +// MsgClearContractAdmin represents a message to +// clear admin address from a smart contract +type MsgClearContractAdmin struct { + // Admin is the current contract admin + Admin string `protobuf:"bytes,1,opt,name=admin,proto3" json:"admin,omitempty" yaml:"admin"` + // Contract is the address of the smart contract + Contract string `protobuf:"bytes,2,opt,name=contract,proto3" json:"contract,omitempty" yaml:"contract"` +} + +func (m *MsgClearContractAdmin) Reset() { *m = MsgClearContractAdmin{} } +func (m *MsgClearContractAdmin) String() string { return proto.CompactTextString(m) } +func (*MsgClearContractAdmin) ProtoMessage() {} +func (*MsgClearContractAdmin) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{12} +} + +func (m *MsgClearContractAdmin) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgClearContractAdmin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgClearContractAdmin.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgClearContractAdmin) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgClearContractAdmin.Merge(m, src) +} + +func (m *MsgClearContractAdmin) XXX_Size() int { + return m.Size() +} + +func (m *MsgClearContractAdmin) XXX_DiscardUnknown() { + xxx_messageInfo_MsgClearContractAdmin.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgClearContractAdmin proto.InternalMessageInfo + +// MsgClearContractAdminResponse defines the Msg/ClearContractAdmin response type. +type MsgClearContractAdminResponse struct{} + +func (m *MsgClearContractAdminResponse) Reset() { *m = MsgClearContractAdminResponse{} } +func (m *MsgClearContractAdminResponse) String() string { return proto.CompactTextString(m) } +func (*MsgClearContractAdminResponse) ProtoMessage() {} +func (*MsgClearContractAdminResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5834e4e1a84cce82, []int{13} +} + +func (m *MsgClearContractAdminResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgClearContractAdminResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgClearContractAdminResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgClearContractAdminResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgClearContractAdminResponse.Merge(m, src) +} + +func (m *MsgClearContractAdminResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgClearContractAdminResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgClearContractAdminResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgClearContractAdminResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgStoreCode)(nil), "terra.wasm.v1beta1.MsgStoreCode") + proto.RegisterType((*MsgStoreCodeResponse)(nil), "terra.wasm.v1beta1.MsgStoreCodeResponse") + proto.RegisterType((*MsgMigrateCode)(nil), "terra.wasm.v1beta1.MsgMigrateCode") + proto.RegisterType((*MsgMigrateCodeResponse)(nil), "terra.wasm.v1beta1.MsgMigrateCodeResponse") + proto.RegisterType((*MsgInstantiateContract)(nil), "terra.wasm.v1beta1.MsgInstantiateContract") + proto.RegisterType((*MsgInstantiateContractResponse)(nil), "terra.wasm.v1beta1.MsgInstantiateContractResponse") + proto.RegisterType((*MsgExecuteContract)(nil), "terra.wasm.v1beta1.MsgExecuteContract") + proto.RegisterType((*MsgExecuteContractResponse)(nil), "terra.wasm.v1beta1.MsgExecuteContractResponse") + proto.RegisterType((*MsgMigrateContract)(nil), "terra.wasm.v1beta1.MsgMigrateContract") + proto.RegisterType((*MsgMigrateContractResponse)(nil), "terra.wasm.v1beta1.MsgMigrateContractResponse") + proto.RegisterType((*MsgUpdateContractAdmin)(nil), "terra.wasm.v1beta1.MsgUpdateContractAdmin") + proto.RegisterType((*MsgUpdateContractAdminResponse)(nil), "terra.wasm.v1beta1.MsgUpdateContractAdminResponse") + proto.RegisterType((*MsgClearContractAdmin)(nil), "terra.wasm.v1beta1.MsgClearContractAdmin") + proto.RegisterType((*MsgClearContractAdminResponse)(nil), "terra.wasm.v1beta1.MsgClearContractAdminResponse") +} + +func init() { proto.RegisterFile("terra/wasm/v1beta1/tx.proto", fileDescriptor_5834e4e1a84cce82) } + +var fileDescriptor_5834e4e1a84cce82 = []byte{ + // 960 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x6f, 0xe3, 0x44, + 0x14, 0x8e, 0x9b, 0xb6, 0xdb, 0x4c, 0x42, 0xdb, 0x75, 0xbb, 0x10, 0xb2, 0x90, 0x89, 0x66, 0xa5, + 0x55, 0x8a, 0xb4, 0xb6, 0x1a, 0xc4, 0x81, 0x3d, 0x91, 0x94, 0x45, 0x2a, 0x92, 0x41, 0x72, 0x85, + 0x56, 0x42, 0x42, 0xd1, 0xc4, 0x1e, 0x19, 0x43, 0xe3, 0x29, 0x1e, 0x67, 0xb3, 0xe1, 0xc2, 0x95, + 0x0b, 0x12, 0x48, 0xfc, 0x01, 0x7b, 0xe6, 0xc0, 0x1f, 0xc1, 0x69, 0x2f, 0x48, 0x3d, 0x72, 0x32, + 0x28, 0xbd, 0x70, 0xb6, 0xc4, 0x01, 0x4e, 0xc8, 0x33, 0x63, 0x77, 0xda, 0x38, 0x4d, 0x52, 0xed, + 0xc9, 0xd6, 0xbc, 0xef, 0xfd, 0x98, 0xef, 0x7b, 0x6f, 0x66, 0xc0, 0xfd, 0x88, 0x84, 0x21, 0x36, + 0xc7, 0x98, 0x0d, 0xcd, 0x67, 0x87, 0x03, 0x12, 0xe1, 0x43, 0x33, 0x7a, 0x6e, 0x9c, 0x85, 0x34, + 0xa2, 0xba, 0xce, 0x8d, 0x46, 0x6a, 0x34, 0xa4, 0xb1, 0xb1, 0xef, 0x51, 0x8f, 0x72, 0xb3, 0x99, + 0xfe, 0x09, 0x64, 0xa3, 0xe9, 0x50, 0x36, 0xa4, 0xcc, 0x1c, 0x60, 0x46, 0xf2, 0x38, 0x0e, 0xf5, + 0x03, 0x61, 0x47, 0x3f, 0x6b, 0xa0, 0x66, 0x31, 0xef, 0x24, 0xa2, 0x21, 0x39, 0xa2, 0x2e, 0xd1, + 0x0f, 0xc0, 0x26, 0x23, 0x81, 0x4b, 0xc2, 0xba, 0xd6, 0xd2, 0xda, 0x95, 0xde, 0xdd, 0x24, 0x86, + 0xaf, 0x4d, 0xf0, 0xf0, 0xf4, 0x31, 0x12, 0xeb, 0xc8, 0x96, 0x00, 0xfd, 0x53, 0xb0, 0x9d, 0x56, + 0xd0, 0x1f, 0x4c, 0x22, 0xd2, 0x77, 0xa8, 0x4b, 0xea, 0x6b, 0x2d, 0xad, 0x5d, 0xeb, 0x1d, 0x4c, + 0x63, 0x58, 0x7b, 0xda, 0x3d, 0xb1, 0x7a, 0x93, 0x88, 0x07, 0x4d, 0x62, 0x78, 0x4f, 0x84, 0xb8, + 0x8a, 0x47, 0x76, 0x2d, 0x5d, 0xc8, 0x60, 0x8f, 0xb7, 0xbe, 0x7f, 0x01, 0x4b, 0x7f, 0xbf, 0x80, + 0x25, 0x64, 0x81, 0x7d, 0xb5, 0x2a, 0x9b, 0xb0, 0x33, 0x1a, 0x30, 0xa2, 0xbf, 0x07, 0xee, 0xa4, + 0x8e, 0x7d, 0xdf, 0xe5, 0xe5, 0xad, 0xf7, 0xde, 0x9a, 0xc6, 0x70, 0x33, 0x85, 0x1c, 0x7f, 0x98, + 0xc4, 0x70, 0x5b, 0x64, 0x91, 0x10, 0x64, 0x6f, 0xa6, 0x7f, 0xc7, 0x2e, 0xfa, 0x5d, 0x03, 0xdb, + 0x16, 0xf3, 0x2c, 0xdf, 0x0b, 0xb1, 0xc8, 0x75, 0xcb, 0x48, 0x0a, 0x3d, 0x6b, 0xab, 0xd3, 0x53, + 0x7e, 0x55, 0xf4, 0xd4, 0xc1, 0xeb, 0x57, 0xb7, 0x93, 0x11, 0x84, 0xfe, 0x5d, 0xe3, 0xa6, 0xe3, + 0x80, 0x45, 0x38, 0x88, 0x7c, 0x6e, 0x0e, 0xa2, 0x10, 0x3b, 0xd1, 0x2a, 0xca, 0x3e, 0x04, 0x1b, + 0xd8, 0x1d, 0xfa, 0x81, 0xdc, 0xe4, 0x6e, 0x12, 0xc3, 0x9a, 0x40, 0xf2, 0x65, 0x64, 0x0b, 0xb3, + 0x4a, 0x62, 0x79, 0x05, 0x12, 0x3f, 0x06, 0x5b, 0x7e, 0xe0, 0x47, 0xfd, 0x21, 0xf3, 0xea, 0xeb, + 0x9c, 0x13, 0x33, 0x89, 0xe1, 0x8e, 0x40, 0x67, 0x16, 0xf4, 0x5f, 0x0c, 0xeb, 0x24, 0x70, 0xa8, + 0xeb, 0x07, 0x9e, 0xf9, 0x15, 0xa3, 0x81, 0x61, 0xe3, 0xb1, 0x45, 0x18, 0xc3, 0x1e, 0xb1, 0xef, + 0xa4, 0x30, 0x8b, 0x79, 0xfa, 0x77, 0x00, 0x70, 0x8f, 0xb4, 0xa7, 0x59, 0x7d, 0xa3, 0x55, 0x6e, + 0x57, 0x3b, 0x6f, 0x1a, 0xa2, 0xeb, 0x8d, 0xb4, 0xeb, 0xb3, 0x01, 0x31, 0x8e, 0xa8, 0x1f, 0xf4, + 0x9e, 0xbc, 0x8c, 0x61, 0x29, 0x89, 0xe1, 0x5d, 0x25, 0x19, 0x77, 0x45, 0xbf, 0xfc, 0x09, 0xdb, + 0x9e, 0x1f, 0x7d, 0x39, 0x1a, 0x18, 0x0e, 0x1d, 0x9a, 0x72, 0x6e, 0xc4, 0xe7, 0x11, 0x73, 0xbf, + 0x36, 0xa3, 0xc9, 0x19, 0x61, 0x3c, 0x0a, 0xb3, 0x2b, 0xa9, 0x23, 0xff, 0x55, 0x54, 0xf9, 0x41, + 0x03, 0xcd, 0x62, 0xee, 0xf3, 0xfe, 0xfd, 0x08, 0xec, 0x3a, 0x72, 0xad, 0x8f, 0x5d, 0x37, 0x24, + 0x8c, 0x49, 0x35, 0xee, 0x27, 0x31, 0x7c, 0x23, 0xe3, 0xeb, 0x2a, 0x02, 0xd9, 0x3b, 0xd9, 0x52, + 0x57, 0xac, 0xe8, 0x0f, 0xc0, 0xba, 0x8b, 0x23, 0x2c, 0x07, 0x6e, 0x27, 0x89, 0x61, 0x55, 0xf8, + 0xa6, 0xab, 0xc8, 0xe6, 0x46, 0xf4, 0xdb, 0x1a, 0xd0, 0x2d, 0xe6, 0x3d, 0x79, 0x4e, 0x9c, 0xd1, + 0xed, 0xfa, 0xc0, 0x04, 0x5b, 0x59, 0x66, 0xd9, 0x0a, 0x7b, 0x97, 0x42, 0x65, 0x16, 0x64, 0xe7, + 0x20, 0xfd, 0x04, 0x54, 0x89, 0x48, 0xc7, 0xc5, 0x15, 0x0d, 0xdf, 0x49, 0x62, 0xa8, 0x0b, 0x1f, + 0xc5, 0x78, 0xb3, 0xbe, 0x40, 0x22, 0x53, 0x89, 0xbf, 0x01, 0x1b, 0x4b, 0xaa, 0xfb, 0x81, 0x54, + 0xb7, 0x96, 0x55, 0xb8, 0xb2, 0xb0, 0x22, 0x93, 0x22, 0x6a, 0x17, 0x34, 0x66, 0x39, 0xcc, 0xf5, + 0xcc, 0x74, 0xd0, 0x6e, 0xd2, 0xe1, 0x27, 0xa1, 0x43, 0x3e, 0xae, 0x92, 0xab, 0x7c, 0xc8, 0xb4, + 0x9b, 0x87, 0x6c, 0x65, 0x11, 0x8e, 0x40, 0x35, 0x20, 0xe3, 0xfe, 0xd5, 0xc9, 0x7c, 0x30, 0x8d, + 0x61, 0xe5, 0x13, 0x32, 0xce, 0x87, 0x53, 0x2a, 0xa2, 0x20, 0x91, 0x5d, 0x09, 0x24, 0xc0, 0x4d, + 0x95, 0x1c, 0x8a, 0x82, 0x95, 0x31, 0x55, 0x94, 0x54, 0x8c, 0x0b, 0x94, 0x94, 0x48, 0x8b, 0x79, + 0x33, 0xb4, 0x5e, 0xa3, 0x64, 0x35, 0x5a, 0x7f, 0xd5, 0xf8, 0x51, 0xf7, 0xd9, 0x99, 0xab, 0x84, + 0xe8, 0x72, 0xca, 0x96, 0xa5, 0xf6, 0x10, 0xa4, 0x3b, 0xee, 0xab, 0x67, 0xdd, 0x7e, 0x12, 0xc3, + 0xdd, 0x4b, 0x6a, 0x24, 0x7e, 0x2b, 0x20, 0xe3, 0xee, 0x8c, 0x1a, 0xe5, 0x25, 0xd4, 0x50, 0xf6, + 0xdc, 0xe2, 0xc7, 0x43, 0x41, 0xbd, 0xf9, 0xe9, 0xfd, 0x2d, 0xb8, 0x67, 0x31, 0xef, 0xe8, 0x94, + 0xe0, 0xf0, 0x76, 0x1b, 0x5a, 0xb5, 0x57, 0x94, 0xea, 0x20, 0x78, 0xbb, 0x30, 0x77, 0x56, 0x5c, + 0xe7, 0x9f, 0x0d, 0x50, 0x4e, 0xc7, 0xf1, 0x29, 0xa8, 0x5c, 0x3e, 0x17, 0x5a, 0xc6, 0xec, 0x53, + 0xc4, 0x50, 0xaf, 0xee, 0x46, 0x7b, 0x11, 0x22, 0x57, 0xfd, 0x0b, 0x50, 0x55, 0x6f, 0x68, 0x34, + 0xc7, 0x51, 0xc1, 0x34, 0xde, 0x59, 0x8c, 0xc9, 0xc3, 0x8f, 0xc0, 0x5e, 0xd1, 0xb5, 0x38, 0x2f, + 0x44, 0x01, 0xb6, 0xd1, 0x59, 0x1e, 0x9b, 0xa7, 0xf5, 0xc1, 0xce, 0xf5, 0x13, 0xf8, 0xe1, 0x9c, + 0x30, 0xd7, 0x70, 0x0d, 0x63, 0x39, 0x9c, 0x9a, 0x6a, 0xe6, 0x90, 0x59, 0x44, 0xd0, 0x82, 0x54, + 0xf3, 0x26, 0x74, 0x04, 0xf6, 0x8a, 0x06, 0x6f, 0x1e, 0x99, 0x05, 0xd8, 0xb9, 0x64, 0xde, 0x30, + 0x20, 0x7a, 0x08, 0xf4, 0x82, 0xe9, 0x38, 0x98, 0x13, 0x69, 0x16, 0xda, 0x38, 0x5c, 0x1a, 0x9a, + 0xe5, 0xec, 0x9d, 0xbc, 0x9c, 0x36, 0xb5, 0xf3, 0x69, 0x53, 0xfb, 0x6b, 0xda, 0xd4, 0x7e, 0xbc, + 0x68, 0x96, 0xce, 0x2f, 0x9a, 0xa5, 0x3f, 0x2e, 0x9a, 0xa5, 0xcf, 0xdf, 0x57, 0xaf, 0x95, 0x53, + 0xcc, 0x98, 0xef, 0x3c, 0x12, 0xcf, 0x76, 0x87, 0x86, 0xc4, 0x7c, 0xd6, 0x31, 0x9d, 0x11, 0x8b, + 0xe8, 0x50, 0xbc, 0xe2, 0xf9, 0x35, 0x63, 0x9e, 0x12, 0x0f, 0x3b, 0x93, 0xc1, 0x26, 0x7f, 0x7e, + 0xbf, 0xfb, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdd, 0xa9, 0xe9, 0x3a, 0xe7, 0x0b, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ context.Context + _ grpc.ClientConn +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + // StoreCode to submit Wasm code to the system + StoreCode(ctx context.Context, in *MsgStoreCode, opts ...grpc.CallOption) (*MsgStoreCodeResponse, error) + // MigrateCode to submit new version Wasm code to the system + MigrateCode(ctx context.Context, in *MsgMigrateCode, opts ...grpc.CallOption) (*MsgMigrateCodeResponse, error) + // Instantiate creates a new smart contract instance for the given code id. + InstantiateContract(ctx context.Context, in *MsgInstantiateContract, opts ...grpc.CallOption) (*MsgInstantiateContractResponse, error) + // Execute submits the given message data to a smart contract + ExecuteContract(ctx context.Context, in *MsgExecuteContract, opts ...grpc.CallOption) (*MsgExecuteContractResponse, error) + // Migrate runs a code upgrade/ downgrade for a smart contract + MigrateContract(ctx context.Context, in *MsgMigrateContract, opts ...grpc.CallOption) (*MsgMigrateContractResponse, error) + // UpdateContractAdmin sets a new admin for a smart contract + UpdateContractAdmin(ctx context.Context, in *MsgUpdateContractAdmin, opts ...grpc.CallOption) (*MsgUpdateContractAdminResponse, error) + // ClearContractAdmin remove admin flag from a smart contract + ClearContractAdmin(ctx context.Context, in *MsgClearContractAdmin, opts ...grpc.CallOption) (*MsgClearContractAdminResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) StoreCode(ctx context.Context, in *MsgStoreCode, opts ...grpc.CallOption) (*MsgStoreCodeResponse, error) { + out := new(MsgStoreCodeResponse) + err := c.cc.Invoke(ctx, "/terra.wasm.v1beta1.Msg/StoreCode", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) MigrateCode(ctx context.Context, in *MsgMigrateCode, opts ...grpc.CallOption) (*MsgMigrateCodeResponse, error) { + out := new(MsgMigrateCodeResponse) + err := c.cc.Invoke(ctx, "/terra.wasm.v1beta1.Msg/MigrateCode", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) InstantiateContract(ctx context.Context, in *MsgInstantiateContract, opts ...grpc.CallOption) (*MsgInstantiateContractResponse, error) { + out := new(MsgInstantiateContractResponse) + err := c.cc.Invoke(ctx, "/terra.wasm.v1beta1.Msg/InstantiateContract", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) ExecuteContract(ctx context.Context, in *MsgExecuteContract, opts ...grpc.CallOption) (*MsgExecuteContractResponse, error) { + out := new(MsgExecuteContractResponse) + err := c.cc.Invoke(ctx, "/terra.wasm.v1beta1.Msg/ExecuteContract", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) MigrateContract(ctx context.Context, in *MsgMigrateContract, opts ...grpc.CallOption) (*MsgMigrateContractResponse, error) { + out := new(MsgMigrateContractResponse) + err := c.cc.Invoke(ctx, "/terra.wasm.v1beta1.Msg/MigrateContract", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) UpdateContractAdmin(ctx context.Context, in *MsgUpdateContractAdmin, opts ...grpc.CallOption) (*MsgUpdateContractAdminResponse, error) { + out := new(MsgUpdateContractAdminResponse) + err := c.cc.Invoke(ctx, "/terra.wasm.v1beta1.Msg/UpdateContractAdmin", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) ClearContractAdmin(ctx context.Context, in *MsgClearContractAdmin, opts ...grpc.CallOption) (*MsgClearContractAdminResponse, error) { + out := new(MsgClearContractAdminResponse) + err := c.cc.Invoke(ctx, "/terra.wasm.v1beta1.Msg/ClearContractAdmin", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + // StoreCode to submit Wasm code to the system + StoreCode(context.Context, *MsgStoreCode) (*MsgStoreCodeResponse, error) + // MigrateCode to submit new version Wasm code to the system + MigrateCode(context.Context, *MsgMigrateCode) (*MsgMigrateCodeResponse, error) + // Instantiate creates a new smart contract instance for the given code id. + InstantiateContract(context.Context, *MsgInstantiateContract) (*MsgInstantiateContractResponse, error) + // Execute submits the given message data to a smart contract + ExecuteContract(context.Context, *MsgExecuteContract) (*MsgExecuteContractResponse, error) + // Migrate runs a code upgrade/ downgrade for a smart contract + MigrateContract(context.Context, *MsgMigrateContract) (*MsgMigrateContractResponse, error) + // UpdateContractAdmin sets a new admin for a smart contract + UpdateContractAdmin(context.Context, *MsgUpdateContractAdmin) (*MsgUpdateContractAdminResponse, error) + // ClearContractAdmin remove admin flag from a smart contract + ClearContractAdmin(context.Context, *MsgClearContractAdmin) (*MsgClearContractAdminResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct{} + +func (*UnimplementedMsgServer) StoreCode(ctx context.Context, req *MsgStoreCode) (*MsgStoreCodeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method StoreCode not implemented") +} + +func (*UnimplementedMsgServer) MigrateCode(ctx context.Context, req *MsgMigrateCode) (*MsgMigrateCodeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MigrateCode not implemented") +} + +func (*UnimplementedMsgServer) InstantiateContract(ctx context.Context, req *MsgInstantiateContract) (*MsgInstantiateContractResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method InstantiateContract not implemented") +} + +func (*UnimplementedMsgServer) ExecuteContract(ctx context.Context, req *MsgExecuteContract) (*MsgExecuteContractResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ExecuteContract not implemented") +} + +func (*UnimplementedMsgServer) MigrateContract(ctx context.Context, req *MsgMigrateContract) (*MsgMigrateContractResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MigrateContract not implemented") +} + +func (*UnimplementedMsgServer) UpdateContractAdmin(ctx context.Context, req *MsgUpdateContractAdmin) (*MsgUpdateContractAdminResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateContractAdmin not implemented") +} + +func (*UnimplementedMsgServer) ClearContractAdmin(ctx context.Context, req *MsgClearContractAdmin) (*MsgClearContractAdminResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClearContractAdmin not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_StoreCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgStoreCode) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).StoreCode(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.wasm.v1beta1.Msg/StoreCode", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).StoreCode(ctx, req.(*MsgStoreCode)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_MigrateCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgMigrateCode) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MigrateCode(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.wasm.v1beta1.Msg/MigrateCode", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MigrateCode(ctx, req.(*MsgMigrateCode)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_InstantiateContract_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgInstantiateContract) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).InstantiateContract(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.wasm.v1beta1.Msg/InstantiateContract", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).InstantiateContract(ctx, req.(*MsgInstantiateContract)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_ExecuteContract_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgExecuteContract) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).ExecuteContract(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.wasm.v1beta1.Msg/ExecuteContract", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ExecuteContract(ctx, req.(*MsgExecuteContract)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_MigrateContract_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgMigrateContract) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MigrateContract(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.wasm.v1beta1.Msg/MigrateContract", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MigrateContract(ctx, req.(*MsgMigrateContract)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_UpdateContractAdmin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateContractAdmin) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateContractAdmin(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.wasm.v1beta1.Msg/UpdateContractAdmin", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateContractAdmin(ctx, req.(*MsgUpdateContractAdmin)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_ClearContractAdmin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgClearContractAdmin) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).ClearContractAdmin(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.wasm.v1beta1.Msg/ClearContractAdmin", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ClearContractAdmin(ctx, req.(*MsgClearContractAdmin)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "terra.wasm.v1beta1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "StoreCode", + Handler: _Msg_StoreCode_Handler, + }, + { + MethodName: "MigrateCode", + Handler: _Msg_MigrateCode_Handler, + }, + { + MethodName: "InstantiateContract", + Handler: _Msg_InstantiateContract_Handler, + }, + { + MethodName: "ExecuteContract", + Handler: _Msg_ExecuteContract_Handler, + }, + { + MethodName: "MigrateContract", + Handler: _Msg_MigrateContract_Handler, + }, + { + MethodName: "UpdateContractAdmin", + Handler: _Msg_UpdateContractAdmin_Handler, + }, + { + MethodName: "ClearContractAdmin", + Handler: _Msg_ClearContractAdmin_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "terra/wasm/v1beta1/tx.proto", +} + +func (m *MsgStoreCode) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgStoreCode) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgStoreCode) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.WASMByteCode) > 0 { + i -= len(m.WASMByteCode) + copy(dAtA[i:], m.WASMByteCode) + i = encodeVarintTx(dAtA, i, uint64(len(m.WASMByteCode))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgStoreCodeResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgStoreCodeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgStoreCodeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CodeID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CodeID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgMigrateCode) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgMigrateCode) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMigrateCode) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.WASMByteCode) > 0 { + i -= len(m.WASMByteCode) + copy(dAtA[i:], m.WASMByteCode) + i = encodeVarintTx(dAtA, i, uint64(len(m.WASMByteCode))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0x12 + } + if m.CodeID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CodeID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgMigrateCodeResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgMigrateCodeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMigrateCodeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgInstantiateContract) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgInstantiateContract) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgInstantiateContract) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.InitCoins) > 0 { + for iNdEx := len(m.InitCoins) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.InitCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if len(m.InitMsg) > 0 { + i -= len(m.InitMsg) + copy(dAtA[i:], m.InitMsg) + i = encodeVarintTx(dAtA, i, uint64(len(m.InitMsg))) + i-- + dAtA[i] = 0x22 + } + if m.CodeID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CodeID)) + i-- + dAtA[i] = 0x18 + } + if len(m.Admin) > 0 { + i -= len(m.Admin) + copy(dAtA[i:], m.Admin) + i = encodeVarintTx(dAtA, i, uint64(len(m.Admin))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgInstantiateContractResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgInstantiateContractResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgInstantiateContractResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTx(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 + } + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgExecuteContract) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgExecuteContract) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgExecuteContract) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Coins) > 0 { + for iNdEx := len(m.Coins) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Coins[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if len(m.ExecuteMsg) > 0 { + i -= len(m.ExecuteMsg) + copy(dAtA[i:], m.ExecuteMsg) + i = encodeVarintTx(dAtA, i, uint64(len(m.ExecuteMsg))) + i-- + dAtA[i] = 0x1a + } + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgExecuteContractResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgExecuteContractResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgExecuteContractResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTx(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgMigrateContract) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgMigrateContract) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMigrateContract) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.MigrateMsg) > 0 { + i -= len(m.MigrateMsg) + copy(dAtA[i:], m.MigrateMsg) + i = encodeVarintTx(dAtA, i, uint64(len(m.MigrateMsg))) + i-- + dAtA[i] = 0x22 + } + if m.NewCodeID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.NewCodeID)) + i-- + dAtA[i] = 0x18 + } + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0x12 + } + if len(m.Admin) > 0 { + i -= len(m.Admin) + copy(dAtA[i:], m.Admin) + i = encodeVarintTx(dAtA, i, uint64(len(m.Admin))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgMigrateContractResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgMigrateContractResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMigrateContractResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTx(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateContractAdmin) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateContractAdmin) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateContractAdmin) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0x1a + } + if len(m.NewAdmin) > 0 { + i -= len(m.NewAdmin) + copy(dAtA[i:], m.NewAdmin) + i = encodeVarintTx(dAtA, i, uint64(len(m.NewAdmin))) + i-- + dAtA[i] = 0x12 + } + if len(m.Admin) > 0 { + i -= len(m.Admin) + copy(dAtA[i:], m.Admin) + i = encodeVarintTx(dAtA, i, uint64(len(m.Admin))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateContractAdminResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateContractAdminResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateContractAdminResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgClearContractAdmin) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgClearContractAdmin) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgClearContractAdmin) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0x12 + } + if len(m.Admin) > 0 { + i -= len(m.Admin) + copy(dAtA[i:], m.Admin) + i = encodeVarintTx(dAtA, i, uint64(len(m.Admin))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgClearContractAdminResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgClearContractAdminResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgClearContractAdminResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} + +func (m *MsgStoreCode) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.WASMByteCode) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgStoreCodeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CodeID != 0 { + n += 1 + sovTx(uint64(m.CodeID)) + } + return n +} + +func (m *MsgMigrateCode) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CodeID != 0 { + n += 1 + sovTx(uint64(m.CodeID)) + } + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.WASMByteCode) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgMigrateCodeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgInstantiateContract) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Admin) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.CodeID != 0 { + n += 1 + sovTx(uint64(m.CodeID)) + } + l = len(m.InitMsg) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.InitCoins) > 0 { + for _, e := range m.InitCoins { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgInstantiateContractResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgExecuteContract) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.ExecuteMsg) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Coins) > 0 { + for _, e := range m.Coins { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgExecuteContractResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgMigrateContract) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Admin) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.NewCodeID != 0 { + n += 1 + sovTx(uint64(m.NewCodeID)) + } + l = len(m.MigrateMsg) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgMigrateContractResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgUpdateContractAdmin) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Admin) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.NewAdmin) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgUpdateContractAdminResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgClearContractAdmin) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Admin) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgClearContractAdminResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} + +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func (m *MsgStoreCode) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgStoreCode: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgStoreCode: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WASMByteCode", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WASMByteCode = append(m.WASMByteCode[:0], dAtA[iNdEx:postIndex]...) + if m.WASMByteCode == nil { + m.WASMByteCode = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgStoreCodeResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgStoreCodeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgStoreCodeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType) + } + m.CodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CodeID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgMigrateCode) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgMigrateCode: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgMigrateCode: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType) + } + m.CodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CodeID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WASMByteCode", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WASMByteCode = append(m.WASMByteCode[:0], dAtA[iNdEx:postIndex]...) + if m.WASMByteCode == nil { + m.WASMByteCode = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgMigrateCodeResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgMigrateCodeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgMigrateCodeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgInstantiateContract) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgInstantiateContract: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgInstantiateContract: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Admin = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType) + } + m.CodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CodeID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitMsg", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InitMsg = append(m.InitMsg[:0], dAtA[iNdEx:postIndex]...) + if m.InitMsg == nil { + m.InitMsg = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitCoins", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InitCoins = append(m.InitCoins, types.Coin{}) + if err := m.InitCoins[len(m.InitCoins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgInstantiateContractResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgInstantiateContractResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgInstantiateContractResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgExecuteContract) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgExecuteContract: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgExecuteContract: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecuteMsg", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExecuteMsg = append(m.ExecuteMsg[:0], dAtA[iNdEx:postIndex]...) + if m.ExecuteMsg == nil { + m.ExecuteMsg = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Coins", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Coins = append(m.Coins, types.Coin{}) + if err := m.Coins[len(m.Coins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgExecuteContractResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgExecuteContractResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgExecuteContractResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgMigrateContract) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgMigrateContract: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgMigrateContract: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Admin = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewCodeID", wireType) + } + m.NewCodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewCodeID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MigrateMsg", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MigrateMsg = append(m.MigrateMsg[:0], dAtA[iNdEx:postIndex]...) + if m.MigrateMsg == nil { + m.MigrateMsg = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgMigrateContractResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgMigrateContractResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgMigrateContractResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgUpdateContractAdmin) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateContractAdmin: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateContractAdmin: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Admin = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewAdmin", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewAdmin = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgUpdateContractAdminResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateContractAdminResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateContractAdminResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgClearContractAdmin) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgClearContractAdmin: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgClearContractAdmin: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Admin = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgClearContractAdminResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgClearContractAdminResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgClearContractAdminResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/custom/wasm/types/legacy/wasm.pb.go b/custom/wasm/types/legacy/wasm.pb.go new file mode 100644 index 000000000..fe7a60f48 --- /dev/null +++ b/custom/wasm/types/legacy/wasm.pb.go @@ -0,0 +1,846 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: terra/wasm/v1beta1/wasm.proto + +package legacy + +import ( + bytes "bytes" + encoding_json "encoding/json" + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/gogo/protobuf/proto" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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 + +// CodeInfo is data for the uploaded contract WASM code +type LegacyCodeInfo struct { + // CodeID is the sequentially increasing unique identifier + CodeID uint64 `protobuf:"varint,1,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty" yaml:"code_id"` + // CodeHash is the unique identifier created by wasmvm + CodeHash []byte `protobuf:"bytes,2,opt,name=code_hash,json=codeHash,proto3" json:"code_hash,omitempty" yaml:"code_hash"` + // Creator address who initially stored the code + Creator string `protobuf:"bytes,3,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"` +} + +func (m *LegacyCodeInfo) Reset() { *m = LegacyCodeInfo{} } +func (m *LegacyCodeInfo) String() string { return proto.CompactTextString(m) } +func (*LegacyCodeInfo) ProtoMessage() {} +func (*LegacyCodeInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_2bd5d0123068c880, []int{0} +} + +func (m *LegacyCodeInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *LegacyCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LegacyCodeInfo.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *LegacyCodeInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_LegacyCodeInfo.Merge(m, src) +} + +func (m *LegacyCodeInfo) XXX_Size() int { + return m.Size() +} + +func (m *LegacyCodeInfo) XXX_DiscardUnknown() { + xxx_messageInfo_LegacyCodeInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_LegacyCodeInfo proto.InternalMessageInfo + +func (m *LegacyCodeInfo) GetCodeID() uint64 { + if m != nil { + return m.CodeID + } + return 0 +} + +func (m *LegacyCodeInfo) GetCodeHash() []byte { + if m != nil { + return m.CodeHash + } + return nil +} + +func (m *LegacyCodeInfo) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +// ContractInfo stores a WASM contract instance +type LegacyContractInfo struct { + // Address is the address of the contract + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty" yaml:"address"` + // Creator is the contract creator address + Creator string `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"` + // Admin is who can execute the contract migration + Admin string `protobuf:"bytes,3,opt,name=admin,proto3" json:"admin,omitempty" yaml:"admin"` + // CodeID is the reference to the stored Wasm code + CodeID uint64 `protobuf:"varint,4,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty" yaml:"code_id"` + // InitMsg is the raw message used when instantiating a contract + InitMsg encoding_json.RawMessage `protobuf:"bytes,5,opt,name=init_msg,json=initMsg,proto3,casttype=encoding/json.RawMessage" json:"init_msg,omitempty" yaml:"init_msg"` +} + +func (m *LegacyContractInfo) Reset() { *m = LegacyContractInfo{} } +func (m *LegacyContractInfo) String() string { return proto.CompactTextString(m) } +func (*LegacyContractInfo) ProtoMessage() {} +func (*LegacyContractInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_2bd5d0123068c880, []int{1} +} + +func (m *LegacyContractInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *LegacyContractInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LegacyContractInfo.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *LegacyContractInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_LegacyContractInfo.Merge(m, src) +} + +func (m *LegacyContractInfo) XXX_Size() int { + return m.Size() +} + +func (m *LegacyContractInfo) XXX_DiscardUnknown() { + xxx_messageInfo_LegacyContractInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_LegacyContractInfo proto.InternalMessageInfo + +func (m *LegacyContractInfo) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *LegacyContractInfo) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *LegacyContractInfo) GetAdmin() string { + if m != nil { + return m.Admin + } + return "" +} + +func (m *LegacyContractInfo) GetCodeID() uint64 { + if m != nil { + return m.CodeID + } + return 0 +} + +func (m *LegacyContractInfo) GetInitMsg() encoding_json.RawMessage { + if m != nil { + return m.InitMsg + } + return nil +} + +func init() { + proto.RegisterType((*LegacyCodeInfo)(nil), "terra.wasm.v1beta1.LegacyCodeInfo") + proto.RegisterType((*LegacyContractInfo)(nil), "terra.wasm.v1beta1.LegacyContractInfo") +} + +func init() { proto.RegisterFile("terra/wasm/v1beta1/wasm.proto", fileDescriptor_2bd5d0123068c880) } + +var fileDescriptor_2bd5d0123068c880 = []byte{ + // 407 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x31, 0x6f, 0xd4, 0x30, + 0x14, 0xc7, 0xcf, 0xc7, 0xf5, 0xae, 0xb5, 0xaa, 0x52, 0x59, 0x1d, 0x22, 0x04, 0xc9, 0xc9, 0x03, + 0xba, 0xa1, 0x9c, 0x75, 0x20, 0x06, 0x3a, 0x06, 0x06, 0x8a, 0xe8, 0x12, 0x36, 0x96, 0xca, 0x67, + 0x1b, 0xc7, 0xe8, 0x62, 0x57, 0xb6, 0xdb, 0xea, 0xbe, 0x05, 0x1f, 0x01, 0x36, 0x3e, 0x0a, 0x63, + 0x47, 0xa6, 0x08, 0xe5, 0x16, 0xe6, 0x8c, 0x4c, 0x28, 0x4e, 0x22, 0x85, 0x09, 0x75, 0x7b, 0xf6, + 0xef, 0xa7, 0xf7, 0x9e, 0xfe, 0x7a, 0xf0, 0x89, 0x17, 0xd6, 0x52, 0x72, 0x4b, 0x5d, 0x41, 0x6e, + 0x56, 0x6b, 0xe1, 0xe9, 0x2a, 0x3c, 0x96, 0x57, 0xd6, 0x78, 0x83, 0x50, 0xc0, 0xcb, 0xf0, 0xd3, + 0xe1, 0x47, 0x27, 0xd2, 0x48, 0x13, 0x30, 0x69, 0xaa, 0xd6, 0xc4, 0xdf, 0x01, 0x3c, 0x7a, 0x2f, + 0x24, 0x65, 0xdb, 0xd7, 0x86, 0x8b, 0x73, 0xfd, 0xc9, 0xa0, 0x97, 0x70, 0xc6, 0x0c, 0x17, 0x97, + 0x8a, 0x47, 0x60, 0x0e, 0x16, 0x93, 0xf4, 0x71, 0x55, 0x26, 0xd3, 0x80, 0xdf, 0xd4, 0x65, 0x72, + 0xb4, 0xa5, 0xc5, 0xe6, 0x0c, 0x77, 0x0a, 0xce, 0xa6, 0x4d, 0x75, 0xce, 0xd1, 0x0a, 0x1e, 0x84, + 0xbf, 0x9c, 0xba, 0x3c, 0x1a, 0xcf, 0xc1, 0xe2, 0x30, 0x3d, 0xa9, 0xcb, 0xe4, 0x78, 0xa0, 0x37, + 0x08, 0x67, 0xfb, 0x4d, 0xfd, 0x96, 0xba, 0x1c, 0x9d, 0xc2, 0x19, 0xb3, 0x82, 0x7a, 0x63, 0xa3, + 0x07, 0x73, 0xb0, 0x38, 0x48, 0xd1, 0xa0, 0x7f, 0x0b, 0x70, 0xd6, 0x2b, 0xf8, 0xdb, 0x18, 0xa2, + 0x7e, 0x55, 0xed, 0x2d, 0x65, 0x3e, 0xac, 0x7b, 0x0a, 0x67, 0x94, 0x73, 0x2b, 0x9c, 0x0b, 0xeb, + 0xfe, 0xd3, 0xa4, 0x03, 0x38, 0xeb, 0x95, 0xe1, 0xc8, 0xf1, 0x7f, 0x47, 0xa2, 0xa7, 0x70, 0x8f, + 0xf2, 0x42, 0xe9, 0x6e, 0xbd, 0xe3, 0xba, 0x4c, 0x0e, 0xfb, 0xce, 0x85, 0xd2, 0x38, 0x6b, 0xf1, + 0x30, 0xb2, 0xc9, 0x3d, 0x22, 0x7b, 0x07, 0xf7, 0x95, 0x56, 0xfe, 0xb2, 0x70, 0x32, 0xda, 0x0b, + 0x89, 0x91, 0xba, 0x4c, 0x1e, 0xb6, 0x76, 0x4f, 0xf0, 0x9f, 0x32, 0x89, 0x84, 0x66, 0x86, 0x2b, + 0x2d, 0xc9, 0x67, 0x67, 0xf4, 0x32, 0xa3, 0xb7, 0x17, 0xc2, 0x39, 0x2a, 0x45, 0x36, 0x6b, 0xb4, + 0x0b, 0x27, 0xcf, 0x26, 0xbf, 0xbf, 0x26, 0x20, 0xfd, 0xf0, 0xa3, 0x8a, 0xc1, 0x5d, 0x15, 0x83, + 0x5f, 0x55, 0x0c, 0xbe, 0xec, 0xe2, 0xd1, 0xdd, 0x2e, 0x1e, 0xfd, 0xdc, 0xc5, 0xa3, 0x8f, 0xaf, + 0xa4, 0xf2, 0xf9, 0xf5, 0x7a, 0xc9, 0x4c, 0x41, 0xd8, 0x86, 0x3a, 0xa7, 0xd8, 0xb3, 0xf6, 0x88, + 0x98, 0xb1, 0x82, 0xdc, 0x3c, 0x27, 0xec, 0xda, 0x79, 0x53, 0xb4, 0x37, 0xe5, 0xb7, 0x57, 0xc2, + 0x91, 0x4d, 0x48, 0x7b, 0x3d, 0x0d, 0xa7, 0xf2, 0xe2, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xed, + 0x5e, 0x7e, 0xf3, 0x75, 0x02, 0x00, 0x00, +} + +func (this *LegacyContractInfo) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*LegacyContractInfo) + if !ok { + that2, ok := that.(LegacyContractInfo) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Address != that1.Address { + return false + } + if this.Creator != that1.Creator { + return false + } + if this.Admin != that1.Admin { + return false + } + if this.CodeID != that1.CodeID { + return false + } + if !bytes.Equal(this.InitMsg, that1.InitMsg) { + return false + } + return true +} + +func (m *LegacyCodeInfo) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LegacyCodeInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LegacyCodeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintWasm(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0x1a + } + if len(m.CodeHash) > 0 { + i -= len(m.CodeHash) + copy(dAtA[i:], m.CodeHash) + i = encodeVarintWasm(dAtA, i, uint64(len(m.CodeHash))) + i-- + dAtA[i] = 0x12 + } + if m.CodeID != 0 { + i = encodeVarintWasm(dAtA, i, uint64(m.CodeID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *LegacyContractInfo) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LegacyContractInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LegacyContractInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.InitMsg) > 0 { + i -= len(m.InitMsg) + copy(dAtA[i:], m.InitMsg) + i = encodeVarintWasm(dAtA, i, uint64(len(m.InitMsg))) + i-- + dAtA[i] = 0x2a + } + if m.CodeID != 0 { + i = encodeVarintWasm(dAtA, i, uint64(m.CodeID)) + i-- + dAtA[i] = 0x20 + } + if len(m.Admin) > 0 { + i -= len(m.Admin) + copy(dAtA[i:], m.Admin) + i = encodeVarintWasm(dAtA, i, uint64(len(m.Admin))) + i-- + dAtA[i] = 0x1a + } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintWasm(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0x12 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintWasm(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintWasm(dAtA []byte, offset int, v uint64) int { + offset -= sovWasm(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} + +func (m *LegacyCodeInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CodeID != 0 { + n += 1 + sovWasm(uint64(m.CodeID)) + } + l = len(m.CodeHash) + if l > 0 { + n += 1 + l + sovWasm(uint64(l)) + } + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovWasm(uint64(l)) + } + return n +} + +func (m *LegacyContractInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovWasm(uint64(l)) + } + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovWasm(uint64(l)) + } + l = len(m.Admin) + if l > 0 { + n += 1 + l + sovWasm(uint64(l)) + } + if m.CodeID != 0 { + n += 1 + sovWasm(uint64(m.CodeID)) + } + l = len(m.InitMsg) + if l > 0 { + n += 1 + l + sovWasm(uint64(l)) + } + return n +} + +func sovWasm(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} + +func sozWasm(x uint64) (n int) { + return sovWasm(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func (m *LegacyCodeInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LegacyCodeInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LegacyCodeInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType) + } + m.CodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CodeID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeHash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthWasm + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthWasm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CodeHash = append(m.CodeHash[:0], dAtA[iNdEx:postIndex]...) + if m.CodeHash == nil { + m.CodeHash = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthWasm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthWasm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipWasm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthWasm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *LegacyContractInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LegacyContractInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LegacyContractInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthWasm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthWasm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthWasm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthWasm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthWasm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthWasm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Admin = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType) + } + m.CodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CodeID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitMsg", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowWasm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthWasm + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthWasm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InitMsg = append(m.InitMsg[:0], dAtA[iNdEx:postIndex]...) + if m.InitMsg == nil { + m.InitMsg = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipWasm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthWasm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func skipWasm(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowWasm + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowWasm + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowWasm + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthWasm + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupWasm + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthWasm + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthWasm = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowWasm = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupWasm = fmt.Errorf("proto: unexpected end of group") +) diff --git a/proto/terra/wasm/v1beta1/genesis.proto b/proto/terra/wasm/v1beta1/genesis.proto new file mode 100644 index 000000000..013590676 --- /dev/null +++ b/proto/terra/wasm/v1beta1/genesis.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; +package terra.wasm.v1beta1; + +import "gogoproto/gogo.proto"; +import "terra/wasm/v1beta1/wasm.proto"; + +option go_package = "github.com/classic-terra/core/v2/custom/wasm/types/legacy"; + +// Model is a struct that holds a KV pair +message Model { + bytes key = 1; + bytes value = 2; +} + +// Code struct encompasses CodeInfo and CodeBytes +message Code { + LegacyCodeInfo code_info = 1 [(gogoproto.nullable) = false]; + bytes code_bytes = 2; +} + +// Contract struct encompasses ContractAddress, ContractInfo, and ContractState +message Contract { + LegacyContractInfo contract_info = 1 [(gogoproto.nullable) = false]; + repeated Model contract_store = 2 [(gogoproto.nullable) = false]; +} diff --git a/proto/terra/wasm/v1beta1/tx.proto b/proto/terra/wasm/v1beta1/tx.proto new file mode 100644 index 000000000..ae32ceee8 --- /dev/null +++ b/proto/terra/wasm/v1beta1/tx.proto @@ -0,0 +1,173 @@ +syntax = "proto3"; +package terra.wasm.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; + +option go_package = "github.com/classic-terra/core/v2/custom/wasm/types/legacy"; + +// Msg defines the oracle Msg service. +service Msg { + // StoreCode to submit Wasm code to the system + rpc StoreCode(MsgStoreCode) returns (MsgStoreCodeResponse); + // MigrateCode to submit new version Wasm code to the system + rpc MigrateCode(MsgMigrateCode) returns (MsgMigrateCodeResponse); + // Instantiate creates a new smart contract instance for the given code id. + rpc InstantiateContract(MsgInstantiateContract) returns (MsgInstantiateContractResponse); + // Execute submits the given message data to a smart contract + rpc ExecuteContract(MsgExecuteContract) returns (MsgExecuteContractResponse); + // Migrate runs a code upgrade/ downgrade for a smart contract + rpc MigrateContract(MsgMigrateContract) returns (MsgMigrateContractResponse); + // UpdateContractAdmin sets a new admin for a smart contract + rpc UpdateContractAdmin(MsgUpdateContractAdmin) returns (MsgUpdateContractAdminResponse); + // ClearContractAdmin remove admin flag from a smart contract + rpc ClearContractAdmin(MsgClearContractAdmin) returns (MsgClearContractAdminResponse); +} + +// MsgStoreCode represents a message to submit +// Wasm code to the system +message MsgStoreCode { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // Sender is the that actor that signed the messages + string sender = 1 [(gogoproto.moretags) = "yaml:\"sender\""]; + // WASMByteCode can be raw or gzip compressed + bytes wasm_byte_code = 2 [(gogoproto.moretags) = "yaml:\"wasm_byte_code\"", (gogoproto.customname) = "WASMByteCode"]; +} + +// MsgStoreCodeResponse defines the Msg/StoreCode response type. +message MsgStoreCodeResponse { + // CodeID is the reference to the stored WASM code + uint64 code_id = 1 [(gogoproto.moretags) = "yaml:\"code_id\"", (gogoproto.customname) = "CodeID"]; +} + +// MsgMigrateCode represents a message to submit +// Wasm code to the system +message MsgMigrateCode { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // CodeID is the migration target code id + uint64 code_id = 1 [(gogoproto.moretags) = "yaml:\"code_id\"", (gogoproto.customname) = "CodeID"]; + // Sender is the that actor that signed the messages + string sender = 2 [(gogoproto.moretags) = "yaml:\"sender\""]; + // WASMByteCode can be raw or gzip compressed + bytes wasm_byte_code = 3 [(gogoproto.moretags) = "yaml:\"wasm_byte_code\"", (gogoproto.customname) = "WASMByteCode"]; +} + +// MsgMigrateCodeResponse defines the Msg/MigrateCode response type. +message MsgMigrateCodeResponse {} + +// MsgInstantiateContract represents a message to create +// a new smart contract instance for the given +// code id. +message MsgInstantiateContract { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // Sender is an sender address + string sender = 1 [(gogoproto.moretags) = "yaml:\"sender\""]; + // Admin is an optional admin address who can migrate the contract + string admin = 2 [(gogoproto.moretags) = "yaml:\"admin\""]; + // CodeID is the reference to the stored WASM code + uint64 code_id = 3 [(gogoproto.moretags) = "yaml:\"code_id\"", (gogoproto.customname) = "CodeID"]; + // InitMsg json encoded message to be passed to the contract on instantiation + bytes init_msg = 4 [(gogoproto.moretags) = "yaml:\"init_msg\"", (gogoproto.casttype) = "encoding/json.RawMessage"]; + // InitCoins that are transferred to the contract on execution + repeated cosmos.base.v1beta1.Coin init_coins = 5 [ + (gogoproto.moretags) = "yaml:\"init_coins\"", + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins" + ]; +} + +// MsgInstantiateContractResponse defines the Msg/InstantiateContract response type. +message MsgInstantiateContractResponse { + // ContractAddress is the bech32 address of the new contract instance. + string contract_address = 1 [(gogoproto.moretags) = "yaml:\"contract_address\""]; + // Data contains base64-encoded bytes to returned from the contract + bytes data = 2 [(gogoproto.moretags) = "yaml:\"data\""]; +} + +// MsgExecuteContract represents a message to +// submits the given message data to a smart contract. +message MsgExecuteContract { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // Sender is the that actor that signed the messages + string sender = 1 [(gogoproto.moretags) = "yaml:\"sender\""]; + // Contract is the address of the smart contract + string contract = 2 [(gogoproto.moretags) = "yaml:\"contract\""]; + // ExecuteMsg json encoded message to be passed to the contract + bytes execute_msg = 3 + [(gogoproto.moretags) = "yaml:\"execute_msg\"", (gogoproto.casttype) = "encoding/json.RawMessage"]; + // Coins that are transferred to the contract on execution + repeated cosmos.base.v1beta1.Coin coins = 5 [ + (gogoproto.moretags) = "yaml:\"coins\"", + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins" + ]; +} + +// MsgExecuteContractResponse defines the Msg/ExecuteContract response type. +message MsgExecuteContractResponse { + // Data contains base64-encoded bytes to returned from the contract + bytes data = 1 [(gogoproto.moretags) = "yaml:\"data\""]; +} + +// MsgMigrateContract represents a message to +// runs a code upgrade/ downgrade for a smart contract +message MsgMigrateContract { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // Admin is the current contract admin + string admin = 1 [(gogoproto.moretags) = "yaml:\"admin\""]; + // Contract is the address of the smart contract + string contract = 2 [(gogoproto.moretags) = "yaml:\"contract\""]; + // NewCodeID references the new WASM code + uint64 new_code_id = 3 [(gogoproto.moretags) = "yaml:\"new_code_id\"", (gogoproto.customname) = "NewCodeID"]; + // MigrateMsg is json encoded message to be passed to the contract on migration + bytes migrate_msg = 4 + [(gogoproto.moretags) = "yaml:\"migrate_msg\"", (gogoproto.casttype) = "encoding/json.RawMessage"]; +} + +// MsgMigrateContractResponse defines the Msg/MigrateContract response type. +message MsgMigrateContractResponse { + // Data contains base64-encoded bytes to returned from the contract + bytes data = 1 [(gogoproto.moretags) = "yaml:\"data\""]; +} + +// MsgUpdateContractAdmin represents a message to +// sets a new admin for a smart contract +message MsgUpdateContractAdmin { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // Admin is the current contract admin + string admin = 1 [(gogoproto.moretags) = "yaml:\"admin\""]; + // NewAdmin is the new contract admin + string new_admin = 2 [(gogoproto.moretags) = "yaml:\"new_admin\""]; + // Contract is the address of the smart contract + string contract = 3 [(gogoproto.moretags) = "yaml:\"contract\""]; +} + +// MsgUpdateContractAdminResponse defines the Msg/UpdateContractAdmin response type. +message MsgUpdateContractAdminResponse {} + +// MsgClearContractAdmin represents a message to +// clear admin address from a smart contract +message MsgClearContractAdmin { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // Admin is the current contract admin + string admin = 1 [(gogoproto.moretags) = "yaml:\"admin\""]; + // Contract is the address of the smart contract + string contract = 2 [(gogoproto.moretags) = "yaml:\"contract\""]; +} + +// MsgClearContractAdminResponse defines the Msg/ClearContractAdmin response type. +message MsgClearContractAdminResponse {} diff --git a/proto/terra/wasm/v1beta1/wasm.proto b/proto/terra/wasm/v1beta1/wasm.proto new file mode 100644 index 000000000..a62dcbba8 --- /dev/null +++ b/proto/terra/wasm/v1beta1/wasm.proto @@ -0,0 +1,32 @@ +syntax = "proto3"; +package terra.wasm.v1beta1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/classic-terra/core/v2/custom/wasm/types/legacy"; + +// CodeInfo is data for the uploaded contract WASM code +message LegacyCodeInfo { + // CodeID is the sequentially increasing unique identifier + uint64 code_id = 1 [(gogoproto.moretags) = "yaml:\"code_id\"", (gogoproto.customname) = "CodeID"]; + // CodeHash is the unique identifier created by wasmvm + bytes code_hash = 2 [(gogoproto.moretags) = "yaml:\"code_hash\""]; + // Creator address who initially stored the code + string creator = 3 [(gogoproto.moretags) = "yaml:\"creator\""]; +} + +// ContractInfo stores a WASM contract instance +message LegacyContractInfo { + option (gogoproto.equal) = true; + + // Address is the address of the contract + string address = 1 [(gogoproto.moretags) = "yaml:\"address\""]; + // Creator is the contract creator address + string creator = 2 [(gogoproto.moretags) = "yaml:\"creator\""]; + // Admin is who can execute the contract migration + string admin = 3 [(gogoproto.moretags) = "yaml:\"admin\""]; + // CodeID is the reference to the stored Wasm code + uint64 code_id = 4 [(gogoproto.moretags) = "yaml:\"code_id\"", (gogoproto.customname) = "CodeID"]; + // InitMsg is the raw message used when instantiating a contract + bytes init_msg = 5 [(gogoproto.moretags) = "yaml:\"init_msg\"", (gogoproto.casttype) = "encoding/json.RawMessage"]; +} diff --git a/scripts/run-node.sh b/scripts/run-node.sh index 9d22d356a..1129d2dbd 100755 --- a/scripts/run-node.sh +++ b/scripts/run-node.sh @@ -1,9 +1,17 @@ #!/bin/bash +BINARY=$1 +CONTINUE=${CONTINUE:-"false"} +HOME_DIR=mytestnet + +if [ "$CONTINUE" == "true" ]; then + $BINARY start --home $HOME + exit 0 +fi + rm -rf mytestnet pkill terrad -BINARY=$1 # check DENOM is set. If not, set to uluna DENOM=${2:-uluna} @@ -29,7 +37,6 @@ if [ -z "$BINARY" ]; then BINARY=build/terrad fi -HOME_DIR=mytestnet CHAIN_ID="localterra" KEYRING="test" KEY="test0" diff --git a/scripts/upgrade-test.sh b/scripts/upgrade-test.sh index f378af17a..d60e24e27 100755 --- a/scripts/upgrade-test.sh +++ b/scripts/upgrade-test.sh @@ -8,7 +8,8 @@ ROOT=$(pwd) DENOM=uluna CHAIN_ID=localterra SOFTWARE_UPGRADE_NAME="v4" -ADDITIONAL_SCRIPTS=${ADDITIONAL_SCRIPTS:-""} +ADDITIONAL_PRE_SCRIPTS=${ADDITIONAL_PRE_SCRIPTS:-""} +ADDITIONAL_AFTER_SCRIPTS=${ADDITIONAL_AFTER_SCRIPTS:-""} # underscore so that go tool will not take gocache into account mkdir -p _build/gocache @@ -47,14 +48,14 @@ fi sleep 20 -# execute additional scripts -if [ ! -z "$ADDITIONAL_SCRIPTS" ]; then +# execute additional pre scripts +if [ ! -z "$ADDITIONAL_PRE_SCRIPTS" ]; then # slice ADDITIONAL_SCRIPTS by , - SCRIPTS=($(echo "$ADDITIONAL_SCRIPTS" | tr ',' ' ')) + SCRIPTS=($(echo "$ADDITIONAL_PRE_SCRIPTS" | tr ',' ' ')) for SCRIPT in "${SCRIPTS[@]}"; do # check if SCRIPT is a file if [ -f "$SCRIPT" ]; then - echo "executing additional scripts from $SCRIPT" + echo "executing additional pre scripts from $SCRIPT" source $SCRIPT sleep 5 else @@ -100,4 +101,26 @@ done sleep 5 # run new node -./_build/new/terrad start --home $HOME \ No newline at end of file +if [[ "$OSTYPE" == "darwin"* ]]; then + CONTINUE="true" screen -L -dmS node1 bash scripts/run-node.sh _build/new/terrad $DENOM +else + CONTINUE="true" screen -L -Logfile mytestnet/log-screen.txt -dmS node1 bash scripts/run-node.sh _build/new/terrad $DENOM +fi + +sleep 20 + +# execute additional after scripts +if [ ! -z "$ADDITIONAL_AFTER_SCRIPTS" ]; then + # slice ADDITIONAL_SCRIPTS by , + SCRIPTS=($(echo "$ADDITIONAL_AFTER_SCRIPTS" | tr ',' ' ')) + for SCRIPT in "${SCRIPTS[@]}"; do + # check if SCRIPT is a file + if [ -f "$SCRIPT" ]; then + echo "executing additional after scripts from $SCRIPT" + source $SCRIPT + sleep 5 + else + echo "$SCRIPT is not a file" + fi + done +fi \ No newline at end of file diff --git a/scripts/wasm/old_cw721_base.wasm b/scripts/wasm/old_cw721_base.wasm new file mode 100644 index 000000000..19b1743ab Binary files /dev/null and b/scripts/wasm/old_cw721_base.wasm differ diff --git a/scripts/wasm-deploy.sh b/scripts/wasm/wasm-deploy.sh similarity index 90% rename from scripts/wasm-deploy.sh rename to scripts/wasm/wasm-deploy.sh index 461e374b2..e9852e83c 100644 --- a/scripts/wasm-deploy.sh +++ b/scripts/wasm/wasm-deploy.sh @@ -1,11 +1,13 @@ #!/bin/sh BINARY=_build/old/terrad -CONTRACTPATH="contrib/localnet/simulation/misc/cw721_base.wasm" +CONTRACTPATH="scripts/wasm/old_cw721_base.wasm" KEYRING_BACKEND="test" HOME=mytestnet CHAIN_ID=localterra +TXHASH=() + echo "SETTING UP SMART CONTRACT INTERACTION" # create two contracts only @@ -25,6 +27,7 @@ for j in $(seq 0 1); do fi sleep 10 txhash=$(echo $out | jq -r '.txhash') + TXHASH+=($txhash) id=$($BINARY q tx $txhash -o json | jq -r '.raw_log' | jq -r '.[0].events[1].attributes[1].value') # instantiates contract @@ -39,6 +42,7 @@ for j in $(seq 0 1); do fi sleep 10 txhash=$(echo $out | jq -r '.txhash') + TXHASH+=("$txhash") contract_addr=$($BINARY q tx $txhash -o json | jq -r '.raw_log' | jq -r '.[0].events[0].attributes[3].value') # mints some tokens @@ -53,6 +57,8 @@ for j in $(seq 0 1); do echo $out >&2 exit $code fi + txhash=$(echo $out | jq -r '.txhash') + TXHASH+=("$txhash") sleep 10 done @@ -72,8 +78,14 @@ for j in $(seq 0 1); do echo $out >&2 exit $code fi + txhash=$(echo $out | jq -r '.txhash') + TXHASH+=("$txhash") sleep 10 done done + +TXHASH_STRING="${TXHASH[*]}" +echo "TXHASH = $TXHASH_STRING" +export TXHASH_STRING \ No newline at end of file diff --git a/scripts/wasm/wasm-tx-check.sh b/scripts/wasm/wasm-tx-check.sh new file mode 100644 index 000000000..7d4ed031c --- /dev/null +++ b/scripts/wasm/wasm-tx-check.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +# expecting that TXHASH from wasm-deploy.sh will be exported +# querying TXHASH after upgrade to see if it still works + +set +e + +read -r -a OLD_TXHASH <<< ${TXHASH_STRING:-""} + +echo "OLD_TXHASH = ${OLD_TXHASH[@]}" + +# loop through OLD_TXHASH +for i in "${OLD_TXHASH[@]}"; do + echo "querying $i" + ./_build/new/terrad q tx $i --output json +done \ No newline at end of file diff --git a/scripts/wasm_command.txt b/scripts/wasm_command.txt index 1b6fefc14..e6582790a 100644 --- a/scripts/wasm_command.txt +++ b/scripts/wasm_command.txt @@ -1,3 +1,4 @@ -ADDITIONAL_SCRIPTS=scripts/wasm-deploy.sh bash scripts/upgrade-test.sh +ADDITIONAL_PRE_SCRIPTS=scripts/wasm/wasm-deploy.sh bash scripts/upgrade-test.sh +ADDITIONAL_PRE_SCRIPTS=scripts/wasm/wasm-deploy.sh ADDITIONAL_AFTER_SCRIPTS=scripts/wasm/wasm-tx-check.sh bash scripts/upgrade-test.sh ./_build/new/terrad tx wasm execute terra18vd8fpwxzck93qlwghaj6arh4p7c5n896xzem5 '{"mint":{"token_id":"'4'","owner":"'terra1p20jxrllewr5meecvhtmpddexr0kkz3tdename'"}}' --from test0 --output json --gas auto --gas-adjustment 2.3 --fees 20000000uluna --chain-id test --home mytestnet --keyring-backend test -y ./_build/new/terrad q wasm contract-state smart terra18vd8fpwxzck93qlwghaj6arh4p7c5n896xzem5 '{"all_tokens":{}}' --chain-id test --home mytestnet \ No newline at end of file diff --git a/x/feeshare/types/feeshare.pb.go b/x/feeshare/types/feeshare.pb.go new file mode 100644 index 000000000..b4999feaf --- /dev/null +++ b/x/feeshare/types/feeshare.pb.go @@ -0,0 +1,442 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: terra/feeshare/v1beta1/feeshare.proto + +package types + +import ( + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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 + +// FeeShare defines an instance that organizes fee distribution conditions for +// the owner of a given smart contract +type FeeShare struct { + // contract_address is the bech32 address of a registered contract in string + // form + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"` + // deployer_address is the bech32 address of message sender. It must be the + // same as the contracts admin address. + DeployerAddress string `protobuf:"bytes,2,opt,name=deployer_address,json=deployerAddress,proto3" json:"deployer_address,omitempty"` + // withdrawer_address is the bech32 address of account receiving the + // transaction fees. + WithdrawerAddress string `protobuf:"bytes,3,opt,name=withdrawer_address,json=withdrawerAddress,proto3" json:"withdrawer_address,omitempty"` +} + +func (m *FeeShare) Reset() { *m = FeeShare{} } +func (m *FeeShare) String() string { return proto.CompactTextString(m) } +func (*FeeShare) ProtoMessage() {} +func (*FeeShare) Descriptor() ([]byte, []int) { + return fileDescriptor_2ad55025c97efc46, []int{0} +} + +func (m *FeeShare) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *FeeShare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FeeShare.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *FeeShare) XXX_Merge(src proto.Message) { + xxx_messageInfo_FeeShare.Merge(m, src) +} + +func (m *FeeShare) XXX_Size() int { + return m.Size() +} + +func (m *FeeShare) XXX_DiscardUnknown() { + xxx_messageInfo_FeeShare.DiscardUnknown(m) +} + +var xxx_messageInfo_FeeShare proto.InternalMessageInfo + +func (m *FeeShare) GetContractAddress() string { + if m != nil { + return m.ContractAddress + } + return "" +} + +func (m *FeeShare) GetDeployerAddress() string { + if m != nil { + return m.DeployerAddress + } + return "" +} + +func (m *FeeShare) GetWithdrawerAddress() string { + if m != nil { + return m.WithdrawerAddress + } + return "" +} + +func init() { + proto.RegisterType((*FeeShare)(nil), "terra.feeshare.v1beta1.FeeShare") +} + +func init() { + proto.RegisterFile("terra/feeshare/v1beta1/feeshare.proto", fileDescriptor_2ad55025c97efc46) +} + +var fileDescriptor_2ad55025c97efc46 = []byte{ + // 219 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2d, 0x49, 0x2d, 0x2a, + 0x4a, 0xd4, 0x4f, 0x4b, 0x4d, 0x2d, 0xce, 0x48, 0x2c, 0x4a, 0xd5, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, + 0x49, 0x34, 0x84, 0x0b, 0xe8, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x89, 0x81, 0x95, 0xe9, 0xc1, + 0x45, 0xa1, 0xca, 0x94, 0xfa, 0x19, 0xb9, 0x38, 0xdc, 0x52, 0x53, 0x83, 0x41, 0x82, 0x42, 0x9a, + 0x5c, 0x02, 0xc9, 0xf9, 0x79, 0x25, 0x45, 0x89, 0xc9, 0x25, 0xf1, 0x89, 0x29, 0x29, 0x45, 0xa9, + 0xc5, 0xc5, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0xfc, 0x30, 0x71, 0x47, 0x88, 0x30, 0x48, + 0x69, 0x4a, 0x6a, 0x41, 0x4e, 0x7e, 0x65, 0x6a, 0x11, 0x5c, 0x29, 0x13, 0x44, 0x29, 0x4c, 0x1c, + 0xa6, 0x54, 0x97, 0x4b, 0xa8, 0x3c, 0xb3, 0x24, 0x23, 0xa5, 0x28, 0xb1, 0x1c, 0x49, 0x31, 0x33, + 0x58, 0xb1, 0x20, 0x42, 0x06, 0xaa, 0xdc, 0xc9, 0xfb, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, + 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, + 0xe5, 0x18, 0xa2, 0x0c, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x93, + 0x73, 0x12, 0x8b, 0x8b, 0x33, 0x93, 0x75, 0x21, 0xbe, 0x4f, 0xce, 0x07, 0xf9, 0xdc, 0x48, 0xbf, + 0x02, 0x11, 0x0e, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0xdf, 0x1b, 0x03, 0x02, 0x00, + 0x00, 0xff, 0xff, 0x86, 0x31, 0x5e, 0xef, 0x26, 0x01, 0x00, 0x00, +} + +func (m *FeeShare) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FeeShare) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FeeShare) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.WithdrawerAddress) > 0 { + i -= len(m.WithdrawerAddress) + copy(dAtA[i:], m.WithdrawerAddress) + i = encodeVarintFeeshare(dAtA, i, uint64(len(m.WithdrawerAddress))) + i-- + dAtA[i] = 0x1a + } + if len(m.DeployerAddress) > 0 { + i -= len(m.DeployerAddress) + copy(dAtA[i:], m.DeployerAddress) + i = encodeVarintFeeshare(dAtA, i, uint64(len(m.DeployerAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintFeeshare(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintFeeshare(dAtA []byte, offset int, v uint64) int { + offset -= sovFeeshare(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} + +func (m *FeeShare) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovFeeshare(uint64(l)) + } + l = len(m.DeployerAddress) + if l > 0 { + n += 1 + l + sovFeeshare(uint64(l)) + } + l = len(m.WithdrawerAddress) + if l > 0 { + n += 1 + l + sovFeeshare(uint64(l)) + } + return n +} + +func sovFeeshare(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} + +func sozFeeshare(x uint64) (n int) { + return sovFeeshare(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func (m *FeeShare) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFeeshare + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FeeShare: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FeeShare: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFeeshare + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFeeshare + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthFeeshare + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeployerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFeeshare + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFeeshare + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthFeeshare + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeployerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFeeshare + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFeeshare + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthFeeshare + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithdrawerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFeeshare(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthFeeshare + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func skipFeeshare(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFeeshare + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFeeshare + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFeeshare + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthFeeshare + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupFeeshare + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthFeeshare + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthFeeshare = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFeeshare = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupFeeshare = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/feeshare/types/genesis.pb.go b/x/feeshare/types/genesis.pb.go new file mode 100644 index 000000000..11dc643bb --- /dev/null +++ b/x/feeshare/types/genesis.pb.go @@ -0,0 +1,686 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: terra/feeshare/v1beta1/genesis.proto + +package types + +import ( + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/gogo/protobuf/proto" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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 + +// Params defines the feeshare module params +type Params struct { + // enable_feeshare defines a parameter to enable the feeshare module + EnableFeeShare bool `protobuf:"varint,1,opt,name=enable_fee_share,json=enableFeeShare,proto3" json:"enable_fee_share,omitempty"` + // developer_shares defines the proportion of the transaction fees to be + // distributed to the registered contract owner + DeveloperShares github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=developer_shares,json=developerShares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"developer_shares"` + // allowed_denoms defines the list of denoms that are allowed to be paid to + // the contract withdraw addresses. If said denom is not in the list, the fees + // will ONLY be sent to the community pool. + // If this list is empty, all denoms are allowed. + AllowedDenoms []string `protobuf:"bytes,3,rep,name=allowed_denoms,json=allowedDenoms,proto3" json:"allowed_denoms,omitempty"` +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_0b6781086762d348, []int{0} +} + +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} + +func (m *Params) XXX_Size() int { + return m.Size() +} + +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +func (m *Params) GetEnableFeeShare() bool { + if m != nil { + return m.EnableFeeShare + } + return false +} + +func (m *Params) GetAllowedDenoms() []string { + if m != nil { + return m.AllowedDenoms + } + return nil +} + +// GenesisState defines the module's genesis state. +type GenesisState struct { + // params are the feeshare module parameters + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + // FeeShare is a slice of active registered contracts for fee distribution + FeeShare []FeeShare `protobuf:"bytes,2,rep,name=fee_share,json=feeShare,proto3" json:"fee_share"` +} + +func (m *GenesisState) Reset() { *m = GenesisState{} } +func (m *GenesisState) String() string { return proto.CompactTextString(m) } +func (*GenesisState) ProtoMessage() {} +func (*GenesisState) Descriptor() ([]byte, []int) { + return fileDescriptor_0b6781086762d348, []int{1} +} + +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} + +func (m *GenesisState) XXX_Size() int { + return m.Size() +} + +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +func (m *GenesisState) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func (m *GenesisState) GetFeeShare() []FeeShare { + if m != nil { + return m.FeeShare + } + return nil +} + +func init() { + proto.RegisterType((*Params)(nil), "terra.feeshare.v1beta1.Params") + proto.RegisterType((*GenesisState)(nil), "terra.feeshare.v1beta1.GenesisState") +} + +func init() { + proto.RegisterFile("terra/feeshare/v1beta1/genesis.proto", fileDescriptor_0b6781086762d348) +} + +var fileDescriptor_0b6781086762d348 = []byte{ + // 355 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xc1, 0x4e, 0xea, 0x40, + 0x14, 0x86, 0x3b, 0x70, 0x43, 0x60, 0xb8, 0x97, 0x4b, 0x9a, 0x9b, 0x1b, 0xc2, 0x62, 0x68, 0x88, + 0x98, 0x6e, 0x98, 0x09, 0xb8, 0x75, 0x85, 0x44, 0x17, 0x6e, 0x4c, 0x59, 0xe9, 0x86, 0x4c, 0xdb, + 0x43, 0x21, 0xb6, 0x4c, 0xd3, 0x19, 0x51, 0xdf, 0x42, 0xdf, 0xc5, 0x87, 0x60, 0xc9, 0xd2, 0xb8, + 0x20, 0x06, 0x5e, 0xc4, 0x74, 0x5a, 0xc0, 0x85, 0xac, 0xda, 0xf9, 0xf3, 0x9d, 0x3f, 0xe7, 0xfc, + 0x3f, 0x3e, 0x51, 0x90, 0x24, 0x9c, 0x4d, 0x00, 0xe4, 0x94, 0x27, 0xc0, 0x16, 0x3d, 0x17, 0x14, + 0xef, 0xb1, 0x00, 0xe6, 0x20, 0x67, 0x92, 0xc6, 0x89, 0x50, 0xc2, 0xfc, 0xaf, 0x29, 0xba, 0xa3, + 0x68, 0x4e, 0x35, 0xff, 0x05, 0x22, 0x10, 0x1a, 0x61, 0xe9, 0x5f, 0x46, 0x37, 0x3b, 0x47, 0x3c, + 0xf7, 0xe3, 0x1a, 0x6b, 0xbf, 0x21, 0x5c, 0xba, 0xe1, 0x09, 0x8f, 0xa4, 0x69, 0xe3, 0x3a, 0xcc, + 0xb9, 0x1b, 0xc2, 0x78, 0x02, 0x30, 0xd6, 0x50, 0x03, 0x59, 0xc8, 0x2e, 0x3b, 0xb5, 0x4c, 0xbf, + 0x04, 0x18, 0xa5, 0xaa, 0x79, 0x8b, 0xeb, 0x3e, 0x2c, 0x20, 0x14, 0x31, 0x24, 0x19, 0x28, 0x1b, + 0x05, 0x0b, 0xd9, 0x95, 0x01, 0x5d, 0xae, 0x5b, 0xc6, 0xc7, 0xba, 0x75, 0x1a, 0xcc, 0xd4, 0xf4, + 0xc1, 0xa5, 0x9e, 0x88, 0x98, 0x27, 0x64, 0x24, 0x64, 0xfe, 0xe9, 0x4a, 0xff, 0x9e, 0xa9, 0xe7, + 0x18, 0x24, 0x1d, 0x82, 0xe7, 0xfc, 0xdd, 0xfb, 0x68, 0x67, 0x69, 0x76, 0x70, 0x8d, 0x87, 0xa1, + 0x78, 0x04, 0x7f, 0xec, 0xc3, 0x5c, 0x44, 0xb2, 0x51, 0xb4, 0x8a, 0x76, 0xc5, 0xf9, 0x93, 0xab, + 0x43, 0x2d, 0xb6, 0x5f, 0x11, 0xfe, 0x7d, 0x95, 0xa5, 0x33, 0x52, 0x5c, 0x81, 0x79, 0x8e, 0x4b, + 0xb1, 0x3e, 0x43, 0xaf, 0x5c, 0xed, 0x13, 0xfa, 0x73, 0x5a, 0x34, 0x3b, 0x76, 0xf0, 0x2b, 0x5d, + 0xd4, 0xc9, 0x67, 0xcc, 0x0b, 0x5c, 0x39, 0xdc, 0x5c, 0xb0, 0x8a, 0x76, 0xb5, 0x6f, 0x1d, 0x33, + 0xd8, 0xa5, 0x90, 0x5b, 0x94, 0x27, 0xbb, 0xf7, 0xf5, 0x72, 0x43, 0xd0, 0x6a, 0x43, 0xd0, 0xe7, + 0x86, 0xa0, 0x97, 0x2d, 0x31, 0x56, 0x5b, 0x62, 0xbc, 0x6f, 0x89, 0x71, 0xd7, 0xfb, 0x9e, 0x46, + 0xc8, 0xa5, 0x9c, 0x79, 0xdd, 0xac, 0x1e, 0x4f, 0xa4, 0xd5, 0xf4, 0xd9, 0xd3, 0xa1, 0x28, 0x1d, + 0x8e, 0x5b, 0xd2, 0xf5, 0x9c, 0x7d, 0x05, 0x00, 0x00, 0xff, 0xff, 0xf0, 0xc9, 0x87, 0xf1, 0x1b, + 0x02, 0x00, 0x00, +} + +func (m *Params) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AllowedDenoms) > 0 { + for iNdEx := len(m.AllowedDenoms) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.AllowedDenoms[iNdEx]) + copy(dAtA[i:], m.AllowedDenoms[iNdEx]) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.AllowedDenoms[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + { + size := m.DeveloperShares.Size() + i -= size + if _, err := m.DeveloperShares.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if m.EnableFeeShare { + i-- + if m.EnableFeeShare { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisState) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.FeeShare) > 0 { + for iNdEx := len(m.FeeShare) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.FeeShare[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} + +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EnableFeeShare { + n += 2 + } + l = m.DeveloperShares.Size() + n += 1 + l + sovGenesis(uint64(l)) + if len(m.AllowedDenoms) > 0 { + for _, s := range m.AllowedDenoms { + l = len(s) + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + if len(m.FeeShare) > 0 { + for _, e := range m.FeeShare { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} + +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func (m *Params) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnableFeeShare", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EnableFeeShare = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeveloperShares", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DeveloperShares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllowedDenoms", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AllowedDenoms = append(m.AllowedDenoms, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *GenesisState) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeShare", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeShare = append(m.FeeShare, FeeShare{}) + if err := m.FeeShare[len(m.FeeShare)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func skipGenesis(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/feeshare/types/query.pb.go b/x/feeshare/types/query.pb.go new file mode 100644 index 000000000..a7efba6c0 --- /dev/null +++ b/x/feeshare/types/query.pb.go @@ -0,0 +1,2507 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: terra/feeshare/v1beta1/query.proto + +package types + +import ( + context "context" + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + query "github.com/cosmos/cosmos-sdk/types/query" + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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 + +// QueryFeeSharesRequest is the request type for the Query/FeeShares RPC method. +type QueryFeeSharesRequest struct { + // pagination defines an optional pagination for the request. + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryFeeSharesRequest) Reset() { *m = QueryFeeSharesRequest{} } +func (m *QueryFeeSharesRequest) String() string { return proto.CompactTextString(m) } +func (*QueryFeeSharesRequest) ProtoMessage() {} +func (*QueryFeeSharesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{0} +} + +func (m *QueryFeeSharesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryFeeSharesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryFeeSharesRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryFeeSharesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryFeeSharesRequest.Merge(m, src) +} + +func (m *QueryFeeSharesRequest) XXX_Size() int { + return m.Size() +} + +func (m *QueryFeeSharesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryFeeSharesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryFeeSharesRequest proto.InternalMessageInfo + +func (m *QueryFeeSharesRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryFeeSharesResponse is the response type for the Query/FeeShares RPC +// method. +type QueryFeeSharesResponse struct { + // FeeShare is a slice of all stored Reveneue + Feeshare []FeeShare `protobuf:"bytes,1,rep,name=feeshare,proto3" json:"feeshare"` + // pagination defines the pagination in the response. + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryFeeSharesResponse) Reset() { *m = QueryFeeSharesResponse{} } +func (m *QueryFeeSharesResponse) String() string { return proto.CompactTextString(m) } +func (*QueryFeeSharesResponse) ProtoMessage() {} +func (*QueryFeeSharesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{1} +} + +func (m *QueryFeeSharesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryFeeSharesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryFeeSharesResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryFeeSharesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryFeeSharesResponse.Merge(m, src) +} + +func (m *QueryFeeSharesResponse) XXX_Size() int { + return m.Size() +} + +func (m *QueryFeeSharesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryFeeSharesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryFeeSharesResponse proto.InternalMessageInfo + +func (m *QueryFeeSharesResponse) GetFeeshare() []FeeShare { + if m != nil { + return m.Feeshare + } + return nil +} + +func (m *QueryFeeSharesResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryFeeShareRequest is the request type for the Query/FeeShare RPC method. +type QueryFeeShareRequest struct { + // contract_address of a registered contract in bech32 format + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"` +} + +func (m *QueryFeeShareRequest) Reset() { *m = QueryFeeShareRequest{} } +func (m *QueryFeeShareRequest) String() string { return proto.CompactTextString(m) } +func (*QueryFeeShareRequest) ProtoMessage() {} +func (*QueryFeeShareRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{2} +} + +func (m *QueryFeeShareRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryFeeShareRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryFeeShareRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryFeeShareRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryFeeShareRequest.Merge(m, src) +} + +func (m *QueryFeeShareRequest) XXX_Size() int { + return m.Size() +} + +func (m *QueryFeeShareRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryFeeShareRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryFeeShareRequest proto.InternalMessageInfo + +func (m *QueryFeeShareRequest) GetContractAddress() string { + if m != nil { + return m.ContractAddress + } + return "" +} + +// QueryFeeShareResponse is the response type for the Query/FeeShare RPC method. +type QueryFeeShareResponse struct { + // FeeShare is a stored Reveneue for the queried contract + Feeshare FeeShare `protobuf:"bytes,1,opt,name=feeshare,proto3" json:"feeshare"` +} + +func (m *QueryFeeShareResponse) Reset() { *m = QueryFeeShareResponse{} } +func (m *QueryFeeShareResponse) String() string { return proto.CompactTextString(m) } +func (*QueryFeeShareResponse) ProtoMessage() {} +func (*QueryFeeShareResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{3} +} + +func (m *QueryFeeShareResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryFeeShareResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryFeeShareResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryFeeShareResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryFeeShareResponse.Merge(m, src) +} + +func (m *QueryFeeShareResponse) XXX_Size() int { + return m.Size() +} + +func (m *QueryFeeShareResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryFeeShareResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryFeeShareResponse proto.InternalMessageInfo + +func (m *QueryFeeShareResponse) GetFeeshare() FeeShare { + if m != nil { + return m.Feeshare + } + return FeeShare{} +} + +// QueryParamsRequest is the request type for the Query/Params RPC method. +type QueryParamsRequest struct{} + +func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } +func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryParamsRequest) ProtoMessage() {} +func (*QueryParamsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{4} +} + +func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsRequest.Merge(m, src) +} + +func (m *QueryParamsRequest) XXX_Size() int { + return m.Size() +} + +func (m *QueryParamsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo + +// QueryParamsResponse is the response type for the Query/Params RPC method. +type QueryParamsResponse struct { + // params is the returned FeeShare parameter + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } +func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryParamsResponse) ProtoMessage() {} +func (*QueryParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{5} +} + +func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsResponse.Merge(m, src) +} + +func (m *QueryParamsResponse) XXX_Size() int { + return m.Size() +} + +func (m *QueryParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo + +func (m *QueryParamsResponse) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +// QueryDeployerFeeSharesRequest is the request type for the +// Query/DeployerFeeShares RPC method. +type QueryDeployerFeeSharesRequest struct { + // deployer_address in bech32 format + DeployerAddress string `protobuf:"bytes,1,opt,name=deployer_address,json=deployerAddress,proto3" json:"deployer_address,omitempty"` + // pagination defines an optional pagination for the request. + Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryDeployerFeeSharesRequest) Reset() { *m = QueryDeployerFeeSharesRequest{} } +func (m *QueryDeployerFeeSharesRequest) String() string { return proto.CompactTextString(m) } +func (*QueryDeployerFeeSharesRequest) ProtoMessage() {} +func (*QueryDeployerFeeSharesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{6} +} + +func (m *QueryDeployerFeeSharesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryDeployerFeeSharesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDeployerFeeSharesRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryDeployerFeeSharesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDeployerFeeSharesRequest.Merge(m, src) +} + +func (m *QueryDeployerFeeSharesRequest) XXX_Size() int { + return m.Size() +} + +func (m *QueryDeployerFeeSharesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDeployerFeeSharesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDeployerFeeSharesRequest proto.InternalMessageInfo + +func (m *QueryDeployerFeeSharesRequest) GetDeployerAddress() string { + if m != nil { + return m.DeployerAddress + } + return "" +} + +func (m *QueryDeployerFeeSharesRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryDeployerFeeSharesResponse is the response type for the +// Query/DeployerFeeShares RPC method. +type QueryDeployerFeeSharesResponse struct { + // contract_addresses is the slice of registered contract addresses for a + // deployer + ContractAddresses []string `protobuf:"bytes,1,rep,name=contract_addresses,json=contractAddresses,proto3" json:"contract_addresses,omitempty"` + // pagination defines the pagination in the response. + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryDeployerFeeSharesResponse) Reset() { *m = QueryDeployerFeeSharesResponse{} } +func (m *QueryDeployerFeeSharesResponse) String() string { return proto.CompactTextString(m) } +func (*QueryDeployerFeeSharesResponse) ProtoMessage() {} +func (*QueryDeployerFeeSharesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{7} +} + +func (m *QueryDeployerFeeSharesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryDeployerFeeSharesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDeployerFeeSharesResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryDeployerFeeSharesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDeployerFeeSharesResponse.Merge(m, src) +} + +func (m *QueryDeployerFeeSharesResponse) XXX_Size() int { + return m.Size() +} + +func (m *QueryDeployerFeeSharesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDeployerFeeSharesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDeployerFeeSharesResponse proto.InternalMessageInfo + +func (m *QueryDeployerFeeSharesResponse) GetContractAddresses() []string { + if m != nil { + return m.ContractAddresses + } + return nil +} + +func (m *QueryDeployerFeeSharesResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryWithdrawerFeeSharesRequest is the request type for the +// Query/WithdrawerFeeShares RPC method. +type QueryWithdrawerFeeSharesRequest struct { + // withdrawer_address in bech32 format + WithdrawerAddress string `protobuf:"bytes,1,opt,name=withdrawer_address,json=withdrawerAddress,proto3" json:"withdrawer_address,omitempty"` + // pagination defines an optional pagination for the request. + Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryWithdrawerFeeSharesRequest) Reset() { *m = QueryWithdrawerFeeSharesRequest{} } +func (m *QueryWithdrawerFeeSharesRequest) String() string { return proto.CompactTextString(m) } +func (*QueryWithdrawerFeeSharesRequest) ProtoMessage() {} +func (*QueryWithdrawerFeeSharesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{8} +} + +func (m *QueryWithdrawerFeeSharesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryWithdrawerFeeSharesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryWithdrawerFeeSharesRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryWithdrawerFeeSharesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryWithdrawerFeeSharesRequest.Merge(m, src) +} + +func (m *QueryWithdrawerFeeSharesRequest) XXX_Size() int { + return m.Size() +} + +func (m *QueryWithdrawerFeeSharesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryWithdrawerFeeSharesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryWithdrawerFeeSharesRequest proto.InternalMessageInfo + +func (m *QueryWithdrawerFeeSharesRequest) GetWithdrawerAddress() string { + if m != nil { + return m.WithdrawerAddress + } + return "" +} + +func (m *QueryWithdrawerFeeSharesRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryWithdrawerFeeSharesResponse is the response type for the +// Query/WithdrawerFeeShares RPC method. +type QueryWithdrawerFeeSharesResponse struct { + // contract_addresses is the slice of registered contract addresses for a + // withdrawer + ContractAddresses []string `protobuf:"bytes,1,rep,name=contract_addresses,json=contractAddresses,proto3" json:"contract_addresses,omitempty"` + // pagination defines the pagination in the response. + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryWithdrawerFeeSharesResponse) Reset() { *m = QueryWithdrawerFeeSharesResponse{} } +func (m *QueryWithdrawerFeeSharesResponse) String() string { return proto.CompactTextString(m) } +func (*QueryWithdrawerFeeSharesResponse) ProtoMessage() {} +func (*QueryWithdrawerFeeSharesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_4e589d86998f9341, []int{9} +} + +func (m *QueryWithdrawerFeeSharesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *QueryWithdrawerFeeSharesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryWithdrawerFeeSharesResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *QueryWithdrawerFeeSharesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryWithdrawerFeeSharesResponse.Merge(m, src) +} + +func (m *QueryWithdrawerFeeSharesResponse) XXX_Size() int { + return m.Size() +} + +func (m *QueryWithdrawerFeeSharesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryWithdrawerFeeSharesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryWithdrawerFeeSharesResponse proto.InternalMessageInfo + +func (m *QueryWithdrawerFeeSharesResponse) GetContractAddresses() []string { + if m != nil { + return m.ContractAddresses + } + return nil +} + +func (m *QueryWithdrawerFeeSharesResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +func init() { + proto.RegisterType((*QueryFeeSharesRequest)(nil), "terra.feeshare.v1beta1.QueryFeeSharesRequest") + proto.RegisterType((*QueryFeeSharesResponse)(nil), "terra.feeshare.v1beta1.QueryFeeSharesResponse") + proto.RegisterType((*QueryFeeShareRequest)(nil), "terra.feeshare.v1beta1.QueryFeeShareRequest") + proto.RegisterType((*QueryFeeShareResponse)(nil), "terra.feeshare.v1beta1.QueryFeeShareResponse") + proto.RegisterType((*QueryParamsRequest)(nil), "terra.feeshare.v1beta1.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "terra.feeshare.v1beta1.QueryParamsResponse") + proto.RegisterType((*QueryDeployerFeeSharesRequest)(nil), "terra.feeshare.v1beta1.QueryDeployerFeeSharesRequest") + proto.RegisterType((*QueryDeployerFeeSharesResponse)(nil), "terra.feeshare.v1beta1.QueryDeployerFeeSharesResponse") + proto.RegisterType((*QueryWithdrawerFeeSharesRequest)(nil), "terra.feeshare.v1beta1.QueryWithdrawerFeeSharesRequest") + proto.RegisterType((*QueryWithdrawerFeeSharesResponse)(nil), "terra.feeshare.v1beta1.QueryWithdrawerFeeSharesResponse") +} + +func init() { + proto.RegisterFile("terra/feeshare/v1beta1/query.proto", fileDescriptor_4e589d86998f9341) +} + +var fileDescriptor_4e589d86998f9341 = []byte{ + // 686 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x96, 0x4f, 0x4f, 0x13, 0x4f, + 0x18, 0xc7, 0x3b, 0xfc, 0x7e, 0x36, 0xf0, 0x70, 0x10, 0x06, 0x24, 0xb8, 0xca, 0x52, 0x37, 0xa2, + 0x80, 0x76, 0x57, 0xd6, 0x7f, 0xc4, 0x78, 0x81, 0x18, 0x3c, 0x78, 0xc1, 0x72, 0x30, 0xd1, 0x03, + 0x99, 0x6e, 0xc7, 0x65, 0x13, 0xd8, 0x59, 0x76, 0x16, 0xb1, 0x31, 0xbd, 0x18, 0x5f, 0x80, 0x7f, + 0x2e, 0xc4, 0x9b, 0x07, 0xdf, 0x85, 0x47, 0x0f, 0x1c, 0x3c, 0x90, 0x78, 0xf1, 0x64, 0x4c, 0xeb, + 0x0b, 0x31, 0x3b, 0x33, 0xdb, 0xda, 0x6d, 0xb7, 0xb4, 0x84, 0xc4, 0xdb, 0x66, 0xe6, 0x79, 0x9e, + 0xef, 0xe7, 0xf9, 0xce, 0xcc, 0x93, 0x05, 0x23, 0xa2, 0x61, 0x48, 0xac, 0xe7, 0x94, 0xf2, 0x2d, + 0x12, 0x52, 0xeb, 0xc5, 0x52, 0x99, 0x46, 0x64, 0xc9, 0xda, 0xdd, 0xa3, 0x61, 0xd5, 0x0c, 0x42, + 0x16, 0x31, 0x3c, 0x25, 0x62, 0xcc, 0x24, 0xc6, 0x54, 0x31, 0xda, 0xa2, 0xc3, 0xf8, 0x0e, 0xe3, + 0x56, 0x99, 0x70, 0x2a, 0x13, 0x9a, 0xe9, 0x01, 0x71, 0x3d, 0x9f, 0x44, 0x1e, 0xf3, 0x65, 0x0d, + 0xed, 0x72, 0x86, 0x8e, 0x4b, 0x7d, 0xca, 0x3d, 0xae, 0xa2, 0xe6, 0x32, 0xa2, 0x9a, 0xd2, 0x32, + 0x6c, 0xd2, 0x65, 0x2e, 0x13, 0x9f, 0x56, 0xfc, 0xa5, 0x56, 0x2f, 0xba, 0x8c, 0xb9, 0xdb, 0xd4, + 0x22, 0x81, 0x67, 0x11, 0xdf, 0x67, 0x91, 0xd0, 0x57, 0xa5, 0x8d, 0x4d, 0x38, 0xf7, 0x38, 0x46, + 0x5c, 0xa3, 0x74, 0x23, 0x2e, 0xc5, 0x4b, 0x74, 0x77, 0x8f, 0xf2, 0x08, 0xaf, 0x01, 0xb4, 0x68, + 0xa7, 0x51, 0x01, 0xcd, 0x8f, 0xda, 0x57, 0x4c, 0xd9, 0x9a, 0x19, 0xb7, 0x66, 0x4a, 0x2f, 0x14, + 0x8b, 0xb9, 0x4e, 0x5c, 0xaa, 0x72, 0x4b, 0x7f, 0x65, 0x1a, 0x9f, 0x11, 0x4c, 0xa5, 0x15, 0x78, + 0xc0, 0x7c, 0x4e, 0xf1, 0x2a, 0x0c, 0x27, 0x1d, 0x4c, 0xa3, 0xc2, 0x7f, 0xf3, 0xa3, 0x76, 0xc1, + 0xec, 0xee, 0xa9, 0x99, 0x24, 0xaf, 0xfe, 0x7f, 0xf8, 0x73, 0x36, 0x57, 0x6a, 0xe6, 0xe1, 0x87, + 0x6d, 0x98, 0x43, 0x02, 0xf3, 0xea, 0xb1, 0x98, 0x12, 0xa0, 0x8d, 0x73, 0x05, 0x26, 0xdb, 0x30, + 0x13, 0x1f, 0x16, 0x60, 0xcc, 0x61, 0x7e, 0x14, 0x12, 0x27, 0xda, 0x24, 0x95, 0x4a, 0x48, 0x39, + 0x17, 0x6e, 0x8c, 0x94, 0xce, 0x26, 0xeb, 0x2b, 0x72, 0xd9, 0x78, 0x96, 0xf2, 0x32, 0xa3, 0x51, + 0x74, 0x92, 0x46, 0x8d, 0x49, 0xc0, 0xa2, 0xf8, 0x3a, 0x09, 0xc9, 0x4e, 0x72, 0x4a, 0xc6, 0x06, + 0x4c, 0xb4, 0xad, 0x2a, 0xc1, 0xfb, 0x90, 0x0f, 0xc4, 0x8a, 0x92, 0xd3, 0xb3, 0xe4, 0x64, 0x9e, + 0x12, 0x53, 0x39, 0xc6, 0x7b, 0x04, 0x33, 0xa2, 0xea, 0x03, 0x1a, 0x6c, 0xb3, 0x2a, 0x0d, 0x3b, + 0x2e, 0xc7, 0x02, 0x8c, 0x55, 0xd4, 0x5e, 0xda, 0x94, 0x64, 0x5d, 0x99, 0x92, 0xba, 0x47, 0x43, + 0x27, 0xbe, 0x47, 0x07, 0x08, 0xf4, 0x2c, 0x28, 0xd5, 0x75, 0x11, 0x70, 0xfa, 0xa8, 0x28, 0x17, + 0x37, 0x6b, 0xa4, 0x34, 0x9e, 0x3a, 0x2c, 0xca, 0x4f, 0xef, 0xea, 0x1c, 0x20, 0x98, 0x15, 0x68, + 0x4f, 0xbc, 0x68, 0xab, 0x12, 0x92, 0xfd, 0x2e, 0x8e, 0x15, 0x01, 0xef, 0x37, 0x77, 0x53, 0x9e, + 0x8d, 0xb7, 0x76, 0x4e, 0xdb, 0xb5, 0x8f, 0x08, 0x0a, 0xd9, 0x68, 0xff, 0xd6, 0x37, 0xfb, 0x5b, + 0x1e, 0xce, 0x08, 0x38, 0xfc, 0x0e, 0xc1, 0x48, 0x93, 0x0b, 0x17, 0xb3, 0x6e, 0x6b, 0xd7, 0x49, + 0xa5, 0x99, 0xfd, 0x86, 0x4b, 0x04, 0x63, 0xee, 0xf5, 0xf7, 0xdf, 0x1f, 0x86, 0x66, 0xf1, 0x8c, + 0xd5, 0x31, 0x56, 0xe3, 0xef, 0x4d, 0x2e, 0x29, 0x3e, 0x21, 0x18, 0x4e, 0x92, 0xf1, 0xf5, 0xbe, + 0x34, 0x12, 0xa2, 0x62, 0x9f, 0xd1, 0x0a, 0x68, 0x59, 0x00, 0xd9, 0xf8, 0x46, 0x4f, 0x20, 0xeb, + 0x55, 0xfa, 0x90, 0x6a, 0xf8, 0x0d, 0x82, 0xbc, 0x7c, 0xc2, 0x78, 0xb1, 0xa7, 0x66, 0xdb, 0xd4, + 0xd0, 0xae, 0xf5, 0x15, 0xab, 0xe8, 0x2e, 0x09, 0xba, 0x0b, 0xf8, 0x7c, 0x17, 0x3a, 0x39, 0x30, + 0xf0, 0x17, 0x04, 0xe3, 0x1d, 0xcf, 0x12, 0xdf, 0xee, 0xa9, 0x92, 0x35, 0x5b, 0xb4, 0x3b, 0x83, + 0xa6, 0x0d, 0xe8, 0x62, 0x7a, 0x70, 0xd5, 0xf0, 0x57, 0x04, 0x13, 0x5d, 0xde, 0x07, 0xbe, 0xdb, + 0x93, 0x24, 0xfb, 0xb1, 0x6b, 0xcb, 0x83, 0x27, 0xaa, 0x26, 0xee, 0x89, 0x26, 0x6e, 0x61, 0xfb, + 0x98, 0x26, 0x3a, 0x67, 0x49, 0x6d, 0xf5, 0xd1, 0x61, 0x5d, 0x47, 0x47, 0x75, 0x1d, 0xfd, 0xaa, + 0xeb, 0xe8, 0x6d, 0x43, 0xcf, 0x1d, 0x35, 0xf4, 0xdc, 0x8f, 0x86, 0x9e, 0x7b, 0xba, 0xe4, 0x7a, + 0xd1, 0xd6, 0x5e, 0xd9, 0x74, 0xd8, 0x8e, 0xe5, 0x6c, 0x13, 0xce, 0x3d, 0xa7, 0x28, 0xeb, 0x3b, + 0x2c, 0xae, 0x6d, 0x5b, 0x2f, 0x5b, 0x4a, 0x51, 0x35, 0xa0, 0xbc, 0x9c, 0x17, 0xbf, 0x07, 0x37, + 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x9f, 0xb0, 0xa2, 0xf3, 0x09, 0x09, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ context.Context + _ grpc.ClientConn +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + // FeeShares retrieves all registered FeeShares + FeeShares(ctx context.Context, in *QueryFeeSharesRequest, opts ...grpc.CallOption) (*QueryFeeSharesResponse, error) + // FeeShare retrieves a registered FeeShare for a given contract address + FeeShare(ctx context.Context, in *QueryFeeShareRequest, opts ...grpc.CallOption) (*QueryFeeShareResponse, error) + // Params retrieves the FeeShare module params + Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) + // DeployerFeeShares retrieves all FeeShares that a given deployer has + // registered + DeployerFeeShares(ctx context.Context, in *QueryDeployerFeeSharesRequest, opts ...grpc.CallOption) (*QueryDeployerFeeSharesResponse, error) + // WithdrawerFeeShares retrieves all FeeShares with a given withdrawer + // address + WithdrawerFeeShares(ctx context.Context, in *QueryWithdrawerFeeSharesRequest, opts ...grpc.CallOption) (*QueryWithdrawerFeeSharesResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) FeeShares(ctx context.Context, in *QueryFeeSharesRequest, opts ...grpc.CallOption) (*QueryFeeSharesResponse, error) { + out := new(QueryFeeSharesResponse) + err := c.cc.Invoke(ctx, "/terra.feeshare.v1beta1.Query/FeeShares", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) FeeShare(ctx context.Context, in *QueryFeeShareRequest, opts ...grpc.CallOption) (*QueryFeeShareResponse, error) { + out := new(QueryFeeShareResponse) + err := c.cc.Invoke(ctx, "/terra.feeshare.v1beta1.Query/FeeShare", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { + out := new(QueryParamsResponse) + err := c.cc.Invoke(ctx, "/terra.feeshare.v1beta1.Query/Params", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) DeployerFeeShares(ctx context.Context, in *QueryDeployerFeeSharesRequest, opts ...grpc.CallOption) (*QueryDeployerFeeSharesResponse, error) { + out := new(QueryDeployerFeeSharesResponse) + err := c.cc.Invoke(ctx, "/terra.feeshare.v1beta1.Query/DeployerFeeShares", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) WithdrawerFeeShares(ctx context.Context, in *QueryWithdrawerFeeSharesRequest, opts ...grpc.CallOption) (*QueryWithdrawerFeeSharesResponse, error) { + out := new(QueryWithdrawerFeeSharesResponse) + err := c.cc.Invoke(ctx, "/terra.feeshare.v1beta1.Query/WithdrawerFeeShares", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + // FeeShares retrieves all registered FeeShares + FeeShares(context.Context, *QueryFeeSharesRequest) (*QueryFeeSharesResponse, error) + // FeeShare retrieves a registered FeeShare for a given contract address + FeeShare(context.Context, *QueryFeeShareRequest) (*QueryFeeShareResponse, error) + // Params retrieves the FeeShare module params + Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) + // DeployerFeeShares retrieves all FeeShares that a given deployer has + // registered + DeployerFeeShares(context.Context, *QueryDeployerFeeSharesRequest) (*QueryDeployerFeeSharesResponse, error) + // WithdrawerFeeShares retrieves all FeeShares with a given withdrawer + // address + WithdrawerFeeShares(context.Context, *QueryWithdrawerFeeSharesRequest) (*QueryWithdrawerFeeSharesResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct{} + +func (*UnimplementedQueryServer) FeeShares(ctx context.Context, req *QueryFeeSharesRequest) (*QueryFeeSharesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method FeeShares not implemented") +} + +func (*UnimplementedQueryServer) FeeShare(ctx context.Context, req *QueryFeeShareRequest) (*QueryFeeShareResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method FeeShare not implemented") +} + +func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") +} + +func (*UnimplementedQueryServer) DeployerFeeShares(ctx context.Context, req *QueryDeployerFeeSharesRequest) (*QueryDeployerFeeSharesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeployerFeeShares not implemented") +} + +func (*UnimplementedQueryServer) WithdrawerFeeShares(ctx context.Context, req *QueryWithdrawerFeeSharesRequest) (*QueryWithdrawerFeeSharesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WithdrawerFeeShares not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_FeeShares_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryFeeSharesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).FeeShares(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.feeshare.v1beta1.Query/FeeShares", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).FeeShares(ctx, req.(*QueryFeeSharesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_FeeShare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryFeeShareRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).FeeShare(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.feeshare.v1beta1.Query/FeeShare", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).FeeShare(ctx, req.(*QueryFeeShareRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryParamsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Params(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.feeshare.v1beta1.Query/Params", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_DeployerFeeShares_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryDeployerFeeSharesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).DeployerFeeShares(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.feeshare.v1beta1.Query/DeployerFeeShares", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).DeployerFeeShares(ctx, req.(*QueryDeployerFeeSharesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_WithdrawerFeeShares_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryWithdrawerFeeSharesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).WithdrawerFeeShares(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.feeshare.v1beta1.Query/WithdrawerFeeShares", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).WithdrawerFeeShares(ctx, req.(*QueryWithdrawerFeeSharesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "terra.feeshare.v1beta1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "FeeShares", + Handler: _Query_FeeShares_Handler, + }, + { + MethodName: "FeeShare", + Handler: _Query_FeeShare_Handler, + }, + { + MethodName: "Params", + Handler: _Query_Params_Handler, + }, + { + MethodName: "DeployerFeeShares", + Handler: _Query_DeployerFeeShares_Handler, + }, + { + MethodName: "WithdrawerFeeShares", + Handler: _Query_WithdrawerFeeShares_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "terra/feeshare/v1beta1/query.proto", +} + +func (m *QueryFeeSharesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryFeeSharesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryFeeSharesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryFeeSharesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryFeeSharesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryFeeSharesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Feeshare) > 0 { + for iNdEx := len(m.Feeshare) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Feeshare[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryFeeShareRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryFeeShareRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryFeeShareRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryFeeShareResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryFeeShareResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryFeeShareResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Feeshare.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryDeployerFeeSharesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryDeployerFeeSharesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDeployerFeeSharesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.DeployerAddress) > 0 { + i -= len(m.DeployerAddress) + copy(dAtA[i:], m.DeployerAddress) + i = encodeVarintQuery(dAtA, i, uint64(len(m.DeployerAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryDeployerFeeSharesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryDeployerFeeSharesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDeployerFeeSharesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ContractAddresses) > 0 { + for iNdEx := len(m.ContractAddresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ContractAddresses[iNdEx]) + copy(dAtA[i:], m.ContractAddresses[iNdEx]) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ContractAddresses[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryWithdrawerFeeSharesRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryWithdrawerFeeSharesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryWithdrawerFeeSharesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.WithdrawerAddress) > 0 { + i -= len(m.WithdrawerAddress) + copy(dAtA[i:], m.WithdrawerAddress) + i = encodeVarintQuery(dAtA, i, uint64(len(m.WithdrawerAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryWithdrawerFeeSharesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryWithdrawerFeeSharesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryWithdrawerFeeSharesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ContractAddresses) > 0 { + for iNdEx := len(m.ContractAddresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ContractAddresses[iNdEx]) + copy(dAtA[i:], m.ContractAddresses[iNdEx]) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ContractAddresses[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} + +func (m *QueryFeeSharesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryFeeSharesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Feeshare) > 0 { + for _, e := range m.Feeshare { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryFeeShareRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryFeeShareResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Feeshare.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryDeployerFeeSharesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DeployerAddress) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDeployerFeeSharesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ContractAddresses) > 0 { + for _, s := range m.ContractAddresses { + l = len(s) + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryWithdrawerFeeSharesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.WithdrawerAddress) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryWithdrawerFeeSharesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ContractAddresses) > 0 { + for _, s := range m.ContractAddresses { + l = len(s) + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} + +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func (m *QueryFeeSharesRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryFeeSharesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryFeeSharesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *QueryFeeSharesResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryFeeSharesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryFeeSharesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Feeshare", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Feeshare = append(m.Feeshare, FeeShare{}) + if err := m.Feeshare[len(m.Feeshare)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *QueryFeeShareRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryFeeShareRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryFeeShareRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *QueryFeeShareResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryFeeShareResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryFeeShareResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Feeshare", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Feeshare.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *QueryDeployerFeeSharesRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDeployerFeeSharesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDeployerFeeSharesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeployerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeployerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *QueryDeployerFeeSharesResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDeployerFeeSharesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDeployerFeeSharesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddresses = append(m.ContractAddresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *QueryWithdrawerFeeSharesRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryWithdrawerFeeSharesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryWithdrawerFeeSharesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithdrawerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *QueryWithdrawerFeeSharesResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryWithdrawerFeeSharesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryWithdrawerFeeSharesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddresses = append(m.ContractAddresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/feeshare/types/query.pb.gw.go b/x/feeshare/types/query.pb.gw.go new file mode 100644 index 000000000..6c1d14c38 --- /dev/null +++ b/x/feeshare/types/query.pb.gw.go @@ -0,0 +1,549 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: terra/feeshare/v1beta1/query.proto + +/* +Package types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var ( + _ codes.Code + _ io.Reader + _ status.Status + _ = runtime.String + _ = utilities.NewDoubleArray + _ = descriptor.ForMessage + _ = metadata.Join +) + +var filter_Query_FeeShares_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Query_FeeShares_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryFeeSharesRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_FeeShares_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.FeeShares(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Query_FeeShares_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryFeeSharesRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_FeeShares_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.FeeShares(ctx, &protoReq) + return msg, metadata, err +} + +func request_Query_FeeShare_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryFeeShareRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["contract_address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "contract_address") + } + + protoReq.ContractAddress, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "contract_address", err) + } + + msg, err := client.FeeShare(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Query_FeeShare_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryFeeShareRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["contract_address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "contract_address") + } + + protoReq.ContractAddress, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "contract_address", err) + } + + msg, err := server.FeeShare(ctx, &protoReq) + return msg, metadata, err +} + +func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := server.Params(ctx, &protoReq) + return msg, metadata, err +} + +var filter_Query_DeployerFeeShares_0 = &utilities.DoubleArray{Encoding: map[string]int{"deployer_address": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} + +func request_Query_DeployerFeeShares_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryDeployerFeeSharesRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["deployer_address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deployer_address") + } + + protoReq.DeployerAddress, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deployer_address", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DeployerFeeShares_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.DeployerFeeShares(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Query_DeployerFeeShares_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryDeployerFeeSharesRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["deployer_address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deployer_address") + } + + protoReq.DeployerAddress, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deployer_address", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DeployerFeeShares_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.DeployerFeeShares(ctx, &protoReq) + return msg, metadata, err +} + +var filter_Query_WithdrawerFeeShares_0 = &utilities.DoubleArray{Encoding: map[string]int{"withdrawer_address": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} + +func request_Query_WithdrawerFeeShares_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryWithdrawerFeeSharesRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["withdrawer_address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "withdrawer_address") + } + + protoReq.WithdrawerAddress, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "withdrawer_address", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_WithdrawerFeeShares_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.WithdrawerFeeShares(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Query_WithdrawerFeeShares_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryWithdrawerFeeSharesRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["withdrawer_address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "withdrawer_address") + } + + protoReq.WithdrawerAddress, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "withdrawer_address", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_WithdrawerFeeShares_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.WithdrawerFeeShares(ctx, &protoReq) + return msg, metadata, err +} + +// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". +// UnaryRPC :call QueryServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + mux.Handle("GET", pattern_Query_FeeShares_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_FeeShares_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_FeeShares_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("GET", pattern_Query_FeeShare_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_FeeShare_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_FeeShare_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("GET", pattern_Query_DeployerFeeShares_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_DeployerFeeShares_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_DeployerFeeShares_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("GET", pattern_Query_WithdrawerFeeShares_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_WithdrawerFeeShares_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_WithdrawerFeeShares_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + mux.Handle("GET", pattern_Query_FeeShares_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_FeeShares_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_FeeShares_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("GET", pattern_Query_FeeShare_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_FeeShare_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_FeeShare_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("GET", pattern_Query_DeployerFeeShares_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_DeployerFeeShares_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_DeployerFeeShares_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("GET", pattern_Query_WithdrawerFeeShares_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_WithdrawerFeeShares_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_WithdrawerFeeShares_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + return nil +} + +var ( + pattern_Query_FeeShares_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"terra", "feeshare", "v1", "fee_shares"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_FeeShare_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"terra", "feeshare", "v1", "fee_shares", "contract_address"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"terra", "feeshare", "v1", "params"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_DeployerFeeShares_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"terra", "feeshare", "v1", "fee_shares", "deployer_address"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_WithdrawerFeeShares_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"terra", "feeshare", "v1", "fee_shares", "withdrawer_address"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Query_FeeShares_0 = runtime.ForwardResponseMessage + + forward_Query_FeeShare_0 = runtime.ForwardResponseMessage + + forward_Query_Params_0 = runtime.ForwardResponseMessage + + forward_Query_DeployerFeeShares_0 = runtime.ForwardResponseMessage + + forward_Query_WithdrawerFeeShares_0 = runtime.ForwardResponseMessage +) diff --git a/x/feeshare/types/tx.pb.go b/x/feeshare/types/tx.pb.go new file mode 100644 index 000000000..feaab984f --- /dev/null +++ b/x/feeshare/types/tx.pb.go @@ -0,0 +1,1512 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: terra/feeshare/v1beta1/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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 + +// MsgRegisterFeeShare defines a message that registers a FeeShare +type MsgRegisterFeeShare struct { + // contract_address in bech32 format + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"` + // deployer_address is the bech32 address of message sender. It must be the + // same the contract's admin address + DeployerAddress string `protobuf:"bytes,2,opt,name=deployer_address,json=deployerAddress,proto3" json:"deployer_address,omitempty"` + // withdrawer_address is the bech32 address of account receiving the + // transaction fees + WithdrawerAddress string `protobuf:"bytes,3,opt,name=withdrawer_address,json=withdrawerAddress,proto3" json:"withdrawer_address,omitempty"` +} + +func (m *MsgRegisterFeeShare) Reset() { *m = MsgRegisterFeeShare{} } +func (m *MsgRegisterFeeShare) String() string { return proto.CompactTextString(m) } +func (*MsgRegisterFeeShare) ProtoMessage() {} +func (*MsgRegisterFeeShare) Descriptor() ([]byte, []int) { + return fileDescriptor_84f7f11948541b86, []int{0} +} + +func (m *MsgRegisterFeeShare) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgRegisterFeeShare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRegisterFeeShare.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgRegisterFeeShare) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRegisterFeeShare.Merge(m, src) +} + +func (m *MsgRegisterFeeShare) XXX_Size() int { + return m.Size() +} + +func (m *MsgRegisterFeeShare) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRegisterFeeShare.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRegisterFeeShare proto.InternalMessageInfo + +func (m *MsgRegisterFeeShare) GetContractAddress() string { + if m != nil { + return m.ContractAddress + } + return "" +} + +func (m *MsgRegisterFeeShare) GetDeployerAddress() string { + if m != nil { + return m.DeployerAddress + } + return "" +} + +func (m *MsgRegisterFeeShare) GetWithdrawerAddress() string { + if m != nil { + return m.WithdrawerAddress + } + return "" +} + +// MsgRegisterFeeShareResponse defines the MsgRegisterFeeShare response type +type MsgRegisterFeeShareResponse struct{} + +func (m *MsgRegisterFeeShareResponse) Reset() { *m = MsgRegisterFeeShareResponse{} } +func (m *MsgRegisterFeeShareResponse) String() string { return proto.CompactTextString(m) } +func (*MsgRegisterFeeShareResponse) ProtoMessage() {} +func (*MsgRegisterFeeShareResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_84f7f11948541b86, []int{1} +} + +func (m *MsgRegisterFeeShareResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgRegisterFeeShareResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRegisterFeeShareResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgRegisterFeeShareResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRegisterFeeShareResponse.Merge(m, src) +} + +func (m *MsgRegisterFeeShareResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgRegisterFeeShareResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRegisterFeeShareResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRegisterFeeShareResponse proto.InternalMessageInfo + +// MsgUpdateFeeShare defines a message that updates the withdrawer address for a +// registered FeeShare +type MsgUpdateFeeShare struct { + // contract_address in bech32 format + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"` + // deployer_address is the bech32 address of message sender. It must be the + // same the contract's admin address + DeployerAddress string `protobuf:"bytes,2,opt,name=deployer_address,json=deployerAddress,proto3" json:"deployer_address,omitempty"` + // withdrawer_address is the bech32 address of account receiving the + // transaction fees + WithdrawerAddress string `protobuf:"bytes,3,opt,name=withdrawer_address,json=withdrawerAddress,proto3" json:"withdrawer_address,omitempty"` +} + +func (m *MsgUpdateFeeShare) Reset() { *m = MsgUpdateFeeShare{} } +func (m *MsgUpdateFeeShare) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateFeeShare) ProtoMessage() {} +func (*MsgUpdateFeeShare) Descriptor() ([]byte, []int) { + return fileDescriptor_84f7f11948541b86, []int{2} +} + +func (m *MsgUpdateFeeShare) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgUpdateFeeShare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateFeeShare.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgUpdateFeeShare) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateFeeShare.Merge(m, src) +} + +func (m *MsgUpdateFeeShare) XXX_Size() int { + return m.Size() +} + +func (m *MsgUpdateFeeShare) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateFeeShare.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateFeeShare proto.InternalMessageInfo + +func (m *MsgUpdateFeeShare) GetContractAddress() string { + if m != nil { + return m.ContractAddress + } + return "" +} + +func (m *MsgUpdateFeeShare) GetDeployerAddress() string { + if m != nil { + return m.DeployerAddress + } + return "" +} + +func (m *MsgUpdateFeeShare) GetWithdrawerAddress() string { + if m != nil { + return m.WithdrawerAddress + } + return "" +} + +// MsgUpdateFeeShareResponse defines the MsgUpdateFeeShare response type +type MsgUpdateFeeShareResponse struct{} + +func (m *MsgUpdateFeeShareResponse) Reset() { *m = MsgUpdateFeeShareResponse{} } +func (m *MsgUpdateFeeShareResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateFeeShareResponse) ProtoMessage() {} +func (*MsgUpdateFeeShareResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_84f7f11948541b86, []int{3} +} + +func (m *MsgUpdateFeeShareResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgUpdateFeeShareResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateFeeShareResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgUpdateFeeShareResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateFeeShareResponse.Merge(m, src) +} + +func (m *MsgUpdateFeeShareResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgUpdateFeeShareResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateFeeShareResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateFeeShareResponse proto.InternalMessageInfo + +// MsgCancelFeeShare defines a message that cancels a registered FeeShare +type MsgCancelFeeShare struct { + // contract_address in bech32 format + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"` + // deployer_address is the bech32 address of message sender. It must be the + // same the contract's admin address + DeployerAddress string `protobuf:"bytes,2,opt,name=deployer_address,json=deployerAddress,proto3" json:"deployer_address,omitempty"` +} + +func (m *MsgCancelFeeShare) Reset() { *m = MsgCancelFeeShare{} } +func (m *MsgCancelFeeShare) String() string { return proto.CompactTextString(m) } +func (*MsgCancelFeeShare) ProtoMessage() {} +func (*MsgCancelFeeShare) Descriptor() ([]byte, []int) { + return fileDescriptor_84f7f11948541b86, []int{4} +} + +func (m *MsgCancelFeeShare) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgCancelFeeShare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCancelFeeShare.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgCancelFeeShare) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCancelFeeShare.Merge(m, src) +} + +func (m *MsgCancelFeeShare) XXX_Size() int { + return m.Size() +} + +func (m *MsgCancelFeeShare) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCancelFeeShare.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCancelFeeShare proto.InternalMessageInfo + +func (m *MsgCancelFeeShare) GetContractAddress() string { + if m != nil { + return m.ContractAddress + } + return "" +} + +func (m *MsgCancelFeeShare) GetDeployerAddress() string { + if m != nil { + return m.DeployerAddress + } + return "" +} + +// MsgCancelFeeShareResponse defines the MsgCancelFeeShare response type +type MsgCancelFeeShareResponse struct{} + +func (m *MsgCancelFeeShareResponse) Reset() { *m = MsgCancelFeeShareResponse{} } +func (m *MsgCancelFeeShareResponse) String() string { return proto.CompactTextString(m) } +func (*MsgCancelFeeShareResponse) ProtoMessage() {} +func (*MsgCancelFeeShareResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_84f7f11948541b86, []int{5} +} + +func (m *MsgCancelFeeShareResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgCancelFeeShareResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCancelFeeShareResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgCancelFeeShareResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCancelFeeShareResponse.Merge(m, src) +} + +func (m *MsgCancelFeeShareResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgCancelFeeShareResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCancelFeeShareResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCancelFeeShareResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgRegisterFeeShare)(nil), "terra.feeshare.v1beta1.MsgRegisterFeeShare") + proto.RegisterType((*MsgRegisterFeeShareResponse)(nil), "terra.feeshare.v1beta1.MsgRegisterFeeShareResponse") + proto.RegisterType((*MsgUpdateFeeShare)(nil), "terra.feeshare.v1beta1.MsgUpdateFeeShare") + proto.RegisterType((*MsgUpdateFeeShareResponse)(nil), "terra.feeshare.v1beta1.MsgUpdateFeeShareResponse") + proto.RegisterType((*MsgCancelFeeShare)(nil), "terra.feeshare.v1beta1.MsgCancelFeeShare") + proto.RegisterType((*MsgCancelFeeShareResponse)(nil), "terra.feeshare.v1beta1.MsgCancelFeeShareResponse") +} + +func init() { proto.RegisterFile("terra/feeshare/v1beta1/tx.proto", fileDescriptor_84f7f11948541b86) } + +var fileDescriptor_84f7f11948541b86 = []byte{ + // 431 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x94, 0xb1, 0xeb, 0xd3, 0x40, + 0x14, 0xc7, 0x73, 0xbf, 0x8a, 0xe0, 0x0d, 0xfa, 0x6b, 0x14, 0xd1, 0x54, 0x53, 0x09, 0x48, 0x2d, + 0xd2, 0x1c, 0x69, 0x37, 0x37, 0x15, 0x5c, 0xa4, 0x4b, 0xc5, 0xc5, 0xa5, 0x5c, 0x2f, 0xcf, 0x6b, + 0x20, 0xe6, 0xc2, 0xdd, 0xd5, 0xb6, 0xab, 0x7f, 0x81, 0xe0, 0xac, 0x74, 0xf1, 0x7f, 0x71, 0x2c, + 0xb8, 0x38, 0x4a, 0xeb, 0xe0, 0xe2, 0xff, 0x20, 0xb9, 0x34, 0xa9, 0x69, 0x43, 0xd5, 0x41, 0x70, + 0x0b, 0xef, 0x3e, 0xef, 0xbd, 0x0f, 0xf9, 0x5e, 0x82, 0xdb, 0x1a, 0xa4, 0xa4, 0xe4, 0x25, 0x80, + 0x9a, 0x52, 0x09, 0xe4, 0x75, 0x30, 0x01, 0x4d, 0x03, 0xa2, 0x17, 0x7e, 0x2a, 0x85, 0x16, 0xf6, + 0x75, 0x03, 0xf8, 0x05, 0xe0, 0xef, 0x00, 0xe7, 0x1a, 0x17, 0x5c, 0x18, 0x84, 0x64, 0x4f, 0x39, + 0xed, 0xdc, 0xe2, 0x42, 0xf0, 0x18, 0x08, 0x4d, 0x23, 0x42, 0x93, 0x44, 0x68, 0xaa, 0x23, 0x91, + 0xa8, 0xfc, 0xd4, 0x5b, 0x21, 0x7c, 0x75, 0xa8, 0xf8, 0x08, 0x78, 0xa4, 0x34, 0xc8, 0x27, 0x00, + 0xcf, 0xb2, 0x99, 0x76, 0x17, 0x9f, 0x33, 0x91, 0x68, 0x49, 0x99, 0x1e, 0xd3, 0x30, 0x94, 0xa0, + 0xd4, 0x0d, 0x74, 0x07, 0xdd, 0xbb, 0x34, 0xba, 0x52, 0xd4, 0x1f, 0xe6, 0xe5, 0x0c, 0x0d, 0x21, + 0x8d, 0xc5, 0x12, 0x64, 0x89, 0x9e, 0xe5, 0x68, 0x51, 0x2f, 0xd0, 0x1e, 0xb6, 0xe7, 0x91, 0x9e, + 0x86, 0x92, 0xce, 0x7f, 0x81, 0x1b, 0x06, 0x6e, 0xee, 0x4f, 0x76, 0xf8, 0x83, 0x0b, 0xdf, 0x57, + 0x6d, 0xcb, 0xbb, 0x8d, 0x5b, 0x35, 0x86, 0x23, 0x50, 0xa9, 0x48, 0x14, 0x78, 0x1f, 0x10, 0x6e, + 0x0e, 0x15, 0x7f, 0x9e, 0x86, 0x54, 0xc3, 0xff, 0xe8, 0xdf, 0xc2, 0x37, 0x8f, 0xfc, 0x4a, 0x7b, + 0x61, 0xe4, 0x1f, 0xd3, 0x84, 0x41, 0xfc, 0x6f, 0xe5, 0x2b, 0x36, 0xd5, 0x85, 0x85, 0x4d, 0xff, + 0x47, 0x03, 0x37, 0x86, 0x8a, 0xdb, 0x1f, 0x11, 0x3e, 0x3f, 0xba, 0x12, 0xf7, 0xfd, 0xfa, 0x7b, + 0xe7, 0xd7, 0xa4, 0xe3, 0x0c, 0xfe, 0x02, 0x2e, 0x5f, 0x06, 0x79, 0xf3, 0xf9, 0xdb, 0xbb, 0xb3, + 0xae, 0xd7, 0x21, 0x47, 0x9f, 0x00, 0xd1, 0x0b, 0x22, 0x77, 0x7d, 0xe3, 0x52, 0xe9, 0x3d, 0xc2, + 0x97, 0x0f, 0x83, 0x3f, 0xb1, 0xb8, 0x8a, 0x3a, 0xc1, 0x1f, 0xa3, 0xa5, 0x61, 0xcf, 0x18, 0x76, + 0xbc, 0xbb, 0xf5, 0x86, 0x33, 0xd3, 0x55, 0xf5, 0x3b, 0xcc, 0xf6, 0xc4, 0xd2, 0x2a, 0x7a, 0xd2, + 0xaf, 0x3e, 0xc0, 0xdf, 0xf9, 0x31, 0xd3, 0x55, 0xfa, 0x3d, 0x7a, 0xfa, 0x69, 0xe3, 0xa2, 0xf5, + 0xc6, 0x45, 0x5f, 0x37, 0x2e, 0x7a, 0xbb, 0x75, 0xad, 0xf5, 0xd6, 0xb5, 0xbe, 0x6c, 0x5d, 0xeb, + 0x45, 0xc0, 0x23, 0x3d, 0x9d, 0x4d, 0x7c, 0x26, 0x5e, 0x11, 0x16, 0x53, 0xa5, 0x22, 0xd6, 0xcb, + 0x47, 0x32, 0x91, 0x8d, 0xeb, 0x93, 0xc5, 0x7e, 0xb8, 0x5e, 0xa6, 0xa0, 0x26, 0x17, 0xcd, 0x1f, + 0x65, 0xf0, 0x33, 0x00, 0x00, 0xff, 0xff, 0x70, 0x8f, 0x80, 0x6a, 0xc0, 0x04, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ context.Context + _ grpc.ClientConn +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + // RegisterFeeShare registers a new contract for receiving transaction fees + RegisterFeeShare(ctx context.Context, in *MsgRegisterFeeShare, opts ...grpc.CallOption) (*MsgRegisterFeeShareResponse, error) + // UpdateFeeShare updates the withdrawer address of a FeeShare + UpdateFeeShare(ctx context.Context, in *MsgUpdateFeeShare, opts ...grpc.CallOption) (*MsgUpdateFeeShareResponse, error) + // CancelFeeShare cancels a contract's fee registration and further receival + // of transaction fees + CancelFeeShare(ctx context.Context, in *MsgCancelFeeShare, opts ...grpc.CallOption) (*MsgCancelFeeShareResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) RegisterFeeShare(ctx context.Context, in *MsgRegisterFeeShare, opts ...grpc.CallOption) (*MsgRegisterFeeShareResponse, error) { + out := new(MsgRegisterFeeShareResponse) + err := c.cc.Invoke(ctx, "/terra.feeshare.v1beta1.Msg/RegisterFeeShare", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) UpdateFeeShare(ctx context.Context, in *MsgUpdateFeeShare, opts ...grpc.CallOption) (*MsgUpdateFeeShareResponse, error) { + out := new(MsgUpdateFeeShareResponse) + err := c.cc.Invoke(ctx, "/terra.feeshare.v1beta1.Msg/UpdateFeeShare", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) CancelFeeShare(ctx context.Context, in *MsgCancelFeeShare, opts ...grpc.CallOption) (*MsgCancelFeeShareResponse, error) { + out := new(MsgCancelFeeShareResponse) + err := c.cc.Invoke(ctx, "/terra.feeshare.v1beta1.Msg/CancelFeeShare", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + // RegisterFeeShare registers a new contract for receiving transaction fees + RegisterFeeShare(context.Context, *MsgRegisterFeeShare) (*MsgRegisterFeeShareResponse, error) + // UpdateFeeShare updates the withdrawer address of a FeeShare + UpdateFeeShare(context.Context, *MsgUpdateFeeShare) (*MsgUpdateFeeShareResponse, error) + // CancelFeeShare cancels a contract's fee registration and further receival + // of transaction fees + CancelFeeShare(context.Context, *MsgCancelFeeShare) (*MsgCancelFeeShareResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct{} + +func (*UnimplementedMsgServer) RegisterFeeShare(ctx context.Context, req *MsgRegisterFeeShare) (*MsgRegisterFeeShareResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RegisterFeeShare not implemented") +} + +func (*UnimplementedMsgServer) UpdateFeeShare(ctx context.Context, req *MsgUpdateFeeShare) (*MsgUpdateFeeShareResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateFeeShare not implemented") +} + +func (*UnimplementedMsgServer) CancelFeeShare(ctx context.Context, req *MsgCancelFeeShare) (*MsgCancelFeeShareResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CancelFeeShare not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_RegisterFeeShare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRegisterFeeShare) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RegisterFeeShare(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.feeshare.v1beta1.Msg/RegisterFeeShare", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RegisterFeeShare(ctx, req.(*MsgRegisterFeeShare)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_UpdateFeeShare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateFeeShare) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateFeeShare(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.feeshare.v1beta1.Msg/UpdateFeeShare", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateFeeShare(ctx, req.(*MsgUpdateFeeShare)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_CancelFeeShare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCancelFeeShare) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CancelFeeShare(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/terra.feeshare.v1beta1.Msg/CancelFeeShare", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CancelFeeShare(ctx, req.(*MsgCancelFeeShare)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "terra.feeshare.v1beta1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "RegisterFeeShare", + Handler: _Msg_RegisterFeeShare_Handler, + }, + { + MethodName: "UpdateFeeShare", + Handler: _Msg_UpdateFeeShare_Handler, + }, + { + MethodName: "CancelFeeShare", + Handler: _Msg_CancelFeeShare_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "terra/feeshare/v1beta1/tx.proto", +} + +func (m *MsgRegisterFeeShare) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgRegisterFeeShare) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRegisterFeeShare) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.WithdrawerAddress) > 0 { + i -= len(m.WithdrawerAddress) + copy(dAtA[i:], m.WithdrawerAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.WithdrawerAddress))) + i-- + dAtA[i] = 0x1a + } + if len(m.DeployerAddress) > 0 { + i -= len(m.DeployerAddress) + copy(dAtA[i:], m.DeployerAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.DeployerAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgRegisterFeeShareResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgRegisterFeeShareResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRegisterFeeShareResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgUpdateFeeShare) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateFeeShare) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateFeeShare) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.WithdrawerAddress) > 0 { + i -= len(m.WithdrawerAddress) + copy(dAtA[i:], m.WithdrawerAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.WithdrawerAddress))) + i-- + dAtA[i] = 0x1a + } + if len(m.DeployerAddress) > 0 { + i -= len(m.DeployerAddress) + copy(dAtA[i:], m.DeployerAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.DeployerAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateFeeShareResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateFeeShareResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateFeeShareResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgCancelFeeShare) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgCancelFeeShare) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCancelFeeShare) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.DeployerAddress) > 0 { + i -= len(m.DeployerAddress) + copy(dAtA[i:], m.DeployerAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.DeployerAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgCancelFeeShareResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgCancelFeeShareResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCancelFeeShareResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} + +func (m *MsgRegisterFeeShare) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.DeployerAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.WithdrawerAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgRegisterFeeShareResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgUpdateFeeShare) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.DeployerAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.WithdrawerAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgUpdateFeeShareResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCancelFeeShare) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.DeployerAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgCancelFeeShareResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} + +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func (m *MsgRegisterFeeShare) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRegisterFeeShare: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRegisterFeeShare: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeployerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeployerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithdrawerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgRegisterFeeShareResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRegisterFeeShareResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRegisterFeeShareResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgUpdateFeeShare) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateFeeShare: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateFeeShare: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeployerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeployerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithdrawerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgUpdateFeeShareResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateFeeShareResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateFeeShareResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgCancelFeeShare) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgCancelFeeShare: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCancelFeeShare: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeployerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeployerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgCancelFeeShareResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgCancelFeeShareResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCancelFeeShareResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/feeshare/types/tx.pb.gw.go b/x/feeshare/types/tx.pb.gw.go new file mode 100644 index 000000000..a55f0f94c --- /dev/null +++ b/x/feeshare/types/tx.pb.gw.go @@ -0,0 +1,319 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: terra/feeshare/v1beta1/tx.proto + +/* +Package types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var ( + _ codes.Code + _ io.Reader + _ status.Status + _ = runtime.String + _ = utilities.NewDoubleArray + _ = descriptor.ForMessage + _ = metadata.Join +) + +var filter_Msg_RegisterFeeShare_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_RegisterFeeShare_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgRegisterFeeShare + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_RegisterFeeShare_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.RegisterFeeShare(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_RegisterFeeShare_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgRegisterFeeShare + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_RegisterFeeShare_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.RegisterFeeShare(ctx, &protoReq) + return msg, metadata, err +} + +var filter_Msg_UpdateFeeShare_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_UpdateFeeShare_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgUpdateFeeShare + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_UpdateFeeShare_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UpdateFeeShare(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_UpdateFeeShare_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgUpdateFeeShare + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_UpdateFeeShare_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.UpdateFeeShare(ctx, &protoReq) + return msg, metadata, err +} + +var filter_Msg_CancelFeeShare_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_Msg_CancelFeeShare_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgCancelFeeShare + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_CancelFeeShare_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.CancelFeeShare(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Msg_CancelFeeShare_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgCancelFeeShare + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_CancelFeeShare_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.CancelFeeShare(ctx, &protoReq) + return msg, metadata, err +} + +// RegisterMsgHandlerServer registers the http handlers for service Msg to "mux". +// UnaryRPC :call MsgServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterMsgHandlerFromEndpoint instead. +func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MsgServer) error { + mux.Handle("POST", pattern_Msg_RegisterFeeShare_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Msg_RegisterFeeShare_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_RegisterFeeShare_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_UpdateFeeShare_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Msg_UpdateFeeShare_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_UpdateFeeShare_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_CancelFeeShare_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Msg_CancelFeeShare_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_CancelFeeShare_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + return nil +} + +// RegisterMsgHandlerFromEndpoint is same as RegisterMsgHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterMsgHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterMsgHandler(ctx, mux, conn) +} + +// RegisterMsgHandler registers the http handlers for service Msg to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterMsgHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterMsgHandlerClient(ctx, mux, NewMsgClient(conn)) +} + +// RegisterMsgHandlerClient registers the http handlers for service Msg +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MsgClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MsgClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "MsgClient" to call the correct interceptors. +func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MsgClient) error { + mux.Handle("POST", pattern_Msg_RegisterFeeShare_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Msg_RegisterFeeShare_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_RegisterFeeShare_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_UpdateFeeShare_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Msg_UpdateFeeShare_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_UpdateFeeShare_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + mux.Handle("POST", pattern_Msg_CancelFeeShare_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Msg_CancelFeeShare_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_CancelFeeShare_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + return nil +} + +var ( + pattern_Msg_RegisterFeeShare_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"terra", "feeshare", "v1", "tx", "register_FeeShare"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Msg_UpdateFeeShare_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"terra", "feeshare", "v1", "tx", "update_FeeShare"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Msg_CancelFeeShare_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"terra", "feeshare", "v1", "tx", "cancel_FeeShare"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Msg_RegisterFeeShare_0 = runtime.ForwardResponseMessage + + forward_Msg_UpdateFeeShare_0 = runtime.ForwardResponseMessage + + forward_Msg_CancelFeeShare_0 = runtime.ForwardResponseMessage +) diff --git a/x/market/types/genesis.pb.go b/x/market/types/genesis.pb.go index 650e43575..ade034394 100644 --- a/x/market/types/genesis.pb.go +++ b/x/market/types/genesis.pb.go @@ -5,18 +5,21 @@ package types import ( fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -38,9 +41,11 @@ func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { return fileDescriptor_e30414b001901db3, []int{0} } + func (m *GenesisState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic) @@ -53,12 +58,15 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *GenesisState) XXX_Merge(src proto.Message) { xxx_messageInfo_GenesisState.Merge(m, src) } + func (m *GenesisState) XXX_Size() int { return m.Size() } + func (m *GenesisState) XXX_DiscardUnknown() { xxx_messageInfo_GenesisState.DiscardUnknown(m) } @@ -156,6 +164,7 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -172,9 +181,11 @@ func (m *GenesisState) Size() (n int) { func sovGenesis(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozGenesis(x uint64) (n int) { return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -291,6 +302,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } return nil } + func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/market/types/market.pb.go b/x/market/types/market.pb.go index 9090e2e61..53f7a0481 100644 --- a/x/market/types/market.pb.go +++ b/x/market/types/market.pb.go @@ -5,18 +5,21 @@ package types import ( fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -36,9 +39,11 @@ func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_114ea92c5ae3e66f, []int{0} } + func (m *Params) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Params.Marshal(b, m, deterministic) @@ -51,12 +56,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Params) XXX_Merge(src proto.Message) { xxx_messageInfo_Params.Merge(m, src) } + func (m *Params) XXX_Size() int { return m.Size() } + func (m *Params) XXX_DiscardUnknown() { xxx_messageInfo_Params.DiscardUnknown(m) } @@ -131,6 +139,7 @@ func (this *Params) Equal(that interface{}) bool { } return true } + func (m *Params) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -190,6 +199,7 @@ func encodeVarintMarket(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -209,9 +219,11 @@ func (m *Params) Size() (n int) { func sovMarket(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozMarket(x uint64) (n int) { return sovMarket(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -347,6 +359,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func skipMarket(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/market/types/query.pb.go b/x/market/types/query.pb.go index 94d784da7..c5bb72818 100644 --- a/x/market/types/query.pb.go +++ b/x/market/types/query.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" @@ -15,15 +19,14 @@ import ( grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -45,9 +48,11 @@ func (*QuerySwapRequest) ProtoMessage() {} func (*QuerySwapRequest) Descriptor() ([]byte, []int) { return fileDescriptor_c172d0f188bf2fb6, []int{0} } + func (m *QuerySwapRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QuerySwapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QuerySwapRequest.Marshal(b, m, deterministic) @@ -60,12 +65,15 @@ func (m *QuerySwapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } + func (m *QuerySwapRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QuerySwapRequest.Merge(m, src) } + func (m *QuerySwapRequest) XXX_Size() int { return m.Size() } + func (m *QuerySwapRequest) XXX_DiscardUnknown() { xxx_messageInfo_QuerySwapRequest.DiscardUnknown(m) } @@ -84,9 +92,11 @@ func (*QuerySwapResponse) ProtoMessage() {} func (*QuerySwapResponse) Descriptor() ([]byte, []int) { return fileDescriptor_c172d0f188bf2fb6, []int{1} } + func (m *QuerySwapResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QuerySwapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QuerySwapResponse.Marshal(b, m, deterministic) @@ -99,12 +109,15 @@ func (m *QuerySwapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } + func (m *QuerySwapResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QuerySwapResponse.Merge(m, src) } + func (m *QuerySwapResponse) XXX_Size() int { return m.Size() } + func (m *QuerySwapResponse) XXX_DiscardUnknown() { xxx_messageInfo_QuerySwapResponse.DiscardUnknown(m) } @@ -119,8 +132,7 @@ func (m *QuerySwapResponse) GetReturnCoin() types.Coin { } // QueryTerraPoolDeltaRequest is the request type for the Query/TerraPoolDelta RPC method. -type QueryTerraPoolDeltaRequest struct { -} +type QueryTerraPoolDeltaRequest struct{} func (m *QueryTerraPoolDeltaRequest) Reset() { *m = QueryTerraPoolDeltaRequest{} } func (m *QueryTerraPoolDeltaRequest) String() string { return proto.CompactTextString(m) } @@ -128,9 +140,11 @@ func (*QueryTerraPoolDeltaRequest) ProtoMessage() {} func (*QueryTerraPoolDeltaRequest) Descriptor() ([]byte, []int) { return fileDescriptor_c172d0f188bf2fb6, []int{2} } + func (m *QueryTerraPoolDeltaRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTerraPoolDeltaRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTerraPoolDeltaRequest.Marshal(b, m, deterministic) @@ -143,12 +157,15 @@ func (m *QueryTerraPoolDeltaRequest) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } + func (m *QueryTerraPoolDeltaRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTerraPoolDeltaRequest.Merge(m, src) } + func (m *QueryTerraPoolDeltaRequest) XXX_Size() int { return m.Size() } + func (m *QueryTerraPoolDeltaRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryTerraPoolDeltaRequest.DiscardUnknown(m) } @@ -167,9 +184,11 @@ func (*QueryTerraPoolDeltaResponse) ProtoMessage() {} func (*QueryTerraPoolDeltaResponse) Descriptor() ([]byte, []int) { return fileDescriptor_c172d0f188bf2fb6, []int{3} } + func (m *QueryTerraPoolDeltaResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTerraPoolDeltaResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTerraPoolDeltaResponse.Marshal(b, m, deterministic) @@ -182,12 +201,15 @@ func (m *QueryTerraPoolDeltaResponse) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *QueryTerraPoolDeltaResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTerraPoolDeltaResponse.Merge(m, src) } + func (m *QueryTerraPoolDeltaResponse) XXX_Size() int { return m.Size() } + func (m *QueryTerraPoolDeltaResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryTerraPoolDeltaResponse.DiscardUnknown(m) } @@ -195,8 +217,7 @@ func (m *QueryTerraPoolDeltaResponse) XXX_DiscardUnknown() { var xxx_messageInfo_QueryTerraPoolDeltaResponse proto.InternalMessageInfo // QueryParamsRequest is the request type for the Query/Params RPC method. -type QueryParamsRequest struct { -} +type QueryParamsRequest struct{} func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } @@ -204,9 +225,11 @@ func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_c172d0f188bf2fb6, []int{4} } + func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) @@ -219,12 +242,15 @@ func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsRequest.Merge(m, src) } + func (m *QueryParamsRequest) XXX_Size() int { return m.Size() } + func (m *QueryParamsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) } @@ -243,9 +269,11 @@ func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_c172d0f188bf2fb6, []int{5} } + func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) @@ -258,12 +286,15 @@ func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsResponse.Merge(m, src) } + func (m *QueryParamsResponse) XXX_Size() int { return m.Size() } + func (m *QueryParamsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) } @@ -327,8 +358,10 @@ var fileDescriptor_c172d0f188bf2fb6 = []byte{ } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ grpc.ClientConn +) // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. @@ -392,15 +425,16 @@ type QueryServer interface { } // UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} +type UnimplementedQueryServer struct{} func (*UnimplementedQueryServer) Swap(ctx context.Context, req *QuerySwapRequest) (*QuerySwapResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Swap not implemented") } + func (*UnimplementedQueryServer) TerraPoolDelta(ctx context.Context, req *QueryTerraPoolDeltaRequest) (*QueryTerraPoolDeltaResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TerraPoolDelta not implemented") } + func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } @@ -677,6 +711,7 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *QuerySwapRequest) Size() (n int) { if m == nil { return 0 @@ -748,9 +783,11 @@ func (m *QueryParamsResponse) Size() (n int) { func sovQuery(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozQuery(x uint64) (n int) { return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *QuerySwapRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -865,6 +902,7 @@ func (m *QuerySwapRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QuerySwapResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -948,6 +986,7 @@ func (m *QuerySwapResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTerraPoolDeltaRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -998,6 +1037,7 @@ func (m *QueryTerraPoolDeltaRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTerraPoolDeltaResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1081,6 +1121,7 @@ func (m *QueryTerraPoolDeltaResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1131,6 +1172,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1214,6 +1256,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/market/types/query.pb.gw.go b/x/market/types/query.pb.gw.go index 67f7fef14..dbbbea97f 100644 --- a/x/market/types/query.pb.gw.go +++ b/x/market/types/query.pb.gw.go @@ -25,18 +25,18 @@ import ( ) // Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = descriptor.ForMessage -var _ = metadata.Join - var ( - filter_Query_Swap_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + _ codes.Code + _ io.Reader + _ status.Status + _ = runtime.String + _ = utilities.NewDoubleArray + _ = descriptor.ForMessage + _ = metadata.Join ) +var filter_Query_Swap_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + func request_Query_Swap_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QuerySwapRequest var metadata runtime.ServerMetadata @@ -50,7 +50,6 @@ func request_Query_Swap_0(ctx context.Context, marshaler runtime.Marshaler, clie msg, err := client.Swap(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_Swap_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -66,7 +65,6 @@ func local_request_Query_Swap_0(ctx context.Context, marshaler runtime.Marshaler msg, err := server.Swap(ctx, &protoReq) return msg, metadata, err - } func request_Query_TerraPoolDelta_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -75,7 +73,6 @@ func request_Query_TerraPoolDelta_0(ctx context.Context, marshaler runtime.Marsh msg, err := client.TerraPoolDelta(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_TerraPoolDelta_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -84,7 +81,6 @@ func local_request_Query_TerraPoolDelta_0(ctx context.Context, marshaler runtime msg, err := server.TerraPoolDelta(ctx, &protoReq) return msg, metadata, err - } func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -93,7 +89,6 @@ func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, cl msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -102,7 +97,6 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal msg, err := server.Params(ctx, &protoReq) return msg, metadata, err - } // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". @@ -110,7 +104,6 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { - mux.Handle("GET", pattern_Query_Swap_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -131,7 +124,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_Swap_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TerraPoolDelta_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -154,7 +146,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_TerraPoolDelta_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -177,7 +168,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil @@ -220,7 +210,6 @@ func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in // "QueryClient" to call the correct interceptors. func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { - mux.Handle("GET", pattern_Query_Swap_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -238,7 +227,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_Swap_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TerraPoolDelta_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -258,7 +246,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_TerraPoolDelta_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -278,7 +265,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil diff --git a/x/market/types/tx.pb.go b/x/market/types/tx.pb.go index 076d632be..b2d003025 100644 --- a/x/market/types/tx.pb.go +++ b/x/market/types/tx.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/gogo/protobuf/grpc" @@ -13,15 +17,14 @@ import ( grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -42,9 +45,11 @@ func (*MsgSwap) ProtoMessage() {} func (*MsgSwap) Descriptor() ([]byte, []int) { return fileDescriptor_7dcd4b152743bd0f, []int{0} } + func (m *MsgSwap) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSwap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSwap.Marshal(b, m, deterministic) @@ -57,12 +62,15 @@ func (m *MsgSwap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *MsgSwap) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSwap.Merge(m, src) } + func (m *MsgSwap) XXX_Size() int { return m.Size() } + func (m *MsgSwap) XXX_DiscardUnknown() { xxx_messageInfo_MsgSwap.DiscardUnknown(m) } @@ -81,9 +89,11 @@ func (*MsgSwapResponse) ProtoMessage() {} func (*MsgSwapResponse) Descriptor() ([]byte, []int) { return fileDescriptor_7dcd4b152743bd0f, []int{1} } + func (m *MsgSwapResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSwapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSwapResponse.Marshal(b, m, deterministic) @@ -96,12 +106,15 @@ func (m *MsgSwapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } + func (m *MsgSwapResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSwapResponse.Merge(m, src) } + func (m *MsgSwapResponse) XXX_Size() int { return m.Size() } + func (m *MsgSwapResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgSwapResponse.DiscardUnknown(m) } @@ -136,9 +149,11 @@ func (*MsgSwapSend) ProtoMessage() {} func (*MsgSwapSend) Descriptor() ([]byte, []int) { return fileDescriptor_7dcd4b152743bd0f, []int{2} } + func (m *MsgSwapSend) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSwapSend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSwapSend.Marshal(b, m, deterministic) @@ -151,12 +166,15 @@ func (m *MsgSwapSend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *MsgSwapSend) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSwapSend.Merge(m, src) } + func (m *MsgSwapSend) XXX_Size() int { return m.Size() } + func (m *MsgSwapSend) XXX_DiscardUnknown() { xxx_messageInfo_MsgSwapSend.DiscardUnknown(m) } @@ -175,9 +193,11 @@ func (*MsgSwapSendResponse) ProtoMessage() {} func (*MsgSwapSendResponse) Descriptor() ([]byte, []int) { return fileDescriptor_7dcd4b152743bd0f, []int{3} } + func (m *MsgSwapSendResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgSwapSendResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgSwapSendResponse.Marshal(b, m, deterministic) @@ -190,12 +210,15 @@ func (m *MsgSwapSendResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *MsgSwapSendResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgSwapSendResponse.Merge(m, src) } + func (m *MsgSwapSendResponse) XXX_Size() int { return m.Size() } + func (m *MsgSwapSendResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgSwapSendResponse.DiscardUnknown(m) } @@ -263,8 +286,10 @@ var fileDescriptor_7dcd4b152743bd0f = []byte{ } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ grpc.ClientConn +) // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. @@ -319,12 +344,12 @@ type MsgServer interface { } // UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} +type UnimplementedMsgServer struct{} func (*UnimplementedMsgServer) Swap(ctx context.Context, req *MsgSwap) (*MsgSwapResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Swap not implemented") } + func (*UnimplementedMsgServer) SwapSend(ctx context.Context, req *MsgSwapSend) (*MsgSwapSendResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SwapSend not implemented") } @@ -584,6 +609,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgSwap) Size() (n int) { if m == nil { return 0 @@ -655,9 +681,11 @@ func (m *MsgSwapSendResponse) Size() (n int) { func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozTx(x uint64) (n int) { return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *MsgSwap) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -805,6 +833,7 @@ func (m *MsgSwap) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgSwapResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -921,6 +950,7 @@ func (m *MsgSwapResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgSwapSend) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1100,6 +1130,7 @@ func (m *MsgSwapSend) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgSwapSendResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1216,6 +1247,7 @@ func (m *MsgSwapSendResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/oracle/types/genesis.pb.go b/x/oracle/types/genesis.pb.go index 13302783b..0ef529aee 100644 --- a/x/oracle/types/genesis.pb.go +++ b/x/oracle/types/genesis.pb.go @@ -5,18 +5,21 @@ package types import ( fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -41,9 +44,11 @@ func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { return fileDescriptor_7ff46fd82c752f1f, []int{0} } + func (m *GenesisState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic) @@ -56,12 +61,15 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *GenesisState) XXX_Merge(src proto.Message) { xxx_messageInfo_GenesisState.Merge(m, src) } + func (m *GenesisState) XXX_Size() int { return m.Size() } + func (m *GenesisState) XXX_DiscardUnknown() { xxx_messageInfo_GenesisState.DiscardUnknown(m) } @@ -131,9 +139,11 @@ func (*FeederDelegation) ProtoMessage() {} func (*FeederDelegation) Descriptor() ([]byte, []int) { return fileDescriptor_7ff46fd82c752f1f, []int{1} } + func (m *FeederDelegation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *FeederDelegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_FeederDelegation.Marshal(b, m, deterministic) @@ -146,12 +156,15 @@ func (m *FeederDelegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } + func (m *FeederDelegation) XXX_Merge(src proto.Message) { xxx_messageInfo_FeederDelegation.Merge(m, src) } + func (m *FeederDelegation) XXX_Size() int { return m.Size() } + func (m *FeederDelegation) XXX_DiscardUnknown() { xxx_messageInfo_FeederDelegation.DiscardUnknown(m) } @@ -185,9 +198,11 @@ func (*MissCounter) ProtoMessage() {} func (*MissCounter) Descriptor() ([]byte, []int) { return fileDescriptor_7ff46fd82c752f1f, []int{2} } + func (m *MissCounter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MissCounter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MissCounter.Marshal(b, m, deterministic) @@ -200,12 +215,15 @@ func (m *MissCounter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *MissCounter) XXX_Merge(src proto.Message) { xxx_messageInfo_MissCounter.Merge(m, src) } + func (m *MissCounter) XXX_Size() int { return m.Size() } + func (m *MissCounter) XXX_DiscardUnknown() { xxx_messageInfo_MissCounter.DiscardUnknown(m) } @@ -239,9 +257,11 @@ func (*TobinTax) ProtoMessage() {} func (*TobinTax) Descriptor() ([]byte, []int) { return fileDescriptor_7ff46fd82c752f1f, []int{3} } + func (m *TobinTax) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *TobinTax) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TobinTax.Marshal(b, m, deterministic) @@ -254,12 +274,15 @@ func (m *TobinTax) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *TobinTax) XXX_Merge(src proto.Message) { xxx_messageInfo_TobinTax.Merge(m, src) } + func (m *TobinTax) XXX_Size() int { return m.Size() } + func (m *TobinTax) XXX_DiscardUnknown() { xxx_messageInfo_TobinTax.DiscardUnknown(m) } @@ -563,6 +586,7 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -661,9 +685,11 @@ func (m *TobinTax) Size() (n int) { func sovGenesis(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozGenesis(x uint64) (n int) { return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -951,6 +977,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } return nil } + func (m *FeederDelegation) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1065,6 +1092,7 @@ func (m *FeederDelegation) Unmarshal(dAtA []byte) error { } return nil } + func (m *MissCounter) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1166,6 +1194,7 @@ func (m *MissCounter) Unmarshal(dAtA []byte) error { } return nil } + func (m *TobinTax) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1282,6 +1311,7 @@ func (m *TobinTax) Unmarshal(dAtA []byte) error { } return nil } + func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/oracle/types/oracle.pb.go b/x/oracle/types/oracle.pb.go index 306f40c8f..4b5e93919 100644 --- a/x/oracle/types/oracle.pb.go +++ b/x/oracle/types/oracle.pb.go @@ -5,18 +5,21 @@ package types import ( fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -41,9 +44,11 @@ func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_2a008582d55f197f, []int{0} } + func (m *Params) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Params.Marshal(b, m, deterministic) @@ -56,12 +61,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Params) XXX_Merge(src proto.Message) { xxx_messageInfo_Params.Merge(m, src) } + func (m *Params) XXX_Size() int { return m.Size() } + func (m *Params) XXX_DiscardUnknown() { xxx_messageInfo_Params.DiscardUnknown(m) } @@ -107,9 +115,11 @@ func (*Denom) ProtoMessage() {} func (*Denom) Descriptor() ([]byte, []int) { return fileDescriptor_2a008582d55f197f, []int{1} } + func (m *Denom) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Denom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Denom.Marshal(b, m, deterministic) @@ -122,12 +132,15 @@ func (m *Denom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Denom) XXX_Merge(src proto.Message) { xxx_messageInfo_Denom.Merge(m, src) } + func (m *Denom) XXX_Size() int { return m.Size() } + func (m *Denom) XXX_DiscardUnknown() { xxx_messageInfo_Denom.DiscardUnknown(m) } @@ -148,9 +161,11 @@ func (*AggregateExchangeRatePrevote) ProtoMessage() {} func (*AggregateExchangeRatePrevote) Descriptor() ([]byte, []int) { return fileDescriptor_2a008582d55f197f, []int{2} } + func (m *AggregateExchangeRatePrevote) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *AggregateExchangeRatePrevote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AggregateExchangeRatePrevote.Marshal(b, m, deterministic) @@ -163,12 +178,15 @@ func (m *AggregateExchangeRatePrevote) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *AggregateExchangeRatePrevote) XXX_Merge(src proto.Message) { xxx_messageInfo_AggregateExchangeRatePrevote.Merge(m, src) } + func (m *AggregateExchangeRatePrevote) XXX_Size() int { return m.Size() } + func (m *AggregateExchangeRatePrevote) XXX_DiscardUnknown() { xxx_messageInfo_AggregateExchangeRatePrevote.DiscardUnknown(m) } @@ -187,9 +205,11 @@ func (*AggregateExchangeRateVote) ProtoMessage() {} func (*AggregateExchangeRateVote) Descriptor() ([]byte, []int) { return fileDescriptor_2a008582d55f197f, []int{3} } + func (m *AggregateExchangeRateVote) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *AggregateExchangeRateVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AggregateExchangeRateVote.Marshal(b, m, deterministic) @@ -202,12 +222,15 @@ func (m *AggregateExchangeRateVote) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *AggregateExchangeRateVote) XXX_Merge(src proto.Message) { xxx_messageInfo_AggregateExchangeRateVote.Merge(m, src) } + func (m *AggregateExchangeRateVote) XXX_Size() int { return m.Size() } + func (m *AggregateExchangeRateVote) XXX_DiscardUnknown() { xxx_messageInfo_AggregateExchangeRateVote.DiscardUnknown(m) } @@ -225,9 +248,11 @@ func (*ExchangeRateTuple) ProtoMessage() {} func (*ExchangeRateTuple) Descriptor() ([]byte, []int) { return fileDescriptor_2a008582d55f197f, []int{4} } + func (m *ExchangeRateTuple) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *ExchangeRateTuple) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExchangeRateTuple.Marshal(b, m, deterministic) @@ -240,12 +265,15 @@ func (m *ExchangeRateTuple) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } + func (m *ExchangeRateTuple) XXX_Merge(src proto.Message) { xxx_messageInfo_ExchangeRateTuple.Merge(m, src) } + func (m *ExchangeRateTuple) XXX_Size() int { return m.Size() } + func (m *ExchangeRateTuple) XXX_DiscardUnknown() { xxx_messageInfo_ExchangeRateTuple.DiscardUnknown(m) } @@ -364,6 +392,7 @@ func (this *Params) Equal(that interface{}) bool { } return true } + func (m *Params) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -633,6 +662,7 @@ func encodeVarintOracle(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -737,9 +767,11 @@ func (m *ExchangeRateTuple) Size() (n int) { func sovOracle(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozOracle(x uint64) (n int) { return sovOracle(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1017,6 +1049,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func (m *Denom) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1133,6 +1166,7 @@ func (m *Denom) Unmarshal(dAtA []byte) error { } return nil } + func (m *AggregateExchangeRatePrevote) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1266,6 +1300,7 @@ func (m *AggregateExchangeRatePrevote) Unmarshal(dAtA []byte) error { } return nil } + func (m *AggregateExchangeRateVote) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1382,6 +1417,7 @@ func (m *AggregateExchangeRateVote) Unmarshal(dAtA []byte) error { } return nil } + func (m *ExchangeRateTuple) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1498,6 +1534,7 @@ func (m *ExchangeRateTuple) Unmarshal(dAtA []byte) error { } return nil } + func skipOracle(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/oracle/types/query.pb.go b/x/oracle/types/query.pb.go index c8fa8a28d..25bd555da 100644 --- a/x/oracle/types/query.pb.go +++ b/x/oracle/types/query.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" @@ -15,15 +19,14 @@ import ( grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -43,9 +46,11 @@ func (*QueryExchangeRateRequest) ProtoMessage() {} func (*QueryExchangeRateRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{0} } + func (m *QueryExchangeRateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryExchangeRateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryExchangeRateRequest.Marshal(b, m, deterministic) @@ -58,12 +63,15 @@ func (m *QueryExchangeRateRequest) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryExchangeRateRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryExchangeRateRequest.Merge(m, src) } + func (m *QueryExchangeRateRequest) XXX_Size() int { return m.Size() } + func (m *QueryExchangeRateRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryExchangeRateRequest.DiscardUnknown(m) } @@ -83,9 +91,11 @@ func (*QueryExchangeRateResponse) ProtoMessage() {} func (*QueryExchangeRateResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{1} } + func (m *QueryExchangeRateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryExchangeRateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryExchangeRateResponse.Marshal(b, m, deterministic) @@ -98,12 +108,15 @@ func (m *QueryExchangeRateResponse) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryExchangeRateResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryExchangeRateResponse.Merge(m, src) } + func (m *QueryExchangeRateResponse) XXX_Size() int { return m.Size() } + func (m *QueryExchangeRateResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryExchangeRateResponse.DiscardUnknown(m) } @@ -111,8 +124,7 @@ func (m *QueryExchangeRateResponse) XXX_DiscardUnknown() { var xxx_messageInfo_QueryExchangeRateResponse proto.InternalMessageInfo // QueryExchangeRatesRequest is the request type for the Query/ExchangeRates RPC method. -type QueryExchangeRatesRequest struct { -} +type QueryExchangeRatesRequest struct{} func (m *QueryExchangeRatesRequest) Reset() { *m = QueryExchangeRatesRequest{} } func (m *QueryExchangeRatesRequest) String() string { return proto.CompactTextString(m) } @@ -120,9 +132,11 @@ func (*QueryExchangeRatesRequest) ProtoMessage() {} func (*QueryExchangeRatesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{2} } + func (m *QueryExchangeRatesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryExchangeRatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryExchangeRatesRequest.Marshal(b, m, deterministic) @@ -135,12 +149,15 @@ func (m *QueryExchangeRatesRequest) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryExchangeRatesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryExchangeRatesRequest.Merge(m, src) } + func (m *QueryExchangeRatesRequest) XXX_Size() int { return m.Size() } + func (m *QueryExchangeRatesRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryExchangeRatesRequest.DiscardUnknown(m) } @@ -160,9 +177,11 @@ func (*QueryExchangeRatesResponse) ProtoMessage() {} func (*QueryExchangeRatesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{3} } + func (m *QueryExchangeRatesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryExchangeRatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryExchangeRatesResponse.Marshal(b, m, deterministic) @@ -175,12 +194,15 @@ func (m *QueryExchangeRatesResponse) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } + func (m *QueryExchangeRatesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryExchangeRatesResponse.Merge(m, src) } + func (m *QueryExchangeRatesResponse) XXX_Size() int { return m.Size() } + func (m *QueryExchangeRatesResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryExchangeRatesResponse.DiscardUnknown(m) } @@ -206,9 +228,11 @@ func (*QueryTobinTaxRequest) ProtoMessage() {} func (*QueryTobinTaxRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{4} } + func (m *QueryTobinTaxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTobinTaxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTobinTaxRequest.Marshal(b, m, deterministic) @@ -221,12 +245,15 @@ func (m *QueryTobinTaxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *QueryTobinTaxRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTobinTaxRequest.Merge(m, src) } + func (m *QueryTobinTaxRequest) XXX_Size() int { return m.Size() } + func (m *QueryTobinTaxRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryTobinTaxRequest.DiscardUnknown(m) } @@ -246,9 +273,11 @@ func (*QueryTobinTaxResponse) ProtoMessage() {} func (*QueryTobinTaxResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{5} } + func (m *QueryTobinTaxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTobinTaxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTobinTaxResponse.Marshal(b, m, deterministic) @@ -261,12 +290,15 @@ func (m *QueryTobinTaxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt return b[:n], nil } } + func (m *QueryTobinTaxResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTobinTaxResponse.Merge(m, src) } + func (m *QueryTobinTaxResponse) XXX_Size() int { return m.Size() } + func (m *QueryTobinTaxResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryTobinTaxResponse.DiscardUnknown(m) } @@ -274,8 +306,7 @@ func (m *QueryTobinTaxResponse) XXX_DiscardUnknown() { var xxx_messageInfo_QueryTobinTaxResponse proto.InternalMessageInfo // QueryTobinTaxesRequest is the request type for the Query/TobinTaxes RPC method. -type QueryTobinTaxesRequest struct { -} +type QueryTobinTaxesRequest struct{} func (m *QueryTobinTaxesRequest) Reset() { *m = QueryTobinTaxesRequest{} } func (m *QueryTobinTaxesRequest) String() string { return proto.CompactTextString(m) } @@ -283,9 +314,11 @@ func (*QueryTobinTaxesRequest) ProtoMessage() {} func (*QueryTobinTaxesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{6} } + func (m *QueryTobinTaxesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTobinTaxesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTobinTaxesRequest.Marshal(b, m, deterministic) @@ -298,12 +331,15 @@ func (m *QueryTobinTaxesRequest) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *QueryTobinTaxesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTobinTaxesRequest.Merge(m, src) } + func (m *QueryTobinTaxesRequest) XXX_Size() int { return m.Size() } + func (m *QueryTobinTaxesRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryTobinTaxesRequest.DiscardUnknown(m) } @@ -323,9 +359,11 @@ func (*QueryTobinTaxesResponse) ProtoMessage() {} func (*QueryTobinTaxesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{7} } + func (m *QueryTobinTaxesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTobinTaxesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTobinTaxesResponse.Marshal(b, m, deterministic) @@ -338,12 +376,15 @@ func (m *QueryTobinTaxesResponse) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *QueryTobinTaxesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTobinTaxesResponse.Merge(m, src) } + func (m *QueryTobinTaxesResponse) XXX_Size() int { return m.Size() } + func (m *QueryTobinTaxesResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryTobinTaxesResponse.DiscardUnknown(m) } @@ -358,8 +399,7 @@ func (m *QueryTobinTaxesResponse) GetTobinTaxes() DenomList { } // QueryActivesRequest is the request type for the Query/Actives RPC method. -type QueryActivesRequest struct { -} +type QueryActivesRequest struct{} func (m *QueryActivesRequest) Reset() { *m = QueryActivesRequest{} } func (m *QueryActivesRequest) String() string { return proto.CompactTextString(m) } @@ -367,9 +407,11 @@ func (*QueryActivesRequest) ProtoMessage() {} func (*QueryActivesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{8} } + func (m *QueryActivesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryActivesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryActivesRequest.Marshal(b, m, deterministic) @@ -382,12 +424,15 @@ func (m *QueryActivesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryActivesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryActivesRequest.Merge(m, src) } + func (m *QueryActivesRequest) XXX_Size() int { return m.Size() } + func (m *QueryActivesRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryActivesRequest.DiscardUnknown(m) } @@ -407,9 +452,11 @@ func (*QueryActivesResponse) ProtoMessage() {} func (*QueryActivesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{9} } + func (m *QueryActivesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryActivesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryActivesResponse.Marshal(b, m, deterministic) @@ -422,12 +469,15 @@ func (m *QueryActivesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *QueryActivesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryActivesResponse.Merge(m, src) } + func (m *QueryActivesResponse) XXX_Size() int { return m.Size() } + func (m *QueryActivesResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryActivesResponse.DiscardUnknown(m) } @@ -442,8 +492,7 @@ func (m *QueryActivesResponse) GetActives() []string { } // QueryVoteTargetsRequest is the request type for the Query/VoteTargets RPC method. -type QueryVoteTargetsRequest struct { -} +type QueryVoteTargetsRequest struct{} func (m *QueryVoteTargetsRequest) Reset() { *m = QueryVoteTargetsRequest{} } func (m *QueryVoteTargetsRequest) String() string { return proto.CompactTextString(m) } @@ -451,9 +500,11 @@ func (*QueryVoteTargetsRequest) ProtoMessage() {} func (*QueryVoteTargetsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{10} } + func (m *QueryVoteTargetsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryVoteTargetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryVoteTargetsRequest.Marshal(b, m, deterministic) @@ -466,12 +517,15 @@ func (m *QueryVoteTargetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *QueryVoteTargetsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryVoteTargetsRequest.Merge(m, src) } + func (m *QueryVoteTargetsRequest) XXX_Size() int { return m.Size() } + func (m *QueryVoteTargetsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryVoteTargetsRequest.DiscardUnknown(m) } @@ -492,9 +546,11 @@ func (*QueryVoteTargetsResponse) ProtoMessage() {} func (*QueryVoteTargetsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{11} } + func (m *QueryVoteTargetsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryVoteTargetsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryVoteTargetsResponse.Marshal(b, m, deterministic) @@ -507,12 +563,15 @@ func (m *QueryVoteTargetsResponse) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryVoteTargetsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryVoteTargetsResponse.Merge(m, src) } + func (m *QueryVoteTargetsResponse) XXX_Size() int { return m.Size() } + func (m *QueryVoteTargetsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryVoteTargetsResponse.DiscardUnknown(m) } @@ -538,9 +597,11 @@ func (*QueryFeederDelegationRequest) ProtoMessage() {} func (*QueryFeederDelegationRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{12} } + func (m *QueryFeederDelegationRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryFeederDelegationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryFeederDelegationRequest.Marshal(b, m, deterministic) @@ -553,12 +614,15 @@ func (m *QueryFeederDelegationRequest) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *QueryFeederDelegationRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryFeederDelegationRequest.Merge(m, src) } + func (m *QueryFeederDelegationRequest) XXX_Size() int { return m.Size() } + func (m *QueryFeederDelegationRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryFeederDelegationRequest.DiscardUnknown(m) } @@ -578,9 +642,11 @@ func (*QueryFeederDelegationResponse) ProtoMessage() {} func (*QueryFeederDelegationResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{13} } + func (m *QueryFeederDelegationResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryFeederDelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryFeederDelegationResponse.Marshal(b, m, deterministic) @@ -593,12 +659,15 @@ func (m *QueryFeederDelegationResponse) XXX_Marshal(b []byte, deterministic bool return b[:n], nil } } + func (m *QueryFeederDelegationResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryFeederDelegationResponse.Merge(m, src) } + func (m *QueryFeederDelegationResponse) XXX_Size() int { return m.Size() } + func (m *QueryFeederDelegationResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryFeederDelegationResponse.DiscardUnknown(m) } @@ -624,9 +693,11 @@ func (*QueryMissCounterRequest) ProtoMessage() {} func (*QueryMissCounterRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{14} } + func (m *QueryMissCounterRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryMissCounterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryMissCounterRequest.Marshal(b, m, deterministic) @@ -639,12 +710,15 @@ func (m *QueryMissCounterRequest) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *QueryMissCounterRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryMissCounterRequest.Merge(m, src) } + func (m *QueryMissCounterRequest) XXX_Size() int { return m.Size() } + func (m *QueryMissCounterRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryMissCounterRequest.DiscardUnknown(m) } @@ -664,9 +738,11 @@ func (*QueryMissCounterResponse) ProtoMessage() {} func (*QueryMissCounterResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{15} } + func (m *QueryMissCounterResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryMissCounterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryMissCounterResponse.Marshal(b, m, deterministic) @@ -679,12 +755,15 @@ func (m *QueryMissCounterResponse) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryMissCounterResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryMissCounterResponse.Merge(m, src) } + func (m *QueryMissCounterResponse) XXX_Size() int { return m.Size() } + func (m *QueryMissCounterResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryMissCounterResponse.DiscardUnknown(m) } @@ -710,9 +789,11 @@ func (*QueryAggregatePrevoteRequest) ProtoMessage() {} func (*QueryAggregatePrevoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{16} } + func (m *QueryAggregatePrevoteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAggregatePrevoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAggregatePrevoteRequest.Marshal(b, m, deterministic) @@ -725,12 +806,15 @@ func (m *QueryAggregatePrevoteRequest) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *QueryAggregatePrevoteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAggregatePrevoteRequest.Merge(m, src) } + func (m *QueryAggregatePrevoteRequest) XXX_Size() int { return m.Size() } + func (m *QueryAggregatePrevoteRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryAggregatePrevoteRequest.DiscardUnknown(m) } @@ -750,9 +834,11 @@ func (*QueryAggregatePrevoteResponse) ProtoMessage() {} func (*QueryAggregatePrevoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{17} } + func (m *QueryAggregatePrevoteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAggregatePrevoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAggregatePrevoteResponse.Marshal(b, m, deterministic) @@ -765,12 +851,15 @@ func (m *QueryAggregatePrevoteResponse) XXX_Marshal(b []byte, deterministic bool return b[:n], nil } } + func (m *QueryAggregatePrevoteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAggregatePrevoteResponse.Merge(m, src) } + func (m *QueryAggregatePrevoteResponse) XXX_Size() int { return m.Size() } + func (m *QueryAggregatePrevoteResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryAggregatePrevoteResponse.DiscardUnknown(m) } @@ -785,8 +874,7 @@ func (m *QueryAggregatePrevoteResponse) GetAggregatePrevote() AggregateExchangeR } // QueryAggregatePrevotesRequest is the request type for the Query/AggregatePrevotes RPC method. -type QueryAggregatePrevotesRequest struct { -} +type QueryAggregatePrevotesRequest struct{} func (m *QueryAggregatePrevotesRequest) Reset() { *m = QueryAggregatePrevotesRequest{} } func (m *QueryAggregatePrevotesRequest) String() string { return proto.CompactTextString(m) } @@ -794,9 +882,11 @@ func (*QueryAggregatePrevotesRequest) ProtoMessage() {} func (*QueryAggregatePrevotesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{18} } + func (m *QueryAggregatePrevotesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAggregatePrevotesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAggregatePrevotesRequest.Marshal(b, m, deterministic) @@ -809,12 +899,15 @@ func (m *QueryAggregatePrevotesRequest) XXX_Marshal(b []byte, deterministic bool return b[:n], nil } } + func (m *QueryAggregatePrevotesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAggregatePrevotesRequest.Merge(m, src) } + func (m *QueryAggregatePrevotesRequest) XXX_Size() int { return m.Size() } + func (m *QueryAggregatePrevotesRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryAggregatePrevotesRequest.DiscardUnknown(m) } @@ -834,9 +927,11 @@ func (*QueryAggregatePrevotesResponse) ProtoMessage() {} func (*QueryAggregatePrevotesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{19} } + func (m *QueryAggregatePrevotesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAggregatePrevotesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAggregatePrevotesResponse.Marshal(b, m, deterministic) @@ -849,12 +944,15 @@ func (m *QueryAggregatePrevotesResponse) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } + func (m *QueryAggregatePrevotesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAggregatePrevotesResponse.Merge(m, src) } + func (m *QueryAggregatePrevotesResponse) XXX_Size() int { return m.Size() } + func (m *QueryAggregatePrevotesResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryAggregatePrevotesResponse.DiscardUnknown(m) } @@ -880,9 +978,11 @@ func (*QueryAggregateVoteRequest) ProtoMessage() {} func (*QueryAggregateVoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{20} } + func (m *QueryAggregateVoteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAggregateVoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAggregateVoteRequest.Marshal(b, m, deterministic) @@ -895,12 +995,15 @@ func (m *QueryAggregateVoteRequest) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryAggregateVoteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAggregateVoteRequest.Merge(m, src) } + func (m *QueryAggregateVoteRequest) XXX_Size() int { return m.Size() } + func (m *QueryAggregateVoteRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryAggregateVoteRequest.DiscardUnknown(m) } @@ -920,9 +1023,11 @@ func (*QueryAggregateVoteResponse) ProtoMessage() {} func (*QueryAggregateVoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{21} } + func (m *QueryAggregateVoteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAggregateVoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAggregateVoteResponse.Marshal(b, m, deterministic) @@ -935,12 +1040,15 @@ func (m *QueryAggregateVoteResponse) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } + func (m *QueryAggregateVoteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAggregateVoteResponse.Merge(m, src) } + func (m *QueryAggregateVoteResponse) XXX_Size() int { return m.Size() } + func (m *QueryAggregateVoteResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryAggregateVoteResponse.DiscardUnknown(m) } @@ -955,8 +1063,7 @@ func (m *QueryAggregateVoteResponse) GetAggregateVote() AggregateExchangeRateVot } // QueryAggregateVotesRequest is the request type for the Query/AggregateVotes RPC method. -type QueryAggregateVotesRequest struct { -} +type QueryAggregateVotesRequest struct{} func (m *QueryAggregateVotesRequest) Reset() { *m = QueryAggregateVotesRequest{} } func (m *QueryAggregateVotesRequest) String() string { return proto.CompactTextString(m) } @@ -964,9 +1071,11 @@ func (*QueryAggregateVotesRequest) ProtoMessage() {} func (*QueryAggregateVotesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{22} } + func (m *QueryAggregateVotesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAggregateVotesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAggregateVotesRequest.Marshal(b, m, deterministic) @@ -979,12 +1088,15 @@ func (m *QueryAggregateVotesRequest) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } + func (m *QueryAggregateVotesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAggregateVotesRequest.Merge(m, src) } + func (m *QueryAggregateVotesRequest) XXX_Size() int { return m.Size() } + func (m *QueryAggregateVotesRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryAggregateVotesRequest.DiscardUnknown(m) } @@ -1004,9 +1116,11 @@ func (*QueryAggregateVotesResponse) ProtoMessage() {} func (*QueryAggregateVotesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{23} } + func (m *QueryAggregateVotesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryAggregateVotesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryAggregateVotesResponse.Marshal(b, m, deterministic) @@ -1019,12 +1133,15 @@ func (m *QueryAggregateVotesResponse) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *QueryAggregateVotesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryAggregateVotesResponse.Merge(m, src) } + func (m *QueryAggregateVotesResponse) XXX_Size() int { return m.Size() } + func (m *QueryAggregateVotesResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryAggregateVotesResponse.DiscardUnknown(m) } @@ -1039,8 +1156,7 @@ func (m *QueryAggregateVotesResponse) GetAggregateVotes() []AggregateExchangeRat } // QueryParamsRequest is the request type for the Query/Params RPC method. -type QueryParamsRequest struct { -} +type QueryParamsRequest struct{} func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } @@ -1048,9 +1164,11 @@ func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{24} } + func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) @@ -1063,12 +1181,15 @@ func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsRequest.Merge(m, src) } + func (m *QueryParamsRequest) XXX_Size() int { return m.Size() } + func (m *QueryParamsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) } @@ -1087,9 +1208,11 @@ func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_198b4e80572a772d, []int{25} } + func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) @@ -1102,12 +1225,15 @@ func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsResponse.Merge(m, src) } + func (m *QueryParamsResponse) XXX_Size() int { return m.Size() } + func (m *QueryParamsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) } @@ -1235,8 +1361,10 @@ var fileDescriptor_198b4e80572a772d = []byte{ } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ grpc.ClientConn +) // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. @@ -1430,45 +1558,56 @@ type QueryServer interface { } // UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} +type UnimplementedQueryServer struct{} func (*UnimplementedQueryServer) ExchangeRate(ctx context.Context, req *QueryExchangeRateRequest) (*QueryExchangeRateResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ExchangeRate not implemented") } + func (*UnimplementedQueryServer) ExchangeRates(ctx context.Context, req *QueryExchangeRatesRequest) (*QueryExchangeRatesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ExchangeRates not implemented") } + func (*UnimplementedQueryServer) TobinTax(ctx context.Context, req *QueryTobinTaxRequest) (*QueryTobinTaxResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TobinTax not implemented") } + func (*UnimplementedQueryServer) TobinTaxes(ctx context.Context, req *QueryTobinTaxesRequest) (*QueryTobinTaxesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TobinTaxes not implemented") } + func (*UnimplementedQueryServer) Actives(ctx context.Context, req *QueryActivesRequest) (*QueryActivesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Actives not implemented") } + func (*UnimplementedQueryServer) VoteTargets(ctx context.Context, req *QueryVoteTargetsRequest) (*QueryVoteTargetsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method VoteTargets not implemented") } + func (*UnimplementedQueryServer) FeederDelegation(ctx context.Context, req *QueryFeederDelegationRequest) (*QueryFeederDelegationResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method FeederDelegation not implemented") } + func (*UnimplementedQueryServer) MissCounter(ctx context.Context, req *QueryMissCounterRequest) (*QueryMissCounterResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method MissCounter not implemented") } + func (*UnimplementedQueryServer) AggregatePrevote(ctx context.Context, req *QueryAggregatePrevoteRequest) (*QueryAggregatePrevoteResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AggregatePrevote not implemented") } + func (*UnimplementedQueryServer) AggregatePrevotes(ctx context.Context, req *QueryAggregatePrevotesRequest) (*QueryAggregatePrevotesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AggregatePrevotes not implemented") } + func (*UnimplementedQueryServer) AggregateVote(ctx context.Context, req *QueryAggregateVoteRequest) (*QueryAggregateVoteResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AggregateVote not implemented") } + func (*UnimplementedQueryServer) AggregateVotes(ctx context.Context, req *QueryAggregateVotesRequest) (*QueryAggregateVotesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AggregateVotes not implemented") } + func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } @@ -2559,6 +2698,7 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *QueryExchangeRateRequest) Size() (n int) { if m == nil { return 0 @@ -2873,9 +3013,11 @@ func (m *QueryParamsResponse) Size() (n int) { func sovQuery(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozQuery(x uint64) (n int) { return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *QueryExchangeRateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2958,6 +3100,7 @@ func (m *QueryExchangeRateRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryExchangeRateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3042,6 +3185,7 @@ func (m *QueryExchangeRateResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryExchangeRatesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3092,6 +3236,7 @@ func (m *QueryExchangeRatesRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryExchangeRatesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3176,6 +3321,7 @@ func (m *QueryExchangeRatesResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTobinTaxRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3258,6 +3404,7 @@ func (m *QueryTobinTaxRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTobinTaxResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3342,6 +3489,7 @@ func (m *QueryTobinTaxResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTobinTaxesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3392,6 +3540,7 @@ func (m *QueryTobinTaxesRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTobinTaxesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3476,6 +3625,7 @@ func (m *QueryTobinTaxesResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryActivesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3526,6 +3676,7 @@ func (m *QueryActivesRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryActivesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3608,6 +3759,7 @@ func (m *QueryActivesResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryVoteTargetsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3658,6 +3810,7 @@ func (m *QueryVoteTargetsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryVoteTargetsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3740,6 +3893,7 @@ func (m *QueryVoteTargetsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryFeederDelegationRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3822,6 +3976,7 @@ func (m *QueryFeederDelegationRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryFeederDelegationResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3904,6 +4059,7 @@ func (m *QueryFeederDelegationResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryMissCounterRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3986,6 +4142,7 @@ func (m *QueryMissCounterRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryMissCounterResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4055,6 +4212,7 @@ func (m *QueryMissCounterResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAggregatePrevoteRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4137,6 +4295,7 @@ func (m *QueryAggregatePrevoteRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAggregatePrevoteResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4220,6 +4379,7 @@ func (m *QueryAggregatePrevoteResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAggregatePrevotesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4270,6 +4430,7 @@ func (m *QueryAggregatePrevotesRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAggregatePrevotesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4354,6 +4515,7 @@ func (m *QueryAggregatePrevotesResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAggregateVoteRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4436,6 +4598,7 @@ func (m *QueryAggregateVoteRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAggregateVoteResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4519,6 +4682,7 @@ func (m *QueryAggregateVoteResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAggregateVotesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4569,6 +4733,7 @@ func (m *QueryAggregateVotesRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryAggregateVotesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4653,6 +4818,7 @@ func (m *QueryAggregateVotesResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4703,6 +4869,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -4786,6 +4953,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/oracle/types/query.pb.gw.go b/x/oracle/types/query.pb.gw.go index 662167cc8..fa9043576 100644 --- a/x/oracle/types/query.pb.gw.go +++ b/x/oracle/types/query.pb.gw.go @@ -25,13 +25,15 @@ import ( ) // Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = descriptor.ForMessage -var _ = metadata.Join +var ( + _ codes.Code + _ io.Reader + _ status.Status + _ = runtime.String + _ = utilities.NewDoubleArray + _ = descriptor.ForMessage + _ = metadata.Join +) func request_Query_ExchangeRate_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryExchangeRateRequest @@ -57,7 +59,6 @@ func request_Query_ExchangeRate_0(ctx context.Context, marshaler runtime.Marshal msg, err := client.ExchangeRate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_ExchangeRate_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -84,7 +85,6 @@ func local_request_Query_ExchangeRate_0(ctx context.Context, marshaler runtime.M msg, err := server.ExchangeRate(ctx, &protoReq) return msg, metadata, err - } func request_Query_ExchangeRates_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -93,7 +93,6 @@ func request_Query_ExchangeRates_0(ctx context.Context, marshaler runtime.Marsha msg, err := client.ExchangeRates(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_ExchangeRates_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -102,7 +101,6 @@ func local_request_Query_ExchangeRates_0(ctx context.Context, marshaler runtime. msg, err := server.ExchangeRates(ctx, &protoReq) return msg, metadata, err - } func request_Query_TobinTax_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -129,7 +127,6 @@ func request_Query_TobinTax_0(ctx context.Context, marshaler runtime.Marshaler, msg, err := client.TobinTax(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_TobinTax_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -156,7 +153,6 @@ func local_request_Query_TobinTax_0(ctx context.Context, marshaler runtime.Marsh msg, err := server.TobinTax(ctx, &protoReq) return msg, metadata, err - } func request_Query_TobinTaxes_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -165,7 +161,6 @@ func request_Query_TobinTaxes_0(ctx context.Context, marshaler runtime.Marshaler msg, err := client.TobinTaxes(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_TobinTaxes_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -174,7 +169,6 @@ func local_request_Query_TobinTaxes_0(ctx context.Context, marshaler runtime.Mar msg, err := server.TobinTaxes(ctx, &protoReq) return msg, metadata, err - } func request_Query_Actives_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -183,7 +177,6 @@ func request_Query_Actives_0(ctx context.Context, marshaler runtime.Marshaler, c msg, err := client.Actives(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_Actives_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -192,7 +185,6 @@ func local_request_Query_Actives_0(ctx context.Context, marshaler runtime.Marsha msg, err := server.Actives(ctx, &protoReq) return msg, metadata, err - } func request_Query_VoteTargets_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -201,7 +193,6 @@ func request_Query_VoteTargets_0(ctx context.Context, marshaler runtime.Marshale msg, err := client.VoteTargets(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_VoteTargets_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -210,7 +201,6 @@ func local_request_Query_VoteTargets_0(ctx context.Context, marshaler runtime.Ma msg, err := server.VoteTargets(ctx, &protoReq) return msg, metadata, err - } func request_Query_FeederDelegation_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -237,7 +227,6 @@ func request_Query_FeederDelegation_0(ctx context.Context, marshaler runtime.Mar msg, err := client.FeederDelegation(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_FeederDelegation_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -264,7 +253,6 @@ func local_request_Query_FeederDelegation_0(ctx context.Context, marshaler runti msg, err := server.FeederDelegation(ctx, &protoReq) return msg, metadata, err - } func request_Query_MissCounter_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -291,7 +279,6 @@ func request_Query_MissCounter_0(ctx context.Context, marshaler runtime.Marshale msg, err := client.MissCounter(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_MissCounter_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -318,7 +305,6 @@ func local_request_Query_MissCounter_0(ctx context.Context, marshaler runtime.Ma msg, err := server.MissCounter(ctx, &protoReq) return msg, metadata, err - } func request_Query_AggregatePrevote_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -345,7 +331,6 @@ func request_Query_AggregatePrevote_0(ctx context.Context, marshaler runtime.Mar msg, err := client.AggregatePrevote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_AggregatePrevote_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -372,7 +357,6 @@ func local_request_Query_AggregatePrevote_0(ctx context.Context, marshaler runti msg, err := server.AggregatePrevote(ctx, &protoReq) return msg, metadata, err - } func request_Query_AggregatePrevotes_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -381,7 +365,6 @@ func request_Query_AggregatePrevotes_0(ctx context.Context, marshaler runtime.Ma msg, err := client.AggregatePrevotes(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_AggregatePrevotes_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -390,7 +373,6 @@ func local_request_Query_AggregatePrevotes_0(ctx context.Context, marshaler runt msg, err := server.AggregatePrevotes(ctx, &protoReq) return msg, metadata, err - } func request_Query_AggregateVote_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -417,7 +399,6 @@ func request_Query_AggregateVote_0(ctx context.Context, marshaler runtime.Marsha msg, err := client.AggregateVote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_AggregateVote_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -444,7 +425,6 @@ func local_request_Query_AggregateVote_0(ctx context.Context, marshaler runtime. msg, err := server.AggregateVote(ctx, &protoReq) return msg, metadata, err - } func request_Query_AggregateVotes_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -453,7 +433,6 @@ func request_Query_AggregateVotes_0(ctx context.Context, marshaler runtime.Marsh msg, err := client.AggregateVotes(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_AggregateVotes_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -462,7 +441,6 @@ func local_request_Query_AggregateVotes_0(ctx context.Context, marshaler runtime msg, err := server.AggregateVotes(ctx, &protoReq) return msg, metadata, err - } func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -471,7 +449,6 @@ func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, cl msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -480,7 +457,6 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal msg, err := server.Params(ctx, &protoReq) return msg, metadata, err - } // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". @@ -488,7 +464,6 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { - mux.Handle("GET", pattern_Query_ExchangeRate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -509,7 +484,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_ExchangeRate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_ExchangeRates_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -532,7 +506,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_ExchangeRates_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TobinTax_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -555,7 +528,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_TobinTax_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TobinTaxes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -578,7 +550,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_TobinTaxes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Actives_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -601,7 +572,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_Actives_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_VoteTargets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -624,7 +594,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_VoteTargets_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_FeederDelegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -647,7 +616,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_FeederDelegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_MissCounter_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -670,7 +638,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_MissCounter_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_AggregatePrevote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -693,7 +660,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_AggregatePrevote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_AggregatePrevotes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -716,7 +682,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_AggregatePrevotes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_AggregateVote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -739,7 +704,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_AggregateVote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_AggregateVotes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -762,7 +726,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_AggregateVotes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -785,7 +748,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil @@ -828,7 +790,6 @@ func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in // "QueryClient" to call the correct interceptors. func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { - mux.Handle("GET", pattern_Query_ExchangeRate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -846,7 +807,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_ExchangeRate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_ExchangeRates_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -866,7 +826,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_ExchangeRates_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TobinTax_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -886,7 +845,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_TobinTax_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TobinTaxes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -906,7 +864,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_TobinTaxes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Actives_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -926,7 +883,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_Actives_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_VoteTargets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -946,7 +902,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_VoteTargets_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_FeederDelegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -966,7 +921,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_FeederDelegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_MissCounter_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -986,7 +940,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_MissCounter_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_AggregatePrevote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -1006,7 +959,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_AggregatePrevote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_AggregatePrevotes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -1026,7 +978,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_AggregatePrevotes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_AggregateVote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -1046,7 +997,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_AggregateVote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_AggregateVotes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -1066,7 +1016,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_AggregateVotes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -1086,7 +1035,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil diff --git a/x/oracle/types/tx.pb.go b/x/oracle/types/tx.pb.go index 0b4ede785..483b310ef 100644 --- a/x/oracle/types/tx.pb.go +++ b/x/oracle/types/tx.pb.go @@ -6,21 +6,24 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/gogo/protobuf/grpc" proto "github.com/gogo/protobuf/proto" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -42,9 +45,11 @@ func (*MsgAggregateExchangeRatePrevote) ProtoMessage() {} func (*MsgAggregateExchangeRatePrevote) Descriptor() ([]byte, []int) { return fileDescriptor_ade38ec3545c6da7, []int{0} } + func (m *MsgAggregateExchangeRatePrevote) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAggregateExchangeRatePrevote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAggregateExchangeRatePrevote.Marshal(b, m, deterministic) @@ -57,12 +62,15 @@ func (m *MsgAggregateExchangeRatePrevote) XXX_Marshal(b []byte, deterministic bo return b[:n], nil } } + func (m *MsgAggregateExchangeRatePrevote) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAggregateExchangeRatePrevote.Merge(m, src) } + func (m *MsgAggregateExchangeRatePrevote) XXX_Size() int { return m.Size() } + func (m *MsgAggregateExchangeRatePrevote) XXX_DiscardUnknown() { xxx_messageInfo_MsgAggregateExchangeRatePrevote.DiscardUnknown(m) } @@ -70,8 +78,7 @@ func (m *MsgAggregateExchangeRatePrevote) XXX_DiscardUnknown() { var xxx_messageInfo_MsgAggregateExchangeRatePrevote proto.InternalMessageInfo // MsgAggregateExchangeRatePrevoteResponse defines the Msg/AggregateExchangeRatePrevote response type. -type MsgAggregateExchangeRatePrevoteResponse struct { -} +type MsgAggregateExchangeRatePrevoteResponse struct{} func (m *MsgAggregateExchangeRatePrevoteResponse) Reset() { *m = MsgAggregateExchangeRatePrevoteResponse{} @@ -81,9 +88,11 @@ func (*MsgAggregateExchangeRatePrevoteResponse) ProtoMessage() {} func (*MsgAggregateExchangeRatePrevoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_ade38ec3545c6da7, []int{1} } + func (m *MsgAggregateExchangeRatePrevoteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAggregateExchangeRatePrevoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAggregateExchangeRatePrevoteResponse.Marshal(b, m, deterministic) @@ -96,12 +105,15 @@ func (m *MsgAggregateExchangeRatePrevoteResponse) XXX_Marshal(b []byte, determin return b[:n], nil } } + func (m *MsgAggregateExchangeRatePrevoteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAggregateExchangeRatePrevoteResponse.Merge(m, src) } + func (m *MsgAggregateExchangeRatePrevoteResponse) XXX_Size() int { return m.Size() } + func (m *MsgAggregateExchangeRatePrevoteResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgAggregateExchangeRatePrevoteResponse.DiscardUnknown(m) } @@ -123,9 +135,11 @@ func (*MsgAggregateExchangeRateVote) ProtoMessage() {} func (*MsgAggregateExchangeRateVote) Descriptor() ([]byte, []int) { return fileDescriptor_ade38ec3545c6da7, []int{2} } + func (m *MsgAggregateExchangeRateVote) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAggregateExchangeRateVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAggregateExchangeRateVote.Marshal(b, m, deterministic) @@ -138,12 +152,15 @@ func (m *MsgAggregateExchangeRateVote) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } + func (m *MsgAggregateExchangeRateVote) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAggregateExchangeRateVote.Merge(m, src) } + func (m *MsgAggregateExchangeRateVote) XXX_Size() int { return m.Size() } + func (m *MsgAggregateExchangeRateVote) XXX_DiscardUnknown() { xxx_messageInfo_MsgAggregateExchangeRateVote.DiscardUnknown(m) } @@ -151,8 +168,7 @@ func (m *MsgAggregateExchangeRateVote) XXX_DiscardUnknown() { var xxx_messageInfo_MsgAggregateExchangeRateVote proto.InternalMessageInfo // MsgAggregateExchangeRateVoteResponse defines the Msg/AggregateExchangeRateVote response type. -type MsgAggregateExchangeRateVoteResponse struct { -} +type MsgAggregateExchangeRateVoteResponse struct{} func (m *MsgAggregateExchangeRateVoteResponse) Reset() { *m = MsgAggregateExchangeRateVoteResponse{} } func (m *MsgAggregateExchangeRateVoteResponse) String() string { return proto.CompactTextString(m) } @@ -160,9 +176,11 @@ func (*MsgAggregateExchangeRateVoteResponse) ProtoMessage() {} func (*MsgAggregateExchangeRateVoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_ade38ec3545c6da7, []int{3} } + func (m *MsgAggregateExchangeRateVoteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgAggregateExchangeRateVoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgAggregateExchangeRateVoteResponse.Marshal(b, m, deterministic) @@ -175,12 +193,15 @@ func (m *MsgAggregateExchangeRateVoteResponse) XXX_Marshal(b []byte, determinist return b[:n], nil } } + func (m *MsgAggregateExchangeRateVoteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgAggregateExchangeRateVoteResponse.Merge(m, src) } + func (m *MsgAggregateExchangeRateVoteResponse) XXX_Size() int { return m.Size() } + func (m *MsgAggregateExchangeRateVoteResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgAggregateExchangeRateVoteResponse.DiscardUnknown(m) } @@ -200,9 +221,11 @@ func (*MsgDelegateFeedConsent) ProtoMessage() {} func (*MsgDelegateFeedConsent) Descriptor() ([]byte, []int) { return fileDescriptor_ade38ec3545c6da7, []int{4} } + func (m *MsgDelegateFeedConsent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgDelegateFeedConsent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgDelegateFeedConsent.Marshal(b, m, deterministic) @@ -215,12 +238,15 @@ func (m *MsgDelegateFeedConsent) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *MsgDelegateFeedConsent) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgDelegateFeedConsent.Merge(m, src) } + func (m *MsgDelegateFeedConsent) XXX_Size() int { return m.Size() } + func (m *MsgDelegateFeedConsent) XXX_DiscardUnknown() { xxx_messageInfo_MsgDelegateFeedConsent.DiscardUnknown(m) } @@ -228,8 +254,7 @@ func (m *MsgDelegateFeedConsent) XXX_DiscardUnknown() { var xxx_messageInfo_MsgDelegateFeedConsent proto.InternalMessageInfo // MsgDelegateFeedConsentResponse defines the Msg/DelegateFeedConsent response type. -type MsgDelegateFeedConsentResponse struct { -} +type MsgDelegateFeedConsentResponse struct{} func (m *MsgDelegateFeedConsentResponse) Reset() { *m = MsgDelegateFeedConsentResponse{} } func (m *MsgDelegateFeedConsentResponse) String() string { return proto.CompactTextString(m) } @@ -237,9 +262,11 @@ func (*MsgDelegateFeedConsentResponse) ProtoMessage() {} func (*MsgDelegateFeedConsentResponse) Descriptor() ([]byte, []int) { return fileDescriptor_ade38ec3545c6da7, []int{5} } + func (m *MsgDelegateFeedConsentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *MsgDelegateFeedConsentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MsgDelegateFeedConsentResponse.Marshal(b, m, deterministic) @@ -252,12 +279,15 @@ func (m *MsgDelegateFeedConsentResponse) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } + func (m *MsgDelegateFeedConsentResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MsgDelegateFeedConsentResponse.Merge(m, src) } + func (m *MsgDelegateFeedConsentResponse) XXX_Size() int { return m.Size() } + func (m *MsgDelegateFeedConsentResponse) XXX_DiscardUnknown() { xxx_messageInfo_MsgDelegateFeedConsentResponse.DiscardUnknown(m) } @@ -312,8 +342,10 @@ var fileDescriptor_ade38ec3545c6da7 = []byte{ } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ grpc.ClientConn +) // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. @@ -381,15 +413,16 @@ type MsgServer interface { } // UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} +type UnimplementedMsgServer struct{} func (*UnimplementedMsgServer) AggregateExchangeRatePrevote(ctx context.Context, req *MsgAggregateExchangeRatePrevote) (*MsgAggregateExchangeRatePrevoteResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AggregateExchangeRatePrevote not implemented") } + func (*UnimplementedMsgServer) AggregateExchangeRateVote(ctx context.Context, req *MsgAggregateExchangeRateVote) (*MsgAggregateExchangeRateVoteResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AggregateExchangeRateVote not implemented") } + func (*UnimplementedMsgServer) DelegateFeedConsent(ctx context.Context, req *MsgDelegateFeedConsent) (*MsgDelegateFeedConsentResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method DelegateFeedConsent not implemented") } @@ -685,6 +718,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *MsgAggregateExchangeRatePrevote) Size() (n int) { if m == nil { return 0 @@ -778,9 +812,11 @@ func (m *MsgDelegateFeedConsentResponse) Size() (n int) { func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozTx(x uint64) (n int) { return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *MsgAggregateExchangeRatePrevote) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -927,6 +963,7 @@ func (m *MsgAggregateExchangeRatePrevote) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgAggregateExchangeRatePrevoteResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -977,6 +1014,7 @@ func (m *MsgAggregateExchangeRatePrevoteResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgAggregateExchangeRateVote) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1155,6 +1193,7 @@ func (m *MsgAggregateExchangeRateVote) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgAggregateExchangeRateVoteResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1205,6 +1244,7 @@ func (m *MsgAggregateExchangeRateVoteResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgDelegateFeedConsent) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1319,6 +1359,7 @@ func (m *MsgDelegateFeedConsent) Unmarshal(dAtA []byte) error { } return nil } + func (m *MsgDelegateFeedConsentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1369,6 +1410,7 @@ func (m *MsgDelegateFeedConsentResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/genesis.pb.go b/x/treasury/types/genesis.pb.go index e01ba5e69..7b5820449 100644 --- a/x/treasury/types/genesis.pb.go +++ b/x/treasury/types/genesis.pb.go @@ -5,19 +5,22 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/gogo/protobuf/proto" - io "io" - math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -42,9 +45,11 @@ func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { return fileDescriptor_c440a3f50aabab34, []int{0} } + func (m *GenesisState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic) @@ -57,12 +62,15 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } + func (m *GenesisState) XXX_Merge(src proto.Message) { xxx_messageInfo_GenesisState.Merge(m, src) } + func (m *GenesisState) XXX_Size() int { return m.Size() } + func (m *GenesisState) XXX_DiscardUnknown() { xxx_messageInfo_GenesisState.DiscardUnknown(m) } @@ -116,9 +124,11 @@ func (*TaxCap) ProtoMessage() {} func (*TaxCap) Descriptor() ([]byte, []int) { return fileDescriptor_c440a3f50aabab34, []int{1} } + func (m *TaxCap) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *TaxCap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaxCap.Marshal(b, m, deterministic) @@ -131,12 +141,15 @@ func (m *TaxCap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *TaxCap) XXX_Merge(src proto.Message) { xxx_messageInfo_TaxCap.Merge(m, src) } + func (m *TaxCap) XXX_Size() int { return m.Size() } + func (m *TaxCap) XXX_DiscardUnknown() { xxx_messageInfo_TaxCap.DiscardUnknown(m) } @@ -164,9 +177,11 @@ func (*EpochState) ProtoMessage() {} func (*EpochState) Descriptor() ([]byte, []int) { return fileDescriptor_c440a3f50aabab34, []int{2} } + func (m *EpochState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EpochState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EpochState.Marshal(b, m, deterministic) @@ -179,12 +194,15 @@ func (m *EpochState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *EpochState) XXX_Merge(src proto.Message) { xxx_messageInfo_EpochState.Merge(m, src) } + func (m *EpochState) XXX_Size() int { return m.Size() } + func (m *EpochState) XXX_DiscardUnknown() { xxx_messageInfo_EpochState.DiscardUnknown(m) } @@ -465,6 +483,7 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -540,9 +559,11 @@ func (m *EpochState) Size() (n int) { func sovGenesis(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozGenesis(x uint64) (n int) { return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -830,6 +851,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } return nil } + func (m *TaxCap) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -946,6 +968,7 @@ func (m *TaxCap) Unmarshal(dAtA []byte) error { } return nil } + func (m *EpochState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1117,6 +1140,7 @@ func (m *EpochState) Unmarshal(dAtA []byte) error { } return nil } + func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/gov.pb.go b/x/treasury/types/gov.pb.go index 18b243451..d1b4cff64 100644 --- a/x/treasury/types/gov.pb.go +++ b/x/treasury/types/gov.pb.go @@ -5,17 +5,20 @@ package types import ( fmt "fmt" - _ "github.com/cosmos/gogoproto/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -35,9 +38,11 @@ func (*AddBurnTaxExemptionAddressProposal) ProtoMessage() {} func (*AddBurnTaxExemptionAddressProposal) Descriptor() ([]byte, []int) { return fileDescriptor_a71b37663a441645, []int{0} } + func (m *AddBurnTaxExemptionAddressProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *AddBurnTaxExemptionAddressProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AddBurnTaxExemptionAddressProposal.Marshal(b, m, deterministic) @@ -50,12 +55,15 @@ func (m *AddBurnTaxExemptionAddressProposal) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *AddBurnTaxExemptionAddressProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_AddBurnTaxExemptionAddressProposal.Merge(m, src) } + func (m *AddBurnTaxExemptionAddressProposal) XXX_Size() int { return m.Size() } + func (m *AddBurnTaxExemptionAddressProposal) XXX_DiscardUnknown() { xxx_messageInfo_AddBurnTaxExemptionAddressProposal.DiscardUnknown(m) } @@ -74,9 +82,11 @@ func (*RemoveBurnTaxExemptionAddressProposal) ProtoMessage() {} func (*RemoveBurnTaxExemptionAddressProposal) Descriptor() ([]byte, []int) { return fileDescriptor_a71b37663a441645, []int{1} } + func (m *RemoveBurnTaxExemptionAddressProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *RemoveBurnTaxExemptionAddressProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveBurnTaxExemptionAddressProposal.Marshal(b, m, deterministic) @@ -89,12 +99,15 @@ func (m *RemoveBurnTaxExemptionAddressProposal) XXX_Marshal(b []byte, determinis return b[:n], nil } } + func (m *RemoveBurnTaxExemptionAddressProposal) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveBurnTaxExemptionAddressProposal.Merge(m, src) } + func (m *RemoveBurnTaxExemptionAddressProposal) XXX_Size() int { return m.Size() } + func (m *RemoveBurnTaxExemptionAddressProposal) XXX_DiscardUnknown() { xxx_messageInfo_RemoveBurnTaxExemptionAddressProposal.DiscardUnknown(m) } @@ -166,6 +179,7 @@ func (this *AddBurnTaxExemptionAddressProposal) Equal(that interface{}) bool { } return true } + func (this *RemoveBurnTaxExemptionAddressProposal) Equal(that interface{}) bool { if that == nil { return this == nil @@ -201,6 +215,7 @@ func (this *RemoveBurnTaxExemptionAddressProposal) Equal(that interface{}) bool } return true } + func (m *AddBurnTaxExemptionAddressProposal) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -304,6 +319,7 @@ func encodeVarintGov(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *AddBurnTaxExemptionAddressProposal) Size() (n int) { if m == nil { return 0 @@ -353,9 +369,11 @@ func (m *RemoveBurnTaxExemptionAddressProposal) Size() (n int) { func sovGov(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozGov(x uint64) (n int) { return sovGov(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *AddBurnTaxExemptionAddressProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -502,6 +520,7 @@ func (m *AddBurnTaxExemptionAddressProposal) Unmarshal(dAtA []byte) error { } return nil } + func (m *RemoveBurnTaxExemptionAddressProposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -648,6 +667,7 @@ func (m *RemoveBurnTaxExemptionAddressProposal) Unmarshal(dAtA []byte) error { } return nil } + func skipGov(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/query.pb.go b/x/treasury/types/query.pb.go index e485160fe..309860704 100644 --- a/x/treasury/types/query.pb.go +++ b/x/treasury/types/query.pb.go @@ -6,6 +6,10 @@ package types import ( context "context" fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" types "github.com/cosmos/cosmos-sdk/types" query "github.com/cosmos/cosmos-sdk/types/query" @@ -16,15 +20,14 @@ import ( grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -33,8 +36,7 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // QueryTaxRateRequest is the request type for the Query/TaxRate RPC method. -type QueryTaxRateRequest struct { -} +type QueryTaxRateRequest struct{} func (m *QueryTaxRateRequest) Reset() { *m = QueryTaxRateRequest{} } func (m *QueryTaxRateRequest) String() string { return proto.CompactTextString(m) } @@ -42,9 +44,11 @@ func (*QueryTaxRateRequest) ProtoMessage() {} func (*QueryTaxRateRequest) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{0} } + func (m *QueryTaxRateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTaxRateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTaxRateRequest.Marshal(b, m, deterministic) @@ -57,12 +61,15 @@ func (m *QueryTaxRateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryTaxRateRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTaxRateRequest.Merge(m, src) } + func (m *QueryTaxRateRequest) XXX_Size() int { return m.Size() } + func (m *QueryTaxRateRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryTaxRateRequest.DiscardUnknown(m) } @@ -81,9 +88,11 @@ func (*QueryTaxRateResponse) ProtoMessage() {} func (*QueryTaxRateResponse) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{1} } + func (m *QueryTaxRateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTaxRateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTaxRateResponse.Marshal(b, m, deterministic) @@ -96,12 +105,15 @@ func (m *QueryTaxRateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *QueryTaxRateResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTaxRateResponse.Merge(m, src) } + func (m *QueryTaxRateResponse) XXX_Size() int { return m.Size() } + func (m *QueryTaxRateResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryTaxRateResponse.DiscardUnknown(m) } @@ -120,9 +132,11 @@ func (*QueryTaxCapRequest) ProtoMessage() {} func (*QueryTaxCapRequest) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{2} } + func (m *QueryTaxCapRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTaxCapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTaxCapRequest.Marshal(b, m, deterministic) @@ -135,12 +149,15 @@ func (m *QueryTaxCapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryTaxCapRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTaxCapRequest.Merge(m, src) } + func (m *QueryTaxCapRequest) XXX_Size() int { return m.Size() } + func (m *QueryTaxCapRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryTaxCapRequest.DiscardUnknown(m) } @@ -159,9 +176,11 @@ func (*QueryTaxCapResponse) ProtoMessage() {} func (*QueryTaxCapResponse) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{3} } + func (m *QueryTaxCapResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTaxCapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTaxCapResponse.Marshal(b, m, deterministic) @@ -174,12 +193,15 @@ func (m *QueryTaxCapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryTaxCapResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTaxCapResponse.Merge(m, src) } + func (m *QueryTaxCapResponse) XXX_Size() int { return m.Size() } + func (m *QueryTaxCapResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryTaxCapResponse.DiscardUnknown(m) } @@ -187,8 +209,7 @@ func (m *QueryTaxCapResponse) XXX_DiscardUnknown() { var xxx_messageInfo_QueryTaxCapResponse proto.InternalMessageInfo // QueryTaxCapsRequest is the request type for the Query/TaxCaps RPC method. -type QueryTaxCapsRequest struct { -} +type QueryTaxCapsRequest struct{} func (m *QueryTaxCapsRequest) Reset() { *m = QueryTaxCapsRequest{} } func (m *QueryTaxCapsRequest) String() string { return proto.CompactTextString(m) } @@ -196,9 +217,11 @@ func (*QueryTaxCapsRequest) ProtoMessage() {} func (*QueryTaxCapsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{4} } + func (m *QueryTaxCapsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTaxCapsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTaxCapsRequest.Marshal(b, m, deterministic) @@ -211,12 +234,15 @@ func (m *QueryTaxCapsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryTaxCapsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTaxCapsRequest.Merge(m, src) } + func (m *QueryTaxCapsRequest) XXX_Size() int { return m.Size() } + func (m *QueryTaxCapsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryTaxCapsRequest.DiscardUnknown(m) } @@ -236,9 +262,11 @@ func (*QueryTaxCapsResponseItem) ProtoMessage() {} func (*QueryTaxCapsResponseItem) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{5} } + func (m *QueryTaxCapsResponseItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTaxCapsResponseItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTaxCapsResponseItem.Marshal(b, m, deterministic) @@ -251,12 +279,15 @@ func (m *QueryTaxCapsResponseItem) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryTaxCapsResponseItem) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTaxCapsResponseItem.Merge(m, src) } + func (m *QueryTaxCapsResponseItem) XXX_Size() int { return m.Size() } + func (m *QueryTaxCapsResponseItem) XXX_DiscardUnknown() { xxx_messageInfo_QueryTaxCapsResponseItem.DiscardUnknown(m) } @@ -282,9 +313,11 @@ func (*QueryTaxCapsResponse) ProtoMessage() {} func (*QueryTaxCapsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{6} } + func (m *QueryTaxCapsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTaxCapsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTaxCapsResponse.Marshal(b, m, deterministic) @@ -297,12 +330,15 @@ func (m *QueryTaxCapsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *QueryTaxCapsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTaxCapsResponse.Merge(m, src) } + func (m *QueryTaxCapsResponse) XXX_Size() int { return m.Size() } + func (m *QueryTaxCapsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryTaxCapsResponse.DiscardUnknown(m) } @@ -317,8 +353,7 @@ func (m *QueryTaxCapsResponse) GetTaxCaps() []QueryTaxCapsResponseItem { } // QueryRewardWeightRequest is the request type for the Query/RewardWeight RPC method. -type QueryRewardWeightRequest struct { -} +type QueryRewardWeightRequest struct{} func (m *QueryRewardWeightRequest) Reset() { *m = QueryRewardWeightRequest{} } func (m *QueryRewardWeightRequest) String() string { return proto.CompactTextString(m) } @@ -326,9 +361,11 @@ func (*QueryRewardWeightRequest) ProtoMessage() {} func (*QueryRewardWeightRequest) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{7} } + func (m *QueryRewardWeightRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryRewardWeightRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryRewardWeightRequest.Marshal(b, m, deterministic) @@ -341,12 +378,15 @@ func (m *QueryRewardWeightRequest) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryRewardWeightRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryRewardWeightRequest.Merge(m, src) } + func (m *QueryRewardWeightRequest) XXX_Size() int { return m.Size() } + func (m *QueryRewardWeightRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryRewardWeightRequest.DiscardUnknown(m) } @@ -365,9 +405,11 @@ func (*QueryRewardWeightResponse) ProtoMessage() {} func (*QueryRewardWeightResponse) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{8} } + func (m *QueryRewardWeightResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryRewardWeightResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryRewardWeightResponse.Marshal(b, m, deterministic) @@ -380,12 +422,15 @@ func (m *QueryRewardWeightResponse) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } + func (m *QueryRewardWeightResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryRewardWeightResponse.Merge(m, src) } + func (m *QueryRewardWeightResponse) XXX_Size() int { return m.Size() } + func (m *QueryRewardWeightResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryRewardWeightResponse.DiscardUnknown(m) } @@ -393,8 +438,7 @@ func (m *QueryRewardWeightResponse) XXX_DiscardUnknown() { var xxx_messageInfo_QueryRewardWeightResponse proto.InternalMessageInfo // QueryTaxProceedsRequest is the request type for the Query/TaxProceeds RPC method. -type QueryTaxProceedsRequest struct { -} +type QueryTaxProceedsRequest struct{} func (m *QueryTaxProceedsRequest) Reset() { *m = QueryTaxProceedsRequest{} } func (m *QueryTaxProceedsRequest) String() string { return proto.CompactTextString(m) } @@ -402,9 +446,11 @@ func (*QueryTaxProceedsRequest) ProtoMessage() {} func (*QueryTaxProceedsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{9} } + func (m *QueryTaxProceedsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTaxProceedsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTaxProceedsRequest.Marshal(b, m, deterministic) @@ -417,12 +463,15 @@ func (m *QueryTaxProceedsRequest) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *QueryTaxProceedsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTaxProceedsRequest.Merge(m, src) } + func (m *QueryTaxProceedsRequest) XXX_Size() int { return m.Size() } + func (m *QueryTaxProceedsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryTaxProceedsRequest.DiscardUnknown(m) } @@ -441,9 +490,11 @@ func (*QueryTaxProceedsResponse) ProtoMessage() {} func (*QueryTaxProceedsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{10} } + func (m *QueryTaxProceedsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryTaxProceedsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryTaxProceedsResponse.Marshal(b, m, deterministic) @@ -456,12 +507,15 @@ func (m *QueryTaxProceedsResponse) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *QueryTaxProceedsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryTaxProceedsResponse.Merge(m, src) } + func (m *QueryTaxProceedsResponse) XXX_Size() int { return m.Size() } + func (m *QueryTaxProceedsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryTaxProceedsResponse.DiscardUnknown(m) } @@ -476,8 +530,7 @@ func (m *QueryTaxProceedsResponse) GetTaxProceeds() github_com_cosmos_cosmos_sdk } // QuerySeigniorageProceedsRequest is the request type for the Query/SeigniorageProceeds RPC method. -type QuerySeigniorageProceedsRequest struct { -} +type QuerySeigniorageProceedsRequest struct{} func (m *QuerySeigniorageProceedsRequest) Reset() { *m = QuerySeigniorageProceedsRequest{} } func (m *QuerySeigniorageProceedsRequest) String() string { return proto.CompactTextString(m) } @@ -485,9 +538,11 @@ func (*QuerySeigniorageProceedsRequest) ProtoMessage() {} func (*QuerySeigniorageProceedsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{11} } + func (m *QuerySeigniorageProceedsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QuerySeigniorageProceedsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QuerySeigniorageProceedsRequest.Marshal(b, m, deterministic) @@ -500,12 +555,15 @@ func (m *QuerySeigniorageProceedsRequest) XXX_Marshal(b []byte, deterministic bo return b[:n], nil } } + func (m *QuerySeigniorageProceedsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QuerySeigniorageProceedsRequest.Merge(m, src) } + func (m *QuerySeigniorageProceedsRequest) XXX_Size() int { return m.Size() } + func (m *QuerySeigniorageProceedsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QuerySeigniorageProceedsRequest.DiscardUnknown(m) } @@ -524,9 +582,11 @@ func (*QuerySeigniorageProceedsResponse) ProtoMessage() {} func (*QuerySeigniorageProceedsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{12} } + func (m *QuerySeigniorageProceedsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QuerySeigniorageProceedsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QuerySeigniorageProceedsResponse.Marshal(b, m, deterministic) @@ -539,12 +599,15 @@ func (m *QuerySeigniorageProceedsResponse) XXX_Marshal(b []byte, deterministic b return b[:n], nil } } + func (m *QuerySeigniorageProceedsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QuerySeigniorageProceedsResponse.Merge(m, src) } + func (m *QuerySeigniorageProceedsResponse) XXX_Size() int { return m.Size() } + func (m *QuerySeigniorageProceedsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QuerySeigniorageProceedsResponse.DiscardUnknown(m) } @@ -552,8 +615,7 @@ func (m *QuerySeigniorageProceedsResponse) XXX_DiscardUnknown() { var xxx_messageInfo_QuerySeigniorageProceedsResponse proto.InternalMessageInfo // QueryIndicatorsRequest is the request type for the Query/Indicators RPC method. -type QueryIndicatorsRequest struct { -} +type QueryIndicatorsRequest struct{} func (m *QueryIndicatorsRequest) Reset() { *m = QueryIndicatorsRequest{} } func (m *QueryIndicatorsRequest) String() string { return proto.CompactTextString(m) } @@ -561,9 +623,11 @@ func (*QueryIndicatorsRequest) ProtoMessage() {} func (*QueryIndicatorsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{13} } + func (m *QueryIndicatorsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryIndicatorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryIndicatorsRequest.Marshal(b, m, deterministic) @@ -576,12 +640,15 @@ func (m *QueryIndicatorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } + func (m *QueryIndicatorsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryIndicatorsRequest.Merge(m, src) } + func (m *QueryIndicatorsRequest) XXX_Size() int { return m.Size() } + func (m *QueryIndicatorsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryIndicatorsRequest.DiscardUnknown(m) } @@ -601,9 +668,11 @@ func (*QueryIndicatorsResponse) ProtoMessage() {} func (*QueryIndicatorsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{14} } + func (m *QueryIndicatorsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryIndicatorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryIndicatorsResponse.Marshal(b, m, deterministic) @@ -616,12 +685,15 @@ func (m *QueryIndicatorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } + func (m *QueryIndicatorsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryIndicatorsResponse.Merge(m, src) } + func (m *QueryIndicatorsResponse) XXX_Size() int { return m.Size() } + func (m *QueryIndicatorsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryIndicatorsResponse.DiscardUnknown(m) } @@ -629,8 +701,7 @@ func (m *QueryIndicatorsResponse) XXX_DiscardUnknown() { var xxx_messageInfo_QueryIndicatorsResponse proto.InternalMessageInfo // QueryParamsRequest is the request type for the Query/Params RPC method. -type QueryParamsRequest struct { -} +type QueryParamsRequest struct{} func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } @@ -638,9 +709,11 @@ func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{15} } + func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) @@ -653,12 +726,15 @@ func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsRequest.Merge(m, src) } + func (m *QueryParamsRequest) XXX_Size() int { return m.Size() } + func (m *QueryParamsRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) } @@ -677,9 +753,11 @@ func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{16} } + func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) @@ -692,12 +770,15 @@ func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } + func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryParamsResponse.Merge(m, src) } + func (m *QueryParamsResponse) XXX_Size() int { return m.Size() } + func (m *QueryParamsResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) } @@ -722,9 +803,11 @@ func (*QueryBurnTaxExemptionListRequest) ProtoMessage() {} func (*QueryBurnTaxExemptionListRequest) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{17} } + func (m *QueryBurnTaxExemptionListRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryBurnTaxExemptionListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryBurnTaxExemptionListRequest.Marshal(b, m, deterministic) @@ -737,12 +820,15 @@ func (m *QueryBurnTaxExemptionListRequest) XXX_Marshal(b []byte, deterministic b return b[:n], nil } } + func (m *QueryBurnTaxExemptionListRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryBurnTaxExemptionListRequest.Merge(m, src) } + func (m *QueryBurnTaxExemptionListRequest) XXX_Size() int { return m.Size() } + func (m *QueryBurnTaxExemptionListRequest) XXX_DiscardUnknown() { xxx_messageInfo_QueryBurnTaxExemptionListRequest.DiscardUnknown(m) } @@ -768,9 +854,11 @@ func (*QueryBurnTaxExemptionListResponse) ProtoMessage() {} func (*QueryBurnTaxExemptionListResponse) Descriptor() ([]byte, []int) { return fileDescriptor_699c8c29293c9a9b, []int{18} } + func (m *QueryBurnTaxExemptionListResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *QueryBurnTaxExemptionListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryBurnTaxExemptionListResponse.Marshal(b, m, deterministic) @@ -783,12 +871,15 @@ func (m *QueryBurnTaxExemptionListResponse) XXX_Marshal(b []byte, deterministic return b[:n], nil } } + func (m *QueryBurnTaxExemptionListResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryBurnTaxExemptionListResponse.Merge(m, src) } + func (m *QueryBurnTaxExemptionListResponse) XXX_Size() int { return m.Size() } + func (m *QueryBurnTaxExemptionListResponse) XXX_DiscardUnknown() { xxx_messageInfo_QueryBurnTaxExemptionListResponse.DiscardUnknown(m) } @@ -906,8 +997,10 @@ var fileDescriptor_699c8c29293c9a9b = []byte{ } // Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var ( + _ context.Context + _ grpc.ClientConn +) // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. @@ -1049,33 +1142,40 @@ type QueryServer interface { } // UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} +type UnimplementedQueryServer struct{} func (*UnimplementedQueryServer) TaxRate(ctx context.Context, req *QueryTaxRateRequest) (*QueryTaxRateResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TaxRate not implemented") } + func (*UnimplementedQueryServer) TaxCap(ctx context.Context, req *QueryTaxCapRequest) (*QueryTaxCapResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TaxCap not implemented") } + func (*UnimplementedQueryServer) TaxCaps(ctx context.Context, req *QueryTaxCapsRequest) (*QueryTaxCapsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TaxCaps not implemented") } + func (*UnimplementedQueryServer) RewardWeight(ctx context.Context, req *QueryRewardWeightRequest) (*QueryRewardWeightResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RewardWeight not implemented") } + func (*UnimplementedQueryServer) SeigniorageProceeds(ctx context.Context, req *QuerySeigniorageProceedsRequest) (*QuerySeigniorageProceedsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SeigniorageProceeds not implemented") } + func (*UnimplementedQueryServer) TaxProceeds(ctx context.Context, req *QueryTaxProceedsRequest) (*QueryTaxProceedsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TaxProceeds not implemented") } + func (*UnimplementedQueryServer) Indicators(ctx context.Context, req *QueryIndicatorsRequest) (*QueryIndicatorsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Indicators not implemented") } + func (*UnimplementedQueryServer) BurnTaxExemptionList(ctx context.Context, req *QueryBurnTaxExemptionListRequest) (*QueryBurnTaxExemptionListResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method BurnTaxExemptionList not implemented") } + func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } @@ -1894,6 +1994,7 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *QueryTaxRateRequest) Size() (n int) { if m == nil { return 0 @@ -2118,9 +2219,11 @@ func (m *QueryBurnTaxExemptionListResponse) Size() (n int) { func sovQuery(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozQuery(x uint64) (n int) { return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *QueryTaxRateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2171,6 +2274,7 @@ func (m *QueryTaxRateRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTaxRateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2255,6 +2359,7 @@ func (m *QueryTaxRateResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTaxCapRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2337,6 +2442,7 @@ func (m *QueryTaxCapRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTaxCapResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2421,6 +2527,7 @@ func (m *QueryTaxCapResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTaxCapsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2471,6 +2578,7 @@ func (m *QueryTaxCapsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTaxCapsResponseItem) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2587,6 +2695,7 @@ func (m *QueryTaxCapsResponseItem) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTaxCapsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2671,6 +2780,7 @@ func (m *QueryTaxCapsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryRewardWeightRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2721,6 +2831,7 @@ func (m *QueryRewardWeightRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryRewardWeightResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2805,6 +2916,7 @@ func (m *QueryRewardWeightResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTaxProceedsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2855,6 +2967,7 @@ func (m *QueryTaxProceedsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryTaxProceedsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2939,6 +3052,7 @@ func (m *QueryTaxProceedsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QuerySeigniorageProceedsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2989,6 +3103,7 @@ func (m *QuerySeigniorageProceedsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QuerySeigniorageProceedsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3073,6 +3188,7 @@ func (m *QuerySeigniorageProceedsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryIndicatorsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3123,6 +3239,7 @@ func (m *QueryIndicatorsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryIndicatorsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3241,6 +3358,7 @@ func (m *QueryIndicatorsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3291,6 +3409,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3374,6 +3493,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryBurnTaxExemptionListRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3460,6 +3580,7 @@ func (m *QueryBurnTaxExemptionListRequest) Unmarshal(dAtA []byte) error { } return nil } + func (m *QueryBurnTaxExemptionListResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3578,6 +3699,7 @@ func (m *QueryBurnTaxExemptionListResponse) Unmarshal(dAtA []byte) error { } return nil } + func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/treasury/types/query.pb.gw.go b/x/treasury/types/query.pb.gw.go index 3078960c4..5052b12a6 100644 --- a/x/treasury/types/query.pb.gw.go +++ b/x/treasury/types/query.pb.gw.go @@ -25,13 +25,15 @@ import ( ) // Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = descriptor.ForMessage -var _ = metadata.Join +var ( + _ codes.Code + _ io.Reader + _ status.Status + _ = runtime.String + _ = utilities.NewDoubleArray + _ = descriptor.ForMessage + _ = metadata.Join +) func request_Query_TaxRate_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryTaxRateRequest @@ -39,7 +41,6 @@ func request_Query_TaxRate_0(ctx context.Context, marshaler runtime.Marshaler, c msg, err := client.TaxRate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_TaxRate_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -48,7 +49,6 @@ func local_request_Query_TaxRate_0(ctx context.Context, marshaler runtime.Marsha msg, err := server.TaxRate(ctx, &protoReq) return msg, metadata, err - } func request_Query_TaxCap_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -75,7 +75,6 @@ func request_Query_TaxCap_0(ctx context.Context, marshaler runtime.Marshaler, cl msg, err := client.TaxCap(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_TaxCap_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -102,7 +101,6 @@ func local_request_Query_TaxCap_0(ctx context.Context, marshaler runtime.Marshal msg, err := server.TaxCap(ctx, &protoReq) return msg, metadata, err - } func request_Query_TaxCaps_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -111,7 +109,6 @@ func request_Query_TaxCaps_0(ctx context.Context, marshaler runtime.Marshaler, c msg, err := client.TaxCaps(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_TaxCaps_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -120,7 +117,6 @@ func local_request_Query_TaxCaps_0(ctx context.Context, marshaler runtime.Marsha msg, err := server.TaxCaps(ctx, &protoReq) return msg, metadata, err - } func request_Query_RewardWeight_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -129,7 +125,6 @@ func request_Query_RewardWeight_0(ctx context.Context, marshaler runtime.Marshal msg, err := client.RewardWeight(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_RewardWeight_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -138,7 +133,6 @@ func local_request_Query_RewardWeight_0(ctx context.Context, marshaler runtime.M msg, err := server.RewardWeight(ctx, &protoReq) return msg, metadata, err - } func request_Query_SeigniorageProceeds_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -147,7 +141,6 @@ func request_Query_SeigniorageProceeds_0(ctx context.Context, marshaler runtime. msg, err := client.SeigniorageProceeds(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_SeigniorageProceeds_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -156,7 +149,6 @@ func local_request_Query_SeigniorageProceeds_0(ctx context.Context, marshaler ru msg, err := server.SeigniorageProceeds(ctx, &protoReq) return msg, metadata, err - } func request_Query_TaxProceeds_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -165,7 +157,6 @@ func request_Query_TaxProceeds_0(ctx context.Context, marshaler runtime.Marshale msg, err := client.TaxProceeds(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_TaxProceeds_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -174,7 +165,6 @@ func local_request_Query_TaxProceeds_0(ctx context.Context, marshaler runtime.Ma msg, err := server.TaxProceeds(ctx, &protoReq) return msg, metadata, err - } func request_Query_Indicators_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -183,7 +173,6 @@ func request_Query_Indicators_0(ctx context.Context, marshaler runtime.Marshaler msg, err := client.Indicators(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_Indicators_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -192,12 +181,9 @@ func local_request_Query_Indicators_0(ctx context.Context, marshaler runtime.Mar msg, err := server.Indicators(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Query_BurnTaxExemptionList_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_Query_BurnTaxExemptionList_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_Query_BurnTaxExemptionList_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryBurnTaxExemptionListRequest @@ -212,7 +198,6 @@ func request_Query_BurnTaxExemptionList_0(ctx context.Context, marshaler runtime msg, err := client.BurnTaxExemptionList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_BurnTaxExemptionList_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -228,7 +213,6 @@ func local_request_Query_BurnTaxExemptionList_0(ctx context.Context, marshaler r msg, err := server.BurnTaxExemptionList(ctx, &protoReq) return msg, metadata, err - } func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -237,7 +221,6 @@ func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, cl msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -246,7 +229,6 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal msg, err := server.Params(ctx, &protoReq) return msg, metadata, err - } // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". @@ -254,7 +236,6 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { - mux.Handle("GET", pattern_Query_TaxRate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -275,7 +256,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_TaxRate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TaxCap_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -298,7 +278,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_TaxCap_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TaxCaps_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -321,7 +300,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_TaxCaps_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_RewardWeight_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -344,7 +322,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_RewardWeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_SeigniorageProceeds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -367,7 +344,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_SeigniorageProceeds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TaxProceeds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -390,7 +366,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_TaxProceeds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Indicators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -413,7 +388,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_Indicators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_BurnTaxExemptionList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -436,7 +410,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_BurnTaxExemptionList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -459,7 +432,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv } forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil @@ -502,7 +474,6 @@ func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in // "QueryClient" to call the correct interceptors. func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { - mux.Handle("GET", pattern_Query_TaxRate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -520,7 +491,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_TaxRate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TaxCap_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -540,7 +510,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_TaxCap_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TaxCaps_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -560,7 +529,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_TaxCaps_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_RewardWeight_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -580,7 +548,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_RewardWeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_SeigniorageProceeds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -600,7 +567,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_SeigniorageProceeds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_TaxProceeds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -620,7 +586,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_TaxProceeds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Indicators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -640,7 +605,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_Indicators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_BurnTaxExemptionList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -660,7 +624,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_BurnTaxExemptionList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { @@ -680,7 +643,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil diff --git a/x/treasury/types/treasury.pb.go b/x/treasury/types/treasury.pb.go index b119e353b..e76f5f094 100644 --- a/x/treasury/types/treasury.pb.go +++ b/x/treasury/types/treasury.pb.go @@ -5,19 +5,22 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/gogo/protobuf/proto" - io "io" - math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -43,9 +46,11 @@ func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { return fileDescriptor_353bb3a9c554268e, []int{0} } + func (m *Params) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Params.Marshal(b, m, deterministic) @@ -58,12 +63,15 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Params) XXX_Merge(src proto.Message) { xxx_messageInfo_Params.Merge(m, src) } + func (m *Params) XXX_Size() int { return m.Size() } + func (m *Params) XXX_DiscardUnknown() { xxx_messageInfo_Params.DiscardUnknown(m) } @@ -118,9 +126,11 @@ func (*PolicyConstraints) ProtoMessage() {} func (*PolicyConstraints) Descriptor() ([]byte, []int) { return fileDescriptor_353bb3a9c554268e, []int{1} } + func (m *PolicyConstraints) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *PolicyConstraints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PolicyConstraints.Marshal(b, m, deterministic) @@ -133,12 +143,15 @@ func (m *PolicyConstraints) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } + func (m *PolicyConstraints) XXX_Merge(src proto.Message) { xxx_messageInfo_PolicyConstraints.Merge(m, src) } + func (m *PolicyConstraints) XXX_Size() int { return m.Size() } + func (m *PolicyConstraints) XXX_DiscardUnknown() { xxx_messageInfo_PolicyConstraints.DiscardUnknown(m) } @@ -164,9 +177,11 @@ func (*EpochTaxProceeds) ProtoMessage() {} func (*EpochTaxProceeds) Descriptor() ([]byte, []int) { return fileDescriptor_353bb3a9c554268e, []int{2} } + func (m *EpochTaxProceeds) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EpochTaxProceeds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EpochTaxProceeds.Marshal(b, m, deterministic) @@ -179,12 +194,15 @@ func (m *EpochTaxProceeds) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } + func (m *EpochTaxProceeds) XXX_Merge(src proto.Message) { xxx_messageInfo_EpochTaxProceeds.Merge(m, src) } + func (m *EpochTaxProceeds) XXX_Size() int { return m.Size() } + func (m *EpochTaxProceeds) XXX_DiscardUnknown() { xxx_messageInfo_EpochTaxProceeds.DiscardUnknown(m) } @@ -210,9 +228,11 @@ func (*EpochInitialIssuance) ProtoMessage() {} func (*EpochInitialIssuance) Descriptor() ([]byte, []int) { return fileDescriptor_353bb3a9c554268e, []int{3} } + func (m *EpochInitialIssuance) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *EpochInitialIssuance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EpochInitialIssuance.Marshal(b, m, deterministic) @@ -225,12 +245,15 @@ func (m *EpochInitialIssuance) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } + func (m *EpochInitialIssuance) XXX_Merge(src proto.Message) { xxx_messageInfo_EpochInitialIssuance.Merge(m, src) } + func (m *EpochInitialIssuance) XXX_Size() int { return m.Size() } + func (m *EpochInitialIssuance) XXX_DiscardUnknown() { xxx_messageInfo_EpochInitialIssuance.DiscardUnknown(m) } @@ -356,6 +379,7 @@ func (this *Params) Equal(that interface{}) bool { } return true } + func (this *PolicyConstraints) Equal(that interface{}) bool { if that == nil { return this == nil @@ -389,6 +413,7 @@ func (this *PolicyConstraints) Equal(that interface{}) bool { } return true } + func (m *Params) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -635,6 +660,7 @@ func encodeVarintTreasury(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *Params) Size() (n int) { if m == nil { return 0 @@ -715,9 +741,11 @@ func (m *EpochInitialIssuance) Size() (n int) { func sovTreasury(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozTreasury(x uint64) (n int) { return sovTreasury(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *Params) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1027,6 +1055,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } + func (m *PolicyConstraints) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1212,6 +1241,7 @@ func (m *PolicyConstraints) Unmarshal(dAtA []byte) error { } return nil } + func (m *EpochTaxProceeds) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1296,6 +1326,7 @@ func (m *EpochTaxProceeds) Unmarshal(dAtA []byte) error { } return nil } + func (m *EpochInitialIssuance) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1380,6 +1411,7 @@ func (m *EpochInitialIssuance) Unmarshal(dAtA []byte) error { } return nil } + func skipTreasury(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/vesting/types/vesting.pb.go b/x/vesting/types/vesting.pb.go index 412f9ec4b..29f4d9850 100644 --- a/x/vesting/types/vesting.pb.go +++ b/x/vesting/types/vesting.pb.go @@ -5,19 +5,22 @@ package types import ( fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" types "github.com/cosmos/cosmos-sdk/x/auth/vesting/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/gogo/protobuf/proto" - io "io" - math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +var ( + _ = proto.Marshal + _ = fmt.Errorf + _ = 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. @@ -37,9 +40,11 @@ func (*LazyGradedVestingAccount) ProtoMessage() {} func (*LazyGradedVestingAccount) Descriptor() ([]byte, []int) { return fileDescriptor_c4a9bc06e563192a, []int{0} } + func (m *LazyGradedVestingAccount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *LazyGradedVestingAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LazyGradedVestingAccount.Marshal(b, m, deterministic) @@ -52,12 +57,15 @@ func (m *LazyGradedVestingAccount) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } + func (m *LazyGradedVestingAccount) XXX_Merge(src proto.Message) { xxx_messageInfo_LazyGradedVestingAccount.Merge(m, src) } + func (m *LazyGradedVestingAccount) XXX_Size() int { return m.Size() } + func (m *LazyGradedVestingAccount) XXX_DiscardUnknown() { xxx_messageInfo_LazyGradedVestingAccount.DiscardUnknown(m) } @@ -77,9 +85,11 @@ func (*Schedule) ProtoMessage() {} func (*Schedule) Descriptor() ([]byte, []int) { return fileDescriptor_c4a9bc06e563192a, []int{1} } + func (m *Schedule) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *Schedule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Schedule.Marshal(b, m, deterministic) @@ -92,12 +102,15 @@ func (m *Schedule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } + func (m *Schedule) XXX_Merge(src proto.Message) { xxx_messageInfo_Schedule.Merge(m, src) } + func (m *Schedule) XXX_Size() int { return m.Size() } + func (m *Schedule) XXX_DiscardUnknown() { xxx_messageInfo_Schedule.DiscardUnknown(m) } @@ -116,9 +129,11 @@ func (*VestingSchedule) ProtoMessage() {} func (*VestingSchedule) Descriptor() ([]byte, []int) { return fileDescriptor_c4a9bc06e563192a, []int{2} } + func (m *VestingSchedule) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } + func (m *VestingSchedule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_VestingSchedule.Marshal(b, m, deterministic) @@ -131,12 +146,15 @@ func (m *VestingSchedule) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } + func (m *VestingSchedule) XXX_Merge(src proto.Message) { xxx_messageInfo_VestingSchedule.Merge(m, src) } + func (m *VestingSchedule) XXX_Size() int { return m.Size() } + func (m *VestingSchedule) XXX_DiscardUnknown() { xxx_messageInfo_VestingSchedule.DiscardUnknown(m) } @@ -335,6 +353,7 @@ func encodeVarintVesting(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } + func (m *LazyGradedVestingAccount) Size() (n int) { if m == nil { return 0 @@ -393,9 +412,11 @@ func (m *VestingSchedule) Size() (n int) { func sovVesting(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } + func sozVesting(x uint64) (n int) { return sovVesting(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } + func (m *LazyGradedVestingAccount) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -516,6 +537,7 @@ func (m *LazyGradedVestingAccount) Unmarshal(dAtA []byte) error { } return nil } + func (m *Schedule) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -638,6 +660,7 @@ func (m *Schedule) Unmarshal(dAtA []byte) error { } return nil } + func (m *VestingSchedule) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -754,6 +777,7 @@ func (m *VestingSchedule) Unmarshal(dAtA []byte) error { } return nil } + func skipVesting(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0