LaconicNetwork/cosmos-sdk
10
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

remove proof path from IBC queries (#7725)

Browse Source 
* remove proof path

* make proto-all with old install

* fix build
This commit is contained in:
colin axnér 2020-10-29 13:42:12 +01:00 committed by GitHub
parent b7b925a1ac
commit 1a15713289
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 246 additions and 935 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -94,10 +94,8 @@ message QueryChannelResponse {
ibc.core.channel.v1.Channel channel = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}
// QueryChannelsRequest is the request type for the Query/Channels RPC method
@ -152,10 +150,8 @@ message QueryChannelClientStateResponse {
ibc.core.client.v1.IdentifiedClientState identified_client_state = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}
// QueryChannelConsensusStateRequest is the request type for the
@ -180,10 +176,8 @@ message QueryChannelConsensusStateResponse {
string client_id = 2;
// merkle proof of existence
bytes proof = 3;
// merkle proof path
string proof_path = 4;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 5 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
}
// QueryPacketCommitmentRequest is the request type for the
@ -205,10 +199,8 @@ message QueryPacketCommitmentResponse {
bytes commitment = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}
// QueryPacketCommitmentsRequest is the request type for the
@ -251,10 +243,8 @@ message QueryPacketAcknowledgementResponse {
bytes acknowledgement = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}
// QueryUnreceivedPacketsRequest is the request type for the
@ -313,8 +303,6 @@ message QueryNextSequenceReceiveResponse {
uint64 next_sequence_receive = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}

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

@ -50,10 +50,8 @@ message QueryClientStateResponse {
google.protobuf.Any client_state = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}
// QueryClientStatesRequest is the request type for the Query/ClientStates RPC
@ -94,10 +92,8 @@ message QueryConsensusStateResponse {
google.protobuf.Any consensus_state = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}
// QueryConsensusStatesRequest is the request type for the Query/ConsensusStates

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

@ -57,10 +57,8 @@ message QueryConnectionResponse {
ibc.core.connection.v1.ConnectionEnd connection = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}
// QueryConnectionsRequest is the request type for the Query/Connections RPC
@ -94,10 +92,8 @@ message QueryClientConnectionsResponse {
repeated string connection_paths = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was generated
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}
// QueryConnectionClientStateRequest is the request type for the
@ -114,10 +110,8 @@ message QueryConnectionClientStateResponse {
ibc.core.client.v1.IdentifiedClientState identified_client_state = 1;
// merkle proof of existence
bytes proof = 2;
// merkle proof path
string proof_path = 3;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
}
// QueryConnectionConsensusStateRequest is the request type for the
@ -138,8 +132,6 @@ message QueryConnectionConsensusStateResponse {
string client_id = 2;
// merkle proof of existence
bytes proof = 3;
// merkle proof path
string proof_path = 4;
// height at which the proof was retrieved
ibc.core.client.v1.Height proof_height = 5 [(gogoproto.nullable) = false];
ibc.core.client.v1.Height proof_height = 4 [(gogoproto.nullable) = false];
}

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

@ -62,7 +62,7 @@ func QueryClientStateABCI(
return nil, err
}
clientStateRes := types.NewQueryClientStateResponse(clientID, anyClientState, proofBz, proofHeight)
clientStateRes := types.NewQueryClientStateResponse(anyClientState, proofBz, proofHeight)
return clientStateRes, nil
}
@ -115,7 +115,7 @@ func QueryConsensusStateABCI(
return nil, err
}
return types.NewQueryConsensusStateResponse(clientID, anyConsensusState, proofBz, proofHeight), nil
return types.NewQueryConsensusStateResponse(anyConsensusState, proofBz, proofHeight), nil
}
// QueryTendermintHeader takes a client context and returns the appropriate

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

@ -1,35 +1,27 @@
package types
import (
"strings"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/core/24-host"
)
// NewQueryClientStateResponse creates a new QueryClientStateResponse instance.
func NewQueryClientStateResponse(
clientID string, clientStateAny *codectypes.Any, proof []byte, height Height,
clientStateAny *codectypes.Any, proof []byte, height Height,
) *QueryClientStateResponse {
path := commitmenttypes.NewMerklePath(append([]string{clientID}, strings.Split(host.ClientStatePath(), "/")...))
return &QueryClientStateResponse{
ClientState: clientStateAny,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}
// NewQueryConsensusStateResponse creates a new QueryConsensusStateResponse instance.
func NewQueryConsensusStateResponse(
clientID string, consensusStateAny *codectypes.Any, proof []byte, height Height,
consensusStateAny *codectypes.Any, proof []byte, height Height,
) *QueryConsensusStateResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(clientID, host.ConsensusStatePath(height)), "/"))
return &QueryConsensusStateResponse{
ConsensusState: consensusStateAny,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}

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

