certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into cyrus/docs-0.40.x

This commit is contained in:
Cyrus Goh 2020-11-10 10:15:09 -08:00 committed by GitHub
parent c432e2871b bcdd6ee15c
commit 131a942ef1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
66 changed files with 1569 additions and 1836 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
client/docs/swagger-ui/swagger.yaml vendored
View File

@ -15760,7 +15760,7 @@ paths:
} }
tags: tags:
- Query - Query
/ibc/channel/v1beta1/channels: /ibc/core/channel/v1beta1/channels:
get: get:
summary: Channels queries all the IBC channels of a chain. summary: Channels queries all the IBC channels of a chain.
operationId: Channels operationId: Channels
@ -16146,7 +16146,7 @@ paths:
type: boolean type: boolean
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}':
get: get:
summary: Channel queries an IBC Channel. summary: Channel queries an IBC Channel.
operationId: Channel operationId: Channel
@ -16471,7 +16471,7 @@ paths:
type: string type: string
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state':
get: get:
summary: >- summary: >-
ChannelClientState queries for the client state for the channel ChannelClientState queries for the client state for the channel
@ -16909,7 +16909,7 @@ paths:
type: string type: string
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/version/{version_number}/height/{version_height}': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/version/{version_number}/height/{version_height}':
get: get:
summary: |- summary: |-
ChannelConsensusState queries for the consensus state for the channel ChannelConsensusState queries for the consensus state for the channel
@ -17344,7 +17344,7 @@ paths:
format: uint64 format: uint64
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence':
get: get:
summary: >- summary: >-
NextSequenceReceive returns the next receive sequence for a given NextSequenceReceive returns the next receive sequence for a given
@ -17596,7 +17596,7 @@ paths:
type: string type: string
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements':
get: get:
summary: >- summary: >-
PacketAcknowledgements returns all the packet acknowledgements PacketAcknowledgements returns all the packet acknowledgements
@ -17945,7 +17945,7 @@ paths:
type: boolean type: boolean
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}':
get: get:
summary: PacketAcknowledgement queries a stored packet acknowledgement hash. summary: PacketAcknowledgement queries a stored packet acknowledgement hash.
operationId: PacketAcknowledgement operationId: PacketAcknowledgement
@ -18205,7 +18205,7 @@ paths:
format: uint64 format: uint64
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments':
get: get:
summary: |- summary: |-
PacketCommitments returns all the packet commitments hashes associated PacketCommitments returns all the packet commitments hashes associated
@ -18552,7 +18552,7 @@ paths:
type: boolean type: boolean
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks':
get: get:
summary: >- summary: >-
UnreceivedAcks returns all the unreceived IBC acknowledgements UnreceivedAcks returns all the unreceived IBC acknowledgements
@ -18814,7 +18814,7 @@ paths:
minItems: 1 minItems: 1
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets':
get: get:
summary: >- summary: >-
UnreceivedPackets returns all the unreceived IBC packets associated with UnreceivedPackets returns all the unreceived IBC packets associated with
@ -19076,7 +19076,7 @@ paths:
minItems: 1 minItems: 1
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}':
get: get:
summary: PacketCommitment queries a stored packet commitment hash. summary: PacketCommitment queries a stored packet commitment hash.
operationId: PacketCommitment operationId: PacketCommitment
@ -19337,7 +19337,7 @@ paths:
format: uint64 format: uint64
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}': '/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}':
get: get:
summary: >- summary: >-
PacketReceipt queries if a given packet sequence has been received on PacketReceipt queries if a given packet sequence has been received on
@ -19599,7 +19599,7 @@ paths:
format: uint64 format: uint64
tags: tags:
- Query - Query
'/ibc/channel/v1beta1/connections/{connection}/channels': '/ibc/core/channel/v1beta1/connections/{connection}/channels':
get: get:
summary: |- summary: |-
ConnectionChannels queries all the channels associated with a connection ConnectionChannels queries all the channels associated with a connection
@ -19992,7 +19992,7 @@ paths:
type: boolean type: boolean
tags: tags:
- Query - Query
/ibc/client/v1beta1/client_states: /ibc/core/client/v1beta1/client_states:
get: get:
summary: ClientStates queries all the IBC light clients of a chain. summary: ClientStates queries all the IBC light clients of a chain.
operationId: ClientStates operationId: ClientStates
@ -20465,7 +20465,7 @@ paths:
type: boolean type: boolean
tags: tags:
- Query - Query
'/ibc/client/v1beta1/client_states/{client_id}': '/ibc/core/client/v1beta1/client_states/{client_id}':
get: get:
summary: ClientState queries an IBC light client. summary: ClientState queries an IBC light client.
operationId: ClientState operationId: ClientState
@ -20883,7 +20883,7 @@ paths:
type: string type: string
tags: tags:
- Query - Query
'/ibc/client/v1beta1/consensus_states/{client_id}': '/ibc/core/client/v1beta1/consensus_states/{client_id}':
get: get:
summary: |- summary: |-
ConsensusStates queries all the consensus state associated with a given ConsensusStates queries all the consensus state associated with a given
@ -21383,7 +21383,7 @@ paths:
type: boolean type: boolean
tags: tags:
- Query - Query
'/ibc/client/v1beta1/consensus_states/{client_id}/version/{version_number}/height/{version_height}': '/ibc/core/client/v1beta1/consensus_states/{client_id}/version/{version_number}/height/{version_height}':
get: get:
summary: >- summary: >-
ConsensusState queries a consensus state associated with a client state ConsensusState queries a consensus state associated with a client state
@ -21825,7 +21825,7 @@ paths:
type: boolean type: boolean
tags: tags:
- Query - Query
'/ibc/connection/v1beta1/client_connections/{client_id}': '/ibc/core/connection/v1beta1/client_connections/{client_id}':
get: get:
summary: |- summary: |-
ClientConnections queries the connection paths associated with a client ClientConnections queries the connection paths associated with a client
@ -22073,7 +22073,7 @@ paths:
type: string type: string
tags: tags:
- Query - Query
/ibc/connection/v1beta1/connections: /ibc/core/connection/v1beta1/connections:
get: get:
summary: Connections queries all the IBC connections of a chain. summary: Connections queries all the IBC connections of a chain.
operationId: Connections operationId: Connections
@ -22457,7 +22457,7 @@ paths:
type: boolean type: boolean
tags: tags:
- Query - Query
'/ibc/connection/v1beta1/connections/{connection_id}': '/ibc/core/connection/v1beta1/connections/{connection_id}':
get: get:
summary: Connection queries an IBC connection end. summary: Connection queries an IBC connection end.
operationId: Connection operationId: Connection
@ -22777,7 +22777,7 @@ paths:
type: string type: string
tags: tags:
- Query - Query
'/ibc/connection/v1beta1/connections/{connection_id}/client_state': '/ibc/core/connection/v1beta1/connections/{connection_id}/client_state':
get: get:
summary: |- summary: |-
ConnectionClientState queries the client state associated with the ConnectionClientState queries the client state associated with the
@ -23208,7 +23208,7 @@ paths:
type: string type: string
tags: tags:
- Query - Query
'/ibc/connection/v1beta1/connections/{connection_id}/consensus_state/version/{version_number}/height/{version_height}': '/ibc/core/connection/v1beta1/connections/{connection_id}/consensus_state/version/{version_number}/height/{version_height}':
get: get:
summary: |- summary: |-
ConnectionConsensusState queries the consensus state associated with the ConnectionConsensusState queries the consensus state associated with the
@ -23636,7 +23636,7 @@ paths:
format: uint64 format: uint64
tags: tags:
- Query - Query
/ibc_transfer/v1beta1/denom_traces: /ibc/applications/transfer/v1beta1/denom_traces:
get: get:
summary: DenomTraces queries all denomination traces. summary: DenomTraces queries all denomination traces.
operationId: DenomTraces operationId: DenomTraces
@ -23761,7 +23761,7 @@ paths:
type: boolean type: boolean
tags: tags:
- Query - Query
'/ibc_transfer/v1beta1/denom_traces/{hash}': '/ibc/applications/transfer/v1beta1/denom_traces/{hash}':
get: get:
summary: DenomTrace queries a denomination trace information. summary: DenomTrace queries a denomination trace information.
operationId: DenomTrace operationId: DenomTrace
@ -23822,7 +23822,7 @@ paths:
type: string type: string
tags: tags:
- Query - Query
/ibc_transfer/v1beta1/params: /ibc/applications/transfer/v1beta1/params:
get: get:
summary: Params queries all parameters of the ibc-transfer module. summary: Params queries all parameters of the ibc-transfer module.
operationId: IBCTransferParams operationId: IBCTransferParams

6
proto/ibc/applications/transfer/v1/query.proto
View File

@ -12,17 +12,17 @@ option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/applications/transfer/ty
service Query { service Query {
// DenomTrace queries a denomination trace information. // DenomTrace queries a denomination trace information.
rpc DenomTrace(QueryDenomTraceRequest) returns (QueryDenomTraceResponse) { rpc DenomTrace(QueryDenomTraceRequest) returns (QueryDenomTraceResponse) {
option (google.api.http).get = "/ibc_transfer/v1beta1/denom_traces/{hash}"; option (google.api.http).get = "/ibc/applications/transfer/v1beta1/denom_traces/{hash}";
} }
// DenomTraces queries all denomination traces. // DenomTraces queries all denomination traces.
rpc DenomTraces(QueryDenomTracesRequest) returns (QueryDenomTracesResponse) { rpc DenomTraces(QueryDenomTracesRequest) returns (QueryDenomTracesResponse) {
option (google.api.http).get = "/ibc_transfer/v1beta1/denom_traces"; option (google.api.http).get = "/ibc/applications/transfer/v1beta1/denom_traces";
} }
// Params queries all parameters of the ibc-transfer module. // Params queries all parameters of the ibc-transfer module.
rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { rpc Params(QueryParamsRequest) returns (QueryParamsResponse) {
option (google.api.http).get = "/ibc_transfer/v1beta1/params"; option (google.api.http).get = "/ibc/applications/transfer/v1beta1/params";
} }
} }

26
proto/ibc/core/channel/v1/query.proto
View File

@ -14,79 +14,79 @@ option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/04-channel/types";
service Query { service Query {
// Channel queries an IBC Channel. // Channel queries an IBC Channel.
rpc Channel(QueryChannelRequest) returns (QueryChannelResponse) { rpc Channel(QueryChannelRequest) returns (QueryChannelResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}"; option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}";
} }
// Channels queries all the IBC channels of a chain. // Channels queries all the IBC channels of a chain.
rpc Channels(QueryChannelsRequest) returns (QueryChannelsResponse) { rpc Channels(QueryChannelsRequest) returns (QueryChannelsResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels"; option (google.api.http).get = "/ibc/core/channel/v1beta1/channels";
} }
// ConnectionChannels queries all the channels associated with a connection // ConnectionChannels queries all the channels associated with a connection
// end. // end.
rpc ConnectionChannels(QueryConnectionChannelsRequest) returns (QueryConnectionChannelsResponse) { rpc ConnectionChannels(QueryConnectionChannelsRequest) returns (QueryConnectionChannelsResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/connections/{connection}/channels"; option (google.api.http).get = "/ibc/core/channel/v1beta1/connections/{connection}/channels";
} }
// ChannelClientState queries for the client state for the channel associated // ChannelClientState queries for the client state for the channel associated
// with the provided channel identifiers. // with the provided channel identifiers.
rpc ChannelClientState(QueryChannelClientStateRequest) returns (QueryChannelClientStateResponse) { rpc ChannelClientState(QueryChannelClientStateRequest) returns (QueryChannelClientStateResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state"; option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state";
} }
// ChannelConsensusState queries for the consensus state for the channel // ChannelConsensusState queries for the consensus state for the channel
// associated with the provided channel identifiers. // associated with the provided channel identifiers.
rpc ChannelConsensusState(QueryChannelConsensusStateRequest) returns (QueryChannelConsensusStateResponse) { rpc ChannelConsensusState(QueryChannelConsensusStateRequest) returns (QueryChannelConsensusStateResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/version/" option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/version/"
"{version_number}/height/{version_height}"; "{version_number}/height/{version_height}";
} }
// PacketCommitment queries a stored packet commitment hash. // PacketCommitment queries a stored packet commitment hash.
rpc PacketCommitment(QueryPacketCommitmentRequest) returns (QueryPacketCommitmentResponse) { rpc PacketCommitment(QueryPacketCommitmentRequest) returns (QueryPacketCommitmentResponse) {
option (google.api.http).get = option (google.api.http).get =
"/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}"; "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}";
} }
// PacketCommitments returns all the packet commitments hashes associated // PacketCommitments returns all the packet commitments hashes associated
// with a channel. // with a channel.
rpc PacketCommitments(QueryPacketCommitmentsRequest) returns (QueryPacketCommitmentsResponse) { rpc PacketCommitments(QueryPacketCommitmentsRequest) returns (QueryPacketCommitmentsResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments"; option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments";
} }
// PacketReceipt queries if a given packet sequence has been received on the queried chain // PacketReceipt queries if a given packet sequence has been received on the queried chain
rpc PacketReceipt(QueryPacketReceiptRequest) returns (QueryPacketReceiptResponse) { rpc PacketReceipt(QueryPacketReceiptRequest) returns (QueryPacketReceiptResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}"; option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}";
} }
// PacketAcknowledgement queries a stored packet acknowledgement hash. // PacketAcknowledgement queries a stored packet acknowledgement hash.
rpc PacketAcknowledgement(QueryPacketAcknowledgementRequest) returns (QueryPacketAcknowledgementResponse) { rpc PacketAcknowledgement(QueryPacketAcknowledgementRequest) returns (QueryPacketAcknowledgementResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}"; option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}";
} }
// PacketAcknowledgements returns all the packet acknowledgements associated // PacketAcknowledgements returns all the packet acknowledgements associated
// with a channel. // with a channel.
rpc PacketAcknowledgements(QueryPacketAcknowledgementsRequest) returns (QueryPacketAcknowledgementsResponse) { rpc PacketAcknowledgements(QueryPacketAcknowledgementsRequest) returns (QueryPacketAcknowledgementsResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements"; option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements";
} }
// UnreceivedPackets returns all the unreceived IBC packets associated with a // UnreceivedPackets returns all the unreceived IBC packets associated with a
// channel and sequences. // channel and sequences.
rpc UnreceivedPackets(QueryUnreceivedPacketsRequest) returns (QueryUnreceivedPacketsResponse) { rpc UnreceivedPackets(QueryUnreceivedPacketsRequest) returns (QueryUnreceivedPacketsResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/" option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/"
"{packet_commitment_sequences}/unreceived_packets"; "{packet_commitment_sequences}/unreceived_packets";
} }
// UnreceivedAcks returns all the unreceived IBC acknowledgements associated with a // UnreceivedAcks returns all the unreceived IBC acknowledgements associated with a
// channel and sequences. // channel and sequences.
rpc UnreceivedAcks(QueryUnreceivedAcksRequest) returns (QueryUnreceivedAcksResponse) { rpc UnreceivedAcks(QueryUnreceivedAcksRequest) returns (QueryUnreceivedAcksResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/" option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/"
"{packet_ack_sequences}/unreceived_acks"; "{packet_ack_sequences}/unreceived_acks";
} }
// NextSequenceReceive returns the next receive sequence for a given channel. // NextSequenceReceive returns the next receive sequence for a given channel.
rpc NextSequenceReceive(QueryNextSequenceReceiveRequest) returns (QueryNextSequenceReceiveResponse) { rpc NextSequenceReceive(QueryNextSequenceReceiveRequest) returns (QueryNextSequenceReceiveResponse) {
option (google.api.http).get = "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence"; option (google.api.http).get = "/ibc/core/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence";
} }
} }

8
proto/ibc/core/client/v1/query.proto
View File

@ -13,25 +13,25 @@ option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/types";
service Query { service Query {
// ClientState queries an IBC light client. // ClientState queries an IBC light client.
rpc ClientState(QueryClientStateRequest) returns (QueryClientStateResponse) { rpc ClientState(QueryClientStateRequest) returns (QueryClientStateResponse) {
option (google.api.http).get = "/ibc/client/v1beta1/client_states/{client_id}"; option (google.api.http).get = "/ibc/core/client/v1beta1/client_states/{client_id}";
} }
// ClientStates queries all the IBC light clients of a chain. // ClientStates queries all the IBC light clients of a chain.
rpc ClientStates(QueryClientStatesRequest) returns (QueryClientStatesResponse) { rpc ClientStates(QueryClientStatesRequest) returns (QueryClientStatesResponse) {
option (google.api.http).get = "/ibc/client/v1beta1/client_states"; option (google.api.http).get = "/ibc/core/client/v1beta1/client_states";
} }
// ConsensusState queries a consensus state associated with a client state at // ConsensusState queries a consensus state associated with a client state at
// a given height. // a given height.
rpc ConsensusState(QueryConsensusStateRequest) returns (QueryConsensusStateResponse) { rpc ConsensusState(QueryConsensusStateRequest) returns (QueryConsensusStateResponse) {
option (google.api.http).get = "/ibc/client/v1beta1/consensus_states/{client_id}/version/{version_number}/" option (google.api.http).get = "/ibc/core/client/v1beta1/consensus_states/{client_id}/version/{version_number}/"
"height/{version_height}"; "height/{version_height}";
} }
// ConsensusStates queries all the consensus state associated with a given // ConsensusStates queries all the consensus state associated with a given
// client. // client.
rpc ConsensusStates(QueryConsensusStatesRequest) returns (QueryConsensusStatesResponse) { rpc ConsensusStates(QueryConsensusStatesRequest) returns (QueryConsensusStatesResponse) {
option (google.api.http).get = "/ibc/client/v1beta1/consensus_states/{client_id}"; option (google.api.http).get = "/ibc/core/client/v1beta1/consensus_states/{client_id}";
} }
} }

38
proto/ibc/core/commitment/v1/commitment.proto
View File

@ -4,7 +4,7 @@ package ibc.core.commitment.v1;
option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types"; option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types";
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "tendermint/crypto/proof.proto"; import "confio/proofs.proto";
// MerkleRoot defines a merkle root hash. // MerkleRoot defines a merkle root hash.
// In the Cosmos SDK, the AppHash of a block header becomes the root. // In the Cosmos SDK, the AppHash of a block header becomes the root.
@ -23,42 +23,18 @@ message MerklePrefix {
// MerklePath is the path used to verify commitment proofs, which can be an // MerklePath is the path used to verify commitment proofs, which can be an
// arbitrary structured object (defined by a commitment type). // arbitrary structured object (defined by a commitment type).
// MerklePath is represented from root-to-leaf
message MerklePath { message MerklePath {
option (gogoproto.goproto_stringer) = false; option (gogoproto.goproto_stringer) = false;
KeyPath key_path = 1 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"key_path\""]; repeated string key_path = 1 [(gogoproto.moretags) = "yaml:\"key_path\""];
} }
// MerkleProof is a wrapper type that contains a merkle proof. // MerkleProof is a wrapper type over a chain of CommitmentProofs.
// It demonstrates membership or non-membership for an element or set of // It demonstrates membership or non-membership for an element or set of
// elements, verifiable in conjunction with a known commitment root. Proofs // elements, verifiable in conjunction with a known commitment root. Proofs
// should be succinct. // should be succinct.
// MerkleProofs are ordered from leaf-to-root
message MerkleProof { message MerkleProof {
tendermint.crypto.ProofOps proof = 1; repeated ics23.CommitmentProof proofs = 1;
} }
// KeyPath defines a slice of keys
message KeyPath {
option (gogoproto.goproto_stringer) = false;
option (gogoproto.goproto_getters) = false;
repeated Key keys = 1;
}
// Key defines a proof Key
message Key {
option (gogoproto.goproto_getters) = false;
bytes name = 1;
KeyEncoding enc = 2;
}
// KeyEncoding defines the encoding format of a key's bytes.
enum KeyEncoding {
option (gogoproto.goproto_enum_prefix) = false;
// URL encoding
KEY_ENCODING_URL_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "URL"];
// Hex encoding
KEY_ENCODING_HEX = 1 [(gogoproto.enumvalue_customname) = "HEX"];
}

10
proto/ibc/core/connection/v1/query.proto
View File

@ -14,30 +14,30 @@ option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/core/03-connection/types
service Query { service Query {
// Connection queries an IBC connection end. // Connection queries an IBC connection end.
rpc Connection(QueryConnectionRequest) returns (QueryConnectionResponse) { rpc Connection(QueryConnectionRequest) returns (QueryConnectionResponse) {
option (google.api.http).get = "/ibc/connection/v1beta1/connections/{connection_id}"; option (google.api.http).get = "/ibc/core/connection/v1beta1/connections/{connection_id}";
} }
// Connections queries all the IBC connections of a chain. // Connections queries all the IBC connections of a chain.
rpc Connections(QueryConnectionsRequest) returns (QueryConnectionsResponse) { rpc Connections(QueryConnectionsRequest) returns (QueryConnectionsResponse) {
option (google.api.http).get = "/ibc/connection/v1beta1/connections"; option (google.api.http).get = "/ibc/core/connection/v1beta1/connections";
} }
// ClientConnections queries the connection paths associated with a client // ClientConnections queries the connection paths associated with a client
// state. // state.
rpc ClientConnections(QueryClientConnectionsRequest) returns (QueryClientConnectionsResponse) { rpc ClientConnections(QueryClientConnectionsRequest) returns (QueryClientConnectionsResponse) {
option (google.api.http).get = "/ibc/connection/v1beta1/client_connections/{client_id}"; option (google.api.http).get = "/ibc/core/connection/v1beta1/client_connections/{client_id}";
} }
// ConnectionClientState queries the client state associated with the // ConnectionClientState queries the client state associated with the
// connection. // connection.
rpc ConnectionClientState(QueryConnectionClientStateRequest) returns (QueryConnectionClientStateResponse) { rpc ConnectionClientState(QueryConnectionClientStateRequest) returns (QueryConnectionClientStateResponse) {
option (google.api.http).get = "/ibc/connection/v1beta1/connections/{connection_id}/client_state"; option (google.api.http).get = "/ibc/core/connection/v1beta1/connections/{connection_id}/client_state";
} }
// ConnectionConsensusState queries the consensus state associated with the // ConnectionConsensusState queries the consensus state associated with the
// connection. // connection.
rpc ConnectionConsensusState(QueryConnectionConsensusStateRequest) returns (QueryConnectionConsensusStateResponse) { rpc ConnectionConsensusState(QueryConnectionConsensusStateRequest) returns (QueryConnectionConsensusStateResponse) {
option (google.api.http).get = "/ibc/connection/v1beta1/connections/{connection_id}/consensus_state/" option (google.api.http).get = "/ibc/core/connection/v1beta1/connections/{connection_id}/consensus_state/"
"version/{version_number}/height/{version_height}"; "version/{version_number}/height/{version_height}";
} }
} }

17
server/start.go
View File

