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

Update ibc proof to be bytes (#6393)

Browse Source 
* update interfaces to use []byte instead of commitment proof

* update 03/04 msgs with bytes

* fix compile errors

* fix channel tests

* fix connection tests

* fix testing, tm, and localhost tests

* fix ante tests

* update 03-connection spec

* update channel msgs spec

* small fixes after self review

* rm unused import

* Update x/ibc/03-connection/client/utils/utils.go

Co-authored-by: Alessio Treglia <alessio@tendermint.com>

* add empty proof test and rm ics 20 from ibc spec

* fix merge issues

Co-authored-by: Alessio Treglia <alessio@tendermint.com>
This commit is contained in:
colin axner 2020-06-11 15:19:25 -07:00 committed by GitHub
parent b09d6728ec
commit 9048ffa8d3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
30 changed files with 1010 additions and 762 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
x/ibc/02-client/exported/exported.go
View File

@ -26,13 +26,14 @@ type ClientState interface {
VerifyClientConsensusState(
store sdk.KVStore,
cdc *codec.Codec,
cdc codec.Marshaler,
aminoCdc *codec.Codec,
root commitmentexported.Root,
height uint64,
counterpartyClientIdentifier string,
consensusHeight uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
consensusState ConsensusState,
) error
VerifyConnectionState(
@ -40,7 +41,7 @@ type ClientState interface {
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
connectionID string,
connectionEnd connectionexported.ConnectionI,
consensusState ConsensusState,
@ -50,7 +51,7 @@ type ClientState interface {
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
channel channelexported.ChannelI,
@ -58,9 +59,10 @@ type ClientState interface {
) error
VerifyPacketCommitment(
store sdk.KVStore,
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
@ -69,9 +71,10 @@ type ClientState interface {
) error
VerifyPacketAcknowledgement(
store sdk.KVStore,
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
@ -80,9 +83,10 @@ type ClientState interface {
) error
VerifyPacketAcknowledgementAbsence(
store sdk.KVStore,
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
@ -90,9 +94,10 @@ type ClientState interface {
) error
VerifyNextSequenceRecv(
store sdk.KVStore,
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
nextSequenceRecv uint64,

30
x/ibc/03-connection/client/cli/tx.go
View File

@ -81,7 +81,7 @@ func GetCmdConnectionOpenTry(storeKey string, cdc *codec.Codec) *cobra.Command {
cmd := &cobra.Command{
Use: strings.TrimSpace(`open-try [connection-id] [client-id]
[counterparty-connection-id] [counterparty-client-id] [path/to/counterparty_prefix.json]
[counterparty-versions] [path/to/proof_init.json]`),
[counterparty-versions] [path/to/proof_init.json] [path/to/proof_consensus.json]`),
Short: "initiate connection handshake between two chains",
Long: strings.TrimSpace(
fmt.Sprintf(`initialize a connection on chain A with a given counterparty chain B:
@ -89,10 +89,10 @@ func GetCmdConnectionOpenTry(storeKey string, cdc *codec.Codec) *cobra.Command {
Example:
$ %s tx ibc connection open-try connection-id] [client-id] \
[counterparty-connection-id] [counterparty-client-id] [path/to/counterparty_prefix.json] \
[counterparty-versions] [path/to/proof_init.json]
[counterparty-versions] [path/to/proof_init.json] [path/tp/proof_consensus.json]
`, version.ClientName),
),
Args: cobra.ExactArgs(7),
Args: cobra.ExactArgs(8),
RunE: func(cmd *cobra.Command, args []string) error {
inBuf := bufio.NewReader(cmd.InOrStdin())
txBldr := authtypes.NewTxBuilderFromCLI(inBuf).WithTxEncoder(authclient.GetTxEncoder(cdc))
@ -113,7 +113,12 @@ $ %s tx ibc connection open-try connection-id] [client-id] \
// TODO: parse strings?
counterpartyVersions := args[5]
proofInit, err := utils.ParseProof(clientCtx.Codec, args[1])
proofInit, err := utils.ParseProof(clientCtx.Codec, args[6])
if err != nil {
return err
}
proofConsensus, err := utils.ParseProof(clientCtx.Codec, args[7])
if err != nil {
return err
}
@ -126,7 +131,7 @@ $ %s tx ibc connection open-try connection-id] [client-id] \
msg := types.NewMsgConnectionOpenTry(
connectionID, clientID, counterpartyConnectionID, counterpartyClientID,
counterpartyPrefix, []string{counterpartyVersions}, proofInit, proofInit, proofHeight,
counterpartyPrefix, []string{counterpartyVersions}, proofInit, proofConsensus, proofHeight,
consensusHeight, clientCtx.GetFromAddress(),
)
@ -145,16 +150,16 @@ $ %s tx ibc connection open-try connection-id] [client-id] \
// connection open attempt from chain B to chain A
func GetCmdConnectionOpenAck(storeKey string, cdc *codec.Codec) *cobra.Command {
cmd := &cobra.Command{
Use: "open-ack [connection-id] [path/to/proof_try.json] [version]",
Use: "open-ack [connection-id] [path/to/proof_try.json] [path/to/proof_consensus.json] [version]",
Short: "relay the acceptance of a connection open attempt from chain B to chain A",
Long: strings.TrimSpace(
fmt.Sprintf(`relay the acceptance of a connection open attempt from chain B to chain A:
Example:
$ %s tx ibc connection open-ack [connection-id] [path/to/proof_try.json] [version]
$ %s tx ibc connection open-ack [connection-id] [path/to/proof_try.json] [path/to/proof_consensus.json] [version]
`, version.ClientName),
),
Args: cobra.ExactArgs(3),
Args: cobra.ExactArgs(4),
RunE: func(cmd *cobra.Command, args []string) error {
inBuf := bufio.NewReader(cmd.InOrStdin())
txBldr := authtypes.NewTxBuilderFromCLI(inBuf).WithTxEncoder(authclient.GetTxEncoder(cdc))
@ -167,16 +172,21 @@ $ %s tx ibc connection open-ack [connection-id] [path/to/proof_try.json] [versio
return err
}
proofConsensus, err := utils.ParseProof(clientCtx.Codec, args[2])
if err != nil {
return err
}
proofHeight := uint64(clientCtx.Height)
consensusHeight, err := lastHeight(clientCtx)
if err != nil {
return err
}
version := args[4]
version := args[3]
msg := types.NewMsgConnectionOpenAck(
connectionID, proofTry, proofTry, proofHeight,
connectionID, proofTry, proofConsensus, proofHeight,
consensusHeight, version, clientCtx.GetFromAddress(),
)

22
x/ibc/03-connection/client/rest/rest.go
View File

@ -38,25 +38,25 @@ type ConnectionOpenTryReq struct {
CounterpartyConnectionID string `json:"counterparty_connection_id" yaml:"counterparty_connection_id"`
CounterpartyPrefix commitmenttypes.MerklePrefix `json:"counterparty_prefix" yaml:"counterparty_prefix"`
CounterpartyVersions []string `json:"counterparty_versions" yaml:"counterparty_versions"`
ProofInit commitmenttypes.MerkleProof `json:"proof_init" yaml:"proof_init"`
ProofConsensus commitmenttypes.MerkleProof `json:"proof_consensus" yaml:"proof_consensus"`
ProofInit []byte `json:"proof_init" yaml:"proof_init"`
ProofConsensus []byte `json:"proof_consensus" yaml:"proof_consensus"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
ConsensusHeight uint64 `json:"consensus_height" yaml:"consensus_height"`
}
// ConnectionOpenAckReq defines the properties of a connection open ack request's body.
type ConnectionOpenAckReq struct {
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
ProofTry commitmenttypes.MerkleProof `json:"proof_try" yaml:"proof_try"`
ProofConsensus commitmenttypes.MerkleProof `json:"proof_consensus" yaml:"proof_consensus"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
ConsensusHeight uint64 `json:"consensus_height" yaml:"consensus_height"`
Version string `json:"version" yaml:"version"`
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
ProofTry []byte `json:"proof_try" yaml:"proof_try"`
ProofConsensus []byte `json:"proof_consensus" yaml:"proof_consensus"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
ConsensusHeight uint64 `json:"consensus_height" yaml:"consensus_height"`
Version string `json:"version" yaml:"version"`
}
// ConnectionOpenConfirmReq defines the properties of a connection open confirm request's body.
type ConnectionOpenConfirmReq struct {
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
ProofAck commitmenttypes.MerkleProof `json:"proof_ack" yaml:"proof_ack"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
ProofAck []byte `json:"proof_ack" yaml:"proof_ack"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
}

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

@ -129,19 +129,21 @@ func ParsePrefix(cdc *codec.Codec, arg string) (commitmenttypes.MerklePrefix, er
return prefix, nil
}
// ParseProof unmarshals an cmd input argument from a JSON string to a commitment
// Proof. If the input is not a JSON, it looks for a path to the JSON file.
func ParseProof(cdc *codec.Codec, arg string) (commitmenttypes.MerkleProof, error) {
var proof commitmenttypes.MerkleProof
if err := cdc.UnmarshalJSON([]byte(arg), &proof); err != nil {
// ParseProof unmarshals a cmd input argument from a JSON string to a commitment
// Proof. If the input is not a JSON, it looks for a path to the JSON file. It
// then marshals the commitment proof into a proto encoded byte array.
func ParseProof(cdc *codec.Codec, arg string) ([]byte, error) {
var merkleProof commitmenttypes.MerkleProof
if err := cdc.UnmarshalJSON([]byte(arg), &merkleProof); err != nil {
// check for file path if JSON input is not provided
contents, err := ioutil.ReadFile(arg)
if err != nil {
return commitmenttypes.MerkleProof{}, errors.New("neither JSON input nor path to .json file were provided")
return nil, errors.New("neither JSON input nor path to .json file were provided")
}
if err := cdc.UnmarshalJSON(contents, &proof); err != nil {
return commitmenttypes.MerkleProof{}, errors.Wrap(err, "error unmarshalling commitment proof")
if err := cdc.UnmarshalJSON(contents, &merkleProof); err != nil {
return nil, fmt.Errorf("error unmarshalling commitment proof: %w", err)
}
}
return proof, nil
return cdc.MarshalBinaryBare(&merkleProof)
}

11
x/ibc/03-connection/keeper/handshake.go
View File

@ -8,7 +8,6 @@ import (
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types"
"github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types"
commitmentexported "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/exported"
commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/types"
)
@ -50,8 +49,8 @@ func (k Keeper) ConnOpenTry(
counterparty types.Counterparty, // counterpartyConnectionIdentifier, counterpartyPrefix and counterpartyClientIdentifier
clientID string, // clientID of chainA
counterpartyVersions []string, // supported versions of chain A
proofInit commitmentexported.Proof, // proof that chainA stored connectionEnd in state (on ConnOpenInit)
proofConsensus commitmentexported.Proof, // proof that chainA stored chainB's consensus state at consensus height
proofInit []byte, // proof that chainA stored connectionEnd in state (on ConnOpenInit)
proofConsensus []byte, // proof that chainA stored chainB's consensus state at consensus height
proofHeight uint64, // height at which relayer constructs proof of A storing connectionEnd in state
consensusHeight uint64, // latest height of chain B which chain A has stored in its chain B client
) error {
@ -124,8 +123,8 @@ func (k Keeper) ConnOpenAck(
ctx sdk.Context,
connectionID string,
version string, // version that ChainB chose in ConnOpenTry
proofTry commitmentexported.Proof, // proof that connectionEnd was added to ChainB state in ConnOpenTry
proofConsensus commitmentexported.Proof, // proof that chainB has stored ConsensusState of chainA on its client
proofTry []byte, // proof that connectionEnd was added to ChainB state in ConnOpenTry
proofConsensus []byte, // proof that chainB has stored ConsensusState of chainA on its client
proofHeight uint64, // height that relayer constructed proofTry
consensusHeight uint64, // latest height of chainA that chainB has stored on its chainA client
) error {
@ -196,7 +195,7 @@ func (k Keeper) ConnOpenAck(
func (k Keeper) ConnOpenConfirm(
ctx sdk.Context,
connectionID string,
proofAck commitmentexported.Proof, // proof that connection opened on ChainA during ConnOpenAck
proofAck []byte, // proof that connection opened on ChainA during ConnOpenAck
proofHeight uint64, // height that relayer constructed proofAck
) error {
// Retrieve connection

6
x/ibc/03-connection/keeper/keeper_test.go
View File

@ -67,7 +67,7 @@ func (suite *KeeperTestSuite) SetupTest() {
}
// nolint: unused
func queryProof(chain *TestChain, key []byte) (commitmenttypes.MerkleProof, uint64) {
func queryProof(chain *TestChain, key []byte) ([]byte, uint64) {
res := chain.App.Query(abci.RequestQuery{
Path: fmt.Sprintf("store/%s/key", storeKey),
Height: chain.App.LastBlockHeight(),
@ -75,10 +75,12 @@ func queryProof(chain *TestChain, key []byte) (commitmenttypes.MerkleProof, uint
Prove: true,
})
proof := commitmenttypes.MerkleProof{
merkleProof := commitmenttypes.MerkleProof{
Proof: res.Proof,
}
proof, _ := chain.App.AppCodec().MarshalBinaryBare(&merkleProof)
return proof, uint64(res.Height)
}
func TestKeeperTestSuite(t *testing.T) {

25
x/ibc/03-connection/keeper/verify.go
View File

@ -7,7 +7,6 @@ import (
clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types"
"github.com/cosmos/cosmos-sdk/x/ibc/03-connection/exported"
channelexported "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/exported"
commitmentexported "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/exported"
)
// VerifyClientConsensusState verifies a proof of the consensus state of the
@ -17,7 +16,7 @@ func (k Keeper) VerifyClientConsensusState(
connection exported.ConnectionI,
height uint64,
consensusHeight uint64,
proof commitmentexported.Proof,
proof []byte,
consensusState clientexported.ConsensusState,
) error {
clientID := connection.GetClientID()
@ -32,7 +31,7 @@ func (k Keeper) VerifyClientConsensusState(
}
return clientState.VerifyClientConsensusState(
k.clientKeeper.ClientStore(ctx, clientID), k.aminoCdc, targetConsState.GetRoot(), height,
k.clientKeeper.ClientStore(ctx, clientID), k.cdc, k.aminoCdc, targetConsState.GetRoot(), height,
connection.GetCounterparty().GetClientID(), consensusHeight, connection.GetCounterparty().GetPrefix(), proof, consensusState,
)
}
@ -43,7 +42,7 @@ func (k Keeper) VerifyConnectionState(
ctx sdk.Context,
connection exported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
connectionID string,
connectionEnd exported.ConnectionI, // opposite connection
) error {
@ -75,7 +74,7 @@ func (k Keeper) VerifyChannelState(
ctx sdk.Context,
connection exported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
channel channelexported.ChannelI,
@ -109,7 +108,7 @@ func (k Keeper) VerifyPacketCommitment(
ctx sdk.Context,
connection exported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
@ -132,7 +131,7 @@ func (k Keeper) VerifyPacketCommitment(
}
return clientState.VerifyPacketCommitment(
k.clientKeeper.ClientStore(ctx, connection.GetClientID()), height,
k.clientKeeper.ClientStore(ctx, connection.GetClientID()), k.cdc, height,
connection.GetCounterparty().GetPrefix(), proof, portID, channelID,
sequence, commitmentBytes, consensusState,
)
@ -144,7 +143,7 @@ func (k Keeper) VerifyPacketAcknowledgement(
ctx sdk.Context,
connection exported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
@ -167,7 +166,7 @@ func (k Keeper) VerifyPacketAcknowledgement(
}
return clientState.VerifyPacketAcknowledgement(
k.clientKeeper.ClientStore(ctx, connection.GetClientID()), height,
k.clientKeeper.ClientStore(ctx, connection.GetClientID()), k.cdc, height,
connection.GetCounterparty().GetPrefix(), proof, portID, channelID,
sequence, acknowledgement, consensusState,
)
@ -180,7 +179,7 @@ func (k Keeper) VerifyPacketAcknowledgementAbsence(
ctx sdk.Context,
connection exported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
@ -202,7 +201,7 @@ func (k Keeper) VerifyPacketAcknowledgementAbsence(
}
return clientState.VerifyPacketAcknowledgementAbsence(
k.clientKeeper.ClientStore(ctx, connection.GetClientID()), height,
k.clientKeeper.ClientStore(ctx, connection.GetClientID()), k.cdc, height,
connection.GetCounterparty().GetPrefix(), proof, portID, channelID,
sequence, consensusState,
)
@ -214,7 +213,7 @@ func (k Keeper) VerifyNextSequenceRecv(
ctx sdk.Context,
connection exported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
nextSequenceRecv uint64,
@ -236,7 +235,7 @@ func (k Keeper) VerifyNextSequenceRecv(
}
return clientState.VerifyNextSequenceRecv(
k.clientKeeper.ClientStore(ctx, connection.GetClientID()), height,
k.clientKeeper.ClientStore(ctx, connection.GetClientID()), k.cdc, height,
connection.GetCounterparty().GetPrefix(), proof, portID, channelID,
nextSequenceRecv, consensusState,
)

35
x/ibc/03-connection/types/msgs.go
View File

@ -66,7 +66,7 @@ var _ sdk.Msg = &MsgConnectionOpenTry{}
func NewMsgConnectionOpenTry(
connectionID, clientID, counterpartyConnectionID,
counterpartyClientID string, counterpartyPrefix commitmenttypes.MerklePrefix,
counterpartyVersions []string, proofInit, proofConsensus commitmenttypes.MerkleProof,
counterpartyVersions []string, proofInit, proofConsensus []byte,
proofHeight, consensusHeight uint64, signer sdk.AccAddress,
) *MsgConnectionOpenTry {
counterparty := NewCounterparty(counterpartyClientID, counterpartyConnectionID, counterpartyPrefix)
@ -109,14 +109,11 @@ func (msg MsgConnectionOpenTry) ValidateBasic() error {
return sdkerrors.Wrap(sdkerrors.ErrInvalidVersion, "version can't be blank")
}
}
if msg.ProofInit.Empty() || msg.ProofConsensus.Empty() {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
if len(msg.ProofInit) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof init")
}
if err := msg.ProofInit.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof init cannot be nil")
}
if err := msg.ProofConsensus.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof consensus cannot be nil")
if len(msg.ProofConsensus) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof of consensus state")
}
if msg.ProofHeight == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidHeight, "proof height must be > 0")
@ -144,7 +141,7 @@ var _ sdk.Msg = &MsgConnectionOpenAck{}
// NewMsgConnectionOpenAck creates a new MsgConnectionOpenAck instance
func NewMsgConnectionOpenAck(
connectionID string, proofTry, proofConsensus commitmenttypes.MerkleProof,
connectionID string, proofTry, proofConsensus []byte,
proofHeight, consensusHeight uint64, version string,
signer sdk.AccAddress,
) *MsgConnectionOpenAck {
@ -177,14 +174,11 @@ func (msg MsgConnectionOpenAck) ValidateBasic() error {
if strings.TrimSpace(msg.Version) == "" {
return sdkerrors.Wrap(sdkerrors.ErrInvalidVersion, "version can't be blank")
}
if msg.ProofTry.Empty() || msg.ProofConsensus.Empty() {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
if len(msg.ProofTry) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof try")
}
if err := msg.ProofTry.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof try cannot be nil")
}
if err := msg.ProofConsensus.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof consensus cannot be nil")
if len(msg.ProofConsensus) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof of consensus state")
}
if msg.ProofHeight == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidHeight, "proof height must be > 0")
@ -212,7 +206,7 @@ var _ sdk.Msg = &MsgConnectionOpenConfirm{}
// NewMsgConnectionOpenConfirm creates a new MsgConnectionOpenConfirm instance
func NewMsgConnectionOpenConfirm(
connectionID string, proofAck commitmenttypes.MerkleProof, proofHeight uint64,
connectionID string, proofAck []byte, proofHeight uint64,
signer sdk.AccAddress,
) *MsgConnectionOpenConfirm {
return &MsgConnectionOpenConfirm{
@ -238,11 +232,8 @@ func (msg MsgConnectionOpenConfirm) ValidateBasic() error {
if err := host.ConnectionIdentifierValidator(msg.ConnectionID); err != nil {
return sdkerrors.Wrap(err, "invalid connection ID")
}
if msg.ProofAck.Empty() {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
}
if err := msg.ProofAck.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof ack cannot be nil")
if len(msg.ProofAck) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof ack")
}
if msg.ProofHeight == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidHeight, "proof height must be > 0")

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

@ -9,6 +9,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/store/iavl"
"github.com/cosmos/cosmos-sdk/store/rootmulti"
storetypes "github.com/cosmos/cosmos-sdk/store/types"
@ -19,16 +20,17 @@ import (
var (
emptyPrefix = commitmenttypes.MerklePrefix{}
emptyProof = commitmenttypes.MerkleProof{Proof: nil}
emptyProof = []byte{}
)
type MsgTestSuite struct {
suite.Suite
proof commitmenttypes.MerkleProof
proof []byte
}
func (suite *MsgTestSuite) SetupTest() {
app := simapp.Setup(false)
db := dbm.NewMemDB()
store := rootmulti.NewStore(db)
storeKey := storetypes.NewKVStoreKey("iavlStoreKey")
@ -46,7 +48,12 @@ func (suite *MsgTestSuite) SetupTest() {
Prove: true,
})
suite.proof = commitmenttypes.MerkleProof{Proof: res.Proof}
merkleProof := commitmenttypes.MerkleProof{Proof: res.Proof}
proof, err := app.AppCodec().MarshalBinaryBare(&merkleProof)
suite.NoError(err)
suite.proof = proof
}
func TestMsgTestSuite(t *testing.T) {

319
x/ibc/03-connection/types/types.pb.go
View File

@ -140,10 +140,10 @@ type MsgConnectionOpenTry struct {
Counterparty Counterparty `protobuf:"bytes,3,opt,name=counterparty,proto3" json:"counterparty"`
CounterpartyVersions []string `protobuf:"bytes,4,rep,name=counterparty_versions,json=counterpartyVersions,proto3" json:"counterparty_versions,omitempty" yaml:"counterparty_versions"`
// proof of the initialization the connection on Chain A: `UNITIALIZED -> INIT`
ProofInit types.MerkleProof `protobuf:"bytes,5,opt,name=proof_init,json=proofInit,proto3" json:"proof_init" yaml:"proof_init"`
ProofHeight uint64 `protobuf:"varint,6,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"`
ProofInit []byte `protobuf:"bytes,5,opt,name=proof_init,json=proofInit,proto3" json:"proof_init,omitempty" yaml:"proof_init"`
ProofHeight uint64 `protobuf:"varint,6,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"`
// proof of client consensus state
ProofConsensus types.MerkleProof `protobuf:"bytes,7,opt,name=proof_consensus,json=proofConsensus,proto3" json:"proof_consensus" yaml:"proof_consensus"`
ProofConsensus []byte `protobuf:"bytes,7,opt,name=proof_consensus,json=proofConsensus,proto3" json:"proof_consensus,omitempty" yaml:"proof_consensus"`
ConsensusHeight uint64 `protobuf:"varint,8,opt,name=consensus_height,json=consensusHeight,proto3" json:"consensus_height,omitempty" yaml:"consensus_height"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,9,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
}
@ -209,11 +209,11 @@ func (m *MsgConnectionOpenTry) GetCounterpartyVersions() []string {
return nil
}
func (m *MsgConnectionOpenTry) GetProofInit() types.MerkleProof {
func (m *MsgConnectionOpenTry) GetProofInit() []byte {
if m != nil {
return m.ProofInit
}
return types.MerkleProof{}
return nil
}
func (m *MsgConnectionOpenTry) GetProofHeight() uint64 {
@ -223,11 +223,11 @@ func (m *MsgConnectionOpenTry) GetProofHeight() uint64 {
return 0
}
func (m *MsgConnectionOpenTry) GetProofConsensus() types.MerkleProof {
func (m *MsgConnectionOpenTry) GetProofConsensus() []byte {
if m != nil {
return m.ProofConsensus
}
return types.MerkleProof{}
return nil
}
func (m *MsgConnectionOpenTry) GetConsensusHeight() uint64 {
@ -250,10 +250,10 @@ type MsgConnectionOpenAck struct {
ConnectionID string `protobuf:"bytes,1,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty" yaml:"connection_id"`
Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
// proof of the initialization the connection on Chain B: `UNITIALIZED -> TRYOPEN`
ProofTry types.MerkleProof `protobuf:"bytes,3,opt,name=proof_try,json=proofTry,proto3" json:"proof_try" yaml:"proof_try"`
ProofHeight uint64 `protobuf:"varint,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
ProofTry []byte `protobuf:"bytes,3,opt,name=proof_try,json=proofTry,proto3" json:"proof_try,omitempty" yaml:"proof_try"`
ProofHeight uint64 `protobuf:"varint,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
// proof of client consensus state
ProofConsensus types.MerkleProof `protobuf:"bytes,5,opt,name=proof_consensus,json=proofConsensus,proto3" json:"proof_consensus" yaml:"proof_consensus"`
ProofConsensus []byte `protobuf:"bytes,5,opt,name=proof_consensus,json=proofConsensus,proto3" json:"proof_consensus,omitempty" yaml:"proof_consensus"`
ConsensusHeight uint64 `protobuf:"varint,6,opt,name=consensus_height,json=consensusHeight,proto3" json:"consensus_height,omitempty" yaml:"consensus_height"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,7,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
}
@ -305,11 +305,11 @@ func (m *MsgConnectionOpenAck) GetVersion() string {
return ""
}
func (m *MsgConnectionOpenAck) GetProofTry() types.MerkleProof {
func (m *MsgConnectionOpenAck) GetProofTry() []byte {
if m != nil {
return m.ProofTry
}
return types.MerkleProof{}
return nil
}
func (m *MsgConnectionOpenAck) GetProofHeight() uint64 {
@ -319,11 +319,11 @@ func (m *MsgConnectionOpenAck) GetProofHeight() uint64 {
return 0
}
func (m *MsgConnectionOpenAck) GetProofConsensus() types.MerkleProof {
func (m *MsgConnectionOpenAck) GetProofConsensus() []byte {
if m != nil {
return m.ProofConsensus
}
return types.MerkleProof{}
return nil
}
func (m *MsgConnectionOpenAck) GetConsensusHeight() uint64 {
@ -345,7 +345,7 @@ func (m *MsgConnectionOpenAck) GetSigner() github_com_cosmos_cosmos_sdk_types.Ac
type MsgConnectionOpenConfirm struct {
ConnectionID string `protobuf:"bytes,1,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty" yaml:"connection_id"`
// proof for the change of the connection state on Chain A: `INIT -> OPEN`
ProofAck types.MerkleProof `protobuf:"bytes,2,opt,name=proof_ack,json=proofAck,proto3" json:"proof_ack" yaml:"proof_ack"`
ProofAck []byte `protobuf:"bytes,2,opt,name=proof_ack,json=proofAck,proto3" json:"proof_ack,omitempty" yaml:"proof_ack"`
ProofHeight uint64 `protobuf:"varint,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,4,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
}
@ -390,11 +390,11 @@ func (m *MsgConnectionOpenConfirm) GetConnectionID() string {
return ""
}
func (m *MsgConnectionOpenConfirm) GetProofAck() types.MerkleProof {
func (m *MsgConnectionOpenConfirm) GetProofAck() []byte {
if m != nil {
return m.ProofAck
}
return types.MerkleProof{}
return nil
}
func (m *MsgConnectionOpenConfirm) GetProofHeight() uint64 {
@ -566,64 +566,63 @@ func init() {
}
var fileDescriptor_30ee50c03d1fbe43 = []byte{
// 911 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x96, 0x31, 0x6f, 0xdb, 0x46,
0x14, 0x80, 0x45, 0x8a, 0x92, 0xa5, 0xb3, 0x9c, 0x28, 0x8c, 0xd3, 0xb0, 0x6a, 0x41, 0xb2, 0x0c,
0x52, 0x08, 0x6d, 0x2d, 0x35, 0x0e, 0x90, 0xc1, 0x45, 0x07, 0x49, 0x56, 0x50, 0x16, 0xb5, 0x23,
0xd0, 0x72, 0x80, 0x66, 0x11, 0x24, 0xf2, 0x2c, 0x1d, 0x64, 0x91, 0x02, 0xef, 0x1c, 0x58, 0xff,
0x20, 0xf0, 0xd4, 0xb5, 0x83, 0x81, 0x02, 0x5d, 0x8a, 0xfe, 0x12, 0x8f, 0x19, 0x3a, 0x74, 0x22,
0x0a, 0x19, 0xe8, 0xd8, 0x41, 0x63, 0xa7, 0xe2, 0xee, 0x28, 0x92, 0x8e, 0x5c, 0x1b, 0x86, 0x05,
0xb4, 0x40, 0x16, 0xe9, 0xde, 0xbb, 0xf7, 0xde, 0xbd, 0x7b, 0xef, 0x23, 0x1f, 0xc1, 0xe3, 0xe3,
0x2a, 0xea, 0xd9, 0xd5, 0x2f, 0x9f, 0x6e, 0xd8, 0x9e, 0xeb, 0x42, 0x9b, 0x20, 0xcf, 0xad, 0x92,
0xc9, 0x18, 0x62, 0xfe, 0x5b, 0x19, 0xfb, 0x1e, 0xf1, 0x64, 0xd5, 0xf6, 0xf0, 0xc8, 0xc3, 0x1d,
0xec, 0x0c, 0x2b, 0xc7, 0x15, 0xd4, 0xb3, 0x2b, 0xb1, 0x79, 0xe5, 0xf5, 0x93, 0xd2, 0xa7, 0x64,
0x80, 0x7c, 0xa7, 0x33, 0xee, 0xfa, 0x64, 0x52, 0x65, 0x2e, 0xd5, 0xbe, 0xd7, 0xf7, 0xe2, 0x15,
0x8f, 0x53, 0x0a, 0x8f, 0xdb, 0xa4, 0xc7, 0x8d, 0x46, 0x88, 0x8c, 0xa0, 0x4b, 0x16, 0x8f, 0x33,
0xce, 0x44, 0xf0, 0x60, 0x07, 0xf7, 0x1b, 0xd1, 0x19, 0x2f, 0xc6, 0xd0, 0x35, 0x5d, 0x44, 0xe4,
0xaf, 0x41, 0xde, 0x3e, 0x44, 0xd0, 0x25, 0x1d, 0xe4, 0x28, 0x82, 0x2e, 0x94, 0xf3, 0x75, 0x7d,
0x1a, 0x68, 0xb9, 0x06, 0x53, 0x9a, 0xdb, 0xb3, 0x40, 0x2b, 0x4e, 0xba, 0xa3, 0xc3, 0x2d, 0x23,
0x32, 0x33, 0xac, 0x1c, 0x5f, 0x9b, 0x8e, 0xbc, 0x03, 0xd6, 0xe2, 0xc4, 0x69, 0x08, 0x91, 0x85,
0x28, 0x4f, 0x03, 0xad, 0x10, 0x9f, 0xc6, 0xc2, 0xac, 0x87, 0x61, 0x92, 0xe6, 0x86, 0x55, 0x88,
0x65, 0xd3, 0x91, 0x5f, 0x82, 0x82, 0xed, 0x1d, 0xb9, 0x04, 0xfa, 0xec, 0xe6, 0x4a, 0x5a, 0x17,
0xca, 0xab, 0x9b, 0x5f, 0x54, 0xae, 0xae, 0x56, 0xa5, 0x91, 0xf0, 0xa9, 0x4b, 0x67, 0x81, 0x96,
0xb2, 0x2e, 0xc4, 0x91, 0x4d, 0x90, 0xc5, 0xa8, 0xef, 0x42, 0x5f, 0x91, 0x74, 0xa1, 0x5c, 0xa8,
0x3f, 0xf9, 0x3b, 0xd0, 0x36, 0xfa, 0x88, 0x0c, 0x8e, 0x7a, 0x15, 0xdb, 0x1b, 0x55, 0x79, 0xfc,
0xf0, 0x6f, 0x03, 0x3b, 0xc3, 0xb0, 0x7a, 0x35, 0xdb, 0xae, 0x39, 0x8e, 0x0f, 0x31, 0xb6, 0xc2,
0x00, 0xc6, 0x9f, 0x19, 0xb0, 0xbe, 0x50, 0xca, 0xb6, 0x3f, 0x79, 0x4f, 0x2a, 0xb9, 0x0f, 0x1e,
0x24, 0xe5, 0xce, 0x6b, 0xe8, 0x63, 0xe4, 0xb9, 0x58, 0x91, 0xf4, 0x34, 0xbd, 0xf1, 0x2c, 0xd0,
0x3e, 0x9e, 0xa7, 0x77, 0x89, 0x99, 0x61, 0xad, 0x27, 0xf5, 0x2f, 0x43, 0xb5, 0x0c, 0x01, 0x18,
0xfb, 0x9e, 0x77, 0xd0, 0x41, 0x2e, 0x22, 0x4a, 0x86, 0x25, 0xfb, 0xf9, 0x65, 0xc9, 0xce, 0x21,
0xa7, 0xc9, 0xee, 0x40, 0x7f, 0x78, 0x08, 0x5b, 0xd4, 0xaf, 0xfe, 0x21, 0xcd, 0x75, 0x16, 0x68,
0xf7, 0xf8, 0xe1, 0x71, 0x30, 0xc3, 0xca, 0x33, 0x81, 0xd1, 0xfe, 0x09, 0x28, 0xf0, 0x9d, 0x01,
0x44, 0xfd, 0x01, 0x51, 0xb2, 0xba, 0x50, 0x96, 0xac, 0x55, 0xa6, 0xfb, 0x86, 0xa9, 0x64, 0x02,
0xee, 0x72, 0x13, 0xdb, 0x73, 0x31, 0x74, 0xf1, 0x11, 0x56, 0x56, 0x6e, 0x9e, 0x8e, 0x1a, 0xa6,
0xf3, 0x41, 0x32, 0x9d, 0x28, 0xa2, 0x61, 0xdd, 0x61, 0x9a, 0xc6, 0x5c, 0x21, 0x3f, 0x07, 0xc5,
0x68, 0x77, 0x9e, 0x5c, 0x8e, 0x26, 0x57, 0xff, 0x68, 0x16, 0x68, 0x0f, 0xa3, 0x86, 0x5f, 0xb0,
0x30, 0xac, 0xbb, 0x91, 0x2a, 0xcc, 0x3e, 0x06, 0x3d, 0x7f, 0x5b, 0xd0, 0x7f, 0x91, 0x2e, 0x01,
0xbd, 0x66, 0x0f, 0x17, 0x49, 0x15, 0x6e, 0x45, 0xaa, 0x02, 0x56, 0x42, 0x3a, 0x38, 0xf2, 0xd6,
0x5c, 0x94, 0x7b, 0x80, 0xb7, 0xae, 0x43, 0xfc, 0x39, 0xc0, 0x37, 0x6a, 0x82, 0x12, 0x36, 0xa1,
0x98, 0x6c, 0x02, 0xf1, 0x27, 0x86, 0x95, 0x63, 0x6b, 0xfa, 0xd4, 0x6e, 0xbd, 0x43, 0x84, 0xc4,
0x8a, 0xfe, 0x70, 0x16, 0x68, 0xf7, 0x93, 0x5e, 0xf3, 0x82, 0x5f, 0x87, 0x4a, 0xe6, 0xbf, 0x41,
0x25, 0x7b, 0x2b, 0x54, 0x56, 0x6e, 0x8b, 0xca, 0x6f, 0x22, 0x50, 0x16, 0x50, 0x69, 0x78, 0xee,
0x01, 0xf2, 0x47, 0xcb, 0xc6, 0x25, 0x82, 0xa2, 0x6b, 0x0f, 0x19, 0x30, 0xcb, 0x80, 0xa2, 0x6b,
0x0f, 0xe7, 0x50, 0x50, 0xc2, 0xdf, 0x85, 0x22, 0x7d, 0x03, 0x28, 0x96, 0x38, 0x6a, 0x7e, 0x15,
0xc1, 0x5a, 0x5c, 0xa1, 0xa6, 0xeb, 0xc8, 0x8f, 0x80, 0x18, 0x15, 0xf0, 0xfe, 0x34, 0xd0, 0x44,
0x56, 0xb6, 0x3c, 0x4f, 0x8a, 0xd6, 0x4a, 0x44, 0xce, 0xc5, 0x41, 0x24, 0xde, 0x78, 0x10, 0x95,
0x40, 0x2e, 0x7a, 0xa9, 0xa7, 0xe9, 0x4b, 0xdd, 0x8a, 0x64, 0xf9, 0x2b, 0x90, 0xc1, 0xa4, 0x4b,
0x20, 0xbb, 0xdb, 0x9d, 0xcd, 0xc7, 0xd7, 0x8d, 0x93, 0x3d, 0x6a, 0x6c, 0x71, 0x9f, 0x85, 0x91,
0x94, 0x59, 0xce, 0x48, 0xda, 0x92, 0xde, 0xfc, 0xa4, 0xa5, 0x8c, 0xbf, 0x04, 0x50, 0x48, 0x9a,
0xfe, 0xcf, 0xe6, 0xf1, 0xb7, 0x20, 0x3b, 0xf6, 0xe1, 0x01, 0x3a, 0xbe, 0x6a, 0x12, 0x5f, 0xc6,
0x2c, 0xf5, 0x09, 0xaf, 0x1d, 0x46, 0x08, 0x2f, 0xfc, 0x08, 0xac, 0xf2, 0xab, 0xb4, 0xba, 0x64,
0x80, 0xe5, 0x75, 0x90, 0x19, 0xd3, 0x85, 0x22, 0xb0, 0x9e, 0x71, 0xe1, 0xb3, 0x1f, 0x05, 0x90,
0x61, 0x4d, 0x90, 0x9f, 0x01, 0x6d, 0xaf, 0x5d, 0x6b, 0x37, 0x3b, 0xfb, 0xbb, 0xe6, 0xae, 0xd9,
0x36, 0x6b, 0xdf, 0x99, 0xaf, 0x9a, 0xdb, 0x9d, 0xfd, 0xdd, 0xbd, 0x56, 0xb3, 0x61, 0x3e, 0x37,
0x9b, 0xdb, 0xc5, 0x54, 0xe9, 0xde, 0xc9, 0xa9, 0xbe, 0x76, 0xc1, 0x40, 0x56, 0x00, 0xe0, 0x7e,
0x54, 0x59, 0x14, 0x4a, 0xb9, 0x93, 0x53, 0x5d, 0xa2, 0x6b, 0x59, 0x05, 0x6b, 0x7c, 0xa7, 0x6d,
0x7d, 0xff, 0xa2, 0xd5, 0xdc, 0x2d, 0x8a, 0xa5, 0xd5, 0x93, 0x53, 0x7d, 0x25, 0x14, 0x63, 0x4f,
0xb6, 0x99, 0xe6, 0x9e, 0x74, 0x5d, 0x92, 0xde, 0xfc, 0xac, 0xa6, 0xea, 0xad, 0xb3, 0xa9, 0x2a,
0xbc, 0x9d, 0xaa, 0xc2, 0x1f, 0x53, 0x55, 0xf8, 0xe1, 0x5c, 0x4d, 0xbd, 0x3d, 0x57, 0x53, 0xbf,
0x9f, 0xab, 0xa9, 0x57, 0xcf, 0xae, 0x7c, 0x5e, 0xfe, 0xf5, 0x0b, 0xbb, 0x97, 0x65, 0x5f, 0xbb,
0x4f, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x43, 0x20, 0xb6, 0x5a, 0x85, 0x0b, 0x00, 0x00,
// 889 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0xbf, 0x6f, 0xdb, 0x46,
0x14, 0x16, 0x29, 0x4a, 0x96, 0xce, 0x72, 0xa2, 0x30, 0x72, 0x43, 0xb0, 0x05, 0xc9, 0x32, 0x48,
0x21, 0x14, 0x35, 0x55, 0x3b, 0x45, 0x06, 0x17, 0x1d, 0x24, 0x59, 0x41, 0x59, 0xd4, 0x8a, 0x40,
0xcb, 0x01, 0x9a, 0x85, 0x90, 0x48, 0x5a, 0x3a, 0xc8, 0x22, 0x05, 0xde, 0x39, 0xb0, 0xf6, 0x0e,
0x81, 0xa7, 0xae, 0x1d, 0x0c, 0x14, 0xc8, 0xd6, 0x3f, 0xa4, 0xf0, 0x98, 0xb1, 0x13, 0x51, 0xc8,
0x7b, 0x07, 0x8d, 0x9d, 0x0a, 0xde, 0x51, 0xa4, 0x14, 0xb9, 0x0e, 0x0c, 0x69, 0x28, 0x90, 0x45,
0xba, 0xf7, 0xeb, 0x7b, 0xf7, 0xde, 0xf7, 0xf8, 0x48, 0xf0, 0xe4, 0xbc, 0x02, 0xbb, 0x56, 0xe5,
0xeb, 0xa7, 0x3b, 0x96, 0xe7, 0xba, 0x8e, 0x85, 0xa1, 0xe7, 0x56, 0xf0, 0x78, 0xe4, 0x20, 0xfa,
0xab, 0x8d, 0x7c, 0x0f, 0x7b, 0xbc, 0x64, 0x79, 0x68, 0xe8, 0x21, 0x13, 0xd9, 0x03, 0xed, 0x5c,
0x83, 0x5d, 0x4b, 0x4b, 0xdc, 0xb5, 0xd7, 0xbb, 0xe2, 0x17, 0xb8, 0x0f, 0x7d, 0xdb, 0x1c, 0x75,
0x7c, 0x3c, 0xae, 0x90, 0x90, 0x4a, 0xcf, 0xeb, 0x79, 0xc9, 0x89, 0xe2, 0x88, 0x51, 0xba, 0xbd,
0x30, 0xdd, 0x70, 0x08, 0xf1, 0xd0, 0x71, 0xf1, 0x72, 0x3a, 0xf5, 0x8a, 0x05, 0xdb, 0x87, 0xa8,
0x57, 0x8f, 0x73, 0xbc, 0x18, 0x39, 0xae, 0xee, 0x42, 0xcc, 0x7f, 0x07, 0xf2, 0xd6, 0x29, 0x74,
0x5c, 0x6c, 0x42, 0x5b, 0x60, 0x14, 0xa6, 0x9c, 0xaf, 0x29, 0x93, 0x40, 0xce, 0xd5, 0x89, 0x52,
0x3f, 0x98, 0x06, 0x72, 0x71, 0xdc, 0x19, 0x9e, 0xee, 0xab, 0xb1, 0x9b, 0x6a, 0xe4, 0xe8, 0x59,
0xb7, 0xf9, 0x43, 0xb0, 0x95, 0x5c, 0x3c, 0x84, 0x60, 0x09, 0x44, 0x79, 0x12, 0xc8, 0x85, 0x24,
0x1b, 0x81, 0x29, 0x45, 0x30, 0xf3, 0xee, 0xaa, 0x51, 0x48, 0x64, 0xdd, 0xe6, 0x5f, 0x82, 0x82,
0xe5, 0x9d, 0xb9, 0xd8, 0xf1, 0x49, 0xe5, 0x42, 0x5a, 0x61, 0xca, 0x9b, 0x7b, 0x5f, 0x69, 0xb7,
0x77, 0x4b, 0xab, 0xcf, 0xc5, 0xd4, 0xb8, 0xab, 0x40, 0x4e, 0x19, 0x0b, 0x38, 0xbc, 0x0e, 0xb2,
0x08, 0xf6, 0x5c, 0xc7, 0x17, 0x38, 0x85, 0x29, 0x17, 0x6a, 0xbb, 0xff, 0x04, 0xf2, 0x4e, 0x0f,
0xe2, 0xfe, 0x59, 0x57, 0xb3, 0xbc, 0x61, 0x85, 0xe2, 0x47, 0x7f, 0x3b, 0xc8, 0x1e, 0x44, 0xdd,
0xab, 0x5a, 0x56, 0xd5, 0xb6, 0x7d, 0x07, 0x21, 0x23, 0x02, 0x50, 0x7f, 0xce, 0x80, 0xd2, 0x52,
0x2b, 0xdb, 0xfe, 0xf8, 0x23, 0xe9, 0xe4, 0x31, 0xd8, 0x9e, 0x97, 0xcd, 0xd7, 0x8e, 0x8f, 0xa0,
0xe7, 0x22, 0x81, 0x53, 0xd2, 0x61, 0xc5, 0xd3, 0x40, 0xfe, 0x6c, 0x76, 0xbd, 0x1b, 0xdc, 0x54,
0xa3, 0x34, 0xaf, 0x7f, 0x19, 0xa9, 0xf9, 0x6f, 0x00, 0x18, 0xf9, 0x9e, 0x77, 0x62, 0x42, 0x17,
0x62, 0x21, 0x43, 0x48, 0xda, 0x9e, 0x06, 0xf2, 0x03, 0x8a, 0x95, 0xd8, 0x54, 0x23, 0x4f, 0x04,
0x32, 0xbc, 0x9f, 0x83, 0x02, 0xb5, 0xf4, 0x1d, 0xd8, 0xeb, 0x63, 0x21, 0xab, 0x30, 0x65, 0xce,
0xd8, 0x24, 0xba, 0xef, 0x89, 0x8a, 0xaf, 0x83, 0xfb, 0xd4, 0xc5, 0xf2, 0x5c, 0xe4, 0xb8, 0xe8,
0x0c, 0x09, 0x1b, 0x04, 0x5d, 0x9c, 0x06, 0xf2, 0x27, 0xf3, 0xe8, 0xb1, 0x83, 0x6a, 0xdc, 0x23,
0x9a, 0xfa, 0x4c, 0xc1, 0x3f, 0x07, 0xc5, 0xd8, 0x3a, 0xcb, 0x95, 0x0b, 0x73, 0xd5, 0x3e, 0x9d,
0x06, 0xf2, 0xa3, 0x98, 0x8e, 0x05, 0x0f, 0xd5, 0xb8, 0x1f, 0xab, 0xa2, 0xcb, 0x24, 0x63, 0x98,
0x5f, 0x75, 0x0c, 0xff, 0x48, 0xdf, 0x30, 0x86, 0x55, 0x6b, 0xb0, 0x3c, 0x47, 0xcc, 0x4a, 0x73,
0x24, 0x80, 0x8d, 0x88, 0x3b, 0x3a, 0x90, 0xc6, 0x4c, 0xe4, 0x77, 0x01, 0x65, 0xc2, 0xc4, 0x3e,
0x1d, 0xaf, 0x42, 0xad, 0x94, 0xcc, 0x78, 0x6c, 0x52, 0x8d, 0x1c, 0x39, 0x87, 0x8f, 0xc8, 0xfe,
0x7b, 0x7c, 0x71, 0xa4, 0x87, 0x8f, 0xa6, 0x81, 0xfc, 0x70, 0x3e, 0x6a, 0xd6, 0xbf, 0x0f, 0x11,
0x99, 0x59, 0x0b, 0x91, 0xd9, 0x95, 0x88, 0xdc, 0x58, 0x95, 0xc8, 0xb7, 0x2c, 0x10, 0x96, 0x88,
0xac, 0x7b, 0xee, 0x09, 0xf4, 0x87, 0xeb, 0x26, 0x33, 0xa6, 0xac, 0x63, 0x0d, 0x08, 0x9d, 0x37,
0x50, 0xd6, 0xb1, 0x06, 0x33, 0xca, 0xc2, 0x71, 0x7a, 0x9f, 0xb2, 0xf4, 0x1d, 0x28, 0x5b, 0xe3,
0xd6, 0xfd, 0x9d, 0x05, 0x5b, 0x49, 0xc1, 0x0d, 0xd7, 0xe6, 0x1f, 0x03, 0x36, 0xee, 0xc7, 0xc3,
0x49, 0x20, 0xb3, 0xa4, 0x0b, 0x79, 0x7a, 0xa9, 0xb0, 0x74, 0x16, 0xda, 0x8b, 0x3b, 0x99, 0xbd,
0xf3, 0x4e, 0x16, 0x41, 0x2e, 0xde, 0x6f, 0xe9, 0x70, 0xbf, 0x19, 0xb1, 0xcc, 0x7f, 0x0b, 0x32,
0x08, 0x77, 0xb0, 0x43, 0x6a, 0xbb, 0xb7, 0xf7, 0xe4, 0x43, 0x9b, 0xf5, 0x28, 0x74, 0x36, 0x68,
0xcc, 0xd2, 0x76, 0xce, 0xac, 0x67, 0x3b, 0xef, 0x73, 0x6f, 0x7e, 0x93, 0x53, 0xea, 0xdf, 0x0c,
0x28, 0xcc, 0xbb, 0xfe, 0xcf, 0x5e, 0x4d, 0x3f, 0x80, 0xec, 0xc8, 0x77, 0x4e, 0xe0, 0xf9, 0x6d,
0x2f, 0xa5, 0xd9, 0xc7, 0x4c, 0x58, 0xf6, 0xa1, 0xe3, 0x0f, 0x4e, 0x9d, 0x16, 0x89, 0x89, 0xca,
0x8e, 0x10, 0xa2, 0x82, 0x1f, 0x83, 0x4d, 0x5a, 0x4a, 0xab, 0x83, 0xfb, 0x88, 0x2f, 0x81, 0xcc,
0x28, 0x3c, 0x08, 0x0c, 0xe1, 0x8c, 0x0a, 0x5f, 0xfe, 0xca, 0x80, 0x0c, 0x21, 0x81, 0x7f, 0x06,
0xe4, 0xa3, 0x76, 0xb5, 0xdd, 0x30, 0x8f, 0x9b, 0x7a, 0x53, 0x6f, 0xeb, 0xd5, 0x1f, 0xf5, 0x57,
0x8d, 0x03, 0xf3, 0xb8, 0x79, 0xd4, 0x6a, 0xd4, 0xf5, 0xe7, 0x7a, 0xe3, 0xa0, 0x98, 0x12, 0x1f,
0x5c, 0x5c, 0x2a, 0x5b, 0x0b, 0x0e, 0xbc, 0x00, 0x00, 0x8d, 0x0b, 0x95, 0x45, 0x46, 0xcc, 0x5d,
0x5c, 0x2a, 0x5c, 0x78, 0xe6, 0x25, 0xb0, 0x45, 0x2d, 0x6d, 0xe3, 0xa7, 0x17, 0xad, 0x46, 0xb3,
0xc8, 0x8a, 0x9b, 0x17, 0x97, 0xca, 0x46, 0x24, 0x26, 0x91, 0xc4, 0x98, 0xa6, 0x91, 0xe1, 0x59,
0xe4, 0xde, 0xbc, 0x95, 0x52, 0xb5, 0xd6, 0xd5, 0x44, 0x62, 0xde, 0x4d, 0x24, 0xe6, 0xaf, 0x89,
0xc4, 0xfc, 0x72, 0x2d, 0xa5, 0xde, 0x5d, 0x4b, 0xa9, 0x3f, 0xaf, 0xa5, 0xd4, 0xab, 0x67, 0xb7,
0x3e, 0x2f, 0xff, 0xf9, 0xb1, 0xd9, 0xcd, 0x92, 0x0f, 0xbf, 0xa7, 0xff, 0x06, 0x00, 0x00, 0xff,
0xff, 0x9f, 0x6b, 0x1d, 0x24, 0x90, 0x0a, 0x00, 0x00,
}
func (m *MsgConnectionOpenInit) Marshal() (dAtA []byte, err error) {
@ -712,31 +711,25 @@ func (m *MsgConnectionOpenTry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x40
}
{
size, err := m.ProofConsensus.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.ProofConsensus) > 0 {
i -= len(m.ProofConsensus)
copy(dAtA[i:], m.ProofConsensus)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProofConsensus)))
i--
dAtA[i] = 0x3a
}
i--
dAtA[i] = 0x3a
if m.ProofHeight != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.ProofHeight))
i--
dAtA[i] = 0x30
}
{
size, err := m.ProofInit.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.ProofInit) > 0 {
i -= len(m.ProofInit)
copy(dAtA[i:], m.ProofInit)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProofInit)))
i--
dAtA[i] = 0x2a
}
i--
dAtA[i] = 0x2a
if len(m.CounterpartyVersions) > 0 {
for iNdEx := len(m.CounterpartyVersions) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.CounterpartyVersions[iNdEx])
@ -805,31 +798,25 @@ func (m *MsgConnectionOpenAck) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x30
}
{
size, err := m.ProofConsensus.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.ProofConsensus) > 0 {
i -= len(m.ProofConsensus)
copy(dAtA[i:], m.ProofConsensus)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProofConsensus)))
i--
dAtA[i] = 0x2a
}
i--
dAtA[i] = 0x2a
if m.ProofHeight != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.ProofHeight))
i--
dAtA[i] = 0x20
}
{
size, err := m.ProofTry.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.ProofTry) > 0 {
i -= len(m.ProofTry)
copy(dAtA[i:], m.ProofTry)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProofTry)))
i--
dAtA[i] = 0x1a
}
i--
dAtA[i] = 0x1a
if len(m.Version) > 0 {
i -= len(m.Version)
copy(dAtA[i:], m.Version)
@ -879,16 +866,13 @@ func (m *MsgConnectionOpenConfirm) MarshalToSizedBuffer(dAtA []byte) (int, error
i--
dAtA[i] = 0x18
}
{
size, err := m.ProofAck.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.ProofAck) > 0 {
i -= len(m.ProofAck)
copy(dAtA[i:], m.ProofAck)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProofAck)))
i--
dAtA[i] = 0x12
}
i--
dAtA[i] = 0x12
if len(m.ConnectionID) > 0 {
i -= len(m.ConnectionID)
copy(dAtA[i:], m.ConnectionID)
@ -1095,13 +1079,17 @@ func (m *MsgConnectionOpenTry) Size() (n int) {
n += 1 + l + sovTypes(uint64(l))
}
}
l = m.ProofInit.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProofInit)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
l = m.ProofConsensus.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProofConsensus)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ConsensusHeight != 0 {
n += 1 + sovTypes(uint64(m.ConsensusHeight))
}
@ -1126,13 +1114,17 @@ func (m *MsgConnectionOpenAck) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.ProofTry.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProofTry)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
l = m.ProofConsensus.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProofConsensus)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ConsensusHeight != 0 {
n += 1 + sovTypes(uint64(m.ConsensusHeight))
}
@ -1153,8 +1145,10 @@ func (m *MsgConnectionOpenConfirm) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.ProofAck.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProofAck)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
@ -1579,7 +1573,7 @@ func (m *MsgConnectionOpenTry) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofInit", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -1589,23 +1583,24 @@ func (m *MsgConnectionOpenTry) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ProofInit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProofInit = append(m.ProofInit[:0], dAtA[iNdEx:postIndex]...)
if m.ProofInit == nil {
m.ProofInit = []byte{}
}
iNdEx = postIndex
case 6:
@ -1631,7 +1626,7 @@ func (m *MsgConnectionOpenTry) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofConsensus", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -1641,23 +1636,24 @@ func (m *MsgConnectionOpenTry) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ProofConsensus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProofConsensus = append(m.ProofConsensus[:0], dAtA[iNdEx:postIndex]...)
if m.ProofConsensus == nil {
m.ProofConsensus = []byte{}
}
iNdEx = postIndex
case 8:
@ -1834,7 +1830,7 @@ func (m *MsgConnectionOpenAck) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofTry", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -1844,23 +1840,24 @@ func (m *MsgConnectionOpenAck) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ProofTry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProofTry = append(m.ProofTry[:0], dAtA[iNdEx:postIndex]...)
if m.ProofTry == nil {
m.ProofTry = []byte{}
}
iNdEx = postIndex
case 4:
@ -1886,7 +1883,7 @@ func (m *MsgConnectionOpenAck) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofConsensus", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -1896,23 +1893,24 @@ func (m *MsgConnectionOpenAck) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ProofConsensus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProofConsensus = append(m.ProofConsensus[:0], dAtA[iNdEx:postIndex]...)
if m.ProofConsensus == nil {
m.ProofConsensus = []byte{}
}
iNdEx = postIndex
case 6:
@ -2057,7 +2055,7 @@ func (m *MsgConnectionOpenConfirm) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofAck", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -2067,23 +2065,24 @@ func (m *MsgConnectionOpenConfirm) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ProofAck.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProofAck = append(m.ProofAck[:0], dAtA[iNdEx:postIndex]...)
if m.ProofAck == nil {
m.ProofAck = []byte{}
}
iNdEx = postIndex
case 3:

19
x/ibc/03-connection/types/types.proto
View File

@ -23,12 +23,11 @@ message MsgConnectionOpenTry {
Counterparty counterparty = 3 [(gogoproto.nullable) = false];
repeated string counterparty_versions = 4 [(gogoproto.moretags) = "yaml:\"counterparty_versions\""];
// proof of the initialization the connection on Chain A: `UNITIALIZED -> INIT`
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof_init = 5
[(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"proof_init\""];
bytes proof_init = 5 [(gogoproto.moretags) = "yaml:\"proof_init\""];
uint64 proof_height = 6;
// proof of client consensus state
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof_consensus = 7
[(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"proof_consensus\""];
bytes proof_consensus = 7
[(gogoproto.moretags) = "yaml:\"proof_consensus\""];
uint64 consensus_height = 8 [(gogoproto.moretags) = "yaml:\"consensus_height\""];
bytes signer = 9 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
}
@ -39,12 +38,12 @@ message MsgConnectionOpenAck {
string connection_id = 1 [(gogoproto.customname) = "ConnectionID", (gogoproto.moretags) = "yaml:\"connection_id\""];
string version = 2;
// proof of the initialization the connection on Chain B: `UNITIALIZED -> TRYOPEN`
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof_try = 3
[(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"proof_try\""];
bytes proof_try = 3
[(gogoproto.moretags) = "yaml:\"proof_try\""];
uint64 proof_height = 4 [(gogoproto.moretags) = "yaml:\"proof_height\""];
// proof of client consensus state
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof_consensus = 5
[(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"proof_consensus\""];
bytes proof_consensus = 5
[(gogoproto.moretags) = "yaml:\"proof_consensus\""];
uint64 consensus_height = 6 [(gogoproto.moretags) = "yaml:\"consensus_height\""];
bytes signer = 7 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
}
@ -54,8 +53,8 @@ message MsgConnectionOpenAck {
message MsgConnectionOpenConfirm {
string connection_id = 1 [(gogoproto.customname) = "ConnectionID", (gogoproto.moretags) = "yaml:\"connection_id\""];
// proof for the change of the connection state on Chain A: `INIT -> OPEN`
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof_ack = 2
[(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"proof_ack\""];
bytes proof_ack = 2
[(gogoproto.moretags) = "yaml:\"proof_ack\""];
uint64 proof_height = 3 [(gogoproto.moretags) = "yaml:\"proof_height\""];
bytes signer = 4 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
}

51
x/ibc/04-channel/client/rest/rest.go
View File

@ -6,7 +6,6 @@ import (
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/types/rest"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/types"
)
const (
@ -34,32 +33,32 @@ type ChannelOpenInitReq struct {
// ChannelOpenTryReq defines the properties of a channel open try request's body.
type ChannelOpenTryReq struct {
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
PortID string `json:"port_id" yaml:"port_id"`
ChannelID string `json:"channel_id" yaml:"channel_id"`
Version string `json:"version" yaml:"version"`
ChannelOrder types.Order `json:"channel_order" yaml:"channel_order"`
ConnectionHops []string `json:"connection_hops" yaml:"connection_hops"`
CounterpartyPortID string `json:"counterparty_port_id" yaml:"counterparty_port_id"`
CounterpartyChannelID string `json:"counterparty_channel_id" yaml:"counterparty_channel_id"`
CounterpartyVersion string `json:"counterparty_version" yaml:"counterparty_version"`
ProofInit commitmenttypes.MerkleProof `json:"proof_init" yaml:"proof_init"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
PortID string `json:"port_id" yaml:"port_id"`
ChannelID string `json:"channel_id" yaml:"channel_id"`
Version string `json:"version" yaml:"version"`
ChannelOrder types.Order `json:"channel_order" yaml:"channel_order"`
ConnectionHops []string `json:"connection_hops" yaml:"connection_hops"`
CounterpartyPortID string `json:"counterparty_port_id" yaml:"counterparty_port_id"`
CounterpartyChannelID string `json:"counterparty_channel_id" yaml:"counterparty_channel_id"`
CounterpartyVersion string `json:"counterparty_version" yaml:"counterparty_version"`
ProofInit []byte `json:"proof_init" yaml:"proof_init"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
}
// ChannelOpenAckReq defines the properties of a channel open ack request's body.
type ChannelOpenAckReq struct {
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
CounterpartyVersion string `json:"counterparty_version" yaml:"counterparty_version"`
ProofTry commitmenttypes.MerkleProof `json:"proof_try" yaml:"proof_try"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
CounterpartyVersion string `json:"counterparty_version" yaml:"counterparty_version"`
ProofTry []byte `json:"proof_try" yaml:"proof_try"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
}
// ChannelOpenConfirmReq defines the properties of a channel open confirm request's body.
type ChannelOpenConfirmReq struct {
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
ProofAck commitmenttypes.MerkleProof `json:"proof_ack" yaml:"proof_ack"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
ProofAck []byte `json:"proof_ack" yaml:"proof_ack"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
}
// ConnectionOpenInitReq defines the properties of a channel close init request's body.
@ -69,15 +68,15 @@ type ChannelCloseInitReq struct {
// ChannelCloseConfirmReq defines the properties of a channel close confirm request's body.
type ChannelCloseConfirmReq struct {
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
ProofInit commitmenttypes.MerkleProof `json:"proof_init" yaml:"proof_init"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
ProofInit []byte `json:"proof_init" yaml:"proof_init"`
ProofHeight uint64 `json:"proof_height" yaml:"proof_height"`
}
// RecvPacketReq defines the properties of a receive packet request's body.
type RecvPacketReq struct {
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
Packet types.Packet `json:"packet" yaml:"packet"`
Proofs commitmenttypes.MerkleProof `json:"proofs" yaml:"proofs"`
Height uint64 `json:"height" yaml:"height"`
BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"`
Packet types.Packet `json:"packet" yaml:"packet"`
Proofs []byte `json:"proofs" yaml:"proofs"`
Height uint64 `json:"height" yaml:"height"`
}

9
x/ibc/04-channel/keeper/handshake.go
View File

@ -9,7 +9,6 @@ import (
connection "github.com/cosmos/cosmos-sdk/x/ibc/03-connection"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
porttypes "github.com/cosmos/cosmos-sdk/x/ibc/05-port/types"
commitmentexported "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/exported"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
)
@ -92,7 +91,7 @@ func (k Keeper) ChanOpenTry(
counterparty types.Counterparty,
version,
counterpartyVersion string,
proofInit commitmentexported.Proof,
proofInit []byte,
proofHeight uint64,
) (*capability.Capability, error) {
// channel identifier and connection hop length checked on msg.ValidateBasic()
@ -170,7 +169,7 @@ func (k Keeper) ChanOpenAck(
channelID string,
chanCap *capability.Capability,
counterpartyVersion string,
proofTry commitmentexported.Proof,
proofTry []byte,
proofHeight uint64,
) error {
channel, found := k.GetChannel(ctx, portID, channelID)
@ -237,7 +236,7 @@ func (k Keeper) ChanOpenConfirm(
portID,
channelID string,
chanCap *capability.Capability,
proofAck commitmentexported.Proof,
proofAck []byte,
proofHeight uint64,
) error {
channel, found := k.GetChannel(ctx, portID, channelID)
@ -348,7 +347,7 @@ func (k Keeper) ChanCloseConfirm(
portID,
channelID string,
chanCap *capability.Capability,
proofInit commitmentexported.Proof,
proofInit []byte,
proofHeight uint64,
) error {
if !k.scopedKeeper.AuthenticateCapability(ctx, chanCap, host.ChannelCapabilityPath(portID, channelID)) {

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

@ -299,7 +299,7 @@ func commitBlockWithNewTimestamp(chain *TestChain, timestamp int64) {
}
// nolint: unused
func queryProof(chain *TestChain, key []byte) (commitmenttypes.MerkleProof, uint64) {
func queryProof(chain *TestChain, key []byte) ([]byte, uint64) {
res := chain.App.Query(abci.RequestQuery{
Path: fmt.Sprintf("store/%s/key", host.StoreKey),
Height: chain.App.LastBlockHeight(),
@ -307,10 +307,12 @@ func queryProof(chain *TestChain, key []byte) (commitmenttypes.MerkleProof, uint
Prove: true,
})
proof := commitmenttypes.MerkleProof{
merkleProof := commitmenttypes.MerkleProof{
Proof: res.Proof,
}
proof, _ := chain.App.AppCodec().MarshalBinaryBare(&merkleProof)
return proof, uint64(res.Height)
}

7
x/ibc/04-channel/keeper/packet.go
View File

@ -12,7 +12,6 @@ import (
connection "github.com/cosmos/cosmos-sdk/x/ibc/03-connection"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/exported"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
commitmentexported "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/exported"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
)
@ -141,7 +140,7 @@ func (k Keeper) SendPacket(
func (k Keeper) RecvPacket(
ctx sdk.Context,
packet exported.PacketI,
proof commitmentexported.Proof,
proof []byte,
proofHeight uint64,
) (exported.PacketI, error) {
channel, found := k.GetChannel(ctx, packet.GetDestPort(), packet.GetDestChannel())
@ -312,7 +311,7 @@ func (k Keeper) AcknowledgePacket(
ctx sdk.Context,
packet exported.PacketI,
acknowledgement []byte,
proof commitmentexported.Proof,
proof []byte,
proofHeight uint64,
) (exported.PacketI, error) {
channel, found := k.GetChannel(ctx, packet.GetSourcePort(), packet.GetSourceChannel())
@ -463,7 +462,7 @@ func (k Keeper) CleanupPacket(
ctx sdk.Context,
chanCap *capability.Capability,
packet exported.PacketI,
proof commitmentexported.Proof,
proof []byte,
proofHeight,
nextSequenceRecv uint64,
acknowledgement []byte,

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

@ -8,7 +8,6 @@ import (
connection "github.com/cosmos/cosmos-sdk/x/ibc/03-connection"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/exported"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
commitmentexported "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/exported"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
)
@ -521,7 +520,7 @@ func (suite *KeeperTestSuite) TestCleanupPacket() {
for i, tc := range testCases {
tc := tc
suite.Run(fmt.Sprintf("Case %s, %d/%d tests", tc.msg, i, len(testCases)), func() {
var proof commitmentexported.Proof
var proof []byte
var proofHeight uint64
suite.SetupTest() // reset

5
x/ibc/04-channel/keeper/timeout.go
View File

@ -10,7 +10,6 @@ import (
connection "github.com/cosmos/cosmos-sdk/x/ibc/03-connection"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/exported"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
commitmentexported "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/exported"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
)
@ -23,7 +22,7 @@ import (
func (k Keeper) TimeoutPacket(
ctx sdk.Context,
packet exported.PacketI,
proof commitmentexported.Proof,
proof []byte,
proofHeight,
nextSequenceRecv uint64,
) (exported.PacketI, error) {
@ -170,7 +169,7 @@ func (k Keeper) TimeoutOnClose(
chanCap *capability.Capability,
packet exported.PacketI,
proof,
proofClosed commitmentexported.Proof,
proofClosed []byte,
proofHeight,
nextSequenceRecv uint64,
) (exported.PacketI, error) {

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

@ -6,7 +6,6 @@ import (
"github.com/cosmos/cosmos-sdk/x/capability"
connection "github.com/cosmos/cosmos-sdk/x/ibc/03-connection"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
commitmentexported "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/exported"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
)
@ -242,7 +241,7 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
for i, tc := range testCases {
tc := tc
suite.Run(fmt.Sprintf("Case %s, %d/%d tests", tc.msg, i, len(testCases)), func() {
var proof commitmentexported.Proof
var proof []byte
suite.SetupTest() // reset
tc.malleate()

11
x/ibc/04-channel/types/expected_keepers.go
View File

@ -7,7 +7,6 @@ import (
connectionexported "github.com/cosmos/cosmos-sdk/x/ibc/03-connection/exported"
connectiontypes "github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/exported"
commitmentexported "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/exported"
)
// ClientKeeper expected account IBC client keeper
@ -27,7 +26,7 @@ type ConnectionKeeper interface {
ctx sdk.Context,
connection connectionexported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
channel exported.ChannelI,
@ -36,7 +35,7 @@ type ConnectionKeeper interface {
ctx sdk.Context,
connection connectionexported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
@ -46,7 +45,7 @@ type ConnectionKeeper interface {
ctx sdk.Context,
connection connectionexported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
@ -56,7 +55,7 @@ type ConnectionKeeper interface {
ctx sdk.Context,
connection connectionexported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
@ -65,7 +64,7 @@ type ConnectionKeeper interface {
ctx sdk.Context,
connection connectionexported.ConnectionI,
height uint64,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
nextSequenceRecv uint64,

57
x/ibc/04-channel/types/msgs.go
View File

@ -65,7 +65,7 @@ var _ sdk.Msg = &MsgChannelOpenTry{}
func NewMsgChannelOpenTry(
portID, channelID, version string, channelOrder Order, connectionHops []string,
counterpartyPortID, counterpartyChannelID, counterpartyVersion string,
proofInit commitmenttypes.MerkleProof, proofHeight uint64, signer sdk.AccAddress,
proofInit []byte, proofHeight uint64, signer sdk.AccAddress,
) *MsgChannelOpenTry {
counterparty := NewCounterparty(counterpartyPortID, counterpartyChannelID)
channel := NewChannel(INIT, channelOrder, counterparty, connectionHops, version)
@ -101,11 +101,8 @@ func (msg MsgChannelOpenTry) ValidateBasic() error {
if strings.TrimSpace(msg.CounterpartyVersion) == "" {
return sdkerrors.Wrap(ErrInvalidCounterparty, "counterparty version cannot be blank")
}
if msg.ProofInit.Empty() {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
}
if err := msg.ProofInit.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof init cannot be nil")
if len(msg.ProofInit) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof init")
}
if msg.ProofHeight == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidHeight, "proof height must be > 0")
@ -128,7 +125,7 @@ var _ sdk.Msg = &MsgChannelOpenAck{}
// NewMsgChannelOpenAck creates a new MsgChannelOpenAck instance
func NewMsgChannelOpenAck(
portID, channelID string, cpv string, proofTry commitmenttypes.MerkleProof, proofHeight uint64,
portID, channelID string, cpv string, proofTry []byte, proofHeight uint64,
signer sdk.AccAddress,
) *MsgChannelOpenAck {
return &MsgChannelOpenAck{
@ -162,11 +159,8 @@ func (msg MsgChannelOpenAck) ValidateBasic() error {
if strings.TrimSpace(msg.CounterpartyVersion) == "" {
return sdkerrors.Wrap(ErrInvalidCounterparty, "counterparty version cannot be blank")
}
if msg.ProofTry.Empty() {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
}
if err := msg.ProofTry.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof try cannot be nil")
if len(msg.ProofTry) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof try")
}
if msg.ProofHeight == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidHeight, "proof height must be > 0")
@ -189,7 +183,7 @@ var _ sdk.Msg = &MsgChannelOpenConfirm{}
// NewMsgChannelOpenConfirm creates a new MsgChannelOpenConfirm instance
func NewMsgChannelOpenConfirm(
portID, channelID string, proofAck commitmenttypes.MerkleProof, proofHeight uint64,
portID, channelID string, proofAck []byte, proofHeight uint64,
signer sdk.AccAddress,
) *MsgChannelOpenConfirm {
return &MsgChannelOpenConfirm{
@ -219,11 +213,8 @@ func (msg MsgChannelOpenConfirm) ValidateBasic() error {
if err := host.ChannelIdentifierValidator(msg.ChannelID); err != nil {
return sdkerrors.Wrap(err, "invalid channel ID")
}
if msg.ProofAck.Empty() {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
}
if err := msg.ProofAck.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof ack cannot be nil")
if len(msg.ProofAck) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof ack")
}
if msg.ProofHeight == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidHeight, "proof height must be > 0")
@ -291,7 +282,7 @@ var _ sdk.Msg = &MsgChannelCloseConfirm{}
// NewMsgChannelCloseConfirm creates a new MsgChannelCloseConfirm instance
func NewMsgChannelCloseConfirm(
portID, channelID string, proofInit commitmenttypes.MerkleProof, proofHeight uint64,
portID, channelID string, proofInit []byte, proofHeight uint64,
signer sdk.AccAddress,
) *MsgChannelCloseConfirm {
return &MsgChannelCloseConfirm{
@ -321,11 +312,8 @@ func (msg MsgChannelCloseConfirm) ValidateBasic() error {
if err := host.ChannelIdentifierValidator(msg.ChannelID); err != nil {
return sdkerrors.Wrap(err, "invalid channel ID")
}
if msg.ProofInit.Empty() {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
}
if err := msg.ProofInit.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof init cannot be nil")
if len(msg.ProofInit) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof init")
}
if msg.ProofHeight == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidHeight, "proof height must be > 0")
@ -348,7 +336,7 @@ var _ sdk.Msg = &MsgPacket{}
// NewMsgPacket constructs new MsgPacket
func NewMsgPacket(
packet Packet, proof commitmenttypes.MerkleProof, proofHeight uint64,
packet Packet, proof []byte, proofHeight uint64,
signer sdk.AccAddress,
) *MsgPacket {
return &MsgPacket{
@ -366,12 +354,9 @@ func (msg MsgPacket) Route() string {
// ValidateBasic implements sdk.Msg
func (msg MsgPacket) ValidateBasic() error {
if msg.Proof.Empty() {
if len(msg.Proof) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
}
if err := msg.Proof.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof ack cannot be nil")
}
if msg.ProofHeight == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidHeight, "proof height must be > 0")
}
@ -408,7 +393,7 @@ var _ sdk.Msg = &MsgTimeout{}
// NewMsgTimeout constructs new MsgTimeout
func NewMsgTimeout(
packet Packet, nextSequenceRecv uint64, proof commitmenttypes.MerkleProof,
packet Packet, nextSequenceRecv uint64, proof []byte,
proofHeight uint64, signer sdk.AccAddress,
) *MsgTimeout {
return &MsgTimeout{
@ -427,12 +412,9 @@ func (msg MsgTimeout) Route() string {
// ValidateBasic implements sdk.Msg
func (msg MsgTimeout) ValidateBasic() error {
if msg.Proof.Empty() {
if len(msg.Proof) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
}
if err := msg.Proof.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof ack cannot be nil")
}
if msg.ProofHeight == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidHeight, "proof height must be > 0")
}
@ -462,7 +444,7 @@ var _ sdk.Msg = &MsgAcknowledgement{}
// NewMsgAcknowledgement constructs a new MsgAcknowledgement
func NewMsgAcknowledgement(
packet Packet, ack []byte, proof commitmenttypes.MerkleProof, proofHeight uint64, signer sdk.AccAddress) *MsgAcknowledgement {
packet Packet, ack []byte, proof []byte, proofHeight uint64, signer sdk.AccAddress) *MsgAcknowledgement {
return &MsgAcknowledgement{
Packet: packet,
Acknowledgement: ack,
@ -479,12 +461,9 @@ func (msg MsgAcknowledgement) Route() string {
// ValidateBasic implements sdk.Msg
func (msg MsgAcknowledgement) ValidateBasic() error {
if msg.Proof.Empty() {
if len(msg.Proof) == 0 {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty proof")
}
if err := msg.Proof.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "proof ack cannot be nil")
}
if len(msg.Acknowledgement) > 100 {
return sdkerrors.Wrap(ErrAcknowledgementTooLong, "acknowledgement cannot exceed 100 bytes")
}

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

@ -4,13 +4,12 @@ import (
"fmt"
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto/merkle"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/store/iavl"
"github.com/cosmos/cosmos-sdk/store/rootmulti"
storetypes "github.com/cosmos/cosmos-sdk/store/types"
@ -37,23 +36,45 @@ const (
// define variables used for testing
var (
timeoutHeight = uint64(100)
timeoutTimestamp = uint64(100)
disabledTimeout = uint64(0)
validPacketData = []byte("testdata")
unknownPacketData = []byte("unknown")
invalidAckData = []byte("123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890")
packet = types.NewPacket(validPacketData, 1, portid, chanid, cpportid, cpchanid, timeoutHeight, timeoutTimestamp)
unknownPacket = types.NewPacket(unknownPacketData, 0, portid, chanid, cpportid, cpchanid, timeoutHeight, timeoutTimestamp)
invalidAck = invalidAckData
emptyProof = []byte{}
invalidProofs1 = commitmentexported.Proof(nil)
invalidProofs2 = emptyProof
addr1 = sdk.AccAddress("testaddr1")
emptyAddr sdk.AccAddress
portid = "testportid"
chanid = "testchannel"
cpportid = "testcpport"
cpchanid = "testcpchannel"
connHops = []string{"testconnection"}
invalidConnHops = []string{"testconnection", "testconnection"}
invalidShortConnHops = []string{invalidShortConnection}
invalidLongConnHops = []string{invalidLongConnection}
proof = commitmenttypes.MerkleProof{Proof: &merkle.Proof{Ops: []merkle.ProofOp{{Type: "proof", Key: []byte("key"), Data: []byte("data")}}}}
addr = sdk.AccAddress("testaddr")
)
type MsgTestSuite struct {
suite.Suite
proof commitmenttypes.MerkleProof
proof []byte
}
func (suite *MsgTestSuite) SetupTest() {
app := simapp.Setup(false)
db := dbm.NewMemDB()
store := rootmulti.NewStore(db)
storeKey := storetypes.NewKVStoreKey("iavlStoreKey")
@ -71,7 +92,11 @@ func (suite *MsgTestSuite) SetupTest() {
Prove: true,
})
suite.proof = commitmenttypes.MerkleProof{Proof: res.Proof}
merkleProof := commitmenttypes.MerkleProof{Proof: res.Proof}
proof, err := app.AppCodec().MarshalBinaryBare(&merkleProof)
suite.NoError(err)
suite.proof = proof
}
func TestMsgTestSuite(t *testing.T) {
@ -150,6 +175,7 @@ func (suite *MsgTestSuite) TestMsgChannelOpenTry() {
types.NewMsgChannelOpenTry("testportid", "testchannel", "", types.UNORDERED, connHops, "testcpport", "testcpchannel", "1.0", suite.proof, 1, addr), // empty channel version
types.NewMsgChannelOpenTry("testportid", "testchannel", "1.0", types.UNORDERED, connHops, invalidPort, "testcpchannel", "1.0", suite.proof, 1, addr), // invalid counterparty port id
types.NewMsgChannelOpenTry("testportid", "testchannel", "1.0", types.UNORDERED, connHops, "testcpport", invalidChannel, "1.0", suite.proof, 1, addr), // invalid counterparty channel id
types.NewMsgChannelOpenTry("testportid", "testchannel", "1.0", types.UNORDERED, connHops, "testcpport", "testcpchannel", "1.0", emptyProof, 1, addr), // empty proof
}
testCases := []struct {
@ -174,6 +200,7 @@ func (suite *MsgTestSuite) TestMsgChannelOpenTry() {
{testMsgs[14], false, "empty channel version"},
{testMsgs[15], false, "invalid counterparty port id"},
{testMsgs[16], false, "invalid counterparty channel id"},
{testMsgs[17], false, "empty proof"},
}
for i, tc := range testCases {
@ -189,16 +216,16 @@ func (suite *MsgTestSuite) TestMsgChannelOpenTry() {
// TestMsgChannelOpenAck tests ValidateBasic for MsgChannelOpenAck
func (suite *MsgTestSuite) TestMsgChannelOpenAck() {
testMsgs := []*types.MsgChannelOpenAck{
types.NewMsgChannelOpenAck("testportid", "testchannel", "1.0", suite.proof, 1, addr), // valid msg
types.NewMsgChannelOpenAck(invalidShortPort, "testchannel", "1.0", suite.proof, 1, addr), // too short port id
types.NewMsgChannelOpenAck(invalidLongPort, "testchannel", "1.0", suite.proof, 1, addr), // too long port id
types.NewMsgChannelOpenAck(invalidPort, "testchannel", "1.0", suite.proof, 1, addr), // port id contains non-alpha
types.NewMsgChannelOpenAck("testportid", invalidShortChannel, "1.0", suite.proof, 1, addr), // too short channel id
types.NewMsgChannelOpenAck("testportid", invalidLongChannel, "1.0", suite.proof, 1, addr), // too long channel id
types.NewMsgChannelOpenAck("testportid", invalidChannel, "1.0", suite.proof, 1, addr), // channel id contains non-alpha
types.NewMsgChannelOpenAck("testportid", "testchannel", "", suite.proof, 1, addr), // empty counterparty version
types.NewMsgChannelOpenAck("testportid", "testchannel", "1.0", commitmenttypes.MerkleProof{Proof: nil}, 1, addr), // empty proof
types.NewMsgChannelOpenAck("testportid", "testchannel", "1.0", suite.proof, 0, addr), // proof height is zero
types.NewMsgChannelOpenAck("testportid", "testchannel", "1.0", suite.proof, 1, addr), // valid msg
types.NewMsgChannelOpenAck(invalidShortPort, "testchannel", "1.0", suite.proof, 1, addr), // too short port id
types.NewMsgChannelOpenAck(invalidLongPort, "testchannel", "1.0", suite.proof, 1, addr), // too long port id
types.NewMsgChannelOpenAck(invalidPort, "testchannel", "1.0", suite.proof, 1, addr), // port id contains non-alpha
types.NewMsgChannelOpenAck("testportid", invalidShortChannel, "1.0", suite.proof, 1, addr), // too short channel id
types.NewMsgChannelOpenAck("testportid", invalidLongChannel, "1.0", suite.proof, 1, addr), // too long channel id
types.NewMsgChannelOpenAck("testportid", invalidChannel, "1.0", suite.proof, 1, addr), // channel id contains non-alpha
types.NewMsgChannelOpenAck("testportid", "testchannel", "", suite.proof, 1, addr), // empty counterparty version
types.NewMsgChannelOpenAck("testportid", "testchannel", "1.0", emptyProof, 1, addr), // empty proof
types.NewMsgChannelOpenAck("testportid", "testchannel", "1.0", suite.proof, 0, addr), // proof height is zero
}
testCases := []struct {
@ -231,15 +258,15 @@ func (suite *MsgTestSuite) TestMsgChannelOpenAck() {
// TestMsgChannelOpenConfirm tests ValidateBasic for MsgChannelOpenConfirm
func (suite *MsgTestSuite) TestMsgChannelOpenConfirm() {
testMsgs := []*types.MsgChannelOpenConfirm{
types.NewMsgChannelOpenConfirm("testportid", "testchannel", suite.proof, 1, addr), // valid msg
types.NewMsgChannelOpenConfirm(invalidShortPort, "testchannel", suite.proof, 1, addr), // too short port id
types.NewMsgChannelOpenConfirm(invalidLongPort, "testchannel", suite.proof, 1, addr), // too long port id
types.NewMsgChannelOpenConfirm(invalidPort, "testchannel", suite.proof, 1, addr), // port id contains non-alpha
types.NewMsgChannelOpenConfirm("testportid", invalidShortChannel, suite.proof, 1, addr), // too short channel id
types.NewMsgChannelOpenConfirm("testportid", invalidLongChannel, suite.proof, 1, addr), // too long channel id
types.NewMsgChannelOpenConfirm("testportid", invalidChannel, suite.proof, 1, addr), // channel id contains non-alpha
types.NewMsgChannelOpenConfirm("testportid", "testchannel", commitmenttypes.MerkleProof{Proof: nil}, 1, addr), // empty proof
types.NewMsgChannelOpenConfirm("testportid", "testchannel", suite.proof, 0, addr), // proof height is zero
types.NewMsgChannelOpenConfirm("testportid", "testchannel", suite.proof, 1, addr), // valid msg
types.NewMsgChannelOpenConfirm(invalidShortPort, "testchannel", suite.proof, 1, addr), // too short port id
types.NewMsgChannelOpenConfirm(invalidLongPort, "testchannel", suite.proof, 1, addr), // too long port id
types.NewMsgChannelOpenConfirm(invalidPort, "testchannel", suite.proof, 1, addr), // port id contains non-alpha
types.NewMsgChannelOpenConfirm("testportid", invalidShortChannel, suite.proof, 1, addr), // too short channel id
types.NewMsgChannelOpenConfirm("testportid", invalidLongChannel, suite.proof, 1, addr), // too long channel id
types.NewMsgChannelOpenConfirm("testportid", invalidChannel, suite.proof, 1, addr), // channel id contains non-alpha
types.NewMsgChannelOpenConfirm("testportid", "testchannel", emptyProof, 1, addr), // empty proof
types.NewMsgChannelOpenConfirm("testportid", "testchannel", suite.proof, 0, addr), // proof height is zero
}
testCases := []struct {
@ -307,15 +334,15 @@ func (suite *MsgTestSuite) TestMsgChannelCloseInit() {
// TestMsgChannelCloseConfirm tests ValidateBasic for MsgChannelCloseConfirm
func (suite *MsgTestSuite) TestMsgChannelCloseConfirm() {
testMsgs := []*types.MsgChannelCloseConfirm{
types.NewMsgChannelCloseConfirm("testportid", "testchannel", suite.proof, 1, addr), // valid msg
types.NewMsgChannelCloseConfirm(invalidShortPort, "testchannel", suite.proof, 1, addr), // too short port id
types.NewMsgChannelCloseConfirm(invalidLongPort, "testchannel", suite.proof, 1, addr), // too long port id
types.NewMsgChannelCloseConfirm(invalidPort, "testchannel", suite.proof, 1, addr), // port id contains non-alpha
types.NewMsgChannelCloseConfirm("testportid", invalidShortChannel, suite.proof, 1, addr), // too short channel id
types.NewMsgChannelCloseConfirm("testportid", invalidLongChannel, suite.proof, 1, addr), // too long channel id
types.NewMsgChannelCloseConfirm("testportid", invalidChannel, suite.proof, 1, addr), // channel id contains non-alpha
types.NewMsgChannelCloseConfirm("testportid", "testchannel", commitmenttypes.MerkleProof{Proof: nil}, 1, addr), // empty proof
types.NewMsgChannelCloseConfirm("testportid", "testchannel", suite.proof, 0, addr), // proof height is zero
types.NewMsgChannelCloseConfirm("testportid", "testchannel", suite.proof, 1, addr), // valid msg
types.NewMsgChannelCloseConfirm(invalidShortPort, "testchannel", suite.proof, 1, addr), // too short port id
types.NewMsgChannelCloseConfirm(invalidLongPort, "testchannel", suite.proof, 1, addr), // too long port id
types.NewMsgChannelCloseConfirm(invalidPort, "testchannel", suite.proof, 1, addr), // port id contains non-alpha
types.NewMsgChannelCloseConfirm("testportid", invalidShortChannel, suite.proof, 1, addr), // too short channel id
types.NewMsgChannelCloseConfirm("testportid", invalidLongChannel, suite.proof, 1, addr), // too long channel id
types.NewMsgChannelCloseConfirm("testportid", invalidChannel, suite.proof, 1, addr), // channel id contains non-alpha
types.NewMsgChannelCloseConfirm("testportid", "testchannel", emptyProof, 1, addr), // empty proof
types.NewMsgChannelCloseConfirm("testportid", "testchannel", suite.proof, 0, addr), // proof height is zero
}
testCases := []struct {
@ -344,47 +371,21 @@ func (suite *MsgTestSuite) TestMsgChannelCloseConfirm() {
}
}
// define variables used for testing
var (
timeoutHeight = uint64(100)
timeoutTimestamp = uint64(100)
disabledTimeout = uint64(0)
validPacketData = []byte("testdata")
unknownPacketData = []byte("unknown")
invalidAckData = []byte("123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890")
// TestMsgPacketType tests Type for MsgPacket.
func (suite *MsgTestSuite) TestMsgPacketType() {
msg := types.NewMsgPacket(packet, suite.proof, 1, addr1)
packet = types.NewPacket(validPacketData, 1, portid, chanid, cpportid, cpchanid, timeoutHeight, timeoutTimestamp)
unknownPacket = types.NewPacket(unknownPacketData, 0, portid, chanid, cpportid, cpchanid, timeoutHeight, timeoutTimestamp)
invalidAck = invalidAckData
emptyProof = commitmenttypes.MerkleProof{Proof: nil}
invalidProofs1 = commitmentexported.Proof(nil)
invalidProofs2 = emptyProof
addr1 = sdk.AccAddress("testaddr1")
emptyAddr sdk.AccAddress
portid = "testportid"
chanid = "testchannel"
cpportid = "testcpport"
cpchanid = "testcpchannel"
)
// TestMsgPacketType tests Type for MsgPacket
func TestMsgPacketType(t *testing.T) {
msg := types.NewMsgPacket(packet, proof, 1, addr1)
require.Equal(t, []byte("testdata"), msg.Packet.GetData())
suite.Equal("ics04/opaque", msg.Type())
}
// TestMsgPacketValidation tests ValidateBasic for MsgPacket
func TestMsgPacketValidation(t *testing.T) {
func (suite *MsgTestSuite) TestMsgPacketValidation() {
testMsgs := []*types.MsgPacket{
types.NewMsgPacket(packet, proof, 1, addr1), // valid msg
types.NewMsgPacket(packet, proof, 0, addr1), // proof height is zero
types.NewMsgPacket(packet, invalidProofs2, 1, addr1), // proof contain empty proof
types.NewMsgPacket(packet, proof, 1, emptyAddr), // missing signer address
types.NewMsgPacket(unknownPacket, proof, 1, addr1), // unknown packet
types.NewMsgPacket(packet, suite.proof, 1, addr1), // valid msg
types.NewMsgPacket(packet, suite.proof, 0, addr1), // proof height is zero
types.NewMsgPacket(packet, emptyProof, 1, addr1), // empty proof
types.NewMsgPacket(packet, suite.proof, 1, emptyAddr), // missing signer address
types.NewMsgPacket(unknownPacket, suite.proof, 1, addr1), // unknown packet
}
testCases := []struct {
@ -402,42 +403,42 @@ func TestMsgPacketValidation(t *testing.T) {
for i, tc := range testCases {
err := tc.msg.ValidateBasic()
if tc.expPass {
require.NoError(t, err, "Msg %d failed: %v", i, err)
suite.NoError(err, "Msg %d failed: %v", i, err)
} else {
require.Error(t, err, "Invalid Msg %d passed: %s", i, tc.errMsg)
suite.Error(err, "Invalid Msg %d passed: %s", i, tc.errMsg)
}
}
}
// TestMsgPacketGetSignBytes tests GetSignBytes for MsgPacket
func TestMsgPacketGetSignBytes(t *testing.T) {
msg := types.NewMsgPacket(packet, proof, 1, addr1)
func (suite *MsgTestSuite) TestMsgPacketGetSignBytes() {
msg := types.NewMsgPacket(packet, suite.proof, 1, addr1)
res := msg.GetSignBytes()
expected := fmt.Sprintf(
`{"type":"ibc/channel/MsgPacket","value":{"packet":{"data":%s,"destination_channel":"testcpchannel","destination_port":"testcpport","sequence":"1","source_channel":"testchannel","source_port":"testportid","timeout_height":"100","timeout_timestamp":"100"},"proof":{"proof":{"ops":[{"data":"ZGF0YQ==","key":"a2V5","type":"proof"}]}},"proof_height":"1","signer":"cosmos1w3jhxarpv3j8yvg4ufs4x"}}`,
`{"type":"ibc/channel/MsgPacket","value":{"packet":{"data":%s,"destination_channel":"testcpchannel","destination_port":"testcpport","sequence":"1","source_channel":"testchannel","source_port":"testportid","timeout_height":"100","timeout_timestamp":"100"},"proof":"Co0BCi4KCmljczIzOmlhdmwSA0tFWRobChkKA0tFWRIFVkFMVUUaCwgBGAEgASoDAAICClsKDGljczIzOnNpbXBsZRIMaWF2bFN0b3JlS2V5Gj0KOwoMaWF2bFN0b3JlS2V5EiAcIiDXSHQRSvh/Wa07MYpTK0B4XtbaXtzxBED76xk0WhoJCAEYASABKgEA","proof_height":"1","signer":"cosmos1w3jhxarpv3j8yvg4ufs4x"}}`,
string(msg.GetDataSignBytes()),
)
require.Equal(t, expected, string(res))
suite.Equal(expected, string(res))
}
// TestMsgPacketGetSigners tests GetSigners for MsgPacket
func TestMsgPacketGetSigners(t *testing.T) {
msg := types.NewMsgPacket(packet, proof, 1, addr1)
func (suite *MsgTestSuite) TestMsgPacketGetSigners() {
msg := types.NewMsgPacket(packet, suite.proof, 1, addr1)
res := msg.GetSigners()
expected := "[746573746164647231]"
require.Equal(t, expected, fmt.Sprintf("%v", res))
suite.Equal(expected, fmt.Sprintf("%v", res))
}
// TestMsgTimeout tests ValidateBasic for MsgTimeout
func (suite *MsgTestSuite) TestMsgTimeout() {
testMsgs := []*types.MsgTimeout{
types.NewMsgTimeout(packet, 1, proof, 1, addr),
types.NewMsgTimeout(packet, 1, proof, 0, addr),
types.NewMsgTimeout(packet, 1, proof, 1, emptyAddr),
types.NewMsgTimeout(packet, 1, suite.proof, 1, addr),
types.NewMsgTimeout(packet, 1, suite.proof, 0, addr),
types.NewMsgTimeout(packet, 1, suite.proof, 1, emptyAddr),
types.NewMsgTimeout(packet, 1, emptyProof, 1, addr),
types.NewMsgTimeout(unknownPacket, 1, proof, 1, addr),
types.NewMsgTimeout(unknownPacket, 1, suite.proof, 1, addr),
}
testCases := []struct {
@ -465,12 +466,12 @@ func (suite *MsgTestSuite) TestMsgTimeout() {
// TestMsgAcknowledgement tests ValidateBasic for MsgAcknowledgement
func (suite *MsgTestSuite) TestMsgAcknowledgement() {
testMsgs := []*types.MsgAcknowledgement{
types.NewMsgAcknowledgement(packet, packet.GetData(), proof, 1, addr),
types.NewMsgAcknowledgement(packet, packet.GetData(), proof, 0, addr),
types.NewMsgAcknowledgement(packet, packet.GetData(), proof, 1, emptyAddr),
types.NewMsgAcknowledgement(packet, packet.GetData(), suite.proof, 1, addr),
types.NewMsgAcknowledgement(packet, packet.GetData(), suite.proof, 0, addr),
types.NewMsgAcknowledgement(packet, packet.GetData(), suite.proof, 1, emptyAddr),
types.NewMsgAcknowledgement(packet, packet.GetData(), emptyProof, 1, addr),
types.NewMsgAcknowledgement(unknownPacket, packet.GetData(), proof, 1, addr),
types.NewMsgAcknowledgement(packet, invalidAck, proof, 1, addr),
types.NewMsgAcknowledgement(unknownPacket, packet.GetData(), suite.proof, 1, addr),
types.NewMsgAcknowledgement(packet, invalidAck, suite.proof, 1, addr),
}
testCases := []struct {

440
x/ibc/04-channel/types/types.pb.go
View File

@ -6,7 +6,6 @@ package types
import (
fmt "fmt"
github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
types "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/types"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
@ -176,7 +175,7 @@ type MsgChannelOpenTry struct {
ChannelID string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty" yaml:"channel_id"`
Channel Channel `protobuf:"bytes,3,opt,name=channel,proto3" json:"channel"`
CounterpartyVersion string `protobuf:"bytes,4,opt,name=counterparty_version,json=counterpartyVersion,proto3" json:"counterparty_version,omitempty" yaml:"counterparty_version"`
ProofInit types.MerkleProof `protobuf:"bytes,5,opt,name=proof_init,json=proofInit,proto3" json:"proof_init" yaml:"proof_init"`
ProofInit []byte `protobuf:"bytes,5,opt,name=proof_init,json=proofInit,proto3" json:"proof_init,omitempty" yaml:"proof_init"`
ProofHeight uint64 `protobuf:"varint,6,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,7,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
}
@ -242,11 +241,11 @@ func (m *MsgChannelOpenTry) GetCounterpartyVersion() string {
return ""
}
func (m *MsgChannelOpenTry) GetProofInit() types.MerkleProof {
func (m *MsgChannelOpenTry) GetProofInit() []byte {
if m != nil {
return m.ProofInit
}
return types.MerkleProof{}
return nil
}
func (m *MsgChannelOpenTry) GetProofHeight() uint64 {
@ -269,7 +268,7 @@ type MsgChannelOpenAck struct {
PortID string `protobuf:"bytes,1,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty" yaml:"port_id"`
ChannelID string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty" yaml:"channel_id"`
CounterpartyVersion string `protobuf:"bytes,3,opt,name=counterparty_version,json=counterpartyVersion,proto3" json:"counterparty_version,omitempty" yaml:"counterparty_version"`
ProofTry types.MerkleProof `protobuf:"bytes,4,opt,name=proof_try,json=proofTry,proto3" json:"proof_try" yaml:"proof_try"`
ProofTry []byte `protobuf:"bytes,4,opt,name=proof_try,json=proofTry,proto3" json:"proof_try,omitempty" yaml:"proof_try"`
ProofHeight uint64 `protobuf:"varint,5,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,6,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
}
@ -328,11 +327,11 @@ func (m *MsgChannelOpenAck) GetCounterpartyVersion() string {
return ""
}
func (m *MsgChannelOpenAck) GetProofTry() types.MerkleProof {
func (m *MsgChannelOpenAck) GetProofTry() []byte {
if m != nil {
return m.ProofTry
}
return types.MerkleProof{}
return nil
}
func (m *MsgChannelOpenAck) GetProofHeight() uint64 {
@ -354,7 +353,7 @@ func (m *MsgChannelOpenAck) GetSigner() github_com_cosmos_cosmos_sdk_types.AccAd
type MsgChannelOpenConfirm struct {
PortID string `protobuf:"bytes,1,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty" yaml:"port_id"`
ChannelID string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty" yaml:"channel_id"`
ProofAck types.MerkleProof `protobuf:"bytes,3,opt,name=proof_ack,json=proofAck,proto3" json:"proof_ack" yaml:"proof_ack"`
ProofAck []byte `protobuf:"bytes,3,opt,name=proof_ack,json=proofAck,proto3" json:"proof_ack,omitempty" yaml:"proof_ack"`
ProofHeight uint64 `protobuf:"varint,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,5,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
}
@ -406,11 +405,11 @@ func (m *MsgChannelOpenConfirm) GetChannelID() string {
return ""
}
func (m *MsgChannelOpenConfirm) GetProofAck() types.MerkleProof {
func (m *MsgChannelOpenConfirm) GetProofAck() []byte {
if m != nil {
return m.ProofAck
}
return types.MerkleProof{}
return nil
}
func (m *MsgChannelOpenConfirm) GetProofHeight() uint64 {
@ -494,7 +493,7 @@ func (m *MsgChannelCloseInit) GetSigner() github_com_cosmos_cosmos_sdk_types.Acc
type MsgChannelCloseConfirm struct {
PortID string `protobuf:"bytes,1,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty" yaml:"port_id"`
ChannelID string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty" yaml:"channel_id"`
ProofInit types.MerkleProof `protobuf:"bytes,3,opt,name=proof_init,json=proofInit,proto3" json:"proof_init" yaml:"proof_init"`
ProofInit []byte `protobuf:"bytes,3,opt,name=proof_init,json=proofInit,proto3" json:"proof_init,omitempty" yaml:"proof_init"`
ProofHeight uint64 `protobuf:"varint,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,5,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
}
@ -546,11 +545,11 @@ func (m *MsgChannelCloseConfirm) GetChannelID() string {
return ""
}
func (m *MsgChannelCloseConfirm) GetProofInit() types.MerkleProof {
func (m *MsgChannelCloseConfirm) GetProofInit() []byte {
if m != nil {
return m.ProofInit
}
return types.MerkleProof{}
return nil
}
func (m *MsgChannelCloseConfirm) GetProofHeight() uint64 {
@ -570,7 +569,7 @@ func (m *MsgChannelCloseConfirm) GetSigner() github_com_cosmos_cosmos_sdk_types.
// MsgPacket receives incoming IBC packet
type MsgPacket struct {
Packet Packet `protobuf:"bytes,1,opt,name=packet,proto3" json:"packet"`
Proof types.MerkleProof `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof"`
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
ProofHeight uint64 `protobuf:"varint,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,4,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
}
@ -615,11 +614,11 @@ func (m *MsgPacket) GetPacket() Packet {
return Packet{}
}
func (m *MsgPacket) GetProof() types.MerkleProof {
func (m *MsgPacket) GetProof() []byte {
if m != nil {
return m.Proof
}
return types.MerkleProof{}
return nil
}
func (m *MsgPacket) GetProofHeight() uint64 {
@ -639,7 +638,7 @@ func (m *MsgPacket) GetSigner() github_com_cosmos_cosmos_sdk_types.AccAddress {
// MsgTimeout receives timed-out packet
type MsgTimeout struct {
Packet Packet `protobuf:"bytes,1,opt,name=packet,proto3" json:"packet"`
Proof types.MerkleProof `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof"`
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
ProofHeight uint64 `protobuf:"varint,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
NextSequenceRecv uint64 `protobuf:"varint,4,opt,name=next_sequence_recv,json=nextSequenceRecv,proto3" json:"next_sequence_recv,omitempty" yaml:"next_sequence_recv"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,5,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
@ -685,11 +684,11 @@ func (m *MsgTimeout) GetPacket() Packet {
return Packet{}
}
func (m *MsgTimeout) GetProof() types.MerkleProof {
func (m *MsgTimeout) GetProof() []byte {
if m != nil {
return m.Proof
}
return types.MerkleProof{}
return nil
}
func (m *MsgTimeout) GetProofHeight() uint64 {
@ -717,7 +716,7 @@ func (m *MsgTimeout) GetSigner() github_com_cosmos_cosmos_sdk_types.AccAddress {
type MsgAcknowledgement struct {
Packet Packet `protobuf:"bytes,1,opt,name=packet,proto3" json:"packet"`
Acknowledgement []byte `protobuf:"bytes,2,opt,name=acknowledgement,proto3" json:"acknowledgement,omitempty"`
Proof types.MerkleProof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof"`
Proof []byte `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
ProofHeight uint64 `protobuf:"varint,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty" yaml:"proof_height"`
Signer github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,5,opt,name=signer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"signer,omitempty"`
}
@ -769,11 +768,11 @@ func (m *MsgAcknowledgement) GetAcknowledgement() []byte {
return nil
}
func (m *MsgAcknowledgement) GetProof() types.MerkleProof {
func (m *MsgAcknowledgement) GetProof() []byte {
if m != nil {
return m.Proof
}
return types.MerkleProof{}
return nil
}
func (m *MsgAcknowledgement) GetProofHeight() uint64 {
@ -958,87 +957,84 @@ func init() {
}
var fileDescriptor_a69005b45bd92d03 = []byte{
// 1265 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcd, 0x6f, 0x1b, 0x45,
0x1b, 0xf7, 0xfa, 0x33, 0x7e, 0xf2, 0xe5, 0x4c, 0xde, 0xa6, 0xae, 0xdb, 0xd7, 0x6b, 0x2d, 0x05,
0x85, 0xa2, 0x38, 0x34, 0xe5, 0x4b, 0x3d, 0x20, 0xec, 0xd8, 0xa5, 0x16, 0x8d, 0x1d, 0x4d, 0x5c,
0x24, 0x7a, 0x59, 0x39, 0xbb, 0x53, 0x67, 0xe5, 0x78, 0xc7, 0xec, 0x4e, 0xd2, 0xe6, 0xc6, 0xb1,
0xca, 0x01, 0x71, 0xe1, 0x18, 0x40, 0xe2, 0x8f, 0xe0, 0xc4, 0xbd, 0x07, 0x0e, 0xe5, 0x86, 0x38,
0x2c, 0x28, 0xbd, 0x72, 0xf2, 0x11, 0x71, 0x40, 0x3b, 0x33, 0x6b, 0xaf, 0x9d, 0x12, 0xd4, 0xba,
0xc2, 0x82, 0x8b, 0x77, 0x9e, 0xcf, 0xf9, 0xcd, 0xef, 0x79, 0x66, 0x76, 0xbc, 0xa0, 0x3d, 0x5c,
0xb7, 0x76, 0x8d, 0xf5, 0x37, 0xdf, 0x5a, 0x33, 0xf6, 0x5a, 0xb6, 0x4d, 0xf6, 0xd7, 0xd9, 0x51,
0x8f, 0xb8, 0xe2, 0xb7, 0xd8, 0x73, 0x28, 0xa3, 0xe8, 0xb2, 0x41, 0xdd, 0x2e, 0x75, 0x75, 0xd7,
0xec, 0x14, 0x1f, 0x16, 0xad, 0x5d, 0xa3, 0x28, 0x7d, 0x8b, 0x87, 0xd7, 0x73, 0xaf, 0xb1, 0x3d,
0xcb, 0x31, 0xf5, 0x5e, 0xcb, 0x61, 0x47, 0xeb, 0xdc, 0x7f, 0xbd, 0x4d, 0xdb, 0x74, 0x38, 0x12,
0x49, 0x72, 0xaf, 0x8a, 0x89, 0x36, 0x6e, 0xac, 0x19, 0xb4, 0xdb, 0xb5, 0x58, 0x97, 0xd8, 0xec,
0xec, 0x5c, 0xda, 0xd7, 0x51, 0x40, 0x5b, 0x6e, 0x7b, 0x53, 0x4c, 0xd0, 0xe8, 0x11, 0xbb, 0x66,
0x5b, 0x0c, 0xbd, 0x0d, 0xa9, 0x1e, 0x75, 0x98, 0x6e, 0x99, 0x59, 0xa5, 0xa0, 0xac, 0xa6, 0xcb,
0x57, 0x4e, 0x3d, 0x35, 0xb9, 0x4d, 0x1d, 0x56, 0xab, 0xf4, 0x3d, 0x75, 0xe1, 0xa8, 0xd5, 0xdd,
0xbf, 0xa9, 0x49, 0x17, 0x0d, 0x27, 0xfd, 0x51, 0xcd, 0x44, 0x25, 0x00, 0x09, 0xd5, 0x8f, 0x8c,
0xf2, 0x48, 0xed, 0xd4, 0x53, 0xd3, 0x32, 0x3f, 0x0f, 0x5e, 0x12, 0xc1, 0x43, 0x47, 0x0d, 0xa7,
0xa5, 0x50, 0x33, 0x51, 0x05, 0x52, 0x52, 0xc8, 0xc6, 0x0a, 0xca, 0xea, 0xec, 0xc6, 0xd5, 0xe2,
0x39, 0x74, 0x14, 0x65, 0xe2, 0x72, 0xfc, 0xb1, 0xa7, 0x46, 0x70, 0x10, 0x8a, 0x6a, 0x90, 0x74,
0xad, 0xb6, 0x4d, 0x9c, 0x6c, 0xbc, 0xa0, 0xac, 0xce, 0x95, 0xaf, 0xff, 0xee, 0xa9, 0x6b, 0x6d,
0x8b, 0xed, 0x1d, 0xec, 0x16, 0x0d, 0xda, 0x5d, 0x17, 0x29, 0xe5, 0x63, 0xcd, 0x35, 0x3b, 0x92,
0x94, 0x92, 0x61, 0x94, 0x4c, 0xd3, 0x21, 0xae, 0x8b, 0x65, 0x02, 0xed, 0xcb, 0x38, 0x2c, 0x8d,
0x32, 0xd4, 0x74, 0x8e, 0xfe, 0xf5, 0x04, 0x61, 0xf8, 0x9f, 0x41, 0x0f, 0x6c, 0x46, 0x1c, 0xde,
0x49, 0xfa, 0x21, 0x71, 0x5c, 0x8b, 0xda, 0x9c, 0xae, 0x74, 0x59, 0xed, 0x7b, 0xea, 0x65, 0x89,
0xe2, 0x19, 0x5e, 0x1a, 0x5e, 0x0e, 0xab, 0x3f, 0x16, 0x5a, 0x44, 0x00, 0x7a, 0x0e, 0xa5, 0xf7,
0x75, 0xcb, 0xb6, 0x58, 0x36, 0xc1, 0xc1, 0xbd, 0xf1, 0x0c, 0x70, 0x83, 0x7e, 0xf4, 0xf1, 0x6d,
0x11, 0xa7, 0xb3, 0x4f, 0xb6, 0xfd, 0xb8, 0xf2, 0x25, 0x1f, 0xe3, 0x90, 0x80, 0x61, 0x32, 0x0d,
0xa7, 0xb9, 0xc0, 0x7b, 0xf3, 0x26, 0xcc, 0x09, 0xcb, 0x1e, 0xb1, 0xda, 0x7b, 0x2c, 0x9b, 0x2c,
0x28, 0xab, 0xf1, 0xf2, 0xc5, 0xbe, 0xa7, 0x2e, 0x87, 0xe3, 0x84, 0x55, 0xc3, 0xb3, 0x5c, 0xbc,
0xcd, 0xa5, 0x50, 0x5f, 0xa4, 0x26, 0xed, 0x8b, 0x1f, 0x62, 0xe3, 0x7d, 0x51, 0x32, 0x3a, 0x53,
0xec, 0x8b, 0xbf, 0xaa, 0x68, 0x6c, 0x82, 0x8a, 0xee, 0x82, 0xe0, 0x5d, 0x67, 0xce, 0x11, 0x6f,
0x8d, 0xe7, 0x2c, 0x68, 0x56, 0x16, 0x34, 0x13, 0x2e, 0x0c, 0x73, 0x8e, 0x34, 0x3c, 0xc3, 0xc7,
0xfe, 0x4e, 0x1a, 0x2f, 0x67, 0xe2, 0x85, 0xca, 0x99, 0x9c, 0xb4, 0x9c, 0x7f, 0x44, 0xe1, 0xc2,
0x68, 0x39, 0x37, 0xa9, 0x7d, 0xdf, 0x72, 0xba, 0x53, 0x2c, 0xe9, 0x80, 0xfe, 0x96, 0xd1, 0x91,
0x9b, 0x7d, 0x72, 0xfa, 0x5b, 0x46, 0x27, 0xa0, 0xdf, 0x6f, 0xd8, 0x71, 0xfa, 0xe3, 0x2f, 0x44,
0x7f, 0x62, 0x52, 0xfa, 0x7f, 0x56, 0x60, 0x79, 0x48, 0xff, 0xe6, 0x3e, 0x75, 0xc9, 0x94, 0x5f,
0x44, 0xc3, 0xc5, 0xc5, 0x26, 0x5d, 0xdc, 0x67, 0x31, 0x58, 0x19, 0x5b, 0xdc, 0xf4, 0x9b, 0x6b,
0xf4, 0xb4, 0x8e, 0xfd, 0x53, 0xa7, 0xf5, 0x94, 0xfa, 0xeb, 0xab, 0x28, 0xa4, 0xb7, 0xdc, 0xf6,
0x76, 0xcb, 0xe8, 0x10, 0x86, 0x4a, 0x90, 0xec, 0xf1, 0x11, 0x27, 0x7d, 0x76, 0xe3, 0x95, 0x73,
0x5f, 0xa1, 0x22, 0x48, 0xbe, 0x41, 0x65, 0x20, 0xfa, 0x10, 0x12, 0x1c, 0x2a, 0x27, 0xff, 0x39,
0x99, 0x13, 0x99, 0x44, 0xfc, 0x19, 0x82, 0x62, 0x2f, 0x44, 0xd0, 0xc4, 0xd7, 0x9c, 0xdf, 0xa2,
0x00, 0x5b, 0x6e, 0xbb, 0x69, 0x75, 0x09, 0x3d, 0xf8, 0xef, 0x30, 0xf4, 0x11, 0x20, 0x9b, 0x3c,
0x64, 0xba, 0x4b, 0x3e, 0x3d, 0x20, 0xb6, 0x41, 0x74, 0x87, 0x18, 0x87, 0xb2, 0x09, 0xff, 0xdf,
0xf7, 0xd4, 0x4b, 0x22, 0xc3, 0x59, 0x1f, 0x0d, 0x67, 0x7c, 0xe5, 0x8e, 0xd4, 0x61, 0x62, 0x1c,
0xbe, 0xcc, 0x7e, 0xfc, 0x51, 0xdc, 0xbb, 0x4b, 0x46, 0xc7, 0xa6, 0x0f, 0xf6, 0x89, 0xd9, 0x26,
0x3e, 0x0d, 0x2f, 0x83, 0xf6, 0x55, 0x58, 0x6c, 0x8d, 0x66, 0xe5, 0x05, 0x98, 0xc3, 0xe3, 0xea,
0x61, 0x81, 0x62, 0x2f, 0xb9, 0x40, 0x53, 0xda, 0xe3, 0xdf, 0x47, 0x21, 0x25, 0xcf, 0x3f, 0xf4,
0x1e, 0x24, 0x5c, 0xd6, 0x62, 0x84, 0xf3, 0xb8, 0xb0, 0xa1, 0x9d, 0xcb, 0xe3, 0x8e, 0xef, 0x89,
0x45, 0x00, 0x7a, 0x1f, 0x66, 0xa8, 0x63, 0x12, 0xc7, 0xb2, 0xdb, 0x9c, 0xb8, 0xbf, 0x0b, 0x6e,
0xf8, 0xce, 0x78, 0x10, 0x83, 0x76, 0x60, 0x2e, 0x7c, 0x95, 0x92, 0xe4, 0xbe, 0x7e, 0xfe, 0x25,
0x3d, 0x14, 0x20, 0xa9, 0x1d, 0x49, 0x82, 0x36, 0x61, 0xd1, 0xa0, 0xb6, 0x4d, 0x0c, 0x66, 0x51,
0x5b, 0xdf, 0xa3, 0x3d, 0x37, 0x1b, 0x2f, 0xc4, 0x56, 0xd3, 0xe5, 0x5c, 0xdf, 0x53, 0x57, 0x82,
0x7b, 0xdd, 0x88, 0x83, 0x86, 0x17, 0x86, 0x9a, 0xdb, 0xb4, 0xe7, 0xa2, 0x2c, 0xa4, 0x82, 0x4b,
0xa1, 0xcf, 0x75, 0x1a, 0x07, 0xe2, 0xcd, 0xf8, 0xa3, 0x6f, 0xd4, 0x88, 0xf6, 0xb9, 0x02, 0x73,
0x61, 0x24, 0xd3, 0x7b, 0x39, 0x49, 0x40, 0xbf, 0xc4, 0x20, 0x29, 0x4f, 0xec, 0x1c, 0xcc, 0x04,
0xdb, 0x93, 0x63, 0x89, 0xe3, 0x81, 0x8c, 0xde, 0x85, 0x59, 0x97, 0x1e, 0x38, 0x06, 0xd1, 0x7d,
0x00, 0x72, 0xc2, 0x95, 0xbe, 0xa7, 0x22, 0x31, 0x47, 0xc8, 0xa8, 0x61, 0x10, 0x92, 0xbf, 0x08,
0xf4, 0x01, 0x2c, 0x48, 0x5b, 0xf8, 0x1f, 0x55, 0xba, 0x7c, 0xa9, 0xef, 0xa9, 0x17, 0x46, 0x62,
0xa5, 0x5d, 0xc3, 0xf3, 0x42, 0x11, 0xb4, 0xd9, 0x2d, 0xc8, 0x98, 0xc4, 0x65, 0x96, 0xdd, 0xe2,
0xbc, 0xf3, 0xf9, 0xc5, 0x5f, 0xa8, 0xcb, 0x7d, 0x4f, 0xbd, 0x28, 0x72, 0x8c, 0x7b, 0x68, 0x78,
0x31, 0xa4, 0xe2, 0x48, 0x1a, 0xb0, 0x1c, 0xf6, 0x0a, 0xe0, 0xf0, 0x32, 0x95, 0xf3, 0x7d, 0x4f,
0xcd, 0x9d, 0x4d, 0x35, 0xc0, 0x84, 0x42, 0xda, 0x00, 0x18, 0x82, 0xb8, 0xd9, 0x62, 0x2d, 0x71,
0x2f, 0xc6, 0x7c, 0xec, 0x2f, 0x97, 0x89, 0xe3, 0x3d, 0xd8, 0xa8, 0x29, 0xbe, 0x51, 0x43, 0xcb,
0x1d, 0xb5, 0x6b, 0x78, 0x5e, 0x2a, 0x06, 0x9b, 0x75, 0x29, 0xf0, 0xf0, 0x9f, 0x2e, 0x6b, 0x75,
0x7b, 0xd9, 0x19, 0x9e, 0xe4, 0x4a, 0xdf, 0x53, 0xb3, 0xa3, 0x49, 0x06, 0x2e, 0x1a, 0xce, 0x48,
0x5d, 0x33, 0x50, 0x89, 0x0a, 0x5f, 0xfb, 0x4e, 0x81, 0x04, 0xdf, 0x7d, 0xe8, 0x1d, 0x50, 0x77,
0x9a, 0xa5, 0x66, 0x55, 0xbf, 0x5b, 0xaf, 0xd5, 0x6b, 0xcd, 0x5a, 0xe9, 0x4e, 0xed, 0x5e, 0xb5,
0xa2, 0xdf, 0xad, 0xef, 0x6c, 0x57, 0x37, 0x6b, 0xb7, 0x6a, 0xd5, 0x4a, 0x26, 0x92, 0x5b, 0x3a,
0x3e, 0x29, 0xcc, 0x8f, 0x38, 0xa0, 0x2c, 0x80, 0x88, 0xf3, 0x95, 0x19, 0x25, 0x37, 0x73, 0x7c,
0x52, 0x88, 0xfb, 0x63, 0x94, 0x87, 0x79, 0x61, 0x69, 0xe2, 0x4f, 0x1a, 0xdb, 0xd5, 0x7a, 0x26,
0x9a, 0x9b, 0x3d, 0x3e, 0x29, 0xa4, 0xa4, 0x38, 0x8c, 0xe4, 0xc6, 0x98, 0x88, 0xe4, 0x96, 0x2b,
0x30, 0x27, 0x2c, 0x9b, 0x77, 0x1a, 0x3b, 0xd5, 0x4a, 0x26, 0x9e, 0x83, 0xe3, 0x93, 0x42, 0x52,
0x48, 0xb9, 0xf8, 0xa3, 0x6f, 0xf3, 0x91, 0x6b, 0x0f, 0x20, 0xc1, 0x77, 0x3e, 0xba, 0x0a, 0x2b,
0x0d, 0x5c, 0xa9, 0x62, 0xbd, 0xde, 0xa8, 0x57, 0xc7, 0xf0, 0xf2, 0x94, 0xbe, 0x1e, 0x69, 0xb0,
0x28, 0xbc, 0xee, 0xd6, 0xf9, 0xb3, 0x5a, 0xc9, 0x28, 0xb9, 0xf9, 0xe3, 0x93, 0x42, 0x7a, 0xa0,
0xf0, 0x01, 0x0b, 0x9f, 0xc0, 0x43, 0x02, 0x96, 0xa2, 0x98, 0xb8, 0xbc, 0xf5, 0xf8, 0x34, 0xaf,
0x3c, 0x39, 0xcd, 0x2b, 0xbf, 0x9e, 0xe6, 0x95, 0x2f, 0x9e, 0xe6, 0x23, 0x4f, 0x9e, 0xe6, 0x23,
0x3f, 0x3d, 0xcd, 0x47, 0xee, 0xdd, 0x38, 0xf7, 0xd8, 0x7c, 0xf6, 0x87, 0xa7, 0xdd, 0x24, 0xff,
0x0e, 0x74, 0xe3, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfb, 0xa1, 0x58, 0xd4, 0x99, 0x12, 0x00,
0x00,
// 1219 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x4b, 0x8f, 0xdb, 0xd4,
0x17, 0x8f, 0xf3, 0x9c, 0x9c, 0x79, 0x65, 0xee, 0xb4, 0xd3, 0x34, 0xed, 0x3f, 0x8e, 0xfc, 0xaf,
0x50, 0xa8, 0xd4, 0x84, 0x3e, 0x78, 0xa8, 0x0b, 0x44, 0x5e, 0x55, 0x23, 0x3a, 0xc9, 0xe8, 0x26,
0x45, 0xa2, 0x1b, 0xcb, 0x63, 0xdf, 0x26, 0x56, 0x26, 0x76, 0xb0, 0x3d, 0xd3, 0xe6, 0x1b, 0x54,
0xb3, 0x40, 0xec, 0xd1, 0x00, 0x12, 0x1f, 0x02, 0xb1, 0x60, 0x5f, 0x89, 0x05, 0x5d, 0x22, 0x16,
0x06, 0x4d, 0xd9, 0xb1, 0xcb, 0x92, 0x15, 0xf2, 0xbd, 0xd7, 0x89, 0x93, 0x19, 0x82, 0x34, 0xa9,
0x14, 0xd8, 0xc4, 0xf7, 0x3c, 0x7e, 0xc7, 0xe7, 0xfc, 0xce, 0xbd, 0xd7, 0x47, 0x01, 0xe9, 0x79,
0x51, 0xdf, 0x57, 0x8b, 0xef, 0xdc, 0xbb, 0xa5, 0x76, 0x15, 0xc3, 0x20, 0x07, 0x45, 0x67, 0x38,
0x20, 0x36, 0xfb, 0x2d, 0x0c, 0x2c, 0xd3, 0x31, 0xd1, 0x35, 0xd5, 0xb4, 0xfb, 0xa6, 0x2d, 0xdb,
0x5a, 0xaf, 0xf0, 0xbc, 0xa0, 0xef, 0xab, 0x05, 0xee, 0x5b, 0x38, 0xba, 0x9d, 0x79, 0xcb, 0xe9,
0xea, 0x96, 0x26, 0x0f, 0x14, 0xcb, 0x19, 0x16, 0xa9, 0x7f, 0xb1, 0x63, 0x76, 0xcc, 0xc9, 0x8a,
0x05, 0x91, 0xbe, 0x0e, 0x03, 0xda, 0xb5, 0x3b, 0x15, 0x86, 0x6c, 0x0e, 0x88, 0x51, 0x37, 0x74,
0x07, 0xbd, 0x0b, 0x89, 0x81, 0x69, 0x39, 0xb2, 0xae, 0xa5, 0x85, 0x9c, 0x90, 0x4f, 0x96, 0xaf,
0x9f, 0xba, 0x62, 0x7c, 0xcf, 0xb4, 0x9c, 0x7a, 0x75, 0xe4, 0x8a, 0x1b, 0x43, 0xa5, 0x7f, 0x70,
0x5f, 0xe2, 0x2e, 0x12, 0x8e, 0x7b, 0xab, 0xba, 0x86, 0x4a, 0x00, 0x3c, 0x07, 0x0f, 0x19, 0xa6,
0x48, 0xe9, 0xd4, 0x15, 0x93, 0x3c, 0x3e, 0x05, 0x6f, 0x31, 0xf0, 0xc4, 0x51, 0xc2, 0x49, 0x2e,
0xd4, 0x35, 0x54, 0x85, 0x04, 0x17, 0xd2, 0x91, 0x9c, 0x90, 0x5f, 0xbd, 0x73, 0xa3, 0x30, 0xa7,
0xce, 0x02, 0x0f, 0x5c, 0x8e, 0xbe, 0x74, 0xc5, 0x10, 0xf6, 0xa1, 0xa8, 0x0e, 0x71, 0x5b, 0xef,
0x18, 0xc4, 0x4a, 0x47, 0x73, 0x42, 0x7e, 0xad, 0x7c, 0xfb, 0x4f, 0x57, 0xbc, 0xd5, 0xd1, 0x9d,
0xee, 0xe1, 0x7e, 0x41, 0x35, 0xfb, 0x45, 0x16, 0x92, 0x3f, 0x6e, 0xd9, 0x5a, 0x8f, 0x33, 0x5b,
0x52, 0xd5, 0x92, 0xa6, 0x59, 0xc4, 0xb6, 0x31, 0x0f, 0x20, 0xfd, 0x1e, 0x81, 0xad, 0x69, 0x86,
0xda, 0xd6, 0xf0, 0x3f, 0x4f, 0x10, 0x86, 0x4b, 0xaa, 0x79, 0x68, 0x38, 0xc4, 0xa2, 0x5b, 0x44,
0x3e, 0x22, 0x96, 0xad, 0x9b, 0x06, 0xa5, 0x2b, 0x59, 0x16, 0x47, 0xae, 0x78, 0x8d, 0x67, 0x71,
0x8e, 0x97, 0x84, 0xb7, 0x83, 0xea, 0x4f, 0x98, 0x16, 0xdd, 0x03, 0x18, 0x58, 0xa6, 0xf9, 0x54,
0xd6, 0x0d, 0xdd, 0x49, 0xc7, 0x28, 0xf1, 0x97, 0x27, 0xf5, 0x4c, 0x6c, 0x12, 0x4e, 0x52, 0x81,
0x6e, 0xb5, 0xfb, 0xb0, 0xc6, 0x2c, 0x5d, 0xa2, 0x77, 0xba, 0x4e, 0x3a, 0x9e, 0x13, 0xf2, 0xd1,
0xf2, 0x95, 0x91, 0x2b, 0x6e, 0x07, 0x71, 0xcc, 0x2a, 0xe1, 0x55, 0x2a, 0x3e, 0xa4, 0x52, 0xa0,
0xcd, 0x89, 0x45, 0xdb, 0xfc, 0xe5, 0x99, 0x36, 0x97, 0xd4, 0xde, 0x12, 0xdb, 0xfc, 0x77, 0x0d,
0x8a, 0x2c, 0xd0, 0xa0, 0xdb, 0xc0, 0x78, 0x97, 0x1d, 0x6b, 0xc8, 0x0f, 0xc6, 0xa5, 0x91, 0x2b,
0xa6, 0x82, 0x3c, 0x3b, 0xd6, 0x50, 0xc2, 0x2b, 0x74, 0xed, 0xed, 0xf3, 0xd9, 0xee, 0xc4, 0x2e,
0xd4, 0x9d, 0xf8, 0xa2, 0xdd, 0xf9, 0x31, 0x0c, 0x97, 0xa7, 0xbb, 0x53, 0x31, 0x8d, 0xa7, 0xba,
0xd5, 0x5f, 0x62, 0x87, 0xc6, 0x6c, 0x2a, 0x6a, 0x8f, 0xb6, 0xe5, 0x1c, 0x36, 0x15, 0xb5, 0xe7,
0xb3, 0xe9, 0x6d, 0xa7, 0x59, 0x36, 0xa3, 0x17, 0x62, 0x33, 0xb6, 0x28, 0x9b, 0xbf, 0x08, 0xb0,
0x3d, 0x61, 0xb3, 0x72, 0x60, 0xda, 0x64, 0xc9, 0xb7, 0xfe, 0xa4, 0xb8, 0xc8, 0xa2, 0xc5, 0xfd,
0x14, 0x86, 0x9d, 0x99, 0xe2, 0x96, 0xbf, 0x57, 0xa6, 0xaf, 0xc6, 0xc8, 0x05, 0xaf, 0xc6, 0x25,
0x6d, 0x97, 0x3f, 0x04, 0x48, 0xee, 0xda, 0x9d, 0x3d, 0x45, 0xed, 0x11, 0x07, 0x95, 0x20, 0x3e,
0xa0, 0x2b, 0xca, 0xe1, 0xea, 0x9d, 0xff, 0xcf, 0xfd, 0xfc, 0x30, 0x10, 0xff, 0xfa, 0x70, 0x20,
0xba, 0x04, 0x31, 0x9a, 0x2a, 0xe5, 0x72, 0x0d, 0x33, 0xe1, 0x4c, 0xb5, 0x91, 0x0b, 0x55, 0xbb,
0xf0, 0xf7, 0xfe, 0xfb, 0x30, 0xc0, 0xae, 0xdd, 0x69, 0xeb, 0x7d, 0x62, 0x1e, 0xfe, 0x4b, 0xcb,
0xfd, 0x18, 0x90, 0x41, 0x9e, 0x3b, 0xb2, 0x4d, 0x3e, 0x3b, 0x24, 0x86, 0x4a, 0x64, 0x8b, 0xa8,
0x47, 0x7c, 0x7b, 0xfc, 0x6f, 0xe4, 0x8a, 0x57, 0x59, 0x84, 0xb3, 0x3e, 0x12, 0x4e, 0x79, 0xca,
0x16, 0xd7, 0x61, 0xa2, 0x1e, 0xbd, 0xc9, 0x9d, 0xf2, 0x15, 0x9b, 0x26, 0x4b, 0x6a, 0xcf, 0x30,
0x9f, 0x1d, 0x10, 0xad, 0x43, 0xfa, 0xc4, 0x78, 0x23, 0x1c, 0xe6, 0x61, 0x53, 0x99, 0x8e, 0xca,
0xd9, 0x9c, 0x55, 0x4f, 0xd8, 0x8e, 0xcc, 0x63, 0x7b, 0x49, 0x47, 0xe9, 0x87, 0x30, 0x24, 0xf8,
0xad, 0x81, 0x3e, 0x80, 0x98, 0xed, 0x28, 0x0e, 0xa1, 0xa4, 0x6c, 0xdc, 0x91, 0xe6, 0x92, 0xd2,
0xf2, 0x3c, 0x31, 0x03, 0xa0, 0x0f, 0x61, 0xc5, 0xb4, 0x34, 0x62, 0xe9, 0x46, 0x87, 0xb2, 0xf0,
0x4f, 0xe0, 0xa6, 0xe7, 0x8c, 0xc7, 0x18, 0xd4, 0x82, 0xb5, 0xe0, 0x78, 0xc0, 0xe7, 0xc8, 0xb7,
0xe7, 0xcf, 0x91, 0x01, 0x00, 0xef, 0xcd, 0x54, 0x10, 0x54, 0x81, 0x4d, 0xd5, 0x34, 0x0c, 0xa2,
0x3a, 0xba, 0x69, 0xc8, 0x5d, 0x73, 0x60, 0xa7, 0xa3, 0xb9, 0x48, 0x3e, 0x59, 0xce, 0x8c, 0x5c,
0x71, 0xc7, 0x9f, 0x55, 0xa6, 0x1c, 0x24, 0xbc, 0x31, 0xd1, 0x3c, 0x34, 0x07, 0x36, 0x4a, 0x43,
0xc2, 0x1f, 0x74, 0x3c, 0xae, 0x93, 0xd8, 0x17, 0xef, 0x47, 0x5f, 0x7c, 0x23, 0x86, 0xa4, 0xcf,
0x05, 0x58, 0x0b, 0x66, 0xb2, 0xbc, 0x2b, 0x9d, 0x27, 0xf4, 0x6b, 0x04, 0xe2, 0xfc, 0x62, 0xcc,
0xc0, 0x8a, 0x7f, 0xd6, 0x68, 0x2e, 0x51, 0x3c, 0x96, 0xd1, 0xfb, 0xb0, 0x6a, 0x9b, 0x87, 0x96,
0x4a, 0x64, 0x2f, 0x01, 0xfe, 0xc2, 0x9d, 0x91, 0x2b, 0x22, 0xf6, 0x8e, 0x80, 0x51, 0xc2, 0xc0,
0x24, 0xaf, 0x08, 0xf4, 0x11, 0x6c, 0x70, 0x5b, 0x70, 0xe8, 0x4f, 0x96, 0xaf, 0x8e, 0x5c, 0xf1,
0xf2, 0x14, 0x96, 0xdb, 0x25, 0xbc, 0xce, 0x14, 0xfe, 0x36, 0x7b, 0x00, 0x29, 0x8d, 0xd8, 0x8e,
0x6e, 0x28, 0x94, 0x77, 0xfa, 0x7e, 0x36, 0xe5, 0x5f, 0x1b, 0xb9, 0xe2, 0x15, 0x16, 0x63, 0xd6,
0x43, 0xc2, 0x9b, 0x01, 0x15, 0xcd, 0xa4, 0x09, 0xdb, 0x41, 0x2f, 0x3f, 0x1d, 0xda, 0xa6, 0x72,
0x76, 0xe4, 0x8a, 0x99, 0xb3, 0xa1, 0xc6, 0x39, 0xa1, 0x80, 0xd6, 0x4f, 0x0c, 0x41, 0x54, 0x53,
0x1c, 0x85, 0x0d, 0x87, 0x98, 0xae, 0xbd, 0x72, 0x1d, 0x76, 0xf1, 0xfa, 0x07, 0x35, 0x41, 0x0f,
0x6a, 0xa0, 0xdc, 0x69, 0xbb, 0x84, 0xd7, 0xb9, 0x62, 0x7c, 0x58, 0xb7, 0x7c, 0x0f, 0xef, 0x69,
0x3b, 0x4a, 0x7f, 0x90, 0x5e, 0xa1, 0x41, 0xae, 0x8f, 0x5c, 0x31, 0x3d, 0x1d, 0x64, 0xec, 0x22,
0xe1, 0x14, 0xd7, 0xb5, 0x7d, 0x15, 0xeb, 0xf0, 0xcd, 0xef, 0x04, 0x88, 0xd1, 0xd3, 0x87, 0xde,
0x03, 0xb1, 0xd5, 0x2e, 0xb5, 0x6b, 0xf2, 0xe3, 0x46, 0xbd, 0x51, 0x6f, 0xd7, 0x4b, 0x8f, 0xea,
0x4f, 0x6a, 0x55, 0xf9, 0x71, 0xa3, 0xb5, 0x57, 0xab, 0xd4, 0x1f, 0xd4, 0x6b, 0xd5, 0x54, 0x28,
0xb3, 0x75, 0x7c, 0x92, 0x5b, 0x9f, 0x72, 0x40, 0x69, 0x00, 0x86, 0xf3, 0x94, 0x29, 0x21, 0xb3,
0x72, 0x7c, 0x92, 0x8b, 0x7a, 0x6b, 0x94, 0x85, 0x75, 0x66, 0x69, 0xe3, 0x4f, 0x9b, 0x7b, 0xb5,
0x46, 0x2a, 0x9c, 0x59, 0x3d, 0x3e, 0xc9, 0x25, 0xb8, 0x38, 0x41, 0x52, 0x63, 0x84, 0x21, 0xa9,
0xe5, 0x3a, 0xac, 0x31, 0x4b, 0xe5, 0x51, 0xb3, 0x55, 0xab, 0xa6, 0xa2, 0x19, 0x38, 0x3e, 0xc9,
0xc5, 0x99, 0x94, 0x89, 0xbe, 0xf8, 0x36, 0x1b, 0xba, 0xf9, 0x0c, 0x62, 0xf4, 0xe4, 0xa3, 0x1b,
0xb0, 0xd3, 0xc4, 0xd5, 0x1a, 0x96, 0x1b, 0xcd, 0x46, 0x6d, 0x26, 0x5f, 0x1a, 0xd2, 0xd3, 0x23,
0x09, 0x36, 0x99, 0xd7, 0xe3, 0x06, 0x7d, 0xd6, 0xaa, 0x29, 0x21, 0xb3, 0x7e, 0x7c, 0x92, 0x4b,
0x8e, 0x15, 0x5e, 0xc2, 0xcc, 0xc7, 0xf7, 0xe0, 0x09, 0x73, 0x91, 0xbd, 0xb8, 0xbc, 0xfb, 0xf2,
0x34, 0x2b, 0xbc, 0x3a, 0xcd, 0x0a, 0xbf, 0x9d, 0x66, 0x85, 0x2f, 0x5e, 0x67, 0x43, 0xaf, 0x5e,
0x67, 0x43, 0x3f, 0xbf, 0xce, 0x86, 0x9e, 0xdc, 0x9d, 0x7b, 0x6d, 0x9e, 0xff, 0xa7, 0xc7, 0x7e,
0x9c, 0xfe, 0x55, 0x71, 0xf7, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x44, 0x7a, 0xc9, 0x51, 0x15,
0x11, 0x00, 0x00,
}
func (m *MsgChannelOpenInit) Marshal() (dAtA []byte, err error) {
@ -1127,16 +1123,13 @@ func (m *MsgChannelOpenTry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x30
}
{
size, err := m.ProofInit.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.ProofInit) > 0 {
i -= len(m.ProofInit)
copy(dAtA[i:], m.ProofInit)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProofInit)))
i--
dAtA[i] = 0x2a
}
i--
dAtA[i] = 0x2a
if len(m.CounterpartyVersion) > 0 {
i -= len(m.CounterpartyVersion)
copy(dAtA[i:], m.CounterpartyVersion)
@ -1203,16 +1196,13 @@ func (m *MsgChannelOpenAck) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x28
}
{
size, err := m.ProofTry.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.ProofTry) > 0 {
i -= len(m.ProofTry)
copy(dAtA[i:], m.ProofTry)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProofTry)))
i--
dAtA[i] = 0x22
}
i--
dAtA[i] = 0x22
if len(m.CounterpartyVersion) > 0 {
i -= len(m.CounterpartyVersion)
copy(dAtA[i:], m.CounterpartyVersion)
@ -1269,16 +1259,13 @@ func (m *MsgChannelOpenConfirm) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x20
}
{
size, err := m.ProofAck.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.ProofAck) > 0 {
i -= len(m.ProofAck)
copy(dAtA[i:], m.ProofAck)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProofAck)))
i--
dAtA[i] = 0x1a
}
i--
dAtA[i] = 0x1a
if len(m.ChannelID) > 0 {
i -= len(m.ChannelID)
copy(dAtA[i:], m.ChannelID)
@ -1372,16 +1359,13 @@ func (m *MsgChannelCloseConfirm) MarshalToSizedBuffer(dAtA []byte) (int, error)
i--
dAtA[i] = 0x20
}
{
size, err := m.ProofInit.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.ProofInit) > 0 {
i -= len(m.ProofInit)
copy(dAtA[i:], m.ProofInit)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProofInit)))
i--
dAtA[i] = 0x1a
}
i--
dAtA[i] = 0x1a
if len(m.ChannelID) > 0 {
i -= len(m.ChannelID)
copy(dAtA[i:], m.ChannelID)
@ -1431,16 +1415,13 @@ func (m *MsgPacket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x18
}
{
size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Proof)))
i--
dAtA[i] = 0x12
}
i--
dAtA[i] = 0x12
{
size, err := m.Packet.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
@ -1491,16 +1472,13 @@ func (m *MsgTimeout) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x18
}
{
size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Proof)))
i--
dAtA[i] = 0x12
}
i--
dAtA[i] = 0x12
{
size, err := m.Packet.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
@ -1546,16 +1524,13 @@ func (m *MsgAcknowledgement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x20
}
{
size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
if len(m.Proof) > 0 {
i -= len(m.Proof)
copy(dAtA[i:], m.Proof)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Proof)))
i--
dAtA[i] = 0x1a
}
i--
dAtA[i] = 0x1a
if len(m.Acknowledgement) > 0 {
i -= len(m.Acknowledgement)
copy(dAtA[i:], m.Acknowledgement)
@ -1799,8 +1774,10 @@ func (m *MsgChannelOpenTry) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.ProofInit.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProofInit)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
@ -1829,8 +1806,10 @@ func (m *MsgChannelOpenAck) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.ProofTry.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProofTry)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
@ -1855,8 +1834,10 @@ func (m *MsgChannelOpenConfirm) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.ProofAck.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProofAck)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
@ -1902,8 +1883,10 @@ func (m *MsgChannelCloseConfirm) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.ProofInit.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProofInit)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
@ -1922,8 +1905,10 @@ func (m *MsgPacket) Size() (n int) {
_ = l
l = m.Packet.Size()
n += 1 + l + sovTypes(uint64(l))
l = m.Proof.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.Proof)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
@ -1942,8 +1927,10 @@ func (m *MsgTimeout) Size() (n int) {
_ = l
l = m.Packet.Size()
n += 1 + l + sovTypes(uint64(l))
l = m.Proof.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.Proof)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
@ -1969,8 +1956,10 @@ func (m *MsgAcknowledgement) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.Proof.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.Proof)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.ProofHeight != 0 {
n += 1 + sovTypes(uint64(m.ProofHeight))
}
@ -2415,7 +2404,7 @@ func (m *MsgChannelOpenTry) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofInit", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -2425,23 +2414,24 @@ func (m *MsgChannelOpenTry) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ProofInit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProofInit = append(m.ProofInit[:0], dAtA[iNdEx:postIndex]...)
if m.ProofInit == nil {
m.ProofInit = []byte{}
}
iNdEx = postIndex
case 6:
@ -2650,7 +2640,7 @@ func (m *MsgChannelOpenAck) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofTry", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -2660,23 +2650,24 @@ func (m *MsgChannelOpenAck) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ProofTry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProofTry = append(m.ProofTry[:0], dAtA[iNdEx:postIndex]...)
if m.ProofTry == nil {
m.ProofTry = []byte{}
}
iNdEx = postIndex
case 5:
@ -2853,7 +2844,7 @@ func (m *MsgChannelOpenConfirm) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofAck", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -2863,23 +2854,24 @@ func (m *MsgChannelOpenConfirm) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ProofAck.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProofAck = append(m.ProofAck[:0], dAtA[iNdEx:postIndex]...)
if m.ProofAck == nil {
m.ProofAck = []byte{}
}
iNdEx = postIndex
case 4:
@ -3207,7 +3199,7 @@ func (m *MsgChannelCloseConfirm) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofInit", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -3217,23 +3209,24 @@ func (m *MsgChannelCloseConfirm) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ProofInit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProofInit = append(m.ProofInit[:0], dAtA[iNdEx:postIndex]...)
if m.ProofInit == nil {
m.ProofInit = []byte{}
}
iNdEx = postIndex
case 4:
@ -3379,7 +3372,7 @@ func (m *MsgPacket) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -3389,23 +3382,24 @@ func (m *MsgPacket) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
if m.Proof == nil {
m.Proof = []byte{}
}
iNdEx = postIndex
case 3:
@ -3551,7 +3545,7 @@ func (m *MsgTimeout) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -3561,23 +3555,24 @@ func (m *MsgTimeout) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
if m.Proof == nil {
m.Proof = []byte{}
}
iNdEx = postIndex
case 3:
@ -3776,7 +3771,7 @@ func (m *MsgAcknowledgement) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -3786,23 +3781,24 @@ func (m *MsgAcknowledgement) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
if m.Proof == nil {
m.Proof = []byte{}
}
iNdEx = postIndex
case 4:

19
x/ibc/04-channel/types/types.proto
View File

@ -4,7 +4,6 @@ package cosmos_sdk.x.ibc.channel.v1;
option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types";
import "third_party/proto/gogoproto/gogo.proto";
import "x/ibc/23-commitment/types/types.proto";
// MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It is
// called by a relayer on Chain A.
@ -22,8 +21,7 @@ message MsgChannelOpenTry {
string channel_id = 2 [(gogoproto.customname) = "ChannelID", (gogoproto.moretags) = "yaml:\"channel_id\""];
Channel channel = 3 [(gogoproto.nullable) = false];
string counterparty_version = 4 [(gogoproto.moretags) = "yaml:\"counterparty_version\""];
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof_init = 5
[(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"proof_init\""];
bytes proof_init = 5 [(gogoproto.moretags) = "yaml:\"proof_init\""];
uint64 proof_height = 6 [(gogoproto.moretags) = "yaml:\"proof_height\""];
bytes signer = 7 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
}
@ -34,8 +32,7 @@ message MsgChannelOpenAck {
string port_id = 1 [(gogoproto.customname) = "PortID", (gogoproto.moretags) = "yaml:\"port_id\""];
string channel_id = 2 [(gogoproto.customname) = "ChannelID", (gogoproto.moretags) = "yaml:\"channel_id\""];
string counterparty_version = 3 [(gogoproto.moretags) = "yaml:\"counterparty_version\""];
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof_try = 4
[(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"proof_try\""];
bytes proof_try = 4 [(gogoproto.moretags) = "yaml:\"proof_try\""];
uint64 proof_height = 5 [(gogoproto.moretags) = "yaml:\"proof_height\""];
bytes signer = 6 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
}
@ -45,8 +42,7 @@ message MsgChannelOpenAck {
message MsgChannelOpenConfirm {
string port_id = 1 [(gogoproto.customname) = "PortID", (gogoproto.moretags) = "yaml:\"port_id\""];
string channel_id = 2 [(gogoproto.customname) = "ChannelID", (gogoproto.moretags) = "yaml:\"channel_id\""];
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof_ack = 3
[(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"proof_ack\""];
bytes proof_ack = 3 [(gogoproto.moretags) = "yaml:\"proof_ack\""];
uint64 proof_height = 4 [(gogoproto.moretags) = "yaml:\"proof_height\""];
bytes signer = 5 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
}
@ -64,8 +60,7 @@ message MsgChannelCloseInit {
message MsgChannelCloseConfirm {
string port_id = 1 [(gogoproto.customname) = "PortID", (gogoproto.moretags) = "yaml:\"port_id\""];
string channel_id = 2 [(gogoproto.customname) = "ChannelID", (gogoproto.moretags) = "yaml:\"channel_id\""];
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof_init = 3
[(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"proof_init\""];
bytes proof_init = 3 [(gogoproto.moretags) = "yaml:\"proof_init\""];
uint64 proof_height = 4 [(gogoproto.moretags) = "yaml:\"proof_height\""];
bytes signer = 5 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
}
@ -73,7 +68,7 @@ message MsgChannelCloseConfirm {
// MsgPacket receives incoming IBC packet
message MsgPacket {
Packet packet = 1 [(gogoproto.nullable) = false];
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof = 2 [(gogoproto.nullable) = false];
bytes proof = 2;
uint64 proof_height = 3 [(gogoproto.moretags) = "yaml:\"proof_height\""];
bytes signer = 4 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
}
@ -81,7 +76,7 @@ message MsgPacket {
// MsgTimeout receives timed-out packet
message MsgTimeout {
Packet packet = 1 [(gogoproto.nullable) = false];
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof = 2 [(gogoproto.nullable) = false];
bytes proof = 2;
uint64 proof_height = 3 [(gogoproto.moretags) = "yaml:\"proof_height\""];
uint64 next_sequence_recv = 4 [(gogoproto.moretags) = "yaml:\"next_sequence_recv\""];
bytes signer = 5 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
@ -91,7 +86,7 @@ message MsgTimeout {
message MsgAcknowledgement {
Packet packet = 1 [(gogoproto.nullable) = false];
bytes acknowledgement = 2;
cosmos_sdk.x.ibc.commitment.v1.MerkleProof proof = 3 [(gogoproto.nullable) = false];
bytes proof = 3;
uint64 proof_height = 4 [(gogoproto.moretags) = "yaml:\"proof_height\""];
bytes signer = 5 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
}

91
x/ibc/07-tendermint/types/client_state.go
View File

@ -150,16 +150,18 @@ func (cs ClientState) Validate() error {
// Tendermint client stored on the target machine.
func (cs ClientState) VerifyClientConsensusState(
_ sdk.KVStore,
cdc *codec.Codec,
cdc codec.Marshaler,
aminoCdc *codec.Codec,
provingRoot commitmentexported.Root,
height uint64,
counterpartyClientIdentifier string,
consensusHeight uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
consensusState clientexported.ConsensusState,
) error {
if err := validateVerificationArgs(cs, height, prefix, proof, consensusState); err != nil {
merkleProof, err := sanitizeVerificationArgs(cdc, cs, height, prefix, proof, consensusState)
if err != nil {
return err
}
@ -169,12 +171,12 @@ func (cs ClientState) VerifyClientConsensusState(
return err
}
bz, err := cdc.MarshalBinaryBare(consensusState)
bz, err := aminoCdc.MarshalBinaryBare(consensusState)
if err != nil {
return err
}
if err := proof.VerifyMembership(provingRoot, path, bz); err != nil {
if err := merkleProof.VerifyMembership(provingRoot, path, bz); err != nil {
return sdkerrors.Wrap(clienttypes.ErrFailedClientConsensusStateVerification, err.Error())
}
@ -188,12 +190,13 @@ func (cs ClientState) VerifyConnectionState(
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
connectionID string,
connectionEnd connectionexported.ConnectionI,
consensusState clientexported.ConsensusState,
) error {
if err := validateVerificationArgs(cs, height, prefix, proof, consensusState); err != nil {
merkleProof, err := sanitizeVerificationArgs(cdc, cs, height, prefix, proof, consensusState)
if err != nil {
return err
}
@ -212,7 +215,7 @@ func (cs ClientState) VerifyConnectionState(
return err
}
if err := proof.VerifyMembership(consensusState.GetRoot(), path, bz); err != nil {
if err := merkleProof.VerifyMembership(consensusState.GetRoot(), path, bz); err != nil {
return sdkerrors.Wrap(clienttypes.ErrFailedConnectionStateVerification, err.Error())
}
@ -226,13 +229,14 @@ func (cs ClientState) VerifyChannelState(
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
channel channelexported.ChannelI,
consensusState clientexported.ConsensusState,
) error {
if err := validateVerificationArgs(cs, height, prefix, proof, consensusState); err != nil {
merkleProof, err := sanitizeVerificationArgs(cdc, cs, height, prefix, proof, consensusState)
if err != nil {
return err
}
@ -251,7 +255,7 @@ func (cs ClientState) VerifyChannelState(
return err
}
if err := proof.VerifyMembership(consensusState.GetRoot(), path, bz); err != nil {
if err := merkleProof.VerifyMembership(consensusState.GetRoot(), path, bz); err != nil {
return sdkerrors.Wrap(clienttypes.ErrFailedChannelStateVerification, err.Error())
}
@ -262,16 +266,18 @@ func (cs ClientState) VerifyChannelState(
// the specified port, specified channel, and specified sequence.
func (cs ClientState) VerifyPacketCommitment(
_ sdk.KVStore,
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
commitmentBytes []byte,
consensusState clientexported.ConsensusState,
) error {
if err := validateVerificationArgs(cs, height, prefix, proof, consensusState); err != nil {
merkleProof, err := sanitizeVerificationArgs(cdc, cs, height, prefix, proof, consensusState)
if err != nil {
return err
}
@ -280,7 +286,7 @@ func (cs ClientState) VerifyPacketCommitment(
return err
}
if err := proof.VerifyMembership(consensusState.GetRoot(), path, commitmentBytes); err != nil {
if err := merkleProof.VerifyMembership(consensusState.GetRoot(), path, commitmentBytes); err != nil {
return sdkerrors.Wrap(clienttypes.ErrFailedPacketCommitmentVerification, err.Error())
}
@ -291,16 +297,18 @@ func (cs ClientState) VerifyPacketCommitment(
// acknowledgement at the specified port, specified channel, and specified sequence.
func (cs ClientState) VerifyPacketAcknowledgement(
_ sdk.KVStore,
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
acknowledgement []byte,
consensusState clientexported.ConsensusState,
) error {
if err := validateVerificationArgs(cs, height, prefix, proof, consensusState); err != nil {
merkleProof, err := sanitizeVerificationArgs(cdc, cs, height, prefix, proof, consensusState)
if err != nil {
return err
}
@ -309,7 +317,7 @@ func (cs ClientState) VerifyPacketAcknowledgement(
return err
}
if err := proof.VerifyMembership(consensusState.GetRoot(), path, channeltypes.CommitAcknowledgement(acknowledgement)); err != nil {
if err := merkleProof.VerifyMembership(consensusState.GetRoot(), path, channeltypes.CommitAcknowledgement(acknowledgement)); err != nil {
return sdkerrors.Wrap(clienttypes.ErrFailedPacketAckVerification, err.Error())
}
@ -321,15 +329,17 @@ func (cs ClientState) VerifyPacketAcknowledgement(
// specified sequence.
func (cs ClientState) VerifyPacketAcknowledgementAbsence(
_ sdk.KVStore,
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
sequence uint64,
consensusState clientexported.ConsensusState,
) error {
if err := validateVerificationArgs(cs, height, prefix, proof, consensusState); err != nil {
merkleProof, err := sanitizeVerificationArgs(cdc, cs, height, prefix, proof, consensusState)
if err != nil {
return err
}
@ -338,7 +348,7 @@ func (cs ClientState) VerifyPacketAcknowledgementAbsence(
return err
}
if err := proof.VerifyNonMembership(consensusState.GetRoot(), path); err != nil {
if err := merkleProof.VerifyNonMembership(consensusState.GetRoot(), path); err != nil {
return sdkerrors.Wrap(clienttypes.ErrFailedPacketAckAbsenceVerification, err.Error())
}
@ -349,15 +359,17 @@ func (cs ClientState) VerifyPacketAcknowledgementAbsence(
// received of the specified channel at the specified port.
func (cs ClientState) VerifyNextSequenceRecv(
_ sdk.KVStore,
cdc codec.Marshaler,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
portID,
channelID string,
nextSequenceRecv uint64,
consensusState clientexported.ConsensusState,
) error {
if err := validateVerificationArgs(cs, height, prefix, proof, consensusState); err != nil {
merkleProof, err := sanitizeVerificationArgs(cdc, cs, height, prefix, proof, consensusState)
if err != nil {
return err
}
@ -368,59 +380,60 @@ func (cs ClientState) VerifyNextSequenceRecv(
bz := sdk.Uint64ToBigEndian(nextSequenceRecv)
if err := proof.VerifyMembership(consensusState.GetRoot(), path, bz); err != nil {
if err := merkleProof.VerifyMembership(consensusState.GetRoot(), path, bz); err != nil {
return sdkerrors.Wrap(clienttypes.ErrFailedNextSeqRecvVerification, err.Error())
}
return nil
}
// validateVerificationArgs perfoms the basic checks on the arguments that are
// shared between the verification functions.
func validateVerificationArgs(
// sanitizeVerificationArgs perfoms the basic checks on the arguments that are
// shared between the verification functions and returns the unmarshalled
// merkle proof and an error if one occurred.
func sanitizeVerificationArgs(
cdc codec.Marshaler,
cs ClientState,
height uint64,
prefix commitmentexported.Prefix,
proof commitmentexported.Proof,
proof []byte,
consensusState clientexported.ConsensusState,
) error {
) (merkleProof commitmenttypes.MerkleProof, err error) {
if cs.GetLatestHeight() < height {
return sdkerrors.Wrapf(
return commitmenttypes.MerkleProof{}, sdkerrors.Wrapf(
sdkerrors.ErrInvalidHeight,
"client state (%s) height < proof height (%d < %d)", cs.ID, cs.GetLatestHeight(), height,
)
}
if cs.IsFrozen() && cs.FrozenHeight <= height {
return clienttypes.ErrClientFrozen
return commitmenttypes.MerkleProof{}, clienttypes.ErrClientFrozen
}
if prefix == nil {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidPrefix, "prefix cannot be empty")
return commitmenttypes.MerkleProof{}, sdkerrors.Wrap(commitmenttypes.ErrInvalidPrefix, "prefix cannot be empty")
}
_, ok := prefix.(*commitmenttypes.MerklePrefix)
if !ok {
return sdkerrors.Wrapf(commitmenttypes.ErrInvalidPrefix, "invalid prefix type %T, expected *MerklePrefix", prefix)
return commitmenttypes.MerkleProof{}, sdkerrors.Wrapf(commitmenttypes.ErrInvalidPrefix, "invalid prefix type %T, expected *MerklePrefix", prefix)
}
if proof == nil {
return sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "proof cannot be empty")
return commitmenttypes.MerkleProof{}, sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "proof cannot be empty")
}
_, ok = proof.(commitmenttypes.MerkleProof)
if !ok {
return sdkerrors.Wrapf(commitmenttypes.ErrInvalidProof, "invalid proof type %T, expected MerkleProof", proof)
if err = cdc.UnmarshalBinaryBare(proof, &merkleProof); err != nil {
return commitmenttypes.MerkleProof{}, sdkerrors.Wrap(commitmenttypes.ErrInvalidProof, "failed to unmarshal proof into commitment merkle proof")
}
if consensusState == nil {
return sdkerrors.Wrap(clienttypes.ErrInvalidConsensus, "consensus state cannot be empty")
return commitmenttypes.MerkleProof{}, sdkerrors.Wrap(clienttypes.ErrInvalidConsensus, "consensus state cannot be empty")
}
_, ok = consensusState.(ConsensusState)
if !ok {
return sdkerrors.Wrapf(clienttypes.ErrInvalidConsensus, "invalid consensus type %T, expected %T", consensusState, ConsensusState{})
return commitmenttypes.MerkleProof{}, sdkerrors.Wrapf(clienttypes.ErrInvalidConsensus, "invalid consensus type %T, expected %T", consensusState, ConsensusState{})
}
return nil
return merkleProof, nil
}

38
x/ibc/07-tendermint/types/client_state_test.go
View File

@ -78,7 +78,7 @@ func (suite *TendermintTestSuite) TestVerifyClientConsensusState() {
clientState ibctmtypes.ClientState
consensusState ibctmtypes.ConsensusState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
// FIXME: uncomment
@ -126,7 +126,7 @@ func (suite *TendermintTestSuite) TestVerifyClientConsensusState() {
ValidatorSet: suite.valSet,
},
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -135,7 +135,7 @@ func (suite *TendermintTestSuite) TestVerifyClientConsensusState() {
tc := tc
err := tc.clientState.VerifyClientConsensusState(
nil, suite.aminoCdc, tc.consensusState.Root, height, "chainA", tc.consensusState.GetHeight(), tc.prefix, tc.proof, tc.consensusState,
nil, suite.cdc, suite.aminoCdc, tc.consensusState.Root, height, "chainA", tc.consensusState.GetHeight(), tc.prefix, tc.proof, tc.consensusState,
)
if tc.expPass {
@ -156,7 +156,7 @@ func (suite *TendermintTestSuite) TestVerifyConnectionState() {
connection connection.End
consensusState ibctmtypes.ConsensusState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
// FIXME: uncomment
@ -209,7 +209,7 @@ func (suite *TendermintTestSuite) TestVerifyConnectionState() {
ValidatorSet: suite.valSet,
},
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -239,7 +239,7 @@ func (suite *TendermintTestSuite) TestVerifyChannelState() {
channel channel.Channel
consensusState ibctmtypes.ConsensusState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
// FIXME: uncomment
@ -292,7 +292,7 @@ func (suite *TendermintTestSuite) TestVerifyChannelState() {
ValidatorSet: suite.valSet,
},
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -319,7 +319,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketCommitment() {
commitment []byte
consensusState ibctmtypes.ConsensusState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
// FIXME: uncomment
@ -372,7 +372,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketCommitment() {
ValidatorSet: suite.valSet,
},
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -381,7 +381,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketCommitment() {
tc := tc
err := tc.clientState.VerifyPacketCommitment(
nil, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.commitment, tc.consensusState,
nil, suite.cdc, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.commitment, tc.consensusState,
)
if tc.expPass {
@ -399,7 +399,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketAcknowledgement() {
ack []byte
consensusState ibctmtypes.ConsensusState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
// FIXME: uncomment
@ -452,7 +452,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketAcknowledgement() {
ValidatorSet: suite.valSet,
},
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -461,7 +461,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketAcknowledgement() {
tc := tc
err := tc.clientState.VerifyPacketAcknowledgement(
nil, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.ack, tc.consensusState,
nil, suite.cdc, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.ack, tc.consensusState,
)
if tc.expPass {
@ -478,7 +478,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketAcknowledgementAbsence() {
clientState ibctmtypes.ClientState
consensusState ibctmtypes.ConsensusState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
// FIXME: uncomment
@ -527,7 +527,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketAcknowledgementAbsence() {
ValidatorSet: suite.valSet,
},
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -536,7 +536,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketAcknowledgementAbsence() {
tc := tc
err := tc.clientState.VerifyPacketAcknowledgementAbsence(
nil, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.consensusState,
nil, suite.cdc, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.consensusState,
)
if tc.expPass {
@ -553,7 +553,7 @@ func (suite *TendermintTestSuite) TestVerifyNextSeqRecv() {
clientState ibctmtypes.ClientState
consensusState ibctmtypes.ConsensusState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
// FIXME: uncomment
@ -602,7 +602,7 @@ func (suite *TendermintTestSuite) TestVerifyNextSeqRecv() {
ValidatorSet: suite.valSet,
},
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -611,7 +611,7 @@ func (suite *TendermintTestSuite) TestVerifyNextSeqRecv() {
tc := tc
err := tc.clientState.VerifyNextSequenceRecv(
nil, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.consensusState,
nil, suite.cdc, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.consensusState,
)
if tc.expPass {

23
x/ibc/09-localhost/types/client_state.go
View File

@ -80,13 +80,14 @@ func (cs ClientState) Validate() error {
// Tendermint client stored on the target machine.
func (cs ClientState) VerifyClientConsensusState(
store sdk.KVStore,
cdc *codec.Codec,
_ codec.Marshaler,
aminoCdc *codec.Codec,
_ commitmentexported.Root,
height uint64,
_ string,
consensusHeight uint64,
prefix commitmentexported.Prefix,
_ commitmentexported.Proof,
_ []byte,
consensusState clientexported.ConsensusState,
) error {
path, err := commitmenttypes.ApplyPrefix(prefix, consensusStatePath(cs.GetID()))
@ -100,7 +101,7 @@ func (cs ClientState) VerifyClientConsensusState(
}
var prevConsensusState clientexported.ConsensusState
if err := cdc.UnmarshalBinaryBare(data, &prevConsensusState); err != nil {
if err := aminoCdc.UnmarshalBinaryBare(data, &prevConsensusState); err != nil {
return err
}
@ -121,7 +122,7 @@ func (cs ClientState) VerifyConnectionState(
cdc codec.Marshaler,
_ uint64,
prefix commitmentexported.Prefix,
_ commitmentexported.Proof,
_ []byte,
connectionID string,
connectionEnd connectionexported.ConnectionI,
_ clientexported.ConsensusState,
@ -159,7 +160,7 @@ func (cs ClientState) VerifyChannelState(
cdc codec.Marshaler,
_ uint64,
prefix commitmentexported.Prefix,
_ commitmentexported.Proof,
_ []byte,
portID,
channelID string,
channel channelexported.ChannelI,
@ -195,9 +196,10 @@ func (cs ClientState) VerifyChannelState(
// the specified port, specified channel, and specified sequence.
func (cs ClientState) VerifyPacketCommitment(
store sdk.KVStore,
_ codec.Marshaler,
_ uint64,
prefix commitmentexported.Prefix,
_ commitmentexported.Proof,
_ []byte,
portID,
channelID string,
sequence uint64,
@ -228,9 +230,10 @@ func (cs ClientState) VerifyPacketCommitment(
// acknowledgement at the specified port, specified channel, and specified sequence.
func (cs ClientState) VerifyPacketAcknowledgement(
store sdk.KVStore,
_ codec.Marshaler,
_ uint64,
prefix commitmentexported.Prefix,
_ commitmentexported.Proof,
_ []byte,
portID,
channelID string,
sequence uint64,
@ -262,9 +265,10 @@ func (cs ClientState) VerifyPacketAcknowledgement(
// specified sequence.
func (cs ClientState) VerifyPacketAcknowledgementAbsence(
store sdk.KVStore,
_ codec.Marshaler,
_ uint64,
prefix commitmentexported.Prefix,
_ commitmentexported.Proof,
_ []byte,
portID,
channelID string,
sequence uint64,
@ -287,9 +291,10 @@ func (cs ClientState) VerifyPacketAcknowledgementAbsence(
// received of the specified channel at the specified port.
func (cs ClientState) VerifyNextSequenceRecv(
store sdk.KVStore,
_ codec.Marshaler,
_ uint64,
prefix commitmentexported.Prefix,
_ commitmentexported.Proof,
_ []byte,
portID,
channelID string,
nextSequenceRecv uint64,

36
x/ibc/09-localhost/types/client_state_test.go
View File

@ -52,7 +52,7 @@ func (suite *LocalhostTestSuite) TestVerifyClientConsensusState() {
name string
clientState types.ClientState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
{
@ -65,7 +65,7 @@ func (suite *LocalhostTestSuite) TestVerifyClientConsensusState() {
name: "proof verification failed",
clientState: types.NewClientState("chainID", 10),
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -74,7 +74,7 @@ func (suite *LocalhostTestSuite) TestVerifyClientConsensusState() {
tc := tc
err := tc.clientState.VerifyClientConsensusState(
suite.store, suite.aminoCdc, nil, height, "chainA", 0, tc.prefix, tc.proof, nil,
suite.store, suite.cdc, suite.aminoCdc, nil, height, "chainA", 0, tc.prefix, tc.proof, nil,
)
if tc.expPass {
@ -94,7 +94,7 @@ func (suite *LocalhostTestSuite) TestVerifyConnectionState() {
clientState types.ClientState
connection connection.End
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
{
@ -109,7 +109,7 @@ func (suite *LocalhostTestSuite) TestVerifyConnectionState() {
clientState: types.NewClientState("chainID", 10),
connection: conn,
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -138,7 +138,7 @@ func (suite *LocalhostTestSuite) TestVerifyChannelState() {
clientState types.ClientState
channel channel.Channel
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
{
@ -160,7 +160,7 @@ func (suite *LocalhostTestSuite) TestVerifyChannelState() {
clientState: types.NewClientState("chainID", 10),
channel: ch,
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -186,7 +186,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketCommitment() {
clientState types.ClientState
commitment []byte
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
{
@ -215,7 +215,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketCommitment() {
clientState: types.NewClientState("chainID", 10),
commitment: []byte{},
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -224,7 +224,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketCommitment() {
tc := tc
err := tc.clientState.VerifyPacketCommitment(
suite.store, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.commitment, nil,
suite.store, suite.cdc, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.commitment, nil,
)
if tc.expPass {
@ -241,7 +241,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketAcknowledgement() {
clientState types.ClientState
ack []byte
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
{
@ -270,7 +270,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketAcknowledgement() {
clientState: types.NewClientState("chainID", 10),
ack: []byte{},
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -279,7 +279,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketAcknowledgement() {
tc := tc
err := tc.clientState.VerifyPacketAcknowledgement(
suite.store, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.ack, nil,
suite.store, suite.cdc, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, tc.ack, nil,
)
if tc.expPass {
@ -295,7 +295,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketAcknowledgementAbsence() {
name string
clientState types.ClientState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
{
@ -310,7 +310,7 @@ func (suite *LocalhostTestSuite) TestVerifyPacketAcknowledgementAbsence() {
tc := tc
err := tc.clientState.VerifyPacketAcknowledgementAbsence(
suite.store, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, nil,
suite.store, suite.cdc, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, nil,
)
if tc.expPass {
@ -326,7 +326,7 @@ func (suite *LocalhostTestSuite) TestVerifyNextSeqRecv() {
name string
clientState types.ClientState
prefix commitmenttypes.MerklePrefix
proof commitmenttypes.MerkleProof
proof []byte
expPass bool
}{
{
@ -351,7 +351,7 @@ func (suite *LocalhostTestSuite) TestVerifyNextSeqRecv() {
name: "proof verification failed",
clientState: types.NewClientState("chainID", 10),
prefix: commitmenttypes.NewMerklePrefix([]byte("ibc")),
proof: commitmenttypes.MerkleProof{},
proof: []byte{},
expPass: false,
},
}
@ -360,7 +360,7 @@ func (suite *LocalhostTestSuite) TestVerifyNextSeqRecv() {
tc := tc
err := tc.clientState.VerifyNextSequenceRecv(
suite.store, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, nil,
suite.store, suite.cdc, height, tc.prefix, tc.proof, testPortID, testChannelID, testSequence, nil,
)
if tc.expPass {

12
x/ibc/ante/ante_test.go
View File

@ -60,19 +60,21 @@ func (suite *HandlerTestSuite) SetupTest() {
suite.chainB.createConnection(testConnection, testConnection, testClientIDA, testClientIDB, connectiontypes.OPEN)
}
func queryProof(chain *TestChain, key string) (proof commitmenttypes.MerkleProof, height int64) {
func queryProof(chain *TestChain, key string) ([]byte, int64) {
res := chain.App.Query(abci.RequestQuery{
Path: fmt.Sprintf("store/%s/key", host.StoreKey),
Data: []byte(key),
Prove: true,
})
height = res.Height
proof = commitmenttypes.MerkleProof{
height := res.Height
merkleProof := commitmenttypes.MerkleProof{
Proof: res.Proof,
}
return
proof, _ := chain.App.AppCodec().MarshalBinaryBare(&merkleProof)
return proof, height
}
func (suite *HandlerTestSuite) newTx(msg sdk.Msg) sdk.Tx {
@ -93,7 +95,7 @@ func (suite *HandlerTestSuite) TestHandleMsgPacketOrdered() {
cctx, _ := ctx.CacheContext()
// suite.chainA.App.IBCKeeper.ChannelKeeper.SetNextSequenceSend(ctx, packet.SourcePort, packet.SourceChannel, 1)
suite.chainB.App.IBCKeeper.ChannelKeeper.SetPacketCommitment(suite.chainB.GetContext(), packet.SourcePort, packet.SourceChannel, packet.Sequence, channeltypes.CommitPacket(packet))
msg := channel.NewMsgPacket(packet, commitmenttypes.MerkleProof{}, 0, addr1)
msg := channel.NewMsgPacket(packet, []byte{}, 0, addr1)
_, err := handler(cctx, suite.newTx(msg), false)
suite.Error(err, "%+v", err) // channel does not exist

252
x/ibc/spec/04_messages.md
View File

@ -17,7 +17,7 @@ type MsgCreateClient struct {
ClientID string
ClientType string
ConsensusState ConsensusState
Signer AccAddress
Signer sdk.AccAddress
}
```
@ -41,7 +41,7 @@ A light client is updated with a new header using the `MsgUpdateClient`.
type MsgUpdateClient struct {
ClientID string
Header Header
Signer AccAddress
Signer sdk.AccAddress
}
```
@ -59,6 +59,119 @@ height, commitment root and validator sets, which are then stored.
## ICS 03 - Connection
### MsgConnectionOpenInit
A connection is initialized on a light client using the `MsgConnectionOpenInit`.
```go
type MsgConnectionOpenInit struct {
ClientID string
ConnectionID string
Counterparty Counterparty
Signer sdk.AccAddress
}
```
This message is expected to fail if:
- `ClientID` is invalid (see naming requirements)
- `ConnectionID` is invalid (see naming requirements)
- `Counterparty` is empty
- `Signer` is empty
- A Client hasn't been created for the given ID
- A Connection for the given ID already exists
The message creates a connection for the given ID with an INIT state.
### MsgConnectionOpenTry
When a counterparty connection is initialized then a connection is initialized on a light client
using the `MsgConnectionOpenTry`.
```go
type MsgConnectionOpenTry struct {
ClientID string
ConnectionID string
Counterparty Counterparty
CounterpartyVersions []string
ProofInit []byte
ProofHeight uint64
ProofConsensus []byte
ConsensusHeight uint64
Signer sdk.AccAddress
}
```
This message is expected to fail if:
- `ClientID` is invalid (see naming requirements)
- `ConnectionID` is invalid (see naming requirements)
- `Counterparty` is empty
- `CounterpartyVersions` is empty
- `ProofInit` is empty
- `ProofHeight` is zero
- `ProofConsensus` is empty
- `ConsensusHeight` is zero
- `Signer` is empty
- A Client hasn't been created for the given ID
- A Connection for the given ID already exists
- `ProofInit` does not prove that the counterparty connection is in state INIT
- `ProofConsensus` does not prove that the counterparty has the correct consensus state for this chain
The message creates a connection for the given ID with an TRYOPEN State.
### MsgConnectionOpenAck
When a counterparty connection is initialized then a connection is opened on a light client
using the `MsgConnectionOpenAck`.
```go
type MsgConnectionOpenAck struct {
ConnectionID string
Version string
ProofTry []byte
ProofHeight uint64
ProofConsensus []byte
ConsensusHeight uint64
Signer sdk.AccAddress
}
```
This message is expected to fail if:
- `ConnectionID` is invalid (see naming requirements)
- `Version` is empty
- `ProofTry` is empty
- `ProofHeight` is zero
- `ProofConsensus` is empty
- `ConsensusHeight` is zero
- `Signer` is empty
- `ProofTry` does not prove that the counterparty connection is in state TRYOPEN
- `ProofConsensus` does not prove that the counterparty has the correct consensus state for this chain
The message sets the connection state for the given ID to OPEN.
### MsgConnectionOpenConfirm
When a counterparty connection is opened then a connection is opened on a light client using
the `MsgConnectionOpenConfirm`.
```go
type MsgConnectionOpenConfirm struct {
ConnectionID string
ProofAck []byte
ProofHeight uint64
Signer sdk.AccAddress
}
```
This message is expected to fail if:
- `ConnectionID` is invalid (see naming requirements)
- `ProofAck` is empty
- `ProofHeight` is zero
- `Signer` is empty
- A Connection with the given ID does not exist
- `ProofAck` does not prove that the counterparty connection is in state OPEN
The message sets the connection state for the given ID to OPEN.
## ICS 04 - Channels
### MsgChannelOpenInit
@ -76,5 +189,138 @@ type MsgChannelOpenInit struct {
```
This message is expected to fail if:
- `PortID` is invalid (see naming requirements)
- `ChannelID` is invalid (see naming requirements)
- `Channel` is empty
- `Signer` is empty
- A Channel End exists for the given Channel ID and Port ID
## ICS 20 - Fungible Token Transfer
The message creates a channel on chain A with an INIT state for the given Channel ID
and Port ID.
### MsgChannelOpenTry
A channel handshake initialization attempt is acknowledged by a chain B using
the `MsgChannelOpenTry` message.
```go
type MsgChannelOpenTry struct {
PortID string
ChannelID string
Channel Channel
CounterpartyVersion string
ProofInit []byte
ProofHeight uint64
Signer sdk.AccAddress
}
```
This message is expected to fail if:
- `PortID` is invalid (see naming requirements)
- `ChannelID` is invalid (see naming requirements)
- `Channel` is empty
- `CounterpartyVersion` is empty
- `ProofInit` is empty
- `ProofHeight` is zero
- `Signer` is empty
- A Channel End exists for the given Channel and Port ID
- `ProofInit` does not prove that the counterparty's Channel state is in INIT
The message creates a channel on chain B with an TRYOPEN state for the given Channel ID
and Port ID.
### MsgChannelOpenAck
A channel handshake is opened by a chain A using the `MsgChannelOpenAck` message.
```go
type MsgChannelOpenAck struct {
PortID string
ChannelID string
CounterpartyVersion string
ProofTry []byte
ProofHeight uint64
Signer sdk.AccAddress
}
```
This message is expected to fail if:
- `PortID` is invalid (see naming requirements)
- `ChannelID` is invalid (see naming requirements)
- `CounterpartyVersion` is empty
- `ProofTry` is empty
- `ProofHeight` is zero
- `Signer` is empty
- `ProofTry` does not prove that the counterparty's Channel state is in TRYOPEN
The message sets a channel on chain A to state OPEN for the given Channel ID and Port ID.
### MsgChannelOpenConfirm
A channel handshake is confirmed and opened by a chain B using the `MsgChannelOpenConfirm`
message.
```go
type MsgChannelOpenConfirm struct {
PortID string
ChannelID string
ProofAck []byte
ProofHeight uint64
Signer sdk.AccAddress
}
```
This message is expected to fail if:
- `PortID` is invalid (see naming requirements)
- `ChannelID` is invalid (see naming requirements)
- `ProofAck` is empty
- `ProofHeight` is zero
- `Signer` is empty
- `ProofAck` does not prove that the counterparty's Channel state is in OPEN
The message sets a channel on chain B to state OPEN for the given Channel ID and Port ID.
### MsgChannelCloseInit
A channel is closed on chain A using the `MsgChannelCloseInit`.
```go
type MsgChannelCloseInit struct {
PortID string
ChannelID string
Signer sdk.AccAddress
}
```
This message is expected to fail if:
- `PortID` is invalid (see naming requirements)
- `ChannelID` is invalid (see naming requirements)
- `Signer` is empty
- A Channel for the given Port ID and Channel ID does not exist or is already closed
The message closes a channel on chain A for the given Port ID and Channel ID.
### MsgChannelCloseConfirm
A channel is closed on chain B using the `MsgChannelCloseConfirm`.
```go
type MsgChannelCloseConfirm struct {
PortID string
ChannelID string
ProofInit []byte
ProofHeight uint64
Signer sdk.AccAddress
}
```
This message is expected to fail if:
- `PortID` is invalid (see naming requirements)
- `ChannelID` is invalid (see naming requirements)
- `ProofInit` is empty
- `ProofHeight` is zero
- `Signer` is empty
- A Channel for the given Port ID and Channel ID does not exist or is already closed
- `ProofInit` does not prove that the counterparty set its channel to state CLOSED
The message closes a channel on chain B for the given Port ID and Channel ID.

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

@ -132,9 +132,9 @@ func (chain *TestChain) GetContext() sdk.Context {
return chain.App.BaseApp.NewContext(false, chain.CurrentHeader)
}
// QueryProof performs an abci query with the given key and returns the merkle proof for the query
// and the height at which the query was performed.
func (chain *TestChain) QueryProof(key []byte) (commitmenttypes.MerkleProof, uint64) {
// QueryProof performs an abci query with the given key and returns the proto encoded merkle proof
// for the query and the height at which the query was performed.
func (chain *TestChain) QueryProof(key []byte) ([]byte, uint64) {
res := chain.App.Query(abci.RequestQuery{
Path: fmt.Sprintf("store/%s/key", host.StoreKey),
Height: chain.App.LastBlockHeight(),
@ -142,10 +142,13 @@ func (chain *TestChain) QueryProof(key []byte) (commitmenttypes.MerkleProof, uin
Prove: true,
})
proof := commitmenttypes.MerkleProof{
merkleProof := commitmenttypes.MerkleProof{
Proof: res.Proof,
}
proof, err := chain.App.AppCodec().MarshalBinaryBare(&merkleProof)
require.NoError(chain.t, err)
return proof, uint64(res.Height)
}