@ -86,10 +86,8 @@ type QueryClientStateResponse struct {
ClientState *types.Any `protobuf:"bytes,1,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryClientStateResponse) Reset() { *m = QueryClientStateResponse{} }
@ -139,13 +137,6 @@ func (m *QueryClientStateResponse) GetProof() []byte {
return nil
}
func (m *QueryClientStateResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryClientStateResponse) GetProofHeight() Height {
if m != nil {
return m.ProofHeight
@ -339,10 +330,8 @@ type QueryConsensusStateResponse struct {
ConsensusState *types.Any `protobuf:"bytes,1,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryConsensusStateResponse) Reset() { *m = QueryConsensusStateResponse{} }
@ -392,13 +381,6 @@ func (m *QueryConsensusStateResponse) GetProof() []byte {
return nil
}
func (m *QueryConsensusStateResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryConsensusStateResponse) GetProofHeight() Height {
if m != nil {
return m.ProofHeight
@ -532,55 +514,54 @@ func init() {
func init() { proto.RegisterFile("ibc/core/client/v1/query.proto", fileDescriptor_dc42cdfd1d52d76e) }
var fileDescriptor_dc42cdfd1d52d76e = []byte{
// 765 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0x4f, 0x4f, 0x13, 0x41,
0x14, 0xef, 0xf0, 0xc7, 0xc0, 0xb4, 0x80, 0x99, 0x90, 0x58, 0x16, 0x2c, 0x58, 0xa2, 0x82, 0xd2,
0x19, 0x5a, 0xa3, 0x78, 0xf1, 0x20, 0x24, 0x28, 0x17, 0x02, 0xeb, 0xc1, 0xc4, 0xc4, 0x90, 0xdd,
0xed, 0xb0, 0x9d, 0x08, 0x3b, 0xa5, 0x33, 0x6d, 0x24, 0x84, 0x0b, 0x9f, 0xc0, 0xc4, 0xc4, 0xab,
0x5f, 0xc0, 0x78, 0xf2, 0x33, 0x18, 0x2e, 0x26, 0x44, 0x13, 0xe3, 0xc1, 0x18, 0x03, 0x7e, 0x10,
0xb3, 0x33, 0xb3, 0xb0, 0x0b, 0x4b, 0x58, 0x8d, 0x89, 0xa7, 0xee, 0xbe, 0x3f, 0xf3, 0x7e, 0xef,
0xf7, 0x7b, 0xf3, 0xba, 0xb0, 0xc4, 0x5c, 0x8f, 0x78, 0xbc, 0x45, 0x89, 0xb7, 0xc1, 0x68, 0x20,
0x49, 0xa7, 0x4a, 0xb6, 0xda, 0xb4, 0xb5, 0x8d, 0x9b, 0x2d, 0x2e, 0x39, 0x42, 0xcc, 0xf5, 0x70,
0xe8, 0xc7, 0xda, 0x8f, 0x3b, 0x55, 0xeb, 0x96, 0xc7, 0xc5, 0x26, 0x17, 0xc4, 0x75, 0x04, 0xd5,
0xc1, 0xa4, 0x53, 0x75, 0xa9, 0x74, 0xaa, 0xa4, 0xe9, 0xf8, 0x2c, 0x70, 0x24, 0xe3, 0x81, 0xce,
0xb7, 0xc6, 0x53, 0xce, 0x37, 0x27, 0xe9, 0x80, 0x11, 0x9f, 0x73, 0x7f, 0x83, 0x12, 0xf5, 0xe6,
0xb6, 0xd7, 0x89, 0x13, 0x98, 0xda, 0xd6, 0x98, 0x71, 0x39, 0x4d, 0x46, 0x9c, 0x20, 0xe0, 0x52,
0x1d, 0x2c, 0x8c, 0x77, 0xd8, 0xe7, 0x3e, 0x57, 0x8f, 0x24, 0x7c, 0xd2, 0xd6, 0xf2, 0x3d, 0x78,
0x65, 0x35, 0x44, 0xb4, 0xa0, 0x6a, 0x3c, 0x91, 0x8e, 0xa4, 0x36, 0xdd, 0x6a, 0x53, 0x21, 0xd1,
0x28, 0xec, 0xd7, 0x95, 0xd7, 0x58, 0xbd, 0x08, 0x26, 0xc0, 0x54, 0xbf, 0xdd, 0xa7, 0x0d, 0x4b,
0xf5, 0xf2, 0x27, 0x00, 0x8b, 0x67, 0x13, 0x45, 0x93, 0x07, 0x82, 0xa2, 0x39, 0x58, 0x30, 0x99,
0x22, 0xb4, 0xab, 0xe4, 0x7c, 0x6d, 0x18, 0x6b, 0x7c, 0x38, 0x82, 0x8e, 0x1f, 0x06, 0xdb, 0x76,
0xde, 0x3b, 0x39, 0x00, 0x0d, 0xc3, 0xde, 0x66, 0x8b, 0xf3, 0xf5, 0x62, 0xd7, 0x04, 0x98, 0x2a,
0xd8, 0xfa, 0x05, 0x5d, 0x85, 0x50, 0x3d, 0xac, 0x35, 0x1d, 0xd9, 0x28, 0x76, 0x2b, 0x24, 0xfd,
0xca, 0xb2, 0xe2, 0xc8, 0x06, 0x5a, 0x80, 0x05, 0xed, 0x6e, 0x50, 0xe6, 0x37, 0x64, 0xb1, 0x47,
0x55, 0xb3, 0xf0, 0x59, 0x25, 0xf0, 0x63, 0x15, 0x31, 0xdf, 0xb3, 0xff, 0x63, 0x3c, 0x67, 0xe7,
0x55, 0x96, 0x36, 0x95, 0xdd, 0xb3, 0xed, 0x88, 0x88, 0x88, 0x45, 0x08, 0x4f, 0x74, 0x32, 0xcd,
0xdc, 0xc0, 0x5a, 0x54, 0x1c, 0x8a, 0x8a, 0xf5, 0x04, 0x18, 0x51, 0xf1, 0x8a, 0xe3, 0x47, 0x24,
0xda, 0xb1, 0xcc, 0xf2, 0x07, 0x00, 0x47, 0x52, 0x8a, 0x18, 0xd2, 0x96, 0xe1, 0x40, 0x9c, 0x34,
0x51, 0x04, 0x13, 0xdd, 0x53, 0xf9, 0xda, 0x74, 0x5a, 0x1f, 0x4b, 0x75, 0x1a, 0x48, 0xb6, 0xce,
0x68, 0x3d, 0x4e, 0x7f, 0x21, 0x46, 0xa5, 0x40, 0x8f, 0x12, 0xa8, 0xbb, 0x14, 0xea, 0x9b, 0x17,
0xa2, 0xd6, 0x60, 0x12, 0xb0, 0xdf, 0x01, 0x68, 0x69, 0xd8, 0xa1, 0x2b, 0x10, 0x6d, 0x91, 0x79,
0x4c, 0xd0, 0x75, 0x38, 0xd8, 0xa1, 0x2d, 0xc1, 0x78, 0xb0, 0x16, 0xb4, 0x37, 0x5d, 0xda, 0x52,
0x40, 0x7a, 0xec, 0x01, 0x63, 0x5d, 0x56, 0xc6, 0x78, 0x98, 0x11, 0xb1, 0x3b, 0x11, 0xa6, 0x45,
0x42, 0x93, 0x70, 0x60, 0x23, 0xec, 0x4d, 0xc6, 0xa5, 0xee, 0xb3, 0x0b, 0xda, 0x68, 0x94, 0xfc,
0x0a, 0xe0, 0x68, 0x2a, 0x5c, 0xc3, 0xf3, 0x03, 0x38, 0xe4, 0x45, 0x9e, 0x0c, 0xf3, 0x39, 0xe8,
0x25, 0x8e, 0xf9, 0x8f, 0x23, 0xba, 0x97, 0xde, 0x98, 0xc8, 0x24, 0xc4, 0x62, 0xca, 0x34, 0xfc,
0xcd, 0x0c, 0x7f, 0x04, 0x70, 0x2c, 0x1d, 0x84, 0xa1, 0xf7, 0x39, 0xbc, 0x7c, 0x8a, 0xde, 0x68,
0x92, 0x67, 0xd2, 0xda, 0x4d, 0x1e, 0xf3, 0x94, 0xc9, 0x46, 0x82, 0x80, 0xa1, 0x24, 0xfb, 0xff,
0x6e, 0xaa, 0x6b, 0x9f, 0x7b, 0x61, 0xaf, 0x6a, 0x04, 0xbd, 0x05, 0x30, 0x1f, 0xbb, 0x46, 0xe8,
0x76, 0x1a, 0xce, 0x73, 0x96, 0xa4, 0x35, 0x93, 0x2d, 0x58, 0x03, 0x28, 0xdf, 0xdd, 0xfb, 0xf2,
0xeb, 0x75, 0x17, 0x41, 0x15, 0xa2, 0xd6, 0x7c, 0xb4, 0xe1, 0xf5, 0x7f, 0x41, 0xe2, 0xf6, 0x93,
0x9d, 0x63, 0x2d, 0x77, 0xd1, 0x1b, 0x00, 0x0b, 0xf1, 0x9d, 0x81, 0x32, 0x55, 0x8d, 0x06, 0xc3,
0xaa, 0x64, 0x8c, 0x36, 0x20, 0xa7, 0x15, 0xc8, 0x49, 0x74, 0xed, 0x42, 0x90, 0xe8, 0x3b, 0x80,
0x83, 0x49, 0x05, 0x11, 0x3e, 0xbf, 0x58, 0xda, 0xfa, 0xb0, 0x48, 0xe6, 0x78, 0x03, 0x8f, 0x29,
0x78, 0x1e, 0x72, 0x52, 0xe1, 0x9d, 0x1a, 0xbd, 0x38, 0x8d, 0xc4, 0x2c, 0x13, 0xb2, 0x93, 0x5c,
0x49, 0xbb, 0x44, 0xdf, 0xca, 0x13, 0xbb, 0x7e, 0xdf, 0x45, 0xef, 0x01, 0x1c, 0x3a, 0x35, 0xe7,
0x28, 0x2b, 0xde, 0x63, 0xf6, 0x67, 0xb3, 0x27, 0x98, 0x0e, 0xef, 0xab, 0x0e, 0x6b, 0x68, 0xf6,
0x4f, 0x3b, 0x9c, 0x5f, 0xdd, 0x3f, 0x2c, 0x81, 0x83, 0xc3, 0x12, 0xf8, 0x79, 0x58, 0x02, 0xaf,
0x8e, 0x4a, 0xb9, 0x83, 0xa3, 0x52, 0xee, 0xdb, 0x51, 0x29, 0xf7, 0x6c, 0xce, 0x67, 0xb2, 0xd1,
0x76, 0xb1, 0xc7, 0x37, 0x89, 0xf9, 0x1c, 0xd1, 0x3f, 0x15, 0x51, 0x7f, 0x41, 0x5e, 0x92, 0xe3,
0xcf, 0x8e, 0xd9, 0x5a, 0xc5, 0x54, 0x94, 0xdb, 0x4d, 0x2a, 0xdc, 0x4b, 0x6a, 0x1b, 0xde, 0xf9,
0x1d, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x28, 0x91, 0xcd, 0xf9, 0x08, 0x00, 0x00,
// 747 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4f, 0x4f, 0x13, 0x41,
0x14, 0xef, 0xf0, 0xc7, 0xc0, 0xb4, 0x80, 0x99, 0x90, 0x58, 0x16, 0x52, 0x6a, 0x89, 0x5a, 0x94,
0xce, 0xd0, 0x1a, 0xc5, 0x8b, 0x07, 0x21, 0x41, 0xb9, 0x10, 0x59, 0x0f, 0x26, 0x26, 0x86, 0xec,
0x6e, 0x87, 0xed, 0x44, 0xd8, 0x29, 0x9d, 0x69, 0x23, 0x21, 0x5c, 0xf8, 0x04, 0x26, 0x26, 0x5e,
0xfd, 0x02, 0x86, 0x93, 0x89, 0xdf, 0xc0, 0x70, 0x24, 0x7a, 0xf1, 0x60, 0x8c, 0x01, 0x3f, 0x88,
0xe9, 0xcc, 0x2c, 0xdd, 0x85, 0x25, 0xac, 0x46, 0x4f, 0x3b, 0xf3, 0xfe, 0xfe, 0xde, 0xef, 0xbd,
0x79, 0x59, 0x58, 0x60, 0xae, 0x47, 0x3c, 0xde, 0xa2, 0xc4, 0xdb, 0x64, 0x34, 0x90, 0xa4, 0x53,
0x25, 0xdb, 0x6d, 0xda, 0xda, 0xc1, 0xcd, 0x16, 0x97, 0x1c, 0x21, 0xe6, 0x7a, 0xb8, 0xab, 0xc7,
0x5a, 0x8f, 0x3b, 0x55, 0xeb, 0xb6, 0xc7, 0xc5, 0x16, 0x17, 0xc4, 0x75, 0x04, 0xd5, 0xc6, 0xa4,
0x53, 0x75, 0xa9, 0x74, 0xaa, 0xa4, 0xe9, 0xf8, 0x2c, 0x70, 0x24, 0xe3, 0x81, 0xf6, 0xb7, 0xa6,
0x13, 0xe2, 0x9b, 0x48, 0xda, 0x60, 0xc2, 0xe7, 0xdc, 0xdf, 0xa4, 0x44, 0xdd, 0xdc, 0xf6, 0x06,
0x71, 0x02, 0x93, 0xdb, 0x9a, 0x32, 0x2a, 0xa7, 0xc9, 0x88, 0x13, 0x04, 0x5c, 0xaa, 0xc0, 0xc2,
0x68, 0xc7, 0x7d, 0xee, 0x73, 0x75, 0x24, 0xdd, 0x93, 0x96, 0x96, 0xee, 0xc3, 0x6b, 0x6b, 0x5d,
0x44, 0x4b, 0x2a, 0xc7, 0x33, 0xe9, 0x48, 0x6a, 0xd3, 0xed, 0x36, 0x15, 0x12, 0x4d, 0xc2, 0x61,
0x9d, 0x79, 0x9d, 0xd5, 0xf3, 0xa0, 0x08, 0xca, 0xc3, 0xf6, 0x90, 0x16, 0xac, 0xd4, 0x4b, 0x07,
0x00, 0xe6, 0xcf, 0x3b, 0x8a, 0x26, 0x0f, 0x04, 0x45, 0x0b, 0x30, 0x67, 0x3c, 0x45, 0x57, 0xae,
0x9c, 0xb3, 0xb5, 0x71, 0xac, 0xf1, 0xe1, 0x10, 0x3a, 0x7e, 0x14, 0xec, 0xd8, 0x59, 0xaf, 0x17,
0x00, 0x8d, 0xc3, 0xc1, 0x66, 0x8b, 0xf3, 0x8d, 0x7c, 0x5f, 0x11, 0x94, 0x73, 0xb6, 0xbe, 0xa0,
0x25, 0x98, 0x53, 0x87, 0xf5, 0x06, 0x65, 0x7e, 0x43, 0xe6, 0xfb, 0x55, 0x38, 0x0b, 0x9f, 0xa7,
0x1a, 0x3f, 0x51, 0x16, 0x8b, 0x03, 0x87, 0x3f, 0xa6, 0x33, 0x76, 0x56, 0x79, 0x69, 0x51, 0xc9,
0x3d, 0x8f, 0x57, 0x84, 0x95, 0x2e, 0x43, 0xd8, 0x6b, 0x84, 0x41, 0x7b, 0x13, 0xeb, 0xae, 0xe1,
0x6e, 0xd7, 0xb0, 0x6e, 0xb1, 0xe9, 0x1a, 0x7e, 0xea, 0xf8, 0x21, 0x4b, 0x76, 0xc4, 0xb3, 0xf4,
0x11, 0xc0, 0x89, 0x84, 0x24, 0x86, 0x95, 0x55, 0x38, 0x12, 0x65, 0x45, 0xe4, 0x41, 0xb1, 0xbf,
0x9c, 0xad, 0xcd, 0x26, 0xd5, 0xb1, 0x52, 0xa7, 0x81, 0x64, 0x1b, 0x8c, 0xd6, 0xa3, 0xfc, 0xe6,
0x22, 0x5c, 0x09, 0xf4, 0x38, 0x86, 0xba, 0x4f, 0xa1, 0xbe, 0x75, 0x29, 0x6a, 0x0d, 0x26, 0x06,
0xfb, 0x03, 0x80, 0x96, 0x86, 0xdd, 0x55, 0x05, 0xa2, 0x2d, 0x52, 0xcf, 0x01, 0xba, 0x01, 0x47,
0x3b, 0xb4, 0x25, 0x18, 0x0f, 0xd6, 0x83, 0xf6, 0x96, 0x4b, 0x5b, 0x0a, 0xc8, 0x80, 0x3d, 0x62,
0xa4, 0xab, 0x4a, 0x18, 0x35, 0x8b, 0x34, 0xb1, 0x67, 0xa6, 0x9b, 0x84, 0x66, 0xe0, 0xc8, 0x66,
0xb7, 0x36, 0x19, 0x5a, 0x0d, 0x14, 0x41, 0x79, 0xc8, 0xce, 0x69, 0xa1, 0xe9, 0xe4, 0x27, 0x00,
0x27, 0x13, 0xe1, 0x1a, 0x9e, 0x1f, 0xc2, 0x31, 0x2f, 0xd4, 0xa4, 0x18, 0xc0, 0x51, 0x2f, 0x16,
0xe6, 0x7f, 0xce, 0xe0, 0x7e, 0x32, 0x72, 0x91, 0x8a, 0xe9, 0xe5, 0x84, 0x76, 0xff, 0xcd, 0x90,
0x7e, 0x06, 0x70, 0x2a, 0x19, 0x84, 0xe1, 0xef, 0x25, 0xbc, 0x7a, 0x86, 0xbf, 0x70, 0x54, 0xe7,
0x92, 0xca, 0x8d, 0x87, 0x79, 0xce, 0x64, 0x23, 0x46, 0xc0, 0x58, 0x9c, 0xde, 0x7f, 0x37, 0xb6,
0xb5, 0x2f, 0x83, 0x70, 0x50, 0x15, 0x82, 0xde, 0x03, 0x98, 0x8d, 0xbc, 0x13, 0x74, 0x27, 0x09,
0xe7, 0x05, 0x6b, 0xce, 0x9a, 0x4b, 0x67, 0xac, 0x01, 0x94, 0xee, 0xed, 0x7f, 0xfd, 0xf5, 0xb6,
0x8f, 0xa0, 0x0a, 0x51, 0x8b, 0x3a, 0xdc, 0xd1, 0x7a, 0x9b, 0xc7, 0x9e, 0x37, 0xd9, 0x3d, 0xed,
0xe5, 0x1e, 0x7a, 0x07, 0x60, 0x2e, 0xba, 0x14, 0x50, 0xaa, 0xac, 0xe1, 0x60, 0x58, 0x95, 0x94,
0xd6, 0x06, 0xe4, 0xac, 0x02, 0x39, 0x83, 0xae, 0x5f, 0x0a, 0x12, 0x7d, 0x07, 0x70, 0x34, 0xde,
0x41, 0x84, 0x2f, 0x4e, 0x96, 0xb4, 0x1f, 0x2c, 0x92, 0xda, 0xde, 0xc0, 0x63, 0x0a, 0x9e, 0x87,
0x9c, 0x44, 0x78, 0x67, 0x46, 0x2f, 0x4a, 0x23, 0x31, 0xdb, 0x82, 0xec, 0xc6, 0x77, 0xce, 0x1e,
0xd1, 0xaf, 0xb2, 0x27, 0xd7, 0xf7, 0x3d, 0x74, 0x00, 0xe0, 0xd8, 0x99, 0x39, 0x47, 0x69, 0xf1,
0x9e, 0xb2, 0x3f, 0x9f, 0xde, 0xc1, 0x54, 0xf8, 0x40, 0x55, 0x58, 0x43, 0xf3, 0x7f, 0x5a, 0xe1,
0xe2, 0xda, 0xe1, 0x71, 0x01, 0x1c, 0x1d, 0x17, 0xc0, 0xcf, 0xe3, 0x02, 0x78, 0x73, 0x52, 0xc8,
0x1c, 0x9d, 0x14, 0x32, 0xdf, 0x4e, 0x0a, 0x99, 0x17, 0x0b, 0x3e, 0x93, 0x8d, 0xb6, 0x8b, 0x3d,
0xbe, 0x45, 0xcc, 0x0f, 0x85, 0xfe, 0x54, 0x44, 0xfd, 0x15, 0x79, 0x4d, 0x4e, 0x7f, 0x1c, 0xe6,
0x6b, 0x15, 0x93, 0x51, 0xee, 0x34, 0xa9, 0x70, 0xaf, 0xa8, 0x75, 0x77, 0xf7, 0x77, 0x00, 0x00,
0x00, 0xff, 0xff, 0x09, 0x8e, 0x83, 0x3d, 0xbb, 0x08, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -842,14 +823,7 @@ func (m *QueryClientStateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -1035,14 +1009,7 @@ func (m *QueryConsensusStateResponse) MarshalToSizedBuffer(dAtA []byte) (int, er
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -1194,10 +1161,6 @@ func (m *QueryClientStateResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -1271,10 +1234,6 @@ func (m *QueryConsensusStateResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -1507,38 +1466,6 @@ func (m *QueryClientStateResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}
@ -2050,38 +1977,6 @@ func (m *QueryConsensusStateResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}

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

@ -57,7 +57,7 @@ func queryConnectionABCI(clientCtx client.Context, connectionID string) (*types.
return nil, err
}
return types.NewQueryConnectionResponse(connectionID, connection, proofBz, proofHeight), nil
return types.NewQueryConnectionResponse(connection, proofBz, proofHeight), nil
}
// QueryClientConnections queries the connection paths registered for a particular client.
@ -96,7 +96,7 @@ func queryClientConnectionsABCI(clientCtx client.Context, clientID string) (*typ
return nil, err
}
return types.NewQueryClientConnectionsResponse(clientID, paths, proofBz, proofHeight), nil
return types.NewQueryClientConnectionsResponse(paths, proofBz, proofHeight), nil
}
// QueryConnectionClientState returns the ClientState of a connection end. If

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

@ -1,37 +1,29 @@
package types
import (
"strings"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/types"
commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/core/24-host"
"github.com/cosmos/cosmos-sdk/x/ibc/core/exported"
)
// NewQueryConnectionResponse creates a new QueryConnectionResponse instance
func NewQueryConnectionResponse(
connectionID string, connection ConnectionEnd, proof []byte, height clienttypes.Height,
connection ConnectionEnd, proof []byte, height clienttypes.Height,
) *QueryConnectionResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.ConnectionPath(connectionID), "/"))
return &QueryConnectionResponse{
Connection: &connection,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}
// NewQueryClientConnectionsResponse creates a new ConnectionPaths instance
func NewQueryClientConnectionsResponse(
clientID string, connectionPaths []string, proof []byte, height clienttypes.Height,
connectionPaths []string, proof []byte, height clienttypes.Height,
) *QueryClientConnectionsResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.ClientConnectionsPath(clientID), "/"))
return &QueryClientConnectionsResponse{
ConnectionPaths: connectionPaths,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}
@ -45,23 +37,19 @@ func NewQueryClientConnectionsRequest(clientID string) *QueryClientConnectionsRe
// NewQueryConnectionClientStateResponse creates a newQueryConnectionClientStateResponse instance
func NewQueryConnectionClientStateResponse(identifiedClientState clienttypes.IdentifiedClientState, proof []byte, height clienttypes.Height) *QueryConnectionClientStateResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(identifiedClientState.ClientId, host.ClientStatePath()), "/"))
return &QueryConnectionClientStateResponse{
IdentifiedClientState: &identifiedClientState,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}
// NewQueryConnectionConsensusStateResponse creates a newQueryConnectionConsensusStateResponse instance
func NewQueryConnectionConsensusStateResponse(clientID string, anyConsensusState *codectypes.Any, consensusStateHeight exported.Height, proof []byte, height clienttypes.Height) *QueryConnectionConsensusStateResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(clientID, host.ConsensusStatePath(consensusStateHeight)), "/"))
return &QueryConnectionConsensusStateResponse{
ConsensusState: anyConsensusState,
ClientId: clientID,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}

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