@ -252,12 +252,20 @@ func startInProcess(ctx *Context, clientCtx client.Context, appCreator types.App
} }
ctx.Logger.Debug("Initialization: tmNode started") ctx.Logger.Debug("Initialization: tmNode started")
// Add the tx service to the gRPC router. config := config.GetConfig(ctx.Viper)
app.RegisterTxService(clientCtx)
// Add the tx service to the gRPC router. We only need to register this
// service if API or gRPC is enabled, and avoid doing so in the general
// case, because it spawns a new local tendermint RPC client.
if config.API.Enable || config.GRPC.Enable {
clientCtx = clientCtx.
WithClient(local.New(tmNode))
app.RegisterTxService(clientCtx)
}
var apiSrv *api.Server var apiSrv *api.Server
config := config.GetConfig(ctx.Viper)
if config.API.Enable { if config.API.Enable {
genDoc, err := genDocProvider() genDoc, err := genDocProvider()
if err != nil { if err != nil {
@ -266,8 +274,7 @@ func startInProcess(ctx *Context, clientCtx client.Context, appCreator types.App
clientCtx := clientCtx. clientCtx := clientCtx.
WithHomeDir(home). WithHomeDir(home).
WithChainID(genDoc.ChainID). WithChainID(genDoc.ChainID)
WithClient(local.New(tmNode))
apiSrv = api.New(clientCtx, ctx.Logger.With("module", "api-server")) apiSrv = api.New(clientCtx, ctx.Logger.With("module", "api-server"))
app.RegisterAPIRoutes(apiSrv, config.API) app.RegisterAPIRoutes(apiSrv, config.API)

2
x/ibc/applications/transfer/keeper/relay_test.go
View File

@ -109,7 +109,7 @@ func (suite *KeeperTestSuite) TestSendTransfer() {
packet := channeltypes.NewPacket(fungibleTokenPacket.GetBytes(), 1, channelB.PortID, channelB.ID, channelA.PortID, channelA.ID, clienttypes.NewHeight(0, 110), 0) packet := channeltypes.NewPacket(fungibleTokenPacket.GetBytes(), 1, channelB.PortID, channelB.ID, channelA.PortID, channelA.ID, clienttypes.NewHeight(0, 110), 0)
// get proof of packet commitment from chainB // get proof of packet commitment from chainB
packetKey := host.KeyPacketCommitment(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence()) packetKey := host.PacketCommitmentKey(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
proof, proofHeight := suite.chainB.QueryProof(packetKey) proof, proofHeight := suite.chainB.QueryProof(packetKey)
recvMsg := channeltypes.NewMsgRecvPacket(packet, proof, proofHeight, suite.chainA.SenderAccount.GetAddress()) recvMsg := channeltypes.NewMsgRecvPacket(packet, proof, proofHeight, suite.chainA.SenderAccount.GetAddress())

69
x/ibc/applications/transfer/types/query.pb.go
View File

@ -324,41 +324,40 @@ func init() {
} }
var fileDescriptor_a638e2800a01538c = []byte{ var fileDescriptor_a638e2800a01538c = []byte{
// 532 bytes of a gzipped FileDescriptorProto // 528 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x4f, 0x6f, 0xd3, 0x30, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x3f, 0x6f, 0xd3, 0x40,
0x14, 0xaf, 0x37, 0xa8, 0xc4, 0x2b, 0xe2, 0x60, 0x26, 0xa8, 0xa2, 0x2a, 0x9b, 0xa2, 0x0a, 0xca, 0x14, 0xcf, 0x95, 0x12, 0x89, 0x17, 0xc4, 0x70, 0x54, 0x10, 0x59, 0x95, 0x5b, 0x59, 0x08, 0x02,
0x06, 0x36, 0x19, 0x7f, 0x4e, 0x88, 0xc3, 0x84, 0x40, 0xdc, 0x46, 0xe1, 0x80, 0xe0, 0x30, 0x39, 0x85, 0x3b, 0x5c, 0xa0, 0x30, 0xa0, 0x0e, 0x15, 0x02, 0xb1, 0x95, 0xc0, 0x80, 0x60, 0x40, 0x67,
0xa9, 0x49, 0x23, 0xd6, 0x38, 0x8b, 0xdd, 0x8a, 0x09, 0x71, 0xe1, 0x13, 0x20, 0xed, 0x4b, 0x20, 0xe7, 0x70, 0x2c, 0x1a, 0x9f, 0xeb, 0xbb, 0x44, 0x54, 0x88, 0x85, 0x4f, 0x80, 0xc4, 0x8e, 0x98,
0xc4, 0x87, 0xe0, 0xb8, 0xe3, 0x24, 0x2e, 0x9c, 0x00, 0xb5, 0x7c, 0x07, 0xae, 0x28, 0xb6, 0xb3, 0xd9, 0x19, 0xd8, 0x18, 0x3b, 0x56, 0x62, 0x61, 0x02, 0x94, 0xf0, 0x41, 0x90, 0xef, 0xce, 0x8d,
0xa6, 0xea, 0xe8, 0x96, 0x53, 0xad, 0xd7, 0xf7, 0x7b, 0xbf, 0x3f, 0xcf, 0x31, 0x74, 0xe2, 0x20, 0xa3, 0x20, 0x13, 0x4f, 0x39, 0x5d, 0xde, 0xef, 0xfd, 0xfe, 0xbc, 0xe7, 0x83, 0x4e, 0x1c, 0x84,
0xa4, 0x2c, 0x4d, 0x77, 0xe3, 0x90, 0xa9, 0x58, 0x24, 0x92, 0xaa, 0x8c, 0x25, 0xf2, 0x0d, 0xcf, 0x94, 0xa5, 0xe9, 0x5e, 0x1c, 0x32, 0x15, 0x8b, 0x44, 0x52, 0x95, 0xb1, 0x44, 0xbe, 0xe4, 0x19,
0xe8, 0xc8, 0xa7, 0x7b, 0x43, 0x9e, 0xed, 0x93, 0x34, 0x13, 0x4a, 0xe0, 0x56, 0x1c, 0x84, 0xa4, 0x1d, 0xf9, 0x74, 0x7f, 0xc8, 0xb3, 0x03, 0x92, 0x66, 0x42, 0x09, 0xbc, 0x1a, 0x07, 0x21, 0x29,
0xdc, 0x49, 0x8a, 0x4e, 0x32, 0xf2, 0x9d, 0x95, 0x48, 0x44, 0x42, 0x37, 0xd2, 0xfc, 0x64, 0x30, 0x57, 0x92, 0xa2, 0x92, 0x8c, 0x7c, 0x67, 0x25, 0x12, 0x91, 0xd0, 0x85, 0x34, 0x3f, 0x19, 0x8c,
0xce, 0x7a, 0x28, 0xe4, 0x40, 0x48, 0x1a, 0x30, 0xc9, 0xcd, 0x30, 0x3a, 0xf2, 0x03, 0xae, 0x98, 0x73, 0x25, 0x14, 0x72, 0x20, 0x24, 0x0d, 0x98, 0xe4, 0xa6, 0x19, 0x1d, 0xf9, 0x01, 0x57, 0xcc,
0x4f, 0x53, 0x16, 0xc5, 0x89, 0x1e, 0x64, 0x7b, 0x37, 0x16, 0x2a, 0x39, 0xe6, 0x32, 0xcd, 0xad, 0xa7, 0x29, 0x8b, 0xe2, 0x44, 0x37, 0xb2, 0xb5, 0x1b, 0x95, 0x4a, 0x8e, 0xb9, 0x4c, 0xf1, 0x6a,
0x48, 0x88, 0x68, 0x97, 0x53, 0x96, 0xc6, 0x94, 0x25, 0x89, 0x50, 0x56, 0x92, 0xfe, 0xd7, 0xbb, 0x24, 0x44, 0xb4, 0xc7, 0x29, 0x4b, 0x63, 0xca, 0x92, 0x44, 0x28, 0x2b, 0x49, 0xff, 0xeb, 0x5d,
0x09, 0x57, 0x9e, 0xe5, 0x64, 0x8f, 0x78, 0x22, 0x06, 0x2f, 0x32, 0x16, 0xf2, 0x2e, 0xdf, 0x1b, 0x85, 0x73, 0x8f, 0x72, 0xb2, 0x7b, 0x3c, 0x11, 0x83, 0x27, 0x19, 0x0b, 0x79, 0x97, 0xef, 0x0f,
0x72, 0xa9, 0x30, 0x86, 0x73, 0x7d, 0x26, 0xfb, 0x4d, 0xb4, 0x86, 0x3a, 0x17, 0xba, 0xfa, 0xec, 0xb9, 0x54, 0x18, 0xc3, 0x72, 0x9f, 0xc9, 0x7e, 0x1b, 0xad, 0xa3, 0xce, 0xa9, 0xae, 0x3e, 0x7b,
0xf5, 0xe0, 0xea, 0x5c, 0xb7, 0x4c, 0x45, 0x22, 0x39, 0x7e, 0x0a, 0x8d, 0x5e, 0x5e, 0xdd, 0x51, 0x3d, 0x38, 0x3f, 0x57, 0x2d, 0x53, 0x91, 0x48, 0x8e, 0x1f, 0x42, 0xab, 0x97, 0xdf, 0xbe, 0x50,
0x79, 0x59, 0xa3, 0x1a, 0x9b, 0x1d, 0xb2, 0x28, 0x09, 0x52, 0x1a, 0x03, 0xbd, 0xe3, 0xb3, 0xc7, 0xf9, 0xb5, 0x46, 0xb5, 0x36, 0x3b, 0xa4, 0x2a, 0x09, 0x52, 0x6a, 0x03, 0xbd, 0xe3, 0xb3, 0xc7,
0xe6, 0x58, 0x64, 0x21, 0xea, 0x31, 0xc0, 0x34, 0x0d, 0x4b, 0x72, 0x8d, 0x98, 0xe8, 0x48, 0x1e, 0xe6, 0x58, 0x64, 0x21, 0xea, 0x3e, 0xc0, 0x34, 0x0d, 0x4b, 0x72, 0x91, 0x98, 0xe8, 0x48, 0x1e,
0x1d, 0x31, 0x7b, 0xb0, 0xd1, 0x91, 0x6d, 0x16, 0x15, 0x86, 0xba, 0x25, 0xa4, 0xf7, 0x0d, 0x41, 0x1d, 0x31, 0x73, 0xb0, 0xd1, 0x91, 0x5d, 0x16, 0x15, 0x86, 0xba, 0x25, 0xa4, 0xf7, 0x0d, 0x41,
0x73, 0x9e, 0xc3, 0x5a, 0x79, 0x0d, 0x17, 0x4b, 0x56, 0x64, 0x13, 0xad, 0x2d, 0x57, 0xf1, 0xb2, 0x7b, 0x9e, 0xc3, 0x5a, 0x79, 0x0e, 0xa7, 0x4b, 0x56, 0x64, 0x1b, 0xad, 0x9f, 0xa8, 0xe3, 0x65,
0x75, 0xe9, 0xf0, 0xe7, 0x6a, 0xed, 0xcb, 0xaf, 0xd5, 0xba, 0x9d, 0xdb, 0x98, 0x7a, 0x93, 0xf8, 0xe7, 0xcc, 0xe1, 0xcf, 0xb5, 0xc6, 0xe7, 0x5f, 0x6b, 0x4d, 0xdb, 0xb7, 0x35, 0xf5, 0x26, 0xf1,
0xc9, 0x8c, 0x83, 0x25, 0xed, 0xe0, 0xfa, 0xa9, 0x0e, 0x8c, 0xb2, 0x19, 0x0b, 0x2b, 0x80, 0xb5, 0x83, 0x19, 0x07, 0x4b, 0xda, 0xc1, 0xa5, 0xff, 0x3a, 0x30, 0xca, 0x66, 0x2c, 0xac, 0x00, 0xd6,
0x83, 0x6d, 0x96, 0xb1, 0x41, 0x11, 0x90, 0xf7, 0x1c, 0x2e, 0xcf, 0x54, 0xad, 0xa5, 0x07, 0x50, 0x0e, 0x76, 0x59, 0xc6, 0x06, 0x45, 0x40, 0xde, 0x63, 0x38, 0x3b, 0x73, 0x6b, 0x2d, 0xdd, 0x85,
0x4f, 0x75, 0xc5, 0x66, 0xd6, 0x5e, 0x6c, 0xc6, 0xa2, 0x2d, 0x66, 0xf3, 0xef, 0x32, 0x9c, 0xd7, 0x66, 0xaa, 0x6f, 0x6c, 0x66, 0x17, 0xaa, 0xcd, 0x58, 0xb4, 0xc5, 0x6c, 0x7e, 0x5c, 0x86, 0x93,
0x53, 0xf1, 0x57, 0x04, 0x30, 0x75, 0x8a, 0xef, 0x2e, 0x1e, 0x73, 0xf2, 0xcd, 0x72, 0xee, 0x55, 0xba, 0x2b, 0xfe, 0x8a, 0x00, 0xa6, 0x4e, 0xf1, 0xcd, 0xea, 0x36, 0xff, 0xde, 0x2c, 0xe7, 0x56,
0x44, 0x19, 0x0f, 0x9e, 0xff, 0xf1, 0xfb, 0x9f, 0x83, 0xa5, 0x0d, 0x7c, 0x83, 0xc6, 0x41, 0xb8, 0x4d, 0x94, 0xf1, 0xe0, 0x6d, 0xbf, 0xfb, 0xfe, 0xe7, 0xc3, 0xd2, 0x1d, 0xbc, 0x45, 0xab, 0xd6,
0x53, 0xba, 0xf1, 0xe6, 0x2b, 0x29, 0xaf, 0x8c, 0xbe, 0xcf, 0xaf, 0xeb, 0x07, 0xfc, 0x19, 0x41, 0xdf, 0x7c, 0x32, 0xe5, 0xf9, 0xd1, 0x37, 0xf9, 0xee, 0xbe, 0xc5, 0x5f, 0x10, 0xb4, 0x4a, 0xe3,
0xa3, 0xb4, 0x61, 0x5c, 0x8d, 0xb9, 0x08, 0xd5, 0xb9, 0x5f, 0x15, 0x66, 0x15, 0xaf, 0x6b, 0xc5, 0xc6, 0xf5, 0x64, 0x14, 0x09, 0x3b, 0x5b, 0x75, 0x61, 0x56, 0xfe, 0x6d, 0x2d, 0xdf, 0xc7, 0xb4,
0x6d, 0xec, 0x9d, 0xae, 0x18, 0x1f, 0x20, 0xa8, 0x9b, 0xd8, 0xf1, 0xed, 0x33, 0xd0, 0xcd, 0x6c, 0xa6, 0x7c, 0xfc, 0x09, 0x41, 0xd3, 0x0c, 0x04, 0x5f, 0x5f, 0x80, 0x7b, 0x66, 0x1f, 0x1c, 0xbf,
0xdd, 0xf1, 0x2b, 0x20, 0xac, 0xb6, 0xb6, 0xd6, 0xe6, 0xe2, 0xd6, 0xc9, 0xda, 0xcc, 0xe6, 0xb7, 0x06, 0xc2, 0x0a, 0xf5, 0xb5, 0xd0, 0x0d, 0x7c, 0x79, 0x01, 0xa1, 0x66, 0x41, 0x76, 0x9e, 0x1e,
0x5e, 0x1e, 0x8e, 0x5d, 0x74, 0x34, 0x76, 0xd1, 0xef, 0xb1, 0x8b, 0x3e, 0x4d, 0xdc, 0xda, 0xd1, 0x8e, 0x5d, 0x74, 0x34, 0x76, 0xd1, 0xef, 0xb1, 0x8b, 0xde, 0x4f, 0xdc, 0xc6, 0xd1, 0xc4, 0x6d,
0xc4, 0xad, 0xfd, 0x98, 0xb8, 0xb5, 0x57, 0x0f, 0xa3, 0x58, 0xf5, 0x87, 0x01, 0x09, 0xc5, 0x80, 0xfc, 0x98, 0xb8, 0x8d, 0x67, 0xdb, 0x51, 0xac, 0xfa, 0xc3, 0x80, 0x84, 0x62, 0x40, 0xed, 0x0b,
0xda, 0xa7, 0xcb, 0xfc, 0xdc, 0x92, 0xbd, 0xb7, 0xf4, 0x1d, 0xfd, 0xff, 0x13, 0xa5, 0xf6, 0x53, 0x67, 0x7e, 0xae, 0xc9, 0xde, 0x2b, 0xfa, 0xba, 0x82, 0x42, 0x1d, 0xa4, 0x5c, 0x06, 0x4d, 0xfd,
0x2e, 0x83, 0xba, 0x7e, 0x7f, 0xee, 0xfc, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x19, 0x46, 0xdf, 0x94, 0x4c, 0xdd, 0xf8, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xb2, 0x7f, 0xfe, 0xbd, 0x7d, 0x05, 0x00, 0x00,
0x56, 0x05, 0x00, 0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.

6
x/ibc/applications/transfer/types/query.pb.gw.go
View File

@ -310,11 +310,11 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
} }
var ( var (
pattern_Query_DenomTrace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"ibc_transfer", "v1beta1", "denom_traces", "hash"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_DenomTrace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"ibc", "applications", "transfer", "v1beta1", "denom_traces", "hash"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_DenomTraces_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"ibc_transfer", "v1beta1", "denom_traces"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_DenomTraces_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"ibc", "applications", "transfer", "v1beta1", "denom_traces"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"ibc_transfer", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"ibc", "applications", "transfer", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(true)))
) )
var ( var (

4
x/ibc/core/02-client/client/utils/utils.go
View File

@ -38,7 +38,7 @@ func QueryClientState(
func QueryClientStateABCI( func QueryClientStateABCI(
clientCtx client.Context, clientID string, clientCtx client.Context, clientID string,
) (*types.QueryClientStateResponse, error) { ) (*types.QueryClientStateResponse, error) {
key := host.FullKeyClientPath(clientID, host.KeyClientState()) key := host.FullClientStateKey(clientID)
value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key) value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key)
if err != nil { if err != nil {
@ -91,7 +91,7 @@ func QueryConsensusState(
func QueryConsensusStateABCI( func QueryConsensusStateABCI(
clientCtx client.Context, clientID string, height exported.Height, clientCtx client.Context, clientID string, height exported.Height,
) (*types.QueryConsensusStateResponse, error) { ) (*types.QueryConsensusStateResponse, error) {
key := host.FullKeyClientPath(clientID, host.KeyConsensusState(height)) key := host.FullConsensusStateKey(clientID, height)
value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key) value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key)
if err != nil { if err != nil {

2
x/ibc/core/02-client/keeper/grpc_query.go
View File

@ -152,7 +152,7 @@ func (q Keeper) ConsensusStates(c context.Context, req *types.QueryConsensusStat
ctx := sdk.UnwrapSDKContext(c) ctx := sdk.UnwrapSDKContext(c)
consensusStates := []types.ConsensusStateWithHeight{} consensusStates := []types.ConsensusStateWithHeight{}
store := prefix.NewStore(ctx.KVStore(q.storeKey), host.FullKeyClientPath(req.ClientId, []byte(fmt.Sprintf("%s/", host.KeyConsensusStatesPrefix)))) store := prefix.NewStore(ctx.KVStore(q.storeKey), host.FullClientKey(req.ClientId, []byte(fmt.Sprintf("%s/", host.KeyConsensusStatePrefix))))
pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error { pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error {
height, err := types.ParseHeight(string(key)) height, err := types.ParseHeight(string(key))

18
x/ibc/core/02-client/keeper/keeper.go
View File

@ -46,7 +46,7 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger {
// GetClientState gets a particular client from the store // GetClientState gets a particular client from the store
func (k Keeper) GetClientState(ctx sdk.Context, clientID string) (exported.ClientState, bool) { func (k Keeper) GetClientState(ctx sdk.Context, clientID string) (exported.ClientState, bool) {
store := k.ClientStore(ctx, clientID) store := k.ClientStore(ctx, clientID)
bz := store.Get(host.KeyClientState()) bz := store.Get(host.ClientStateKey())
if bz == nil { if bz == nil {
return nil, false return nil, false
} }
@ -58,13 +58,13 @@ func (k Keeper) GetClientState(ctx sdk.Context, clientID string) (exported.Clien
// SetClientState sets a particular Client to the store // SetClientState sets a particular Client to the store
func (k Keeper) SetClientState(ctx sdk.Context, clientID string, clientState exported.ClientState) { func (k Keeper) SetClientState(ctx sdk.Context, clientID string, clientState exported.ClientState) {
store := k.ClientStore(ctx, clientID) store := k.ClientStore(ctx, clientID)
store.Set(host.KeyClientState(), k.MustMarshalClientState(clientState)) store.Set(host.ClientStateKey(), k.MustMarshalClientState(clientState))
} }
// GetClientConsensusState gets the stored consensus state from a client at a given height. // GetClientConsensusState gets the stored consensus state from a client at a given height.
func (k Keeper) GetClientConsensusState(ctx sdk.Context, clientID string, height exported.Height) (exported.ConsensusState, bool) { func (k Keeper) GetClientConsensusState(ctx sdk.Context, clientID string, height exported.Height) (exported.ConsensusState, bool) {
store := k.ClientStore(ctx, clientID) store := k.ClientStore(ctx, clientID)
bz := store.Get(host.KeyConsensusState(height)) bz := store.Get(host.ConsensusStateKey(height))
if bz == nil { if bz == nil {
return nil, false return nil, false
} }
@ -77,7 +77,7 @@ func (k Keeper) GetClientConsensusState(ctx sdk.Context, clientID string, height
// height // height
func (k Keeper) SetClientConsensusState(ctx sdk.Context, clientID string, height exported.Height, consensusState exported.ConsensusState) { func (k Keeper) SetClientConsensusState(ctx sdk.Context, clientID string, height exported.Height, consensusState exported.ConsensusState) {
store := k.ClientStore(ctx, clientID) store := k.ClientStore(ctx, clientID)
store.Set(host.KeyConsensusState(height), k.MustMarshalConsensusState(consensusState)) store.Set(host.ConsensusStateKey(height), k.MustMarshalConsensusState(consensusState))
} }
// IterateConsensusStates provides an iterator over all stored consensus states. // IterateConsensusStates provides an iterator over all stored consensus states.
@ -91,7 +91,7 @@ func (k Keeper) IterateConsensusStates(ctx sdk.Context, cb func(clientID string,
for ; iterator.Valid(); iterator.Next() { for ; iterator.Valid(); iterator.Next() {
keySplit := strings.Split(string(iterator.Key()), "/") keySplit := strings.Split(string(iterator.Key()), "/")
// consensus key is in the format "clients/<clientID>/consensusStates/<height>" // consensus key is in the format "clients/<clientID>/consensusStates/<height>"
if len(keySplit) != 4 || keySplit[2] != string(host.KeyConsensusStatesPrefix) { if len(keySplit) != 4 || keySplit[2] != string(host.KeyConsensusStatePrefix) {
continue continue
} }
clientID := keySplit[1] clientID := keySplit[1]
@ -144,7 +144,7 @@ func (k Keeper) GetAllConsensusStates(ctx sdk.Context) types.ClientsConsensusSta
// client at the given height // client at the given height
func (k Keeper) HasClientConsensusState(ctx sdk.Context, clientID string, height exported.Height) bool { func (k Keeper) HasClientConsensusState(ctx sdk.Context, clientID string, height exported.Height) bool {
store := k.ClientStore(ctx, clientID) store := k.ClientStore(ctx, clientID)
return store.Has(host.KeyConsensusState(height)) return store.Has(host.ConsensusStateKey(height))
} }
// GetLatestClientConsensusState gets the latest ConsensusState stored for a given client // GetLatestClientConsensusState gets the latest ConsensusState stored for a given client
@ -266,7 +266,7 @@ func (k Keeper) IterateClients(ctx sdk.Context, cb func(clientID string, cs expo
defer iterator.Close() defer iterator.Close()
for ; iterator.Valid(); iterator.Next() { for ; iterator.Valid(); iterator.Next() {
keySplit := strings.Split(string(iterator.Key()), "/") keySplit := strings.Split(string(iterator.Key()), "/")
if keySplit[len(keySplit)-1] != "clientState" { if keySplit[len(keySplit)-1] != host.KeyClientState {
continue continue
} }
clientState := k.MustUnmarshalClientState(iterator.Value()) clientState := k.MustUnmarshalClientState(iterator.Value())
@ -291,8 +291,6 @@ func (k Keeper) GetAllClients(ctx sdk.Context) (states []exported.ClientState) {
// ClientStore returns isolated prefix store for each client so they can read/write in separate // ClientStore returns isolated prefix store for each client so they can read/write in separate
// namespace without being able to read/write other client's data // namespace without being able to read/write other client's data
func (k Keeper) ClientStore(ctx sdk.Context, clientID string) sdk.KVStore { func (k Keeper) ClientStore(ctx sdk.Context, clientID string) sdk.KVStore {
// append here is safe, appends within a function won't cause clientPrefix := []byte(fmt.Sprintf("%s/%s/", host.KeyClientStorePrefix, clientID))
// weird side effects when its singlethreaded
clientPrefix := append([]byte("clients/"+clientID), '/')
return prefix.NewStore(ctx.KVStore(k.storeKey), clientPrefix) return prefix.NewStore(ctx.KVStore(k.storeKey), clientPrefix)
} }

4
x/ibc/core/02-client/simulation/decoder.go
View File

@ -22,12 +22,12 @@ type ClientUnmarshaler interface {
// Value to the corresponding client type. // Value to the corresponding client type.
func NewDecodeStore(cdc ClientUnmarshaler, kvA, kvB kv.Pair) (string, bool) { func NewDecodeStore(cdc ClientUnmarshaler, kvA, kvB kv.Pair) (string, bool) {
switch { switch {
case bytes.HasPrefix(kvA.Key, host.KeyClientStorePrefix) && bytes.HasSuffix(kvA.Key, host.KeyClientState()): case bytes.HasPrefix(kvA.Key, host.KeyClientStorePrefix) && bytes.HasSuffix(kvA.Key, []byte(host.KeyClientState)):
clientStateA := cdc.MustUnmarshalClientState(kvA.Value) clientStateA := cdc.MustUnmarshalClientState(kvA.Value)
clientStateB := cdc.MustUnmarshalClientState(kvB.Value) clientStateB := cdc.MustUnmarshalClientState(kvB.Value)
return fmt.Sprintf("ClientState A: %v\nClientState B: %v", clientStateA, clientStateB), true return fmt.Sprintf("ClientState A: %v\nClientState B: %v", clientStateA, clientStateB), true
case bytes.HasPrefix(kvA.Key, host.KeyClientStorePrefix) && bytes.Contains(kvA.Key, []byte("consensusState")): case bytes.HasPrefix(kvA.Key, host.KeyClientStorePrefix) && bytes.Contains(kvA.Key, []byte(host.KeyConsensusStatePrefix)):
consensusStateA := cdc.MustUnmarshalConsensusState(kvA.Value) consensusStateA := cdc.MustUnmarshalConsensusState(kvA.Value)
consensusStateB := cdc.MustUnmarshalConsensusState(kvB.Value) consensusStateB := cdc.MustUnmarshalConsensusState(kvB.Value)
return fmt.Sprintf("ConsensusState A: %v\nConsensusState B: %v", consensusStateA, consensusStateB), true return fmt.Sprintf("ConsensusState A: %v\nConsensusState B: %v", consensusStateA, consensusStateB), true

4
x/ibc/core/02-client/simulation/decoder_test.go
View File

@ -32,11 +32,11 @@ func TestDecodeStore(t *testing.T) {
kvPairs := kv.Pairs{ kvPairs := kv.Pairs{
Pairs: []kv.Pair{ Pairs: []kv.Pair{
{ {
Key: host.FullKeyClientPath(clientID, host.KeyClientState()), Key: host.FullClientStateKey(clientID),
Value: app.IBCKeeper.ClientKeeper.MustMarshalClientState(clientState), Value: app.IBCKeeper.ClientKeeper.MustMarshalClientState(clientState),
}, },
{ {
Key: host.FullKeyClientPath(clientID, host.KeyConsensusState(height)), Key: host.FullConsensusStateKey(clientID, height),
Value: app.IBCKeeper.ClientKeeper.MustMarshalConsensusState(consState), Value: app.IBCKeeper.ClientKeeper.MustMarshalConsensusState(consState),
}, },
{ {

96
x/ibc/core/02-client/types/query.pb.go
View File

@ -514,54 +514,54 @@ func init() {
func init() { proto.RegisterFile("ibc/core/client/v1/query.proto", fileDescriptor_dc42cdfd1d52d76e) } func init() { proto.RegisterFile("ibc/core/client/v1/query.proto", fileDescriptor_dc42cdfd1d52d76e) }
var fileDescriptor_dc42cdfd1d52d76e = []byte{ var fileDescriptor_dc42cdfd1d52d76e = []byte{
// 747 bytes of a gzipped FileDescriptorProto // 746 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4f, 0x4f, 0x13, 0x41, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4d, 0x6b, 0x13, 0x4f,
0x14, 0xef, 0xf0, 0xc7, 0xc0, 0xb4, 0x80, 0x99, 0x90, 0x58, 0x16, 0x52, 0x6a, 0x89, 0x5a, 0x94, 0x18, 0xcf, 0xf4, 0xe5, 0x4f, 0x3b, 0x49, 0xdb, 0x3f, 0x43, 0xc1, 0x74, 0x5b, 0xb6, 0x21, 0x62,
0xce, 0xd0, 0x1a, 0xc5, 0x8b, 0x07, 0x21, 0x41, 0xb9, 0x10, 0x59, 0x0f, 0x26, 0x26, 0x86, 0xec, 0x8d, 0xda, 0xce, 0x34, 0xf1, 0xa5, 0x20, 0xf4, 0x60, 0x0b, 0xd5, 0x5e, 0x8a, 0x5d, 0x0f, 0x82,
0x6e, 0x87, 0xed, 0x44, 0xd8, 0x29, 0x9d, 0x69, 0x23, 0x21, 0x5c, 0xf8, 0x04, 0x26, 0x26, 0x5e, 0x20, 0x65, 0x77, 0x33, 0xd9, 0x2c, 0xb6, 0x3b, 0x69, 0x66, 0x12, 0x2c, 0xa5, 0x97, 0x7e, 0x02,
0xfd, 0x02, 0x86, 0x93, 0x89, 0xdf, 0xc0, 0x70, 0x24, 0x7a, 0xf1, 0x60, 0x8c, 0x01, 0x3f, 0x88, 0xc1, 0xa3, 0x57, 0x8f, 0xe2, 0x45, 0xc1, 0x6f, 0x20, 0x3d, 0x16, 0xbc, 0x78, 0x12, 0x6d, 0xc5,
0xe9, 0xcc, 0x2c, 0xdd, 0x85, 0x25, 0xac, 0x46, 0x4f, 0x3b, 0xf3, 0xfe, 0xfe, 0xde, 0xef, 0xbd, 0xcf, 0x21, 0x3b, 0x33, 0xdb, 0xec, 0x36, 0x5b, 0x5c, 0x8a, 0x9e, 0xb2, 0xfb, 0xbc, 0xfe, 0x9e,
0x79, 0x59, 0x58, 0x60, 0xae, 0x47, 0x3c, 0xde, 0xa2, 0xc4, 0xdb, 0x64, 0x34, 0x90, 0xa4, 0x53, 0xdf, 0xef, 0xd9, 0x87, 0x40, 0xd3, 0x77, 0x5c, 0xe2, 0xb2, 0x36, 0x25, 0xee, 0xb6, 0x4f, 0x03,
0x25, 0xdb, 0x6d, 0xda, 0xda, 0xc1, 0xcd, 0x16, 0x97, 0x1c, 0x21, 0xe6, 0x7a, 0xb8, 0xab, 0xc7, 0x41, 0xba, 0x55, 0xb2, 0xdb, 0xa1, 0xed, 0x3d, 0xdc, 0x6a, 0x33, 0xc1, 0x10, 0xf2, 0x1d, 0x17,
0x5a, 0x8f, 0x3b, 0x55, 0xeb, 0xb6, 0xc7, 0xc5, 0x16, 0x17, 0xc4, 0x75, 0x04, 0xd5, 0xc6, 0xa4, 0x87, 0x7e, 0xac, 0xfc, 0xb8, 0x5b, 0x35, 0x6e, 0xba, 0x8c, 0xef, 0x30, 0x4e, 0x1c, 0x9b, 0x53,
0x53, 0x75, 0xa9, 0x74, 0xaa, 0xa4, 0xe9, 0xf8, 0x2c, 0x70, 0x24, 0xe3, 0x81, 0xf6, 0xb7, 0xa6, 0x15, 0x4c, 0xba, 0x55, 0x87, 0x0a, 0xbb, 0x4a, 0x5a, 0xb6, 0xe7, 0x07, 0xb6, 0xf0, 0x59, 0xa0,
0x13, 0xe2, 0x9b, 0x48, 0xda, 0x60, 0xc2, 0xe7, 0xdc, 0xdf, 0xa4, 0x44, 0xdd, 0xdc, 0xf6, 0x06, 0xf2, 0x8d, 0xd9, 0x94, 0xfa, 0xba, 0x92, 0x0a, 0x98, 0xf2, 0x18, 0xf3, 0xb6, 0x29, 0x91, 0x6f,
0x71, 0x02, 0x93, 0xdb, 0x9a, 0x32, 0x2a, 0xa7, 0xc9, 0x88, 0x13, 0x04, 0x5c, 0xaa, 0xc0, 0xc2, 0x4e, 0xa7, 0x41, 0xec, 0x40, 0xf7, 0x36, 0x66, 0xb4, 0xcb, 0x6e, 0xf9, 0xc4, 0x0e, 0x02, 0x26,
0x68, 0xc7, 0x7d, 0xee, 0x73, 0x75, 0x24, 0xdd, 0x93, 0x96, 0x96, 0xee, 0xc3, 0x6b, 0x6b, 0x5d, 0x64, 0x61, 0xae, 0xbd, 0x93, 0x1e, 0xf3, 0x98, 0x7c, 0x24, 0xe1, 0x93, 0xb2, 0x96, 0xef, 0xc1,
0x44, 0x4b, 0x2a, 0xc7, 0x33, 0xe9, 0x48, 0x6a, 0xd3, 0xed, 0x36, 0x15, 0x12, 0x4d, 0xc2, 0x61, 0x2b, 0x9b, 0x21, 0xa2, 0x55, 0xd9, 0xe3, 0x89, 0xb0, 0x05, 0xb5, 0xe8, 0x6e, 0x87, 0x72, 0x81,
0x9d, 0x79, 0x9d, 0xd5, 0xf3, 0xa0, 0x08, 0xca, 0xc3, 0xf6, 0x90, 0x16, 0xac, 0xd4, 0x4b, 0x07, 0xa6, 0xe1, 0xa8, 0xea, 0xbc, 0xe5, 0xd7, 0x8b, 0xa0, 0x04, 0x2a, 0xa3, 0xd6, 0x88, 0x32, 0xac,
0x00, 0xe6, 0xcf, 0x3b, 0x8a, 0x26, 0x0f, 0x04, 0x45, 0x0b, 0x30, 0x67, 0x3c, 0x45, 0x57, 0xae, 0xd7, 0xcb, 0xef, 0x01, 0x2c, 0xf6, 0x27, 0xf2, 0x16, 0x0b, 0x38, 0x45, 0x4b, 0xb0, 0xa0, 0x33,
0x9c, 0xb3, 0xb5, 0x71, 0xac, 0xf1, 0xe1, 0x10, 0x3a, 0x7e, 0x14, 0xec, 0xd8, 0x59, 0xaf, 0x17, 0x79, 0x68, 0x97, 0xc9, 0xf9, 0xda, 0x24, 0x56, 0xf8, 0x70, 0x04, 0x1d, 0x3f, 0x08, 0xf6, 0xac,
0x00, 0x8d, 0xc3, 0xc1, 0x66, 0x8b, 0xf3, 0x8d, 0x7c, 0x5f, 0x11, 0x94, 0x73, 0xb6, 0xbe, 0xa0, 0xbc, 0xdb, 0x2b, 0x80, 0x26, 0xe1, 0x70, 0xab, 0xcd, 0x58, 0xa3, 0x38, 0x50, 0x02, 0x95, 0x82,
0x25, 0x98, 0x53, 0x87, 0xf5, 0x06, 0x65, 0x7e, 0x43, 0xe6, 0xfb, 0x55, 0x38, 0x0b, 0x9f, 0xa7, 0xa5, 0x5e, 0xd0, 0x2a, 0x2c, 0xc8, 0x87, 0xad, 0x26, 0xf5, 0xbd, 0xa6, 0x28, 0x0e, 0xca, 0x72,
0x1a, 0x3f, 0x51, 0x16, 0x8b, 0x03, 0x87, 0x3f, 0xa6, 0x33, 0x76, 0x56, 0x79, 0x69, 0x51, 0xc9, 0x06, 0xee, 0xa7, 0x1a, 0x3f, 0x92, 0x11, 0x2b, 0x43, 0x47, 0xdf, 0x66, 0x73, 0x56, 0x5e, 0x66,
0x3d, 0x8f, 0x57, 0x84, 0x95, 0x2e, 0x43, 0xd8, 0x6b, 0x84, 0x41, 0x7b, 0x13, 0xeb, 0xae, 0xe1, 0x29, 0x53, 0xd9, 0xe9, 0xc7, 0xcb, 0xa3, 0x49, 0xd7, 0x20, 0xec, 0x09, 0xa1, 0xd1, 0xce, 0x61,
0x6e, 0xd7, 0xb0, 0x6e, 0xb1, 0xe9, 0x1a, 0x7e, 0xea, 0xf8, 0x21, 0x4b, 0x76, 0xc4, 0xb3, 0xf4, 0xa5, 0x1a, 0x0e, 0x55, 0xc3, 0x4a, 0x62, 0xad, 0x1a, 0x7e, 0x6c, 0x7b, 0x11, 0x4b, 0x56, 0x2c,
0x11, 0xc0, 0x89, 0x84, 0x24, 0x86, 0x95, 0x55, 0x38, 0x12, 0x65, 0x45, 0xe4, 0x41, 0xb1, 0xbf, 0xb3, 0xfc, 0x11, 0xc0, 0xa9, 0x94, 0x26, 0x9a, 0x95, 0x0d, 0x38, 0x16, 0x67, 0x85, 0x17, 0x41,
0x9c, 0xad, 0xcd, 0x26, 0xd5, 0xb1, 0x52, 0xa7, 0x81, 0x64, 0x1b, 0x8c, 0xd6, 0xa3, 0xfc, 0xe6, 0x69, 0xb0, 0x92, 0xaf, 0xdd, 0x48, 0x9b, 0x63, 0xbd, 0x4e, 0x03, 0xe1, 0x37, 0x7c, 0x5a, 0x8f,
0x22, 0x5c, 0x09, 0xf4, 0x38, 0x86, 0xba, 0x4f, 0xa1, 0xbe, 0x75, 0x29, 0x6a, 0x0d, 0x26, 0x06, 0xf3, 0x5b, 0x88, 0x71, 0xc5, 0xd1, 0xc3, 0x04, 0xea, 0x01, 0x89, 0xfa, 0xfa, 0x1f, 0x51, 0x2b,
0xfb, 0x03, 0x80, 0x96, 0x86, 0xdd, 0x55, 0x05, 0xa2, 0x2d, 0x52, 0xcf, 0x01, 0xba, 0x01, 0x47, 0x30, 0x09, 0xd8, 0xef, 0x00, 0x34, 0x14, 0xec, 0xd0, 0x15, 0xf0, 0x0e, 0xcf, 0xbc, 0x07, 0xe8,
0x3b, 0xb4, 0x25, 0x18, 0x0f, 0xd6, 0x83, 0xf6, 0x96, 0x4b, 0x5b, 0x0a, 0xc8, 0x80, 0x3d, 0x62, 0x1a, 0x1c, 0xef, 0xd2, 0x36, 0xf7, 0x59, 0xb0, 0x15, 0x74, 0x76, 0x1c, 0xda, 0x96, 0x40, 0x86,
0xa4, 0xab, 0x4a, 0x18, 0x35, 0x8b, 0x34, 0xb1, 0x67, 0xa6, 0x9b, 0x84, 0x66, 0xe0, 0xc8, 0x66, 0xac, 0x31, 0x6d, 0xdd, 0x90, 0xc6, 0x78, 0x58, 0x4c, 0xc4, 0x5e, 0x98, 0x12, 0x09, 0x5d, 0x85,
0xb7, 0x36, 0x19, 0x5a, 0x0d, 0x14, 0x41, 0x79, 0xc8, 0xce, 0x69, 0xa1, 0xe9, 0xe4, 0x27, 0x00, 0x63, 0xdb, 0xe1, 0x6c, 0x22, 0x8a, 0x1a, 0x2a, 0x81, 0xca, 0x88, 0x55, 0x50, 0x46, 0xad, 0xe4,
0x27, 0x13, 0xe1, 0x1a, 0x9e, 0x1f, 0xc2, 0x31, 0x2f, 0xd4, 0xa4, 0x18, 0xc0, 0x51, 0x2f, 0x16, 0x27, 0x00, 0xa7, 0x53, 0xe1, 0x6a, 0x9e, 0x97, 0xe1, 0x84, 0x1b, 0x79, 0x32, 0x2c, 0xe0, 0xb8,
0xe6, 0x7f, 0xce, 0xe0, 0x7e, 0x32, 0x72, 0x91, 0x8a, 0xe9, 0xe5, 0x84, 0x76, 0xff, 0xcd, 0x90, 0x9b, 0x28, 0xf3, 0x2f, 0x77, 0xf0, 0x30, 0x1d, 0x39, 0xcf, 0xc4, 0xf4, 0x5a, 0x8a, 0xdc, 0x97,
0x7e, 0x06, 0x70, 0x2a, 0x19, 0x84, 0xe1, 0xef, 0x25, 0xbc, 0x7a, 0x86, 0xbf, 0x70, 0x54, 0xe7, 0x59, 0xd2, 0xcf, 0x00, 0xce, 0xa4, 0x83, 0xd0, 0xfc, 0x3d, 0x87, 0xff, 0x9f, 0xe3, 0x2f, 0x5a,
0x92, 0xca, 0x8d, 0x87, 0x79, 0xce, 0x64, 0x23, 0x46, 0xc0, 0x58, 0x9c, 0xde, 0x7f, 0x37, 0xb6, 0xd5, 0xf9, 0xb4, 0x71, 0x93, 0x65, 0x9e, 0xfa, 0xa2, 0x99, 0x20, 0x60, 0x22, 0x49, 0xef, 0xdf,
0xb5, 0x2f, 0x83, 0x70, 0x50, 0x15, 0x82, 0xde, 0x03, 0x98, 0x8d, 0xbc, 0x13, 0x74, 0x27, 0x09, 0x5b, 0xdb, 0xda, 0xaf, 0x61, 0x38, 0x2c, 0x07, 0x41, 0x6f, 0x01, 0xcc, 0xc7, 0xbe, 0x13, 0x74,
0xe7, 0x05, 0x6b, 0xce, 0x9a, 0x4b, 0x67, 0xac, 0x01, 0x94, 0xee, 0xed, 0x7f, 0xfd, 0xf5, 0xb6, 0x2b, 0x0d, 0xe7, 0x05, 0x67, 0xce, 0x98, 0xcf, 0x16, 0xac, 0x00, 0x94, 0xef, 0x1f, 0x7e, 0xf9,
0x8f, 0xa0, 0x0a, 0x51, 0x8b, 0x3a, 0xdc, 0xd1, 0x7a, 0x9b, 0xc7, 0x9e, 0x37, 0xd9, 0x3d, 0xed, 0xf9, 0x7a, 0xe0, 0x0e, 0xaa, 0x91, 0xfe, 0x43, 0xad, 0x4e, 0x7a, 0xe2, 0x1b, 0x27, 0xfb, 0x67,
0xe5, 0x1e, 0x7a, 0x07, 0x60, 0x2e, 0xba, 0x14, 0x50, 0xaa, 0xac, 0xe1, 0x60, 0x58, 0x95, 0x94, 0x82, 0x1e, 0xa0, 0x37, 0x00, 0x16, 0xe2, 0x97, 0x01, 0x65, 0x6a, 0x1d, 0x6d, 0x87, 0xb1, 0x90,
0xd6, 0x06, 0xe4, 0xac, 0x02, 0x39, 0x83, 0xae, 0x5f, 0x0a, 0x12, 0x7d, 0x07, 0x70, 0x34, 0xde, 0x31, 0x5a, 0x23, 0xc5, 0x12, 0x69, 0x05, 0xcd, 0x65, 0x43, 0x8a, 0x7e, 0x00, 0x38, 0x9e, 0xd4,
0x41, 0x84, 0x2f, 0x4e, 0x96, 0xb4, 0x1f, 0x2c, 0x92, 0xda, 0xde, 0xc0, 0x63, 0x0a, 0x9e, 0x87, 0x12, 0xe1, 0x8b, 0x3b, 0xa6, 0x5d, 0x0a, 0x83, 0x64, 0x8e, 0xd7, 0x18, 0x03, 0x89, 0xb1, 0x89,
0x9c, 0x44, 0x78, 0x67, 0x46, 0x2f, 0x4a, 0x23, 0x31, 0xdb, 0x82, 0xec, 0xc6, 0x77, 0xce, 0x1e, 0x1a, 0x17, 0x63, 0x3c, 0xb7, 0x89, 0x71, 0x42, 0x89, 0x3e, 0x1e, 0x64, 0x3f, 0x79, 0x82, 0x0e,
0xd1, 0xaf, 0xb2, 0x27, 0xd7, 0xf7, 0x3d, 0x74, 0x00, 0xe0, 0xd8, 0x99, 0x39, 0x47, 0x69, 0xf1, 0x88, 0xfa, 0x48, 0x7b, 0x76, 0xf5, 0x7e, 0x80, 0x3e, 0x00, 0x38, 0x71, 0x6e, 0xed, 0x51, 0x56,
0x9e, 0xb2, 0x3f, 0x9f, 0xde, 0xc1, 0x54, 0xf8, 0x40, 0x55, 0x58, 0x43, 0xf3, 0x7f, 0x5a, 0xe1, 0xd0, 0x67, 0x3a, 0x2c, 0x66, 0x4f, 0xd0, 0x63, 0x2e, 0xcb, 0x31, 0x97, 0xd0, 0xdd, 0x4b, 0x8d,
0xe2, 0xda, 0xe1, 0x71, 0x01, 0x1c, 0x1d, 0x17, 0xc0, 0xcf, 0xe3, 0x02, 0x78, 0x73, 0x52, 0xc8, 0xb9, 0xb2, 0x79, 0x74, 0x62, 0x82, 0xe3, 0x13, 0x13, 0x7c, 0x3f, 0x31, 0xc1, 0xab, 0x53, 0x33,
0x1c, 0x9d, 0x14, 0x32, 0xdf, 0x4e, 0x0a, 0x99, 0x17, 0x0b, 0x3e, 0x93, 0x8d, 0xb6, 0x8b, 0x3d, 0x77, 0x7c, 0x6a, 0xe6, 0xbe, 0x9e, 0x9a, 0xb9, 0x67, 0x4b, 0x9e, 0x2f, 0x9a, 0x1d, 0x07, 0xbb,
0xbe, 0x45, 0xcc, 0x0f, 0x85, 0xfe, 0x54, 0x44, 0xfd, 0x15, 0x79, 0x4d, 0x4e, 0x7f, 0x1c, 0xe6, 0x6c, 0x87, 0xe8, 0x3f, 0x19, 0xea, 0x67, 0x81, 0xd7, 0x5f, 0x90, 0x97, 0xbd, 0x76, 0x8b, 0xb5,
0x6b, 0x15, 0x93, 0x51, 0xee, 0x34, 0xa9, 0x70, 0xaf, 0xa8, 0x75, 0x77, 0xf7, 0x77, 0x00, 0x00, 0x05, 0xdd, 0x51, 0xec, 0xb5, 0x28, 0x77, 0xfe, 0x93, 0x27, 0xf0, 0xf6, 0xef, 0x00, 0x00, 0x00,
0x00, 0xff, 0xff, 0x09, 0x8e, 0x83, 0x3d, 0xbb, 0x08, 0x00, 0x00, 0xff, 0xff, 0x71, 0x1f, 0x83, 0xc2, 0xcf, 0x08, 0x00, 0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.

8
x/ibc/core/02-client/types/query.pb.gw.go
View File

@ -520,13 +520,13 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
} }
var ( var (
pattern_Query_ClientState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"ibc", "client", "v1beta1", "client_states", "client_id"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ClientState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"ibc", "core", "client", "v1beta1", "client_states", "client_id"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_ClientStates_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ibc", "client", "v1beta1", "client_states"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ClientStates_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"ibc", "core", "client", "v1beta1", "client_states"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_ConsensusState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7, 1, 0, 4, 1, 5, 8}, []string{"ibc", "client", "v1beta1", "consensus_states", "client_id", "version", "version_number", "height", "version_height"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ConsensusState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8, 1, 0, 4, 1, 5, 9}, []string{"ibc", "core", "client", "v1beta1", "consensus_states", "client_id", "version", "version_number", "height", "version_height"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_ConsensusStates_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"ibc", "client", "v1beta1", "consensus_states", "client_id"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ConsensusStates_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"ibc", "core", "client", "v1beta1", "consensus_states", "client_id"}, "", runtime.AssumeColonVerbOpt(true)))
) )
var ( var (

4
x/ibc/core/03-connection/client/utils/utils.go
View File

@ -38,7 +38,7 @@ func QueryConnection(
} }
func queryConnectionABCI(clientCtx client.Context, connectionID string) (*types.QueryConnectionResponse, error) { func queryConnectionABCI(clientCtx client.Context, connectionID string) (*types.QueryConnectionResponse, error) {
key := host.KeyConnection(connectionID) key := host.ConnectionKey(connectionID)
value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key) value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key)
if err != nil { if err != nil {
@ -79,7 +79,7 @@ func QueryClientConnections(
} }
func queryClientConnectionsABCI(clientCtx client.Context, clientID string) (*types.QueryClientConnectionsResponse, error) { func queryClientConnectionsABCI(clientCtx client.Context, clientID string) (*types.QueryClientConnectionsResponse, error) {
key := host.KeyClientConnections(clientID) key := host.ClientConnectionsKey(clientID)
value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key) value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key)
if err != nil { if err != nil {

2
x/ibc/core/03-connection/keeper/grpc_query.go
View File

@ -51,7 +51,7 @@ func (q Keeper) Connections(c context.Context, req *types.QueryConnectionsReques
ctx := sdk.UnwrapSDKContext(c) ctx := sdk.UnwrapSDKContext(c)
connections := []*types.IdentifiedConnection{} connections := []*types.IdentifiedConnection{}
store := prefix.NewStore(ctx.KVStore(q.storeKey), host.KeyConnectionPrefix) store := prefix.NewStore(ctx.KVStore(q.storeKey), []byte(host.KeyConnectionPrefix))
pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error { pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error {
var result types.ConnectionEnd var result types.ConnectionEnd

20
x/ibc/core/03-connection/keeper/handshake_test.go
View File

@ -306,18 +306,18 @@ func (suite *KeeperTestSuite) TestConnOpenTry() {
counterpartyChosenConnectionID = connection.Counterparty.ConnectionId counterpartyChosenConnectionID = connection.Counterparty.ConnectionId
} }
connectionKey := host.KeyConnection(connA.ID) connectionKey := host.ConnectionKey(connA.ID)
proofInit, proofHeight := suite.chainA.QueryProof(connectionKey) proofInit, proofHeight := suite.chainA.QueryProof(connectionKey)
if consensusHeight.IsZero() { if consensusHeight.IsZero() {
// retrieve consensus state height to provide proof for // retrieve consensus state height to provide proof for
consensusHeight = counterpartyClient.GetLatestHeight() consensusHeight = counterpartyClient.GetLatestHeight()
} }
consensusKey := host.FullKeyClientPath(clientA, host.KeyConsensusState(consensusHeight)) consensusKey := host.FullConsensusStateKey(clientA, consensusHeight)
proofConsensus, _ := suite.chainA.QueryProof(consensusKey) proofConsensus, _ := suite.chainA.QueryProof(consensusKey)
// retrieve proof of counterparty clientstate on chainA // retrieve proof of counterparty clientstate on chainA
clientKey := host.FullKeyClientPath(clientA, host.KeyClientState()) clientKey := host.FullClientStateKey(clientA)
proofClient, _ := suite.chainA.QueryProof(clientKey) proofClient, _ := suite.chainA.QueryProof(clientKey)
err := suite.chainB.App.IBCKeeper.ConnectionKeeper.ConnOpenTry( err := suite.chainB.App.IBCKeeper.ConnectionKeeper.ConnOpenTry(
@ -661,10 +661,10 @@ func (suite *KeeperTestSuite) TestConnOpenAck() {
for _, tc := range testCases { for _, tc := range testCases {
tc := tc tc := tc
suite.Run(tc.msg, func() { suite.Run(tc.msg, func() {
suite.SetupTest() // reset suite.SetupTest() // reset
version = types.ExportedVersionsToProto(types.GetCompatibleVersions())[0] // must be explicitly changed in malleate version = types.ExportedVersionsToProto(types.GetCompatibleVersions())[0] // must be explicitly changed in malleate
consensusHeight = clienttypes.ZeroHeight() // must be explicitly changed in malleate consensusHeight = clienttypes.ZeroHeight() // must be explicitly changed in malleate
counterpartyConnectionID = "" // must be explicitly changed in malleate counterpartyConnectionID = "" // must be explicitly changed in malleate
tc.malleate() tc.malleate()
@ -675,7 +675,7 @@ func (suite *KeeperTestSuite) TestConnOpenAck() {
counterpartyConnectionID = connB.ID counterpartyConnectionID = connB.ID
} }
connectionKey := host.KeyConnection(connB.ID) connectionKey := host.ConnectionKey(connB.ID)
proofTry, proofHeight := suite.chainB.QueryProof(connectionKey) proofTry, proofHeight := suite.chainB.QueryProof(connectionKey)
if consensusHeight.IsZero() { if consensusHeight.IsZero() {
@ -683,11 +683,11 @@ func (suite *KeeperTestSuite) TestConnOpenAck() {
clientState := suite.chainB.GetClientState(clientB) clientState := suite.chainB.GetClientState(clientB)
consensusHeight = clientState.GetLatestHeight() consensusHeight = clientState.GetLatestHeight()
} }
consensusKey := host.FullKeyClientPath(clientB, host.KeyConsensusState(consensusHeight)) consensusKey := host.FullConsensusStateKey(clientB, consensusHeight)
proofConsensus, _ := suite.chainB.QueryProof(consensusKey) proofConsensus, _ := suite.chainB.QueryProof(consensusKey)
// retrieve proof of counterparty clientstate on chainA // retrieve proof of counterparty clientstate on chainA
clientKey := host.FullKeyClientPath(clientB, host.KeyClientState()) clientKey := host.FullClientStateKey(clientB)
proofClient, _ := suite.chainB.QueryProof(clientKey) proofClient, _ := suite.chainB.QueryProof(clientKey)
err := suite.chainA.App.IBCKeeper.ConnectionKeeper.ConnOpenAck( err := suite.chainA.App.IBCKeeper.ConnectionKeeper.ConnOpenAck(
@ -757,7 +757,7 @@ func (suite *KeeperTestSuite) TestConnOpenConfirm() {
connA := suite.chainA.GetFirstTestConnection(clientA, clientB) connA := suite.chainA.GetFirstTestConnection(clientA, clientB)
connB := suite.chainB.GetFirstTestConnection(clientB, clientA) connB := suite.chainB.GetFirstTestConnection(clientB, clientA)
connectionKey := host.KeyConnection(connA.ID) connectionKey := host.ConnectionKey(connA.ID)
proofAck, proofHeight := suite.chainA.QueryProof(connectionKey) proofAck, proofHeight := suite.chainA.QueryProof(connectionKey)
err := suite.chainB.App.IBCKeeper.ConnectionKeeper.ConnOpenConfirm( err := suite.chainB.App.IBCKeeper.ConnectionKeeper.ConnOpenConfirm(

10
x/ibc/core/03-connection/keeper/keeper.go
View File

@ -48,7 +48,7 @@ func (k Keeper) GetCommitmentPrefix() exported.Prefix {
// GetConnection returns a connection with a particular identifier // GetConnection returns a connection with a particular identifier
func (k Keeper) GetConnection(ctx sdk.Context, connectionID string) (types.ConnectionEnd, bool) { func (k Keeper) GetConnection(ctx sdk.Context, connectionID string) (types.ConnectionEnd, bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := store.Get(host.KeyConnection(connectionID)) bz := store.Get(host.ConnectionKey(connectionID))
if bz == nil { if bz == nil {
return types.ConnectionEnd{}, false return types.ConnectionEnd{}, false
} }
@ -63,7 +63,7 @@ func (k Keeper) GetConnection(ctx sdk.Context, connectionID string) (types.Conne
func (k Keeper) SetConnection(ctx sdk.Context, connectionID string, connection types.ConnectionEnd) { func (k Keeper) SetConnection(ctx sdk.Context, connectionID string, connection types.ConnectionEnd) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := k.cdc.MustMarshalBinaryBare(&connection) bz := k.cdc.MustMarshalBinaryBare(&connection)
store.Set(host.KeyConnection(connectionID), bz) store.Set(host.ConnectionKey(connectionID), bz)
} }
// GetTimestampAtHeight returns the timestamp in nanoseconds of the consensus state at the // GetTimestampAtHeight returns the timestamp in nanoseconds of the consensus state at the
@ -87,7 +87,7 @@ func (k Keeper) GetTimestampAtHeight(ctx sdk.Context, connection types.Connectio
// particular client // particular client
func (k Keeper) GetClientConnectionPaths(ctx sdk.Context, clientID string) ([]string, bool) { func (k Keeper) GetClientConnectionPaths(ctx sdk.Context, clientID string) ([]string, bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := store.Get(host.KeyClientConnections(clientID)) bz := store.Get(host.ClientConnectionsKey(clientID))
if bz == nil { if bz == nil {
return nil, false return nil, false
} }
@ -102,7 +102,7 @@ func (k Keeper) SetClientConnectionPaths(ctx sdk.Context, clientID string, paths
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
clientPaths := types.ClientPaths{Paths: paths} clientPaths := types.ClientPaths{Paths: paths}
bz := k.cdc.MustMarshalBinaryBare(&clientPaths) bz := k.cdc.MustMarshalBinaryBare(&clientPaths)
store.Set(host.KeyClientConnections(clientID), bz) store.Set(host.ClientConnectionsKey(clientID), bz)
} }
// GetAllClientConnectionPaths returns all stored clients connection id paths. It // GetAllClientConnectionPaths returns all stored clients connection id paths. It
@ -129,7 +129,7 @@ func (k Keeper) GetAllClientConnectionPaths(ctx sdk.Context) []types.ConnectionP
// iterator will close and stop. // iterator will close and stop.
func (k Keeper) IterateConnections(ctx sdk.Context, cb func(types.IdentifiedConnection) bool) { func (k Keeper) IterateConnections(ctx sdk.Context, cb func(types.IdentifiedConnection) bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
iterator := sdk.KVStorePrefixIterator(store, host.KeyConnectionPrefix) iterator := sdk.KVStorePrefixIterator(store, []byte(host.KeyConnectionPrefix))
defer iterator.Close() defer iterator.Close()
for ; iterator.Valid(); iterator.Next() { for ; iterator.Valid(); iterator.Next() {

12
x/ibc/core/03-connection/keeper/verify_test.go
View File

@ -178,7 +178,7 @@ func (suite *KeeperTestSuite) TestVerifyConnectionState() {
} }
expectedConnection := suite.chainB.GetConnection(connB) expectedConnection := suite.chainB.GetConnection(connB)
connectionKey := host.KeyConnection(connB.ID) connectionKey := host.ConnectionKey(connB.ID)
proof, proofHeight := suite.chainB.QueryProof(connectionKey) proof, proofHeight := suite.chainB.QueryProof(connectionKey)
if tc.changeConnectionState { if tc.changeConnectionState {
@ -227,7 +227,7 @@ func (suite *KeeperTestSuite) TestVerifyChannelState() {
connection.ClientId = ibctesting.InvalidID connection.ClientId = ibctesting.InvalidID
} }
channelKey := host.KeyChannel(channelB.PortID, channelB.ID) channelKey := host.ChannelKey(channelB.PortID, channelB.ID)
proof, proofHeight := suite.chainB.QueryProof(channelKey) proof, proofHeight := suite.chainB.QueryProof(channelKey)
channel := suite.chainB.GetChannel(channelB) channel := suite.chainB.GetChannel(channelB)
@ -282,7 +282,7 @@ func (suite *KeeperTestSuite) TestVerifyPacketCommitment() {
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
commitmentKey := host.KeyPacketCommitment(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence()) commitmentKey := host.PacketCommitmentKey(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
proof, proofHeight := suite.chainA.QueryProof(commitmentKey) proof, proofHeight := suite.chainA.QueryProof(commitmentKey)
if tc.changePacketCommitmentState { if tc.changePacketCommitmentState {
@ -340,7 +340,7 @@ func (suite *KeeperTestSuite) TestVerifyPacketAcknowledgement() {
err = suite.coordinator.RecvPacket(suite.chainA, suite.chainB, clientA, packet) err = suite.coordinator.RecvPacket(suite.chainA, suite.chainB, clientA, packet)
suite.Require().NoError(err) suite.Require().NoError(err)
packetAckKey := host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetAckKey := host.PacketAcknowledgementKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
proof, proofHeight := suite.chainB.QueryProof(packetAckKey) proof, proofHeight := suite.chainB.QueryProof(packetAckKey)
ack := ibcmock.MockAcknowledgement ack := ibcmock.MockAcknowledgement
@ -405,7 +405,7 @@ func (suite *KeeperTestSuite) TestVerifyPacketReceiptAbsence() {
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
} }
packetReceiptKey := host.KeyPacketReceipt(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetReceiptKey := host.PacketReceiptKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
proof, proofHeight := suite.chainB.QueryProof(packetReceiptKey) proof, proofHeight := suite.chainB.QueryProof(packetReceiptKey)
err = suite.chainA.App.IBCKeeper.ConnectionKeeper.VerifyPacketReceiptAbsence( err = suite.chainA.App.IBCKeeper.ConnectionKeeper.VerifyPacketReceiptAbsence(
@ -459,7 +459,7 @@ func (suite *KeeperTestSuite) TestVerifyNextSequenceRecv() {
err = suite.coordinator.RecvPacket(suite.chainA, suite.chainB, clientA, packet) err = suite.coordinator.RecvPacket(suite.chainA, suite.chainB, clientA, packet)
suite.Require().NoError(err) suite.Require().NoError(err)
nextSeqRecvKey := host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) nextSeqRecvKey := host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
proof, proofHeight := suite.chainB.QueryProof(nextSeqRecvKey) proof, proofHeight := suite.chainB.QueryProof(nextSeqRecvKey)
err = suite.chainA.App.IBCKeeper.ConnectionKeeper.VerifyNextSequenceRecv( err = suite.chainA.App.IBCKeeper.ConnectionKeeper.VerifyNextSequenceRecv(

4
x/ibc/core/03-connection/simulation/decoder.go
View File

@ -14,13 +14,13 @@ import (
// Value to the corresponding connection type. // Value to the corresponding connection type.
func NewDecodeStore(cdc codec.BinaryMarshaler, kvA, kvB kv.Pair) (string, bool) { func NewDecodeStore(cdc codec.BinaryMarshaler, kvA, kvB kv.Pair) (string, bool) {
switch { switch {
case bytes.HasPrefix(kvA.Key, host.KeyClientStorePrefix) && bytes.HasSuffix(kvA.Key, host.KeyConnectionPrefix): case bytes.HasPrefix(kvA.Key, host.KeyClientStorePrefix) && bytes.HasSuffix(kvA.Key, []byte(host.KeyConnectionPrefix)):
var clientConnectionsA, clientConnectionsB types.ClientPaths var clientConnectionsA, clientConnectionsB types.ClientPaths
cdc.MustUnmarshalBinaryBare(kvA.Value, &clientConnectionsA) cdc.MustUnmarshalBinaryBare(kvA.Value, &clientConnectionsA)
cdc.MustUnmarshalBinaryBare(kvB.Value, &clientConnectionsB) cdc.MustUnmarshalBinaryBare(kvB.Value, &clientConnectionsB)
return fmt.Sprintf("ClientPaths A: %v\nClientPaths B: %v", clientConnectionsA, clientConnectionsB), true return fmt.Sprintf("ClientPaths A: %v\nClientPaths B: %v", clientConnectionsA, clientConnectionsB), true
case bytes.HasPrefix(kvA.Key, host.KeyConnectionPrefix): case bytes.HasPrefix(kvA.Key, []byte(host.KeyConnectionPrefix)):
var connectionA, connectionB types.ConnectionEnd var connectionA, connectionB types.ConnectionEnd
cdc.MustUnmarshalBinaryBare(kvA.Value, &connectionA) cdc.MustUnmarshalBinaryBare(kvA.Value, &connectionA)
cdc.MustUnmarshalBinaryBare(kvB.Value, &connectionB) cdc.MustUnmarshalBinaryBare(kvB.Value, &connectionB)

4
x/ibc/core/03-connection/simulation/decoder_test.go
View File

@ -31,11 +31,11 @@ func TestDecodeStore(t *testing.T) {
kvPairs := kv.Pairs{ kvPairs := kv.Pairs{
Pairs: []kv.Pair{ Pairs: []kv.Pair{
{ {
Key: host.KeyClientConnections(connection.ClientId), Key: host.ClientConnectionsKey(connection.ClientId),
Value: cdc.MustMarshalBinaryBare(&paths), Value: cdc.MustMarshalBinaryBare(&paths),
}, },
{ {
Key: host.KeyConnection(connectionID), Key: host.ConnectionKey(connectionID),
Value: cdc.MustMarshalBinaryBare(&connection), Value: cdc.MustMarshalBinaryBare(&connection),
}, },
{ {

5
x/ibc/core/03-connection/types/msgs_test.go
View File

@ -62,9 +62,10 @@ func (suite *MsgTestSuite) SetupTest() {
Prove: true, Prove: true,
}) })
merkleProof := commitmenttypes.MerkleProof{Proof: res.ProofOps} merkleProof, err := commitmenttypes.ConvertProofs(res.ProofOps)
suite.Require().NoError(err)
proof, err := app.AppCodec().MarshalBinaryBare(&merkleProof) proof, err := app.AppCodec().MarshalBinaryBare(&merkleProof)
suite.NoError(err) suite.Require().NoError(err)
suite.proof = proof suite.proof = proof

114
x/ibc/core/03-connection/types/query.pb.go
View File

@ -635,63 +635,63 @@ func init() {
} }
var fileDescriptor_cd8d529f8c7cd06b = []byte{ var fileDescriptor_cd8d529f8c7cd06b = []byte{
// 891 bytes of a gzipped FileDescriptorProto // 887 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xc1, 0x4f, 0x2b, 0x45, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x41, 0x4f, 0x33, 0x45,
0x18, 0xef, 0x14, 0xde, 0xcb, 0x63, 0xca, 0x7b, 0xea, 0xa4, 0x0f, 0xea, 0xaa, 0x05, 0x17, 0x2b, 0x18, 0xee, 0x14, 0xbe, 0x2f, 0x1f, 0x53, 0x40, 0x9d, 0x14, 0xa8, 0xab, 0x16, 0x5c, 0x45, 0x0a,
0xa0, 0x32, 0x43, 0x21, 0x10, 0x04, 0x6a, 0xb4, 0x04, 0x85, 0x0b, 0xc1, 0x35, 0x5e, 0xbc, 0x90, 0x91, 0x19, 0x0a, 0xd1, 0x20, 0xd0, 0x44, 0x21, 0x88, 0x1c, 0x24, 0xb8, 0xc6, 0x8b, 0x17, 0xb2,
0xdd, 0xed, 0xb0, 0xdd, 0x48, 0x77, 0x4a, 0x77, 0xdb, 0xd8, 0x60, 0x2f, 0x9e, 0x3d, 0x98, 0x18, 0xbb, 0x1d, 0xb6, 0x1b, 0xe9, 0x4e, 0xe9, 0x6e, 0x1b, 0x1b, 0xd2, 0x83, 0xfe, 0x02, 0x13, 0x8f,
0x8f, 0x5e, 0x3d, 0x78, 0xf5, 0xe8, 0xcd, 0x13, 0x47, 0x12, 0x2f, 0x9c, 0x88, 0x29, 0x5e, 0xbd, 0xde, 0x3c, 0x70, 0xf5, 0xe0, 0xd1, 0x1f, 0x20, 0x47, 0x12, 0x2f, 0x5e, 0x24, 0xa6, 0x78, 0xf5,
0xf8, 0x17, 0x98, 0x9d, 0x99, 0xb2, 0xb3, 0x74, 0x0b, 0xa5, 0x91, 0x53, 0x77, 0xbf, 0xf9, 0xbe, 0xe2, 0x2f, 0x30, 0x3b, 0x33, 0x65, 0x67, 0xe9, 0xb6, 0x94, 0xe6, 0xe3, 0xd4, 0xdd, 0x77, 0xde,
0x99, 0xdf, 0xef, 0xf7, 0x7d, 0xf3, 0xdb, 0x42, 0xdd, 0xb5, 0x6c, 0x62, 0xb3, 0x06, 0x25, 0x36, 0x77, 0xe6, 0x79, 0x9e, 0xf7, 0x9d, 0x67, 0x0b, 0x75, 0xd7, 0xb2, 0x89, 0xcd, 0xea, 0x94, 0xd8,
0xf3, 0x3c, 0x6a, 0x07, 0x2e, 0xf3, 0x48, 0xab, 0x48, 0x4e, 0x9b, 0xb4, 0xd1, 0xc6, 0xf5, 0x06, 0xcc, 0xf3, 0xa8, 0x1d, 0xb8, 0xcc, 0x23, 0xcd, 0x22, 0x39, 0x6f, 0xd0, 0x7a, 0x0b, 0xd7, 0xea,
0x0b, 0x18, 0x9a, 0x72, 0x2d, 0x1b, 0x87, 0x39, 0x38, 0xca, 0xc1, 0xad, 0xa2, 0x96, 0x75, 0x98, 0x2c, 0x60, 0x68, 0xd6, 0xb5, 0x6c, 0x1c, 0xe6, 0xe0, 0x28, 0x07, 0x37, 0x8b, 0x5a, 0xd6, 0x61,
0xc3, 0x78, 0x0a, 0x09, 0x9f, 0x44, 0xb6, 0xf6, 0x9e, 0xcd, 0xfc, 0x1a, 0xf3, 0x89, 0x65, 0xfa, 0x0e, 0xe3, 0x29, 0x24, 0x7c, 0x12, 0xd9, 0xda, 0x8a, 0xcd, 0xfc, 0x2a, 0xf3, 0x89, 0x65, 0xfa,
0x54, 0x6c, 0x43, 0x5a, 0x45, 0x8b, 0x06, 0x66, 0x91, 0xd4, 0x4d, 0xc7, 0xf5, 0x4c, 0x5e, 0x2e, 0x54, 0x6c, 0x43, 0x9a, 0x45, 0x8b, 0x06, 0x66, 0x91, 0xd4, 0x4c, 0xc7, 0xf5, 0x4c, 0x5e, 0x2e,
0x72, 0x67, 0xa2, 0xd3, 0x4f, 0x5c, 0xea, 0x05, 0xe1, 0xc9, 0xe2, 0x49, 0x26, 0xcc, 0x0f, 0x80, 0x72, 0xe7, 0xa3, 0xd3, 0xcf, 0x5c, 0xea, 0x05, 0xe1, 0xc9, 0xe2, 0x49, 0x26, 0x2c, 0xf5, 0x81,
0xa7, 0x00, 0x11, 0x89, 0x6f, 0x3a, 0x8c, 0x39, 0x27, 0x94, 0x98, 0x75, 0x97, 0x98, 0x9e, 0xc7, 0xa7, 0x00, 0x11, 0x89, 0x6f, 0x3a, 0x8c, 0x39, 0x67, 0x94, 0x98, 0x35, 0x97, 0x98, 0x9e, 0xc7,
0x02, 0x7e, 0x8c, 0x2f, 0x57, 0x5f, 0x97, 0xab, 0xfc, 0xcd, 0x6a, 0x1e, 0x13, 0xd3, 0x93, 0xe4, 0x02, 0x7e, 0x8c, 0x2f, 0x57, 0x5f, 0x97, 0xab, 0xfc, 0xcd, 0x6a, 0x9c, 0x12, 0xd3, 0x93, 0xe4,
0xf4, 0x12, 0x9c, 0xfa, 0x3c, 0x04, 0xb9, 0x73, 0xb3, 0xa3, 0x41, 0x4f, 0x9b, 0xd4, 0x0f, 0xd0, 0xf4, 0x12, 0x9c, 0xfd, 0x22, 0x04, 0xb9, 0x77, 0xb7, 0xa3, 0x41, 0xcf, 0x1b, 0xd4, 0x0f, 0xd0,
0x1c, 0x7c, 0x1e, 0x1d, 0x73, 0xe4, 0x56, 0x72, 0x60, 0x16, 0x2c, 0x4c, 0x18, 0x93, 0x51, 0x70, 0x3b, 0x70, 0x2a, 0x3a, 0xe6, 0xc4, 0x2d, 0xe7, 0xc0, 0x02, 0x28, 0x4c, 0x18, 0x93, 0x51, 0xf0,
0xbf, 0xa2, 0xff, 0x0e, 0xe0, 0x74, 0x5f, 0xbd, 0x5f, 0x67, 0x9e, 0x4f, 0xd1, 0x2e, 0x84, 0x51, 0xb0, 0xac, 0xff, 0x06, 0xe0, 0x5c, 0x4f, 0xbd, 0x5f, 0x63, 0x9e, 0x4f, 0xd1, 0x3e, 0x84, 0x51,
0x2e, 0xaf, 0xce, 0xac, 0x14, 0x70, 0xb2, 0x98, 0x38, 0xaa, 0xdf, 0xf5, 0x2a, 0x86, 0x52, 0x88, 0x2e, 0xaf, 0xce, 0xac, 0x2f, 0xe2, 0x64, 0x31, 0x71, 0x54, 0xbf, 0xef, 0x95, 0x0d, 0xa5, 0x10,
0xb2, 0xf0, 0x49, 0xbd, 0xc1, 0xd8, 0x71, 0x2e, 0x3d, 0x0b, 0x16, 0x26, 0x0d, 0xf1, 0x82, 0x76, 0x65, 0xe1, 0xb3, 0x5a, 0x9d, 0xb1, 0xd3, 0x5c, 0x7a, 0x01, 0x14, 0x26, 0x0d, 0xf1, 0x82, 0xf6,
0xe0, 0x24, 0x7f, 0x38, 0xaa, 0x52, 0xd7, 0xa9, 0x06, 0xb9, 0x31, 0xbe, 0xbd, 0xa6, 0x6c, 0x2f, 0xe0, 0x24, 0x7f, 0x38, 0xa9, 0x50, 0xd7, 0xa9, 0x04, 0xb9, 0x31, 0xbe, 0xbd, 0xa6, 0x6c, 0x2f,
0x74, 0x6c, 0x15, 0xf1, 0x1e, 0xcf, 0x28, 0x8f, 0x9f, 0x5f, 0xcd, 0xa4, 0x8c, 0x0c, 0xaf, 0x12, 0x74, 0x6c, 0x16, 0xf1, 0x67, 0x3c, 0x63, 0x77, 0xfc, 0xea, 0x66, 0x3e, 0x65, 0x64, 0x78, 0x95,
0x21, 0xdd, 0xec, 0x03, 0xef, 0xf7, 0xd8, 0x7f, 0x0a, 0x61, 0xd4, 0x2e, 0x09, 0xfe, 0x5d, 0x2c, 0x08, 0xe9, 0x66, 0x0f, 0x78, 0xbf, 0xcb, 0xfe, 0x53, 0x08, 0xa3, 0x76, 0x49, 0xf0, 0xef, 0x61,
0x7a, 0x8b, 0xc3, 0xde, 0x62, 0x31, 0x22, 0xb2, 0xb7, 0xf8, 0xd0, 0x74, 0xa8, 0xac, 0x35, 0x94, 0xd1, 0x5b, 0x1c, 0xf6, 0x16, 0x8b, 0x11, 0x91, 0xbd, 0xc5, 0xc7, 0xa6, 0x43, 0x65, 0xad, 0xa1,
0x4a, 0xfd, 0x1f, 0x00, 0x73, 0xfd, 0x67, 0x48, 0x85, 0x0e, 0x60, 0x26, 0x22, 0xea, 0xe7, 0xc0, 0x54, 0xea, 0xff, 0x02, 0x98, 0xeb, 0x3d, 0x43, 0x2a, 0x74, 0x04, 0x33, 0x11, 0x51, 0x3f, 0x07,
0xec, 0xd8, 0x42, 0x66, 0xe5, 0x83, 0x41, 0x12, 0xed, 0x57, 0xa8, 0x17, 0xb8, 0xc7, 0x2e, 0xad, 0x16, 0xc6, 0x0a, 0x99, 0xf5, 0xf7, 0xfb, 0x49, 0x74, 0x58, 0xa6, 0x5e, 0xe0, 0x9e, 0xba, 0xb4,
0x28, 0x62, 0xab, 0x1b, 0xa0, 0xcf, 0x62, 0xa0, 0xd3, 0x1c, 0xf4, 0xfc, 0xbd, 0xa0, 0x05, 0x18, 0xac, 0x88, 0xad, 0x6e, 0x80, 0x0e, 0x62, 0xa0, 0xd3, 0x1c, 0xf4, 0xd2, 0x83, 0xa0, 0x05, 0x18,
0x15, 0x35, 0xda, 0x80, 0x4f, 0x1f, 0xa8, 0xab, 0xcc, 0xd7, 0xb7, 0xe1, 0x5b, 0x82, 0x2e, 0x4f, 0x15, 0x35, 0xda, 0x84, 0xcf, 0x1f, 0xa9, 0xab, 0xcc, 0xd7, 0x77, 0xe0, 0x5b, 0x82, 0x2e, 0x4f,
0x4b, 0x10, 0xf6, 0x0d, 0x38, 0x21, 0xb6, 0x88, 0x46, 0xea, 0x99, 0x08, 0xec, 0x57, 0xf4, 0x5f, 0x4b, 0x10, 0xf6, 0x0d, 0x38, 0x21, 0xb6, 0x88, 0x46, 0xea, 0x85, 0x08, 0x1c, 0x96, 0xf5, 0x4b,
0x00, 0xcc, 0x0f, 0x2a, 0x97, 0x9a, 0x2d, 0xc2, 0x57, 0x95, 0xb1, 0xac, 0x9b, 0x41, 0x55, 0x08, 0x00, 0xf3, 0xfd, 0xca, 0xa5, 0x66, 0xcb, 0xf0, 0x55, 0x65, 0x2c, 0x6b, 0x66, 0x50, 0x11, 0xc2,
0x37, 0x61, 0xbc, 0x12, 0xc5, 0x0f, 0xc3, 0xf0, 0x63, 0x4e, 0x8e, 0x05, 0xdf, 0xbe, 0xd5, 0x55, 0x4d, 0x18, 0xaf, 0x44, 0xf1, 0xe3, 0x30, 0xfc, 0x94, 0x93, 0x63, 0xc1, 0xb7, 0xef, 0x75, 0x55,
0x81, 0xf8, 0x8b, 0xc0, 0x0c, 0x7a, 0x73, 0x80, 0x4a, 0x89, 0x37, 0xa8, 0x9c, 0xfb, 0xf7, 0x6a, 0x20, 0xfe, 0x32, 0x30, 0x83, 0xee, 0x1c, 0xa0, 0x52, 0xe2, 0x0d, 0xda, 0xcd, 0xfd, 0x77, 0x33,
0x26, 0xdb, 0x36, 0x6b, 0x27, 0x9b, 0x7a, 0x6c, 0x59, 0xbf, 0x75, 0xb7, 0xba, 0x00, 0xea, 0x77, 0x9f, 0x6d, 0x99, 0xd5, 0xb3, 0x2d, 0x3d, 0xb6, 0xac, 0xdf, 0xbb, 0x5b, 0x1d, 0x00, 0xf5, 0x41,
0x1d, 0x22, 0x05, 0x31, 0xe1, 0xb4, 0x7b, 0x33, 0x19, 0x47, 0x52, 0x5b, 0x3f, 0x4c, 0x91, 0x63, 0x87, 0x48, 0x41, 0x4c, 0x38, 0xe7, 0xde, 0x4d, 0xc6, 0x89, 0xd4, 0xd6, 0x0f, 0x53, 0xe4, 0xd8,
0xbb, 0x98, 0x44, 0x4d, 0x19, 0x26, 0x65, 0xcf, 0x97, 0x6e, 0x52, 0xf8, 0x31, 0x85, 0xfc, 0x0d, 0x2e, 0x27, 0x51, 0x53, 0x86, 0x49, 0xd9, 0x73, 0xc6, 0x4d, 0x0a, 0x3f, 0xa5, 0x90, 0xbf, 0x02,
0xc0, 0x77, 0x6e, 0x93, 0x0c, 0x69, 0x79, 0x7e, 0xd3, 0xff, 0x1f, 0xc5, 0x44, 0x05, 0xf8, 0xa2, 0xf8, 0xee, 0x7d, 0x92, 0x21, 0x2d, 0xcf, 0x6f, 0xf8, 0x2f, 0x51, 0x4c, 0xb4, 0x08, 0xa7, 0x9b,
0x45, 0x1b, 0x7e, 0xb8, 0xe8, 0x35, 0x6b, 0x16, 0x6d, 0x70, 0x2e, 0xe3, 0xc6, 0x73, 0x19, 0x3d, 0xb4, 0xee, 0x87, 0x8b, 0x5e, 0xa3, 0x6a, 0xd1, 0x3a, 0xe7, 0x32, 0x6e, 0x4c, 0xc9, 0xe8, 0x11,
0xe0, 0x41, 0x35, 0x4d, 0x61, 0x15, 0xa5, 0x49, 0xd4, 0x57, 0x00, 0x16, 0xee, 0x41, 0x2d, 0xbb, 0x0f, 0xaa, 0x69, 0x0a, 0xab, 0x28, 0x4d, 0xa2, 0xbe, 0x01, 0x70, 0xf1, 0x01, 0xd4, 0xb2, 0x3b,
0x53, 0x82, 0xe1, 0x58, 0x8a, 0x95, 0x58, 0x57, 0xb2, 0x58, 0x98, 0x32, 0xee, 0x99, 0x32, 0xfe, 0x25, 0x18, 0x8e, 0xa5, 0x58, 0x89, 0x75, 0x25, 0x8b, 0x85, 0x29, 0xe3, 0xae, 0x29, 0xe3, 0x4f,
0xc4, 0x6b, 0x1b, 0x2f, 0xec, 0xd8, 0x36, 0xf1, 0xdb, 0x92, 0x8e, 0xdf, 0x96, 0xa8, 0x2d, 0x63, 0xbc, 0x96, 0x31, 0x6d, 0xc7, 0xb6, 0x89, 0xdf, 0x96, 0x74, 0xfc, 0xb6, 0x44, 0x6d, 0x19, 0x1b,
0x77, 0xb5, 0x65, 0x7c, 0x84, 0xb6, 0xac, 0x7c, 0xff, 0x0c, 0x3e, 0xe1, 0x04, 0xd1, 0xaf, 0x00, 0xd4, 0x96, 0xf1, 0x11, 0xda, 0xb2, 0x7e, 0xf9, 0x02, 0x3e, 0xe3, 0x04, 0xd1, 0x2f, 0x00, 0xc2,
0xc2, 0x88, 0x25, 0xc2, 0x83, 0xdc, 0x29, 0xf9, 0x2b, 0xa2, 0x91, 0xa1, 0xf3, 0x85, 0x60, 0xfa, 0x88, 0x25, 0xc2, 0xfd, 0xdc, 0x29, 0xf9, 0x2b, 0xa2, 0x91, 0xa1, 0xf3, 0x85, 0x60, 0xfa, 0xc7,
0xd6, 0x77, 0x7f, 0xfe, 0xfd, 0x63, 0x7a, 0x0d, 0xad, 0x12, 0xf1, 0xed, 0x53, 0x3e, 0x7b, 0xe2, 0xdf, 0xff, 0xf1, 0xcf, 0x8f, 0xe9, 0x2d, 0xb4, 0x49, 0x92, 0xbf, 0x7d, 0xe2, 0x53, 0xaa, 0xb8,
0x2b, 0xaa, 0x18, 0x1e, 0x39, 0x8b, 0xf5, 0xbc, 0x83, 0x7e, 0x06, 0x30, 0xa3, 0x98, 0x06, 0x1a, 0x1e, 0xb9, 0x88, 0x35, 0xbe, 0x8d, 0x7e, 0x06, 0x30, 0xa3, 0x38, 0x07, 0x1a, 0x16, 0x42, 0xd7,
0xf6, 0xf4, 0x9e, 0x3b, 0x69, 0xcb, 0xc3, 0x17, 0x48, 0xbc, 0xef, 0x73, 0xbc, 0x05, 0x34, 0x37, 0xa2, 0xb4, 0xb5, 0xe1, 0x0b, 0x24, 0xe8, 0x35, 0x0e, 0x7a, 0x05, 0x15, 0x86, 0x05, 0x8d, 0x7e,
0x04, 0x5e, 0xf4, 0x07, 0x80, 0xaf, 0xf5, 0x59, 0x1b, 0x5a, 0xbb, 0xfb, 0xd0, 0x01, 0x4e, 0xaa, 0x07, 0xf0, 0xb5, 0x1e, 0x93, 0x43, 0x1f, 0x0c, 0x3e, 0xb9, 0x8f, 0xa7, 0x6a, 0x1f, 0x3e, 0xb6,
0xad, 0x3f, 0xb4, 0x4c, 0x22, 0xfe, 0x88, 0x23, 0xde, 0x40, 0xeb, 0x03, 0x11, 0x8b, 0x89, 0x8b, 0x4c, 0xc2, 0xde, 0xe3, 0xb0, 0x4b, 0x68, 0x7b, 0x30, 0x6c, 0x31, 0x80, 0x71, 0xc9, 0xbb, 0x43,
0x0b, 0xdd, 0x9b, 0xc2, 0x0e, 0xba, 0x04, 0xf0, 0x65, 0xa2, 0x25, 0xa1, 0x0f, 0x87, 0x54, 0xaf, 0xd9, 0x46, 0x7f, 0x01, 0x38, 0x93, 0xe8, 0x50, 0xe8, 0xa3, 0x21, 0x75, 0xec, 0xb5, 0x4e, 0x6d,
0xdf, 0x2b, 0xb5, 0xcd, 0x51, 0x4a, 0x25, 0xa1, 0x3d, 0x4e, 0xa8, 0x8c, 0x3e, 0x1e, 0x61, 0x64, 0x6b, 0x94, 0x52, 0xc9, 0xea, 0x73, 0xce, 0xea, 0x00, 0xed, 0x8f, 0x3a, 0x41, 0x44, 0x35, 0x51,
0x88, 0x6a, 0x98, 0xe8, 0xa7, 0x34, 0xcc, 0x0d, 0xba, 0xd2, 0x68, 0x7b, 0x58, 0x88, 0x49, 0xfe, 0xf4, 0x53, 0x1a, 0xe6, 0xfa, 0x5d, 0x73, 0xb4, 0x33, 0x2c, 0xce, 0x24, 0x4f, 0xd3, 0x4a, 0x23,
0xa5, 0x95, 0x46, 0xac, 0x96, 0x1c, 0xbf, 0xe5, 0x1c, 0x5b, 0x28, 0x18, 0x89, 0x63, 0xdc, 0x81, 0x56, 0x4b, 0xa2, 0xdf, 0x01, 0xce, 0xf4, 0x02, 0xb5, 0x46, 0x67, 0x1a, 0xf7, 0x26, 0x22, 0x6d,
0x88, 0x34, 0x33, 0x72, 0x16, 0xb7, 0xc4, 0x0e, 0x11, 0x96, 0x11, 0xc5, 0xc5, 0x7b, 0xa7, 0xfc, 0x8e, 0x5c, 0xc4, 0xcd, 0xb2, 0x4d, 0x84, 0x99, 0x44, 0x71, 0xf1, 0xde, 0xde, 0xfd, 0xea, 0xaa,
0xe5, 0x79, 0x37, 0x0f, 0x2e, 0xba, 0x79, 0xf0, 0x57, 0x37, 0x0f, 0x7e, 0xb8, 0xce, 0xa7, 0x2e, 0x93, 0x07, 0xd7, 0x9d, 0x3c, 0xf8, 0xbb, 0x93, 0x07, 0x3f, 0xdc, 0xe6, 0x53, 0xd7, 0xb7, 0xf9,
0xae, 0xf3, 0xa9, 0xcb, 0xeb, 0x7c, 0xea, 0xab, 0x2d, 0xc7, 0x0d, 0xaa, 0x4d, 0x0b, 0xdb, 0xac, 0xd4, 0x9f, 0xb7, 0xf9, 0xd4, 0xd7, 0xdb, 0x8e, 0x1b, 0x54, 0x1a, 0x16, 0xb6, 0x59, 0x95, 0xc8,
0x46, 0xe4, 0x3f, 0x5f, 0xf1, 0xb3, 0xe4, 0x57, 0xbe, 0x26, 0xdf, 0x90, 0x9b, 0x3f, 0xb0, 0xcb, 0xff, 0xc4, 0xe2, 0x67, 0xd5, 0x2f, 0x7f, 0x43, 0xbe, 0x8d, 0x20, 0xaf, 0x6d, 0xac, 0x2a, 0xa8,
0xab, 0x4b, 0x0a, 0xea, 0xa0, 0x5d, 0xa7, 0xbe, 0xf5, 0x94, 0x7b, 0xdf, 0xea, 0x7f, 0x01, 0x00, 0x83, 0x56, 0x8d, 0xfa, 0xd6, 0x73, 0xee, 0x8a, 0x1b, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0x91,
0x00, 0xff, 0xff, 0x3b, 0x66, 0x6e, 0x99, 0x86, 0x0b, 0x00, 0x00, 0x3b, 0x2c, 0x79, 0xa0, 0x0b, 0x00, 0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.

10
x/ibc/core/03-connection/types/query.pb.gw.go
View File

@ -578,15 +578,15 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
} }
var ( var (
pattern_Query_Connection_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"ibc", "connection", "v1beta1", "connections", "connection_id"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_Connection_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"ibc", "core", "connection", "v1beta1", "connections", "connection_id"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_Connections_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ibc", "connection", "v1beta1", "connections"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_Connections_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"ibc", "core", "connection", "v1beta1", "connections"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_ClientConnections_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"ibc", "connection", "v1beta1", "client_connections", "client_id"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ClientConnections_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"ibc", "core", "connection", "v1beta1", "client_connections", "client_id"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_ConnectionClientState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"ibc", "connection", "v1beta1", "connections", "connection_id", "client_state"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ConnectionClientState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6}, []string{"ibc", "core", "connection", "v1beta1", "connections", "connection_id", "client_state"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_ConnectionConsensusState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8, 1, 0, 4, 1, 5, 9}, []string{"ibc", "connection", "v1beta1", "connections", "connection_id", "consensus_state", "version", "version_number", "height", "version_height"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ConnectionConsensusState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 2, 7, 1, 0, 4, 1, 5, 8, 2, 9, 1, 0, 4, 1, 5, 10}, []string{"ibc", "core", "connection", "v1beta1", "connections", "connection_id", "consensus_state", "version", "version_number", "height", "version_height"}, "", runtime.AssumeColonVerbOpt(true)))
) )
var ( var (

10
x/ibc/core/04-channel/client/utils/utils.go
View File

@ -35,7 +35,7 @@ func QueryChannel(
} }
func queryChannelABCI(clientCtx client.Context, portID, channelID string) (*types.QueryChannelResponse, error) { func queryChannelABCI(clientCtx client.Context, portID, channelID string) (*types.QueryChannelResponse, error) {
key := host.KeyChannel(portID, channelID) key := host.ChannelKey(portID, channelID)
value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key) value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key)
if err != nil { if err != nil {
@ -176,7 +176,7 @@ func QueryNextSequenceReceive(
} }
func queryNextSequenceRecvABCI(clientCtx client.Context, portID, channelID string) (*types.QueryNextSequenceReceiveResponse, error) { func queryNextSequenceRecvABCI(clientCtx client.Context, portID, channelID string) (*types.QueryNextSequenceReceiveResponse, error) {
key := host.KeyNextSequenceRecv(portID, channelID) key := host.NextSequenceRecvKey(portID, channelID)
value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key) value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key)
if err != nil { if err != nil {
@ -217,7 +217,7 @@ func QueryPacketCommitment(
func queryPacketCommitmentABCI( func queryPacketCommitmentABCI(
clientCtx client.Context, portID, channelID string, sequence uint64, clientCtx client.Context, portID, channelID string, sequence uint64,
) (*types.QueryPacketCommitmentResponse, error) { ) (*types.QueryPacketCommitmentResponse, error) {
key := host.KeyPacketCommitment(portID, channelID, sequence) key := host.PacketCommitmentKey(portID, channelID, sequence)
value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key) value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key)
if err != nil { if err != nil {
@ -256,7 +256,7 @@ func QueryPacketReceipt(
func queryPacketReceiptABCI( func queryPacketReceiptABCI(
clientCtx client.Context, portID, channelID string, sequence uint64, clientCtx client.Context, portID, channelID string, sequence uint64,
) (*types.QueryPacketReceiptResponse, error) { ) (*types.QueryPacketReceiptResponse, error) {
key := host.KeyPacketReceipt(portID, channelID, sequence) key := host.PacketReceiptKey(portID, channelID, sequence)
value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key) value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key)
if err != nil { if err != nil {
@ -285,7 +285,7 @@ func QueryPacketAcknowledgement(clientCtx client.Context, portID, channelID stri
} }
func queryPacketAcknowledgementABCI(clientCtx client.Context, portID, channelID string, sequence uint64) (*types.QueryPacketAcknowledgementResponse, error) { func queryPacketAcknowledgementABCI(clientCtx client.Context, portID, channelID string, sequence uint64) (*types.QueryPacketAcknowledgementResponse, error) {
key := host.KeyPacketAcknowledgement(portID, channelID, sequence) key := host.PacketAcknowledgementKey(portID, channelID, sequence)
value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key) value, proofBz, proofHeight, err := ibcclient.QueryTendermintProof(clientCtx, key)
if err != nil { if err != nil {

4
x/ibc/core/04-channel/keeper/grpc_query.go
View File

@ -52,7 +52,7 @@ func (q Keeper) Channels(c context.Context, req *types.QueryChannelsRequest) (*t
ctx := sdk.UnwrapSDKContext(c) ctx := sdk.UnwrapSDKContext(c)
channels := []*types.IdentifiedChannel{} channels := []*types.IdentifiedChannel{}
store := prefix.NewStore(ctx.KVStore(q.storeKey), []byte(host.KeyChannelPrefix)) store := prefix.NewStore(ctx.KVStore(q.storeKey), []byte(host.KeyChannelEndPrefix))
pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error { pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error {
var result types.Channel var result types.Channel
@ -95,7 +95,7 @@ func (q Keeper) ConnectionChannels(c context.Context, req *types.QueryConnection
ctx := sdk.UnwrapSDKContext(c) ctx := sdk.UnwrapSDKContext(c)
channels := []*types.IdentifiedChannel{} channels := []*types.IdentifiedChannel{}
store := prefix.NewStore(ctx.KVStore(q.storeKey), []byte(host.KeyChannelPrefix)) store := prefix.NewStore(ctx.KVStore(q.storeKey), []byte(host.KeyChannelEndPrefix))
pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error { pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error {
var result types.Channel var result types.Channel

8
x/ibc/core/04-channel/keeper/handshake_test.go
View File

@ -289,7 +289,7 @@ func (suite *KeeperTestSuite) TestChanOpenTry() {
counterpartyChosenChannelID = channel.Counterparty.ChannelId counterpartyChosenChannelID = channel.Counterparty.ChannelId
} }
channelKey := host.KeyChannel(counterparty.PortId, counterparty.ChannelId) channelKey := host.ChannelKey(counterparty.PortId, counterparty.ChannelId)
proof, proofHeight := suite.chainA.QueryProof(channelKey) proof, proofHeight := suite.chainA.QueryProof(channelKey)
cap, err := suite.chainB.App.IBCKeeper.ChannelKeeper.ChanOpenTry( cap, err := suite.chainB.App.IBCKeeper.ChannelKeeper.ChanOpenTry(
@ -455,7 +455,7 @@ func (suite *KeeperTestSuite) TestChanOpenAck() {
counterpartyChannelID = channelB.ID counterpartyChannelID = channelB.ID
} }
channelKey := host.KeyChannel(channelB.PortID, channelB.ID) channelKey := host.ChannelKey(channelB.PortID, channelB.ID)
proof, proofHeight := suite.chainB.QueryProof(channelKey) proof, proofHeight := suite.chainB.QueryProof(channelKey)
err := suite.chainA.App.IBCKeeper.ChannelKeeper.ChanOpenAck( err := suite.chainA.App.IBCKeeper.ChannelKeeper.ChanOpenAck(
@ -583,7 +583,7 @@ func (suite *KeeperTestSuite) TestChanOpenConfirm() {
channelA := connA.FirstOrNextTestChannel(ibctesting.MockPort) channelA := connA.FirstOrNextTestChannel(ibctesting.MockPort)
channelB := connB.FirstOrNextTestChannel(ibctesting.MockPort) channelB := connB.FirstOrNextTestChannel(ibctesting.MockPort)
channelKey := host.KeyChannel(channelA.PortID, channelA.ID) channelKey := host.ChannelKey(channelA.PortID, channelA.ID)
proof, proofHeight := suite.chainA.QueryProof(channelKey) proof, proofHeight := suite.chainA.QueryProof(channelKey)
err := suite.chainB.App.IBCKeeper.ChannelKeeper.ChanOpenConfirm( err := suite.chainB.App.IBCKeeper.ChannelKeeper.ChanOpenConfirm(
@ -784,7 +784,7 @@ func (suite *KeeperTestSuite) TestChanCloseConfirm() {
channelA = connA.FirstOrNextTestChannel(ibctesting.MockPort) channelA = connA.FirstOrNextTestChannel(ibctesting.MockPort)
channelB = connB.FirstOrNextTestChannel(ibctesting.MockPort) channelB = connB.FirstOrNextTestChannel(ibctesting.MockPort)
channelKey := host.KeyChannel(channelA.PortID, channelA.ID) channelKey := host.ChannelKey(channelA.PortID, channelA.ID)
proof, proofHeight := suite.chainA.QueryProof(channelKey) proof, proofHeight := suite.chainA.QueryProof(channelKey)
err := suite.chainB.App.IBCKeeper.ChannelKeeper.ChanCloseConfirm( err := suite.chainB.App.IBCKeeper.ChannelKeeper.ChanCloseConfirm(

36
x/ibc/core/04-channel/keeper/keeper.go
View File

@ -58,7 +58,7 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger {
// GetChannel returns a channel with a particular identifier binded to a specific port // GetChannel returns a channel with a particular identifier binded to a specific port
func (k Keeper) GetChannel(ctx sdk.Context, portID, channelID string) (types.Channel, bool) { func (k Keeper) GetChannel(ctx sdk.Context, portID, channelID string) (types.Channel, bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := store.Get(host.KeyChannel(portID, channelID)) bz := store.Get(host.ChannelKey(portID, channelID))
if bz == nil { if bz == nil {
return types.Channel{}, false return types.Channel{}, false
} }
@ -72,13 +72,13 @@ func (k Keeper) GetChannel(ctx sdk.Context, portID, channelID string) (types.Cha
func (k Keeper) SetChannel(ctx sdk.Context, portID, channelID string, channel types.Channel) { func (k Keeper) SetChannel(ctx sdk.Context, portID, channelID string, channel types.Channel) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := k.cdc.MustMarshalBinaryBare(&channel) bz := k.cdc.MustMarshalBinaryBare(&channel)
store.Set(host.KeyChannel(portID, channelID), bz) store.Set(host.ChannelKey(portID, channelID), bz)
} }
// GetNextSequenceSend gets a channel's next send sequence from the store // GetNextSequenceSend gets a channel's next send sequence from the store
func (k Keeper) GetNextSequenceSend(ctx sdk.Context, portID, channelID string) (uint64, bool) { func (k Keeper) GetNextSequenceSend(ctx sdk.Context, portID, channelID string) (uint64, bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := store.Get(host.KeyNextSequenceSend(portID, channelID)) bz := store.Get(host.NextSequenceSendKey(portID, channelID))
if bz == nil { if bz == nil {
return 0, false return 0, false
} }
@ -90,13 +90,13 @@ func (k Keeper) GetNextSequenceSend(ctx sdk.Context, portID, channelID string) (
func (k Keeper) SetNextSequenceSend(ctx sdk.Context, portID, channelID string, sequence uint64) { func (k Keeper) SetNextSequenceSend(ctx sdk.Context, portID, channelID string, sequence uint64) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := sdk.Uint64ToBigEndian(sequence) bz := sdk.Uint64ToBigEndian(sequence)
store.Set(host.KeyNextSequenceSend(portID, channelID), bz) store.Set(host.NextSequenceSendKey(portID, channelID), bz)
} }
// GetNextSequenceRecv gets a channel's next receive sequence from the store // GetNextSequenceRecv gets a channel's next receive sequence from the store
func (k Keeper) GetNextSequenceRecv(ctx sdk.Context, portID, channelID string) (uint64, bool) { func (k Keeper) GetNextSequenceRecv(ctx sdk.Context, portID, channelID string) (uint64, bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := store.Get(host.KeyNextSequenceRecv(portID, channelID)) bz := store.Get(host.NextSequenceRecvKey(portID, channelID))
if bz == nil { if bz == nil {
return 0, false return 0, false
} }
@ -108,13 +108,13 @@ func (k Keeper) GetNextSequenceRecv(ctx sdk.Context, portID, channelID string) (
func (k Keeper) SetNextSequenceRecv(ctx sdk.Context, portID, channelID string, sequence uint64) { func (k Keeper) SetNextSequenceRecv(ctx sdk.Context, portID, channelID string, sequence uint64) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := sdk.Uint64ToBigEndian(sequence) bz := sdk.Uint64ToBigEndian(sequence)
store.Set(host.KeyNextSequenceRecv(portID, channelID), bz) store.Set(host.NextSequenceRecvKey(portID, channelID), bz)
} }
// GetNextSequenceAck gets a channel's next ack sequence from the store // GetNextSequenceAck gets a channel's next ack sequence from the store
func (k Keeper) GetNextSequenceAck(ctx sdk.Context, portID, channelID string) (uint64, bool) { func (k Keeper) GetNextSequenceAck(ctx sdk.Context, portID, channelID string) (uint64, bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := store.Get(host.KeyNextSequenceAck(portID, channelID)) bz := store.Get(host.NextSequenceAckKey(portID, channelID))
if bz == nil { if bz == nil {
return 0, false return 0, false
} }
@ -126,13 +126,13 @@ func (k Keeper) GetNextSequenceAck(ctx sdk.Context, portID, channelID string) (u
func (k Keeper) SetNextSequenceAck(ctx sdk.Context, portID, channelID string, sequence uint64) { func (k Keeper) SetNextSequenceAck(ctx sdk.Context, portID, channelID string, sequence uint64) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := sdk.Uint64ToBigEndian(sequence) bz := sdk.Uint64ToBigEndian(sequence)
store.Set(host.KeyNextSequenceAck(portID, channelID), bz) store.Set(host.NextSequenceAckKey(portID, channelID), bz)
} }
// GetPacketReceipt gets a packet receipt from the store // GetPacketReceipt gets a packet receipt from the store
func (k Keeper) GetPacketReceipt(ctx sdk.Context, portID, channelID string, sequence uint64) (string, bool) { func (k Keeper) GetPacketReceipt(ctx sdk.Context, portID, channelID string, sequence uint64) (string, bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := store.Get(host.KeyPacketReceipt(portID, channelID, sequence)) bz := store.Get(host.PacketReceiptKey(portID, channelID, sequence))
if bz == nil { if bz == nil {
return "", false return "", false
} }
@ -143,43 +143,43 @@ func (k Keeper) GetPacketReceipt(ctx sdk.Context, portID, channelID string, sequ
// SetPacketReceipt sets an empty packet receipt to the store // SetPacketReceipt sets an empty packet receipt to the store
func (k Keeper) SetPacketReceipt(ctx sdk.Context, portID, channelID string, sequence uint64) { func (k Keeper) SetPacketReceipt(ctx sdk.Context, portID, channelID string, sequence uint64) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
store.Set(host.KeyPacketReceipt(portID, channelID, sequence), []byte("")) store.Set(host.PacketReceiptKey(portID, channelID, sequence), []byte(""))
} }
// GetPacketCommitment gets the packet commitment hash from the store // GetPacketCommitment gets the packet commitment hash from the store
func (k Keeper) GetPacketCommitment(ctx sdk.Context, portID, channelID string, sequence uint64) []byte { func (k Keeper) GetPacketCommitment(ctx sdk.Context, portID, channelID string, sequence uint64) []byte {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := store.Get(host.KeyPacketCommitment(portID, channelID, sequence)) bz := store.Get(host.PacketCommitmentKey(portID, channelID, sequence))
return bz return bz
} }
// HasPacketCommitment returns true if the packet commitment exists // HasPacketCommitment returns true if the packet commitment exists
func (k Keeper) HasPacketCommitment(ctx sdk.Context, portID, channelID string, sequence uint64) bool { func (k Keeper) HasPacketCommitment(ctx sdk.Context, portID, channelID string, sequence uint64) bool {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
return store.Has(host.KeyPacketCommitment(portID, channelID, sequence)) return store.Has(host.PacketCommitmentKey(portID, channelID, sequence))
} }
// SetPacketCommitment sets the packet commitment hash to the store // SetPacketCommitment sets the packet commitment hash to the store
func (k Keeper) SetPacketCommitment(ctx sdk.Context, portID, channelID string, sequence uint64, commitmentHash []byte) { func (k Keeper) SetPacketCommitment(ctx sdk.Context, portID, channelID string, sequence uint64, commitmentHash []byte) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
store.Set(host.KeyPacketCommitment(portID, channelID, sequence), commitmentHash) store.Set(host.PacketCommitmentKey(portID, channelID, sequence), commitmentHash)
} }
func (k Keeper) deletePacketCommitment(ctx sdk.Context, portID, channelID string, sequence uint64) { func (k Keeper) deletePacketCommitment(ctx sdk.Context, portID, channelID string, sequence uint64) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
store.Delete(host.KeyPacketCommitment(portID, channelID, sequence)) store.Delete(host.PacketCommitmentKey(portID, channelID, sequence))
} }
// SetPacketAcknowledgement sets the packet ack hash to the store // SetPacketAcknowledgement sets the packet ack hash to the store
func (k Keeper) SetPacketAcknowledgement(ctx sdk.Context, portID, channelID string, sequence uint64, ackHash []byte) { func (k Keeper) SetPacketAcknowledgement(ctx sdk.Context, portID, channelID string, sequence uint64, ackHash []byte) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
store.Set(host.KeyPacketAcknowledgement(portID, channelID, sequence), ackHash) store.Set(host.PacketAcknowledgementKey(portID, channelID, sequence), ackHash)
} }
// GetPacketAcknowledgement gets the packet ack hash from the store // GetPacketAcknowledgement gets the packet ack hash from the store
func (k Keeper) GetPacketAcknowledgement(ctx sdk.Context, portID, channelID string, sequence uint64) ([]byte, bool) { func (k Keeper) GetPacketAcknowledgement(ctx sdk.Context, portID, channelID string, sequence uint64) ([]byte, bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
bz := store.Get(host.KeyPacketAcknowledgement(portID, channelID, sequence)) bz := store.Get(host.PacketAcknowledgementKey(portID, channelID, sequence))
if bz == nil { if bz == nil {
return nil, false return nil, false
} }
@ -189,7 +189,7 @@ func (k Keeper) GetPacketAcknowledgement(ctx sdk.Context, portID, channelID stri
// HasPacketAcknowledgement check if the packet ack hash is already on the store // HasPacketAcknowledgement check if the packet ack hash is already on the store
func (k Keeper) HasPacketAcknowledgement(ctx sdk.Context, portID, channelID string, sequence uint64) bool { func (k Keeper) HasPacketAcknowledgement(ctx sdk.Context, portID, channelID string, sequence uint64) bool {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
return store.Has(host.KeyPacketAcknowledgement(portID, channelID, sequence)) return store.Has(host.PacketAcknowledgementKey(portID, channelID, sequence))
} }
// IteratePacketSequence provides an iterator over all send, receive or ack sequences. // IteratePacketSequence provides an iterator over all send, receive or ack sequences.
@ -330,7 +330,7 @@ func (k Keeper) GetAllPacketAcks(ctx sdk.Context) (acks []types.PacketState) {
// and stop. // and stop.
func (k Keeper) IterateChannels(ctx sdk.Context, cb func(types.IdentifiedChannel) bool) { func (k Keeper) IterateChannels(ctx sdk.Context, cb func(types.IdentifiedChannel) bool) {
store := ctx.KVStore(k.storeKey) store := ctx.KVStore(k.storeKey)
iterator := sdk.KVStorePrefixIterator(store, []byte(host.KeyChannelPrefix)) iterator := sdk.KVStorePrefixIterator(store, []byte(host.KeyChannelEndPrefix))
defer iterator.Close() defer iterator.Close()
for ; iterator.Valid(); iterator.Next() { for ; iterator.Valid(); iterator.Next() {

3
x/ibc/core/04-channel/keeper/keeper_test.go
View File

@ -30,6 +30,9 @@ func (suite *KeeperTestSuite) SetupTest() {
suite.coordinator = ibctesting.NewCoordinator(suite.T(), 2) suite.coordinator = ibctesting.NewCoordinator(suite.T(), 2)
suite.chainA = suite.coordinator.GetChain(ibctesting.GetChainID(0)) suite.chainA = suite.coordinator.GetChain(ibctesting.GetChainID(0))
suite.chainB = suite.coordinator.GetChain(ibctesting.GetChainID(1)) suite.chainB = suite.coordinator.GetChain(ibctesting.GetChainID(1))
// commit some blocks so that QueryProof returns valid proof (cannot return valid query if height <= 1)
suite.coordinator.CommitNBlocks(suite.chainA, 2)
suite.coordinator.CommitNBlocks(suite.chainB, 2)
} }
// TestSetChannel create clients and connections on both chains. It tests for the non-existence // TestSetChannel create clients and connections on both chains. It tests for the non-existence

4
x/ibc/core/04-channel/keeper/packet_test.go
View File

@ -345,7 +345,7 @@ func (suite *KeeperTestSuite) TestRecvPacket() {
tc.malleate() tc.malleate()
// get proof of packet commitment from chainA // get proof of packet commitment from chainA
packetKey := host.KeyPacketCommitment(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence()) packetKey := host.PacketCommitmentKey(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
proof, proofHeight := suite.chainA.QueryProof(packetKey) proof, proofHeight := suite.chainA.QueryProof(packetKey)
err := suite.chainB.App.IBCKeeper.ChannelKeeper.RecvPacket(suite.chainB.GetContext(), channelCap, packet, proof, proofHeight) err := suite.chainB.App.IBCKeeper.ChannelKeeper.RecvPacket(suite.chainB.GetContext(), channelCap, packet, proof, proofHeight)
@ -622,7 +622,7 @@ func (suite *KeeperTestSuite) TestAcknowledgePacket() {
suite.SetupTest() // reset suite.SetupTest() // reset
tc.malleate() tc.malleate()
packetKey := host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey := host.PacketAcknowledgementKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
proof, proofHeight := suite.chainB.QueryProof(packetKey) proof, proofHeight := suite.chainB.QueryProof(packetKey)
err := suite.chainA.App.IBCKeeper.ChannelKeeper.AcknowledgePacket(suite.chainA.GetContext(), channelCap, packet, ack, proof, proofHeight) err := suite.chainA.App.IBCKeeper.ChannelKeeper.AcknowledgePacket(suite.chainA.GetContext(), channelCap, packet, ack, proof, proofHeight)

10
x/ibc/core/04-channel/keeper/timeout_test.go
View File

@ -125,8 +125,8 @@ func (suite *KeeperTestSuite) TestTimeoutPacket() {
nextSeqRecv = 1 // must be explicitly changed nextSeqRecv = 1 // must be explicitly changed
tc.malleate() tc.malleate()
orderedPacketKey := host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) orderedPacketKey := host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
unorderedPacketKey := host.KeyPacketReceipt(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) unorderedPacketKey := host.PacketReceiptKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
if ordered { if ordered {
proof, proofHeight = suite.chainB.QueryProof(orderedPacketKey) proof, proofHeight = suite.chainB.QueryProof(orderedPacketKey)
@ -326,9 +326,9 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
nextSeqRecv = 1 // must be explicitly changed nextSeqRecv = 1 // must be explicitly changed
tc.malleate() tc.malleate()
channelKey := host.KeyChannel(packet.GetDestPort(), packet.GetDestChannel()) channelKey := host.ChannelKey(packet.GetDestPort(), packet.GetDestChannel())
unorderedPacketKey := host.KeyPacketReceipt(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) unorderedPacketKey := host.PacketReceiptKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
orderedPacketKey := host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) orderedPacketKey := host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
proofClosed, proofHeight := suite.chainB.QueryProof(channelKey) proofClosed, proofHeight := suite.chainB.QueryProof(channelKey)

2
x/ibc/core/04-channel/simulation/decoder.go
View File

@ -15,7 +15,7 @@ import (
// Value to the corresponding channel type. // Value to the corresponding channel type.
func NewDecodeStore(cdc codec.BinaryMarshaler, kvA, kvB kv.Pair) (string, bool) { func NewDecodeStore(cdc codec.BinaryMarshaler, kvA, kvB kv.Pair) (string, bool) {
switch { switch {
case bytes.HasPrefix(kvA.Key, []byte(host.KeyChannelPrefix)): case bytes.HasPrefix(kvA.Key, []byte(host.KeyChannelEndPrefix)):
var channelA, channelB types.Channel var channelA, channelB types.Channel
cdc.MustUnmarshalBinaryBare(kvA.Value, &channelA) cdc.MustUnmarshalBinaryBare(kvA.Value, &channelA)
cdc.MustUnmarshalBinaryBare(kvB.Value, &channelB) cdc.MustUnmarshalBinaryBare(kvB.Value, &channelB)

12
x/ibc/core/04-channel/simulation/decoder_test.go
View File

@ -31,27 +31,27 @@ func TestDecodeStore(t *testing.T) {
kvPairs := kv.Pairs{ kvPairs := kv.Pairs{
Pairs: []kv.Pair{ Pairs: []kv.Pair{
{ {
Key: host.KeyChannel(portID, channelID), Key: host.ChannelKey(portID, channelID),
Value: cdc.MustMarshalBinaryBare(&channel), Value: cdc.MustMarshalBinaryBare(&channel),
}, },
{ {
Key: host.KeyNextSequenceSend(portID, channelID), Key: host.NextSequenceSendKey(portID, channelID),
Value: sdk.Uint64ToBigEndian(1), Value: sdk.Uint64ToBigEndian(1),
}, },
{ {
Key: host.KeyNextSequenceRecv(portID, channelID), Key: host.NextSequenceRecvKey(portID, channelID),
Value: sdk.Uint64ToBigEndian(1), Value: sdk.Uint64ToBigEndian(1),
}, },
{ {
Key: host.KeyNextSequenceAck(portID, channelID), Key: host.NextSequenceAckKey(portID, channelID),
Value: sdk.Uint64ToBigEndian(1), Value: sdk.Uint64ToBigEndian(1),
}, },
{ {
Key: host.KeyPacketCommitment(portID, channelID, 1), Key: host.PacketCommitmentKey(portID, channelID, 1),
Value: bz, Value: bz,
}, },
{ {
Key: host.KeyPacketAcknowledgement(portID, channelID, 1), Key: host.PacketAcknowledgementKey(portID, channelID, 1),
Value: bz, Value: bz,
}, },
{ {

5
x/ibc/core/04-channel/types/msgs_test.go
View File

@ -93,9 +93,10 @@ func (suite *TypesTestSuite) SetupTest() {
Prove: true, Prove: true,
}) })
merkleProof := commitmenttypes.MerkleProof{Proof: res.ProofOps} merkleProof, err := commitmenttypes.ConvertProofs(res.ProofOps)
suite.Require().NoError(err)
proof, err := app.AppCodec().MarshalBinaryBare(&merkleProof) proof, err := app.AppCodec().MarshalBinaryBare(&merkleProof)
suite.NoError(err) suite.Require().NoError(err)
suite.proof = proof suite.proof = proof
} }

188
x/ibc/core/04-channel/types/query.pb.go
View File

@ -1699,100 +1699,100 @@ func init() {
func init() { proto.RegisterFile("ibc/core/channel/v1/query.proto", fileDescriptor_1034a1e9abc4cca1) } func init() { proto.RegisterFile("ibc/core/channel/v1/query.proto", fileDescriptor_1034a1e9abc4cca1) }
var fileDescriptor_1034a1e9abc4cca1 = []byte{ var fileDescriptor_1034a1e9abc4cca1 = []byte{
// 1488 bytes of a gzipped FileDescriptorProto // 1487 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x59, 0xcf, 0x6f, 0x13, 0xc7, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x59, 0xdf, 0x6b, 0x14, 0xd7,
0x17, 0xcf, 0x38, 0x01, 0x92, 0xc7, 0xef, 0x49, 0x02, 0x61, 0x09, 0x4e, 0xf0, 0x57, 0x7c, 0x1b, 0x17, 0xcf, 0xdd, 0x44, 0x4d, 0x8e, 0xbf, 0x6f, 0x12, 0x8d, 0x63, 0x5c, 0xe3, 0x7e, 0xbf, 0x6d,
0x90, 0xd8, 0x21, 0x81, 0xd2, 0xa8, 0x6a, 0x91, 0x48, 0xa4, 0x42, 0xaa, 0xf2, 0x6b, 0x29, 0x2a, 0xa3, 0xe0, 0x5c, 0x13, 0xad, 0x15, 0x8a, 0x2d, 0x31, 0x50, 0x1b, 0x50, 0x6b, 0x47, 0x6d, 0x55,
0x20, 0xb5, 0xee, 0x7a, 0x3d, 0x38, 0xab, 0x24, 0xbb, 0xc6, 0xbb, 0x36, 0x41, 0xa9, 0xab, 0xaa, 0x5a, 0x97, 0xd9, 0xd9, 0xeb, 0x66, 0x48, 0x32, 0xb3, 0xee, 0xcc, 0xc6, 0x84, 0xb0, 0xd0, 0x56,
0x95, 0x80, 0x53, 0x55, 0x89, 0x43, 0xa5, 0x5e, 0x2a, 0x55, 0xbd, 0x70, 0xec, 0x5f, 0xd0, 0x2b, 0x90, 0x52, 0x2a, 0x14, 0xa4, 0x14, 0xfa, 0xd2, 0x97, 0x42, 0xf1, 0xb1, 0xff, 0x43, 0x1f, 0x7c,
0xb7, 0x22, 0xd1, 0x43, 0x25, 0x24, 0x5a, 0x91, 0x4a, 0xf4, 0xda, 0x4b, 0xcf, 0xd5, 0xce, 0xbc, 0xe8, 0x83, 0xd0, 0x16, 0x2c, 0x05, 0x2b, 0x5a, 0xa8, 0x0f, 0x7d, 0x6e, 0x5f, 0xcb, 0xdc, 0x7b,
0x5d, 0xef, 0xda, 0xbb, 0x9b, 0x38, 0x8e, 0xa5, 0xa8, 0xa7, 0x78, 0x67, 0xe7, 0xbd, 0xf9, 0x7c, 0xe6, 0xd7, 0xee, 0xcc, 0x24, 0xeb, 0x66, 0x41, 0xfa, 0x94, 0x9d, 0x3b, 0xe7, 0x9c, 0xfb, 0xf9,
0x3e, 0x6f, 0xde, 0xf3, 0x7b, 0x0e, 0x8c, 0x99, 0x05, 0x83, 0x19, 0x76, 0x85, 0x33, 0x63, 0x5e, 0x7c, 0xce, 0x3d, 0x67, 0xef, 0xd9, 0xc0, 0x7e, 0xb3, 0x64, 0x30, 0xc3, 0xae, 0x71, 0x66, 0xcc,
0xb7, 0x2c, 0xbe, 0xc8, 0x6a, 0x93, 0xec, 0x6e, 0x95, 0x57, 0xee, 0xab, 0xe5, 0x8a, 0xed, 0xda, 0xea, 0x96, 0xc5, 0xe7, 0xd9, 0xe2, 0x04, 0xbb, 0x51, 0xe7, 0xb5, 0x65, 0xb5, 0x5a, 0xb3, 0x5d,
0x74, 0xd0, 0x2c, 0x18, 0xaa, 0xb7, 0x41, 0xc5, 0x0d, 0x6a, 0x6d, 0x52, 0x09, 0x59, 0x2d, 0x9a, 0x9b, 0x0e, 0x9a, 0x25, 0x43, 0xf5, 0x0c, 0x54, 0x34, 0x50, 0x17, 0x27, 0x94, 0x88, 0xd7, 0xbc,
0xdc, 0x72, 0x3d, 0x23, 0xf9, 0x49, 0x5a, 0x29, 0x27, 0x0c, 0xdb, 0x59, 0xb2, 0x1d, 0x56, 0xd0, 0xc9, 0x2d, 0xd7, 0x73, 0x92, 0x9f, 0xa4, 0x97, 0x72, 0xc8, 0xb0, 0x9d, 0x05, 0xdb, 0x61, 0x25,
0x1d, 0x2e, 0xdd, 0xb1, 0xda, 0x64, 0x81, 0xbb, 0xfa, 0x24, 0x2b, 0xeb, 0x25, 0xd3, 0xd2, 0x5d, 0xdd, 0xe1, 0x32, 0x1c, 0x5b, 0x9c, 0x28, 0x71, 0x57, 0x9f, 0x60, 0x55, 0xbd, 0x62, 0x5a, 0xba,
0xd3, 0xb6, 0x70, 0xef, 0xd1, 0x38, 0x08, 0xfe, 0x61, 0x72, 0xcb, 0x68, 0xc9, 0xb6, 0x4b, 0x8b, 0x6b, 0xda, 0x16, 0xda, 0x1e, 0x48, 0x82, 0xe0, 0x6f, 0x26, 0x4d, 0x46, 0x2b, 0xb6, 0x5d, 0x99,
0x9c, 0xe9, 0x65, 0x93, 0xe9, 0x96, 0x65, 0xbb, 0xc2, 0xde, 0xc1, 0xb7, 0x87, 0xf0, 0xad, 0x78, 0xe7, 0x4c, 0xaf, 0x9a, 0x4c, 0xb7, 0x2c, 0xdb, 0x15, 0xfe, 0x0e, 0xbe, 0xdd, 0x83, 0x6f, 0xc5,
0x2a, 0x54, 0xef, 0x30, 0xdd, 0x42, 0xf4, 0xca, 0x50, 0xc9, 0x2e, 0xd9, 0xe2, 0x23, 0xf3, 0x3e, 0x53, 0xa9, 0x7e, 0x9d, 0xe9, 0x16, 0xa2, 0x57, 0x86, 0x2a, 0x76, 0xc5, 0x16, 0x1f, 0x99, 0xf7,
0xc9, 0xd5, 0xdc, 0x25, 0x18, 0xbc, 0xe6, 0x61, 0x9a, 0x95, 0x87, 0x68, 0xfc, 0x6e, 0x95, 0x3b, 0x49, 0xae, 0x16, 0xce, 0xc2, 0xe0, 0xbb, 0x1e, 0xa6, 0x69, 0xb9, 0x89, 0xc6, 0x6f, 0xd4, 0xb9,
0x2e, 0x3d, 0x08, 0x3b, 0xca, 0x76, 0xc5, 0xcd, 0x9b, 0xc5, 0x11, 0x32, 0x4e, 0x26, 0x06, 0xb4, 0xe3, 0xd2, 0xdd, 0xb0, 0xa9, 0x6a, 0xd7, 0xdc, 0xa2, 0x59, 0x1e, 0x21, 0x63, 0x64, 0x7c, 0x40,
0xed, 0xde, 0xe3, 0x5c, 0x91, 0x1e, 0x01, 0x40, 0x3c, 0xde, 0xbb, 0x8c, 0x78, 0x37, 0x80, 0x2b, 0xdb, 0xe8, 0x3d, 0xce, 0x94, 0xe9, 0x3e, 0x00, 0xc4, 0xe3, 0xbd, 0xcb, 0x89, 0x77, 0x03, 0xb8,
0x73, 0xc5, 0xdc, 0x13, 0x02, 0x43, 0x51, 0x7f, 0x4e, 0xd9, 0xb6, 0x1c, 0x4e, 0xcf, 0xc2, 0x0e, 0x32, 0x53, 0x2e, 0xdc, 0x23, 0x30, 0x14, 0x8f, 0xe7, 0x54, 0x6d, 0xcb, 0xe1, 0xf4, 0x38, 0x6c,
0xdc, 0x25, 0x1c, 0xee, 0x9c, 0x1a, 0x55, 0x63, 0xd4, 0x54, 0x7d, 0x33, 0x7f, 0x33, 0x1d, 0x82, 0x42, 0x2b, 0x11, 0x70, 0xf3, 0xe4, 0xa8, 0x9a, 0xa0, 0xa6, 0xea, 0xbb, 0xf9, 0xc6, 0x74, 0x08,
0x6d, 0xe5, 0x8a, 0x6d, 0xdf, 0x11, 0x47, 0xed, 0xd2, 0xe4, 0x03, 0x9d, 0x85, 0x5d, 0xe2, 0x43, 0x36, 0x54, 0x6b, 0xb6, 0x7d, 0x5d, 0x6c, 0xb5, 0x45, 0x93, 0x0f, 0x74, 0x1a, 0xb6, 0x88, 0x0f,
0x7e, 0x9e, 0x9b, 0xa5, 0x79, 0x77, 0xa4, 0x57, 0xb8, 0x54, 0x42, 0x2e, 0x65, 0x04, 0x6a, 0x93, 0xc5, 0x59, 0x6e, 0x56, 0x66, 0xdd, 0x91, 0x5e, 0x11, 0x52, 0x89, 0x84, 0x94, 0x19, 0x58, 0x9c,
0xea, 0x45, 0xb1, 0x63, 0xa6, 0xef, 0xe9, 0xcb, 0xb1, 0x1e, 0x6d, 0xa7, 0xb0, 0x92, 0x4b, 0xb9, 0x50, 0xdf, 0x16, 0x16, 0xa7, 0xfa, 0xee, 0x3f, 0xda, 0xdf, 0xa3, 0x6d, 0x16, 0x5e, 0x72, 0xa9,
0x4f, 0xa2, 0x50, 0x1d, 0x9f, 0xfb, 0x7b, 0x00, 0x8d, 0xc0, 0x20, 0xda, 0xff, 0xab, 0x32, 0x8a, 0x70, 0x2d, 0x0e, 0xd5, 0xf1, 0xb9, 0xbf, 0x05, 0x10, 0x26, 0x06, 0xd1, 0xbe, 0xac, 0xca, 0x2c,
0xaa, 0x17, 0x45, 0x55, 0x5e, 0x0a, 0x8c, 0xa2, 0x7a, 0x55, 0x2f, 0x71, 0xb4, 0xd5, 0x42, 0x96, 0xaa, 0x5e, 0x16, 0x55, 0x79, 0x28, 0x30, 0x8b, 0xea, 0x79, 0xbd, 0xc2, 0xd1, 0x57, 0x8b, 0x78,
0xb9, 0x97, 0x04, 0x86, 0x9b, 0x0e, 0x40, 0x31, 0x66, 0xa0, 0x1f, 0xf9, 0x39, 0x23, 0x64, 0xbc, 0x16, 0x1e, 0x11, 0x18, 0x6e, 0xda, 0x00, 0xc5, 0x38, 0x05, 0xfd, 0xc8, 0xcf, 0x19, 0x21, 0x63,
0x57, 0xf8, 0x8f, 0x53, 0x63, 0xae, 0xc8, 0x2d, 0xd7, 0xbc, 0x63, 0xf2, 0xa2, 0xaf, 0x4b, 0x60, 0xbd, 0x22, 0x7e, 0x92, 0x1a, 0x33, 0x65, 0x6e, 0xb9, 0xe6, 0x75, 0x93, 0x97, 0x7d, 0x5d, 0x02,
0x47, 0x2f, 0x44, 0x50, 0x66, 0x04, 0xca, 0x37, 0xd6, 0x44, 0x29, 0x01, 0x84, 0x61, 0xd2, 0x69, 0x3f, 0x7a, 0x3a, 0x86, 0x32, 0x27, 0x50, 0xbe, 0xb2, 0x2a, 0x4a, 0x09, 0x20, 0x0a, 0x93, 0x9e,
0xd8, 0xde, 0xa6, 0x8a, 0xb8, 0x3f, 0xf7, 0x88, 0x40, 0x56, 0x12, 0xb4, 0x2d, 0x8b, 0x1b, 0x9e, 0x80, 0x8d, 0x6d, 0xaa, 0x88, 0xf6, 0x85, 0x4f, 0x09, 0xe4, 0x25, 0x41, 0xdb, 0xb2, 0xb8, 0xe1,
0xb7, 0x66, 0x2d, 0xb3, 0x00, 0x46, 0xf0, 0x12, 0xaf, 0x52, 0x68, 0xa5, 0x49, 0xeb, 0xcc, 0x86, 0x45, 0x6b, 0xd6, 0x32, 0x0f, 0x60, 0x04, 0x2f, 0xf1, 0x28, 0x45, 0x56, 0x9a, 0xb4, 0xce, 0x3d,
0xb5, 0xfe, 0x8b, 0xc0, 0x58, 0x22, 0x94, 0xff, 0x96, 0xea, 0x37, 0x7d, 0xd1, 0x25, 0xa6, 0x59, 0xb7, 0xd6, 0xcf, 0x08, 0xec, 0x4f, 0x85, 0xf2, 0xdf, 0x52, 0xfd, 0xb2, 0x2f, 0xba, 0xc4, 0x34,
0xb1, 0xfb, 0xba, 0xab, 0xbb, 0xbc, 0xd3, 0xe4, 0xfd, 0x3d, 0x10, 0x31, 0xc6, 0x35, 0x8a, 0xa8, 0x2d, 0xac, 0x2f, 0xb8, 0xba, 0xcb, 0x3b, 0x2d, 0xde, 0xdf, 0x03, 0x11, 0x13, 0x42, 0xa3, 0x88,
0xc3, 0x41, 0x33, 0xd0, 0x27, 0x2f, 0xa1, 0xe6, 0x1d, 0x6f, 0x0b, 0x66, 0xca, 0xf1, 0x38, 0x22, 0x3a, 0xec, 0x36, 0x03, 0x7d, 0x8a, 0x12, 0x6a, 0xd1, 0xf1, 0x4c, 0xb0, 0x52, 0x0e, 0x26, 0x11,
0x21, 0x49, 0x43, 0x3e, 0x87, 0xcd, 0xb8, 0xe5, 0x6e, 0xa6, 0xfc, 0x13, 0x02, 0x47, 0x23, 0x0c, 0x89, 0x48, 0x1a, 0x89, 0x39, 0x6c, 0x26, 0x2d, 0x77, 0xb3, 0xe4, 0xef, 0x11, 0x38, 0x10, 0x63,
0x3d, 0x4e, 0x96, 0x53, 0x75, 0x36, 0x43, 0x3f, 0x7a, 0x0c, 0xf6, 0xd4, 0x78, 0xc5, 0x31, 0x6d, 0xe8, 0x71, 0xb2, 0x9c, 0xba, 0xb3, 0x1e, 0xfa, 0xd1, 0x97, 0x60, 0xdb, 0x22, 0xaf, 0x39, 0xa6,
0x2b, 0x6f, 0x55, 0x97, 0x0a, 0xbc, 0x22, 0x40, 0xf6, 0x69, 0xbb, 0x71, 0xf5, 0xb2, 0x58, 0x0c, 0x6d, 0x15, 0xad, 0xfa, 0x42, 0x89, 0xd7, 0x04, 0xc8, 0x3e, 0x6d, 0x2b, 0xae, 0x9e, 0x13, 0x8b,
0x6f, 0x43, 0x2e, 0x7d, 0x91, 0x6d, 0x88, 0xf5, 0x05, 0x81, 0x5c, 0x1a, 0x56, 0x0c, 0xc8, 0xbb, 0x51, 0x33, 0xe4, 0xd2, 0x17, 0x33, 0x43, 0xac, 0xbf, 0x11, 0x28, 0x64, 0x61, 0xc5, 0x84, 0x9c,
0xb0, 0xd7, 0xf0, 0xdf, 0x44, 0x02, 0x31, 0xa4, 0xca, 0xef, 0x02, 0xd5, 0xff, 0x2e, 0x50, 0xcf, 0x84, 0xed, 0x86, 0xff, 0x26, 0x96, 0x88, 0x21, 0x55, 0x7e, 0x17, 0xa8, 0xfe, 0x77, 0x81, 0x3a,
0x5b, 0xf7, 0xb5, 0x3d, 0x46, 0xc4, 0x0d, 0x3d, 0x0c, 0x03, 0x18, 0xc4, 0x80, 0x51, 0xbf, 0x5c, 0x65, 0x2d, 0x6b, 0xdb, 0x8c, 0x58, 0x18, 0xba, 0x17, 0x06, 0x30, 0x89, 0x01, 0xa3, 0x7e, 0xb9,
0x98, 0x2b, 0x36, 0x22, 0xd1, 0x9b, 0x16, 0x89, 0xbe, 0x8d, 0x44, 0xa2, 0x02, 0xa3, 0x82, 0xdc, 0x30, 0x53, 0x0e, 0x33, 0xd1, 0x9b, 0x95, 0x89, 0xbe, 0xe7, 0xc9, 0x44, 0x0d, 0x46, 0x05, 0xb9,
0x55, 0xdd, 0x58, 0xe0, 0xee, 0xac, 0xbd, 0xb4, 0x64, 0xba, 0x4b, 0xdc, 0x72, 0x3b, 0x8d, 0x81, 0xf3, 0xba, 0x31, 0xc7, 0xdd, 0x69, 0x7b, 0x61, 0xc1, 0x74, 0x17, 0xb8, 0xe5, 0x76, 0x9a, 0x03,
0x02, 0xfd, 0x8e, 0xe7, 0xc2, 0x32, 0x38, 0xaa, 0x1f, 0x3c, 0xe7, 0xbe, 0x23, 0x70, 0x24, 0xe1, 0x05, 0xfa, 0x1d, 0x2f, 0x84, 0x65, 0x70, 0x54, 0x3f, 0x78, 0x2e, 0x7c, 0x4d, 0x60, 0x5f, 0xca,
0x50, 0x14, 0x53, 0x94, 0x2b, 0x7f, 0x55, 0x1c, 0xbc, 0x4b, 0x0b, 0xad, 0x74, 0xf3, 0x6a, 0x7e, 0xa6, 0x28, 0xa6, 0x68, 0x57, 0xfe, 0xaa, 0xd8, 0x78, 0x8b, 0x16, 0x59, 0xe9, 0xe6, 0xd1, 0xfc,
0x9f, 0x04, 0xce, 0xe9, 0x54, 0x92, 0x68, 0x8d, 0xed, 0xdd, 0x70, 0x8d, 0x7d, 0xed, 0x97, 0xfb, 0x26, 0x0d, 0x9c, 0xd3, 0xa9, 0x24, 0xf1, 0x1e, 0xdb, 0xfb, 0xdc, 0x3d, 0xf6, 0x4f, 0xbf, 0xdd,
0x18, 0x84, 0x41, 0x89, 0xdd, 0xd9, 0x50, 0xcb, 0xaf, 0xb2, 0xe3, 0xb1, 0x55, 0x56, 0x3a, 0x91, 0x27, 0x20, 0x0c, 0x5a, 0xec, 0xe6, 0x50, 0x2d, 0xbf, 0xcb, 0x8e, 0x25, 0x76, 0x59, 0x19, 0x44,
0x77, 0x39, 0x6c, 0xb4, 0x15, 0x4a, 0xac, 0x0d, 0x87, 0x42, 0x44, 0x35, 0x6e, 0x70, 0xb3, 0xdc, 0x9e, 0xe5, 0xa8, 0xd3, 0x8b, 0xd0, 0x62, 0x6d, 0xd8, 0x13, 0x21, 0xaa, 0x71, 0x83, 0x9b, 0xd5,
0xd5, 0x9b, 0xf9, 0x98, 0x80, 0x12, 0x77, 0x22, 0xca, 0xaa, 0x40, 0x7f, 0xc5, 0x5b, 0xaa, 0x71, 0xae, 0x9e, 0xcc, 0xbb, 0x04, 0x94, 0xa4, 0x1d, 0x51, 0x56, 0x05, 0xfa, 0x6b, 0xde, 0xd2, 0x22,
0xe9, 0xb7, 0x5f, 0x0b, 0x9e, 0xbb, 0x99, 0xa3, 0xf7, 0xb0, 0x58, 0x4a, 0x50, 0xe7, 0x8d, 0x05, 0x97, 0x71, 0xfb, 0xb5, 0xe0, 0xb9, 0x9b, 0x35, 0x7a, 0x13, 0x9b, 0xa5, 0x04, 0x35, 0x65, 0xcc,
0xcb, 0xbe, 0xb7, 0xc8, 0x8b, 0x25, 0xde, 0xed, 0x44, 0x7d, 0xe2, 0x97, 0xbe, 0x84, 0x93, 0x51, 0x59, 0xf6, 0xcd, 0x79, 0x5e, 0xae, 0xf0, 0x6e, 0x17, 0xea, 0x3d, 0xbf, 0xf5, 0xa5, 0xec, 0x8c,
0x96, 0x09, 0xd8, 0xab, 0x47, 0x5f, 0x61, 0xca, 0x36, 0x2f, 0x77, 0x33, 0x6f, 0x7f, 0x4c, 0xc5, 0xb2, 0x8c, 0xc3, 0x76, 0x3d, 0xfe, 0x0a, 0x4b, 0xb6, 0x79, 0xb9, 0x9b, 0x75, 0xfb, 0x6d, 0x26,
0xba, 0x65, 0x92, 0xf7, 0x1f, 0x02, 0xff, 0x4b, 0x85, 0x89, 0x9a, 0x7e, 0x00, 0xfb, 0x9a, 0xc4, 0xd6, 0x17, 0xa6, 0x78, 0xff, 0x26, 0xf0, 0xbf, 0x4c, 0x98, 0xa8, 0xe9, 0x19, 0xd8, 0xd1, 0x24,
0x5b, 0x7f, 0x1a, 0xb7, 0x58, 0x6e, 0x85, 0x5c, 0xfe, 0xd6, 0xaf, 0xab, 0x37, 0x2c, 0x3f, 0x67, 0xde, 0xda, 0xcb, 0xb8, 0xc5, 0xf3, 0x45, 0xa8, 0xe5, 0xaf, 0xfc, 0xbe, 0x7a, 0xc9, 0xf2, 0x6b,
0x24, 0xe6, 0x8e, 0x43, 0x73, 0x0e, 0x0e, 0x97, 0x85, 0xa7, 0x7c, 0xa3, 0x7c, 0xe5, 0xfd, 0x3b, 0x46, 0x62, 0xee, 0x38, 0x35, 0x6f, 0xc0, 0xde, 0xaa, 0x88, 0x54, 0x0c, 0xdb, 0x57, 0xd1, 0x3f,
0xec, 0x8c, 0xf4, 0x8e, 0xf7, 0x4e, 0xf4, 0x69, 0x87, 0xca, 0x4d, 0xc5, 0xf2, 0xba, 0xbf, 0x21, 0xc3, 0xce, 0x48, 0xef, 0x58, 0xef, 0x78, 0x9f, 0xb6, 0xa7, 0xda, 0xd4, 0x2c, 0x2f, 0xf8, 0x06,
0xb7, 0x8c, 0xe5, 0x34, 0x06, 0x18, 0x06, 0x63, 0x14, 0x06, 0x1a, 0xfe, 0x88, 0xf0, 0xd7, 0x58, 0x85, 0x25, 0x6c, 0xa7, 0x09, 0xc0, 0x30, 0x19, 0xa3, 0x30, 0x10, 0xc6, 0x23, 0x22, 0x5e, 0xb8,
0x08, 0x69, 0x92, 0x69, 0x53, 0x93, 0x07, 0x7e, 0xb9, 0x69, 0x1c, 0x7d, 0xde, 0x58, 0xe8, 0x58, 0x10, 0xd1, 0x24, 0xd7, 0xa6, 0x26, 0xb7, 0xfd, 0x76, 0x13, 0x6e, 0x3d, 0x65, 0xcc, 0x75, 0x2c,
0x90, 0x53, 0x30, 0x84, 0x82, 0xe8, 0xc6, 0x42, 0x8b, 0x12, 0xb4, 0xec, 0xdf, 0xbc, 0x86, 0x04, 0xc8, 0x11, 0x18, 0x42, 0x41, 0x74, 0x63, 0xae, 0x45, 0x09, 0x5a, 0xf5, 0x4f, 0x5e, 0x28, 0x41,
0x55, 0x38, 0x1c, 0x8b, 0xa3, 0xcb, 0xfc, 0x6f, 0x61, 0x9f, 0x7b, 0x99, 0x2f, 0x07, 0xf1, 0xd0, 0x1d, 0xf6, 0x26, 0xe2, 0xe8, 0x32, 0xff, 0x2b, 0x78, 0xcf, 0x3d, 0xc7, 0x97, 0x82, 0x7c, 0x68,
0x24, 0x80, 0x4e, 0x7b, 0xe8, 0x9f, 0x08, 0x8c, 0x27, 0xfb, 0x46, 0x5e, 0x53, 0x30, 0x6c, 0xf1, 0x12, 0x40, 0xa7, 0x77, 0xe8, 0xef, 0x09, 0x8c, 0xa5, 0xc7, 0x46, 0x5e, 0x93, 0x30, 0x6c, 0xf1,
0xe5, 0xc6, 0x65, 0xc9, 0x23, 0x7b, 0x71, 0x54, 0x9f, 0x36, 0x68, 0xb5, 0xda, 0x76, 0xb1, 0x84, 0xa5, 0xf0, 0xb0, 0x14, 0x91, 0xbd, 0xd8, 0xaa, 0x4f, 0x1b, 0xb4, 0x5a, 0x7d, 0xbb, 0xd8, 0xc2,
0x4d, 0x3d, 0x3c, 0x00, 0xdb, 0x04, 0x66, 0xfa, 0x03, 0x81, 0x1d, 0xd8, 0x6e, 0xd2, 0x89, 0xd8, 0x26, 0x7f, 0xdc, 0x05, 0x1b, 0x04, 0x66, 0xfa, 0x1d, 0x81, 0x4d, 0x78, 0xdd, 0xa4, 0xe3, 0x89,
0x7c, 0x8f, 0xf9, 0xb1, 0x40, 0x39, 0xbe, 0x8e, 0x9d, 0x92, 0x79, 0x6e, 0xe6, 0xcb, 0xe7, 0x7f, 0xf5, 0x9e, 0xf0, 0x63, 0x81, 0x72, 0x70, 0x0d, 0x96, 0x92, 0x79, 0xe1, 0xf4, 0x27, 0x3f, 0xfd,
0x3e, 0xce, 0xbc, 0x43, 0xdf, 0x66, 0xe2, 0x97, 0x8e, 0xe0, 0x47, 0x0e, 0xf9, 0x7b, 0x88, 0x3f, 0x71, 0x37, 0x37, 0x45, 0xdf, 0x64, 0x09, 0xbf, 0x74, 0xc8, 0x1f, 0x45, 0xfc, 0x59, 0x8b, 0xad,
0x66, 0xb1, 0x95, 0x86, 0xc4, 0x75, 0xe6, 0x09, 0xef, 0xb0, 0x15, 0x0c, 0x47, 0x9d, 0x3e, 0x22, 0x84, 0x3a, 0x37, 0x98, 0xa7, 0xbe, 0xc3, 0x56, 0x30, 0x27, 0x0d, 0x7a, 0x87, 0x40, 0xbf, 0x3f,
0xd0, 0xef, 0x0f, 0x77, 0x74, 0xed, 0xb3, 0xfd, 0x6b, 0xad, 0x9c, 0x58, 0xcf, 0x56, 0xc4, 0x79, 0xe1, 0xd1, 0xd5, 0x01, 0xf8, 0x67, 0x5b, 0x39, 0xb4, 0x16, 0x53, 0x04, 0x7b, 0x48, 0x80, 0xfd,
0x4c, 0xe0, 0x1c, 0xa3, 0x47, 0x52, 0x71, 0xd2, 0x9f, 0x09, 0xd0, 0xd6, 0x89, 0x93, 0x9e, 0x4e, 0x3f, 0x2d, 0xac, 0x0e, 0x96, 0xfe, 0x40, 0x80, 0xb6, 0xce, 0x9e, 0xf4, 0x68, 0xc6, 0x76, 0x69,
0x39, 0x29, 0x69, 0x54, 0x56, 0xce, 0xb4, 0x67, 0x84, 0x40, 0xcf, 0x09, 0xa0, 0xd3, 0xf4, 0x6c, 0x43, 0xb3, 0x72, 0xac, 0x3d, 0x27, 0x44, 0x3b, 0x2d, 0xd0, 0x9e, 0xa4, 0xaf, 0x67, 0xa0, 0x0d,
0x3c, 0xd0, 0xc0, 0xd0, 0xd3, 0x34, 0x78, 0xa8, 0x37, 0x18, 0x3c, 0xf3, 0x18, 0xb4, 0x8c, 0x7b, 0xbc, 0x3d, 0x75, 0x83, 0x87, 0x46, 0x48, 0xe3, 0x17, 0x8f, 0x46, 0xcb, 0xf4, 0x97, 0x49, 0x23,
0xa9, 0x0c, 0x92, 0xe6, 0xce, 0x54, 0x06, 0x89, 0x13, 0x65, 0xee, 0x8a, 0x60, 0x30, 0x47, 0x2f, 0x6d, 0x0c, 0xcd, 0xa4, 0x91, 0x3a, 0x60, 0x16, 0x2e, 0x0a, 0x1a, 0xe7, 0xe8, 0x99, 0x0e, 0x4f,
0x6c, 0xfc, 0x4a, 0xb0, 0xf0, 0x1c, 0x4a, 0xbf, 0xce, 0xc0, 0x70, 0xec, 0xcc, 0x44, 0xcf, 0xae, 0x08, 0x8b, 0xce, 0xa6, 0xf4, 0xcb, 0x1c, 0x0c, 0x27, 0xce, 0x51, 0xf4, 0xf8, 0xea, 0x28, 0x93,
0x0d, 0x30, 0x6e, 0x20, 0x54, 0xde, 0x6a, 0xdb, 0x0e, 0xb9, 0x7d, 0x45, 0x04, 0xb9, 0x3a, 0x5d, 0x86, 0x44, 0xe5, 0xb5, 0xb6, 0xfd, 0x90, 0xe0, 0x67, 0x44, 0x30, 0xbc, 0x45, 0xe8, 0x47, 0xa4,
0xe9, 0x84, 0x5c, 0x74, 0xbc, 0x63, 0x38, 0x26, 0xb2, 0x95, 0xe8, 0xb0, 0x59, 0x67, 0xb2, 0x06, 0x63, 0x8e, 0xf1, 0xc9, 0x8f, 0xe1, 0x04, 0xc9, 0x56, 0xe2, 0x73, 0x68, 0x83, 0xc9, 0xf6, 0x10,
0x34, 0xd6, 0xe5, 0x73, 0x9d, 0xbe, 0x20, 0xb0, 0xaf, 0xb9, 0x67, 0xa7, 0x93, 0xc9, 0x9c, 0x12, 0xae, 0xcb, 0xe7, 0x06, 0x7d, 0x4c, 0x60, 0x47, 0xf3, 0x75, 0x9e, 0x4e, 0xa4, 0x53, 0x4b, 0x19,
0x66, 0x32, 0x65, 0xaa, 0x1d, 0x13, 0x54, 0xe0, 0x53, 0x21, 0xc0, 0x6d, 0x7a, 0xb3, 0x03, 0x01, 0xd7, 0x94, 0xc9, 0x76, 0x5c, 0x50, 0x08, 0x2e, 0x74, 0x28, 0xd2, 0x0f, 0x3b, 0x55, 0xa1, 0xe5,
0x5a, 0xbe, 0x65, 0x1d, 0xb6, 0xe2, 0x97, 0xce, 0x3a, 0x7d, 0x4e, 0x60, 0x7f, 0xcb, 0x44, 0x42, 0x5b, 0xd8, 0x61, 0x2b, 0x7e, 0x6b, 0x6d, 0xd0, 0x87, 0x04, 0x76, 0xb6, 0x4c, 0x2c, 0xb4, 0x0d,
0xdb, 0xc0, 0x1a, 0x64, 0xe0, 0xe9, 0xb6, 0x6c, 0x90, 0xe0, 0x0d, 0x41, 0xf0, 0x0a, 0xbd, 0xb4, 0xc0, 0x41, 0x5d, 0x1e, 0x6d, 0xcb, 0x07, 0x59, 0x5e, 0x15, 0x2c, 0x2f, 0x52, 0x6d, 0xfd, 0x59,
0xa9, 0x04, 0xe9, 0x2f, 0x04, 0x76, 0x47, 0x86, 0x01, 0xaa, 0xae, 0x85, 0x2e, 0x3a, 0xa7, 0x28, 0xd2, 0x9f, 0x09, 0x6c, 0x8d, 0x4d, 0x0c, 0x54, 0x5d, 0x0d, 0x62, 0x7c, 0x98, 0x51, 0xd8, 0x9a,
0x6c, 0xdd, 0xfb, 0x91, 0xc9, 0xc7, 0x82, 0xc9, 0x47, 0xf4, 0x46, 0xe7, 0x4c, 0x2a, 0xd2, 0x75, 0xed, 0x91, 0x4e, 0x49, 0xd0, 0xf9, 0x80, 0x5e, 0x5d, 0x27, 0x3a, 0x35, 0x19, 0x3f, 0x96, 0xb1,
0x24, 0x4e, 0xab, 0x04, 0x86, 0x63, 0x9b, 0xcf, 0xb4, 0xb4, 0x4c, 0x1b, 0x3d, 0xd2, 0xd2, 0x32, 0x67, 0x04, 0x86, 0x13, 0xaf, 0xa9, 0x59, 0xc5, 0x9a, 0x35, 0xa4, 0x64, 0x15, 0x6b, 0xe6, 0x88,
0x75, 0x70, 0xc8, 0xdd, 0x12, 0x4c, 0xaf, 0xd3, 0x6b, 0x9d, 0x33, 0xd5, 0x8d, 0x85, 0x08, 0xcb, 0x51, 0xb8, 0x26, 0xe8, 0x5e, 0xa6, 0xef, 0xad, 0x13, 0x5d, 0xdd, 0x98, 0x8b, 0x51, 0xfd, 0x8b,
0xd7, 0x04, 0x0e, 0xc4, 0xb7, 0xd8, 0xb4, 0x5d, 0xb8, 0xc1, 0xbd, 0x9c, 0x6e, 0xdf, 0x10, 0x89, 0xc0, 0xae, 0xe4, 0x1b, 0x39, 0x6d, 0x17, 0x73, 0x70, 0x4c, 0x4f, 0xb4, 0xef, 0x88, 0x6c, 0x8b,
0xde, 0x16, 0x44, 0x3f, 0xa4, 0xda, 0xa6, 0x10, 0x8d, 0xd2, 0x79, 0x90, 0x81, 0xfd, 0x2d, 0xad, 0x82, 0xed, 0x15, 0xfa, 0xfe, 0xfa, 0xb1, 0x8d, 0x73, 0xfa, 0x3c, 0x07, 0x3b, 0x5b, 0xae, 0xbb,
0x6b, 0x5a, 0xde, 0x25, 0x35, 0xe0, 0x69, 0x79, 0x97, 0xd8, 0x1b, 0xe7, 0x1e, 0xca, 0xd2, 0xfa, 0x59, 0xb5, 0x98, 0x76, 0x69, 0xcf, 0xaa, 0xc5, 0xd4, 0xfb, 0x74, 0xe1, 0x8e, 0x6c, 0xbd, 0xb7,
0x05, 0xa1, 0x9f, 0x6f, 0x72, 0x69, 0x49, 0x69, 0xea, 0xeb, 0xac, 0x1a, 0x00, 0xca, 0x97, 0x91, 0x09, 0xbd, 0x45, 0xba, 0xd1, 0x74, 0x32, 0xc6, 0x81, 0x06, 0xab, 0x07, 0xb0, 0x8a, 0x55, 0x24,
0xf2, 0xdf, 0x04, 0xf6, 0x44, 0x1b, 0x58, 0xca, 0xd6, 0xc3, 0x28, 0xd4, 0x72, 0x2b, 0xa7, 0xd6, 0xfe, 0x0f, 0x81, 0x6d, 0xf1, 0xab, 0x2f, 0x65, 0x6b, 0xe1, 0x15, 0xb9, 0xac, 0x2b, 0x47, 0xd6,
0x6f, 0x80, 0xfc, 0x3f, 0x13, 0xf4, 0x6b, 0xd4, 0xed, 0x0e, 0xfb, 0x48, 0x07, 0x1f, 0xa1, 0xed, 0xee, 0x80, 0x2a, 0x7c, 0x2c, 0x55, 0x58, 0xa1, 0xcb, 0x5d, 0xd4, 0x20, 0x36, 0x01, 0xc4, 0xc8,
0xdd, 0x78, 0xfa, 0x2b, 0x81, 0xc1, 0x98, 0x0e, 0x97, 0xa6, 0xb4, 0x00, 0xc9, 0xcd, 0xb6, 0xf2, 0x7b, 0x25, 0x40, 0x7f, 0x25, 0x30, 0x98, 0x70, 0x43, 0xa6, 0x19, 0x77, 0x86, 0xf4, 0xcb, 0xba,
0x66, 0x9b, 0x56, 0x28, 0xc1, 0x55, 0x21, 0xc1, 0xfb, 0xf4, 0x62, 0x07, 0x12, 0x44, 0xfa, 0xf0, 0xf2, 0x6a, 0x9b, 0x5e, 0x28, 0xc4, 0x25, 0xa1, 0xc3, 0x3b, 0xf4, 0x6c, 0xa7, 0x3a, 0xc4, 0x2e,
0x19, 0xed, 0xe9, 0xab, 0x2c, 0x79, 0xf6, 0x2a, 0x4b, 0xfe, 0x78, 0x95, 0x25, 0xdf, 0xac, 0x66, 0xf3, 0xa7, 0xb4, 0xfb, 0x4f, 0xf2, 0xe4, 0xc1, 0x93, 0x3c, 0x79, 0xfc, 0x24, 0x4f, 0xbe, 0x78,
0x7b, 0x9e, 0xad, 0x66, 0x7b, 0x7e, 0x5b, 0xcd, 0xf6, 0xdc, 0x9e, 0x2e, 0x99, 0xee, 0x7c, 0xb5, 0x9a, 0xef, 0x79, 0xf0, 0x34, 0xdf, 0xf3, 0xf0, 0x69, 0xbe, 0xe7, 0xea, 0x89, 0x8a, 0xe9, 0xce,
0xa0, 0x1a, 0xf6, 0x12, 0xc3, 0x7f, 0xe8, 0xc9, 0x3f, 0x27, 0x9d, 0xe2, 0x02, 0x5b, 0x66, 0xc1, 0xd6, 0x4b, 0xaa, 0x61, 0x2f, 0x30, 0xfc, 0xaf, 0xa0, 0xfc, 0x73, 0xd8, 0x29, 0xcf, 0xb1, 0xa5,
0x3f, 0xee, 0x4e, 0x9d, 0x39, 0xe9, 0x23, 0x71, 0xef, 0x97, 0xb9, 0x53, 0xd8, 0x2e, 0x7e, 0x7f, 0x10, 0xc6, 0x91, 0x63, 0x87, 0x7d, 0x24, 0xee, 0x72, 0x95, 0x3b, 0xa5, 0x8d, 0xe2, 0x47, 0xdc,
0x3d, 0xfd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x07, 0x22, 0x97, 0x6e, 0x5f, 0x1c, 0x00, 0x00, 0xa3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x48, 0x61, 0x15, 0x26, 0xa4, 0x1c, 0x00, 0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.

26
x/ibc/core/04-channel/types/query.pb.gw.go
View File

@ -1736,31 +1736,31 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
} }
var ( var (
pattern_Query_Channel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_Channel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_Channels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ibc", "channel", "v1beta1", "channels"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_Channels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"ibc", "core", "channel", "v1beta1", "channels"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_ConnectionChannels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"ibc", "channel", "v1beta1", "connections", "connection", "channels"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ConnectionChannels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6}, []string{"ibc", "core", "channel", "v1beta1", "connections", "connection", "channels"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_ChannelClientState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "client_state"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ChannelClientState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "client_state"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_ChannelConsensusState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7, 2, 8, 1, 0, 4, 1, 5, 9, 2, 10, 1, 0, 4, 1, 5, 11}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "consensus_state", "version", "version_number", "height", "version_height"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_ChannelConsensusState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8, 2, 9, 1, 0, 4, 1, 5, 10, 2, 11, 1, 0, 4, 1, 5, 12}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "consensus_state", "version", "version_number", "height", "version_height"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_PacketCommitment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7, 1, 0, 4, 1, 5, 8}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_commitments", "sequence"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_PacketCommitment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8, 1, 0, 4, 1, 5, 9}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_commitments", "sequence"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_PacketCommitments_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_commitments"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_PacketCommitments_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_commitments"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_PacketReceipt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7, 1, 0, 4, 1, 5, 8}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_receipts", "sequence"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_PacketReceipt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8, 1, 0, 4, 1, 5, 9}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_receipts", "sequence"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_PacketAcknowledgement_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7, 1, 0, 4, 1, 5, 8}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_acks", "sequence"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_PacketAcknowledgement_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8, 1, 0, 4, 1, 5, 9}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_acks", "sequence"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_PacketAcknowledgements_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_acknowledgements"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_PacketAcknowledgements_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_acknowledgements"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_UnreceivedPackets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7, 1, 0, 4, 1, 5, 8, 2, 9}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_commitments", "packet_commitment_sequences", "unreceived_packets"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_UnreceivedPackets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8, 1, 0, 4, 1, 5, 9, 2, 10}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_commitments", "packet_commitment_sequences", "unreceived_packets"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_UnreceivedAcks_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7, 1, 0, 4, 1, 5, 8, 2, 9}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_commitments", "packet_ack_sequences", "unreceived_acks"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_UnreceivedAcks_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8, 1, 0, 4, 1, 5, 9, 2, 10}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "packet_commitments", "packet_ack_sequences", "unreceived_acks"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_NextSequenceReceive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7}, []string{"ibc", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "next_sequence"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_NextSequenceReceive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 2, 8}, []string{"ibc", "core", "channel", "v1beta1", "channels", "channel_id", "ports", "port_id", "next_sequence"}, "", runtime.AssumeColonVerbOpt(true)))
) )
var ( var (

526
x/ibc/core/23-commitment/types/commitment.pb.go
View File

@ -5,9 +5,9 @@ package types
import ( import (
fmt "fmt" fmt "fmt"
_go "github.com/confio/ics23/go"
_ "github.com/gogo/protobuf/gogoproto" _ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto" proto "github.com/gogo/protobuf/proto"
crypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
io "io" io "io"
math "math" math "math"
math_bits "math/bits" math_bits "math/bits"
@ -24,34 +24,6 @@ var _ = math.Inf
// proto package needs to be updated. // proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// KeyEncoding defines the encoding format of a key's bytes.
type KeyEncoding int32
const (
// URL encoding
URL KeyEncoding = 0
// Hex encoding
HEX KeyEncoding = 1
)
var KeyEncoding_name = map[int32]string{
0: "KEY_ENCODING_URL_UNSPECIFIED",
1: "KEY_ENCODING_HEX",
}
var KeyEncoding_value = map[string]int32{
"KEY_ENCODING_URL_UNSPECIFIED": 0,
"KEY_ENCODING_HEX": 1,
}
func (x KeyEncoding) String() string {
return proto.EnumName(KeyEncoding_name, int32(x))
}
func (KeyEncoding) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_7921d88972a41469, []int{0}
}
// MerkleRoot defines a merkle root hash. // MerkleRoot defines a merkle root hash.
// In the Cosmos SDK, the AppHash of a block header becomes the root. // In the Cosmos SDK, the AppHash of a block header becomes the root.
type MerkleRoot struct { type MerkleRoot struct {
@ -140,8 +112,9 @@ func (m *MerklePrefix) GetKeyPrefix() []byte {
// MerklePath is the path used to verify commitment proofs, which can be an // MerklePath is the path used to verify commitment proofs, which can be an
// arbitrary structured object (defined by a commitment type). // arbitrary structured object (defined by a commitment type).
// MerklePath is represented from root-to-leaf
type MerklePath struct { type MerklePath struct {
KeyPath KeyPath `protobuf:"bytes,1,opt,name=key_path,json=keyPath,proto3" json:"key_path" yaml:"key_path"` KeyPath []string `protobuf:"bytes,1,rep,name=key_path,json=keyPath,proto3" json:"key_path,omitempty" yaml:"key_path"`
} }
func (m *MerklePath) Reset() { *m = MerklePath{} } func (m *MerklePath) Reset() { *m = MerklePath{} }
@ -176,19 +149,20 @@ func (m *MerklePath) XXX_DiscardUnknown() {
var xxx_messageInfo_MerklePath proto.InternalMessageInfo var xxx_messageInfo_MerklePath proto.InternalMessageInfo
func (m *MerklePath) GetKeyPath() KeyPath { func (m *MerklePath) GetKeyPath() []string {
if m != nil { if m != nil {
return m.KeyPath return m.KeyPath
} }
return KeyPath{} return nil
} }
// MerkleProof is a wrapper type that contains a merkle proof. // MerkleProof is a wrapper type over a chain of CommitmentProofs.
// It demonstrates membership or non-membership for an element or set of // It demonstrates membership or non-membership for an element or set of
// elements, verifiable in conjunction with a known commitment root. Proofs // elements, verifiable in conjunction with a known commitment root. Proofs
// should be succinct. // should be succinct.
// MerkleProofs are ordered from leaf-to-root
type MerkleProof struct { type MerkleProof struct {
Proof *crypto.ProofOps `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"` Proofs []*_go.CommitmentProof `protobuf:"bytes,1,rep,name=proofs,proto3" json:"proofs,omitempty"`
} }
func (m *MerkleProof) Reset() { *m = MerkleProof{} } func (m *MerkleProof) Reset() { *m = MerkleProof{} }
@ -224,97 +198,18 @@ func (m *MerkleProof) XXX_DiscardUnknown() {
var xxx_messageInfo_MerkleProof proto.InternalMessageInfo var xxx_messageInfo_MerkleProof proto.InternalMessageInfo
func (m *MerkleProof) GetProof() *crypto.ProofOps { func (m *MerkleProof) GetProofs() []*_go.CommitmentProof {
if m != nil { if m != nil {
return m.Proof return m.Proofs
} }
return nil return nil
} }
// KeyPath defines a slice of keys
type KeyPath struct {
Keys []*Key `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
}
func (m *KeyPath) Reset() { *m = KeyPath{} }
func (*KeyPath) ProtoMessage() {}
func (*KeyPath) Descriptor() ([]byte, []int) {
return fileDescriptor_7921d88972a41469, []int{4}
}
func (m *KeyPath) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *KeyPath) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_KeyPath.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 *KeyPath) XXX_Merge(src proto.Message) {
xxx_messageInfo_KeyPath.Merge(m, src)
}
func (m *KeyPath) XXX_Size() int {
return m.Size()
}
func (m *KeyPath) XXX_DiscardUnknown() {
xxx_messageInfo_KeyPath.DiscardUnknown(m)
}
var xxx_messageInfo_KeyPath proto.InternalMessageInfo
// Key defines a proof Key
type Key struct {
Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Enc KeyEncoding `protobuf:"varint,2,opt,name=enc,proto3,enum=ibc.core.commitment.v1.KeyEncoding" json:"enc,omitempty"`
}
func (m *Key) Reset() { *m = Key{} }
func (m *Key) String() string { return proto.CompactTextString(m) }
func (*Key) ProtoMessage() {}
func (*Key) Descriptor() ([]byte, []int) {
return fileDescriptor_7921d88972a41469, []int{5}
}
func (m *Key) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Key) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Key.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 *Key) XXX_Merge(src proto.Message) {
xxx_messageInfo_Key.Merge(m, src)
}
func (m *Key) XXX_Size() int {
return m.Size()
}
func (m *Key) XXX_DiscardUnknown() {
xxx_messageInfo_Key.DiscardUnknown(m)
}
var xxx_messageInfo_Key proto.InternalMessageInfo
func init() { func init() {
proto.RegisterEnum("ibc.core.commitment.v1.KeyEncoding", KeyEncoding_name, KeyEncoding_value)
proto.RegisterType((*MerkleRoot)(nil), "ibc.core.commitment.v1.MerkleRoot") proto.RegisterType((*MerkleRoot)(nil), "ibc.core.commitment.v1.MerkleRoot")
proto.RegisterType((*MerklePrefix)(nil), "ibc.core.commitment.v1.MerklePrefix") proto.RegisterType((*MerklePrefix)(nil), "ibc.core.commitment.v1.MerklePrefix")
proto.RegisterType((*MerklePath)(nil), "ibc.core.commitment.v1.MerklePath") proto.RegisterType((*MerklePath)(nil), "ibc.core.commitment.v1.MerklePath")
proto.RegisterType((*MerkleProof)(nil), "ibc.core.commitment.v1.MerkleProof") proto.RegisterType((*MerkleProof)(nil), "ibc.core.commitment.v1.MerkleProof")
proto.RegisterType((*KeyPath)(nil), "ibc.core.commitment.v1.KeyPath")
proto.RegisterType((*Key)(nil), "ibc.core.commitment.v1.Key")
} }
func init() { func init() {
@ -322,39 +217,28 @@ func init() {
} }
var fileDescriptor_7921d88972a41469 = []byte{ var fileDescriptor_7921d88972a41469 = []byte{
// 499 bytes of a gzipped FileDescriptorProto // 334 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0x4f, 0x6f, 0xd3, 0x30, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x91, 0xcf, 0x4e, 0xfa, 0x40,
0x18, 0xc6, 0x13, 0x5a, 0xe8, 0x70, 0x27, 0x28, 0x16, 0x7f, 0xaa, 0xc2, 0x92, 0x2a, 0x48, 0x30, 0x10, 0xc7, 0xdb, 0xfc, 0x08, 0x3f, 0x59, 0x48, 0x8c, 0x45, 0x89, 0xe1, 0x50, 0x4c, 0x0f, 0xca,
0x90, 0x16, 0xab, 0x1d, 0x5c, 0xca, 0x05, 0x75, 0x0d, 0xac, 0xea, 0xe8, 0x2a, 0x4f, 0x45, 0x03, 0x85, 0xdd, 0x00, 0x9e, 0x30, 0x5e, 0xaa, 0x57, 0x13, 0xd2, 0xc4, 0x8b, 0x17, 0xd3, 0xae, 0x5b,
0x09, 0x55, 0x69, 0xea, 0x26, 0x51, 0x96, 0x38, 0x4a, 0xcc, 0xb4, 0x7c, 0x83, 0x89, 0x13, 0x47, 0xba, 0x29, 0x65, 0x9a, 0xee, 0x4a, 0xe8, 0x1b, 0x78, 0xf4, 0xe8, 0xd1, 0xc7, 0xf1, 0xc8, 0xd1,
0x2e, 0x48, 0x48, 0x7c, 0x99, 0x1d, 0x77, 0xe4, 0x54, 0xa1, 0xf6, 0x1b, 0xec, 0x13, 0x20, 0xdb, 0x13, 0x31, 0xf0, 0x06, 0x3c, 0x81, 0xe9, 0x2e, 0x60, 0x4f, 0x3b, 0xb3, 0xf3, 0x99, 0x7f, 0xdf,
0x2d, 0x0b, 0x12, 0x70, 0xca, 0x6b, 0xbd, 0xbf, 0x37, 0xcf, 0xe3, 0xc7, 0x2f, 0x78, 0xec, 0x8f, 0x41, 0x57, 0x3c, 0xa0, 0x84, 0x42, 0xc6, 0x08, 0x85, 0x24, 0xe1, 0x32, 0x61, 0x33, 0x49, 0xe6,
0x1d, 0xe4, 0xd0, 0x84, 0x20, 0x87, 0x86, 0xa1, 0xcf, 0x42, 0x12, 0x31, 0x74, 0xdc, 0xc8, 0x9d, 0xfd, 0x92, 0x87, 0xd3, 0x0c, 0x24, 0x58, 0x2d, 0x1e, 0x50, 0x5c, 0x80, 0xb8, 0x14, 0x9a, 0xf7,
0xcc, 0x38, 0xa1, 0x8c, 0xc2, 0xbb, 0xfe, 0xd8, 0x31, 0x39, 0x68, 0xe6, 0x5a, 0xc7, 0x8d, 0xda, 0xdb, 0xa7, 0x13, 0x98, 0x80, 0x42, 0x48, 0x61, 0x69, 0xba, 0xdd, 0xa4, 0x30, 0x0b, 0x39, 0x90,
0x6d, 0x97, 0xba, 0x54, 0x20, 0x88, 0x57, 0x92, 0xae, 0x6d, 0x30, 0x12, 0x4d, 0x48, 0x12, 0xfa, 0x34, 0x03, 0x08, 0x85, 0xfe, 0x74, 0x2e, 0x11, 0x7a, 0x60, 0x59, 0x3c, 0x65, 0x1e, 0x80, 0xb4,
0x11, 0x43, 0x4e, 0x92, 0xc5, 0x8c, 0xa2, 0x38, 0xa1, 0x74, 0x2a, 0xdb, 0xc6, 0x23, 0x00, 0xde, 0x2c, 0x54, 0x89, 0x7c, 0x11, 0x9d, 0x9b, 0x17, 0x66, 0xb7, 0xe1, 0x29, 0x7b, 0x54, 0x79, 0xfb,
0x90, 0x24, 0x38, 0x22, 0x98, 0x52, 0x06, 0x21, 0x28, 0x7a, 0x76, 0xea, 0x55, 0xd5, 0xba, 0xba, 0xec, 0x18, 0xce, 0x3d, 0x6a, 0x68, 0x6e, 0x9c, 0xb1, 0x90, 0x2f, 0xac, 0x6b, 0x84, 0x62, 0x96,
0xb9, 0x8e, 0x45, 0xdd, 0x2a, 0x9e, 0x7e, 0xd3, 0x15, 0xa3, 0x03, 0xd6, 0x25, 0x37, 0x48, 0xc8, 0x3f, 0xa7, 0xca, 0xd3, 0xbc, 0x7b, 0xb6, 0x5d, 0x75, 0x4e, 0x72, 0x3f, 0x99, 0x8e, 0x9c, 0xbf,
0xd4, 0x3f, 0x81, 0xcf, 0x00, 0x08, 0x48, 0x36, 0x8a, 0xc5, 0x49, 0xf2, 0xed, 0x3b, 0x17, 0x33, 0x98, 0xe3, 0xd5, 0x62, 0x96, 0xeb, 0x2c, 0xc7, 0xdd, 0x77, 0x1b, 0xfb, 0x32, 0xb2, 0x30, 0x3a,
0xfd, 0x56, 0x66, 0x87, 0x47, 0x2d, 0xe3, 0xb2, 0x67, 0xe0, 0xeb, 0x01, 0xc9, 0xe4, 0x94, 0xe1, 0x52, 0x9c, 0x2f, 0x8b, 0x8e, 0xff, 0xba, 0x35, 0xb7, 0xb9, 0x5d, 0x75, 0x8e, 0x4b, 0x15, 0x7c,
0xae, 0xd4, 0x06, 0x36, 0xf3, 0xe0, 0x01, 0x58, 0x13, 0x9c, 0xcd, 0xa4, 0x62, 0xb9, 0xa9, 0x9b, 0x19, 0x39, 0xde, 0xff, 0x22, 0xdf, 0x97, 0xd1, 0xa8, 0xf2, 0x51, 0x4c, 0x72, 0x8b, 0xea, 0xfb,
0x7f, 0xbf, 0x9b, 0xd9, 0x23, 0x19, 0x1f, 0x69, 0xdf, 0x3b, 0x9b, 0xe9, 0xca, 0xc5, 0x4c, 0xbf, 0x49, 0x00, 0x42, 0x0b, 0xa3, 0xaa, 0x5e, 0x48, 0x95, 0xa8, 0x0f, 0x5a, 0x98, 0x53, 0x31, 0x18,
0x99, 0x93, 0xb1, 0x99, 0x67, 0xe0, 0x52, 0x20, 0x89, 0x56, 0xf1, 0x0b, 0xb7, 0xfb, 0x12, 0x94, 0xe2, 0xbb, 0x83, 0x22, 0x8a, 0xf3, 0x76, 0x94, 0xfb, 0xf8, 0xb5, 0xb6, 0xcd, 0xe5, 0xda, 0x36,
0x57, 0x76, 0x29, 0x9d, 0xc2, 0x06, 0xb8, 0x2a, 0x2e, 0xbd, 0x94, 0xb9, 0x6f, 0x5e, 0x86, 0x62, 0x7f, 0xd6, 0xb6, 0xf9, 0xbe, 0xb1, 0x8d, 0xe5, 0xc6, 0x36, 0xbe, 0x37, 0xb6, 0xf1, 0x74, 0x33,
0xca, 0x50, 0x4c, 0x01, 0xee, 0xc7, 0x29, 0x96, 0xa4, 0xd1, 0x01, 0xa5, 0xa5, 0x28, 0x44, 0xa0, 0xe1, 0x32, 0x7a, 0x0d, 0x0a, 0x2d, 0x09, 0x05, 0x91, 0x80, 0xd8, 0x3d, 0x3d, 0xf1, 0x12, 0x93,
0x18, 0x90, 0x2c, 0xad, 0xaa, 0xf5, 0x82, 0x18, 0xfe, 0xb7, 0x47, 0x2c, 0xc0, 0xd6, 0x1a, 0x8f, 0x05, 0x39, 0x5c, 0x65, 0x30, 0xec, 0x95, 0x0e, 0x23, 0xf3, 0x94, 0x89, 0xa0, 0xaa, 0xe4, 0x1c,
0x4c, 0xf8, 0x78, 0x0b, 0x0a, 0x3d, 0x92, 0xf1, 0x5c, 0x23, 0x3b, 0x24, 0xab, 0x5c, 0x79, 0x0d, 0xfe, 0x06, 0x00, 0x00, 0xff, 0xff, 0x1b, 0xe7, 0x68, 0xd0, 0xbc, 0x01, 0x00, 0x00,
0x9f, 0x83, 0x02, 0x89, 0x9c, 0xea, 0x95, 0xba, 0xba, 0x79, 0xa3, 0xf9, 0xf0, 0x3f, 0x3f, 0xb5,
0x22, 0x87, 0x4e, 0xfc, 0xc8, 0xc5, 0x9c, 0x97, 0xcf, 0xf1, 0xf4, 0x03, 0x28, 0xe7, 0x3a, 0xf0,
0x09, 0x78, 0xd0, 0xb3, 0xde, 0x8d, 0xac, 0xfe, 0xce, 0x7e, 0xa7, 0xdb, 0x7f, 0x3d, 0x1a, 0xe2,
0xbd, 0xd1, 0xb0, 0x7f, 0x30, 0xb0, 0x76, 0xba, 0xaf, 0xba, 0x56, 0xa7, 0xa2, 0xd4, 0x4a, 0x9f,
0xbe, 0xd6, 0x0b, 0x43, 0xbc, 0x07, 0x37, 0x40, 0xe5, 0x0f, 0x74, 0xd7, 0x3a, 0xac, 0xa8, 0xb2,
0xbd, 0x6b, 0x1d, 0xd6, 0x8a, 0xa7, 0xdf, 0x35, 0xa5, 0x3d, 0x3c, 0x9b, 0x6b, 0xea, 0xf9, 0x5c,
0x53, 0x7f, 0xce, 0x35, 0xf5, 0xf3, 0x42, 0x53, 0xce, 0x17, 0x9a, 0xf2, 0x63, 0xa1, 0x29, 0xef,
0x5f, 0xb8, 0x3e, 0xf3, 0x3e, 0x8e, 0xb9, 0x4b, 0xe4, 0xd0, 0x34, 0xa4, 0xe9, 0xf2, 0xb3, 0x95,
0x4e, 0x02, 0x74, 0x82, 0x7e, 0x2f, 0x71, 0x73, 0x7b, 0x2b, 0xb7, 0xc7, 0x2c, 0x8b, 0x49, 0x3a,
0xbe, 0x26, 0x76, 0x6e, 0xfb, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0x78, 0x4b, 0x97, 0xeb,
0x02, 0x00, 0x00,
} }
func (m *MerkleRoot) Marshal() (dAtA []byte, err error) { func (m *MerkleRoot) Marshal() (dAtA []byte, err error) {
@ -437,16 +321,15 @@ func (m *MerklePath) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
{ if len(m.KeyPath) > 0 {
size, err := m.KeyPath.MarshalToSizedBuffer(dAtA[:i]) for iNdEx := len(m.KeyPath) - 1; iNdEx >= 0; iNdEx-- {
if err != nil { i -= len(m.KeyPath[iNdEx])
return 0, err copy(dAtA[i:], m.KeyPath[iNdEx])
i = encodeVarintCommitment(dAtA, i, uint64(len(m.KeyPath[iNdEx])))
i--
dAtA[i] = 0xa
} }
i -= size
i = encodeVarintCommitment(dAtA, i, uint64(size))
} }
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
@ -470,45 +353,10 @@ func (m *MerkleProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if m.Proof != nil { if len(m.Proofs) > 0 {
{ for iNdEx := len(m.Proofs) - 1; iNdEx >= 0; iNdEx-- {
size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintCommitment(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *KeyPath) 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 *KeyPath) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *KeyPath) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Keys) > 0 {
for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
{ {
size, err := m.Keys[iNdEx].MarshalToSizedBuffer(dAtA[:i]) size, err := m.Proofs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -522,41 +370,6 @@ func (m *KeyPath) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *Key) 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 *Key) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Key) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Enc != 0 {
i = encodeVarintCommitment(dAtA, i, uint64(m.Enc))
i--
dAtA[i] = 0x10
}
if len(m.Name) > 0 {
i -= len(m.Name)
copy(dAtA[i:], m.Name)
i = encodeVarintCommitment(dAtA, i, uint64(len(m.Name)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintCommitment(dAtA []byte, offset int, v uint64) int { func encodeVarintCommitment(dAtA []byte, offset int, v uint64) int {
offset -= sovCommitment(v) offset -= sovCommitment(v)
base := offset base := offset
@ -600,8 +413,12 @@ func (m *MerklePath) Size() (n int) {
} }
var l int var l int
_ = l _ = l
l = m.KeyPath.Size() if len(m.KeyPath) > 0 {
n += 1 + l + sovCommitment(uint64(l)) for _, s := range m.KeyPath {
l = len(s)
n += 1 + l + sovCommitment(uint64(l))
}
}
return n return n
} }
@ -611,21 +428,8 @@ func (m *MerkleProof) Size() (n int) {
} }
var l int var l int
_ = l _ = l
if m.Proof != nil { if len(m.Proofs) > 0 {
l = m.Proof.Size() for _, e := range m.Proofs {
n += 1 + l + sovCommitment(uint64(l))
}
return n
}
func (m *KeyPath) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Keys) > 0 {
for _, e := range m.Keys {
l = e.Size() l = e.Size()
n += 1 + l + sovCommitment(uint64(l)) n += 1 + l + sovCommitment(uint64(l))
} }
@ -633,22 +437,6 @@ func (m *KeyPath) Size() (n int) {
return n return n
} }
func (m *Key) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Name)
if l > 0 {
n += 1 + l + sovCommitment(uint64(l))
}
if m.Enc != 0 {
n += 1 + sovCommitment(uint64(m.Enc))
}
return n
}
func sovCommitment(x uint64) (n int) { func sovCommitment(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7 return (math_bits.Len64(x|1) + 6) / 7
} }
@ -862,7 +650,7 @@ func (m *MerklePath) Unmarshal(dAtA []byte) error {
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field KeyPath", wireType) return fmt.Errorf("proto: wrong wireType = %d for field KeyPath", wireType)
} }
var msglen int var stringLen uint64
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
if shift >= 64 { if shift >= 64 {
return ErrIntOverflowCommitment return ErrIntOverflowCommitment
@ -872,24 +660,23 @@ func (m *MerklePath) Unmarshal(dAtA []byte) error {
} }
b := dAtA[iNdEx] b := dAtA[iNdEx]
iNdEx++ iNdEx++
msglen |= int(b&0x7F) << shift stringLen |= uint64(b&0x7F) << shift
if b < 0x80 { if b < 0x80 {
break break
} }
} }
if msglen < 0 { intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthCommitment return ErrInvalidLengthCommitment
} }
postIndex := iNdEx + msglen postIndex := iNdEx + intStringLen
if postIndex < 0 { if postIndex < 0 {
return ErrInvalidLengthCommitment return ErrInvalidLengthCommitment
} }
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
if err := m.KeyPath.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { m.KeyPath = append(m.KeyPath, string(dAtA[iNdEx:postIndex]))
return err
}
iNdEx = postIndex iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
@ -946,7 +733,7 @@ func (m *MerkleProof) Unmarshal(dAtA []byte) error {
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Proofs", wireType)
} }
var msglen int var msglen int
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
@ -973,10 +760,8 @@ func (m *MerkleProof) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
if m.Proof == nil { m.Proofs = append(m.Proofs, &_go.CommitmentProof{})
m.Proof = &crypto.ProofOps{} if err := m.Proofs[len(m.Proofs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
}
if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex
@ -1004,199 +789,6 @@ func (m *MerkleProof) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *KeyPath) 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 ErrIntOverflowCommitment
}
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: KeyPath: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: KeyPath: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCommitment
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthCommitment
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthCommitment
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Keys = append(m.Keys, &Key{})
if err := m.Keys[len(m.Keys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipCommitment(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthCommitment
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthCommitment
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Key) 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 ErrIntOverflowCommitment
}
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: Key: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Key: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCommitment
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthCommitment
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthCommitment
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = append(m.Name[:0], dAtA[iNdEx:postIndex]...)
if m.Name == nil {
m.Name = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Enc", wireType)
}
m.Enc = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCommitment
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Enc |= KeyEncoding(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipCommitment(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthCommitment
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthCommitment
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipCommitment(dAtA []byte) (n int, err error) { func skipCommitment(dAtA []byte) (n int, err error) {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0

40
x/ibc/core/23-commitment/types/key_path.go
View File

@ -1,40 +0,0 @@
package types
import (
fmt "fmt"
"net/url"
)
// AppendKey appends a new key to a KeyPath
func (pth KeyPath) AppendKey(key []byte, enc KeyEncoding) KeyPath {
pth.Keys = append(pth.Keys, &Key{Name: key, Enc: enc})
return pth
}
// String implements the fmt.Stringer interface
func (pth *KeyPath) String() string {
res := ""
for _, key := range pth.Keys {
switch key.Enc {
case URL:
res += "/" + url.PathEscape(string(key.Name))
case HEX:
res += "/x:" + fmt.Sprintf("%X", key.Name)
default:
panic("unexpected key encoding type")
}
}
return res
}
// GetKey returns the bytes representation of key at given index
// Passing in a positive index return the key at index in forward order
// from the highest key to the lowest key
// Passing in a negative index will return the key at index in reverse order
// from the lowest key to the highest key. This is the order for proof verification,
// since we prove lowest key first before moving to key of higher subtrees
func (pth *KeyPath) GetKey(i int) []byte {
total := len(pth.Keys)
index := (total + i) % total
return pth.Keys[index].Name
}

187
x/ibc/core/23-commitment/types/merkle.go
View File

@ -2,6 +2,7 @@ package types
import ( import (
"bytes" "bytes"
"fmt"
"net/url" "net/url"
ics23 "github.com/confio/ics23/go" ics23 "github.com/confio/ics23/go"
@ -9,7 +10,6 @@ import (
tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto" tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
host "github.com/cosmos/cosmos-sdk/x/ibc/core/24-host"
"github.com/cosmos/cosmos-sdk/x/ibc/core/exported" "github.com/cosmos/cosmos-sdk/x/ibc/core/exported"
) )
@ -68,51 +68,62 @@ func (mp MerklePrefix) Empty() bool {
var _ exported.Path = (*MerklePath)(nil) var _ exported.Path = (*MerklePath)(nil)
// NewMerklePath creates a new MerklePath instance // NewMerklePath creates a new MerklePath instance
func NewMerklePath(keyPathStr []string) MerklePath { // The keys must be passed in from root-to-leaf order
merkleKeyPath := KeyPath{} func NewMerklePath(keyPath ...string) MerklePath {
for _, keyStr := range keyPathStr {
merkleKeyPath = merkleKeyPath.AppendKey([]byte(keyStr), URL)
}
return MerklePath{ return MerklePath{
KeyPath: merkleKeyPath, KeyPath: keyPath,
} }
} }
// String implements fmt.Stringer. // String implements fmt.Stringer.
// This represents the path in the same way the tendermint KeyPath will
// represent a key path. The backslashes partition the key path into
// the respective stores they belong to.
func (mp MerklePath) String() string { func (mp MerklePath) String() string {
return mp.KeyPath.String() pathStr := ""
for _, k := range mp.KeyPath {
pathStr += "/" + url.PathEscape(k)
}
return pathStr
} }
// Pretty returns the unescaped path of the URL string. // Pretty returns the unescaped path of the URL string.
// This function will unescape any backslash within a particular store key.
// This makes the keypath more human-readable while removing information
// about the exact partitions in the key path.
func (mp MerklePath) Pretty() string { func (mp MerklePath) Pretty() string {
path, err := url.PathUnescape(mp.KeyPath.String()) path, err := url.PathUnescape(mp.String())
if err != nil { if err != nil {
panic(err) panic(err)
} }
return path return path
} }
// Empty returns true if the path is empty // GetKey will return a byte representation of the key
func (mp MerklePath) Empty() bool { // after URL escaping the key element
return len(mp.KeyPath.Keys) == 0 func (mp MerklePath) GetKey(i uint64) ([]byte, error) {
if i >= uint64(len(mp.KeyPath)) {
return nil, fmt.Errorf("index out of range. %d (index) >= %d (len)", i, len(mp.KeyPath))
}
key, err := url.PathUnescape(mp.KeyPath[i])
if err != nil {
return nil, err
}
return []byte(key), nil
} }
// ApplyPrefix constructs a new commitment path from the arguments. It interprets // Empty returns true if the path is empty
// the path argument in the context of the prefix argument. func (mp MerklePath) Empty() bool {
// return len(mp.KeyPath) == 0
// CONTRACT: provided path string MUST be a well formated path. See ICS24 for }
// reference.
func ApplyPrefix(prefix exported.Prefix, path string) (MerklePath, error) {
err := host.PathValidator(path)
if err != nil {
return MerklePath{}, err
}
// ApplyPrefix constructs a new commitment path from the arguments. It prepends the prefix key
// with the given path.
func ApplyPrefix(prefix exported.Prefix, path MerklePath) (MerklePath, error) {
if prefix == nil || prefix.Empty() { if prefix == nil || prefix.Empty() {
return MerklePath{}, sdkerrors.Wrap(ErrInvalidPrefix, "prefix can't be empty") return MerklePath{}, sdkerrors.Wrap(ErrInvalidPrefix, "prefix can't be empty")
} }
return NewMerklePath([]string{string(prefix.Bytes()), path}), nil return NewMerklePath(append([]string{string(prefix.Bytes())}, path.KeyPath...)...), nil
} }
var _ exported.Proof = (*MerkleProof)(nil) var _ exported.Proof = (*MerkleProof)(nil)
@ -128,22 +139,17 @@ func (proof MerkleProof) VerifyMembership(specs []*ics23.ProofSpec, root exporte
if !ok { if !ok {
return sdkerrors.Wrapf(ErrInvalidProof, "path %v is not of type MerklePath", path) return sdkerrors.Wrapf(ErrInvalidProof, "path %v is not of type MerklePath", path)
} }
if len(mpath.KeyPath.Keys) != len(specs) { if len(mpath.KeyPath) != len(specs) {
return sdkerrors.Wrapf(ErrInvalidProof, "path length %d not same as proof %d", return sdkerrors.Wrapf(ErrInvalidProof, "path length %d not same as proof %d",
len(mpath.KeyPath.Keys), len(specs)) len(mpath.KeyPath), len(specs))
} }
if len(value) == 0 { if len(value) == 0 {
return sdkerrors.Wrap(ErrInvalidProof, "empty value in membership proof") return sdkerrors.Wrap(ErrInvalidProof, "empty value in membership proof")
} }
// Convert Proof to []CommitmentProof // Since every proof in chain is a membership proof we can use verifyChainedMembershipProof from index 0
proofs, err := convertProofs(proof) // to validate entire proof
if err != nil { if err := verifyChainedMembershipProof(root.GetHash(), specs, proof.Proofs, mpath, value, 0); err != nil {
return err
}
// Since every proof in chain is a membership proof we can chain from index 0
if err := verifyChainedMembershipProof(root.GetHash(), specs, proofs, mpath.KeyPath, value, 0); err != nil {
return err return err
} }
return nil return nil
@ -162,31 +168,37 @@ func (proof MerkleProof) VerifyNonMembership(specs []*ics23.ProofSpec, root expo
if !ok { if !ok {
return sdkerrors.Wrapf(ErrInvalidProof, "path %v is not of type MerkleProof", path) return sdkerrors.Wrapf(ErrInvalidProof, "path %v is not of type MerkleProof", path)
} }
if len(mpath.KeyPath.Keys) != len(specs) { if len(mpath.KeyPath) != len(specs) {
return sdkerrors.Wrapf(ErrInvalidProof, "path length %d not same as proof %d", return sdkerrors.Wrapf(ErrInvalidProof, "path length %d not same as proof %d",
len(mpath.KeyPath.Keys), len(specs)) len(mpath.KeyPath), len(specs))
} }
// Convert Proof to []CommitmentProof switch proof.Proofs[0].Proof.(type) {
proofs, err := convertProofs(proof) case *ics23.CommitmentProof_Nonexist:
if err != nil { // VerifyNonMembership will verify the absence of key in lowest subtree, and then chain inclusion proofs
return err // of all subroots up to final root
} subroot, err := proof.Proofs[0].Calculate()
if err != nil {
return sdkerrors.Wrapf(ErrInvalidProof, "could not calculate root for proof index 0, merkle tree is likely empty. %v", err)
}
key, err := mpath.GetKey(uint64(len(mpath.KeyPath) - 1))
if err != nil {
return sdkerrors.Wrapf(ErrInvalidProof, "could not retrieve key bytes for key: %s", mpath.KeyPath[len(mpath.KeyPath)-1])
}
if ok := ics23.VerifyNonMembership(specs[0], subroot, proof.Proofs[0], key); !ok {
return sdkerrors.Wrapf(ErrInvalidProof, "could not verify absence of key %s. Please ensure that the path is correct.", string(key))
}
// VerifyNonMembership will verify the absence of key in lowest subtree, and then chain inclusion proofs // Verify chained membership proof starting from index 1 with value = subroot
// of all subroots up to final root if err := verifyChainedMembershipProof(root.GetHash(), specs, proof.Proofs, mpath, subroot, 1); err != nil {
subroot, err := proofs[0].Calculate() return err
if err != nil { }
sdkerrors.Wrapf(ErrInvalidProof, "could not calculate root for proof index 0. %v", err) case *ics23.CommitmentProof_Exist:
} return sdkerrors.Wrapf(ErrInvalidProof,
key := mpath.KeyPath.GetKey(-1) "got ExistenceProof in VerifyNonMembership. If this is unexpected, please ensure that proof was queried with the correct key.")
if ok := ics23.VerifyNonMembership(specs[0], subroot, proofs[0], key); !ok { default:
return sdkerrors.Wrapf(ErrInvalidProof, "could not verify absence of key %s", string(key)) return sdkerrors.Wrapf(ErrInvalidProof,
} "expected proof type: %T, got: %T", &ics23.CommitmentProof_Exist{}, proof.Proofs[0].Proof)
// Verify chained membership proof starting from index 1 with value = subroot
if err := verifyChainedMembershipProof(root.GetHash(), specs, proofs, mpath.KeyPath, subroot, 1); err != nil {
return err
} }
return nil return nil
} }
@ -208,7 +220,7 @@ func (proof MerkleProof) BatchVerifyNonMembership(specs []*ics23.ProofSpec, root
// The proofs and specs are passed in from lowest subtree to the highest subtree, but the keys are passed in from highest subtree to lowest. // The proofs and specs are passed in from lowest subtree to the highest subtree, but the keys are passed in from highest subtree to lowest.
// The index specifies what index to start chaining the membership proofs, this is useful since the lowest proof may not be a membership proof, thus we // The index specifies what index to start chaining the membership proofs, this is useful since the lowest proof may not be a membership proof, thus we
// will want to start the membership proof chaining from index 1 with value being the lowest subroot // will want to start the membership proof chaining from index 1 with value being the lowest subroot
func verifyChainedMembershipProof(root []byte, specs []*ics23.ProofSpec, proofs []*ics23.CommitmentProof, keys KeyPath, value []byte, index int) error { func verifyChainedMembershipProof(root []byte, specs []*ics23.ProofSpec, proofs []*ics23.CommitmentProof, keys MerklePath, value []byte, index int) error {
var ( var (
subroot []byte subroot []byte
err error err error
@ -218,42 +230,45 @@ func verifyChainedMembershipProof(root []byte, specs []*ics23.ProofSpec, proofs
// In this case, there may be no intermediate proofs to verify and we just check that lowest proof root equals final root // In this case, there may be no intermediate proofs to verify and we just check that lowest proof root equals final root
subroot = value subroot = value
for i := index; i < len(proofs); i++ { for i := index; i < len(proofs); i++ {
subroot, err = proofs[i].Calculate() switch proofs[i].Proof.(type) {
if err != nil { case *ics23.CommitmentProof_Exist:
return sdkerrors.Wrapf(ErrInvalidProof, "could not calculate proof root at index %d. %v", i, err) subroot, err = proofs[i].Calculate()
if err != nil {
return sdkerrors.Wrapf(ErrInvalidProof, "could not calculate proof root at index %d, merkle tree may be empty. %v", i, err)
}
// Since keys are passed in from highest to lowest, we must grab their indices in reverse order
// from the proofs and specs which are lowest to highest
key, err := keys.GetKey(uint64(len(keys.KeyPath) - 1 - i))
if err != nil {
return sdkerrors.Wrapf(ErrInvalidProof, "could not retrieve key bytes for key %s: %v", keys.KeyPath[len(keys.KeyPath)-1-i], err)
}
// verify membership of the proof at this index with appropriate key and value
if ok := ics23.VerifyMembership(specs[i], subroot, proofs[i], key, value); !ok {
return sdkerrors.Wrapf(ErrInvalidProof,
"chained membership proof failed to verify membership of value: %X in subroot %X at index %d. Please ensure the path and value are both correct.",
value, subroot, i)
}
// Set value to subroot so that we verify next proof in chain commits to this subroot
value = subroot
case *ics23.CommitmentProof_Nonexist:
return sdkerrors.Wrapf(ErrInvalidProof,
"chained membership proof contains nonexistence proof at index %d. If this is unexpected, please ensure that proof was queried from the height that contained the value in store and was queried with the correct key.",
i)
default:
return sdkerrors.Wrapf(ErrInvalidProof,
"expected proof type: %T, got: %T", &ics23.CommitmentProof_Exist{}, proofs[i].Proof)
} }
// Since keys are passed in from highest to lowest, we must grab their indices in reverse order
// from the proofs and specs which are lowest to highest
key := keys.GetKey(-1 * (i + 1))
if ok := ics23.VerifyMembership(specs[i], subroot, proofs[i], key, value); !ok {
return sdkerrors.Wrapf(ErrInvalidProof, "chained membership proof failed to verify membership of value: %X in subroot %X at index %d for proof %v",
value, subroot, i, proofs[i])
}
// Set value to subroot so that we verify next proof in chain commits to this subroot
value = subroot
} }
// Check that chained proof root equals passed-in root // Check that chained proof root equals passed-in root
if !bytes.Equal(root, subroot) { if !bytes.Equal(root, subroot) {
return sdkerrors.Wrapf(ErrInvalidProof, "proof did not commit to expected root: %X, got: %X", root, subroot) return sdkerrors.Wrapf(ErrInvalidProof,
"proof did not commit to expected root: %X, got: %X. Please ensure proof was submitted with correct proofHeight and to the correct chain.",
root, subroot)
} }
return nil return nil
} }
// convertProofs converts a MerkleProof into []*ics23.CommitmentProof
func convertProofs(mproof MerkleProof) ([]*ics23.CommitmentProof, error) {
// Unmarshal all proof ops to CommitmentProof
proofs := make([]*ics23.CommitmentProof, len(mproof.Proof.Ops))
for i, op := range mproof.Proof.Ops {
var p ics23.CommitmentProof
err := p.Unmarshal(op.Data)
if err != nil {
return nil, sdkerrors.Wrapf(ErrInvalidMerkleProof, "could not unmarshal proof op into CommitmentProof at index: %d", i)
}
proofs[i] = &p
}
return proofs, nil
}
// Empty returns true if the root is empty // Empty returns true if the root is empty
func (proof MerkleProof) Empty() bool { func (proof MerkleProof) Empty() bool {
return proto.Equal(&proof, nil) || proto.Equal(&proof, &MerkleProof{}) || proto.Equal(&proof, &tmcrypto.ProofOps{}) return proto.Equal(&proof, nil) || proto.Equal(&proof, &MerkleProof{}) || proto.Equal(&proof, &tmcrypto.ProofOps{})
@ -277,10 +292,10 @@ func (proof MerkleProof) validateVerificationArgs(specs []*ics23.ProofSpec, root
return sdkerrors.Wrap(ErrInvalidMerkleProof, "root cannot be empty") return sdkerrors.Wrap(ErrInvalidMerkleProof, "root cannot be empty")
} }
if len(specs) != len(proof.Proof.Ops) { if len(specs) != len(proof.Proofs) {
return sdkerrors.Wrapf(ErrInvalidMerkleProof, return sdkerrors.Wrapf(ErrInvalidMerkleProof,
"length of specs: %d not equal to length of proof: %d", "length of specs: %d not equal to length of proof: %d",
len(specs), len(proof.Proof.Ops)) len(specs), len(proof.Proofs))
} }
for i, spec := range specs { for i, spec := range specs {

58
x/ibc/core/23-commitment/types/merkle_test.go
View File

@ -6,8 +6,6 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
abci "github.com/tendermint/tendermint/abci/types" abci "github.com/tendermint/tendermint/abci/types"
tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
tmmerkle "github.com/tendermint/tendermint/proto/tendermint/crypto"
"github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types" "github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types"
) )
@ -23,9 +21,9 @@ func (suite *MerkleTestSuite) TestVerifyMembership() {
}) })
require.NotNil(suite.T(), res.ProofOps) require.NotNil(suite.T(), res.ProofOps)
proof := types.MerkleProof{ proof, err := types.ConvertProofs(res.ProofOps)
Proof: res.ProofOps, require.NoError(suite.T(), err)
}
suite.Require().NoError(proof.ValidateBasic()) suite.Require().NoError(proof.ValidateBasic())
suite.Require().Error(types.MerkleProof{}.ValidateBasic()) suite.Require().Error(types.MerkleProof{}.ValidateBasic())
@ -49,9 +47,7 @@ func (suite *MerkleTestSuite) TestVerifyMembership() {
{"nil root", []byte(nil), []string{suite.storeKey.Name(), "MYKEY"}, []byte("MYVALUE"), func() {}, false}, // invalid proof with nil root {"nil root", []byte(nil), []string{suite.storeKey.Name(), "MYKEY"}, []byte("MYVALUE"), func() {}, false}, // invalid proof with nil root
{"proof is wrong length", cid.Hash, []string{suite.storeKey.Name(), "MYKEY"}, []byte("MYVALUE"), func() { {"proof is wrong length", cid.Hash, []string{suite.storeKey.Name(), "MYKEY"}, []byte("MYVALUE"), func() {
proof = types.MerkleProof{ proof = types.MerkleProof{
Proof: &tmmerkle.ProofOps{ Proofs: proof.Proofs[1:],
Ops: res.ProofOps.Ops[1:],
},
} }
}, false}, // invalid proof with wrong length }, false}, // invalid proof with wrong length
@ -63,7 +59,7 @@ func (suite *MerkleTestSuite) TestVerifyMembership() {
tc.malleate() tc.malleate()
root := types.NewMerkleRoot(tc.root) root := types.NewMerkleRoot(tc.root)
path := types.NewMerklePath(tc.pathArr) path := types.NewMerklePath(tc.pathArr...)
err := proof.VerifyMembership(types.GetSDKSpecs(), &root, path, tc.value) err := proof.VerifyMembership(types.GetSDKSpecs(), &root, path, tc.value)
@ -91,9 +87,9 @@ func (suite *MerkleTestSuite) TestVerifyNonMembership() {
}) })
require.NotNil(suite.T(), res.ProofOps) require.NotNil(suite.T(), res.ProofOps)
proof := types.MerkleProof{ proof, err := types.ConvertProofs(res.ProofOps)
Proof: res.ProofOps, require.NoError(suite.T(), err)
}
suite.Require().NoError(proof.ValidateBasic()) suite.Require().NoError(proof.ValidateBasic())
cases := []struct { cases := []struct {
@ -114,9 +110,7 @@ func (suite *MerkleTestSuite) TestVerifyNonMembership() {
{"nil root", []byte(nil), []string{suite.storeKey.Name(), "MYABSENTKEY"}, func() {}, false}, // invalid proof with nil root {"nil root", []byte(nil), []string{suite.storeKey.Name(), "MYABSENTKEY"}, func() {}, false}, // invalid proof with nil root
{"proof is wrong length", cid.Hash, []string{suite.storeKey.Name(), "MYKEY"}, func() { {"proof is wrong length", cid.Hash, []string{suite.storeKey.Name(), "MYKEY"}, func() {
proof = types.MerkleProof{ proof = types.MerkleProof{
Proof: &tmcrypto.ProofOps{ Proofs: proof.Proofs[1:],
Ops: res.ProofOps.Ops[1:],
},
} }
}, false}, // invalid proof with wrong length }, false}, // invalid proof with wrong length
@ -129,7 +123,7 @@ func (suite *MerkleTestSuite) TestVerifyNonMembership() {
tc.malleate() tc.malleate()
root := types.NewMerkleRoot(tc.root) root := types.NewMerkleRoot(tc.root)
path := types.NewMerklePath(tc.pathArr) path := types.NewMerklePath(tc.pathArr...)
err := proof.VerifyNonMembership(types.GetSDKSpecs(), &root, path) err := proof.VerifyNonMembership(types.GetSDKSpecs(), &root, path)
@ -149,16 +143,30 @@ func TestApplyPrefix(t *testing.T) {
prefix := types.NewMerklePrefix([]byte("storePrefixKey")) prefix := types.NewMerklePrefix([]byte("storePrefixKey"))
pathStr := "pathone/pathtwo/paththree/key" pathStr := "pathone/pathtwo/paththree/key"
path := types.MerklePath{
KeyPath: []string{pathStr},
}
prefixedPath, err := types.ApplyPrefix(prefix, pathStr) prefixedPath, err := types.ApplyPrefix(prefix, path)
require.Nil(t, err, "valid prefix returns error") require.NoError(t, err, "valid prefix returns error")
require.Equal(t, "/storePrefixKey/"+pathStr, prefixedPath.Pretty(), "Prefixed path incorrect") require.Equal(t, "/storePrefixKey/"+pathStr, prefixedPath.Pretty(), "Prefixed path incorrect")
require.Equal(t, "/storePrefixKey/pathone%2Fpathtwo%2Fpaththree%2Fkey", prefixedPath.String(), "Prefixed scaped path incorrect") require.Equal(t, "/storePrefixKey/pathone%2Fpathtwo%2Fpaththree%2Fkey", prefixedPath.String(), "Prefixed escaped path incorrect")
}
// invalid prefix contains non-alphanumeric character
invalidPathStr := "invalid-path/doesitfail?/hopefully" func TestString(t *testing.T) {
invalidPath, err := types.ApplyPrefix(prefix, invalidPathStr) path := types.NewMerklePath("rootKey", "storeKey", "path/to/leaf")
require.NotNil(t, err, "invalid prefix does not returns error")
require.Equal(t, types.MerklePath{}, invalidPath, "invalid prefix returns valid Path on ApplyPrefix") require.Equal(t, "/rootKey/storeKey/path%2Fto%2Fleaf", path.String(), "path String returns unxpected value")
require.Equal(t, "/rootKey/storeKey/path/to/leaf", path.Pretty(), "path's pretty string representation is incorrect")
onePath := types.NewMerklePath("path/to/leaf")
require.Equal(t, "/path%2Fto%2Fleaf", onePath.String(), "one element path does not have correct string representation")
require.Equal(t, "/path/to/leaf", onePath.Pretty(), "one element path has incorrect pretty string representation")
zeroPath := types.NewMerklePath()
require.Equal(t, "", zeroPath.String(), "zero element path does not have correct string representation")
require.Equal(t, "", zeroPath.Pretty(), "zero element path does not have correct pretty string representation")
} }

27
x/ibc/core/23-commitment/types/utils.go Normal file
View File

@ -0,0 +1,27 @@
package types
import (
ics23 "github.com/confio/ics23/go"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
crypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
)
// ConvertProofs converts crypto.ProofOps into MerkleProof
func ConvertProofs(tmProof *crypto.ProofOps) (MerkleProof, error) {
if tmProof == nil {
return MerkleProof{}, sdkerrors.Wrapf(ErrInvalidMerkleProof, "tendermint proof is nil")
}
// Unmarshal all proof ops to CommitmentProof
proofs := make([]*ics23.CommitmentProof, len(tmProof.Ops))
for i, op := range tmProof.Ops {
var p ics23.CommitmentProof
err := p.Unmarshal(op.Data)
if err != nil || p.Proof == nil {
return MerkleProof{}, sdkerrors.Wrapf(ErrInvalidMerkleProof, "could not unmarshal proof op into CommitmentProof at index %d: %v", i, err)
}
proofs[i] = &p
}
return MerkleProof{
Proofs: proofs,
}, nil
}

97
x/ibc/core/23-commitment/types/utils_test.go Normal file
View File

@ -0,0 +1,97 @@
package types_test
import (
"fmt"
"github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types"
"github.com/stretchr/testify/require"
abci "github.com/tendermint/tendermint/abci/types"
crypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
)
func (suite *MerkleTestSuite) TestConvertProofs() {
suite.iavlStore.Set([]byte("MYKEY"), []byte("MYVALUE"))
cid := suite.store.Commit()
root := types.NewMerkleRoot(cid.Hash)
existsPath := types.NewMerklePath(suite.storeKey.Name(), "MYKEY")
nonexistPath := types.NewMerklePath(suite.storeKey.Name(), "NOTMYKEY")
value := []byte("MYVALUE")
var proofOps *crypto.ProofOps
testcases := []struct {
name string
malleate func()
keyExists bool
expPass bool
}{
{
"success for ExistenceProof",
func() {
res := suite.store.Query(abci.RequestQuery{
Path: fmt.Sprintf("/%s/key", suite.storeKey.Name()), // required path to get key/value+proof
Data: []byte("MYKEY"),
Prove: true,
})
require.NotNil(suite.T(), res.ProofOps)
proofOps = res.ProofOps
},
true, true,
},
{
"success for NonexistenceProof",
func() {
res := suite.store.Query(abci.RequestQuery{
Path: fmt.Sprintf("/%s/key", suite.storeKey.Name()), // required path to get key/value+proof
Data: []byte("NOTMYKEY"),
Prove: true,
})
require.NotNil(suite.T(), res.ProofOps)
proofOps = res.ProofOps
},
false, true,
},
{
"nil proofOps",
func() {
proofOps = nil
},
true, false,
},
{
"proof op data is nil",
func() {
res := suite.store.Query(abci.RequestQuery{
Path: fmt.Sprintf("/%s/key", suite.storeKey.Name()), // required path to get key/value+proof
Data: []byte("MYKEY"),
Prove: true,
})
require.NotNil(suite.T(), res.ProofOps)
proofOps = res.ProofOps
proofOps.Ops[0].Data = nil
},
true, false,
},
}
for _, tc := range testcases {
tc.malleate()
proof, err := types.ConvertProofs(proofOps)
if tc.expPass {
suite.Require().NoError(err, "ConvertProofs unexpectedly returned error for case: %s", tc.name)
if tc.keyExists {
err := proof.VerifyMembership(types.GetSDKSpecs(), &root, existsPath, value)
suite.Require().NoError(err, "converted proof failed to verify membership for case: %s", tc.name)
} else {
err := proof.VerifyNonMembership(types.GetSDKSpecs(), &root, nonexistPath)
suite.Require().NoError(err, "converted proof failed to verify membership for case: %s", tc.name)
}
} else {
suite.Require().Error(err, "ConvertProofs passed on invalid case for case: %s", tc.name)
}
}
}

7
x/ibc/core/24-host/errors.go
View File

@ -9,8 +9,7 @@ const SubModuleName = "host"
// IBC client sentinel errors // IBC client sentinel errors
var ( var (
ErrInvalidID = sdkerrors.Register(SubModuleName, 2, "invalid identifier") ErrInvalidID = sdkerrors.Register(SubModuleName, 2, "invalid identifier")
ErrInvalidPath = sdkerrors.Register(SubModuleName, 3, "invalid path") ErrInvalidPath = sdkerrors.Register(SubModuleName, 3, "invalid path")
ErrInvalidPacket = sdkerrors.Register(SubModuleName, 4, "invalid packet") ErrInvalidPacket = sdkerrors.Register(SubModuleName, 4, "invalid packet")
ErrInvalidVersion = sdkerrors.Register(SubModuleName, 5, "invalid version")
) )

185
x/ibc/core/24-host/keys.go
View File

@ -22,14 +22,18 @@ const (
// KVStore key prefixes for IBC // KVStore key prefixes for IBC
var ( var (
KeyClientStorePrefix = []byte("clients") KeyClientStorePrefix = []byte("clients")
KeyConsensusStatesPrefix = []byte("consensusStates")
KeyConnectionPrefix = []byte("connections")
) )
// KVStore key prefixes for IBC // KVStore key prefixes for IBC
const ( const (
KeyChannelPrefix = "channelEnds" KeyClientState = "clientState"
KeyConsensusStatePrefix = "consensusStates"
KeyConnectionPrefix = "connections"
KeyChannelEndPrefix = "channelEnds"
KeyChannelPrefix = "channels"
KeyPortPrefix = "ports"
KeySequencePrefix = "sequences"
KeyChannelCapabilityPrefix = "capabilities" KeyChannelCapabilityPrefix = "capabilities"
KeyNextSeqSendPrefix = "nextSequenceSend" KeyNextSeqSendPrefix = "nextSequenceSend"
KeyNextSeqRecvPrefix = "nextSequenceRecv" KeyNextSeqRecvPrefix = "nextSequenceRecv"
@ -42,38 +46,57 @@ const (
// FullClientPath returns the full path of a specific client path in the format: // FullClientPath returns the full path of a specific client path in the format:
// "clients/{clientID}/{path}" as a string. // "clients/{clientID}/{path}" as a string.
func FullClientPath(clientID string, path string) string { func FullClientPath(clientID string, path string) string {
return string(FullKeyClientPath(clientID, []byte(path))) return fmt.Sprintf("%s/%s/%s", KeyClientStorePrefix, clientID, path)
} }
// FullKeyClientPath returns the full path of specific client path in the format: // FullClientKey returns the full path of specific client path in the format:
// "clients/{clientID}/{path}" as a byte array. // "clients/{clientID}/{path}" as a byte array.
func FullKeyClientPath(clientID string, path []byte) []byte { func FullClientKey(clientID string, path []byte) []byte {
return append(KeyClientStorePrefix, append([]byte("/"+clientID+"/"), path...)...) return []byte(FullClientPath(clientID, string(path)))
} }
// ICS02 // ICS02
// The following paths are the keys to the store as defined in https://github.com/cosmos/ics/tree/master/spec/ics-002-client-semantics#path-space // The following paths are the keys to the store as defined in https://github.com/cosmos/ics/tree/master/spec/ics-002-client-semantics#path-space
// ClientStatePath takes an Identifier and returns a Path under which to store a // FullClientStatePath takes a client identifier and returns a Path under which to store a
// particular client state // particular client state
func ClientStatePath() string { func FullClientStatePath(clientID string) string {
return "clientState" return FullClientPath(clientID, KeyClientState)
} }
// ConsensusStatePath takes an Identifier and returns a Path under which to // FullClientStateKey takes a client identifier and returns a Key under which to store a
// particular client state.
func FullClientStateKey(clientID string) []byte {
return FullClientKey(clientID, []byte(KeyClientState))
}
// ClientStateKey returns a store key under which a particular client state is stored
// in a client prefixed store
func ClientStateKey() []byte {
return []byte(KeyClientState)
}
// FullConsensusStatePath takes a client identifier and returns a Path under which to
// store the consensus state of a client. // store the consensus state of a client.
func FullConsensusStatePath(clientID string, height exported.Height) string {
return FullClientPath(clientID, fmt.Sprintf("%s/%s", KeyConsensusStatePrefix, height))
}
// FullConsensusStateKey returns the store key for the consensus state of a particular
// client.
func FullConsensusStateKey(clientID string, height exported.Height) []byte {
return []byte(FullConsensusStatePath(clientID, height))
}
// ConsensusStatePath returns the suffix store key for the consensus state at a
// particular height stored in a client prefixed store.
func ConsensusStatePath(height exported.Height) string { func ConsensusStatePath(height exported.Height) string {
return fmt.Sprintf("%s/%s", KeyConsensusStatesPrefix, height) return fmt.Sprintf("%s/%s", KeyConsensusStatePrefix, height)
} }
// KeyClientState returns the store key for a particular client state // ConsensusStateKey returns the store key for a the consensus state of a particular
func KeyClientState() []byte { // client stored in a client prefixed store.
return []byte(ClientStatePath()) func ConsensusStateKey(height exported.Height) []byte {
}
// KeyConsensusState returns the store key for the consensus state of a particular
// client
func KeyConsensusState(height exported.Height) []byte {
return []byte(ConsensusStatePath(height)) return []byte(ConsensusStatePath(height))
} }
@ -82,7 +105,12 @@ func KeyConsensusState(height exported.Height) []byte {
// ClientConnectionsPath defines a reverse mapping from clients to a set of connections // ClientConnectionsPath defines a reverse mapping from clients to a set of connections
func ClientConnectionsPath(clientID string) string { func ClientConnectionsPath(clientID string) string {
return fmt.Sprintf("%s/%s/connections", KeyClientStorePrefix, clientID) return FullClientPath(clientID, KeyConnectionPrefix)
}
// ClientConnectionsKey returns the store key for the connections of a given client
func ClientConnectionsKey(clientID string) []byte {
return []byte(ClientConnectionsPath(clientID))
} }
// ConnectionPath defines the path under which connection paths are stored // ConnectionPath defines the path under which connection paths are stored
@ -90,13 +118,8 @@ func ConnectionPath(connectionID string) string {
return fmt.Sprintf("%s/%s", KeyConnectionPrefix, connectionID) return fmt.Sprintf("%s/%s", KeyConnectionPrefix, connectionID)
} }
// KeyClientConnections returns the store key for the connections of a given client // ConnectionKey returns the store key for a particular connection
func KeyClientConnections(clientID string) []byte { func ConnectionKey(connectionID string) []byte {
return []byte(ClientConnectionsPath(clientID))
}
// KeyConnection returns the store key for a particular connection
func KeyConnection(connectionID string) []byte {
return []byte(ConnectionPath(connectionID)) return []byte(ConnectionPath(connectionID))
} }
@ -105,98 +128,102 @@ func KeyConnection(connectionID string) []byte {
// ChannelPath defines the path under which channels are stored // ChannelPath defines the path under which channels are stored
func ChannelPath(portID, channelID string) string { func ChannelPath(portID, channelID string) string {
return fmt.Sprintf("%s/", KeyChannelPrefix) + channelPath(portID, channelID) return fmt.Sprintf("%s/%s", KeyChannelEndPrefix, channelPath(portID, channelID))
}
// ChannelKey returns the store key for a particular channel
func ChannelKey(portID, channelID string) []byte {
return []byte(ChannelPath(portID, channelID))
} }
// ChannelCapabilityPath defines the path under which capability keys associated // ChannelCapabilityPath defines the path under which capability keys associated
// with a channel are stored // with a channel are stored
func ChannelCapabilityPath(portID, channelID string) string { func ChannelCapabilityPath(portID, channelID string) string {
return fmt.Sprintf("%s/", KeyChannelCapabilityPrefix) + channelPath(portID, channelID) + "/key" return fmt.Sprintf("%s/%s", KeyChannelCapabilityPrefix, channelPath(portID, channelID))
} }
// NextSequenceSendPath defines the next send sequence counter store path // NextSequenceSendPath defines the next send sequence counter store path
func NextSequenceSendPath(portID, channelID string) string { func NextSequenceSendPath(portID, channelID string) string {
return fmt.Sprintf("%s/", KeyNextSeqSendPrefix) + channelPath(portID, channelID) return fmt.Sprintf("%s/%s", KeyNextSeqSendPrefix, channelPath(portID, channelID))
} }
// NextSequenceRecvPath defines the next receive sequence counter store path // NextSequenceSendKey returns the store key for the send sequence of a particular
// channel binded to a specific port.
func NextSequenceSendKey(portID, channelID string) []byte {
return []byte(NextSequenceSendPath(portID, channelID))
}
// NextSequenceRecvPath defines the next receive sequence counter store path.
func NextSequenceRecvPath(portID, channelID string) string { func NextSequenceRecvPath(portID, channelID string) string {
return fmt.Sprintf("%s/", KeyNextSeqRecvPrefix) + channelPath(portID, channelID) return fmt.Sprintf("%s/%s", KeyNextSeqRecvPrefix, channelPath(portID, channelID))
}
// NextSequenceRecvKey returns the store key for the receive sequence of a particular
// channel binded to a specific port
func NextSequenceRecvKey(portID, channelID string) []byte {
return []byte(NextSequenceRecvPath(portID, channelID))
} }
// NextSequenceAckPath defines the next acknowledgement sequence counter store path // NextSequenceAckPath defines the next acknowledgement sequence counter store path
func NextSequenceAckPath(portID, channelID string) string { func NextSequenceAckPath(portID, channelID string) string {
return fmt.Sprintf("%s/", KeyNextSeqAckPrefix) + channelPath(portID, channelID) return fmt.Sprintf("%s/%s", KeyNextSeqAckPrefix, channelPath(portID, channelID))
}
// NextSequenceAckKey returns the store key for the acknowledgement sequence of
// a particular channel binded to a specific port.
func NextSequenceAckKey(portID, channelID string) []byte {
return []byte(NextSequenceAckPath(portID, channelID))
} }
// PacketCommitmentPath defines the commitments to packet data fields store path // PacketCommitmentPath defines the commitments to packet data fields store path
func PacketCommitmentPath(portID, channelID string, sequence uint64) string { func PacketCommitmentPath(portID, channelID string, sequence uint64) string {
return fmt.Sprintf("%s/", KeyPacketCommitmentPrefix) + channelPath(portID, channelID) + fmt.Sprintf("/packets/%d", sequence) return fmt.Sprintf("%s/%s/%s", KeyPacketCommitmentPrefix, channelPath(portID, channelID), sequencePath(sequence))
}
// PacketCommitmentKey returns the store key of under which a packet commitment
// is stored
func PacketCommitmentKey(portID, channelID string, sequence uint64) []byte {
return []byte(PacketCommitmentPath(portID, channelID, sequence))
} }
// PacketCommitmentPrefixPath defines the prefix for commitments to packet data fields store path. // PacketCommitmentPrefixPath defines the prefix for commitments to packet data fields store path.
func PacketCommitmentPrefixPath(portID, channelID string) string { func PacketCommitmentPrefixPath(portID, channelID string) string {
return fmt.Sprintf("%s/", KeyPacketCommitmentPrefix) + channelPath(portID, channelID) return fmt.Sprintf("%s/%s/%s", KeyPacketCommitmentPrefix, channelPath(portID, channelID), KeySequencePrefix)
} }
// PacketAcknowledgementPath defines the packet acknowledgement store path // PacketAcknowledgementPath defines the packet acknowledgement store path
func PacketAcknowledgementPath(portID, channelID string, sequence uint64) string { func PacketAcknowledgementPath(portID, channelID string, sequence uint64) string {
return fmt.Sprintf("%s/", KeyPacketAckPrefix) + channelPath(portID, channelID) + fmt.Sprintf("/acknowledgements/%d", sequence) return fmt.Sprintf("%s/%s/%s", KeyPacketAckPrefix, channelPath(portID, channelID), sequencePath(sequence))
}
// PacketAcknowledgementKey returns the store key of under which a packet
// acknowledgement is stored
func PacketAcknowledgementKey(portID, channelID string, sequence uint64) []byte {
return []byte(PacketAcknowledgementPath(portID, channelID, sequence))
} }
// PacketAcknowledgementPrefixPath defines the prefix for commitments to packet data fields store path. // PacketAcknowledgementPrefixPath defines the prefix for commitments to packet data fields store path.
func PacketAcknowledgementPrefixPath(portID, channelID string) string { func PacketAcknowledgementPrefixPath(portID, channelID string) string {
return fmt.Sprintf("%s/", KeyPacketAckPrefix) + channelPath(portID, channelID) return fmt.Sprintf("%s/%s/%s", KeyPacketAckPrefix, channelPath(portID, channelID), KeySequencePrefix)
} }
// PacketReceiptPath defines the packet receipt store path // PacketReceiptPath defines the packet receipt store path
func PacketReceiptPath(portID, channelID string, sequence uint64) string { func PacketReceiptPath(portID, channelID string, sequence uint64) string {
return fmt.Sprintf("%s/", KeyPacketReceiptPrefix) + channelPath(portID, channelID) + fmt.Sprintf("/receipts/%d", sequence) return fmt.Sprintf("%s/%s/%s", KeyPacketReceiptPrefix, channelPath(portID, channelID), sequencePath(sequence))
} }
// KeyChannel returns the store key for a particular channel // PacketReceiptKey returns the store key of under which a packet
func KeyChannel(portID, channelID string) []byte {
return []byte(ChannelPath(portID, channelID))
}
// KeyNextSequenceSend returns the store key for the send sequence of a particular
// channel binded to a specific port
func KeyNextSequenceSend(portID, channelID string) []byte {
return []byte(NextSequenceSendPath(portID, channelID))
}
// KeyNextSequenceRecv returns the store key for the receive sequence of a particular
// channel binded to a specific port
func KeyNextSequenceRecv(portID, channelID string) []byte {
return []byte(NextSequenceRecvPath(portID, channelID))
}
// KeyNextSequenceAck returns the store key for the acknowledgement sequence of
// a particular channel binded to a specific port.
func KeyNextSequenceAck(portID, channelID string) []byte {
return []byte(NextSequenceAckPath(portID, channelID))
}
// KeyPacketCommitment returns the store key of under which a packet commitment
// is stored
func KeyPacketCommitment(portID, channelID string, sequence uint64) []byte {
return []byte(PacketCommitmentPath(portID, channelID, sequence))
}
// KeyPacketAcknowledgement returns the store key of under which a packet
// acknowledgement is stored
func KeyPacketAcknowledgement(portID, channelID string, sequence uint64) []byte {
return []byte(PacketAcknowledgementPath(portID, channelID, sequence))
}
// KeyPacketReceipt returns the store key of under which a packet
// receipt is stored // receipt is stored
func KeyPacketReceipt(portID, channelID string, sequence uint64) []byte { func PacketReceiptKey(portID, channelID string, sequence uint64) []byte {
return []byte(PacketReceiptPath(portID, channelID, sequence)) return []byte(PacketReceiptPath(portID, channelID, sequence))
} }
func channelPath(portID, channelID string) string { func channelPath(portID, channelID string) string {
return fmt.Sprintf("ports/%s/channels/%s", portID, channelID) return fmt.Sprintf("%s/%s/%s/%s", KeyPortPrefix, portID, KeyChannelPrefix, channelID)
}
func sequencePath(sequence uint64) string {
return fmt.Sprintf("%s/%d", KeySequencePrefix, sequence)
} }
// ICS05 // ICS05
@ -204,5 +231,5 @@ func channelPath(portID, channelID string) string {
// PortPath defines the path under which ports paths are stored on the capability module // PortPath defines the path under which ports paths are stored on the capability module
func PortPath(portID string) string { func PortPath(portID string) string {
return fmt.Sprintf("ports/%s", portID) return fmt.Sprintf("%s/%s", KeyPortPrefix, portID)
} }

2
x/ibc/core/24-host/parse.go
View File

@ -25,7 +25,7 @@ func ParseChannelPath(path string) (string, string, error) {
return "", "", sdkerrors.Wrapf(ErrInvalidPath, "cannot parse channel path %s", path) return "", "", sdkerrors.Wrapf(ErrInvalidPath, "cannot parse channel path %s", path)
} }
if split[1] != "ports" || split[3] != "channels" { if split[1] != KeyPortPrefix || split[3] != KeyChannelPrefix {
return "", "", sdkerrors.Wrapf(ErrInvalidPath, "cannot parse channel path %s", path) return "", "", sdkerrors.Wrapf(ErrInvalidPath, "cannot parse channel path %s", path)
} }

5
x/ibc/core/client/query.go
View File

@ -50,8 +50,9 @@ func QueryTendermintProof(clientCtx client.Context, key []byte) ([]byte, []byte,
return nil, nil, clienttypes.Height{}, err return nil, nil, clienttypes.Height{}, err
} }
merkleProof := commitmenttypes.MerkleProof{ merkleProof, err := commitmenttypes.ConvertProofs(res.ProofOps)
Proof: res.ProofOps, if err != nil {
return nil, nil, clienttypes.Height{}, err
} }
cdc := codec.NewProtoCodec(clientCtx.InterfaceRegistry) cdc := codec.NewProtoCodec(clientCtx.InterfaceRegistry)

35
x/ibc/core/keeper/msg_server_test.go
View File

@ -41,6 +41,9 @@ func (suite *KeeperTestSuite) SetupTest() {
suite.chainA = suite.coordinator.GetChain(ibctesting.GetChainID(0)) suite.chainA = suite.coordinator.GetChain(ibctesting.GetChainID(0))
suite.chainB = suite.coordinator.GetChain(ibctesting.GetChainID(1)) suite.chainB = suite.coordinator.GetChain(ibctesting.GetChainID(1))
// commit some blocks so that QueryProof returns valid proof (cannot return valid query if height <= 1)
suite.coordinator.CommitNBlocks(suite.chainA, 2)
suite.coordinator.CommitNBlocks(suite.chainB, 2)
} }
func TestIBCTestSuite(t *testing.T) { func TestIBCTestSuite(t *testing.T) {
@ -139,7 +142,7 @@ func (suite *KeeperTestSuite) TestHandleRecvPacket() {
tc.malleate() tc.malleate()
// get proof of packet commitment from chainA // get proof of packet commitment from chainA
packetKey := host.KeyPacketCommitment(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence()) packetKey := host.PacketCommitmentKey(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
proof, proofHeight := suite.chainA.QueryProof(packetKey) proof, proofHeight := suite.chainA.QueryProof(packetKey)
msg := channeltypes.NewMsgRecvPacket(packet, proof, proofHeight, suite.chainB.SenderAccount.GetAddress()) msg := channeltypes.NewMsgRecvPacket(packet, proof, proofHeight, suite.chainB.SenderAccount.GetAddress())
@ -278,7 +281,7 @@ func (suite *KeeperTestSuite) TestHandleAcknowledgePacket() {
tc.malleate() tc.malleate()
packetKey := host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey := host.PacketAcknowledgementKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
proof, proofHeight := suite.chainB.QueryProof(packetKey) proof, proofHeight := suite.chainB.QueryProof(packetKey)
msg := channeltypes.NewMsgAcknowledgement(packet, ibcmock.MockAcknowledgement, proof, proofHeight, suite.chainA.SenderAccount.GetAddress()) msg := channeltypes.NewMsgAcknowledgement(packet, ibcmock.MockAcknowledgement, proof, proofHeight, suite.chainA.SenderAccount.GetAddress())
@ -330,7 +333,7 @@ func (suite *KeeperTestSuite) TestHandleTimeoutPacket() {
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
}, true}, }, true},
{"success: UNORDERED", func() { {"success: UNORDERED", func() {
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
@ -343,7 +346,7 @@ func (suite *KeeperTestSuite) TestHandleTimeoutPacket() {
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
packetKey = host.KeyPacketReceipt(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.PacketReceiptKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
}, true}, }, true},
{"success: UNORDERED timeout out of order packet", func() { {"success: UNORDERED timeout out of order packet", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
@ -360,7 +363,7 @@ func (suite *KeeperTestSuite) TestHandleTimeoutPacket() {
} }
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
packetKey = host.KeyPacketReceipt(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.PacketReceiptKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
}, true}, }, true},
{"success: ORDERED timeout out of order packet", func() { {"success: ORDERED timeout out of order packet", func() {
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
@ -376,19 +379,19 @@ func (suite *KeeperTestSuite) TestHandleTimeoutPacket() {
} }
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
}, true}, }, true},
{"channel does not exist", func() { {"channel does not exist", func() {
// any non-nil value of packet is valid // any non-nil value of packet is valid
suite.Require().NotNil(packet) suite.Require().NotNil(packet)
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
}, false}, }, false},
{"UNORDERED: packet not sent", func() { {"UNORDERED: packet not sent", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packetKey = host.KeyPacketReceipt(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.PacketReceiptKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
}, false}, }, false},
} }
@ -457,7 +460,7 @@ func (suite *KeeperTestSuite) TestHandleTimeoutOnClosePacket() {
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
// close counterparty channel // close counterparty channel
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, counterpartyChannel) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, counterpartyChannel)
@ -478,7 +481,7 @@ func (suite *KeeperTestSuite) TestHandleTimeoutOnClosePacket() {
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
packetKey = host.KeyPacketReceipt(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.PacketReceiptKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
// close counterparty channel // close counterparty channel
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, counterpartyChannel) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, counterpartyChannel)
@ -503,7 +506,7 @@ func (suite *KeeperTestSuite) TestHandleTimeoutOnClosePacket() {
} }
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
packetKey = host.KeyPacketReceipt(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.PacketReceiptKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
// close counterparty channel // close counterparty channel
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, counterpartyChannel) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, counterpartyChannel)
@ -527,7 +530,7 @@ func (suite *KeeperTestSuite) TestHandleTimeoutOnClosePacket() {
} }
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
// close counterparty channel // close counterparty channel
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, counterpartyChannel) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, counterpartyChannel)
@ -536,12 +539,12 @@ func (suite *KeeperTestSuite) TestHandleTimeoutOnClosePacket() {
// any non-nil value of packet is valid // any non-nil value of packet is valid
suite.Require().NotNil(packet) suite.Require().NotNil(packet)
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
}, false}, }, false},
{"UNORDERED: packet not sent", func() { {"UNORDERED: packet not sent", func() {
clientA, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED) clientA, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packetKey = host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.PacketAcknowledgementKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
counterpartyChannel = ibctesting.TestChannel{ counterpartyChannel = ibctesting.TestChannel{
PortID: channelB.PortID, PortID: channelB.PortID,
ID: channelB.ID, ID: channelB.ID,
@ -567,7 +570,7 @@ func (suite *KeeperTestSuite) TestHandleTimeoutOnClosePacket() {
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, ibctesting.Tendermint)
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
}, false}, }, false},
} }
@ -581,7 +584,7 @@ func (suite *KeeperTestSuite) TestHandleTimeoutOnClosePacket() {
proof, proofHeight := suite.chainB.QueryProof(packetKey) proof, proofHeight := suite.chainB.QueryProof(packetKey)
channelKey := host.KeyChannel(counterpartyChannel.PortID, counterpartyChannel.ID) channelKey := host.ChannelKey(counterpartyChannel.PortID, counterpartyChannel.ID)
proofClosed, _ := suite.chainB.QueryProof(channelKey) proofClosed, _ := suite.chainB.QueryProof(channelKey)
msg := channeltypes.NewMsgTimeoutOnClose(packet, 1, proof, proofClosed, proofHeight, suite.chainA.SenderAccount.GetAddress()) msg := channeltypes.NewMsgTimeoutOnClose(packet, 1, proof, proofClosed, proofHeight, suite.chainA.SenderAccount.GetAddress())

6
x/ibc/core/simulation/decoder_test.go
View File

@ -40,15 +40,15 @@ func TestDecodeStore(t *testing.T) {
kvPairs := kv.Pairs{ kvPairs := kv.Pairs{
Pairs: []kv.Pair{ Pairs: []kv.Pair{
{ {
Key: host.FullKeyClientPath(clientID, host.KeyClientState()), Key: host.FullClientStateKey(clientID),
Value: app.IBCKeeper.ClientKeeper.MustMarshalClientState(clientState), Value: app.IBCKeeper.ClientKeeper.MustMarshalClientState(clientState),
}, },
{ {
Key: host.KeyConnection(connectionID), Key: host.ConnectionKey(connectionID),
Value: app.IBCKeeper.Codec().MustMarshalBinaryBare(&connection), Value: app.IBCKeeper.Codec().MustMarshalBinaryBare(&connection),
}, },
{ {
Key: host.KeyChannel(portID, channelID), Key: host.ChannelKey(portID, channelID),
Value: app.IBCKeeper.Codec().MustMarshalBinaryBare(&channel), Value: app.IBCKeeper.Codec().MustMarshalBinaryBare(&channel),
}, },
{ {

14
x/ibc/core/spec/02_state.md
View File

@ -16,10 +16,10 @@ The client type is not stored since it can be obtained through the client state.
| "0/" | "connections/{identifier}" | ConnectionEnd | | "0/" | "connections/{identifier}" | ConnectionEnd |
| "0/" | "ports/{identifier}" | CapabilityKey | | "0/" | "ports/{identifier}" | CapabilityKey |
| "0/" | "channelEnds/ports/{identifier}/channels/{identifier}" | ChannelEnd | | "0/" | "channelEnds/ports/{identifier}/channels/{identifier}" | ChannelEnd |
| "0/" | "capabilities/ports/{identifier}/channels/{identifier}/key" | CapabilityKey | | "0/" | "capabilities/ports/{identifier}/channels/{identifier}" | CapabilityKey |
| "0/" | "seqSends/ports/{identifier}/channels/{identifier}/nextSequenceSend" | uint64 | | "0/" | "nextSequenceSend/ports/{identifier}/channels/{identifier}" | uint64 |
| "0/" | "seqRecvs/ports/{identifier}/channels/{identifier}/nextSequenceRecv" | uint64 | | "0/" | "nextSequenceRecv/ports/{identifier}/channels/{identifier}" | uint64 |
| "0/" | "seqAcks/ports/{identifier}/channels/{identifier}/nextSequenceAck" | uint64 | | "0/" | "nextSequenceAck/ports/{identifier}/channels/{identifier}" | uint64 |
| "0/" | "commitments/ports/{identifier}/channels/{identifier}/packets/{sequence}" | bytes | | "0/" | "commitments/ports/{identifier}/channels/{identifier}/sequences/{sequence}" | bytes |
| "0/" | "receipts/ports/{identifier}/channels/{identifier}/receipts/{sequence}" | bytes | | "0/" | "receipts/ports/{identifier}/channels/{identifier}/sequences/{sequence}" | bytes |
| "0/" | "acks/ports/{identifier}/channels/{identifier}/acknowledgements/{sequence}" | bytes | | "0/" | "acks/ports/{identifier}/channels/{identifier}/sequences/{sequence}" | bytes |

24
x/ibc/light-clients/06-solomachine/types/client_state.go
View File

@ -100,7 +100,7 @@ func (cs ClientState) VerifyClientState(
return err return err
} }
clientPrefixedPath := "clients/" + counterpartyClientIdentifier + "/" + host.ClientStatePath() clientPrefixedPath := commitmenttypes.NewMerklePath(host.FullClientStatePath(counterpartyClientIdentifier))
path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath) path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath)
if err != nil { if err != nil {
return err return err
@ -138,7 +138,7 @@ func (cs ClientState) VerifyClientConsensusState(
return err return err
} }
clientPrefixedPath := "clients/" + counterpartyClientIdentifier + "/" + host.ConsensusStatePath(consensusHeight) clientPrefixedPath := commitmenttypes.NewMerklePath(host.FullConsensusStatePath(counterpartyClientIdentifier, consensusHeight))
path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath) path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath)
if err != nil { if err != nil {
return err return err
@ -175,7 +175,8 @@ func (cs ClientState) VerifyConnectionState(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.ConnectionPath(connectionID)) connectionPath := commitmenttypes.NewMerklePath(host.ConnectionPath(connectionID))
path, err := commitmenttypes.ApplyPrefix(prefix, connectionPath)
if err != nil { if err != nil {
return err return err
} }
@ -212,7 +213,8 @@ func (cs ClientState) VerifyChannelState(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.ChannelPath(portID, channelID)) channelPath := commitmenttypes.NewMerklePath(host.ChannelPath(portID, channelID))
path, err := commitmenttypes.ApplyPrefix(prefix, channelPath)
if err != nil { if err != nil {
return err return err
} }
@ -250,7 +252,8 @@ func (cs ClientState) VerifyPacketCommitment(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.PacketCommitmentPath(portID, channelID, packetSequence)) commitmentPath := commitmenttypes.NewMerklePath(host.PacketCommitmentPath(portID, channelID, packetSequence))
path, err := commitmenttypes.ApplyPrefix(prefix, commitmentPath)
if err != nil { if err != nil {
return err return err
} }
@ -288,7 +291,8 @@ func (cs ClientState) VerifyPacketAcknowledgement(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.PacketAcknowledgementPath(portID, channelID, packetSequence)) ackPath := commitmenttypes.NewMerklePath(host.PacketAcknowledgementPath(portID, channelID, packetSequence))
path, err := commitmenttypes.ApplyPrefix(prefix, ackPath)
if err != nil { if err != nil {
return err return err
} }
@ -326,7 +330,8 @@ func (cs ClientState) VerifyPacketReceiptAbsence(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.PacketReceiptPath(portID, channelID, packetSequence)) receiptPath := commitmenttypes.NewMerklePath(host.PacketReceiptPath(portID, channelID, packetSequence))
path, err := commitmenttypes.ApplyPrefix(prefix, receiptPath)
if err != nil { if err != nil {
return err return err
} }
@ -363,7 +368,8 @@ func (cs ClientState) VerifyNextSequenceRecv(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.NextSequenceRecvPath(portID, channelID)) nextSequenceRecvPath := commitmenttypes.NewMerklePath(host.NextSequenceRecvPath(portID, channelID))
path, err := commitmenttypes.ApplyPrefix(prefix, nextSequenceRecvPath)
if err != nil { if err != nil {
return err return err
} }
@ -454,5 +460,5 @@ func produceVerificationArgs(
// sets the client state to the store // sets the client state to the store
func setClientState(store sdk.KVStore, cdc codec.BinaryMarshaler, clientState exported.ClientState) { func setClientState(store sdk.KVStore, cdc codec.BinaryMarshaler, clientState exported.ClientState) {
bz := clienttypes.MustMarshalClientState(cdc, clientState) bz := clienttypes.MustMarshalClientState(cdc, clientState)
store.Set(host.KeyClientState(), bz) store.Set([]byte(host.KeyClientState), bz)
} }

2
x/ibc/light-clients/06-solomachine/types/solomachine_test.go
View File

@ -49,7 +49,7 @@ func TestSoloMachineTestSuite(t *testing.T) {
} }
func (suite *SoloMachineTestSuite) GetSequenceFromStore() uint64 { func (suite *SoloMachineTestSuite) GetSequenceFromStore() uint64 {
bz := suite.store.Get(host.KeyClientState()) bz := suite.store.Get(host.ClientStateKey())
suite.Require().NotNil(bz) suite.Require().NotNil(bz)
var clientState exported.ClientState var clientState exported.ClientState

22
x/ibc/light-clients/07-tendermint/types/client_state.go
View File

@ -180,7 +180,7 @@ func (cs ClientState) VerifyClientState(
return err return err
} }
clientPrefixedPath := "clients/" + counterpartyClientIdentifier + "/" + host.ClientStatePath() clientPrefixedPath := commitmenttypes.NewMerklePath(host.FullClientStatePath(counterpartyClientIdentifier))
path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath) path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath)
if err != nil { if err != nil {
return err return err
@ -220,7 +220,7 @@ func (cs ClientState) VerifyClientConsensusState(
return err return err
} }
clientPrefixedPath := "clients/" + counterpartyClientIdentifier + "/" + host.ConsensusStatePath(consensusHeight) clientPrefixedPath := commitmenttypes.NewMerklePath(host.FullConsensusStatePath(counterpartyClientIdentifier, consensusHeight))
path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath) path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath)
if err != nil { if err != nil {
return err return err
@ -263,7 +263,8 @@ func (cs ClientState) VerifyConnectionState(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.ConnectionPath(connectionID)) connectionPath := commitmenttypes.NewMerklePath(host.ConnectionPath(connectionID))
path, err := commitmenttypes.ApplyPrefix(prefix, connectionPath)
if err != nil { if err != nil {
return err return err
} }
@ -302,7 +303,8 @@ func (cs ClientState) VerifyChannelState(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.ChannelPath(portID, channelID)) channelPath := commitmenttypes.NewMerklePath(host.ChannelPath(portID, channelID))
path, err := commitmenttypes.ApplyPrefix(prefix, channelPath)
if err != nil { if err != nil {
return err return err
} }
@ -342,7 +344,8 @@ func (cs ClientState) VerifyPacketCommitment(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.PacketCommitmentPath(portID, channelID, sequence)) commitmentPath := commitmenttypes.NewMerklePath(host.PacketCommitmentPath(portID, channelID, sequence))
path, err := commitmenttypes.ApplyPrefix(prefix, commitmentPath)
if err != nil { if err != nil {
return err return err
} }
@ -372,7 +375,8 @@ func (cs ClientState) VerifyPacketAcknowledgement(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.PacketAcknowledgementPath(portID, channelID, sequence)) ackPath := commitmenttypes.NewMerklePath(host.PacketAcknowledgementPath(portID, channelID, sequence))
path, err := commitmenttypes.ApplyPrefix(prefix, ackPath)
if err != nil { if err != nil {
return err return err
} }
@ -402,7 +406,8 @@ func (cs ClientState) VerifyPacketReceiptAbsence(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.PacketReceiptPath(portID, channelID, sequence)) receiptPath := commitmenttypes.NewMerklePath(host.PacketReceiptPath(portID, channelID, sequence))
path, err := commitmenttypes.ApplyPrefix(prefix, receiptPath)
if err != nil { if err != nil {
return err return err
} }
@ -431,7 +436,8 @@ func (cs ClientState) VerifyNextSequenceRecv(
return err return err
} }
path, err := commitmenttypes.ApplyPrefix(prefix, host.NextSequenceRecvPath(portID, channelID)) nextSequenceRecvPath := commitmenttypes.NewMerklePath(host.NextSequenceRecvPath(portID, channelID))
path, err := commitmenttypes.ApplyPrefix(prefix, nextSequenceRecvPath)
if err != nil { if err != nil {
return err return err
} }

12
x/ibc/light-clients/07-tendermint/types/client_state_test.go
View File

@ -230,7 +230,7 @@ func (suite *TendermintTestSuite) TestVerifyConnectionState() {
prefix = suite.chainB.GetPrefix() prefix = suite.chainB.GetPrefix()
// make connection proof // make connection proof
connectionKey := host.KeyConnection(connB.ID) connectionKey := host.ConnectionKey(connB.ID)
proof, proofHeight = suite.chainB.QueryProof(connectionKey) proof, proofHeight = suite.chainB.QueryProof(connectionKey)
tc.malleate() // make changes as necessary tc.malleate() // make changes as necessary
@ -308,7 +308,7 @@ func (suite *TendermintTestSuite) TestVerifyChannelState() {
prefix = suite.chainB.GetPrefix() prefix = suite.chainB.GetPrefix()
// make channel proof // make channel proof
channelKey := host.KeyChannel(channelB.PortID, channelB.ID) channelKey := host.ChannelKey(channelB.PortID, channelB.ID)
proof, proofHeight = suite.chainB.QueryProof(channelKey) proof, proofHeight = suite.chainB.QueryProof(channelKey)
tc.malleate() // make changes as necessary tc.malleate() // make changes as necessary
@ -389,7 +389,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketCommitment() {
prefix = suite.chainB.GetPrefix() prefix = suite.chainB.GetPrefix()
// make packet commitment proof // make packet commitment proof
packetKey := host.KeyPacketCommitment(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence()) packetKey := host.PacketCommitmentKey(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
proof, proofHeight = suite.chainB.QueryProof(packetKey) proof, proofHeight = suite.chainB.QueryProof(packetKey)
tc.malleate() // make changes as necessary tc.malleate() // make changes as necessary
@ -477,7 +477,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketAcknowledgement() {
prefix = suite.chainB.GetPrefix() prefix = suite.chainB.GetPrefix()
// make packet acknowledgement proof // make packet acknowledgement proof
acknowledgementKey := host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) acknowledgementKey := host.PacketAcknowledgementKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
proof, proofHeight = suite.chainB.QueryProof(acknowledgementKey) proof, proofHeight = suite.chainB.QueryProof(acknowledgementKey)
tc.malleate() // make changes as necessary tc.malleate() // make changes as necessary
@ -564,7 +564,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketReceiptAbsence() {
prefix = suite.chainB.GetPrefix() prefix = suite.chainB.GetPrefix()
// make packet receipt absence proof // make packet receipt absence proof
receiptKey := host.KeyPacketReceipt(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) receiptKey := host.PacketReceiptKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
proof, proofHeight = suite.chainB.QueryProof(receiptKey) proof, proofHeight = suite.chainB.QueryProof(receiptKey)
tc.malleate() // make changes as necessary tc.malleate() // make changes as necessary
@ -655,7 +655,7 @@ func (suite *TendermintTestSuite) TestVerifyNextSeqRecv() {
prefix = suite.chainB.GetPrefix() prefix = suite.chainB.GetPrefix()
// make next seq recv proof // make next seq recv proof
nextSeqRecvKey := host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) nextSeqRecvKey := host.NextSequenceRecvKey(packet.GetDestPort(), packet.GetDestChannel())
proof, proofHeight = suite.chainB.QueryProof(nextSeqRecvKey) proof, proofHeight = suite.chainB.QueryProof(nextSeqRecvKey)
tc.malleate() // make changes as necessary tc.malleate() // make changes as necessary

2
x/ibc/light-clients/07-tendermint/types/store.go
View File

@ -12,7 +12,7 @@ import (
// GetConsensusState retrieves the consensus state from the client prefixed // GetConsensusState retrieves the consensus state from the client prefixed
// store. An error is returned if the consensus state does not exist. // store. An error is returned if the consensus state does not exist.
func GetConsensusState(store sdk.KVStore, cdc codec.BinaryMarshaler, height exported.Height) (*ConsensusState, error) { func GetConsensusState(store sdk.KVStore, cdc codec.BinaryMarshaler, height exported.Height) (*ConsensusState, error) {
bz := store.Get(host.KeyConsensusState(height)) bz := store.Get(host.ConsensusStateKey(height))
if bz == nil { if bz == nil {
return nil, sdkerrors.Wrapf( return nil, sdkerrors.Wrapf(
clienttypes.ErrConsensusStateNotFound, clienttypes.ErrConsensusStateNotFound,

4
x/ibc/light-clients/07-tendermint/types/store_test.go
View File

@ -34,7 +34,7 @@ func (suite *TendermintTestSuite) TestGetConsensusState() {
// marshal an empty client state and set as consensus state // marshal an empty client state and set as consensus state
store := suite.chainA.App.IBCKeeper.ClientKeeper.ClientStore(suite.chainA.GetContext(), clientA) store := suite.chainA.App.IBCKeeper.ClientKeeper.ClientStore(suite.chainA.GetContext(), clientA)
clientStateBz := suite.chainA.App.IBCKeeper.ClientKeeper.MustMarshalClientState(&types.ClientState{}) clientStateBz := suite.chainA.App.IBCKeeper.ClientKeeper.MustMarshalClientState(&types.ClientState{})
store.Set(host.KeyConsensusState(height), clientStateBz) store.Set(host.ConsensusStateKey(height), clientStateBz)
}, false, }, false,
}, },
{ {
@ -42,7 +42,7 @@ func (suite *TendermintTestSuite) TestGetConsensusState() {
// marshal and set solomachine consensus state // marshal and set solomachine consensus state
store := suite.chainA.App.IBCKeeper.ClientKeeper.ClientStore(suite.chainA.GetContext(), clientA) store := suite.chainA.App.IBCKeeper.ClientKeeper.ClientStore(suite.chainA.GetContext(), clientA)
consensusStateBz := suite.chainA.App.IBCKeeper.ClientKeeper.MustMarshalConsensusState(&solomachinetypes.ConsensusState{}) consensusStateBz := suite.chainA.App.IBCKeeper.ClientKeeper.MustMarshalConsensusState(&solomachinetypes.ConsensusState{})
store.Set(host.KeyConsensusState(height), consensusStateBz) store.Set(host.ConsensusStateKey(height), consensusStateBz)
}, false, }, false,
}, },
} }

3
x/ibc/light-clients/07-tendermint/types/tendermint_test.go
View File

@ -60,6 +60,9 @@ func (suite *TendermintTestSuite) SetupTest() {
suite.coordinator = ibctesting.NewCoordinator(suite.T(), 2) suite.coordinator = ibctesting.NewCoordinator(suite.T(), 2)
suite.chainA = suite.coordinator.GetChain(ibctesting.GetChainID(0)) suite.chainA = suite.coordinator.GetChain(ibctesting.GetChainID(0))
suite.chainB = suite.coordinator.GetChain(ibctesting.GetChainID(1)) suite.chainB = suite.coordinator.GetChain(ibctesting.GetChainID(1))
// commit some blocks so that QueryProof returns valid proof (cannot return valid query if height <= 1)
suite.coordinator.CommitNBlocks(suite.chainA, 2)
suite.coordinator.CommitNBlocks(suite.chainB, 2)
// TODO: deprecate usage in favor of testing package // TODO: deprecate usage in favor of testing package
checkTx := false checkTx := false

2
x/ibc/light-clients/07-tendermint/types/upgrade.go
View File

@ -117,5 +117,5 @@ func constructUpgradeMerklePath(upgradePath string, upgradeHeight exported.Heigh
// append upgradeHeight to last key in merkle path // append upgradeHeight to last key in merkle path
// this will create the IAVL key that is used to store client in upgrade store // this will create the IAVL key that is used to store client in upgrade store
upgradeKeys[len(upgradeKeys)-1] = fmt.Sprintf("%s/%d", lastKey, upgradeHeight.GetVersionHeight()) upgradeKeys[len(upgradeKeys)-1] = fmt.Sprintf("%s/%d", lastKey, upgradeHeight.GetVersionHeight())
return commitmenttypes.NewMerklePath(upgradeKeys), nil return commitmenttypes.NewMerklePath(upgradeKeys...), nil
} }

16
x/ibc/light-clients/09-localhost/types/client_state.go
View File

@ -115,8 +115,8 @@ func (cs ClientState) VerifyClientState(
store sdk.KVStore, cdc codec.BinaryMarshaler, store sdk.KVStore, cdc codec.BinaryMarshaler,
_ exported.Height, _ exported.Prefix, _ string, _ []byte, clientState exported.ClientState, _ exported.Height, _ exported.Prefix, _ string, _ []byte, clientState exported.ClientState,
) error { ) error {
path := host.KeyClientState() path := host.KeyClientState
bz := store.Get(path) bz := store.Get([]byte(path))
if bz == nil { if bz == nil {
return sdkerrors.Wrapf(clienttypes.ErrFailedClientStateVerification, return sdkerrors.Wrapf(clienttypes.ErrFailedClientStateVerification,
"not found for path: %s", path) "not found for path: %s", path)
@ -154,7 +154,7 @@ func (cs ClientState) VerifyConnectionState(
connectionID string, connectionID string,
connectionEnd exported.ConnectionI, connectionEnd exported.ConnectionI,
) error { ) error {
path := host.KeyConnection(connectionID) path := host.ConnectionKey(connectionID)
bz := store.Get(path) bz := store.Get(path)
if bz == nil { if bz == nil {
return sdkerrors.Wrapf(clienttypes.ErrFailedConnectionStateVerification, "not found for path %s", path) return sdkerrors.Wrapf(clienttypes.ErrFailedConnectionStateVerification, "not found for path %s", path)
@ -188,7 +188,7 @@ func (cs ClientState) VerifyChannelState(
channelID string, channelID string,
channel exported.ChannelI, channel exported.ChannelI,
) error { ) error {
path := host.KeyChannel(portID, channelID) path := host.ChannelKey(portID, channelID)
bz := store.Get(path) bz := store.Get(path)
if bz == nil { if bz == nil {
return sdkerrors.Wrapf(clienttypes.ErrFailedChannelStateVerification, "not found for path %s", path) return sdkerrors.Wrapf(clienttypes.ErrFailedChannelStateVerification, "not found for path %s", path)
@ -223,7 +223,7 @@ func (cs ClientState) VerifyPacketCommitment(
sequence uint64, sequence uint64,
commitmentBytes []byte, commitmentBytes []byte,
) error { ) error {
path := host.KeyPacketCommitment(portID, channelID, sequence) path := host.PacketCommitmentKey(portID, channelID, sequence)
data := store.Get(path) data := store.Get(path)
if len(data) == 0 { if len(data) == 0 {
@ -253,7 +253,7 @@ func (cs ClientState) VerifyPacketAcknowledgement(
sequence uint64, sequence uint64,
acknowledgement []byte, acknowledgement []byte,
) error { ) error {
path := host.KeyPacketAcknowledgement(portID, channelID, sequence) path := host.PacketAcknowledgementKey(portID, channelID, sequence)
data := store.Get(path) data := store.Get(path)
if len(data) == 0 { if len(data) == 0 {
@ -283,7 +283,7 @@ func (cs ClientState) VerifyPacketReceiptAbsence(
channelID string, channelID string,
sequence uint64, sequence uint64,
) error { ) error {
path := host.KeyPacketReceipt(portID, channelID, sequence) path := host.PacketReceiptKey(portID, channelID, sequence)
data := store.Get(path) data := store.Get(path)
if data != nil { if data != nil {
@ -305,7 +305,7 @@ func (cs ClientState) VerifyNextSequenceRecv(
channelID string, channelID string,
nextSequenceRecv uint64, nextSequenceRecv uint64,
) error { ) error {
path := host.KeyNextSequenceRecv(portID, channelID) path := host.NextSequenceRecvKey(portID, channelID)
data := store.Get(path) data := store.Get(path)
if len(data) == 0 { if len(data) == 0 {

30
x/ibc/light-clients/09-localhost/types/client_state_test.go
View File

@ -66,7 +66,7 @@ func (suite *LocalhostTestSuite) TestVerifyClientState() {
clientState: clientState, clientState: clientState,
malleate: func() { malleate: func() {
bz := clienttypes.MustMarshalClientState(suite.cdc, clientState) bz := clienttypes.MustMarshalClientState(suite.cdc, clientState)
suite.store.Set(host.KeyClientState(), bz) suite.store.Set(host.ClientStateKey(), bz)
}, },
counterparty: clientState, counterparty: clientState,
expPass: true, expPass: true,
@ -76,7 +76,7 @@ func (suite *LocalhostTestSuite) TestVerifyClientState() {
clientState: clientState, clientState: clientState,
malleate: func() { malleate: func() {
bz := clienttypes.MustMarshalClientState(suite.cdc, clientState) bz := clienttypes.MustMarshalClientState(suite.cdc, clientState)
suite.store.Set(host.KeyClientState(), bz) suite.store.Set(host.ClientStateKey(), bz)
}, },
counterparty: invalidClient, counterparty: invalidClient,
expPass: false, expPass: false,
@ -161,7 +161,7 @@ func (suite *LocalhostTestSuite) TestVerifyConnectionState() {
malleate: func() { malleate: func() {
bz, err := suite.cdc.MarshalBinaryBare(&conn1) bz, err := suite.cdc.MarshalBinaryBare(&conn1)
suite.Require().NoError(err) suite.Require().NoError(err)
suite.store.Set(host.KeyConnection(testConnectionID), bz) suite.store.Set(host.ConnectionKey(testConnectionID), bz)
}, },
connection: conn1, connection: conn1,
expPass: true, expPass: true,
@ -177,7 +177,7 @@ func (suite *LocalhostTestSuite) TestVerifyConnectionState() {
name: "proof verification failed: unmarshal error", name: "proof verification failed: unmarshal error",
clientState: types.NewClientState("chainID", clientHeight), clientState: types.NewClientState("chainID", clientHeight),
malleate: func() { malleate: func() {
suite.store.Set(host.KeyConnection(testConnectionID), []byte("connection")) suite.store.Set(host.ConnectionKey(testConnectionID), []byte("connection"))
}, },
connection: conn1, connection: conn1,
expPass: false, expPass: false,
@ -188,7 +188,7 @@ func (suite *LocalhostTestSuite) TestVerifyConnectionState() {
malleate: func() { malleate: func() {
bz, err := suite.cdc.MarshalBinaryBare(&conn2) bz, err := suite.cdc.MarshalBinaryBare(&conn2)
suite.Require().NoError(err) suite.Require().NoError(err)
suite.store.Set(host.KeyConnection(testConnectionID), bz) suite.store.Set(host.ConnectionKey(testConnectionID), bz)
}, },
connection: conn1, connection: conn1,
expPass: false, expPass: false,
@ -233,7 +233,7 @@ func (suite *LocalhostTestSuite) TestVerifyChannelState() {
malleate: func() { malleate: func() {
bz, err := suite.cdc.MarshalBinaryBare(&ch1) bz, err := suite.cdc.MarshalBinaryBare(&ch1)
suite.Require().NoError(err) suite.Require().NoError(err)
suite.store.Set(host.KeyChannel(testPortID, testChannelID), bz) suite.store.Set(host.ChannelKey(testPortID, testChannelID), bz)
}, },
channel: ch1, channel: ch1,
expPass: true, expPass: true,
@ -249,7 +249,7 @@ func (suite *LocalhostTestSuite) TestVerifyChannelState() {
name: "proof verification failed: unmarshal failed", name: "proof verification failed: unmarshal failed",
clientState: types.NewClientState("chainID", clientHeight), clientState: types.NewClientState("chainID", clientHeight),
malleate: func() { malleate: func() {
suite.store.Set(host.KeyChannel(testPortID, testChannelID), []byte("channel")) suite.store.Set(host.ChannelKey(testPortID, testChannelID), []byte("channel"))
}, },
channel: ch1, channel: ch1,
@ -261,7 +261,7 @@ func (suite *LocalhostTestSuite) TestVerifyChannelState() {
malleate: func() { malleate: func() {
bz, err := suite.cdc.MarshalBinaryBare(&ch2) bz, err := suite.cdc.MarshalBinaryBare(&ch2)
suite.Require().NoError(err) suite.Require().NoError(err)
suite.store.Set(host.KeyChannel(testPortID, testChannelID), bz) suite.store.Set(host.ChannelKey(testPortID, testChannelID), bz)
}, },
channel: ch1, channel: ch1,
@ -302,7 +302,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketCommitment() {
clientState: types.NewClientState("chainID", clientHeight), clientState: types.NewClientState("chainID", clientHeight),
malleate: func() { malleate: func() {
suite.store.Set( suite.store.Set(
host.KeyPacketCommitment(testPortID, testChannelID, testSequence), []byte("commitment"), host.PacketCommitmentKey(testPortID, testChannelID, testSequence), []byte("commitment"),
) )
}, },
commitment: []byte("commitment"), commitment: []byte("commitment"),
@ -313,7 +313,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketCommitment() {
clientState: types.NewClientState("chainID", clientHeight), clientState: types.NewClientState("chainID", clientHeight),
malleate: func() { malleate: func() {
suite.store.Set( suite.store.Set(
host.KeyPacketCommitment(testPortID, testChannelID, testSequence), []byte("different"), host.PacketCommitmentKey(testPortID, testChannelID, testSequence), []byte("different"),
) )
}, },
commitment: []byte("commitment"), commitment: []byte("commitment"),
@ -361,7 +361,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketAcknowledgement() {
clientState: types.NewClientState("chainID", clientHeight), clientState: types.NewClientState("chainID", clientHeight),
malleate: func() { malleate: func() {
suite.store.Set( suite.store.Set(
host.KeyPacketAcknowledgement(testPortID, testChannelID, testSequence), []byte("acknowledgement"), host.PacketAcknowledgementKey(testPortID, testChannelID, testSequence), []byte("acknowledgement"),
) )
}, },
ack: []byte("acknowledgement"), ack: []byte("acknowledgement"),
@ -372,7 +372,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketAcknowledgement() {
clientState: types.NewClientState("chainID", clientHeight), clientState: types.NewClientState("chainID", clientHeight),
malleate: func() { malleate: func() {
suite.store.Set( suite.store.Set(
host.KeyPacketAcknowledgement(testPortID, testChannelID, testSequence), []byte("different"), host.PacketAcknowledgementKey(testPortID, testChannelID, testSequence), []byte("different"),
) )
}, },
ack: []byte("acknowledgement"), ack: []byte("acknowledgement"),
@ -416,7 +416,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketReceiptAbsence() {
suite.Require().NoError(err, "receipt absence failed") suite.Require().NoError(err, "receipt absence failed")
suite.store.Set(host.KeyPacketReceipt(testPortID, testChannelID, testSequence), []byte("receipt")) suite.store.Set(host.PacketReceiptKey(testPortID, testChannelID, testSequence), []byte("receipt"))
err = clientState.VerifyPacketReceiptAbsence( err = clientState.VerifyPacketReceiptAbsence(
suite.store, suite.cdc, clientHeight, nil, nil, testPortID, testChannelID, testSequence, suite.store, suite.cdc, clientHeight, nil, nil, testPortID, testChannelID, testSequence,
@ -439,7 +439,7 @@ func (suite *LocalhostTestSuite) TestVerifyNextSeqRecv() {
clientState: types.NewClientState("chainID", clientHeight), clientState: types.NewClientState("chainID", clientHeight),
malleate: func() { malleate: func() {
suite.store.Set( suite.store.Set(
host.KeyNextSequenceRecv(testPortID, testChannelID), host.NextSequenceRecvKey(testPortID, testChannelID),
sdk.Uint64ToBigEndian(nextSeqRecv), sdk.Uint64ToBigEndian(nextSeqRecv),
) )
}, },
@ -451,7 +451,7 @@ func (suite *LocalhostTestSuite) TestVerifyNextSeqRecv() {
clientState: types.NewClientState("chainID", clientHeight), clientState: types.NewClientState("chainID", clientHeight),
malleate: func() { malleate: func() {
suite.store.Set( suite.store.Set(
host.KeyNextSequenceRecv(testPortID, testChannelID), host.NextSequenceRecvKey(testPortID, testChannelID),
sdk.Uint64ToBigEndian(3), sdk.Uint64ToBigEndian(3),
) )
}, },

26
x/ibc/testing/chain.go
View File

@ -197,9 +197,8 @@ func (chain *TestChain) QueryProof(key []byte) ([]byte, clienttypes.Height) {
Prove: true, Prove: true,
}) })
merkleProof := commitmenttypes.MerkleProof{ merkleProof, err := commitmenttypes.ConvertProofs(res.ProofOps)
Proof: res.ProofOps, require.NoError(chain.t, err)
}
proof, err := chain.App.AppCodec().MarshalBinaryBare(&merkleProof) proof, err := chain.App.AppCodec().MarshalBinaryBare(&merkleProof)
require.NoError(chain.t, err) require.NoError(chain.t, err)
@ -222,9 +221,8 @@ func (chain *TestChain) QueryUpgradeProof(key []byte, height uint64) ([]byte, cl
Prove: true, Prove: true,
}) })
merkleProof := commitmenttypes.MerkleProof{ merkleProof, err := commitmenttypes.ConvertProofs(res.ProofOps)
Proof: res.ProofOps, require.NoError(chain.t, err)
}
proof, err := chain.App.AppCodec().MarshalBinaryBare(&merkleProof) proof, err := chain.App.AppCodec().MarshalBinaryBare(&merkleProof)
require.NoError(chain.t, err) require.NoError(chain.t, err)
@ -244,7 +242,7 @@ func (chain *TestChain) QueryClientStateProof(clientID string) (exported.ClientS
clientState, found := chain.App.IBCKeeper.ClientKeeper.GetClientState(chain.GetContext(), clientID) clientState, found := chain.App.IBCKeeper.ClientKeeper.GetClientState(chain.GetContext(), clientID)
require.True(chain.t, found) require.True(chain.t, found)
clientKey := host.FullKeyClientPath(clientID, host.KeyClientState()) clientKey := host.FullClientStateKey(clientID)
proofClient, _ := chain.QueryProof(clientKey) proofClient, _ := chain.QueryProof(clientKey)
return clientState, proofClient return clientState, proofClient
@ -256,7 +254,7 @@ func (chain *TestChain) QueryConsensusStateProof(clientID string) ([]byte, clien
clientState := chain.GetClientState(clientID) clientState := chain.GetClientState(clientID)
consensusHeight := clientState.GetLatestHeight().(clienttypes.Height) consensusHeight := clientState.GetLatestHeight().(clienttypes.Height)
consensusKey := host.FullKeyClientPath(clientID, host.KeyConsensusState(consensusHeight)) consensusKey := host.FullConsensusStateKey(clientID, consensusHeight)
proofConsensus, _ := chain.QueryProof(consensusKey) proofConsensus, _ := chain.QueryProof(consensusKey)
return proofConsensus, consensusHeight return proofConsensus, consensusHeight
@ -647,7 +645,7 @@ func (chain *TestChain) ConnectionOpenTry(
) error { ) error {
counterpartyClient, proofClient := counterparty.QueryClientStateProof(counterpartyConnection.ClientID) counterpartyClient, proofClient := counterparty.QueryClientStateProof(counterpartyConnection.ClientID)
connectionKey := host.KeyConnection(counterpartyConnection.ID) connectionKey := host.ConnectionKey(counterpartyConnection.ID)
proofInit, proofHeight := counterparty.QueryProof(connectionKey) proofInit, proofHeight := counterparty.QueryProof(connectionKey)
proofConsensus, consensusHeight := counterparty.QueryConsensusStateProof(counterpartyConnection.ClientID) proofConsensus, consensusHeight := counterparty.QueryConsensusStateProof(counterpartyConnection.ClientID)
@ -670,7 +668,7 @@ func (chain *TestChain) ConnectionOpenAck(
) error { ) error {
counterpartyClient, proofClient := counterparty.QueryClientStateProof(counterpartyConnection.ClientID) counterpartyClient, proofClient := counterparty.QueryClientStateProof(counterpartyConnection.ClientID)
connectionKey := host.KeyConnection(counterpartyConnection.ID) connectionKey := host.ConnectionKey(counterpartyConnection.ID)
proofTry, proofHeight := counterparty.QueryProof(connectionKey) proofTry, proofHeight := counterparty.QueryProof(connectionKey)
proofConsensus, consensusHeight := counterparty.QueryConsensusStateProof(counterpartyConnection.ClientID) proofConsensus, consensusHeight := counterparty.QueryConsensusStateProof(counterpartyConnection.ClientID)
@ -690,7 +688,7 @@ func (chain *TestChain) ConnectionOpenConfirm(
counterparty *TestChain, counterparty *TestChain,
connection, counterpartyConnection *TestConnection, connection, counterpartyConnection *TestConnection,
) error { ) error {
connectionKey := host.KeyConnection(counterpartyConnection.ID) connectionKey := host.ConnectionKey(counterpartyConnection.ID)
proof, height := counterparty.QueryProof(connectionKey) proof, height := counterparty.QueryProof(connectionKey)
msg := connectiontypes.NewMsgConnectionOpenConfirm( msg := connectiontypes.NewMsgConnectionOpenConfirm(
@ -790,7 +788,7 @@ func (chain *TestChain) ChanOpenTry(
order channeltypes.Order, order channeltypes.Order,
connectionID string, connectionID string,
) error { ) error {
proof, height := counterparty.QueryProof(host.KeyChannel(counterpartyCh.PortID, counterpartyCh.ID)) proof, height := counterparty.QueryProof(host.ChannelKey(counterpartyCh.PortID, counterpartyCh.ID))
msg := channeltypes.NewMsgChannelOpenTry( msg := channeltypes.NewMsgChannelOpenTry(
ch.PortID, ch.ID, ch.ID, // testing doesn't use flexible selection ch.PortID, ch.ID, ch.ID, // testing doesn't use flexible selection
@ -808,7 +806,7 @@ func (chain *TestChain) ChanOpenAck(
counterparty *TestChain, counterparty *TestChain,
ch, counterpartyCh TestChannel, ch, counterpartyCh TestChannel,
) error { ) error {
proof, height := counterparty.QueryProof(host.KeyChannel(counterpartyCh.PortID, counterpartyCh.ID)) proof, height := counterparty.QueryProof(host.ChannelKey(counterpartyCh.PortID, counterpartyCh.ID))
msg := channeltypes.NewMsgChannelOpenAck( msg := channeltypes.NewMsgChannelOpenAck(
ch.PortID, ch.ID, ch.PortID, ch.ID,
@ -824,7 +822,7 @@ func (chain *TestChain) ChanOpenConfirm(
counterparty *TestChain, counterparty *TestChain,
ch, counterpartyCh TestChannel, ch, counterpartyCh TestChannel,
) error { ) error {
proof, height := counterparty.QueryProof(host.KeyChannel(counterpartyCh.PortID, counterpartyCh.ID)) proof, height := counterparty.QueryProof(host.ChannelKey(counterpartyCh.PortID, counterpartyCh.ID))
msg := channeltypes.NewMsgChannelOpenConfirm( msg := channeltypes.NewMsgChannelOpenConfirm(
ch.PortID, ch.ID, ch.PortID, ch.ID,

4
x/ibc/testing/coordinator.go
View File

@ -238,7 +238,7 @@ func (coord *Coordinator) RecvPacket(
packet channeltypes.Packet, packet channeltypes.Packet,
) error { ) error {
// get proof of packet commitment on source // get proof of packet commitment on source
packetKey := host.KeyPacketCommitment(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence()) packetKey := host.PacketCommitmentKey(packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
proof, proofHeight := source.QueryProof(packetKey) proof, proofHeight := source.QueryProof(packetKey)
recvMsg := channeltypes.NewMsgRecvPacket(packet, proof, proofHeight, counterparty.SenderAccount.GetAddress()) recvMsg := channeltypes.NewMsgRecvPacket(packet, proof, proofHeight, counterparty.SenderAccount.GetAddress())
@ -277,7 +277,7 @@ func (coord *Coordinator) AcknowledgePacket(
packet channeltypes.Packet, ack []byte, packet channeltypes.Packet, ack []byte,
) error { ) error {
// get proof of acknowledgement on counterparty // get proof of acknowledgement on counterparty
packetKey := host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey := host.PacketAcknowledgementKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
proof, proofHeight := counterparty.QueryProof(packetKey) proof, proofHeight := counterparty.QueryProof(packetKey)
ackMsg := channeltypes.NewMsgAcknowledgement(packet, ack, proof, proofHeight, source.SenderAccount.GetAddress()) ackMsg := channeltypes.NewMsgAcknowledgement(packet, ack, proof, proofHeight, source.SenderAccount.GetAddress())

24
x/ibc/testing/solomachine.go
View File

@ -251,8 +251,7 @@ func (solo *Solomachine) GenerateSignature(signBytes []byte) []byte {
// GetClientStatePath returns the commitment path for the client state. // GetClientStatePath returns the commitment path for the client state.
func (solo *Solomachine) GetClientStatePath(counterpartyClientIdentifier string) commitmenttypes.MerklePath { func (solo *Solomachine) GetClientStatePath(counterpartyClientIdentifier string) commitmenttypes.MerklePath {
clientPrefixedPath := "clients/" + counterpartyClientIdentifier + "/" + host.ClientStatePath() path, err := commitmenttypes.ApplyPrefix(prefix, commitmenttypes.NewMerklePath(host.FullClientStatePath(counterpartyClientIdentifier)))
path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath)
require.NoError(solo.t, err) require.NoError(solo.t, err)
return path return path
@ -260,8 +259,7 @@ func (solo *Solomachine) GetClientStatePath(counterpartyClientIdentifier string)
// GetConsensusStatePath returns the commitment path for the consensus state. // GetConsensusStatePath returns the commitment path for the consensus state.
func (solo *Solomachine) GetConsensusStatePath(counterpartyClientIdentifier string, consensusHeight exported.Height) commitmenttypes.MerklePath { func (solo *Solomachine) GetConsensusStatePath(counterpartyClientIdentifier string, consensusHeight exported.Height) commitmenttypes.MerklePath {
clientPrefixedPath := "clients/" + counterpartyClientIdentifier + "/" + host.ConsensusStatePath(consensusHeight) path, err := commitmenttypes.ApplyPrefix(prefix, commitmenttypes.NewMerklePath(host.FullConsensusStatePath(counterpartyClientIdentifier, consensusHeight)))
path, err := commitmenttypes.ApplyPrefix(prefix, clientPrefixedPath)
require.NoError(solo.t, err) require.NoError(solo.t, err)
return path return path
@ -269,7 +267,8 @@ func (solo *Solomachine) GetConsensusStatePath(counterpartyClientIdentifier stri
// GetConnectionStatePath returns the commitment path for the connection state. // GetConnectionStatePath returns the commitment path for the connection state.
func (solo *Solomachine) GetConnectionStatePath(connID string) commitmenttypes.MerklePath { func (solo *Solomachine) GetConnectionStatePath(connID string) commitmenttypes.MerklePath {
path, err := commitmenttypes.ApplyPrefix(prefix, host.ConnectionPath(connID)) connectionPath := commitmenttypes.NewMerklePath(host.ConnectionPath(connID))
path, err := commitmenttypes.ApplyPrefix(prefix, connectionPath)
require.NoError(solo.t, err) require.NoError(solo.t, err)
return path return path
@ -277,7 +276,8 @@ func (solo *Solomachine) GetConnectionStatePath(connID string) commitmenttypes.M
// GetChannelStatePath returns the commitment path for that channel state. // GetChannelStatePath returns the commitment path for that channel state.
func (solo *Solomachine) GetChannelStatePath(portID, channelID string) commitmenttypes.MerklePath { func (solo *Solomachine) GetChannelStatePath(portID, channelID string) commitmenttypes.MerklePath {
path, err := commitmenttypes.ApplyPrefix(prefix, host.ChannelPath(portID, channelID)) channelPath := commitmenttypes.NewMerklePath(host.ChannelPath(portID, channelID))
path, err := commitmenttypes.ApplyPrefix(prefix, channelPath)
require.NoError(solo.t, err) require.NoError(solo.t, err)
return path return path
@ -285,7 +285,8 @@ func (solo *Solomachine) GetChannelStatePath(portID, channelID string) commitmen
// GetPacketCommitmentPath returns the commitment path for a packet commitment. // GetPacketCommitmentPath returns the commitment path for a packet commitment.
func (solo *Solomachine) GetPacketCommitmentPath(portID, channelID string) commitmenttypes.MerklePath { func (solo *Solomachine) GetPacketCommitmentPath(portID, channelID string) commitmenttypes.MerklePath {
path, err := commitmenttypes.ApplyPrefix(prefix, host.PacketCommitmentPath(portID, channelID, solo.Sequence)) commitmentPath := commitmenttypes.NewMerklePath(host.PacketCommitmentPath(portID, channelID, solo.Sequence))
path, err := commitmenttypes.ApplyPrefix(prefix, commitmentPath)
require.NoError(solo.t, err) require.NoError(solo.t, err)
return path return path
@ -293,7 +294,8 @@ func (solo *Solomachine) GetPacketCommitmentPath(portID, channelID string) commi
// GetPacketAcknowledgementPath returns the commitment path for a packet acknowledgement. // GetPacketAcknowledgementPath returns the commitment path for a packet acknowledgement.
func (solo *Solomachine) GetPacketAcknowledgementPath(portID, channelID string) commitmenttypes.MerklePath { func (solo *Solomachine) GetPacketAcknowledgementPath(portID, channelID string) commitmenttypes.MerklePath {
path, err := commitmenttypes.ApplyPrefix(prefix, host.PacketAcknowledgementPath(portID, channelID, solo.Sequence)) ackPath := commitmenttypes.NewMerklePath(host.PacketAcknowledgementPath(portID, channelID, solo.Sequence))
path, err := commitmenttypes.ApplyPrefix(prefix, ackPath)
require.NoError(solo.t, err) require.NoError(solo.t, err)
return path return path
@ -302,7 +304,8 @@ func (solo *Solomachine) GetPacketAcknowledgementPath(portID, channelID string)
// GetPacketReceiptPath returns the commitment path for a packet receipt // GetPacketReceiptPath returns the commitment path for a packet receipt
// and an absent receipts. // and an absent receipts.
func (solo *Solomachine) GetPacketReceiptPath(portID, channelID string) commitmenttypes.MerklePath { func (solo *Solomachine) GetPacketReceiptPath(portID, channelID string) commitmenttypes.MerklePath {
path, err := commitmenttypes.ApplyPrefix(prefix, host.PacketReceiptPath(portID, channelID, solo.Sequence)) receiptPath := commitmenttypes.NewMerklePath(host.PacketReceiptPath(portID, channelID, solo.Sequence))
path, err := commitmenttypes.ApplyPrefix(prefix, receiptPath)
require.NoError(solo.t, err) require.NoError(solo.t, err)
return path return path
@ -310,7 +313,8 @@ func (solo *Solomachine) GetPacketReceiptPath(portID, channelID string) commitme
// GetNextSequenceRecvPath returns the commitment path for the next sequence recv counter. // GetNextSequenceRecvPath returns the commitment path for the next sequence recv counter.
func (solo *Solomachine) GetNextSequenceRecvPath(portID, channelID string) commitmenttypes.MerklePath { func (solo *Solomachine) GetNextSequenceRecvPath(portID, channelID string) commitmenttypes.MerklePath {
path, err := commitmenttypes.ApplyPrefix(prefix, host.NextSequenceRecvPath(portID, channelID)) nextSequenceRecvPath := commitmenttypes.NewMerklePath(host.NextSequenceRecvPath(portID, channelID))
path, err := commitmenttypes.ApplyPrefix(prefix, nextSequenceRecvPath)
require.NoError(solo.t, err) require.NoError(solo.t, err)
return path return path

1184
x/staking/types/staking.pb.go
View File

File diff suppressed because it is too large Load Diff