From a1c47bf3f898745f93191587a39a0c1260630e8b Mon Sep 17 00:00:00 2001 From: Daniel Date: Wed, 2 Nov 2022 11:06:40 +0000 Subject: [PATCH] Rename and rebuild proto --- .../ccv/provider/v1/genesis.proto | 2 +- .../ccv/provider/v1/query.proto | 14 +- .../ccv/provider/v1/tx.proto | 17 +- x/ccv/provider/types/genesis.pb.go | 131 +- x/ccv/provider/types/query.pb.go | 248 +-- x/ccv/provider/types/query.pb.gw.go | 34 +- x/ccv/provider/types/tx.pb.go | 199 +-- x/ccv/types/keyassignment.pb.go | 1488 +++++++++++++++++ 8 files changed, 1810 insertions(+), 323 deletions(-) create mode 100644 x/ccv/types/keyassignment.pb.go diff --git a/proto/interchain_security/ccv/provider/v1/genesis.proto b/proto/interchain_security/ccv/provider/v1/genesis.proto index f3b467fb33..6e25b2bbfd 100644 --- a/proto/interchain_security/ccv/provider/v1/genesis.proto +++ b/proto/interchain_security/ccv/provider/v1/genesis.proto @@ -61,7 +61,7 @@ message ConsumerState { // UnbondingOpsIndex defines the unbonding operations on the consumer chain repeated UnbondingOpIndex unbonding_ops_index = 9 [ (gogoproto.nullable) = false ]; - KeyAssignment key_map = 10; + KeyAssignment key_assignment = 10; } // UnbondingOpIndex defines the genesis information for each unbonding diff --git a/proto/interchain_security/ccv/provider/v1/query.proto b/proto/interchain_security/ccv/provider/v1/query.proto index c7552f5a1c..db0d65cb91 100644 --- a/proto/interchain_security/ccv/provider/v1/query.proto +++ b/proto/interchain_security/ccv/provider/v1/query.proto @@ -42,12 +42,12 @@ service Query { } // TODO: - rpc QueryConsumerChainValidatorKeyAssignmentping( - QueryConsumerChainValidatorKeyAssignmentpingRequest) - returns (QueryConsumerChainValidatorKeyAssignmentpingResponse) { + rpc QueryConsumerChainValidatorKeyAssignment( + QueryConsumerChainValidatorKeyAssignmentRequest) + returns (QueryConsumerChainValidatorKeyAssignmentResponse) { // TODO: make sure path up to date option (google.api.http).get = "/interchain_security/ccv/provider/" - "consumer_chain_validator_key_mapping"; + "consumer_chain_validator_key_assignment"; } } @@ -79,7 +79,7 @@ message Chain { string client_id = 2; } -message QueryConsumerChainValidatorKeyAssignmentpingRequest { +message QueryConsumerChainValidatorKeyAssignmentRequest { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; string chain_id = 1; @@ -87,7 +87,7 @@ message QueryConsumerChainValidatorKeyAssignmentpingRequest { [ (gogoproto.moretags) = "yaml:\"address\"" ]; } -message QueryConsumerChainValidatorKeyAssignmentpingResponse { - google.protobuf.Any consumer_validator_pub_key = 1 +message QueryConsumerChainValidatorKeyAssignmentResponse { + google.protobuf.Any consumer_consensus_pub_key = 1 [ (cosmos_proto.accepts_interface) = "cosmos.crypto.PubKey" ]; } \ No newline at end of file diff --git a/proto/interchain_security/ccv/provider/v1/tx.proto b/proto/interchain_security/ccv/provider/v1/tx.proto index 15dec83ab7..2e35118944 100644 --- a/proto/interchain_security/ccv/provider/v1/tx.proto +++ b/proto/interchain_security/ccv/provider/v1/tx.proto @@ -1,8 +1,6 @@ syntax = "proto3"; package interchain_security.ccv.provider.v1; -// this line is used by starport scaffolding # proto/tx/import - option go_package = "github.com/cosmos/interchain-security/x/ccv/provider/types"; import "google/api/annotations.proto"; @@ -13,22 +11,19 @@ import "google/protobuf/any.proto"; // Msg defines the Msg service. service Msg { - rpc DesignateConsensusKeyForConsumerChain( - MsgDesignateConsensusKeyForConsumerChain) - returns (MsgDesignateConsensusKeyForConsumerChainResponse); - // this line is used by starport scaffolding # proto/tx/rpc + rpc AssignConsensusPublicKeyToConsumerChain( + MsgAssignConsensusPublicKeyToConsumerChain) + returns (MsgAssignConsensusPublicKeyToConsumerChainResponse); } -message MsgDesignateConsensusKeyForConsumerChain { +message MsgAssignConsensusPublicKeyToConsumerChain { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; string chain_id = 1; string provider_validator_address = 2 [ (gogoproto.moretags) = "yaml:\"address\"" ]; - google.protobuf.Any consumer_validator_pub_key = 3 + google.protobuf.Any consumer_consensus_pub_key = 3 [ (cosmos_proto.accepts_interface) = "cosmos.crypto.PubKey" ]; } -message MsgDesignateConsensusKeyForConsumerChainResponse {} - -// this line is used by starport scaffolding # proto/tx/message +message MsgAssignConsensusPublicKeyToConsumerChainResponse {} \ No newline at end of file diff --git a/x/ccv/provider/types/genesis.pb.go b/x/ccv/provider/types/genesis.pb.go index bec77216ba..ff583dda16 100644 --- a/x/ccv/provider/types/genesis.pb.go +++ b/x/ccv/provider/types/genesis.pb.go @@ -153,8 +153,8 @@ type ConsumerState struct { PendingValsetChanges []types.ValidatorSetChangePacketData `protobuf:"bytes,7,rep,name=pending_valset_changes,json=pendingValsetChanges,proto3" json:"pending_valset_changes"` SlashDowntimeAck []string `protobuf:"bytes,8,rep,name=slash_downtime_ack,json=slashDowntimeAck,proto3" json:"slash_downtime_ack,omitempty"` // UnbondingOpsIndex defines the unbonding operations on the consumer chain - UnbondingOpsIndex []UnbondingOpIndex `protobuf:"bytes,9,rep,name=unbonding_ops_index,json=unbondingOpsIndex,proto3" json:"unbonding_ops_index"` - KeyMap *types.KeyMap `protobuf:"bytes,10,opt,name=key_map,json=keyMap,proto3" json:"key_map,omitempty"` + UnbondingOpsIndex []UnbondingOpIndex `protobuf:"bytes,9,rep,name=unbonding_ops_index,json=unbondingOpsIndex,proto3" json:"unbonding_ops_index"` + KeyAssignment *types.KeyAssignment `protobuf:"bytes,10,opt,name=key_assignment,json=keyAssignment,proto3" json:"key_assignment,omitempty"` } func (m *ConsumerState) Reset() { *m = ConsumerState{} } @@ -253,9 +253,9 @@ func (m *ConsumerState) GetUnbondingOpsIndex() []UnbondingOpIndex { return nil } -func (m *ConsumerState) GetKeyMap() *types.KeyMap { +func (m *ConsumerState) GetKeyAssignment() *types.KeyAssignment { if m != nil { - return m.KeyMap + return m.KeyAssignment } return nil } @@ -380,59 +380,60 @@ func init() { } var fileDescriptor_48411d9c7900d48e = []byte{ - // 830 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0x41, 0x6f, 0xe3, 0x44, - 0x14, 0x8e, 0x9b, 0x6c, 0x9a, 0xcc, 0x6e, 0x4b, 0x18, 0xaa, 0xc8, 0xcd, 0x8a, 0x6c, 0x14, 0x40, - 0x44, 0x62, 0xb1, 0x71, 0x10, 0x12, 0x2c, 0x70, 0xd8, 0x6e, 0x25, 0x88, 0xd0, 0x8a, 0xca, 0xdb, - 0xdd, 0xc3, 0x5e, 0xac, 0xc9, 0x78, 0x94, 0x0c, 0xb6, 0x67, 0x2c, 0xcf, 0xd8, 0x6c, 0x84, 0x90, - 0x90, 0xfa, 0x07, 0xf8, 0x47, 0x5c, 0x7b, 0xec, 0x91, 0x53, 0x85, 0xda, 0x7f, 0xc0, 0x2f, 0x40, - 0x1e, 0x4f, 0x52, 0x27, 0x4a, 0x4a, 0x72, 0x4a, 0xfc, 0x3e, 0x7f, 0xdf, 0xfb, 0xe6, 0xbd, 0x37, - 0xcf, 0xc0, 0xa1, 0x4c, 0x92, 0x04, 0x4f, 0x11, 0x65, 0x9e, 0x20, 0x38, 0x4d, 0xa8, 0x9c, 0xd9, - 0x18, 0x67, 0x76, 0x9c, 0xf0, 0x8c, 0xfa, 0x24, 0xb1, 0x33, 0xc7, 0x9e, 0x10, 0x46, 0x04, 0x15, - 0x56, 0x9c, 0x70, 0xc9, 0xe1, 0x47, 0x6b, 0x28, 0x16, 0xc6, 0x99, 0x35, 0xa7, 0x58, 0x99, 0xd3, - 0x39, 0x9a, 0xf0, 0x09, 0x57, 0xef, 0xdb, 0xf9, 0xbf, 0x82, 0xda, 0xf9, 0x78, 0x53, 0xb6, 0xcc, - 0xb1, 0xb5, 0x82, 0xe4, 0x9d, 0xe1, 0x36, 0x9e, 0x16, 0xc9, 0xfe, 0x87, 0x83, 0x39, 0x13, 0x69, - 0x54, 0x70, 0xe6, 0xff, 0x35, 0xc7, 0xd9, 0x86, 0xb3, 0x74, 0xf6, 0xce, 0x17, 0xdb, 0x58, 0x0b, - 0xc8, 0x2c, 0x42, 0x71, 0xc1, 0xe8, 0xff, 0x55, 0x07, 0x8f, 0x7e, 0x28, 0x34, 0x5e, 0x49, 0x24, - 0x09, 0x1c, 0x80, 0x56, 0x86, 0x42, 0x41, 0xa4, 0x97, 0xc6, 0x3e, 0x92, 0xc4, 0xa3, 0xbe, 0x69, - 0xf4, 0x8c, 0x41, 0xcd, 0x3d, 0x2c, 0xe2, 0xaf, 0x55, 0x78, 0xe4, 0xc3, 0xdf, 0xc0, 0x7b, 0x73, - 0x27, 0x9e, 0xc8, 0xb9, 0xc2, 0xdc, 0xeb, 0x55, 0x07, 0x0f, 0x87, 0x43, 0x6b, 0x8b, 0x16, 0x58, - 0x2f, 0x34, 0x57, 0xa5, 0x3d, 0xe9, 0x5e, 0x5e, 0x3f, 0xa9, 0xfc, 0x7b, 0xfd, 0xa4, 0x3d, 0x43, - 0x51, 0xf8, 0xac, 0xbf, 0x22, 0xdc, 0x77, 0x0f, 0x71, 0xf9, 0x75, 0x01, 0x5d, 0x70, 0x90, 0xb2, - 0x31, 0x67, 0x3e, 0x65, 0x13, 0x8f, 0xc7, 0xc2, 0xac, 0xaa, 0xd4, 0x9f, 0x6e, 0x4c, 0x9d, 0x39, - 0xd6, 0xeb, 0x39, 0xe1, 0xe7, 0xf8, 0xa4, 0x96, 0xe7, 0x73, 0x1f, 0xa5, 0x77, 0x21, 0x01, 0x11, - 0x38, 0x8a, 0x90, 0x4c, 0x13, 0xe2, 0x2d, 0x4b, 0xd7, 0x7a, 0xc6, 0xe0, 0xe1, 0xd0, 0xbe, 0x4f, - 0xfa, 0xa5, 0xe2, 0xf9, 0xa5, 0x0c, 0xc2, 0x85, 0x85, 0x58, 0x39, 0x06, 0x7f, 0x07, 0x9d, 0xd5, - 0xea, 0x7a, 0x92, 0x7b, 0x53, 0x42, 0x27, 0x53, 0x69, 0x3e, 0x50, 0x67, 0xf8, 0x76, 0xab, 0xf2, - 0xbd, 0x59, 0x6a, 0xc6, 0x39, 0xff, 0x51, 0x49, 0xe8, 0x73, 0xb5, 0xb3, 0xb5, 0x28, 0xbc, 0x30, - 0xc0, 0xe3, 0x45, 0x69, 0x91, 0xef, 0x53, 0x49, 0x39, 0xf3, 0xe2, 0x84, 0xc7, 0x5c, 0xa0, 0x50, - 0x98, 0x75, 0x65, 0xe0, 0xfb, 0x9d, 0xfa, 0xf7, 0x5c, 0xcb, 0x9c, 0x69, 0x15, 0x6d, 0xe1, 0x18, - 0x6f, 0xc0, 0x05, 0xfc, 0xc3, 0x00, 0x9d, 0x85, 0x8b, 0x84, 0x44, 0x3c, 0x43, 0x61, 0xc9, 0xc4, - 0xbe, 0x32, 0xf1, 0xdd, 0x4e, 0x26, 0xdc, 0x42, 0x65, 0xc5, 0x83, 0x89, 0xd7, 0xc3, 0x02, 0x8e, - 0x40, 0x3d, 0x46, 0x09, 0x8a, 0x84, 0xd9, 0x50, 0xcd, 0xfd, 0x6c, 0xab, 0x6c, 0x67, 0x8a, 0xa2, - 0xc5, 0xb5, 0x40, 0xff, 0xe2, 0x01, 0x38, 0x58, 0x9a, 0x65, 0x78, 0x0c, 0x1a, 0x85, 0x90, 0xbe, - 0x3a, 0x4d, 0x77, 0x5f, 0x3d, 0x8f, 0x7c, 0xf8, 0x21, 0x00, 0x78, 0x8a, 0x18, 0x23, 0x61, 0x0e, - 0xee, 0x29, 0xb0, 0xa9, 0x23, 0x23, 0x1f, 0x3e, 0x06, 0x4d, 0x1c, 0x52, 0xc2, 0x64, 0x8e, 0x56, - 0x15, 0xda, 0x28, 0x02, 0x23, 0x1f, 0x7e, 0x02, 0x0e, 0x29, 0xa3, 0x92, 0xa2, 0x70, 0x3e, 0x2f, - 0x35, 0x75, 0x2f, 0x0f, 0x74, 0x54, 0xf7, 0xf8, 0x1b, 0x70, 0x1c, 0x72, 0x1c, 0x94, 0x67, 0x98, - 0x79, 0x92, 0x46, 0x84, 0xa7, 0xf9, 0x84, 0x19, 0x83, 0x86, 0xdb, 0xce, 0x5f, 0xb8, 0x9b, 0x4b, - 0x76, 0x5e, 0xa0, 0x70, 0x0c, 0x5a, 0x8b, 0xbe, 0xe8, 0xc5, 0x62, 0xd6, 0x55, 0x7d, 0x9c, 0x8d, - 0xf5, 0x59, 0x2c, 0xad, 0xcc, 0xb1, 0xca, 0x8b, 0x44, 0x57, 0x69, 0xb1, 0x22, 0x34, 0x06, 0x25, - 0x68, 0xc7, 0xa4, 0xf0, 0xa5, 0x6f, 0x42, 0x7e, 0xfc, 0x09, 0x99, 0xf7, 0xfd, 0xeb, 0xfb, 0xae, - 0xd9, 0x1b, 0x14, 0x52, 0x1f, 0x49, 0x9e, 0xbc, 0x22, 0xf2, 0x85, 0xa2, 0x9d, 0x21, 0x1c, 0x10, - 0x79, 0x8a, 0x24, 0xd2, 0x09, 0x8f, 0xb4, 0x7a, 0x71, 0x3f, 0x8a, 0x97, 0x04, 0x7c, 0x0a, 0xa0, - 0x08, 0x91, 0x98, 0x7a, 0x3e, 0xff, 0x95, 0xe5, 0xc5, 0xf0, 0x10, 0x0e, 0xcc, 0x46, 0xaf, 0x3a, - 0x68, 0xba, 0x2d, 0x85, 0x9c, 0x6a, 0xe0, 0x39, 0x0e, 0x60, 0x00, 0x3e, 0x58, 0xda, 0x00, 0x1e, - 0x65, 0x3e, 0x79, 0x67, 0x36, 0x95, 0xc1, 0xaf, 0xb6, 0x1a, 0x95, 0xd2, 0xad, 0x1f, 0xe5, 0x64, - 0xed, 0xee, 0xfd, 0xf2, 0xc2, 0x51, 0x00, 0x3c, 0x05, 0xfb, 0x01, 0x99, 0x79, 0x11, 0x8a, 0x4d, - 0xb0, 0xc3, 0x2c, 0xfe, 0x44, 0x66, 0x2f, 0x51, 0xec, 0xd6, 0x03, 0xf5, 0xdb, 0xff, 0x05, 0xb4, - 0x56, 0x53, 0xee, 0xb0, 0xca, 0x9f, 0x02, 0x58, 0x3e, 0xb0, 0x3e, 0x6f, 0xbe, 0xcd, 0x6b, 0x6e, - 0x2b, 0x5d, 0xd1, 0xed, 0xbf, 0x05, 0xed, 0xf5, 0xdb, 0x67, 0x87, 0x8c, 0x6d, 0x50, 0xd7, 0x43, - 0xbc, 0xa7, 0x70, 0xfd, 0x74, 0x72, 0x7e, 0x79, 0xd3, 0x35, 0xae, 0x6e, 0xba, 0xc6, 0x3f, 0x37, - 0x5d, 0xe3, 0xcf, 0xdb, 0x6e, 0xe5, 0xea, 0xb6, 0x5b, 0xf9, 0xfb, 0xb6, 0x5b, 0x79, 0xfb, 0x6c, - 0x42, 0xe5, 0x34, 0x1d, 0x5b, 0x98, 0x47, 0x36, 0xe6, 0x22, 0xe2, 0xc2, 0xbe, 0xab, 0xd3, 0xe7, - 0x8b, 0xaf, 0xdd, 0xbb, 0xe5, 0xef, 0x9d, 0x9c, 0xc5, 0x44, 0x8c, 0xeb, 0xea, 0x63, 0xf7, 0xe5, - 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x09, 0x5a, 0xeb, 0x74, 0x4f, 0x08, 0x00, 0x00, + // 839 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0x41, 0x8f, 0xdb, 0x44, + 0x14, 0x5e, 0xef, 0xa6, 0x69, 0x32, 0xed, 0x2e, 0x61, 0x58, 0x45, 0xde, 0x54, 0xa4, 0xab, 0x00, + 0x22, 0x12, 0xc5, 0x96, 0x17, 0x21, 0xa0, 0xc0, 0x61, 0xb7, 0x95, 0x20, 0x42, 0x88, 0x95, 0xbb, + 0xad, 0x44, 0x2f, 0xd6, 0x64, 0x3c, 0x72, 0x06, 0xdb, 0x33, 0x96, 0x67, 0x6c, 0x1a, 0x21, 0x24, + 0x24, 0xfe, 0x00, 0x47, 0xfe, 0x0d, 0xd7, 0x1e, 0x7b, 0xe4, 0x54, 0xa1, 0xdd, 0x7f, 0xc0, 0x2f, + 0x40, 0x1e, 0x4f, 0x1c, 0x27, 0x4a, 0x8a, 0x73, 0xb3, 0xdf, 0xe7, 0xef, 0x7b, 0xdf, 0xbc, 0xf7, + 0xe6, 0x19, 0x38, 0x94, 0x49, 0x92, 0xe2, 0x19, 0xa2, 0xcc, 0x13, 0x04, 0x67, 0x29, 0x95, 0x73, + 0x1b, 0xe3, 0xdc, 0x4e, 0x52, 0x9e, 0x53, 0x9f, 0xa4, 0x76, 0xee, 0xd8, 0x01, 0x61, 0x44, 0x50, + 0x61, 0x25, 0x29, 0x97, 0x1c, 0xbe, 0xb7, 0x81, 0x62, 0x61, 0x9c, 0x5b, 0x0b, 0x8a, 0x95, 0x3b, + 0x83, 0xe3, 0x80, 0x07, 0x5c, 0x7d, 0x6f, 0x17, 0x4f, 0x25, 0x75, 0xf0, 0xfe, 0xb6, 0x6c, 0xb9, + 0x63, 0x6b, 0x05, 0xc9, 0x07, 0x67, 0x4d, 0x3c, 0x55, 0xc9, 0xfe, 0x87, 0x83, 0x39, 0x13, 0x59, + 0x5c, 0x72, 0x16, 0xcf, 0x9a, 0xe3, 0x34, 0xe1, 0xac, 0x9c, 0x7d, 0xf0, 0x59, 0x13, 0x6b, 0x21, + 0x99, 0x23, 0x21, 0x68, 0xc0, 0x62, 0xc2, 0x64, 0x49, 0x1c, 0xfd, 0xd5, 0x06, 0x77, 0xbf, 0x29, + 0xa5, 0x9e, 0x48, 0x24, 0x09, 0x1c, 0x83, 0x5e, 0x8e, 0x22, 0x41, 0xa4, 0x97, 0x25, 0x3e, 0x92, + 0xc4, 0xa3, 0xbe, 0x69, 0x9c, 0x1a, 0xe3, 0x96, 0x7b, 0x54, 0xc6, 0x9f, 0xaa, 0xf0, 0xc4, 0x87, + 0xbf, 0x80, 0xb7, 0x16, 0x86, 0x3c, 0x51, 0x70, 0x85, 0xb9, 0x7f, 0x7a, 0x30, 0xbe, 0x73, 0x76, + 0x66, 0x35, 0xe8, 0x84, 0xf5, 0x48, 0x73, 0x55, 0xda, 0x8b, 0xe1, 0xcb, 0xd7, 0xf7, 0xf7, 0xfe, + 0x7d, 0x7d, 0xbf, 0x3f, 0x47, 0x71, 0xf4, 0x70, 0xb4, 0x26, 0x3c, 0x72, 0x8f, 0x70, 0xfd, 0x73, + 0x01, 0x5d, 0x70, 0x98, 0xb1, 0x29, 0x67, 0x3e, 0x65, 0x81, 0xc7, 0x13, 0x61, 0x1e, 0xa8, 0xd4, + 0x1f, 0x6e, 0x4d, 0x9d, 0x3b, 0xd6, 0xd3, 0x05, 0xe1, 0x87, 0xe4, 0xa2, 0x55, 0xe4, 0x73, 0xef, + 0x66, 0xcb, 0x90, 0x80, 0x08, 0x1c, 0xc7, 0x48, 0x66, 0x29, 0xf1, 0x56, 0xa5, 0x5b, 0xa7, 0xc6, + 0xf8, 0xce, 0x99, 0xfd, 0x26, 0xe9, 0xef, 0x15, 0xcf, 0xaf, 0x65, 0x10, 0x2e, 0x2c, 0xc5, 0xea, + 0x31, 0xf8, 0x2b, 0x18, 0xac, 0x57, 0xd7, 0x93, 0xdc, 0x9b, 0x11, 0x1a, 0xcc, 0xa4, 0x79, 0x4b, + 0x9d, 0xe1, 0xcb, 0x46, 0xe5, 0x7b, 0xb6, 0xd2, 0x8c, 0x2b, 0xfe, 0xad, 0x92, 0xd0, 0xe7, 0xea, + 0xe7, 0x1b, 0x51, 0xf8, 0xbb, 0x01, 0xee, 0x55, 0xa5, 0x45, 0xbe, 0x4f, 0x25, 0xe5, 0xcc, 0x4b, + 0x52, 0x9e, 0x70, 0x81, 0x22, 0x61, 0xb6, 0x95, 0x81, 0xaf, 0x77, 0xea, 0xdf, 0xb9, 0x96, 0xb9, + 0xd4, 0x2a, 0xda, 0xc2, 0x09, 0xde, 0x82, 0x0b, 0xf8, 0x9b, 0x01, 0x06, 0x95, 0x8b, 0x94, 0xc4, + 0x3c, 0x47, 0x51, 0xcd, 0xc4, 0x6d, 0x65, 0xe2, 0xab, 0x9d, 0x4c, 0xb8, 0xa5, 0xca, 0x9a, 0x07, + 0x13, 0x6f, 0x86, 0x05, 0x9c, 0x80, 0x76, 0x82, 0x52, 0x14, 0x0b, 0xb3, 0xa3, 0x9a, 0xfb, 0x51, + 0xa3, 0x6c, 0x97, 0x8a, 0xa2, 0xc5, 0xb5, 0xc0, 0xe8, 0xcf, 0x5b, 0xe0, 0x70, 0x65, 0x96, 0xe1, + 0x09, 0xe8, 0x94, 0x42, 0xfa, 0xea, 0x74, 0xdd, 0xdb, 0xea, 0x7d, 0xe2, 0xc3, 0x77, 0x01, 0xc0, + 0x33, 0xc4, 0x18, 0x89, 0x0a, 0x70, 0x5f, 0x81, 0x5d, 0x1d, 0x99, 0xf8, 0xf0, 0x1e, 0xe8, 0xe2, + 0x88, 0x12, 0x26, 0x0b, 0xf4, 0x40, 0xa1, 0x9d, 0x32, 0x30, 0xf1, 0xe1, 0x07, 0xe0, 0x88, 0x32, + 0x2a, 0x29, 0x8a, 0x16, 0xf3, 0xd2, 0x52, 0xf7, 0xf2, 0x50, 0x47, 0x75, 0x8f, 0xbf, 0x00, 0x27, + 0x11, 0xc7, 0x61, 0x7d, 0x86, 0x99, 0x27, 0x69, 0x4c, 0x78, 0x56, 0x4c, 0x98, 0x31, 0xee, 0xb8, + 0xfd, 0xe2, 0x83, 0xe5, 0x5c, 0xb2, 0xab, 0x12, 0x85, 0x53, 0xd0, 0xab, 0xfa, 0xa2, 0xf7, 0x8b, + 0xd9, 0x56, 0xf5, 0x71, 0xb6, 0xd6, 0xa7, 0xda, 0x5d, 0xb9, 0x63, 0xd5, 0x17, 0x89, 0xae, 0x52, + 0xb5, 0x22, 0x34, 0x06, 0x25, 0xe8, 0x27, 0xa4, 0xf4, 0xa5, 0x6f, 0x42, 0x71, 0xfc, 0x80, 0x2c, + 0xfa, 0xfe, 0xf9, 0x9b, 0xae, 0xd9, 0x33, 0x14, 0x51, 0x1f, 0x49, 0x9e, 0x3e, 0x21, 0xf2, 0x91, + 0xa2, 0x5d, 0x22, 0x1c, 0x12, 0xf9, 0x18, 0x49, 0xa4, 0x13, 0x1e, 0x6b, 0xf5, 0xf2, 0x7e, 0x94, + 0x1f, 0x09, 0xf8, 0x00, 0x40, 0x11, 0x21, 0x31, 0xf3, 0x7c, 0xfe, 0x33, 0x2b, 0x8a, 0xe1, 0x21, + 0x1c, 0x9a, 0x9d, 0xd3, 0x83, 0x71, 0xd7, 0xed, 0x29, 0xe4, 0xb1, 0x06, 0xce, 0x71, 0x08, 0x43, + 0xf0, 0xce, 0xca, 0x06, 0xf0, 0x28, 0xf3, 0xc9, 0x0b, 0xb3, 0xab, 0x0c, 0x7e, 0xda, 0x68, 0x54, + 0x6a, 0xb7, 0x7e, 0x52, 0x90, 0xb5, 0xbb, 0xb7, 0xeb, 0x0b, 0x47, 0x01, 0xf0, 0x47, 0x70, 0x14, + 0x92, 0xb9, 0xb7, 0xdc, 0xcc, 0x26, 0x50, 0x25, 0x6f, 0xb6, 0x45, 0xbf, 0x23, 0xf3, 0xf3, 0x8a, + 0xe9, 0x1e, 0x86, 0xf5, 0xd7, 0xd1, 0x4f, 0xa0, 0xb7, 0xee, 0x63, 0x87, 0xfd, 0xfe, 0x00, 0xc0, + 0x7a, 0x15, 0x74, 0x11, 0x8a, 0x15, 0xdf, 0x72, 0x7b, 0xd9, 0x9a, 0xee, 0xe8, 0x39, 0xe8, 0x6f, + 0x5e, 0x49, 0x3b, 0x64, 0xec, 0x83, 0xb6, 0x9e, 0xec, 0x7d, 0x85, 0xeb, 0xb7, 0x8b, 0xab, 0x97, + 0xd7, 0x43, 0xe3, 0xd5, 0xf5, 0xd0, 0xf8, 0xe7, 0x7a, 0x68, 0xfc, 0x71, 0x33, 0xdc, 0x7b, 0x75, + 0x33, 0xdc, 0xfb, 0xfb, 0x66, 0xb8, 0xf7, 0xfc, 0x61, 0x40, 0xe5, 0x2c, 0x9b, 0x5a, 0x98, 0xc7, + 0x36, 0xe6, 0x22, 0xe6, 0xc2, 0x5e, 0x56, 0xed, 0xe3, 0xea, 0x4f, 0xf8, 0x62, 0xf5, 0x5f, 0x28, + 0xe7, 0x09, 0x11, 0xd3, 0xb6, 0xfa, 0x03, 0x7e, 0xf2, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf1, + 0x7e, 0x85, 0x2c, 0x6b, 0x08, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -575,9 +576,9 @@ func (m *ConsumerState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.KeyMap != nil { + if m.KeyAssignment != nil { { - size, err := m.KeyMap.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.KeyAssignment.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -855,8 +856,8 @@ func (m *ConsumerState) Size() (n int) { n += 1 + l + sovGenesis(uint64(l)) } } - if m.KeyMap != nil { - l = m.KeyMap.Size() + if m.KeyAssignment != nil { + l = m.KeyAssignment.Size() n += 1 + l + sovGenesis(uint64(l)) } return n @@ -1509,7 +1510,7 @@ func (m *ConsumerState) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 10: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KeyMap", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KeyAssignment", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -1536,10 +1537,10 @@ func (m *ConsumerState) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.KeyMap == nil { - m.KeyMap = &types.KeyMap{} + if m.KeyAssignment == nil { + m.KeyAssignment = &types.KeyAssignment{} } - if err := m.KeyMap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.KeyAssignment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/x/ccv/provider/types/query.pb.go b/x/ccv/provider/types/query.pb.go index e163a1c43f..06b14cc854 100644 --- a/x/ccv/provider/types/query.pb.go +++ b/x/ccv/provider/types/query.pb.go @@ -420,27 +420,27 @@ func (m *Chain) GetClientId() string { return "" } -type QueryConsumerChainValidatorKeyMappingRequest struct { +type QueryConsumerChainValidatorKeyAssignmentRequest struct { ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` ProviderValidatorAddress string `protobuf:"bytes,2,opt,name=provider_validator_address,json=providerValidatorAddress,proto3" json:"provider_validator_address,omitempty" yaml:"address"` } -func (m *QueryConsumerChainValidatorKeyMappingRequest) Reset() { - *m = QueryConsumerChainValidatorKeyMappingRequest{} +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) Reset() { + *m = QueryConsumerChainValidatorKeyAssignmentRequest{} } -func (m *QueryConsumerChainValidatorKeyMappingRequest) String() string { +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) String() string { return proto.CompactTextString(m) } -func (*QueryConsumerChainValidatorKeyMappingRequest) ProtoMessage() {} -func (*QueryConsumerChainValidatorKeyMappingRequest) Descriptor() ([]byte, []int) { +func (*QueryConsumerChainValidatorKeyAssignmentRequest) ProtoMessage() {} +func (*QueryConsumerChainValidatorKeyAssignmentRequest) Descriptor() ([]byte, []int) { return fileDescriptor_422512d7b7586cd7, []int{9} } -func (m *QueryConsumerChainValidatorKeyMappingRequest) XXX_Unmarshal(b []byte) error { +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *QueryConsumerChainValidatorKeyMappingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_QueryConsumerChainValidatorKeyMappingRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_QueryConsumerChainValidatorKeyAssignmentRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -450,38 +450,38 @@ func (m *QueryConsumerChainValidatorKeyMappingRequest) XXX_Marshal(b []byte, det return b[:n], nil } } -func (m *QueryConsumerChainValidatorKeyMappingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_QueryConsumerChainValidatorKeyMappingRequest.Merge(m, src) +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryConsumerChainValidatorKeyAssignmentRequest.Merge(m, src) } -func (m *QueryConsumerChainValidatorKeyMappingRequest) XXX_Size() int { +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) XXX_Size() int { return m.Size() } -func (m *QueryConsumerChainValidatorKeyMappingRequest) XXX_DiscardUnknown() { - xxx_messageInfo_QueryConsumerChainValidatorKeyMappingRequest.DiscardUnknown(m) +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryConsumerChainValidatorKeyAssignmentRequest.DiscardUnknown(m) } -var xxx_messageInfo_QueryConsumerChainValidatorKeyMappingRequest proto.InternalMessageInfo +var xxx_messageInfo_QueryConsumerChainValidatorKeyAssignmentRequest proto.InternalMessageInfo -type QueryConsumerChainValidatorKeyMappingResponse struct { - ConsumerValidatorPubKey *types1.Any `protobuf:"bytes,1,opt,name=consumer_validator_pub_key,json=consumerValidatorPubKey,proto3" json:"consumer_validator_pub_key,omitempty"` +type QueryConsumerChainValidatorKeyAssignmentResponse struct { + ConsumerConsensusPubKey *types1.Any `protobuf:"bytes,1,opt,name=consumer_consensus_pub_key,json=consumerConsensusPubKey,proto3" json:"consumer_consensus_pub_key,omitempty"` } -func (m *QueryConsumerChainValidatorKeyMappingResponse) Reset() { - *m = QueryConsumerChainValidatorKeyMappingResponse{} +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) Reset() { + *m = QueryConsumerChainValidatorKeyAssignmentResponse{} } -func (m *QueryConsumerChainValidatorKeyMappingResponse) String() string { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) String() string { return proto.CompactTextString(m) } -func (*QueryConsumerChainValidatorKeyMappingResponse) ProtoMessage() {} -func (*QueryConsumerChainValidatorKeyMappingResponse) Descriptor() ([]byte, []int) { +func (*QueryConsumerChainValidatorKeyAssignmentResponse) ProtoMessage() {} +func (*QueryConsumerChainValidatorKeyAssignmentResponse) Descriptor() ([]byte, []int) { return fileDescriptor_422512d7b7586cd7, []int{10} } -func (m *QueryConsumerChainValidatorKeyMappingResponse) XXX_Unmarshal(b []byte) error { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *QueryConsumerChainValidatorKeyMappingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_QueryConsumerChainValidatorKeyMappingResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_QueryConsumerChainValidatorKeyAssignmentResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -491,21 +491,21 @@ func (m *QueryConsumerChainValidatorKeyMappingResponse) XXX_Marshal(b []byte, de return b[:n], nil } } -func (m *QueryConsumerChainValidatorKeyMappingResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_QueryConsumerChainValidatorKeyMappingResponse.Merge(m, src) +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryConsumerChainValidatorKeyAssignmentResponse.Merge(m, src) } -func (m *QueryConsumerChainValidatorKeyMappingResponse) XXX_Size() int { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) XXX_Size() int { return m.Size() } -func (m *QueryConsumerChainValidatorKeyMappingResponse) XXX_DiscardUnknown() { - xxx_messageInfo_QueryConsumerChainValidatorKeyMappingResponse.DiscardUnknown(m) +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryConsumerChainValidatorKeyAssignmentResponse.DiscardUnknown(m) } -var xxx_messageInfo_QueryConsumerChainValidatorKeyMappingResponse proto.InternalMessageInfo +var xxx_messageInfo_QueryConsumerChainValidatorKeyAssignmentResponse proto.InternalMessageInfo -func (m *QueryConsumerChainValidatorKeyMappingResponse) GetConsumerValidatorPubKey() *types1.Any { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) GetConsumerConsensusPubKey() *types1.Any { if m != nil { - return m.ConsumerValidatorPubKey + return m.ConsumerConsensusPubKey } return nil } @@ -520,8 +520,8 @@ func init() { proto.RegisterType((*QueryConsumerChainStopProposalsRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsRequest") proto.RegisterType((*QueryConsumerChainStopProposalsResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsResponse") proto.RegisterType((*Chain)(nil), "interchain_security.ccv.provider.v1.Chain") - proto.RegisterType((*QueryConsumerChainValidatorKeyMappingRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainValidatorKeyMappingRequest") - proto.RegisterType((*QueryConsumerChainValidatorKeyMappingResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainValidatorKeyMappingResponse") + proto.RegisterType((*QueryConsumerChainValidatorKeyAssignmentRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainValidatorKeyAssignmentRequest") + proto.RegisterType((*QueryConsumerChainValidatorKeyAssignmentResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainValidatorKeyAssignmentResponse") } func init() { @@ -529,59 +529,59 @@ func init() { } var fileDescriptor_422512d7b7586cd7 = []byte{ - // 823 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x41, 0x4f, 0xdb, 0x48, - 0x18, 0x8d, 0xb3, 0x0b, 0x4b, 0x86, 0xdd, 0x3d, 0xcc, 0x46, 0x22, 0x18, 0x94, 0x20, 0xaf, 0x76, - 0x37, 0xbb, 0x5a, 0x6c, 0x25, 0x5c, 0x76, 0x91, 0xd8, 0x90, 0xa0, 0x5d, 0x40, 0xc0, 0x0a, 0x4c, - 0xd5, 0x43, 0x5b, 0xc9, 0x72, 0xec, 0xa9, 0xb1, 0x48, 0x3c, 0xc6, 0x33, 0xb6, 0x6a, 0xb5, 0x3d, - 0xb4, 0x87, 0x8a, 0x63, 0xa5, 0x5e, 0xab, 0x8a, 0x4b, 0xff, 0x41, 0x7f, 0x04, 0xea, 0x09, 0x89, - 0x4b, 0x4f, 0xa8, 0x0a, 0x95, 0xda, 0x73, 0xef, 0x95, 0xaa, 0xd8, 0x63, 0x93, 0x34, 0x0e, 0x24, - 0x29, 0xb7, 0xcc, 0x7c, 0xfe, 0xde, 0xf7, 0xde, 0x9b, 0xf1, 0x73, 0x80, 0x64, 0x5a, 0x14, 0x39, - 0xda, 0x9e, 0x6a, 0x5a, 0x0a, 0x41, 0x9a, 0xeb, 0x98, 0xd4, 0x97, 0x34, 0xcd, 0x93, 0x6c, 0x07, - 0x7b, 0xa6, 0x8e, 0x1c, 0xc9, 0x2b, 0x49, 0x07, 0x2e, 0x72, 0x7c, 0xd1, 0x76, 0x30, 0xc5, 0xf0, - 0xe7, 0x84, 0x06, 0x51, 0xd3, 0x3c, 0x31, 0x6a, 0x10, 0xbd, 0x12, 0x3f, 0x6b, 0x60, 0x6c, 0x34, - 0x90, 0xa4, 0xda, 0xa6, 0xa4, 0x5a, 0x16, 0xa6, 0x2a, 0x35, 0xb1, 0x45, 0x42, 0x08, 0x3e, 0x6b, - 0x60, 0x03, 0x07, 0x3f, 0xa5, 0xf6, 0x2f, 0xb6, 0x3b, 0xcd, 0x7a, 0x82, 0x55, 0xdd, 0xbd, 0x2b, - 0xa9, 0x96, 0x1f, 0x95, 0x34, 0x4c, 0x9a, 0x98, 0x28, 0x61, 0x4f, 0xb8, 0x60, 0xa5, 0x52, 0x3f, - 0xfe, 0x1a, 0xb6, 0x88, 0xdb, 0x0c, 0xf9, 0x1b, 0xc8, 0x42, 0xc4, 0x8c, 0x5a, 0xca, 0x83, 0x48, - 0x8e, 0xd5, 0x04, 0x3d, 0xc2, 0x5f, 0x60, 0x66, 0xa7, 0x6d, 0xc2, 0x0a, 0x43, 0x5d, 0x0d, 0x11, - 0x65, 0x74, 0xe0, 0x22, 0x42, 0xe1, 0x34, 0x98, 0x08, 0xf1, 0x4c, 0x3d, 0xc7, 0xcd, 0x71, 0xc5, - 0x8c, 0xfc, 0x5d, 0xb0, 0x5e, 0xd7, 0x85, 0x07, 0x60, 0x36, 0xb9, 0x93, 0xd8, 0xd8, 0x22, 0x08, - 0xde, 0x01, 0x3f, 0x30, 0x7a, 0x0a, 0xa1, 0x2a, 0x45, 0x41, 0xff, 0x64, 0xb9, 0x24, 0xf6, 0xf3, - 0x39, 0x12, 0x26, 0x7a, 0x25, 0x91, 0x81, 0xed, 0xb6, 0x1b, 0x6b, 0xdf, 0x1e, 0x9f, 0x15, 0x52, - 0xf2, 0xf7, 0x46, 0xc7, 0x9e, 0x30, 0x0b, 0xf8, 0xae, 0xe9, 0x2b, 0x6d, 0xbc, 0x88, 0xb6, 0xa0, - 0x7e, 0xa1, 0x2a, 0xaa, 0x32, 0x6a, 0x35, 0x30, 0x1e, 0xcc, 0x27, 0x39, 0x6e, 0xee, 0x9b, 0xe2, - 0x64, 0xf9, 0x0f, 0x71, 0x80, 0xb3, 0x17, 0x03, 0x10, 0x99, 0x75, 0x0a, 0xbf, 0x83, 0xdf, 0x7a, - 0x47, 0xec, 0x52, 0xd5, 0xa1, 0xdb, 0x0e, 0xb6, 0x31, 0x51, 0x1b, 0x31, 0x9b, 0x43, 0x0e, 0x14, - 0xaf, 0x7e, 0x36, 0xb6, 0x2d, 0x63, 0x47, 0x9b, 0xcc, 0xb2, 0x7f, 0x06, 0xa3, 0xc7, 0xc0, 0xab, - 0xba, 0x6e, 0xb6, 0x2f, 0xe5, 0x05, 0xf4, 0x05, 0xa0, 0x50, 0x04, 0xbf, 0x26, 0x31, 0xc1, 0x76, - 0x0f, 0xe9, 0x27, 0x5c, 0xb2, 0xc0, 0xae, 0x47, 0x19, 0xe7, 0xdb, 0xbd, 0x9c, 0x97, 0x86, 0xe2, - 0x2c, 0xa3, 0x26, 0xf6, 0xd4, 0x46, 0x22, 0xe5, 0x0a, 0x18, 0x0b, 0x46, 0x5f, 0x72, 0x17, 0xe1, - 0x0c, 0xc8, 0x68, 0x0d, 0x13, 0x59, 0xb4, 0x5d, 0x4b, 0x07, 0xb5, 0x89, 0x70, 0x63, 0x5d, 0x17, - 0x5e, 0x72, 0xe0, 0xcf, 0x5e, 0x25, 0x37, 0xd5, 0x86, 0xa9, 0xab, 0x14, 0x3b, 0x1b, 0xc8, 0xdf, - 0x52, 0x6d, 0xdb, 0xb4, 0x8c, 0xab, 0x2f, 0x3d, 0xdc, 0x06, 0x7c, 0xc4, 0x5f, 0xf1, 0x22, 0x04, - 0x45, 0xd5, 0x75, 0x07, 0x11, 0x12, 0x4e, 0xae, 0xc1, 0x8f, 0x67, 0x85, 0x1f, 0x7d, 0xb5, 0xd9, - 0x58, 0x14, 0x58, 0x41, 0x90, 0x73, 0x51, 0x57, 0x3c, 0xb6, 0x1a, 0x96, 0x16, 0x27, 0x0e, 0x8f, - 0x0a, 0xa9, 0x0f, 0x47, 0x85, 0x94, 0xf0, 0x9c, 0x03, 0xf3, 0x03, 0xf2, 0x64, 0xbe, 0xef, 0x03, - 0x3e, 0x7a, 0x69, 0x3a, 0xd8, 0xd8, 0x6e, 0x5d, 0xd9, 0x47, 0x3e, 0x3b, 0x88, 0xac, 0x18, 0xc6, - 0x8f, 0x18, 0xc5, 0x8f, 0x58, 0xb5, 0xfc, 0x5a, 0xee, 0xf5, 0xab, 0xf9, 0x2c, 0xcb, 0x1b, 0xcd, - 0xf1, 0x6d, 0x8a, 0xc5, 0x6d, 0xb7, 0xbe, 0x81, 0x7c, 0x79, 0x2a, 0x42, 0x8c, 0x07, 0x87, 0x85, - 0xf2, 0xfb, 0x0c, 0x18, 0x0b, 0xe8, 0xc1, 0x16, 0x07, 0xb2, 0x49, 0xaf, 0x3e, 0x5c, 0x1e, 0xe8, - 0xd0, 0x2f, 0xc9, 0x1b, 0xbe, 0xfa, 0x15, 0x08, 0xa1, 0x29, 0xc2, 0xbf, 0x8f, 0x4f, 0xdf, 0x3d, - 0x4b, 0x57, 0xe0, 0xd2, 0xd5, 0x5f, 0x80, 0xd8, 0x3c, 0x16, 0x2d, 0xd2, 0xfd, 0xe8, 0xdc, 0x1f, - 0xc2, 0x53, 0x0e, 0xfc, 0x94, 0x90, 0x21, 0xb0, 0x32, 0x3c, 0xc3, 0xae, 0x6c, 0xe2, 0x97, 0x47, - 0x07, 0x60, 0x0a, 0xff, 0x0e, 0x14, 0x2e, 0xc0, 0xd2, 0x10, 0x0a, 0xc3, 0xd4, 0x82, 0x8f, 0xd2, - 0x20, 0xd7, 0x27, 0x8a, 0x08, 0xdc, 0x1c, 0x91, 0x59, 0x62, 0xea, 0xf1, 0x5b, 0xd7, 0x84, 0xc6, - 0x44, 0xaf, 0x05, 0xa2, 0x6b, 0x70, 0x79, 0x58, 0xd1, 0xed, 0xaf, 0x8f, 0x43, 0x95, 0x38, 0x50, - 0xe0, 0x27, 0x0e, 0x4c, 0x25, 0x27, 0x1b, 0x81, 0x1b, 0x23, 0x93, 0xee, 0x8d, 0x50, 0x7e, 0xf3, - 0x7a, 0xc0, 0x98, 0x01, 0xab, 0x81, 0x01, 0x55, 0x58, 0x19, 0xc1, 0x00, 0x6c, 0x77, 0xe8, 0x7f, - 0x91, 0x06, 0xbf, 0x0c, 0x94, 0x33, 0x70, 0x67, 0x44, 0x01, 0xfd, 0xb3, 0x95, 0x97, 0xaf, 0x13, - 0x92, 0x39, 0xf3, 0x7f, 0xe0, 0xcc, 0x1a, 0xfc, 0x6f, 0x68, 0x67, 0x2e, 0x42, 0x73, 0x1f, 0xf9, - 0x4a, 0x33, 0xc4, 0xad, 0xdd, 0x38, 0x6e, 0xe5, 0xb9, 0x93, 0x56, 0x9e, 0x7b, 0xdb, 0xca, 0x73, - 0x4f, 0xcf, 0xf3, 0xa9, 0x93, 0xf3, 0x7c, 0xea, 0xcd, 0x79, 0x3e, 0x75, 0x6b, 0xd1, 0x30, 0xe9, - 0x9e, 0x5b, 0x17, 0x35, 0xdc, 0x64, 0xff, 0xd6, 0x3a, 0x46, 0xce, 0xc7, 0x23, 0xef, 0x75, 0x0f, - 0xa5, 0xbe, 0x8d, 0x48, 0x7d, 0x3c, 0x08, 0xe0, 0x85, 0xcf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1f, - 0xff, 0x48, 0x67, 0x99, 0x0a, 0x00, 0x00, + // 828 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x41, 0x6f, 0xd3, 0x48, + 0x18, 0x8d, 0xb3, 0xdb, 0x6e, 0x33, 0xdd, 0xdd, 0xc3, 0x6c, 0xa4, 0xa6, 0x6e, 0x95, 0x54, 0x5e, + 0x69, 0x37, 0x20, 0xd5, 0x26, 0xe9, 0x05, 0x2a, 0x95, 0x34, 0xa9, 0x50, 0xa9, 0x52, 0xa4, 0x36, + 0x2d, 0x1c, 0x00, 0xc9, 0x72, 0xec, 0xc1, 0xb5, 0x9a, 0x78, 0x5c, 0xcf, 0xd8, 0xc2, 0x02, 0x0e, + 0x70, 0x40, 0x3d, 0x22, 0xf1, 0x03, 0xe8, 0x11, 0x71, 0xe6, 0x47, 0x54, 0x9c, 0x2a, 0xf5, 0xc2, + 0xa9, 0x42, 0x29, 0x07, 0xce, 0x70, 0x46, 0x42, 0xb6, 0xc7, 0x6e, 0x43, 0xdc, 0x36, 0x09, 0xbd, + 0xd9, 0xf3, 0xf9, 0x7b, 0xdf, 0x7b, 0x6f, 0x26, 0x6f, 0x02, 0x24, 0xc3, 0xa4, 0xc8, 0x56, 0xb7, + 0x14, 0xc3, 0x94, 0x09, 0x52, 0x1d, 0xdb, 0xa0, 0x9e, 0xa4, 0xaa, 0xae, 0x64, 0xd9, 0xd8, 0x35, + 0x34, 0x64, 0x4b, 0x6e, 0x49, 0xda, 0x71, 0x90, 0xed, 0x89, 0x96, 0x8d, 0x29, 0x86, 0xff, 0x26, + 0x34, 0x88, 0xaa, 0xea, 0x8a, 0x51, 0x83, 0xe8, 0x96, 0xf8, 0x69, 0x1d, 0x63, 0xbd, 0x85, 0x24, + 0xc5, 0x32, 0x24, 0xc5, 0x34, 0x31, 0x55, 0xa8, 0x81, 0x4d, 0x12, 0x42, 0xf0, 0x59, 0x1d, 0xeb, + 0x38, 0x78, 0x94, 0xfc, 0x27, 0xb6, 0x3a, 0xc9, 0x7a, 0x82, 0xb7, 0xa6, 0xf3, 0x48, 0x52, 0x4c, + 0x2f, 0x2a, 0xa9, 0x98, 0xb4, 0x31, 0x91, 0xc3, 0x9e, 0xf0, 0x85, 0x95, 0x4a, 0x67, 0xf1, 0x57, + 0xb1, 0x49, 0x9c, 0x76, 0xc8, 0x5f, 0x47, 0x26, 0x22, 0x46, 0xd4, 0x52, 0xee, 0x47, 0x72, 0xac, + 0x26, 0xe8, 0x11, 0xae, 0x83, 0xa9, 0x75, 0xdf, 0x84, 0x25, 0x86, 0xba, 0x1c, 0x22, 0x36, 0xd0, + 0x8e, 0x83, 0x08, 0x85, 0x93, 0x60, 0x2c, 0xc4, 0x33, 0xb4, 0x1c, 0x37, 0xc3, 0x15, 0x33, 0x8d, + 0x3f, 0x82, 0xf7, 0x15, 0x4d, 0x78, 0x0a, 0xa6, 0x93, 0x3b, 0x89, 0x85, 0x4d, 0x82, 0xe0, 0x43, + 0xf0, 0x17, 0xa3, 0x27, 0x13, 0xaa, 0x50, 0x14, 0xf4, 0x8f, 0x97, 0x4b, 0xe2, 0x59, 0x3e, 0x47, + 0xc2, 0x44, 0xb7, 0x24, 0x32, 0xb0, 0x0d, 0xbf, 0xb1, 0xf6, 0xfb, 0xfe, 0x51, 0x21, 0xd5, 0xf8, + 0x53, 0x3f, 0xb5, 0x26, 0x4c, 0x03, 0xbe, 0x6b, 0xfa, 0x92, 0x8f, 0x17, 0xd1, 0x16, 0x94, 0x9f, + 0x54, 0x45, 0x55, 0x46, 0xad, 0x06, 0x46, 0x83, 0xf9, 0x24, 0xc7, 0xcd, 0xfc, 0x56, 0x1c, 0x2f, + 0x5f, 0x15, 0xfb, 0xd8, 0x7b, 0x31, 0x00, 0x69, 0xb0, 0x4e, 0xe1, 0x0a, 0xf8, 0xbf, 0x77, 0xc4, + 0x06, 0x55, 0x6c, 0xba, 0x66, 0x63, 0x0b, 0x13, 0xa5, 0x15, 0xb3, 0xd9, 0xe5, 0x40, 0xf1, 0xe2, + 0x6f, 0x63, 0xdb, 0x32, 0x56, 0xb4, 0xc8, 0x2c, 0xbb, 0xd9, 0x1f, 0x3d, 0x06, 0x5e, 0xd5, 0x34, + 0xc3, 0x3f, 0x94, 0x27, 0xd0, 0x27, 0x80, 0x42, 0x11, 0xfc, 0x97, 0xc4, 0x04, 0x5b, 0x3d, 0xa4, + 0x5f, 0x72, 0xc9, 0x02, 0xbb, 0x3e, 0x65, 0x9c, 0x1f, 0xf4, 0x72, 0x5e, 0x18, 0x88, 0x73, 0x03, + 0xb5, 0xb1, 0xab, 0xb4, 0x12, 0x29, 0x57, 0xc0, 0x48, 0x30, 0xfa, 0x9c, 0xb3, 0x08, 0xa7, 0x40, + 0x46, 0x6d, 0x19, 0xc8, 0xa4, 0x7e, 0x2d, 0x1d, 0xd4, 0xc6, 0xc2, 0x85, 0x15, 0x4d, 0x78, 0xcb, + 0x01, 0xa9, 0x57, 0xc9, 0x3d, 0xa5, 0x65, 0x68, 0x0a, 0xc5, 0x76, 0x1d, 0x79, 0x55, 0x42, 0x0c, + 0xdd, 0x6c, 0x23, 0x93, 0x5e, 0x7c, 0xee, 0xe1, 0x1a, 0xe0, 0x23, 0x09, 0xb2, 0x1b, 0x81, 0xc8, + 0x8a, 0xa6, 0xd9, 0x88, 0x90, 0x70, 0x78, 0x0d, 0x7e, 0x3d, 0x2a, 0xfc, 0xed, 0x29, 0xed, 0xd6, + 0xbc, 0xc0, 0x0a, 0x42, 0x23, 0x17, 0x75, 0xc5, 0x93, 0xab, 0x61, 0x69, 0x7e, 0x6c, 0x77, 0xaf, + 0x90, 0xfa, 0xb2, 0x57, 0x48, 0x09, 0x6f, 0x38, 0x70, 0xad, 0x7f, 0xaa, 0xcc, 0xfd, 0x6d, 0xc0, + 0x47, 0x3f, 0x1d, 0xd9, 0x7f, 0x40, 0x26, 0x71, 0x88, 0x6c, 0x39, 0x4d, 0x79, 0x1b, 0x79, 0x6c, + 0x3b, 0xb2, 0x62, 0x18, 0x42, 0x62, 0x14, 0x42, 0x62, 0xd5, 0xf4, 0x6a, 0xb9, 0x0f, 0xef, 0x67, + 0xb3, 0x2c, 0x75, 0x54, 0xdb, 0xb3, 0x28, 0x16, 0xd7, 0x9c, 0x66, 0x1d, 0x79, 0x8d, 0x89, 0x08, + 0x71, 0x29, 0x02, 0x0c, 0x0b, 0xe5, 0x6f, 0x19, 0x30, 0x12, 0x30, 0x84, 0x1d, 0x0e, 0x64, 0x93, + 0x02, 0x00, 0x2e, 0xf6, 0xb5, 0xf5, 0xe7, 0xa4, 0x0e, 0x5f, 0xfd, 0x05, 0x84, 0xd0, 0x14, 0xe1, + 0xd6, 0x8b, 0xc3, 0xcf, 0xaf, 0xd3, 0x15, 0xb8, 0x70, 0xf1, 0x3d, 0x10, 0x9b, 0xc7, 0x02, 0x46, + 0x7a, 0x12, 0x6d, 0xfd, 0x33, 0x78, 0xc8, 0x81, 0x7f, 0x12, 0x92, 0x04, 0x56, 0x06, 0x67, 0xd8, + 0x95, 0x50, 0xfc, 0xe2, 0xf0, 0x00, 0x4c, 0xe1, 0x8d, 0x40, 0xe1, 0x1c, 0x2c, 0x0d, 0xa0, 0x30, + 0xcc, 0x2e, 0xf8, 0x3c, 0x0d, 0x72, 0x67, 0x04, 0x12, 0x81, 0xab, 0x43, 0x32, 0x4b, 0xcc, 0x3e, + 0xfe, 0xce, 0x25, 0xa1, 0x31, 0xd1, 0xb7, 0x03, 0xd1, 0x35, 0xb8, 0x38, 0xa8, 0x68, 0xff, 0x0e, + 0xb2, 0xa9, 0x1c, 0xc7, 0x0a, 0xfc, 0xce, 0x81, 0x89, 0xe4, 0x7c, 0x23, 0xb0, 0x3e, 0x34, 0xe9, + 0xde, 0x20, 0xe5, 0x57, 0x2f, 0x07, 0x8c, 0x19, 0xb0, 0x1c, 0x18, 0x50, 0x85, 0x95, 0x21, 0x0c, + 0xc0, 0xd6, 0x29, 0xfd, 0xef, 0xd2, 0x49, 0x97, 0x52, 0x72, 0xd4, 0xc0, 0xcd, 0x21, 0x35, 0x9c, + 0x1b, 0xb2, 0xfc, 0xdd, 0x4b, 0x46, 0x65, 0x16, 0xad, 0x07, 0x16, 0xd5, 0xe1, 0xca, 0xc0, 0x16, + 0x9d, 0xc4, 0xf9, 0x36, 0xf2, 0x64, 0x25, 0x86, 0xae, 0x6d, 0xee, 0x77, 0xf2, 0xdc, 0x41, 0x27, + 0xcf, 0x7d, 0xea, 0xe4, 0xb9, 0x57, 0xc7, 0xf9, 0xd4, 0xc1, 0x71, 0x3e, 0xf5, 0xf1, 0x38, 0x9f, + 0xba, 0x3f, 0xaf, 0x1b, 0x74, 0xcb, 0x69, 0x8a, 0x2a, 0x6e, 0xb3, 0xff, 0x6f, 0xa7, 0xa6, 0xce, + 0xc6, 0x53, 0x1f, 0x77, 0xcf, 0xa5, 0x9e, 0x85, 0x48, 0x73, 0x34, 0x08, 0xe3, 0xb9, 0x1f, 0x01, + 0x00, 0x00, 0xff, 0xff, 0xdb, 0x11, 0x59, 0x3f, 0xab, 0x0a, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -607,7 +607,7 @@ type QueryClient interface { // QueryConsumerChainStops queries consumer chain stop proposals. QueryConsumerChainStops(ctx context.Context, in *QueryConsumerChainStopProposalsRequest, opts ...grpc.CallOption) (*QueryConsumerChainStopProposalsResponse, error) // TODO: - QueryConsumerChainValidatorKeyMapping(ctx context.Context, in *QueryConsumerChainValidatorKeyMappingRequest, opts ...grpc.CallOption) (*QueryConsumerChainValidatorKeyMappingResponse, error) + QueryConsumerChainValidatorKeyAssignment(ctx context.Context, in *QueryConsumerChainValidatorKeyAssignmentRequest, opts ...grpc.CallOption) (*QueryConsumerChainValidatorKeyAssignmentResponse, error) } type queryClient struct { @@ -654,9 +654,9 @@ func (c *queryClient) QueryConsumerChainStops(ctx context.Context, in *QueryCons return out, nil } -func (c *queryClient) QueryConsumerChainValidatorKeyMapping(ctx context.Context, in *QueryConsumerChainValidatorKeyMappingRequest, opts ...grpc.CallOption) (*QueryConsumerChainValidatorKeyMappingResponse, error) { - out := new(QueryConsumerChainValidatorKeyMappingResponse) - err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainValidatorKeyMapping", in, out, opts...) +func (c *queryClient) QueryConsumerChainValidatorKeyAssignment(ctx context.Context, in *QueryConsumerChainValidatorKeyAssignmentRequest, opts ...grpc.CallOption) (*QueryConsumerChainValidatorKeyAssignmentResponse, error) { + out := new(QueryConsumerChainValidatorKeyAssignmentResponse) + err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainValidatorKeyAssignment", in, out, opts...) if err != nil { return nil, err } @@ -676,7 +676,7 @@ type QueryServer interface { // QueryConsumerChainStops queries consumer chain stop proposals. QueryConsumerChainStops(context.Context, *QueryConsumerChainStopProposalsRequest) (*QueryConsumerChainStopProposalsResponse, error) // TODO: - QueryConsumerChainValidatorKeyMapping(context.Context, *QueryConsumerChainValidatorKeyMappingRequest) (*QueryConsumerChainValidatorKeyMappingResponse, error) + QueryConsumerChainValidatorKeyAssignment(context.Context, *QueryConsumerChainValidatorKeyAssignmentRequest) (*QueryConsumerChainValidatorKeyAssignmentResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -695,8 +695,8 @@ func (*UnimplementedQueryServer) QueryConsumerChainStarts(ctx context.Context, r func (*UnimplementedQueryServer) QueryConsumerChainStops(ctx context.Context, req *QueryConsumerChainStopProposalsRequest) (*QueryConsumerChainStopProposalsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerChainStops not implemented") } -func (*UnimplementedQueryServer) QueryConsumerChainValidatorKeyMapping(ctx context.Context, req *QueryConsumerChainValidatorKeyMappingRequest) (*QueryConsumerChainValidatorKeyMappingResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerChainValidatorKeyMapping not implemented") +func (*UnimplementedQueryServer) QueryConsumerChainValidatorKeyAssignment(ctx context.Context, req *QueryConsumerChainValidatorKeyAssignmentRequest) (*QueryConsumerChainValidatorKeyAssignmentResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerChainValidatorKeyAssignment not implemented") } func RegisterQueryServer(s grpc1.Server, srv QueryServer) { @@ -775,20 +775,20 @@ func _Query_QueryConsumerChainStops_Handler(srv interface{}, ctx context.Context return interceptor(ctx, in, info, handler) } -func _Query_QueryConsumerChainValidatorKeyMapping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(QueryConsumerChainValidatorKeyMappingRequest) +func _Query_QueryConsumerChainValidatorKeyAssignment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryConsumerChainValidatorKeyAssignmentRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).QueryConsumerChainValidatorKeyMapping(ctx, in) + return srv.(QueryServer).QueryConsumerChainValidatorKeyAssignment(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainValidatorKeyMapping", + FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainValidatorKeyAssignment", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).QueryConsumerChainValidatorKeyMapping(ctx, req.(*QueryConsumerChainValidatorKeyMappingRequest)) + return srv.(QueryServer).QueryConsumerChainValidatorKeyAssignment(ctx, req.(*QueryConsumerChainValidatorKeyAssignmentRequest)) } return interceptor(ctx, in, info, handler) } @@ -814,8 +814,8 @@ var _Query_serviceDesc = grpc.ServiceDesc{ Handler: _Query_QueryConsumerChainStops_Handler, }, { - MethodName: "QueryConsumerChainValidatorKeyMapping", - Handler: _Query_QueryConsumerChainValidatorKeyMapping_Handler, + MethodName: "QueryConsumerChainValidatorKeyAssignment", + Handler: _Query_QueryConsumerChainValidatorKeyAssignment_Handler, }, }, Streams: []grpc.StreamDesc{}, @@ -1098,7 +1098,7 @@ func (m *Chain) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *QueryConsumerChainValidatorKeyMappingRequest) Marshal() (dAtA []byte, err error) { +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1108,12 +1108,12 @@ func (m *QueryConsumerChainValidatorKeyMappingRequest) Marshal() (dAtA []byte, e return dAtA[:n], nil } -func (m *QueryConsumerChainValidatorKeyMappingRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QueryConsumerChainValidatorKeyMappingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -1135,7 +1135,7 @@ func (m *QueryConsumerChainValidatorKeyMappingRequest) MarshalToSizedBuffer(dAtA return len(dAtA) - i, nil } -func (m *QueryConsumerChainValidatorKeyMappingResponse) Marshal() (dAtA []byte, err error) { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1145,19 +1145,19 @@ func (m *QueryConsumerChainValidatorKeyMappingResponse) Marshal() (dAtA []byte, return dAtA[:n], nil } -func (m *QueryConsumerChainValidatorKeyMappingResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QueryConsumerChainValidatorKeyMappingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.ConsumerValidatorPubKey != nil { + if m.ConsumerConsensusPubKey != nil { { - size, err := m.ConsumerValidatorPubKey.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ConsumerConsensusPubKey.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1290,7 +1290,7 @@ func (m *Chain) Size() (n int) { return n } -func (m *QueryConsumerChainValidatorKeyMappingRequest) Size() (n int) { +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) Size() (n int) { if m == nil { return 0 } @@ -1307,14 +1307,14 @@ func (m *QueryConsumerChainValidatorKeyMappingRequest) Size() (n int) { return n } -func (m *QueryConsumerChainValidatorKeyMappingResponse) Size() (n int) { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.ConsumerValidatorPubKey != nil { - l = m.ConsumerValidatorPubKey.Size() + if m.ConsumerConsensusPubKey != nil { + l = m.ConsumerConsensusPubKey.Size() n += 1 + l + sovQuery(uint64(l)) } return n @@ -2011,7 +2011,7 @@ func (m *Chain) Unmarshal(dAtA []byte) error { } return nil } -func (m *QueryConsumerChainValidatorKeyMappingRequest) Unmarshal(dAtA []byte) error { +func (m *QueryConsumerChainValidatorKeyAssignmentRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2034,10 +2034,10 @@ func (m *QueryConsumerChainValidatorKeyMappingRequest) Unmarshal(dAtA []byte) er fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: QueryConsumerChainValidatorKeyMappingRequest: wiretype end group for non-group") + return fmt.Errorf("proto: QueryConsumerChainValidatorKeyAssignmentRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: QueryConsumerChainValidatorKeyMappingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: QueryConsumerChainValidatorKeyAssignmentRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -2125,7 +2125,7 @@ func (m *QueryConsumerChainValidatorKeyMappingRequest) Unmarshal(dAtA []byte) er } return nil } -func (m *QueryConsumerChainValidatorKeyMappingResponse) Unmarshal(dAtA []byte) error { +func (m *QueryConsumerChainValidatorKeyAssignmentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2148,15 +2148,15 @@ func (m *QueryConsumerChainValidatorKeyMappingResponse) Unmarshal(dAtA []byte) e fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: QueryConsumerChainValidatorKeyMappingResponse: wiretype end group for non-group") + return fmt.Errorf("proto: QueryConsumerChainValidatorKeyAssignmentResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: QueryConsumerChainValidatorKeyMappingResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: QueryConsumerChainValidatorKeyAssignmentResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConsumerValidatorPubKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConsumerConsensusPubKey", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -2183,10 +2183,10 @@ func (m *QueryConsumerChainValidatorKeyMappingResponse) Unmarshal(dAtA []byte) e if postIndex > l { return io.ErrUnexpectedEOF } - if m.ConsumerValidatorPubKey == nil { - m.ConsumerValidatorPubKey = &types1.Any{} + if m.ConsumerConsensusPubKey == nil { + m.ConsumerConsensusPubKey = &types1.Any{} } - if err := m.ConsumerValidatorPubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConsumerConsensusPubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/x/ccv/provider/types/query.pb.gw.go b/x/ccv/provider/types/query.pb.gw.go index 4b40aa0951..e30f59e1f0 100644 --- a/x/ccv/provider/types/query.pb.gw.go +++ b/x/ccv/provider/types/query.pb.gw.go @@ -142,37 +142,37 @@ func local_request_Query_QueryConsumerChainStops_0(ctx context.Context, marshale } var ( - filter_Query_QueryConsumerChainValidatorKeyAssignmentping_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + filter_Query_QueryConsumerChainValidatorKeyAssignment_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} ) -func request_Query_QueryConsumerChainValidatorKeyAssignmentping_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryConsumerChainValidatorKeyAssignmentpingRequest +func request_Query_QueryConsumerChainValidatorKeyAssignment_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryConsumerChainValidatorKeyAssignmentRequest 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_QueryConsumerChainValidatorKeyAssignmentping_0); err != nil { + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QueryConsumerChainValidatorKeyAssignment_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.QueryConsumerChainValidatorKeyAssignmentping(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.QueryConsumerChainValidatorKeyAssignment(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_QueryConsumerChainValidatorKeyAssignmentping_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryConsumerChainValidatorKeyAssignmentpingRequest +func local_request_Query_QueryConsumerChainValidatorKeyAssignment_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryConsumerChainValidatorKeyAssignmentRequest 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_QueryConsumerChainValidatorKeyAssignmentping_0); err != nil { + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QueryConsumerChainValidatorKeyAssignment_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.QueryConsumerChainValidatorKeyAssignmentping(ctx, &protoReq) + msg, err := server.QueryConsumerChainValidatorKeyAssignment(ctx, &protoReq) return msg, metadata, err } @@ -275,7 +275,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) - mux.Handle("GET", pattern_Query_QueryConsumerChainValidatorKeyAssignmentping_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryConsumerChainValidatorKeyAssignment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream @@ -286,7 +286,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_QueryConsumerChainValidatorKeyAssignmentping_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QueryConsumerChainValidatorKeyAssignment_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 { @@ -294,7 +294,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } - forward_Query_QueryConsumerChainValidatorKeyAssignmentping_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryConsumerChainValidatorKeyAssignment_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -419,7 +419,7 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) - mux.Handle("GET", pattern_Query_QueryConsumerChainValidatorKeyAssignmentping_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryConsumerChainValidatorKeyAssignment_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) @@ -428,14 +428,14 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_QueryConsumerChainValidatorKeyAssignmentping_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QueryConsumerChainValidatorKeyAssignment_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_QueryConsumerChainValidatorKeyAssignmentping_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryConsumerChainValidatorKeyAssignment_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -451,7 +451,7 @@ var ( pattern_Query_QueryConsumerChainStops_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"interchain_security", "ccv", "provider", "consumer_chain_stop_proposals"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_QueryConsumerChainValidatorKeyAssignmentping_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"interchain_security", "ccv", "provider", "consumer_chain_validator_key_mapping"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_QueryConsumerChainValidatorKeyAssignment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"interchain_security", "ccv", "provider", "consumer_chain_validator_key_assignment"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( @@ -463,5 +463,5 @@ var ( forward_Query_QueryConsumerChainStops_0 = runtime.ForwardResponseMessage - forward_Query_QueryConsumerChainValidatorKeyAssignmentping_0 = runtime.ForwardResponseMessage + forward_Query_QueryConsumerChainValidatorKeyAssignment_0 = runtime.ForwardResponseMessage ) diff --git a/x/ccv/provider/types/tx.pb.go b/x/ccv/provider/types/tx.pb.go index ad77ed91b2..a81719823f 100644 --- a/x/ccv/provider/types/tx.pb.go +++ b/x/ccv/provider/types/tx.pb.go @@ -32,26 +32,28 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package -type MsgDesignateConsensusKeyForConsumerChain struct { +type MsgAssignConsensusPublicKeyToConsumerChain struct { ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` ProviderValidatorAddress string `protobuf:"bytes,2,opt,name=provider_validator_address,json=providerValidatorAddress,proto3" json:"provider_validator_address,omitempty" yaml:"address"` - ConsumerValidatorPubKey *types.Any `protobuf:"bytes,3,opt,name=consumer_validator_pub_key,json=consumerValidatorPubKey,proto3" json:"consumer_validator_pub_key,omitempty"` + ConsumerConsensusPubKey *types.Any `protobuf:"bytes,3,opt,name=consumer_consensus_pub_key,json=consumerConsensusPubKey,proto3" json:"consumer_consensus_pub_key,omitempty"` } -func (m *MsgDesignateConsensusKeyForConsumerChain) Reset() { - *m = MsgDesignateConsensusKeyForConsumerChain{} +func (m *MsgAssignConsensusPublicKeyToConsumerChain) Reset() { + *m = MsgAssignConsensusPublicKeyToConsumerChain{} } -func (m *MsgDesignateConsensusKeyForConsumerChain) String() string { return proto.CompactTextString(m) } -func (*MsgDesignateConsensusKeyForConsumerChain) ProtoMessage() {} -func (*MsgDesignateConsensusKeyForConsumerChain) Descriptor() ([]byte, []int) { +func (m *MsgAssignConsensusPublicKeyToConsumerChain) String() string { + return proto.CompactTextString(m) +} +func (*MsgAssignConsensusPublicKeyToConsumerChain) ProtoMessage() {} +func (*MsgAssignConsensusPublicKeyToConsumerChain) Descriptor() ([]byte, []int) { return fileDescriptor_43221a4391e9fbf4, []int{0} } -func (m *MsgDesignateConsensusKeyForConsumerChain) XXX_Unmarshal(b []byte) error { +func (m *MsgAssignConsensusPublicKeyToConsumerChain) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *MsgDesignateConsensusKeyForConsumerChain) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MsgAssignConsensusPublicKeyToConsumerChain) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_MsgDesignateConsensusKeyForConsumerChain.Marshal(b, m, deterministic) + return xxx_messageInfo_MsgAssignConsensusPublicKeyToConsumerChain.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -61,37 +63,37 @@ func (m *MsgDesignateConsensusKeyForConsumerChain) XXX_Marshal(b []byte, determi return b[:n], nil } } -func (m *MsgDesignateConsensusKeyForConsumerChain) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgDesignateConsensusKeyForConsumerChain.Merge(m, src) +func (m *MsgAssignConsensusPublicKeyToConsumerChain) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgAssignConsensusPublicKeyToConsumerChain.Merge(m, src) } -func (m *MsgDesignateConsensusKeyForConsumerChain) XXX_Size() int { +func (m *MsgAssignConsensusPublicKeyToConsumerChain) XXX_Size() int { return m.Size() } -func (m *MsgDesignateConsensusKeyForConsumerChain) XXX_DiscardUnknown() { - xxx_messageInfo_MsgDesignateConsensusKeyForConsumerChain.DiscardUnknown(m) +func (m *MsgAssignConsensusPublicKeyToConsumerChain) XXX_DiscardUnknown() { + xxx_messageInfo_MsgAssignConsensusPublicKeyToConsumerChain.DiscardUnknown(m) } -var xxx_messageInfo_MsgDesignateConsensusKeyForConsumerChain proto.InternalMessageInfo +var xxx_messageInfo_MsgAssignConsensusPublicKeyToConsumerChain proto.InternalMessageInfo -type MsgDesignateConsensusKeyForConsumerChainResponse struct { +type MsgAssignConsensusPublicKeyToConsumerChainResponse struct { } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) Reset() { - *m = MsgDesignateConsensusKeyForConsumerChainResponse{} +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) Reset() { + *m = MsgAssignConsensusPublicKeyToConsumerChainResponse{} } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) String() string { +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) String() string { return proto.CompactTextString(m) } -func (*MsgDesignateConsensusKeyForConsumerChainResponse) ProtoMessage() {} -func (*MsgDesignateConsensusKeyForConsumerChainResponse) Descriptor() ([]byte, []int) { +func (*MsgAssignConsensusPublicKeyToConsumerChainResponse) ProtoMessage() {} +func (*MsgAssignConsensusPublicKeyToConsumerChainResponse) Descriptor() ([]byte, []int) { return fileDescriptor_43221a4391e9fbf4, []int{1} } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) XXX_Unmarshal(b []byte) error { +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_MsgDesignateConsensusKeyForConsumerChainResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_MsgAssignConsensusPublicKeyToConsumerChainResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -101,21 +103,21 @@ func (m *MsgDesignateConsensusKeyForConsumerChainResponse) XXX_Marshal(b []byte, return b[:n], nil } } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgDesignateConsensusKeyForConsumerChainResponse.Merge(m, src) +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgAssignConsensusPublicKeyToConsumerChainResponse.Merge(m, src) } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) XXX_Size() int { +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) XXX_Size() int { return m.Size() } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgDesignateConsensusKeyForConsumerChainResponse.DiscardUnknown(m) +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgAssignConsensusPublicKeyToConsumerChainResponse.DiscardUnknown(m) } -var xxx_messageInfo_MsgDesignateConsensusKeyForConsumerChainResponse proto.InternalMessageInfo +var xxx_messageInfo_MsgAssignConsensusPublicKeyToConsumerChainResponse proto.InternalMessageInfo func init() { - proto.RegisterType((*MsgDesignateConsensusKeyForConsumerChain)(nil), "interchain_security.ccv.provider.v1.MsgDesignateConsensusKeyForConsumerChain") - proto.RegisterType((*MsgDesignateConsensusKeyForConsumerChainResponse)(nil), "interchain_security.ccv.provider.v1.MsgDesignateConsensusKeyForConsumerChainResponse") + proto.RegisterType((*MsgAssignConsensusPublicKeyToConsumerChain)(nil), "interchain_security.ccv.provider.v1.MsgAssignConsensusPublicKeyToConsumerChain") + proto.RegisterType((*MsgAssignConsensusPublicKeyToConsumerChainResponse)(nil), "interchain_security.ccv.provider.v1.MsgAssignConsensusPublicKeyToConsumerChainResponse") } func init() { @@ -123,35 +125,36 @@ func init() { } var fileDescriptor_43221a4391e9fbf4 = []byte{ - // 446 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x52, 0x41, 0x6b, 0xd4, 0x40, - 0x14, 0x4e, 0x5a, 0xd0, 0x1a, 0xc1, 0x43, 0x58, 0x30, 0x0d, 0x92, 0x2d, 0x2b, 0xc2, 0x1e, 0xec, - 0x4c, 0xbb, 0xde, 0xf6, 0xd6, 0xad, 0x08, 0x52, 0x16, 0xca, 0xa2, 0x1e, 0xbc, 0x84, 0xc9, 0x64, - 0x4c, 0x87, 0xdd, 0xcc, 0x0b, 0x33, 0x93, 0xd0, 0xf9, 0x07, 0x9e, 0xc4, 0x9f, 0xd0, 0x1f, 0xe1, - 0x8f, 0x10, 0x41, 0xe8, 0x45, 0xf0, 0x24, 0xb2, 0x7b, 0xf1, 0xec, 0x2f, 0x90, 0xec, 0x64, 0xaa, - 0x82, 0x87, 0x1c, 0xbc, 0xcd, 0x97, 0xef, 0xbd, 0xef, 0x7d, 0xef, 0xe5, 0x0b, 0x1e, 0x73, 0xa1, - 0x99, 0xa4, 0x17, 0x84, 0x8b, 0x54, 0x31, 0x5a, 0x4b, 0xae, 0x0d, 0xa6, 0xb4, 0xc1, 0x95, 0x84, - 0x86, 0xe7, 0x4c, 0xe2, 0xe6, 0x18, 0xeb, 0x4b, 0x54, 0x49, 0xd0, 0x10, 0x3e, 0xfc, 0x47, 0x35, - 0xa2, 0xb4, 0x41, 0xae, 0x1a, 0x35, 0xc7, 0xf1, 0x83, 0x02, 0xa0, 0x58, 0x31, 0x4c, 0x2a, 0x8e, - 0x89, 0x10, 0xa0, 0x89, 0xe6, 0x20, 0x94, 0x95, 0x88, 0x07, 0x05, 0x14, 0xb0, 0x7d, 0xe2, 0xf6, - 0xd5, 0x7d, 0x3d, 0xea, 0x63, 0x63, 0xc9, 0x4c, 0x49, 0xaa, 0xae, 0x63, 0x9f, 0x82, 0x2a, 0x41, - 0xa5, 0x56, 0xca, 0x02, 0x47, 0x75, 0x06, 0xb6, 0x28, 0xab, 0xdf, 0x60, 0x22, 0x8c, 0xa5, 0x46, - 0xef, 0x76, 0x82, 0xf1, 0x5c, 0x15, 0x4f, 0x99, 0xe2, 0x85, 0x20, 0x9a, 0x9d, 0x82, 0x50, 0x4c, - 0xa8, 0x5a, 0x9d, 0x31, 0xf3, 0x0c, 0x64, 0x0b, 0xeb, 0x92, 0xc9, 0xd3, 0xd6, 0x48, 0xb8, 0x1f, - 0xec, 0x59, 0x47, 0x3c, 0x8f, 0xfc, 0x03, 0x7f, 0x7c, 0x67, 0x71, 0x7b, 0x8b, 0x9f, 0xe7, 0xe1, - 0x79, 0x10, 0x3b, 0x67, 0x69, 0x43, 0x56, 0x3c, 0x27, 0x1a, 0x64, 0x4a, 0xf2, 0x5c, 0x32, 0xa5, - 0xa2, 0x9d, 0xb6, 0x78, 0x16, 0xfe, 0xfc, 0x36, 0xbc, 0x67, 0x48, 0xb9, 0x9a, 0x8e, 0x3a, 0x62, - 0xb4, 0x88, 0x5c, 0xd7, 0x2b, 0xd7, 0x74, 0x62, 0xa9, 0x70, 0x19, 0xc4, 0xb4, 0x9b, 0xfe, 0x87, - 0x62, 0x55, 0x67, 0xe9, 0x92, 0x99, 0x68, 0xf7, 0xc0, 0x1f, 0xdf, 0x9d, 0x0c, 0x90, 0xdd, 0x0c, - 0xb9, 0xcd, 0xd0, 0x89, 0x30, 0xb3, 0xe8, 0xd3, 0x87, 0xc3, 0x41, 0x77, 0x00, 0x2a, 0x4d, 0xa5, - 0x01, 0x9d, 0xd7, 0xd9, 0x19, 0x33, 0x8b, 0xfb, 0x4e, 0xf1, 0x66, 0x9a, 0x25, 0xa6, 0x7b, 0x6f, - 0xaf, 0x86, 0xde, 0x8f, 0xab, 0xa1, 0x37, 0x9a, 0x04, 0x47, 0x7d, 0xef, 0xb1, 0x60, 0xaa, 0x6a, - 0xe9, 0xc9, 0x17, 0x3f, 0xd8, 0x9d, 0xab, 0x22, 0xfc, 0xec, 0x07, 0x8f, 0xfa, 0x5d, 0x72, 0x8e, - 0x7a, 0x04, 0x07, 0xf5, 0x35, 0x12, 0xbf, 0xfc, 0xaf, 0x72, 0x6e, 0xaf, 0xd9, 0x8b, 0x8f, 0xeb, - 0xc4, 0xbf, 0x5e, 0x27, 0xfe, 0xf7, 0x75, 0xe2, 0xbf, 0xdf, 0x24, 0xde, 0xf5, 0x26, 0xf1, 0xbe, - 0x6e, 0x12, 0xef, 0xf5, 0xb4, 0xe0, 0xfa, 0xa2, 0xce, 0x10, 0x85, 0xb2, 0x8b, 0x1a, 0xfe, 0xed, - 0xe0, 0xf0, 0x26, 0xb0, 0x97, 0x7f, 0x47, 0x56, 0x9b, 0x8a, 0xa9, 0xec, 0xd6, 0xf6, 0x67, 0x3d, - 0xf9, 0x15, 0x00, 0x00, 0xff, 0xff, 0x19, 0xf0, 0x0f, 0x0f, 0x6a, 0x03, 0x00, 0x00, + // 454 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x92, 0x4d, 0x6b, 0xd4, 0x40, + 0x18, 0xc7, 0x93, 0x16, 0xb4, 0x46, 0xf0, 0x10, 0x16, 0x4c, 0x83, 0x64, 0xcb, 0x7a, 0xb0, 0x88, + 0x9d, 0xa1, 0xab, 0x20, 0xec, 0x6d, 0xb7, 0x27, 0x59, 0x8a, 0xcb, 0x52, 0x14, 0xbc, 0x84, 0xc9, + 0x64, 0x4c, 0x87, 0xdd, 0xcc, 0x13, 0x66, 0x26, 0xa1, 0xf3, 0x0d, 0x3c, 0xf6, 0x23, 0xf4, 0x43, + 0xf8, 0x21, 0xc4, 0xd3, 0x82, 0x17, 0x41, 0x10, 0xd9, 0xbd, 0x78, 0xf6, 0x13, 0x48, 0x5e, 0xc6, + 0x17, 0xf0, 0x90, 0x83, 0xb7, 0x79, 0xde, 0xfe, 0xf9, 0x3d, 0x4f, 0xfe, 0xde, 0x13, 0x2e, 0x34, + 0x93, 0xf4, 0x92, 0x70, 0x11, 0x2b, 0x46, 0x4b, 0xc9, 0xb5, 0xc1, 0x94, 0x56, 0xb8, 0x90, 0x50, + 0xf1, 0x94, 0x49, 0x5c, 0x9d, 0x62, 0x7d, 0x85, 0x0a, 0x09, 0x1a, 0xfc, 0x87, 0xff, 0xe8, 0x46, + 0x94, 0x56, 0xc8, 0x76, 0xa3, 0xea, 0x34, 0x7c, 0x90, 0x01, 0x64, 0x6b, 0x86, 0x49, 0xc1, 0x31, + 0x11, 0x02, 0x34, 0xd1, 0x1c, 0x84, 0x6a, 0x25, 0xc2, 0x41, 0x06, 0x19, 0x34, 0x4f, 0x5c, 0xbf, + 0xba, 0xec, 0xf3, 0x3e, 0x18, 0x2b, 0x66, 0x88, 0x52, 0x3c, 0x13, 0x39, 0x13, 0xba, 0x1b, 0x3c, + 0xa4, 0xa0, 0x72, 0x50, 0x71, 0xab, 0xd8, 0x06, 0xb6, 0xd4, 0x71, 0x34, 0x51, 0x52, 0xbe, 0xc5, + 0x44, 0x98, 0xb6, 0x34, 0xba, 0xde, 0xf3, 0x1e, 0x9f, 0xab, 0x6c, 0xda, 0xa8, 0x9d, 0x81, 0x50, + 0x4c, 0xa8, 0x52, 0x2d, 0xca, 0x64, 0xcd, 0xe9, 0x9c, 0x99, 0x0b, 0xa8, 0x73, 0x65, 0xce, 0xe4, + 0x59, 0x4d, 0xe4, 0x1f, 0x7a, 0x07, 0x2d, 0x1a, 0x4f, 0x03, 0xf7, 0xc8, 0x3d, 0xbe, 0xb3, 0xbc, + 0xdd, 0xc4, 0x2f, 0x52, 0x7f, 0xe1, 0x85, 0x16, 0x31, 0xae, 0xc8, 0x9a, 0xa7, 0x44, 0x83, 0x8c, + 0x49, 0x9a, 0x4a, 0xa6, 0x54, 0xb0, 0x57, 0x37, 0xcf, 0xfc, 0x1f, 0x5f, 0x87, 0xf7, 0x0c, 0xc9, + 0xd7, 0x93, 0x51, 0x57, 0x18, 0x2d, 0x03, 0x3b, 0xf5, 0xca, 0x0e, 0x4d, 0xdb, 0x92, 0xbf, 0xf2, + 0x42, 0xda, 0x7d, 0x3d, 0xa6, 0x16, 0x2d, 0x2e, 0xca, 0x24, 0x5e, 0x31, 0x13, 0xec, 0x1f, 0xb9, + 0xc7, 0x77, 0xc7, 0x03, 0xd4, 0xee, 0x86, 0xec, 0x6e, 0x68, 0x2a, 0xcc, 0x2c, 0xf8, 0xf8, 0xfe, + 0x64, 0xd0, 0x9d, 0x80, 0x4a, 0x53, 0x68, 0x40, 0x8b, 0x32, 0x99, 0x33, 0xb3, 0xbc, 0x6f, 0x15, + 0xff, 0xdc, 0x75, 0xce, 0xcc, 0xe4, 0xe0, 0xdd, 0xcd, 0xd0, 0xf9, 0x7e, 0x33, 0x74, 0x46, 0xcf, + 0xbc, 0x71, 0xff, 0x8b, 0x2c, 0x99, 0x2a, 0xea, 0x9e, 0xf1, 0x17, 0xd7, 0xdb, 0x3f, 0x57, 0x99, + 0xff, 0xc9, 0xf5, 0x1e, 0xf5, 0xbd, 0xe6, 0x4b, 0xd4, 0xc3, 0x45, 0xa8, 0x3f, 0x4c, 0xf8, 0xfa, + 0x3f, 0x0b, 0xda, 0xed, 0x66, 0x17, 0x1f, 0xb6, 0x91, 0xbb, 0xd9, 0x46, 0xee, 0xb7, 0x6d, 0xe4, + 0x5e, 0xef, 0x22, 0x67, 0xb3, 0x8b, 0x9c, 0xcf, 0xbb, 0xc8, 0x79, 0x33, 0xc9, 0xb8, 0xbe, 0x2c, + 0x13, 0x44, 0x21, 0xef, 0x4c, 0x87, 0x7f, 0x33, 0x9c, 0xfc, 0x72, 0xf0, 0xd5, 0xdf, 0x1e, 0xd6, + 0xa6, 0x60, 0x2a, 0xb9, 0xd5, 0xfc, 0xb4, 0xa7, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x81, 0x04, + 0x6f, 0xce, 0x7b, 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -166,7 +169,7 @@ const _ = grpc.SupportPackageIsVersion4 // // 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 { - DesignateConsensusKeyForConsumerChain(ctx context.Context, in *MsgDesignateConsensusKeyForConsumerChain, opts ...grpc.CallOption) (*MsgDesignateConsensusKeyForConsumerChainResponse, error) + AssignConsensusPublicKeyToConsumerChain(ctx context.Context, in *MsgAssignConsensusPublicKeyToConsumerChain, opts ...grpc.CallOption) (*MsgAssignConsensusPublicKeyToConsumerChainResponse, error) } type msgClient struct { @@ -177,9 +180,9 @@ func NewMsgClient(cc grpc1.ClientConn) MsgClient { return &msgClient{cc} } -func (c *msgClient) DesignateConsensusKeyForConsumerChain(ctx context.Context, in *MsgDesignateConsensusKeyForConsumerChain, opts ...grpc.CallOption) (*MsgDesignateConsensusKeyForConsumerChainResponse, error) { - out := new(MsgDesignateConsensusKeyForConsumerChainResponse) - err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Msg/DesignateConsensusKeyForConsumerChain", in, out, opts...) +func (c *msgClient) AssignConsensusPublicKeyToConsumerChain(ctx context.Context, in *MsgAssignConsensusPublicKeyToConsumerChain, opts ...grpc.CallOption) (*MsgAssignConsensusPublicKeyToConsumerChainResponse, error) { + out := new(MsgAssignConsensusPublicKeyToConsumerChainResponse) + err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Msg/AssignConsensusPublicKeyToConsumerChain", in, out, opts...) if err != nil { return nil, err } @@ -188,35 +191,35 @@ func (c *msgClient) DesignateConsensusKeyForConsumerChain(ctx context.Context, i // MsgServer is the server API for Msg service. type MsgServer interface { - DesignateConsensusKeyForConsumerChain(context.Context, *MsgDesignateConsensusKeyForConsumerChain) (*MsgDesignateConsensusKeyForConsumerChainResponse, error) + AssignConsensusPublicKeyToConsumerChain(context.Context, *MsgAssignConsensusPublicKeyToConsumerChain) (*MsgAssignConsensusPublicKeyToConsumerChainResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. type UnimplementedMsgServer struct { } -func (*UnimplementedMsgServer) DesignateConsensusKeyForConsumerChain(ctx context.Context, req *MsgDesignateConsensusKeyForConsumerChain) (*MsgDesignateConsensusKeyForConsumerChainResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DesignateConsensusKeyForConsumerChain not implemented") +func (*UnimplementedMsgServer) AssignConsensusPublicKeyToConsumerChain(ctx context.Context, req *MsgAssignConsensusPublicKeyToConsumerChain) (*MsgAssignConsensusPublicKeyToConsumerChainResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AssignConsensusPublicKeyToConsumerChain not implemented") } func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) } -func _Msg_DesignateConsensusKeyForConsumerChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDesignateConsensusKeyForConsumerChain) +func _Msg_AssignConsensusPublicKeyToConsumerChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgAssignConsensusPublicKeyToConsumerChain) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(MsgServer).DesignateConsensusKeyForConsumerChain(ctx, in) + return srv.(MsgServer).AssignConsensusPublicKeyToConsumerChain(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/interchain_security.ccv.provider.v1.Msg/DesignateConsensusKeyForConsumerChain", + FullMethod: "/interchain_security.ccv.provider.v1.Msg/AssignConsensusPublicKeyToConsumerChain", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).DesignateConsensusKeyForConsumerChain(ctx, req.(*MsgDesignateConsensusKeyForConsumerChain)) + return srv.(MsgServer).AssignConsensusPublicKeyToConsumerChain(ctx, req.(*MsgAssignConsensusPublicKeyToConsumerChain)) } return interceptor(ctx, in, info, handler) } @@ -226,15 +229,15 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ HandlerType: (*MsgServer)(nil), Methods: []grpc.MethodDesc{ { - MethodName: "DesignateConsensusKeyForConsumerChain", - Handler: _Msg_DesignateConsensusKeyForConsumerChain_Handler, + MethodName: "AssignConsensusPublicKeyToConsumerChain", + Handler: _Msg_AssignConsensusPublicKeyToConsumerChain_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "interchain_security/ccv/provider/v1/tx.proto", } -func (m *MsgDesignateConsensusKeyForConsumerChain) Marshal() (dAtA []byte, err error) { +func (m *MsgAssignConsensusPublicKeyToConsumerChain) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -244,19 +247,19 @@ func (m *MsgDesignateConsensusKeyForConsumerChain) Marshal() (dAtA []byte, err e return dAtA[:n], nil } -func (m *MsgDesignateConsensusKeyForConsumerChain) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgAssignConsensusPublicKeyToConsumerChain) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgDesignateConsensusKeyForConsumerChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgAssignConsensusPublicKeyToConsumerChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.ConsumerValidatorPubKey != nil { + if m.ConsumerConsensusPubKey != nil { { - size, err := m.ConsumerValidatorPubKey.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ConsumerConsensusPubKey.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -283,7 +286,7 @@ func (m *MsgDesignateConsensusKeyForConsumerChain) MarshalToSizedBuffer(dAtA []b return len(dAtA) - i, nil } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -293,12 +296,12 @@ func (m *MsgDesignateConsensusKeyForConsumerChainResponse) Marshal() (dAtA []byt return dAtA[:n], nil } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -317,7 +320,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } -func (m *MsgDesignateConsensusKeyForConsumerChain) Size() (n int) { +func (m *MsgAssignConsensusPublicKeyToConsumerChain) Size() (n int) { if m == nil { return 0 } @@ -331,14 +334,14 @@ func (m *MsgDesignateConsensusKeyForConsumerChain) Size() (n int) { if l > 0 { n += 1 + l + sovTx(uint64(l)) } - if m.ConsumerValidatorPubKey != nil { - l = m.ConsumerValidatorPubKey.Size() + if m.ConsumerConsensusPubKey != nil { + l = m.ConsumerConsensusPubKey.Size() n += 1 + l + sovTx(uint64(l)) } return n } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) Size() (n int) { +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) Size() (n int) { if m == nil { return 0 } @@ -353,7 +356,7 @@ func sovTx(x uint64) (n int) { func sozTx(x uint64) (n int) { return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } -func (m *MsgDesignateConsensusKeyForConsumerChain) Unmarshal(dAtA []byte) error { +func (m *MsgAssignConsensusPublicKeyToConsumerChain) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -376,10 +379,10 @@ func (m *MsgDesignateConsensusKeyForConsumerChain) Unmarshal(dAtA []byte) error fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDesignateConsensusKeyForConsumerChain: wiretype end group for non-group") + return fmt.Errorf("proto: MsgAssignConsensusPublicKeyToConsumerChain: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDesignateConsensusKeyForConsumerChain: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgAssignConsensusPublicKeyToConsumerChain: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -448,7 +451,7 @@ func (m *MsgDesignateConsensusKeyForConsumerChain) Unmarshal(dAtA []byte) error iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConsumerValidatorPubKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConsumerConsensusPubKey", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -475,10 +478,10 @@ func (m *MsgDesignateConsensusKeyForConsumerChain) Unmarshal(dAtA []byte) error if postIndex > l { return io.ErrUnexpectedEOF } - if m.ConsumerValidatorPubKey == nil { - m.ConsumerValidatorPubKey = &types.Any{} + if m.ConsumerConsensusPubKey == nil { + m.ConsumerConsensusPubKey = &types.Any{} } - if err := m.ConsumerValidatorPubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConsumerConsensusPubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -503,7 +506,7 @@ func (m *MsgDesignateConsensusKeyForConsumerChain) Unmarshal(dAtA []byte) error } return nil } -func (m *MsgDesignateConsensusKeyForConsumerChainResponse) Unmarshal(dAtA []byte) error { +func (m *MsgAssignConsensusPublicKeyToConsumerChainResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -526,10 +529,10 @@ func (m *MsgDesignateConsensusKeyForConsumerChainResponse) Unmarshal(dAtA []byte fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDesignateConsensusKeyForConsumerChainResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgAssignConsensusPublicKeyToConsumerChainResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDesignateConsensusKeyForConsumerChainResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgAssignConsensusPublicKeyToConsumerChainResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: diff --git a/x/ccv/types/keyassignment.pb.go b/x/ccv/types/keyassignment.pb.go new file mode 100644 index 0000000000..ae70e6f524 --- /dev/null +++ b/x/ccv/types/keyassignment.pb.go @@ -0,0 +1,1488 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: interchain_security/ccv/provider/v1/keyassignment.proto + +package types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + crypto "github.com/tendermint/tendermint/proto/tendermint/crypto" + 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 + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type LastUpdateMemo struct { + ConsumerKey *crypto.PublicKey `protobuf:"bytes,1,opt,name=consumer_key,json=consumerKey,proto3" json:"consumer_key,omitempty"` + ProviderKey *crypto.PublicKey `protobuf:"bytes,2,opt,name=provider_key,json=providerKey,proto3" json:"provider_key,omitempty"` + Vscid uint64 `protobuf:"varint,4,opt,name=vscid,proto3" json:"vscid,omitempty"` + Power int64 `protobuf:"varint,5,opt,name=power,proto3" json:"power,omitempty"` +} + +func (m *LastUpdateMemo) Reset() { *m = LastUpdateMemo{} } +func (m *LastUpdateMemo) String() string { return proto.CompactTextString(m) } +func (*LastUpdateMemo) ProtoMessage() {} +func (*LastUpdateMemo) Descriptor() ([]byte, []int) { + return fileDescriptor_d36beb32b6cd555b, []int{0} +} +func (m *LastUpdateMemo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LastUpdateMemo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LastUpdateMemo.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 *LastUpdateMemo) XXX_Merge(src proto.Message) { + xxx_messageInfo_LastUpdateMemo.Merge(m, src) +} +func (m *LastUpdateMemo) XXX_Size() int { + return m.Size() +} +func (m *LastUpdateMemo) XXX_DiscardUnknown() { + xxx_messageInfo_LastUpdateMemo.DiscardUnknown(m) +} + +var xxx_messageInfo_LastUpdateMemo proto.InternalMessageInfo + +func (m *LastUpdateMemo) GetConsumerKey() *crypto.PublicKey { + if m != nil { + return m.ConsumerKey + } + return nil +} + +func (m *LastUpdateMemo) GetProviderKey() *crypto.PublicKey { + if m != nil { + return m.ProviderKey + } + return nil +} + +func (m *LastUpdateMemo) GetVscid() uint64 { + if m != nil { + return m.Vscid + } + return 0 +} + +func (m *LastUpdateMemo) GetPower() int64 { + if m != nil { + return m.Power + } + return 0 +} + +type ConsAddrToKey struct { + ConsAddr []byte `protobuf:"bytes,1,opt,name=cons_addr,json=consAddr,proto3" json:"cons_addr,omitempty"` + Key *crypto.PublicKey `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *ConsAddrToKey) Reset() { *m = ConsAddrToKey{} } +func (m *ConsAddrToKey) String() string { return proto.CompactTextString(m) } +func (*ConsAddrToKey) ProtoMessage() {} +func (*ConsAddrToKey) Descriptor() ([]byte, []int) { + return fileDescriptor_d36beb32b6cd555b, []int{1} +} +func (m *ConsAddrToKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConsAddrToKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConsAddrToKey.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 *ConsAddrToKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConsAddrToKey.Merge(m, src) +} +func (m *ConsAddrToKey) XXX_Size() int { + return m.Size() +} +func (m *ConsAddrToKey) XXX_DiscardUnknown() { + xxx_messageInfo_ConsAddrToKey.DiscardUnknown(m) +} + +var xxx_messageInfo_ConsAddrToKey proto.InternalMessageInfo + +func (m *ConsAddrToKey) GetConsAddr() []byte { + if m != nil { + return m.ConsAddr + } + return nil +} + +func (m *ConsAddrToKey) GetKey() *crypto.PublicKey { + if m != nil { + return m.Key + } + return nil +} + +type KeyToKey struct { + From *crypto.PublicKey `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"` + To *crypto.PublicKey `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"` +} + +func (m *KeyToKey) Reset() { *m = KeyToKey{} } +func (m *KeyToKey) String() string { return proto.CompactTextString(m) } +func (*KeyToKey) ProtoMessage() {} +func (*KeyToKey) Descriptor() ([]byte, []int) { + return fileDescriptor_d36beb32b6cd555b, []int{2} +} +func (m *KeyToKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyToKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyToKey.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 *KeyToKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyToKey.Merge(m, src) +} +func (m *KeyToKey) XXX_Size() int { + return m.Size() +} +func (m *KeyToKey) XXX_DiscardUnknown() { + xxx_messageInfo_KeyToKey.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyToKey proto.InternalMessageInfo + +func (m *KeyToKey) GetFrom() *crypto.PublicKey { + if m != nil { + return m.From + } + return nil +} + +func (m *KeyToKey) GetTo() *crypto.PublicKey { + if m != nil { + return m.To + } + return nil +} + +type ConsAddrToLastUpdateMemo struct { + ConsAddr []byte `protobuf:"bytes,1,opt,name=cons_addr,json=consAddr,proto3" json:"cons_addr,omitempty"` + LastUpdateMemo *LastUpdateMemo `protobuf:"bytes,2,opt,name=last_update_memo,json=lastUpdateMemo,proto3" json:"last_update_memo,omitempty"` +} + +func (m *ConsAddrToLastUpdateMemo) Reset() { *m = ConsAddrToLastUpdateMemo{} } +func (m *ConsAddrToLastUpdateMemo) String() string { return proto.CompactTextString(m) } +func (*ConsAddrToLastUpdateMemo) ProtoMessage() {} +func (*ConsAddrToLastUpdateMemo) Descriptor() ([]byte, []int) { + return fileDescriptor_d36beb32b6cd555b, []int{3} +} +func (m *ConsAddrToLastUpdateMemo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConsAddrToLastUpdateMemo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConsAddrToLastUpdateMemo.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 *ConsAddrToLastUpdateMemo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConsAddrToLastUpdateMemo.Merge(m, src) +} +func (m *ConsAddrToLastUpdateMemo) XXX_Size() int { + return m.Size() +} +func (m *ConsAddrToLastUpdateMemo) XXX_DiscardUnknown() { + xxx_messageInfo_ConsAddrToLastUpdateMemo.DiscardUnknown(m) +} + +var xxx_messageInfo_ConsAddrToLastUpdateMemo proto.InternalMessageInfo + +func (m *ConsAddrToLastUpdateMemo) GetConsAddr() []byte { + if m != nil { + return m.ConsAddr + } + return nil +} + +func (m *ConsAddrToLastUpdateMemo) GetLastUpdateMemo() *LastUpdateMemo { + if m != nil { + return m.LastUpdateMemo + } + return nil +} + +type KeyAssignment struct { + ProviderConsAddrToConsumerKey []ConsAddrToKey `protobuf:"bytes,1,rep,name=provider_cons_addr_to_consumer_key,json=providerConsAddrToConsumerKey,proto3" json:"provider_cons_addr_to_consumer_key"` + ConsumerKeyToProviderKey []KeyToKey `protobuf:"bytes,2,rep,name=consumer_key_to_provider_key,json=consumerKeyToProviderKey,proto3" json:"consumer_key_to_provider_key"` + ConsumerConsAddrToLastUpdateMemo []ConsAddrToLastUpdateMemo `protobuf:"bytes,3,rep,name=consumer_cons_addr_to_last_update_memo,json=consumerConsAddrToLastUpdateMemo,proto3" json:"consumer_cons_addr_to_last_update_memo"` +} + +func (m *KeyAssignment) Reset() { *m = KeyAssignment{} } +func (m *KeyAssignment) String() string { return proto.CompactTextString(m) } +func (*KeyAssignment) ProtoMessage() {} +func (*KeyAssignment) Descriptor() ([]byte, []int) { + return fileDescriptor_d36beb32b6cd555b, []int{4} +} +func (m *KeyAssignment) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyAssignment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyAssignment.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 *KeyAssignment) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyAssignment.Merge(m, src) +} +func (m *KeyAssignment) XXX_Size() int { + return m.Size() +} +func (m *KeyAssignment) XXX_DiscardUnknown() { + xxx_messageInfo_KeyAssignment.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyAssignment proto.InternalMessageInfo + +func (m *KeyAssignment) GetProviderConsAddrToConsumerKey() []ConsAddrToKey { + if m != nil { + return m.ProviderConsAddrToConsumerKey + } + return nil +} + +func (m *KeyAssignment) GetConsumerKeyToProviderKey() []KeyToKey { + if m != nil { + return m.ConsumerKeyToProviderKey + } + return nil +} + +func (m *KeyAssignment) GetConsumerConsAddrToLastUpdateMemo() []ConsAddrToLastUpdateMemo { + if m != nil { + return m.ConsumerConsAddrToLastUpdateMemo + } + return nil +} + +func init() { + proto.RegisterType((*LastUpdateMemo)(nil), "interchain_security.ccv.provider.v1.LastUpdateMemo") + proto.RegisterType((*ConsAddrToKey)(nil), "interchain_security.ccv.provider.v1.ConsAddrToKey") + proto.RegisterType((*KeyToKey)(nil), "interchain_security.ccv.provider.v1.KeyToKey") + proto.RegisterType((*ConsAddrToLastUpdateMemo)(nil), "interchain_security.ccv.provider.v1.ConsAddrToLastUpdateMemo") + proto.RegisterType((*KeyAssignment)(nil), "interchain_security.ccv.provider.v1.KeyAssignment") +} + +func init() { + proto.RegisterFile("interchain_security/ccv/provider/v1/keyassignment.proto", fileDescriptor_d36beb32b6cd555b) +} + +var fileDescriptor_d36beb32b6cd555b = []byte{ + // 518 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xcf, 0x6e, 0xd3, 0x4e, + 0x18, 0xcc, 0xc6, 0xe9, 0x4f, 0xfd, 0x6d, 0xda, 0x0a, 0x59, 0x3d, 0x58, 0x25, 0x98, 0xc8, 0x48, + 0x28, 0x07, 0xba, 0x26, 0xe9, 0x81, 0x13, 0x42, 0xa5, 0x47, 0x83, 0x54, 0x59, 0xe5, 0x82, 0x40, + 0x96, 0xb3, 0x5e, 0x52, 0xd3, 0xd8, 0x9f, 0xb5, 0xbb, 0x36, 0xf8, 0xcc, 0x0b, 0x70, 0x81, 0x07, + 0xe0, 0x41, 0x38, 0xf7, 0xd8, 0x23, 0x27, 0x84, 0x92, 0x17, 0x41, 0x6b, 0xc7, 0x4e, 0x1c, 0xfe, + 0xc8, 0xdc, 0xb2, 0xd9, 0xf9, 0x66, 0xe6, 0xf3, 0x8c, 0x16, 0x3f, 0x0a, 0x63, 0xc9, 0x38, 0xbd, + 0xf4, 0xc3, 0xd8, 0x13, 0x8c, 0xa6, 0x3c, 0x94, 0xb9, 0x4d, 0x69, 0x66, 0x27, 0x1c, 0xb2, 0x30, + 0x60, 0xdc, 0xce, 0xc6, 0xf6, 0x15, 0xcb, 0x7d, 0x21, 0xc2, 0x59, 0x1c, 0xb1, 0x58, 0x92, 0x84, + 0x83, 0x04, 0xfd, 0xde, 0x6f, 0x06, 0x09, 0xa5, 0x19, 0xa9, 0x06, 0x49, 0x36, 0x3e, 0x3a, 0x9c, + 0xc1, 0x0c, 0x0a, 0xbc, 0xad, 0x7e, 0x95, 0xa3, 0x47, 0x03, 0xc9, 0xe2, 0x80, 0xf1, 0x28, 0x8c, + 0xa5, 0x4d, 0x79, 0x9e, 0x48, 0x50, 0x0a, 0xa2, 0xbc, 0xb5, 0xbe, 0x22, 0x7c, 0xf0, 0xcc, 0x17, + 0xf2, 0x45, 0x12, 0xf8, 0x92, 0x3d, 0x67, 0x11, 0xe8, 0x4f, 0xf0, 0x1e, 0x85, 0x58, 0xa4, 0x11, + 0xe3, 0xde, 0x15, 0xcb, 0x0d, 0x34, 0x44, 0xa3, 0xfe, 0x64, 0x40, 0xd6, 0x3c, 0xa4, 0xe4, 0x21, + 0xe7, 0xe9, 0x74, 0x1e, 0x52, 0x87, 0xe5, 0x6e, 0xbf, 0x9a, 0x70, 0x58, 0xae, 0x08, 0x2a, 0x5b, + 0x05, 0x41, 0xb7, 0x0d, 0x41, 0x35, 0xa1, 0x08, 0x0e, 0xf1, 0x4e, 0x26, 0x68, 0x18, 0x18, 0xbd, + 0x21, 0x1a, 0xf5, 0xdc, 0xf2, 0xa0, 0xfe, 0x4d, 0xe0, 0x1d, 0xe3, 0xc6, 0xce, 0x10, 0x8d, 0x34, + 0xb7, 0x3c, 0x58, 0xaf, 0xf0, 0xfe, 0x19, 0xc4, 0xe2, 0x34, 0x08, 0xf8, 0x05, 0xa8, 0xe1, 0xdb, + 0xf8, 0x7f, 0x65, 0xc6, 0xf3, 0x83, 0x80, 0x17, 0xde, 0xf7, 0xdc, 0x5d, 0xba, 0x42, 0xe8, 0x04, + 0x6b, 0x6d, 0x1d, 0x29, 0xa0, 0xf5, 0x16, 0xef, 0x3a, 0x2c, 0x2f, 0x89, 0x1f, 0xe2, 0xde, 0x1b, + 0x0e, 0x51, 0xab, 0xef, 0x51, 0x20, 0xf5, 0x07, 0xb8, 0x2b, 0xa1, 0x95, 0x58, 0x57, 0x82, 0xf5, + 0x19, 0x61, 0x63, 0xbd, 0xca, 0x56, 0x28, 0x7f, 0xdd, 0xea, 0x35, 0xbe, 0x35, 0xf7, 0x85, 0xf4, + 0xd2, 0x02, 0xef, 0x45, 0x2c, 0xaa, 0x54, 0x4f, 0x48, 0x8b, 0xe2, 0x90, 0xa6, 0x96, 0x7b, 0x30, + 0x6f, 0x9c, 0xad, 0x2f, 0x1a, 0xde, 0x77, 0x58, 0x7e, 0x5a, 0x97, 0x52, 0xff, 0x80, 0xb0, 0x55, + 0x47, 0x5c, 0xfb, 0xf2, 0x24, 0x78, 0x5b, 0xcd, 0xd1, 0x46, 0xfd, 0xc9, 0xa4, 0x95, 0x87, 0x46, + 0x88, 0x4f, 0x7b, 0xd7, 0xdf, 0xef, 0x76, 0xdc, 0x3b, 0x15, 0x60, 0x7d, 0x79, 0xb6, 0xd1, 0x33, + 0x81, 0x07, 0x9b, 0x72, 0x4a, 0x7e, 0xab, 0x77, 0x4a, 0xfe, 0xb8, 0x95, 0x7c, 0x95, 0xf2, 0x4a, + 0xd9, 0xd8, 0xe8, 0xf3, 0x05, 0x9c, 0x6f, 0x74, 0xf3, 0x13, 0xc2, 0xf7, 0x6b, 0xd5, 0xc6, 0xea, + 0xbf, 0x44, 0xa0, 0x15, 0xfa, 0x8f, 0xff, 0x71, 0xfd, 0x66, 0x18, 0x2b, 0x3f, 0xc3, 0x4a, 0xf2, + 0x8f, 0x38, 0xe7, 0x7a, 0x61, 0xa2, 0x9b, 0x85, 0x89, 0x7e, 0x2c, 0x4c, 0xf4, 0x71, 0x69, 0x76, + 0x6e, 0x96, 0x66, 0xe7, 0xdb, 0xd2, 0xec, 0xbc, 0x1c, 0xcf, 0x42, 0x79, 0x99, 0x4e, 0x09, 0x85, + 0xc8, 0xa6, 0x20, 0x22, 0x10, 0xf6, 0xda, 0xd1, 0x71, 0xfd, 0x0c, 0xbd, 0x2f, 0x1e, 0x22, 0x99, + 0x27, 0x4c, 0x4c, 0xff, 0x2b, 0x1e, 0x87, 0x93, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xfc, 0x3d, + 0x9f, 0xe7, 0xb0, 0x04, 0x00, 0x00, +} + +func (m *LastUpdateMemo) 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 *LastUpdateMemo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LastUpdateMemo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Power != 0 { + i = encodeVarintKeyassignment(dAtA, i, uint64(m.Power)) + i-- + dAtA[i] = 0x28 + } + if m.Vscid != 0 { + i = encodeVarintKeyassignment(dAtA, i, uint64(m.Vscid)) + i-- + dAtA[i] = 0x20 + } + if m.ProviderKey != nil { + { + size, err := m.ProviderKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeyassignment(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.ConsumerKey != nil { + { + size, err := m.ConsumerKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeyassignment(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ConsAddrToKey) 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 *ConsAddrToKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConsAddrToKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Key != nil { + { + size, err := m.Key.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeyassignment(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ConsAddr) > 0 { + i -= len(m.ConsAddr) + copy(dAtA[i:], m.ConsAddr) + i = encodeVarintKeyassignment(dAtA, i, uint64(len(m.ConsAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *KeyToKey) 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 *KeyToKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KeyToKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.To != nil { + { + size, err := m.To.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeyassignment(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.From != nil { + { + size, err := m.From.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeyassignment(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ConsAddrToLastUpdateMemo) 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 *ConsAddrToLastUpdateMemo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConsAddrToLastUpdateMemo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.LastUpdateMemo != nil { + { + size, err := m.LastUpdateMemo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeyassignment(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ConsAddr) > 0 { + i -= len(m.ConsAddr) + copy(dAtA[i:], m.ConsAddr) + i = encodeVarintKeyassignment(dAtA, i, uint64(len(m.ConsAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *KeyAssignment) 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 *KeyAssignment) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KeyAssignment) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ConsumerConsAddrToLastUpdateMemo) > 0 { + for iNdEx := len(m.ConsumerConsAddrToLastUpdateMemo) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ConsumerConsAddrToLastUpdateMemo[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeyassignment(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.ConsumerKeyToProviderKey) > 0 { + for iNdEx := len(m.ConsumerKeyToProviderKey) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ConsumerKeyToProviderKey[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeyassignment(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.ProviderConsAddrToConsumerKey) > 0 { + for iNdEx := len(m.ProviderConsAddrToConsumerKey) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ProviderConsAddrToConsumerKey[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeyassignment(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintKeyassignment(dAtA []byte, offset int, v uint64) int { + offset -= sovKeyassignment(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *LastUpdateMemo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ConsumerKey != nil { + l = m.ConsumerKey.Size() + n += 1 + l + sovKeyassignment(uint64(l)) + } + if m.ProviderKey != nil { + l = m.ProviderKey.Size() + n += 1 + l + sovKeyassignment(uint64(l)) + } + if m.Vscid != 0 { + n += 1 + sovKeyassignment(uint64(m.Vscid)) + } + if m.Power != 0 { + n += 1 + sovKeyassignment(uint64(m.Power)) + } + return n +} + +func (m *ConsAddrToKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ConsAddr) + if l > 0 { + n += 1 + l + sovKeyassignment(uint64(l)) + } + if m.Key != nil { + l = m.Key.Size() + n += 1 + l + sovKeyassignment(uint64(l)) + } + return n +} + +func (m *KeyToKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.From != nil { + l = m.From.Size() + n += 1 + l + sovKeyassignment(uint64(l)) + } + if m.To != nil { + l = m.To.Size() + n += 1 + l + sovKeyassignment(uint64(l)) + } + return n +} + +func (m *ConsAddrToLastUpdateMemo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ConsAddr) + if l > 0 { + n += 1 + l + sovKeyassignment(uint64(l)) + } + if m.LastUpdateMemo != nil { + l = m.LastUpdateMemo.Size() + n += 1 + l + sovKeyassignment(uint64(l)) + } + return n +} + +func (m *KeyAssignment) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ProviderConsAddrToConsumerKey) > 0 { + for _, e := range m.ProviderConsAddrToConsumerKey { + l = e.Size() + n += 1 + l + sovKeyassignment(uint64(l)) + } + } + if len(m.ConsumerKeyToProviderKey) > 0 { + for _, e := range m.ConsumerKeyToProviderKey { + l = e.Size() + n += 1 + l + sovKeyassignment(uint64(l)) + } + } + if len(m.ConsumerConsAddrToLastUpdateMemo) > 0 { + for _, e := range m.ConsumerConsAddrToLastUpdateMemo { + l = e.Size() + n += 1 + l + sovKeyassignment(uint64(l)) + } + } + return n +} + +func sovKeyassignment(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozKeyassignment(x uint64) (n int) { + return sovKeyassignment(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *LastUpdateMemo) 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 ErrIntOverflowKeyassignment + } + 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: LastUpdateMemo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LastUpdateMemo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsumerKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ConsumerKey == nil { + m.ConsumerKey = &crypto.PublicKey{} + } + if err := m.ConsumerKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProviderKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProviderKey == nil { + m.ProviderKey = &crypto.PublicKey{} + } + if err := m.ProviderKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Vscid", wireType) + } + m.Vscid = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Vscid |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType) + } + m.Power = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Power |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipKeyassignment(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeyassignment + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConsAddrToKey) 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 ErrIntOverflowKeyassignment + } + 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: ConsAddrToKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConsAddrToKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConsAddr = append(m.ConsAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ConsAddr == nil { + m.ConsAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Key == nil { + m.Key = &crypto.PublicKey{} + } + if err := m.Key.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeyassignment(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeyassignment + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *KeyToKey) 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 ErrIntOverflowKeyassignment + } + 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: KeyToKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KeyToKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field From", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.From == nil { + m.From = &crypto.PublicKey{} + } + if err := m.From.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.To == nil { + m.To = &crypto.PublicKey{} + } + if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeyassignment(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeyassignment + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConsAddrToLastUpdateMemo) 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 ErrIntOverflowKeyassignment + } + 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: ConsAddrToLastUpdateMemo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConsAddrToLastUpdateMemo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConsAddr = append(m.ConsAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ConsAddr == nil { + m.ConsAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateMemo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LastUpdateMemo == nil { + m.LastUpdateMemo = &LastUpdateMemo{} + } + if err := m.LastUpdateMemo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeyassignment(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeyassignment + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *KeyAssignment) 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 ErrIntOverflowKeyassignment + } + 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: KeyAssignment: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KeyAssignment: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProviderConsAddrToConsumerKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProviderConsAddrToConsumerKey = append(m.ProviderConsAddrToConsumerKey, ConsAddrToKey{}) + if err := m.ProviderConsAddrToConsumerKey[len(m.ProviderConsAddrToConsumerKey)-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 ConsumerKeyToProviderKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConsumerKeyToProviderKey = append(m.ConsumerKeyToProviderKey, KeyToKey{}) + if err := m.ConsumerKeyToProviderKey[len(m.ConsumerKeyToProviderKey)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsumerConsAddrToLastUpdateMemo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeyassignment + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeyassignment + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeyassignment + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConsumerConsAddrToLastUpdateMemo = append(m.ConsumerConsAddrToLastUpdateMemo, ConsAddrToLastUpdateMemo{}) + if err := m.ConsumerConsAddrToLastUpdateMemo[len(m.ConsumerConsAddrToLastUpdateMemo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeyassignment(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeyassignment + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipKeyassignment(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, ErrIntOverflowKeyassignment + } + 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, ErrIntOverflowKeyassignment + } + 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, ErrIntOverflowKeyassignment + } + 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, ErrInvalidLengthKeyassignment + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupKeyassignment + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthKeyassignment + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthKeyassignment = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowKeyassignment = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupKeyassignment = fmt.Errorf("proto: unexpected end of group") +)