@ -87,10 +87,8 @@ type QueryConnectionResponse struct {
Connection *ConnectionEnd `protobuf:"bytes,1,opt,name=connection,proto3" json:"connection,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryConnectionResponse) Reset() { *m = QueryConnectionResponse{} }
@ -140,13 +138,6 @@ func (m *QueryConnectionResponse) GetProof() []byte {
return nil
}
func (m *QueryConnectionResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryConnectionResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -319,10 +310,8 @@ type QueryClientConnectionsResponse struct {
ConnectionPaths []string `protobuf:"bytes,1,rep,name=connection_paths,json=connectionPaths,proto3" json:"connection_paths,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was generated
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryClientConnectionsResponse) Reset() { *m = QueryClientConnectionsResponse{} }
@ -372,13 +361,6 @@ func (m *QueryClientConnectionsResponse) GetProof() []byte {
return nil
}
func (m *QueryClientConnectionsResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryClientConnectionsResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -440,10 +422,8 @@ type QueryConnectionClientStateResponse struct {
IdentifiedClientState *types.IdentifiedClientState `protobuf:"bytes,1,opt,name=identified_client_state,json=identifiedClientState,proto3" json:"identified_client_state,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryConnectionClientStateResponse) Reset() { *m = QueryConnectionClientStateResponse{} }
@ -493,13 +473,6 @@ func (m *QueryConnectionClientStateResponse) GetProof() []byte {
return nil
}
func (m *QueryConnectionClientStateResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryConnectionClientStateResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -579,10 +552,8 @@ type QueryConnectionConsensusStateResponse struct {
ClientId string `protobuf:"bytes,2,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,4,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight types.Height `protobuf:"bytes,5,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryConnectionConsensusStateResponse) Reset() { *m = QueryConnectionConsensusStateResponse{} }
@ -639,13 +610,6 @@ func (m *QueryConnectionConsensusStateResponse) GetProof() []byte {
return nil
}
func (m *QueryConnectionConsensusStateResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryConnectionConsensusStateResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -671,65 +635,63 @@ func init() {
}
var fileDescriptor_cd8d529f8c7cd06b = []byte{
// 921 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0x41, 0x6f, 0x1b, 0x45,
0x14, 0xce, 0x38, 0x49, 0xd5, 0x3c, 0xa7, 0x05, 0x46, 0x69, 0xbb, 0x2c, 0xd4, 0x09, 0x5b, 0x42,
0x53, 0xa0, 0x33, 0x75, 0xa2, 0x56, 0xa5, 0xad, 0x11, 0xb8, 0x2a, 0x34, 0x97, 0xaa, 0x2c, 0xe2,
0xc2, 0x25, 0xda, 0x5d, 0x4f, 0xd6, 0x2b, 0xe2, 0x1d, 0xd7, 0xb3, 0xb6, 0xb0, 0x8a, 0x0f, 0x70,
0xe6, 0x80, 0x84, 0x38, 0xf2, 0x07, 0xb8, 0xf2, 0x0f, 0x90, 0x90, 0x7a, 0xac, 0xc4, 0xa5, 0xe2,
0x50, 0xa1, 0x84, 0x2b, 0x17, 0xee, 0x48, 0x68, 0x67, 0xc6, 0xd9, 0xd9, 0x78, 0xb7, 0x31, 0x16,
0x52, 0x4e, 0xde, 0x79, 0xf3, 0xde, 0xbc, 0xef, 0x7d, 0xef, 0xcd, 0x37, 0x06, 0x27, 0xf2, 0x03,
0x1a, 0xf0, 0x1e, 0xa3, 0x01, 0x8f, 0x63, 0x16, 0x24, 0x11, 0x8f, 0xe9, 0xa0, 0x4e, 0x1f, 0xf5,
0x59, 0x6f, 0x48, 0xba, 0x3d, 0x9e, 0x70, 0x7c, 0x3e, 0xf2, 0x03, 0x92, 0xfa, 0x90, 0xcc, 0x87,
0x0c, 0xea, 0xf6, 0x4a, 0xc8, 0x43, 0x2e, 0x5d, 0x68, 0xfa, 0xa5, 0xbc, 0xed, 0xb7, 0x03, 0x2e,
0x3a, 0x5c, 0x50, 0xdf, 0x13, 0x4c, 0x1d, 0x43, 0x07, 0x75, 0x9f, 0x25, 0x5e, 0x9d, 0x76, 0xbd,
0x30, 0x8a, 0x3d, 0x19, 0xae, 0x7c, 0x57, 0xb3, 0xec, 0x7b, 0x11, 0x8b, 0x93, 0x34, 0xb3, 0xfa,
0xd2, 0x0e, 0x97, 0x4b, 0xe0, 0x19, 0x40, 0x94, 0xe3, 0xeb, 0x21, 0xe7, 0xe1, 0x1e, 0xa3, 0x5e,
0x37, 0xa2, 0x5e, 0x1c, 0xf3, 0x44, 0xa6, 0x11, 0x7a, 0xf7, 0x55, 0xbd, 0x2b, 0x57, 0x7e, 0x7f,
0x97, 0x7a, 0xb1, 0x2e, 0xce, 0x69, 0xc0, 0xf9, 0x4f, 0x52, 0x90, 0x77, 0x0f, 0x4f, 0x74, 0xd9,
0xa3, 0x3e, 0x13, 0x09, 0xbe, 0x04, 0x67, 0xb2, 0x34, 0x3b, 0x51, 0xcb, 0x42, 0x6b, 0x68, 0x63,
0xc9, 0x5d, 0xce, 0x8c, 0xdb, 0x2d, 0xe7, 0x77, 0x04, 0x17, 0x26, 0xe2, 0x45, 0x97, 0xc7, 0x82,
0xe1, 0x7b, 0x00, 0x99, 0xaf, 0x8c, 0xae, 0x6e, 0xae, 0x93, 0x62, 0x32, 0x49, 0x16, 0x7f, 0x2f,
0x6e, 0xb9, 0x46, 0x20, 0x5e, 0x81, 0xc5, 0x6e, 0x8f, 0xf3, 0x5d, 0xab, 0xb2, 0x86, 0x36, 0x96,
0x5d, 0xb5, 0xc0, 0x17, 0x01, 0xe4, 0xc7, 0x4e, 0xd7, 0x4b, 0xda, 0xd6, 0xbc, 0x84, 0xb6, 0x24,
0x2d, 0x0f, 0xbd, 0xa4, 0x8d, 0xef, 0xc2, 0xb2, 0xda, 0x6e, 0xb3, 0x28, 0x6c, 0x27, 0xd6, 0x82,
0xcc, 0x6e, 0x1b, 0xd9, 0x15, 0xcd, 0x83, 0x3a, 0xb9, 0x2f, 0x3d, 0x9a, 0x0b, 0x4f, 0x9e, 0xaf,
0xce, 0xb9, 0x55, 0x19, 0xa5, 0x4c, 0x8e, 0x37, 0x51, 0x9b, 0x18, 0x93, 0xf3, 0x11, 0x40, 0xd6,
0x4d, 0x5d, 0xdb, 0x5b, 0x44, 0xb5, 0x9e, 0xa4, 0xad, 0x27, 0x6a, 0x82, 0x74, 0xeb, 0xc9, 0x43,
0x2f, 0x64, 0x3a, 0xd6, 0x35, 0x22, 0x9d, 0xbf, 0x10, 0x58, 0x93, 0x39, 0x34, 0x81, 0x0f, 0xa0,
0x9a, 0xf1, 0x20, 0x2c, 0xb4, 0x36, 0xbf, 0x51, 0xdd, 0x7c, 0xb7, 0x8c, 0xc1, 0xed, 0x16, 0x8b,
0x93, 0x68, 0x37, 0x62, 0x2d, 0xa3, 0x17, 0xe6, 0x01, 0xf8, 0xe3, 0x1c, 0xe8, 0x8a, 0x04, 0x7d,
0xf9, 0x58, 0xd0, 0x0a, 0x8c, 0x89, 0x1a, 0xdf, 0x84, 0x53, 0x9a, 0xd7, 0xf9, 0x29, 0x79, 0xd5,
0xfe, 0xce, 0x1d, 0xb8, 0xa8, 0xca, 0x95, 0x6e, 0x05, 0xc4, 0xbe, 0x06, 0x4b, 0xea, 0x88, 0x6c,
0xe2, 0x4e, 0x2b, 0xc3, 0x76, 0xcb, 0xf9, 0x15, 0x41, 0xad, 0x2c, 0x5c, 0x73, 0x76, 0x05, 0x5e,
0x36, 0xa6, 0x36, 0x1d, 0x0e, 0x45, 0xdc, 0x92, 0xfb, 0x52, 0x66, 0x4f, 0x47, 0x44, 0x9c, 0xe0,
0x60, 0xf9, 0xf0, 0xc6, 0x91, 0xa6, 0xab, 0x82, 0x3e, 0x4d, 0xbc, 0x64, 0x3c, 0x26, 0xb8, 0x51,
0x78, 0xff, 0x9a, 0xd6, 0xdf, 0xcf, 0x57, 0x57, 0x86, 0x5e, 0x67, 0xef, 0x96, 0x93, 0xdb, 0x76,
0x8e, 0xdc, 0xcc, 0xaf, 0x2b, 0xe0, 0xbc, 0x28, 0x89, 0xe6, 0xcb, 0x83, 0x0b, 0xd1, 0xe1, 0xe0,
0xec, 0x68, 0xea, 0x45, 0xea, 0xa2, 0xa7, 0xfa, 0x4a, 0x51, 0x69, 0xc6, 0xac, 0x19, 0x67, 0x9e,
0x8b, 0x8a, 0xcc, 0x27, 0xc8, 0xf3, 0xcf, 0x08, 0xde, 0x3c, 0xca, 0x41, 0x5a, 0x75, 0x2c, 0xfa,
0xe2, 0x7f, 0xe4, 0x1a, 0xaf, 0xc3, 0xd9, 0x01, 0xeb, 0x89, 0x74, 0x33, 0xee, 0x77, 0x7c, 0xd6,
0x93, 0xa5, 0x2e, 0xb8, 0x67, 0xb4, 0xf5, 0x81, 0x34, 0x9a, 0x6e, 0xc6, 0xf5, 0xc9, 0xdc, 0x34,
0xea, 0x7f, 0x10, 0xac, 0x1f, 0x83, 0x5a, 0x37, 0xaf, 0x01, 0xe9, 0x50, 0xab, 0x9d, 0x5c, 0xd3,
0x56, 0x88, 0x52, 0x7c, 0x32, 0x56, 0x7c, 0xf2, 0x61, 0x3c, 0x74, 0xcf, 0x06, 0xb9, 0x63, 0xf2,
0x77, 0xad, 0x92, 0xbf, 0x6b, 0x59, 0xd7, 0xe6, 0xcb, 0xbb, 0xb6, 0x70, 0x5c, 0xd7, 0x16, 0x67,
0xe8, 0xda, 0xe6, 0xb7, 0xa7, 0x61, 0x51, 0xd6, 0x8f, 0x7f, 0x42, 0x00, 0x19, 0x09, 0x98, 0x94,
0x49, 0x5f, 0xf1, 0x0b, 0x66, 0xd3, 0xa9, 0xfd, 0x15, 0x9f, 0xce, 0xed, 0x6f, 0x7e, 0xfb, 0xf3,
0xfb, 0xca, 0x75, 0xbc, 0x45, 0xd5, 0xbb, 0x6b, 0x3c, 0xb9, 0xea, 0x05, 0x37, 0xd4, 0x94, 0x3e,
0xce, 0x8d, 0xc4, 0x08, 0xff, 0x88, 0xa0, 0x6a, 0x28, 0x12, 0x9e, 0x36, 0xfb, 0x58, 0xfa, 0xec,
0x6b, 0xd3, 0x07, 0x68, 0xbc, 0xef, 0x48, 0xbc, 0xeb, 0xf8, 0xd2, 0x14, 0x78, 0xf1, 0x2f, 0x08,
0x5e, 0x99, 0xd0, 0x4d, 0x7c, 0xfd, 0xc5, 0x49, 0x4b, 0x64, 0xda, 0xbe, 0xf1, 0x5f, 0xc3, 0x34,
0xe2, 0xf7, 0x25, 0xe2, 0x9b, 0xf8, 0x46, 0x29, 0x62, 0x35, 0x90, 0x79, 0xa2, 0xc7, 0x43, 0x3a,
0xc2, 0xcf, 0x10, 0x9c, 0x2b, 0x14, 0x34, 0xfc, 0xde, 0x94, 0xec, 0x4d, 0x2a, 0xad, 0x7d, 0x6b,
0x96, 0x50, 0x5d, 0xd0, 0x7d, 0x59, 0x50, 0x13, 0x7f, 0x30, 0xc3, 0xc8, 0x50, 0x53, 0x6e, 0xf1,
0x0f, 0x15, 0xb0, 0xca, 0x6e, 0x3c, 0xbe, 0x33, 0x2d, 0xc4, 0x22, 0x79, 0xb3, 0x1b, 0x33, 0x46,
0xeb, 0x1a, 0xbf, 0x92, 0x35, 0x0e, 0x70, 0x32, 0x53, 0x8d, 0x79, 0x81, 0xa2, 0x5a, 0xeb, 0xe8,
0xe3, 0xbc, 0x62, 0x8e, 0xa8, 0x92, 0x8c, 0xcc, 0xae, 0xd6, 0xa3, 0xe6, 0x67, 0x4f, 0xf6, 0x6b,
0xe8, 0xe9, 0x7e, 0x0d, 0xfd, 0xb1, 0x5f, 0x43, 0xdf, 0x1d, 0xd4, 0xe6, 0x9e, 0x1e, 0xd4, 0xe6,
0x9e, 0x1d, 0xd4, 0xe6, 0x3e, 0xbf, 0x1d, 0x46, 0x49, 0xbb, 0xef, 0x93, 0x80, 0x77, 0xa8, 0xfe,
0xd7, 0xad, 0x7e, 0xae, 0x8a, 0xd6, 0x17, 0xf4, 0x4b, 0x7a, 0xf8, 0xe7, 0xf9, 0xda, 0xd6, 0x55,
0x03, 0x75, 0x32, 0xec, 0x32, 0xe1, 0x9f, 0x92, 0xd2, 0xb8, 0xf5, 0x6f, 0x00, 0x00, 0x00, 0xff,
0xff, 0xa3, 0x81, 0x7f, 0x88, 0x02, 0x0c, 0x00, 0x00,
// 891 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xc1, 0x4f, 0x2b, 0x45,
0x18, 0xef, 0x14, 0xde, 0xcb, 0x63, 0xca, 0x7b, 0xea, 0xa4, 0x0f, 0xea, 0xaa, 0x05, 0x17, 0x2b,
0xa0, 0x32, 0x43, 0x21, 0x10, 0x04, 0x6a, 0xb4, 0x04, 0x85, 0x0b, 0xc1, 0x35, 0x5e, 0xbc, 0x90,
0xdd, 0xed, 0xb0, 0xdd, 0x48, 0x77, 0x4a, 0x77, 0xdb, 0xd8, 0x60, 0x2f, 0x9e, 0x3d, 0x98, 0x18,
0x8f, 0x5e, 0x3d, 0x78, 0xf5, 0xe8, 0xcd, 0x13, 0x47, 0x12, 0x2f, 0x9c, 0x88, 0x29, 0x5e, 0xbd,
0xf8, 0x17, 0x98, 0x9d, 0x99, 0xb2, 0xb3, 0x74, 0x0b, 0xa5, 0x91, 0x53, 0x77, 0xbf, 0xf9, 0xbe,
0x99, 0xdf, 0xef, 0xf7, 0x7d, 0xf3, 0xdb, 0x42, 0xdd, 0xb5, 0x6c, 0x62, 0xb3, 0x06, 0x25, 0x36,
0xf3, 0x3c, 0x6a, 0x07, 0x2e, 0xf3, 0x48, 0xab, 0x48, 0x4e, 0x9b, 0xb4, 0xd1, 0xc6, 0xf5, 0x06,
0x0b, 0x18, 0x9a, 0x72, 0x2d, 0x1b, 0x87, 0x39, 0x38, 0xca, 0xc1, 0xad, 0xa2, 0x96, 0x75, 0x98,
0xc3, 0x78, 0x0a, 0x09, 0x9f, 0x44, 0xb6, 0xf6, 0x9e, 0xcd, 0xfc, 0x1a, 0xf3, 0x89, 0x65, 0xfa,
0x54, 0x6c, 0x43, 0x5a, 0x45, 0x8b, 0x06, 0x66, 0x91, 0xd4, 0x4d, 0xc7, 0xf5, 0x4c, 0x5e, 0x2e,
0x72, 0x67, 0xa2, 0xd3, 0x4f, 0x5c, 0xea, 0x05, 0xe1, 0xc9, 0xe2, 0x49, 0x26, 0xcc, 0x0f, 0x80,
0xa7, 0x00, 0x11, 0x89, 0x6f, 0x3a, 0x8c, 0x39, 0x27, 0x94, 0x98, 0x75, 0x97, 0x98, 0x9e, 0xc7,
0x02, 0x7e, 0x8c, 0x2f, 0x57, 0x5f, 0x97, 0xab, 0xfc, 0xcd, 0x6a, 0x1e, 0x13, 0xd3, 0x93, 0xe4,
0xf4, 0x12, 0x9c, 0xfa, 0x3c, 0x04, 0xb9, 0x73, 0xb3, 0xa3, 0x41, 0x4f, 0x9b, 0xd4, 0x0f, 0xd0,
0x1c, 0x7c, 0x1e, 0x1d, 0x73, 0xe4, 0x56, 0x72, 0x60, 0x16, 0x2c, 0x4c, 0x18, 0x93, 0x51, 0x70,
0xbf, 0xa2, 0xff, 0x0e, 0xe0, 0x74, 0x5f, 0xbd, 0x5f, 0x67, 0x9e, 0x4f, 0xd1, 0x2e, 0x84, 0x51,
0x2e, 0xaf, 0xce, 0xac, 0x14, 0x70, 0xb2, 0x98, 0x38, 0xaa, 0xdf, 0xf5, 0x2a, 0x86, 0x52, 0x88,
0xb2, 0xf0, 0x49, 0xbd, 0xc1, 0xd8, 0x71, 0x2e, 0x3d, 0x0b, 0x16, 0x26, 0x0d, 0xf1, 0x82, 0x76,
0xe0, 0x24, 0x7f, 0x38, 0xaa, 0x52, 0xd7, 0xa9, 0x06, 0xb9, 0x31, 0xbe, 0xbd, 0xa6, 0x6c, 0x2f,
0x74, 0x6c, 0x15, 0xf1, 0x1e, 0xcf, 0x28, 0x8f, 0x9f, 0x5f, 0xcd, 0xa4, 0x8c, 0x0c, 0xaf, 0x12,
0x21, 0xdd, 0xec, 0x03, 0xef, 0xf7, 0xd8, 0x7f, 0x0a, 0x61, 0xd4, 0x2e, 0x09, 0xfe, 0x5d, 0x2c,
0x7a, 0x8b, 0xc3, 0xde, 0x62, 0x31, 0x22, 0xb2, 0xb7, 0xf8, 0xd0, 0x74, 0xa8, 0xac, 0x35, 0x94,
0x4a, 0xfd, 0x1f, 0x00, 0x73, 0xfd, 0x67, 0x48, 0x85, 0x0e, 0x60, 0x26, 0x22, 0xea, 0xe7, 0xc0,
0xec, 0xd8, 0x42, 0x66, 0xe5, 0x83, 0x41, 0x12, 0xed, 0x57, 0xa8, 0x17, 0xb8, 0xc7, 0x2e, 0xad,
0x28, 0x62, 0xab, 0x1b, 0xa0, 0xcf, 0x62, 0xa0, 0xd3, 0x1c, 0xf4, 0xfc, 0xbd, 0xa0, 0x05, 0x18,
0x15, 0x35, 0xda, 0x80, 0x4f, 0x1f, 0xa8, 0xab, 0xcc, 0xd7, 0xb7, 0xe1, 0x5b, 0x82, 0x2e, 0x4f,
0x4b, 0x10, 0xf6, 0x0d, 0x38, 0x21, 0xb6, 0x88, 0x46, 0xea, 0x99, 0x08, 0xec, 0x57, 0xf4, 0x5f,
0x00, 0xcc, 0x0f, 0x2a, 0x97, 0x9a, 0x2d, 0xc2, 0x57, 0x95, 0xb1, 0xac, 0x9b, 0x41, 0x55, 0x08,
0x37, 0x61, 0xbc, 0x12, 0xc5, 0x0f, 0xc3, 0xf0, 0x63, 0x4e, 0x8e, 0x05, 0xdf, 0xbe, 0xd5, 0x55,
0x81, 0xf8, 0x8b, 0xc0, 0x0c, 0x7a, 0x73, 0x80, 0x4a, 0x89, 0x37, 0xa8, 0x9c, 0xfb, 0xf7, 0x6a,
0x26, 0xdb, 0x36, 0x6b, 0x27, 0x9b, 0x7a, 0x6c, 0x59, 0xbf, 0x75, 0xb7, 0xba, 0x00, 0xea, 0x77,
0x1d, 0x22, 0x05, 0x31, 0xe1, 0xb4, 0x7b, 0x33, 0x19, 0x47, 0x52, 0x5b, 0x3f, 0x4c, 0x91, 0x63,
0xbb, 0x98, 0x44, 0x4d, 0x19, 0x26, 0x65, 0xcf, 0x97, 0x6e, 0x52, 0xf8, 0x31, 0x85, 0xfc, 0x0d,
0xc0, 0x77, 0x6e, 0x93, 0x0c, 0x69, 0x79, 0x7e, 0xd3, 0xff, 0x1f, 0xc5, 0x44, 0x05, 0xf8, 0xa2,
0x45, 0x1b, 0x7e, 0xb8, 0xe8, 0x35, 0x6b, 0x16, 0x6d, 0x70, 0x2e, 0xe3, 0xc6, 0x73, 0x19, 0x3d,
0xe0, 0x41, 0x35, 0x4d, 0x61, 0x15, 0xa5, 0x49, 0xd4, 0x57, 0x00, 0x16, 0xee, 0x41, 0x2d, 0xbb,
0x53, 0x82, 0xe1, 0x58, 0x8a, 0x95, 0x58, 0x57, 0xb2, 0x58, 0x98, 0x32, 0xee, 0x99, 0x32, 0xfe,
0xc4, 0x6b, 0x1b, 0x2f, 0xec, 0xd8, 0x36, 0xf1, 0xdb, 0x92, 0x8e, 0xdf, 0x96, 0xa8, 0x2d, 0x63,
0x77, 0xb5, 0x65, 0x7c, 0x84, 0xb6, 0xac, 0x7c, 0xff, 0x0c, 0x3e, 0xe1, 0x04, 0xd1, 0xaf, 0x00,
0xc2, 0x88, 0x25, 0xc2, 0x83, 0xdc, 0x29, 0xf9, 0x2b, 0xa2, 0x91, 0xa1, 0xf3, 0x85, 0x60, 0xfa,
0xd6, 0x77, 0x7f, 0xfe, 0xfd, 0x63, 0x7a, 0x0d, 0xad, 0x12, 0xf1, 0xed, 0x53, 0x3e, 0x7b, 0xe2,
0x2b, 0xaa, 0x18, 0x1e, 0x39, 0x8b, 0xf5, 0xbc, 0x83, 0x7e, 0x06, 0x30, 0xa3, 0x98, 0x06, 0x1a,
0xf6, 0xf4, 0x9e, 0x3b, 0x69, 0xcb, 0xc3, 0x17, 0x48, 0xbc, 0xef, 0x73, 0xbc, 0x05, 0x34, 0x37,
0x04, 0x5e, 0xf4, 0x07, 0x80, 0xaf, 0xf5, 0x59, 0x1b, 0x5a, 0xbb, 0xfb, 0xd0, 0x01, 0x4e, 0xaa,
0xad, 0x3f, 0xb4, 0x4c, 0x22, 0xfe, 0x88, 0x23, 0xde, 0x40, 0xeb, 0x03, 0x11, 0x8b, 0x89, 0x8b,
0x0b, 0xdd, 0x9b, 0xc2, 0x0e, 0xba, 0x04, 0xf0, 0x65, 0xa2, 0x25, 0xa1, 0x0f, 0x87, 0x54, 0xaf,
0xdf, 0x2b, 0xb5, 0xcd, 0x51, 0x4a, 0x25, 0xa1, 0x3d, 0x4e, 0xa8, 0x8c, 0x3e, 0x1e, 0x61, 0x64,
0x88, 0x6a, 0x98, 0xe8, 0xa7, 0x34, 0xcc, 0x0d, 0xba, 0xd2, 0x68, 0x7b, 0x58, 0x88, 0x49, 0xfe,
0xa5, 0x95, 0x46, 0xac, 0x96, 0x1c, 0xbf, 0xe5, 0x1c, 0x5b, 0x28, 0x18, 0x89, 0x63, 0xdc, 0x81,
0x88, 0x34, 0x33, 0x72, 0x16, 0xb7, 0xc4, 0x0e, 0x11, 0x96, 0x11, 0xc5, 0xc5, 0x7b, 0xa7, 0xfc,
0xe5, 0x79, 0x37, 0x0f, 0x2e, 0xba, 0x79, 0xf0, 0x57, 0x37, 0x0f, 0x7e, 0xb8, 0xce, 0xa7, 0x2e,
0xae, 0xf3, 0xa9, 0xcb, 0xeb, 0x7c, 0xea, 0xab, 0x2d, 0xc7, 0x0d, 0xaa, 0x4d, 0x0b, 0xdb, 0xac,
0x46, 0xe4, 0x3f, 0x5f, 0xf1, 0xb3, 0xe4, 0x57, 0xbe, 0x26, 0xdf, 0x90, 0x9b, 0x3f, 0xb0, 0xcb,
0xab, 0x4b, 0x0a, 0xea, 0xa0, 0x5d, 0xa7, 0xbe, 0xf5, 0x94, 0x7b, 0xdf, 0xea, 0x7f, 0x01, 0x00,
0x00, 0xff, 0xff, 0x3b, 0x66, 0x6e, 0x99, 0x86, 0x0b, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -1031,14 +993,7 @@ func (m *QueryConnectionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -1214,14 +1169,7 @@ func (m *QueryClientConnectionsResponse) MarshalToSizedBuffer(dAtA []byte) (int,
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -1300,14 +1248,7 @@ func (m *QueryConnectionClientStateResponse) MarshalToSizedBuffer(dAtA []byte) (
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -1399,14 +1340,7 @@ func (m *QueryConnectionConsensusStateResponse) MarshalToSizedBuffer(dAtA []byte
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x2a
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x22
}
dAtA[i] = 0x22
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -1474,10 +1408,6 @@ func (m *QueryConnectionResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -1546,10 +1476,6 @@ func (m *QueryClientConnectionsResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -1582,10 +1508,6 @@ func (m *QueryConnectionClientStateResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -1628,10 +1550,6 @@ func (m *QueryConnectionConsensusStateResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -1828,38 +1746,6 @@ func (m *QueryConnectionResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}
@ -2342,38 +2228,6 @@ func (m *QueryClientConnectionsResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}
@ -2615,38 +2469,6 @@ func (m *QueryConnectionClientStateResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}
@ -2958,38 +2780,6 @@ func (m *QueryConnectionConsensusStateResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}

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

@ -51,7 +51,7 @@ func queryPacketCommitmentABCI(
return nil, sdkerrors.Wrapf(types.ErrPacketCommitmentNotFound, "portID (%s), channelID (%s), sequence (%d)", portID, channelID, sequence)
}
return types.NewQueryPacketCommitmentResponse(portID, channelID, sequence, value, proofBz, proofHeight), nil
return types.NewQueryPacketCommitmentResponse(value, proofBz, proofHeight), nil
}
// QueryChannel returns a channel end.
@ -93,7 +93,7 @@ func queryChannelABCI(clientCtx client.Context, portID, channelID string) (*type
return nil, err
}
return types.NewQueryChannelResponse(portID, channelID, channel, proofBz, proofHeight), nil
return types.NewQueryChannelResponse(channel, proofBz, proofHeight), nil
}
// QueryChannelClientState returns the ClientState of a channel end. If
@ -229,5 +229,5 @@ func queryNextSequenceRecvABCI(clientCtx client.Context, portID, channelID strin
sequence := binary.BigEndian.Uint64(value)
return types.NewQueryNextSequenceReceiveResponse(portID, channelID, sequence, proofBz, proofHeight), nil
return types.NewQueryNextSequenceReceiveResponse(sequence, proofBz, proofHeight), nil
}

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

@ -40,7 +40,7 @@ func (q Keeper) Channel(c context.Context, req *types.QueryChannelRequest) (*typ
}
selfHeight := clienttypes.GetSelfHeight(ctx)
return types.NewQueryChannelResponse(req.PortId, req.ChannelId, channel, nil, selfHeight), nil
return types.NewQueryChannelResponse(channel, nil, selfHeight), nil
}
// Channels implements the Query/Channels gRPC method
@ -222,7 +222,7 @@ func (q Keeper) PacketCommitment(c context.Context, req *types.QueryPacketCommit
}
selfHeight := clienttypes.GetSelfHeight(ctx)
return types.NewQueryPacketCommitmentResponse(req.PortId, req.ChannelId, req.Sequence, commitmentBz, nil, selfHeight), nil
return types.NewQueryPacketCommitmentResponse(commitmentBz, nil, selfHeight), nil
}
// PacketCommitments implements the Query/PacketCommitments gRPC method
@ -287,7 +287,7 @@ func (q Keeper) PacketAcknowledgement(c context.Context, req *types.QueryPacketA
}
selfHeight := clienttypes.GetSelfHeight(ctx)
return types.NewQueryPacketAcknowledgementResponse(req.PortId, req.ChannelId, req.Sequence, acknowledgementBz, nil, selfHeight), nil
return types.NewQueryPacketAcknowledgementResponse(acknowledgementBz, nil, selfHeight), nil
}
// UnreceivedPackets implements the Query/UnreceivedPackets gRPC method. Given
@ -411,7 +411,7 @@ func (q Keeper) NextSequenceReceive(c context.Context, req *types.QueryNextSeque
}
selfHeight := clienttypes.GetSelfHeight(ctx)
return types.NewQueryNextSequenceReceiveResponse(req.PortId, req.ChannelId, sequence, nil, selfHeight), nil
return types.NewQueryNextSequenceReceiveResponse(sequence, nil, selfHeight), nil
}
func validategRPCRequest(portID, channelID string) error {

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

@ -1,84 +1,68 @@
package types
import (
"strings"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/types"
commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/core/24-host"
"github.com/cosmos/cosmos-sdk/x/ibc/core/exported"
)
// NewQueryChannelResponse creates a new QueryChannelResponse instance
func NewQueryChannelResponse(portID, channelID string, channel Channel, proof []byte, height clienttypes.Height) *QueryChannelResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.ChannelPath(portID, channelID), "/"))
func NewQueryChannelResponse(channel Channel, proof []byte, height clienttypes.Height) *QueryChannelResponse {
return &QueryChannelResponse{
Channel: &channel,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}
// NewQueryChannelClientStateResponse creates a newQueryChannelClientStateResponse instance
func NewQueryChannelClientStateResponse(identifiedClientState clienttypes.IdentifiedClientState, proof []byte, height clienttypes.Height) *QueryChannelClientStateResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(identifiedClientState.ClientId, host.ClientStatePath()), "/"))
return &QueryChannelClientStateResponse{
IdentifiedClientState: &identifiedClientState,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}
// NewQueryChannelConsensusStateResponse creates a newQueryChannelConsensusStateResponse instance
func NewQueryChannelConsensusStateResponse(clientID string, anyConsensusState *codectypes.Any, consensusStateHeight exported.Height, proof []byte, height clienttypes.Height) *QueryChannelConsensusStateResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(clientID, host.ConsensusStatePath(consensusStateHeight)), "/"))
return &QueryChannelConsensusStateResponse{
ConsensusState: anyConsensusState,
ClientId: clientID,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}
// NewQueryPacketCommitmentResponse creates a new QueryPacketCommitmentResponse instance
func NewQueryPacketCommitmentResponse(
portID, channelID string, sequence uint64, commitment []byte, proof []byte, height clienttypes.Height,
commitment []byte, proof []byte, height clienttypes.Height,
) *QueryPacketCommitmentResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.PacketCommitmentPath(portID, channelID, sequence), "/"))
return &QueryPacketCommitmentResponse{
Commitment: commitment,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}
// NewQueryPacketAcknowledgementResponse creates a new QueryPacketAcknowledgementResponse instance
func NewQueryPacketAcknowledgementResponse(
portID, channelID string, sequence uint64, acknowledgement []byte, proof []byte, height clienttypes.Height,
acknowledgement []byte, proof []byte, height clienttypes.Height,
) *QueryPacketAcknowledgementResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.PacketAcknowledgementPath(portID, channelID, sequence), "/"))
return &QueryPacketAcknowledgementResponse{
Acknowledgement: acknowledgement,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}
// NewQueryNextSequenceReceiveResponse creates a new QueryNextSequenceReceiveResponse instance
func NewQueryNextSequenceReceiveResponse(
portID, channelID string, sequence uint64, proof []byte, height clienttypes.Height,
sequence uint64, proof []byte, height clienttypes.Height,
) *QueryNextSequenceReceiveResponse {
path := commitmenttypes.NewMerklePath(strings.Split(host.NextSequenceRecvPath(portID, channelID), "/"))
return &QueryNextSequenceReceiveResponse{
NextSequenceReceive: sequence,
Proof: proof,
ProofPath: path.Pretty(),
ProofHeight: height,
}
}

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

@ -95,10 +95,8 @@ type QueryChannelResponse struct {
Channel *Channel `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryChannelResponse) Reset() { *m = QueryChannelResponse{} }
@ -148,13 +146,6 @@ func (m *QueryChannelResponse) GetProof() []byte {
return nil
}
func (m *QueryChannelResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryChannelResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -456,10 +447,8 @@ type QueryChannelClientStateResponse struct {
IdentifiedClientState *types.IdentifiedClientState `protobuf:"bytes,1,opt,name=identified_client_state,json=identifiedClientState,proto3" json:"identified_client_state,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryChannelClientStateResponse) Reset() { *m = QueryChannelClientStateResponse{} }
@ -509,13 +498,6 @@ func (m *QueryChannelClientStateResponse) GetProof() []byte {
return nil
}
func (m *QueryChannelClientStateResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryChannelClientStateResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -606,10 +588,8 @@ type QueryChannelConsensusStateResponse struct {
ClientId string `protobuf:"bytes,2,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,4,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight types.Height `protobuf:"bytes,5,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryChannelConsensusStateResponse) Reset() { *m = QueryChannelConsensusStateResponse{} }
@ -666,13 +646,6 @@ func (m *QueryChannelConsensusStateResponse) GetProof() []byte {
return nil
}
func (m *QueryChannelConsensusStateResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryChannelConsensusStateResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -753,10 +726,8 @@ type QueryPacketCommitmentResponse struct {
Commitment []byte `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryPacketCommitmentResponse) Reset() { *m = QueryPacketCommitmentResponse{} }
@ -806,13 +777,6 @@ func (m *QueryPacketCommitmentResponse) GetProof() []byte {
return nil
}
func (m *QueryPacketCommitmentResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryPacketCommitmentResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -1022,10 +986,8 @@ type QueryPacketAcknowledgementResponse struct {
Acknowledgement []byte `protobuf:"bytes,1,opt,name=acknowledgement,proto3" json:"acknowledgement,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryPacketAcknowledgementResponse) Reset() { *m = QueryPacketAcknowledgementResponse{} }
@ -1075,13 +1037,6 @@ func (m *QueryPacketAcknowledgementResponse) GetProof() []byte {
return nil
}
func (m *QueryPacketAcknowledgementResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryPacketAcknowledgementResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -1394,10 +1349,8 @@ type QueryNextSequenceReceiveResponse struct {
NextSequenceReceive uint64 `protobuf:"varint,1,opt,name=next_sequence_receive,json=nextSequenceReceive,proto3" json:"next_sequence_receive,omitempty"`
// merkle proof of existence
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
// merkle proof path
ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"`
// height at which the proof was retrieved
ProofHeight types.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
ProofHeight types.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
}
func (m *QueryNextSequenceReceiveResponse) Reset() { *m = QueryNextSequenceReceiveResponse{} }
@ -1447,13 +1400,6 @@ func (m *QueryNextSequenceReceiveResponse) GetProof() []byte {
return nil
}
func (m *QueryNextSequenceReceiveResponse) GetProofPath() string {
if m != nil {
return m.ProofPath
}
return ""
}
func (m *QueryNextSequenceReceiveResponse) GetProofHeight() types.Height {
if m != nil {
return m.ProofHeight
@ -1489,94 +1435,92 @@ func init() {
func init() { proto.RegisterFile("ibc/core/channel/v1/query.proto", fileDescriptor_1034a1e9abc4cca1) }
var fileDescriptor_1034a1e9abc4cca1 = []byte{
// 1377 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x59, 0xcf, 0x6f, 0x1b, 0x45,
0x14, 0xce, 0xd8, 0x6e, 0x9b, 0xbc, 0xfe, 0xa2, 0x93, 0x44, 0x4d, 0xb7, 0xa9, 0x93, 0xae, 0x54,
0x48, 0x2b, 0x75, 0x07, 0x27, 0x25, 0x44, 0x08, 0x2a, 0x25, 0x91, 0x68, 0x53, 0xa9, 0x6d, 0xba,
0x51, 0xa5, 0xb6, 0x07, 0xcc, 0x7a, 0x3d, 0xb1, 0x57, 0x89, 0x77, 0x5d, 0xef, 0xda, 0x4d, 0x08,
0x46, 0xa8, 0x48, 0xd0, 0x13, 0x42, 0xea, 0x81, 0x23, 0x12, 0x37, 0xfe, 0x04, 0x4e, 0x5c, 0x73,
0x23, 0x52, 0x39, 0x20, 0x21, 0x55, 0x28, 0xe1, 0xc0, 0x8d, 0x13, 0x17, 0x0e, 0x08, 0xed, 0xcc,
0xec, 0x7a, 0xd7, 0xde, 0xdd, 0xc4, 0x71, 0x4a, 0x10, 0xa7, 0x7a, 0xdf, 0xbc, 0xf7, 0xe6, 0xfb,
0xbe, 0xf7, 0x76, 0xf6, 0x4d, 0x03, 0x63, 0x46, 0x41, 0x27, 0xba, 0x55, 0xa3, 0x44, 0x2f, 0x6b,
0xa6, 0x49, 0x57, 0x49, 0x23, 0x47, 0x1e, 0xd7, 0x69, 0x6d, 0x5d, 0xa9, 0xd6, 0x2c, 0xc7, 0xc2,
0x83, 0x46, 0x41, 0x57, 0x5c, 0x07, 0x45, 0x38, 0x28, 0x8d, 0x9c, 0x14, 0x88, 0x5a, 0x35, 0xa8,
0xe9, 0xb8, 0x41, 0xfc, 0x17, 0x8f, 0x92, 0xae, 0xe8, 0x96, 0x5d, 0xb1, 0x6c, 0x52, 0xd0, 0x6c,
0xca, 0xd3, 0x91, 0x46, 0xae, 0x40, 0x1d, 0x2d, 0x47, 0xaa, 0x5a, 0xc9, 0x30, 0x35, 0xc7, 0xb0,
0x4c, 0xe1, 0x7b, 0x31, 0x0a, 0x82, 0xb7, 0x19, 0x77, 0x19, 0x2d, 0x59, 0x56, 0x69, 0x95, 0x12,
0xad, 0x6a, 0x10, 0xcd, 0x34, 0x2d, 0x87, 0xc5, 0xdb, 0x62, 0xf5, 0x9c, 0x58, 0x65, 0x4f, 0x85,
0xfa, 0x32, 0xd1, 0x4c, 0x81, 0x5e, 0x1a, 0x2a, 0x59, 0x25, 0x8b, 0xfd, 0x24, 0xee, 0x2f, 0x6e,
0x95, 0x6f, 0xc3, 0xe0, 0x3d, 0x17, 0xd3, 0x3c, 0xdf, 0x44, 0xa5, 0x8f, 0xeb, 0xd4, 0x76, 0xf0,
0x59, 0x38, 0x56, 0xb5, 0x6a, 0x4e, 0xde, 0x28, 0x8e, 0xa0, 0x71, 0x34, 0x31, 0xa0, 0x1e, 0x75,
0x1f, 0x17, 0x8a, 0xf8, 0x02, 0x80, 0xc0, 0xe3, 0xae, 0xa5, 0xd8, 0xda, 0x80, 0xb0, 0x2c, 0x14,
0xe5, 0x4d, 0x04, 0x43, 0xe1, 0x7c, 0x76, 0xd5, 0x32, 0x6d, 0x8a, 0xa7, 0xe1, 0x98, 0xf0, 0x62,
0x09, 0x8f, 0x4f, 0x8e, 0x2a, 0x11, 0x6a, 0x2a, 0x5e, 0x98, 0xe7, 0x8c, 0x87, 0xe0, 0x48, 0xb5,
0x66, 0x59, 0xcb, 0x6c, 0xab, 0x13, 0x2a, 0x7f, 0x70, 0x51, 0xb0, 0x1f, 0xf9, 0xaa, 0xe6, 0x94,
0x47, 0xd2, 0x1c, 0x05, 0xb3, 0x2c, 0x6a, 0x4e, 0x19, 0xcf, 0xc3, 0x09, 0xbe, 0x5c, 0xa6, 0x46,
0xa9, 0xec, 0x8c, 0x64, 0xd8, 0x8e, 0x52, 0x60, 0x47, 0x5e, 0xa0, 0x46, 0x4e, 0xb9, 0xc9, 0x3c,
0xe6, 0x32, 0x9b, 0x2f, 0xc7, 0xfa, 0xd4, 0xe3, 0x2c, 0x8a, 0x9b, 0xe4, 0x0f, 0xc2, 0x4c, 0x6c,
0x4f, 0x9a, 0xf7, 0x01, 0x5a, 0x75, 0x13, 0x64, 0x5e, 0x57, 0x78, 0x91, 0x15, 0xb7, 0xc8, 0x0a,
0xef, 0x19, 0x51, 0x64, 0x65, 0x51, 0x2b, 0x51, 0x11, 0xab, 0x06, 0x22, 0xe5, 0x97, 0x08, 0x86,
0xdb, 0x36, 0x10, 0x5a, 0xcd, 0x41, 0xbf, 0xa0, 0x6f, 0x8f, 0xa0, 0xf1, 0x34, 0xcb, 0x1f, 0x25,
0xd6, 0x42, 0x91, 0x9a, 0x8e, 0xb1, 0x6c, 0xd0, 0xa2, 0x27, 0x9b, 0x1f, 0x87, 0x6f, 0x84, 0x50,
0xa6, 0x18, 0xca, 0x37, 0x76, 0x45, 0xc9, 0x01, 0x04, 0x61, 0xe2, 0x19, 0x38, 0x2a, 0x54, 0x4c,
0xef, 0x51, 0x45, 0xe1, 0x2f, 0x3f, 0x43, 0x90, 0xe5, 0x04, 0x2d, 0xd3, 0xa4, 0xba, 0x9b, 0xad,
0x5d, 0xcb, 0x2c, 0x80, 0xee, 0x2f, 0x8a, 0x4e, 0x0b, 0x58, 0xda, 0xb4, 0x4e, 0xed, 0x5b, 0xeb,
0xdf, 0x11, 0x8c, 0xc5, 0x42, 0xf9, 0x7f, 0xa9, 0xfe, 0xc0, 0x13, 0x9d, 0x63, 0x9a, 0x67, 0xde,
0x4b, 0x8e, 0xe6, 0xd0, 0x5e, 0xdf, 0xed, 0xbf, 0x7d, 0x11, 0x23, 0x52, 0x0b, 0x11, 0x35, 0x38,
0x6b, 0xf8, 0xfa, 0xe4, 0x39, 0xd4, 0xbc, 0xed, 0xba, 0x88, 0x37, 0xe5, 0x72, 0x14, 0x91, 0x80,
0xa4, 0x81, 0x9c, 0xc3, 0x46, 0x94, 0xf9, 0x10, 0x4f, 0x84, 0xef, 0x10, 0x5c, 0x0c, 0x09, 0xe0,
0x52, 0x36, 0xed, 0xba, 0x7d, 0x10, 0xf2, 0xe2, 0x4b, 0x70, 0xaa, 0x41, 0x6b, 0xb6, 0x61, 0x99,
0x79, 0xb3, 0x5e, 0x29, 0xd0, 0x1a, 0x63, 0x91, 0x51, 0x4f, 0x0a, 0xeb, 0x1d, 0x66, 0x0c, 0xba,
0x05, 0xb8, 0xb4, 0xdc, 0x04, 0xd6, 0xbf, 0x10, 0xc8, 0x49, 0x58, 0x45, 0xbd, 0xde, 0x83, 0xd3,
0xba, 0xb7, 0x12, 0xaa, 0xd3, 0x90, 0xc2, 0xbf, 0x24, 0x8a, 0xf7, 0x25, 0x51, 0x66, 0xcd, 0x75,
0xf5, 0x94, 0x1e, 0x4a, 0x83, 0xcf, 0xc3, 0x80, 0xa8, 0xb1, 0xcf, 0xa8, 0x9f, 0x1b, 0x16, 0x8a,
0xad, 0x42, 0xa5, 0xe3, 0x0b, 0x95, 0xd9, 0xad, 0x50, 0x47, 0xf6, 0x53, 0xa8, 0x1a, 0x8c, 0x32,
0xee, 0x8b, 0x9a, 0xbe, 0x42, 0x9d, 0x79, 0xab, 0x52, 0x31, 0x9c, 0x0a, 0x35, 0x9d, 0x5e, 0x4b,
0x24, 0x41, 0xbf, 0xed, 0xa6, 0x30, 0x75, 0x2a, 0x8a, 0xe3, 0x3f, 0xcb, 0xdf, 0x23, 0xb8, 0x10,
0xb3, 0xa9, 0xd0, 0x9a, 0x1d, 0x76, 0x9e, 0x95, 0x6d, 0x7c, 0x42, 0x0d, 0x58, 0x0e, 0xb1, 0xb1,
0xbf, 0x89, 0xc3, 0x6e, 0xf7, 0xaa, 0x58, 0xf8, 0x00, 0x4f, 0xef, 0xfb, 0x00, 0xff, 0xc3, 0xfb,
0x96, 0x44, 0x20, 0x14, 0xf2, 0xde, 0x82, 0xe3, 0x2d, 0x31, 0xbd, 0x23, 0x7c, 0x22, 0xf2, 0x08,
0xe7, 0x49, 0x66, 0xf5, 0x95, 0x40, 0x95, 0x82, 0xc1, 0xff, 0x85, 0x73, 0xfc, 0x89, 0x38, 0x6b,
0x7c, 0xac, 0xa6, 0xf5, 0x64, 0x95, 0x16, 0x4b, 0xf4, 0x55, 0x37, 0xf2, 0xa6, 0x77, 0x72, 0xc4,
0xec, 0x2c, 0xe4, 0x9e, 0x80, 0xd3, 0x5a, 0x78, 0x49, 0xb4, 0x74, 0xbb, 0xf9, 0x10, 0xfb, 0xfa,
0x6b, 0xaf, 0xaf, 0xef, 0x9b, 0x35, 0xaa, 0x53, 0xa3, 0x41, 0x8b, 0x9c, 0x54, 0xcf, 0x7d, 0x7d,
0x1d, 0xce, 0x57, 0x59, 0xa6, 0x7c, 0xab, 0x6d, 0xf2, 0x9e, 0x84, 0xf6, 0x48, 0x7a, 0x3c, 0x3d,
0x91, 0x51, 0xcf, 0x55, 0xdb, 0x9a, 0x75, 0xc9, 0x73, 0x90, 0xd7, 0x44, 0x3b, 0x47, 0x00, 0x13,
0xfa, 0x8e, 0xc2, 0x40, 0x2b, 0x1f, 0x62, 0xf9, 0x5a, 0x86, 0x40, 0x5f, 0xa5, 0xba, 0xec, 0xab,
0xe7, 0x08, 0xce, 0xf9, 0x5b, 0xaf, 0x6a, 0xeb, 0xb4, 0x38, 0xab, 0xaf, 0x1c, 0xba, 0x1e, 0x0e,
0x48, 0x51, 0xa0, 0x5e, 0xb1, 0x16, 0x0f, 0xc5, 0x40, 0x73, 0x87, 0xae, 0xf9, 0x58, 0x54, 0x5e,
0x8f, 0x5e, 0x87, 0xa5, 0x2d, 0x04, 0xe3, 0xf1, 0xb9, 0x05, 0xaf, 0x49, 0x18, 0x36, 0xe9, 0x5a,
0x4b, 0xa8, 0xbc, 0x68, 0x06, 0xb6, 0x55, 0x46, 0x1d, 0x34, 0x3b, 0x63, 0x0f, 0xef, 0x6d, 0x9a,
0xfc, 0x11, 0xc3, 0x11, 0x46, 0x09, 0x7f, 0x8b, 0xe0, 0x98, 0x98, 0x2b, 0x70, 0xf4, 0x09, 0x1b,
0x71, 0xa7, 0x94, 0x2e, 0xef, 0xc1, 0x93, 0x0b, 0x23, 0xcf, 0x3d, 0x7d, 0xf1, 0xdb, 0xf3, 0xd4,
0xbb, 0xf8, 0x1d, 0xc2, 0x2e, 0xc4, 0xfe, 0x5d, 0x98, 0x5f, 0x9b, 0xbd, 0x71, 0x9b, 0x6c, 0xb4,
0x2a, 0xd0, 0x24, 0x6e, 0x5d, 0x6c, 0xb2, 0x21, 0xaa, 0xd5, 0xc4, 0xcf, 0x10, 0xf4, 0x7b, 0x43,
0x3e, 0xde, 0x7d, 0x6f, 0xef, 0x15, 0x90, 0xae, 0xec, 0xc5, 0x55, 0xe0, 0xbc, 0xc4, 0x70, 0x8e,
0xe1, 0x0b, 0x89, 0x38, 0xf1, 0x0f, 0x08, 0x70, 0xe7, 0xcd, 0x03, 0x4f, 0x25, 0xec, 0x14, 0x77,
0x65, 0x92, 0xae, 0x75, 0x17, 0x24, 0x80, 0x5e, 0x67, 0x40, 0x67, 0xf0, 0x74, 0x34, 0x50, 0x3f,
0xd0, 0xd5, 0xd4, 0x7f, 0x68, 0xb6, 0x18, 0x6c, 0xb9, 0x0c, 0x3a, 0xc6, 0xfe, 0x44, 0x06, 0x71,
0xf7, 0x8f, 0x44, 0x06, 0xb1, 0x37, 0x0b, 0xf9, 0x2e, 0x63, 0xb0, 0x80, 0x6f, 0xec, 0xbf, 0x25,
0x48, 0xf0, 0x3e, 0x82, 0xbf, 0x4c, 0xc1, 0x70, 0xe4, 0x70, 0x8c, 0xa7, 0x77, 0x07, 0x18, 0x35,
0xf9, 0x4b, 0x6f, 0x77, 0x1d, 0x27, 0xb8, 0x7d, 0x86, 0x18, 0xb9, 0x26, 0xde, 0xe8, 0x85, 0x5c,
0x78, 0x8e, 0x27, 0xe2, 0x3e, 0x40, 0x36, 0xc2, 0xb7, 0x8a, 0x26, 0xe1, 0x67, 0x40, 0xcb, 0xce,
0x9f, 0x9b, 0xf8, 0x17, 0x04, 0xaf, 0xb5, 0x8f, 0x57, 0x38, 0x17, 0xcf, 0x29, 0x66, 0xba, 0x96,
0x26, 0xbb, 0x09, 0x11, 0x0a, 0x7c, 0xc8, 0x04, 0x78, 0x84, 0x1f, 0xf4, 0x20, 0x40, 0xc7, 0x07,
0xc8, 0x26, 0x1b, 0xde, 0xc9, 0xda, 0xc4, 0x2f, 0x10, 0x9c, 0xe9, 0x18, 0x1e, 0x71, 0x17, 0x58,
0xfd, 0x37, 0x70, 0xaa, 0xab, 0x18, 0x41, 0xf0, 0x3e, 0x23, 0x78, 0x17, 0xdf, 0x3e, 0x50, 0x82,
0x78, 0x07, 0xc1, 0x70, 0xe4, 0x9c, 0x96, 0xd4, 0xc4, 0x49, 0x23, 0x65, 0x52, 0x13, 0x27, 0x0e,
0x84, 0xf2, 0x43, 0xc6, 0x70, 0x09, 0xdf, 0xeb, 0x9d, 0xa1, 0xa6, 0xaf, 0x84, 0x6a, 0xf7, 0x79,
0x0a, 0xce, 0x74, 0x4c, 0x4a, 0x49, 0xb5, 0x8b, 0x9b, 0xf7, 0x92, 0x6a, 0x17, 0x3b, 0x8a, 0xc9,
0x5f, 0xf0, 0xd7, 0xf3, 0x53, 0x84, 0x3f, 0x39, 0xe0, 0xf6, 0x4c, 0x98, 0x99, 0x9a, 0xa4, 0xee,
0x03, 0xca, 0x57, 0x05, 0xe5, 0x3f, 0x11, 0x9c, 0x0c, 0x8d, 0x48, 0x58, 0x49, 0x26, 0xd4, 0x3e,
0xe0, 0x49, 0x64, 0xcf, 0xfe, 0x82, 0xfc, 0x53, 0x4e, 0xfe, 0x63, 0xfc, 0xd1, 0xbf, 0xcd, 0x9d,
0x61, 0x61, 0xbd, 0x80, 0x7f, 0x42, 0x30, 0x18, 0x31, 0x48, 0xe1, 0x84, 0x4f, 0x49, 0xfc, 0x4c,
0x27, 0xbd, 0xd5, 0x65, 0x94, 0x50, 0x62, 0x91, 0x09, 0x71, 0x0b, 0xdf, 0xec, 0x41, 0x88, 0xd0,
0xb8, 0x37, 0xa7, 0x6e, 0x6e, 0x67, 0xd1, 0xd6, 0x76, 0x16, 0xfd, 0xba, 0x9d, 0x45, 0x5f, 0xed,
0x64, 0xfb, 0xb6, 0x76, 0xb2, 0x7d, 0x3f, 0xef, 0x64, 0xfb, 0x1e, 0xcd, 0x94, 0x0c, 0xa7, 0x5c,
0x2f, 0x28, 0xba, 0x55, 0x21, 0xe2, 0xef, 0x07, 0xfc, 0x9f, 0xab, 0x76, 0x71, 0x85, 0xac, 0x11,
0xff, 0xef, 0x04, 0x6f, 0x5e, 0xbb, 0xea, 0x21, 0x71, 0xd6, 0xab, 0xd4, 0x2e, 0x1c, 0x65, 0xff,
0x61, 0x33, 0xf5, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x51, 0xd1, 0xa1, 0x4e, 0xce, 0x18, 0x00,
0x00,
// 1353 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcf, 0x6f, 0xdc, 0xc4,
0x17, 0xcf, 0xec, 0x6e, 0xdb, 0xe4, 0xf5, 0xd7, 0xb7, 0x93, 0x44, 0x4d, 0xdd, 0x74, 0x93, 0x5a,
0xea, 0x97, 0xb4, 0x52, 0x3d, 0x6c, 0x52, 0x42, 0x84, 0xa0, 0x52, 0x12, 0x89, 0x36, 0x95, 0xda,
0xa6, 0x8e, 0x2a, 0xb5, 0x3d, 0xb0, 0x78, 0xbd, 0x93, 0x8d, 0x95, 0xac, 0xbd, 0x5d, 0x7b, 0xb7,
0x09, 0x61, 0x11, 0x2a, 0x12, 0xf4, 0x84, 0x90, 0x7a, 0x40, 0xe2, 0x82, 0xc4, 0x2d, 0x47, 0xfe,
0x02, 0xae, 0xbd, 0x11, 0xa9, 0x1c, 0x90, 0x2a, 0x15, 0x94, 0x70, 0xe0, 0xc6, 0x89, 0x3b, 0xf2,
0xcc, 0xd8, 0x6b, 0xef, 0xda, 0x4e, 0x36, 0x9b, 0x05, 0xc4, 0x29, 0xeb, 0xf1, 0x7b, 0x6f, 0x3e,
0x9f, 0xcf, 0x7b, 0x1e, 0x7f, 0x1c, 0x18, 0x33, 0x0a, 0x3a, 0xd1, 0xad, 0x2a, 0x25, 0xfa, 0x8a,
0x66, 0x9a, 0x74, 0x8d, 0xd4, 0x73, 0xe4, 0x71, 0x8d, 0x56, 0x37, 0x94, 0x4a, 0xd5, 0x72, 0x2c,
0x3c, 0x68, 0x14, 0x74, 0xc5, 0x0d, 0x50, 0x44, 0x80, 0x52, 0xcf, 0x49, 0x81, 0xac, 0x35, 0x83,
0x9a, 0x8e, 0x9b, 0xc4, 0x7f, 0xf1, 0x2c, 0xe9, 0x8a, 0x6e, 0xd9, 0x65, 0xcb, 0x26, 0x05, 0xcd,
0xa6, 0xbc, 0x1c, 0xa9, 0xe7, 0x0a, 0xd4, 0xd1, 0x72, 0xa4, 0xa2, 0x95, 0x0c, 0x53, 0x73, 0x0c,
0xcb, 0x14, 0xb1, 0x17, 0xa3, 0x20, 0x78, 0x9b, 0xf1, 0x90, 0xd1, 0x92, 0x65, 0x95, 0xd6, 0x28,
0xd1, 0x2a, 0x06, 0xd1, 0x4c, 0xd3, 0x72, 0x58, 0xbe, 0x2d, 0xee, 0x9e, 0x13, 0x77, 0xd9, 0x55,
0xa1, 0xb6, 0x4c, 0x34, 0x53, 0xa0, 0x97, 0x86, 0x4a, 0x56, 0xc9, 0x62, 0x3f, 0x89, 0xfb, 0x8b,
0xaf, 0xca, 0xb7, 0x61, 0xf0, 0x9e, 0x8b, 0x69, 0x9e, 0x6f, 0xa2, 0xd2, 0xc7, 0x35, 0x6a, 0x3b,
0xf8, 0x2c, 0x1c, 0xab, 0x58, 0x55, 0x27, 0x6f, 0x14, 0x47, 0xd0, 0x38, 0x9a, 0x18, 0x50, 0x8f,
0xba, 0x97, 0x0b, 0x45, 0x7c, 0x01, 0x40, 0xe0, 0x71, 0xef, 0xa5, 0xd8, 0xbd, 0x01, 0xb1, 0xb2,
0x50, 0x94, 0xb7, 0x10, 0x0c, 0x85, 0xeb, 0xd9, 0x15, 0xcb, 0xb4, 0x29, 0x9e, 0x86, 0x63, 0x22,
0x8a, 0x15, 0x3c, 0x3e, 0x39, 0xaa, 0x44, 0xa8, 0xa9, 0x78, 0x69, 0x5e, 0x30, 0x1e, 0x82, 0x23,
0x95, 0xaa, 0x65, 0x2d, 0xb3, 0xad, 0x4e, 0xa8, 0xfc, 0x02, 0xcf, 0xc3, 0x09, 0xf6, 0x23, 0xbf,
0x42, 0x8d, 0xd2, 0x8a, 0x33, 0x92, 0x66, 0x25, 0xa5, 0x40, 0x49, 0xde, 0x81, 0x7a, 0x4e, 0xb9,
0xc9, 0x22, 0xe6, 0x32, 0x2f, 0x5e, 0x8f, 0xf5, 0xa9, 0xc7, 0x59, 0x16, 0x5f, 0x92, 0x3f, 0x08,
0x43, 0xb5, 0x3d, 0xee, 0xef, 0x03, 0x34, 0x1b, 0x23, 0xd0, 0xfe, 0x5f, 0xe1, 0x5d, 0x54, 0xdc,
0x2e, 0x2a, 0x7c, 0x28, 0x44, 0x17, 0x95, 0x45, 0xad, 0x44, 0x45, 0xae, 0x1a, 0xc8, 0x94, 0x5f,
0x23, 0x18, 0x6e, 0xd9, 0x40, 0x88, 0x31, 0x07, 0xfd, 0x82, 0x9f, 0x3d, 0x82, 0xc6, 0xd3, 0xac,
0x7e, 0x94, 0x1a, 0x0b, 0x45, 0x6a, 0x3a, 0xc6, 0xb2, 0x41, 0x8b, 0x9e, 0x2e, 0x7e, 0x1e, 0xbe,
0x11, 0x42, 0x99, 0x62, 0x28, 0xdf, 0xd8, 0x13, 0x25, 0x07, 0x10, 0x84, 0x89, 0x67, 0xe0, 0x68,
0x87, 0x2a, 0x8a, 0x78, 0xf9, 0x19, 0x82, 0x2c, 0x27, 0x68, 0x99, 0x26, 0xd5, 0xdd, 0x6a, 0xad,
0x5a, 0x66, 0x01, 0x74, 0xff, 0xa6, 0x18, 0xa5, 0xc0, 0x4a, 0x8b, 0xd6, 0xa9, 0x03, 0x6b, 0xfd,
0x3b, 0x82, 0xb1, 0x58, 0x28, 0xff, 0x2d, 0xd5, 0x1f, 0x78, 0xa2, 0x73, 0x4c, 0xf3, 0x2c, 0x7a,
0xc9, 0xd1, 0x1c, 0xda, 0xed, 0xc3, 0xfb, 0x8b, 0x2f, 0x62, 0x44, 0x69, 0x21, 0xa2, 0x06, 0x67,
0x0d, 0x5f, 0x9f, 0x3c, 0x87, 0x9a, 0xb7, 0xdd, 0x10, 0xf1, 0xa4, 0x5c, 0x8e, 0x22, 0x12, 0x90,
0x34, 0x50, 0x73, 0xd8, 0x88, 0x5a, 0xee, 0xe5, 0x23, 0xbf, 0x85, 0xe0, 0x62, 0x88, 0xa1, 0xcb,
0xc9, 0xb4, 0x6b, 0xf6, 0x61, 0xe8, 0x87, 0x2f, 0xc1, 0xa9, 0x3a, 0xad, 0xda, 0x86, 0x65, 0xe6,
0xcd, 0x5a, 0xb9, 0x40, 0xab, 0x0c, 0x64, 0x46, 0x3d, 0x29, 0x56, 0xef, 0xb0, 0xc5, 0x60, 0x98,
0xe0, 0x92, 0x09, 0x85, 0x09, 0xac, 0xaf, 0x10, 0xc8, 0x49, 0x58, 0x45, 0x43, 0xde, 0x83, 0xd3,
0xba, 0x77, 0x27, 0xd4, 0x88, 0x21, 0x85, 0xbf, 0x0b, 0x14, 0xef, 0x5d, 0xa0, 0xcc, 0x9a, 0x1b,
0xea, 0x29, 0x3d, 0x54, 0x06, 0x9f, 0x87, 0x01, 0xd1, 0x44, 0x9f, 0x51, 0x3f, 0x5f, 0x58, 0x28,
0x36, 0x3b, 0x91, 0x4e, 0xea, 0x44, 0xe6, 0x20, 0x9d, 0xa8, 0xc2, 0x28, 0x23, 0xb7, 0xa8, 0xe9,
0xab, 0xd4, 0x99, 0xb7, 0xca, 0x65, 0xc3, 0x29, 0x53, 0xd3, 0xe9, 0xb6, 0x07, 0x12, 0xf4, 0xdb,
0x6e, 0x09, 0x53, 0xa7, 0x42, 0x7d, 0xff, 0x5a, 0xfe, 0x06, 0xc1, 0x85, 0x98, 0x4d, 0x85, 0x98,
0xec, 0xb8, 0xf2, 0x56, 0xd9, 0xc6, 0x27, 0xd4, 0xc0, 0x4a, 0x2f, 0x47, 0xf3, 0xdb, 0x38, 0x70,
0x76, 0xb7, 0x92, 0x84, 0xcf, 0xd8, 0xf4, 0x81, 0xcf, 0xd8, 0x3f, 0xbc, 0xe3, 0x3e, 0x02, 0xa1,
0xd0, 0xef, 0x16, 0x1c, 0x6f, 0xaa, 0xe5, 0x9d, 0xb2, 0x13, 0x91, 0xa7, 0x2c, 0x2f, 0x32, 0xab,
0xaf, 0x06, 0xda, 0x10, 0x4c, 0xfe, 0x37, 0x1c, 0xb5, 0x4f, 0xc4, 0x69, 0xe1, 0x63, 0x35, 0xad,
0x27, 0x6b, 0xb4, 0x58, 0xa2, 0xbd, 0x9e, 0xd4, 0x2d, 0xef, 0xd9, 0x8f, 0xd9, 0x59, 0xc8, 0x3d,
0x01, 0xa7, 0xb5, 0xf0, 0x2d, 0x31, 0xb3, 0xad, 0xcb, 0xbd, 0x1c, 0xdc, 0xaf, 0xbd, 0xc1, 0xbd,
0x6f, 0x56, 0xa9, 0x4e, 0x8d, 0x3a, 0x2d, 0x72, 0xd4, 0x5d, 0x0f, 0xee, 0x75, 0x38, 0x5f, 0x61,
0x95, 0xf2, 0xcd, 0xb9, 0xc8, 0x7b, 0x1a, 0xd9, 0x23, 0xe9, 0xf1, 0xf4, 0x44, 0x46, 0x3d, 0x57,
0x69, 0x99, 0xc6, 0x25, 0x2f, 0x40, 0x5e, 0x17, 0xf3, 0x1a, 0x01, 0x4c, 0x08, 0x38, 0x0a, 0x03,
0xcd, 0x7a, 0x88, 0xd5, 0x6b, 0x2e, 0x04, 0x06, 0x27, 0xd5, 0xe1, 0xe0, 0x3c, 0x47, 0x70, 0xce,
0xdf, 0x7a, 0x4d, 0xdb, 0xa0, 0xc5, 0x59, 0x7d, 0xf5, 0x1f, 0xd7, 0xc3, 0x01, 0x29, 0x0a, 0x54,
0x8f, 0xb5, 0x78, 0x28, 0x4c, 0xc5, 0x1d, 0xba, 0xee, 0x63, 0x51, 0x79, 0x3f, 0xba, 0x35, 0x2c,
0xdf, 0x23, 0x18, 0x8f, 0xaf, 0x2d, 0x78, 0x4d, 0xc2, 0xb0, 0x49, 0xd7, 0x9b, 0x42, 0xe5, 0xc5,
0x30, 0xb0, 0xad, 0x32, 0xea, 0xa0, 0xd9, 0x9e, 0xdb, 0xc3, 0xc7, 0x65, 0xf2, 0x47, 0x0c, 0x47,
0x18, 0x66, 0xfc, 0x1d, 0x82, 0x63, 0xe2, 0xdd, 0x8e, 0xa3, 0xcf, 0xc8, 0x88, 0x2f, 0x33, 0xe9,
0xf2, 0x3e, 0x22, 0x39, 0x73, 0x79, 0xee, 0xe9, 0xcb, 0xdf, 0x9e, 0xa7, 0xde, 0xc5, 0xef, 0x10,
0xf6, 0x59, 0xe9, 0x7f, 0x51, 0xf2, 0x8f, 0x4f, 0xcf, 0xd3, 0x92, 0xcd, 0xa6, 0xc4, 0x0d, 0xe2,
0x0a, 0x6f, 0x93, 0x4d, 0xd1, 0x8e, 0x06, 0x7e, 0x86, 0xa0, 0xdf, 0x73, 0xd2, 0x78, 0xef, 0xbd,
0xbd, 0x19, 0x97, 0xae, 0xec, 0x27, 0x54, 0xe0, 0xbc, 0xc4, 0x70, 0x8e, 0xe1, 0x0b, 0x89, 0x38,
0xf1, 0x0f, 0x08, 0x70, 0xbb, 0xbd, 0xc7, 0x53, 0x09, 0x3b, 0xc5, 0x7d, 0x97, 0x48, 0xd7, 0x3a,
0x4b, 0x12, 0x40, 0xaf, 0x33, 0xa0, 0x33, 0x78, 0x3a, 0x1a, 0xa8, 0x9f, 0xe8, 0x6a, 0xea, 0x5f,
0x34, 0x9a, 0x0c, 0xb6, 0x5d, 0x06, 0x6d, 0xde, 0x3a, 0x91, 0x41, 0x9c, 0xc9, 0x4f, 0x64, 0x10,
0x6b, 0xdf, 0xe5, 0xbb, 0x8c, 0xc1, 0x02, 0xbe, 0x71, 0xf0, 0x91, 0x20, 0x41, 0xd3, 0x8f, 0xbf,
0x4c, 0xc1, 0x70, 0xa4, 0x41, 0xc5, 0xd3, 0x7b, 0x03, 0x8c, 0x72, 0xdf, 0xd2, 0xdb, 0x1d, 0xe7,
0x09, 0x6e, 0x9f, 0x21, 0x46, 0xae, 0x81, 0x37, 0xbb, 0x21, 0x17, 0xf6, 0xd2, 0x44, 0x78, 0x72,
0xb2, 0x19, 0x76, 0xf6, 0x0d, 0xc2, 0xcf, 0x80, 0xe6, 0x3a, 0xbf, 0x6e, 0xe0, 0x57, 0x08, 0xfe,
0xd7, 0x6a, 0x90, 0x70, 0x2e, 0x9e, 0x53, 0x8c, 0x01, 0x96, 0x26, 0x3b, 0x49, 0x11, 0x0a, 0x7c,
0xc8, 0x04, 0x78, 0x84, 0x1f, 0x74, 0x21, 0x40, 0xdb, 0x1b, 0xc6, 0x26, 0x9b, 0xde, 0xd1, 0xd9,
0xc0, 0x2f, 0x11, 0x9c, 0x69, 0xb3, 0x7f, 0xb8, 0x03, 0xac, 0xfe, 0x13, 0x38, 0xd5, 0x51, 0x8e,
0x20, 0x78, 0x9f, 0x11, 0xbc, 0x8b, 0x6f, 0x1f, 0x2a, 0x41, 0xbc, 0x8b, 0x60, 0x38, 0xd2, 0x69,
0x25, 0x0d, 0x71, 0x92, 0x29, 0x4c, 0x1a, 0xe2, 0x44, 0x4b, 0x27, 0x3f, 0x64, 0x0c, 0x97, 0xf0,
0xbd, 0xee, 0x19, 0x6a, 0xfa, 0x6a, 0xa8, 0x77, 0x9f, 0xa7, 0xe0, 0x4c, 0x9b, 0x15, 0x4a, 0xea,
0x5d, 0x9c, 0xa1, 0x4b, 0xea, 0x5d, 0xac, 0xd7, 0x92, 0xbf, 0xe0, 0x8f, 0xe7, 0xa7, 0x08, 0x7f,
0x72, 0xc8, 0xe3, 0x99, 0x60, 0x8a, 0x1a, 0xa4, 0xe6, 0x03, 0xca, 0x57, 0x04, 0xe5, 0x3f, 0x11,
0x9c, 0x0c, 0x79, 0x20, 0xac, 0x24, 0x13, 0x6a, 0x75, 0x70, 0x12, 0xd9, 0x77, 0xbc, 0x20, 0xff,
0x94, 0x93, 0xff, 0x18, 0x7f, 0xf4, 0x77, 0x73, 0x67, 0x58, 0xd8, 0x2c, 0xe0, 0x9f, 0x10, 0x0c,
0x46, 0x38, 0x25, 0x9c, 0xf0, 0x2a, 0x89, 0x37, 0x6d, 0xd2, 0x5b, 0x1d, 0x66, 0x09, 0x25, 0x16,
0x99, 0x10, 0xb7, 0xf0, 0xcd, 0x2e, 0x84, 0x08, 0xf9, 0xb9, 0x39, 0xf5, 0xc5, 0x4e, 0x16, 0x6d,
0xef, 0x64, 0xd1, 0xaf, 0x3b, 0x59, 0xf4, 0xd5, 0x6e, 0xb6, 0x6f, 0x7b, 0x37, 0xdb, 0xf7, 0xf3,
0x6e, 0xb6, 0xef, 0xd1, 0x4c, 0xc9, 0x70, 0x56, 0x6a, 0x05, 0x45, 0xb7, 0xca, 0x44, 0xfc, 0x17,
0x9e, 0xff, 0xb9, 0x6a, 0x17, 0x57, 0xc9, 0x3a, 0xf1, 0xff, 0xdb, 0xfe, 0xe6, 0xb5, 0xab, 0x1e,
0x12, 0x67, 0xa3, 0x42, 0xed, 0xc2, 0x51, 0xf6, 0x4f, 0x93, 0xa9, 0xbf, 0x02, 0x00, 0x00, 0xff,
0xff, 0x4c, 0x6c, 0x44, 0xa5, 0x14, 0x18, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -2119,14 +2063,7 @@ func (m *QueryChannelResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -2410,14 +2347,7 @@ func (m *QueryChannelClientStateResponse) MarshalToSizedBuffer(dAtA []byte) (int
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -2516,14 +2446,7 @@ func (m *QueryChannelConsensusStateResponse) MarshalToSizedBuffer(dAtA []byte) (
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x2a
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x22
}
dAtA[i] = 0x22
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -2624,14 +2547,7 @@ func (m *QueryPacketCommitmentResponse) MarshalToSizedBuffer(dAtA []byte) (int,
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -2828,14 +2744,7 @@ func (m *QueryPacketAcknowledgementResponse) MarshalToSizedBuffer(dAtA []byte) (
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -3131,14 +3040,7 @@ func (m *QueryNextSequenceReceiveResponse) MarshalToSizedBuffer(dAtA []byte) (in
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.ProofPath) > 0 {
i -= len(m.ProofPath)
copy(dAtA[i:], m.ProofPath)
i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath)))
i--
dAtA[i] = 0x1a
}
dAtA[i] = 0x1a
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
@ -3196,10 +3098,6 @@ func (m *QueryChannelResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -3308,10 +3206,6 @@ func (m *QueryChannelClientStateResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -3358,10 +3252,6 @@ func (m *QueryChannelConsensusStateResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -3401,10 +3291,6 @@ func (m *QueryPacketCommitmentResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -3486,10 +3372,6 @@ func (m *QueryPacketAcknowledgementResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -3609,10 +3491,6 @@ func (m *QueryNextSequenceReceiveResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.ProofPath)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = m.ProofHeight.Size()
n += 1 + l + sovQuery(uint64(l))
return n
@ -3841,38 +3719,6 @@ func (m *QueryChannelResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}
@ -4668,38 +4514,6 @@ func (m *QueryChannelClientStateResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}
@ -5043,38 +4857,6 @@ func (m *QueryChannelConsensusStateResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}
@ -5365,38 +5147,6 @@ func (m *QueryPacketCommitmentResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}
@ -5996,38 +5746,6 @@ func (m *QueryPacketAcknowledgementResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}
@ -6994,38 +6712,6 @@ func (m *QueryNextSequenceReceiveResponse) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ProofPath = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType)
}