Merge pull request #2174 from CosmWasm/jawoznia/test/ibc2-send-msg

Add E2E test for IBC2SendMsg (#2165)

Author: jawoznia

app/app.go

@@ -594,6 +594,7 @@ func NewWasmApp(
 		distrkeeper.NewQuerier(app.DistrKeeper),
 		app.IBCKeeper.ChannelKeeper,
 		app.IBCKeeper.ChannelKeeper,
+		app.IBCKeeper.ChannelKeeperV2,
 		app.TransferKeeper,
 		app.MsgServiceRouter(),
 		app.GRPCQueryRouter(),

tests/e2e/ibc2_test.go

@@ -2,6 +2,7 @@ package e2e_test
 
 import (
 	"testing"
+	"time"
 
 	ibctransfertypes "github.com/cosmos/ibc-go/v10/modules/apps/transfer/types"
 	channeltypes "github.com/cosmos/ibc-go/v10/modules/core/04-channel/types"
@@ -23,19 +24,21 @@ type State struct {
 	IBC2PacketReceiveCounter uint32 `json:"ibc2_packet_receive_counter"`
 }
 
-func TestIBC2ReceiveEntrypoint(t *testing.T) {
+func TestIBC2SendMsg(t *testing.T) {
 	coord := wasmibctesting.NewCoordinator(t, 2)
 	chainA := wasmibctesting.NewWasmTestChain(coord.GetChain(ibctesting.GetChainID(1)))
 	chainB := wasmibctesting.NewWasmTestChain(coord.GetChain(ibctesting.GetChainID(2)))
-
 	contractCodeA := chainA.StoreCodeFile("./testdata/ibc2.wasm").CodeID
 	contractAddrA := chainA.InstantiateContract(contractCodeA, []byte(`{}`))
 	contractPortA := wasmkeeper.PortIDForContractV2(contractAddrA)
+	require.NotEmpty(t, contractAddrA)
 
 	contractCodeB := chainB.StoreCodeFile("./testdata/ibc2.wasm").CodeID
+	// Skip initial contract address to not overlap with ChainA
+	_ = chainB.InstantiateContract(contractCodeB, []byte(`{}`))
 	contractAddrB := chainB.InstantiateContract(contractCodeB, []byte(`{}`))
 	contractPortB := wasmkeeper.PortIDForContractV2(contractAddrB)
-	require.NotEmpty(t, contractAddrA)
+	require.NotEmpty(t, contractAddrB)
 
 	path := wasmibctesting.NewWasmPath(chainA, chainB)
 	path.EndpointA.ChannelConfig = &ibctesting.ChannelConfig{
@@ -51,15 +54,42 @@ func TestIBC2ReceiveEntrypoint(t *testing.T) {
 
 	path.Path.SetupV2()
 
-	var err error
-	timeoutTimestamp := chainA.GetTimeoutTimestampSecs()
-	packet, err := path.EndpointB.MsgSendPacket(timeoutTimestamp, mockv2.NewMockPayload(contractPortB, contractPortA))
+	// IBC v2 Payload from contract on Chain B to contract on Chain A
+	payload := mockv2.NewMockPayload(contractPortB, contractPortA)
+
+	// Message timeout
+	timeoutTimestamp := uint64(chainB.GetContext().BlockTime().Add(time.Minute * 5).Unix())
+
+	_, err := path.EndpointB.MsgSendPacket(timeoutTimestamp, payload)
 	require.NoError(t, err)
-	err = path.EndpointA.MsgRecvPacket(packet)
+
+	// First message send through test
+	err = wasmibctesting.RelayPendingPacketsV2(path)
 	require.NoError(t, err)
 
+	// Check if counter was incremented in the recv entry point
 	var response State
+
 	err = chainA.SmartQuery(contractAddrA.String(), QueryMsg{QueryState: struct{}{}}, &response)
 	require.NoError(t, err)
 	require.Equal(t, uint32(1), response.IBC2PacketReceiveCounter)
+
+	// The counters on both Chains are both incremented in every iteration of the loop,
+	// because once the first relaying loop in `RelayPendingPacketsV2` the array of
+	// pending packets on the other chain is updated with new packet send from the contract.
+	for i := 1; i <= 100; i++ {
+		// Relay message sent by contract
+		err = wasmibctesting.RelayPendingPacketsV2(path)
+		require.NoError(t, err)
+
+		// Check counter in contract A
+		err = chainA.SmartQuery(contractAddrA.String(), QueryMsg{QueryState: struct{}{}}, &response)
+		require.NoError(t, err)
+		require.Equal(t, uint32(i+1), response.IBC2PacketReceiveCounter)
+
+		// Check counter in contract B
+		err = chainB.SmartQuery(contractAddrB.String(), QueryMsg{QueryState: struct{}{}}, &response)
+		require.NoError(t, err)
+		require.Equal(t, uint32(i), response.IBC2PacketReceiveCounter)
+	}
 }

tests/e2e/testdata/ibc2.wasm

@@ -19,6 +19,7 @@ import (
 	"github.com/cosmos/gogoproto/proto"
 	clienttypes "github.com/cosmos/ibc-go/v10/modules/core/02-client/types"
 	channeltypes "github.com/cosmos/ibc-go/v10/modules/core/04-channel/types"
+	channeltypesv2 "github.com/cosmos/ibc-go/v10/modules/core/04-channel/v2/types"
 	host "github.com/cosmos/ibc-go/v10/modules/core/24-host"
 	ibctesting "github.com/cosmos/ibc-go/v10/testing"
 	"github.com/stretchr/testify/require"
@@ -55,21 +56,82 @@ func (app WasmTestApp) GetTxConfig() client.TxConfig {
 type WasmTestChain struct {
 	*ibctesting.TestChain
 
-	PendingSendPackets *[]channeltypes.Packet
+	PendingSendPackets   *[]channeltypes.Packet
+	PendingSendPacketsV2 *[]channeltypesv2.Packet
 }
 
 func NewWasmTestChain(chain *ibctesting.TestChain) *WasmTestChain {
-	res := WasmTestChain{TestChain: chain, PendingSendPackets: &[]channeltypes.Packet{}}
+	res := WasmTestChain{TestChain: chain, PendingSendPackets: &[]channeltypes.Packet{}, PendingSendPacketsV2: &[]channeltypesv2.Packet{}}
 	res.SendMsgsOverride = res.OverrideSendMsgs
 	return &res
 }
 
+func (chain *WasmTestChain) CaptureIBCEventsV2(result *abci.ExecTxResult) {
+	toSend, err := ParsePacketsFromEventsV2(channeltypesv2.EventTypeSendPacket, result.Events)
+	require.NoError(chain, err)
+	if len(toSend) > 0 {
+		// Keep a queue on the chain that we can relay in tests
+		*chain.PendingSendPacketsV2 = append(*chain.PendingSendPacketsV2, toSend...)
+	}
+}
+
+// TODO: Remove this once it's implemented in the `ibc-go`.
+// https://github.com/cosmos/ibc-go/issues/8284
+//
+// ParsePacketsFromEventsV2 parses events emitted from a MsgRecvPacket and returns
+// all the packets found.
+// Returns an error if no packet is found.
+func ParsePacketsFromEventsV2(eventType string, events []abci.Event) ([]channeltypesv2.Packet, error) {
+	ferr := func(err error) ([]channeltypesv2.Packet, error) {
+		return nil, fmt.Errorf("wasmd.ParsePacketsFromEventsV2: %w", err)
+	}
+	var packets []channeltypesv2.Packet
+	for _, ev := range events {
+		if ev.Type == eventType {
+			for _, attr := range ev.Attributes {
+				switch attr.Key {
+				case channeltypesv2.AttributeKeyEncodedPacketHex:
+					data, err := hex.DecodeString(attr.Value)
+					if err != nil {
+						return ferr(err)
+					}
+					var packet channeltypesv2.Packet
+					err = proto.Unmarshal(data, &packet)
+					if err != nil {
+						return ferr(err)
+					}
+					packets = append(packets, packet)
+
+				default:
+					continue
+				}
+			}
+		}
+	}
+	return packets, nil
+}
+
 func (chain *WasmTestChain) CaptureIBCEvents(result *abci.ExecTxResult) {
 	toSend, _ := ibctesting.ParsePacketsFromEvents(channeltypes.EventTypeSendPacket, result.Events)
+
+	// IBCv1 and IBCv2 `EventTypeSendPacket` are the same
+	// and the [`ParsePacketsFromEvents`] parses both of them as they were IBCv1
+	// so we have to filter them here.
+	//
+	// While parsing IBC2 events in IBC1 context the only overlapping event is the
+	// `AttributeKeyTimeoutTimestamp` so to determine if the wrong set of events was parsed
+	// we should be able to check if any other field in the packet is not set.
+	var toSendFiltered []channeltypes.Packet
+	for _, packet := range toSend {
+		if packet.SourcePort != "" {
+			toSendFiltered = append(toSendFiltered, packet)
+		}
+	}
+
 	// require.NoError(chain, err)
-	if len(toSend) > 0 {
+	if len(toSendFiltered) > 0 {
 		// Keep a queue on the chain that we can relay in tests
-		*chain.PendingSendPackets = append(*chain.PendingSendPackets, toSend...)
+		*chain.PendingSendPackets = append(*chain.PendingSendPackets, toSendFiltered...)
 	}
 }
 
@@ -78,6 +140,7 @@ func (chain *WasmTestChain) OverrideSendMsgs(msgs ...sdk.Msg) (*abci.ExecTxResul
 	result, err := chain.TestChain.SendMsgs(msgs...)
 	chain.SendMsgsOverride = chain.OverrideSendMsgs
 	chain.CaptureIBCEvents(result)
+	chain.CaptureIBCEventsV2(result)
 	return result, err
 }
 
@@ -297,6 +360,45 @@ func RelayPacketWithoutAck(path *ibctesting.Path, packet channeltypes.Packet) er
 	return fmt.Errorf("packet commitment does not exist on either endpoint for provided packet")
 }
 
+// RelayPacketWithoutAckV2 attempts to relay the packet first on EndpointA and then on EndpointB
+// if EndpointA does not contain a packet commitment for that packet. An error is returned
+// if a relay step fails or the packet commitment does not exist on either endpoint.
+// In contrast to RelayPacket, this function does not acknowledge the packet and expects it to have no acknowledgement yet.
+// It is useful for testing async acknowledgement.
+func RelayPacketWithoutAckV2(path *WasmPath, packet channeltypesv2.Packet) error {
+	pc := path.EndpointA.Chain.App.GetIBCKeeper().ChannelKeeperV2.GetPacketCommitment(path.EndpointA.Chain.GetContext(), packet.GetSourceClient(), packet.GetSequence())
+	if bytes.Equal(pc, channeltypesv2.CommitPacket(packet)) {
+		// packet found, relay from A to B
+		if err := path.EndpointB.UpdateClient(); err != nil {
+			return err
+		}
+
+		err := path.EndpointB.MsgRecvPacket(packet)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	}
+
+	pc = path.EndpointB.Chain.App.GetIBCKeeper().ChannelKeeperV2.GetPacketCommitment(path.EndpointB.Chain.GetContext(), packet.GetSourceClient(), packet.GetSequence())
+	if bytes.Equal(pc, channeltypesv2.CommitPacket(packet)) {
+		// packet found, relay B to A
+		if err := path.EndpointA.UpdateClient(); err != nil {
+			return err
+		}
+
+		err := path.EndpointA.MsgRecvPacket(packet)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	}
+
+	return fmt.Errorf("packet commitment does not exist on either endpointV2 for provided packet")
+}
+
 type WasmPath struct {
 	ibctesting.Path
 
@@ -338,6 +440,34 @@ func RelayAndAckPendingPackets(path *WasmPath) error {
 	return nil
 }
 
+// RelayAndAckPendingPackets sends pending packages from path.EndpointA to the counterparty chain and acks
+func RelayPendingPacketsV2(path *WasmPath) error {
+	// get all the packet to relay src->dest
+	src := path.EndpointA
+	require.NoError(path.chainA, src.UpdateClient())
+	path.chainA.Logf("Relay: %d PacketsV2 A->B, %d PacketsV2 B->A\n", len(*path.chainA.PendingSendPacketsV2), len(*path.chainB.PendingSendPacketsV2))
+	for _, v := range *path.chainA.PendingSendPacketsV2 {
+		err := RelayPacketWithoutAckV2(path, v)
+		if err != nil {
+			return err
+		}
+
+		*path.chainA.PendingSendPacketsV2 = (*path.chainA.PendingSendPacketsV2)[1:]
+	}
+
+	src = path.EndpointB
+	require.NoError(path.chainB, src.UpdateClient())
+	for _, v := range *path.chainB.PendingSendPacketsV2 {
+		err := RelayPacketWithoutAckV2(path, v)
+		if err != nil {
+			return err
+		}
+
+		*path.chainB.PendingSendPacketsV2 = (*path.chainB.PendingSendPacketsV2)[1:]
+	}
+	return nil
+}
+
 // TimeoutPendingPackets returns the package to source chain to let the IBC app revert any operation.
 // from A to B
 func TimeoutPendingPackets(coord *ibctesting.Coordinator, path *WasmPath) error {

tests/wasmibctesting/utils.go

@@ -695,6 +695,7 @@ func setupKeeper(t *testing.T) (*Keeper, sdk.Context) {
 		nil,
 		nil,
 		nil,
+		nil,
 		tempDir,
 		nodeConfig,
 		wasmtypes.VMConfig{},

x/wasm/keeper/genesis_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	wasmvmtypes "github.com/CosmWasm/wasmvm/v2/types"
+	channeltypesv2 "github.com/cosmos/ibc-go/v10/modules/core/04-channel/v2/types"
 
 	errorsmod "cosmossdk.io/errors"
 
@@ -40,6 +41,7 @@ func NewDefaultMessageHandler(
 	keeper *Keeper,
 	router MessageRouter,
 	ics4Wrapper types.ICS4Wrapper,
+	channelKeeperV2 types.ChannelKeeperV2,
 	bankKeeper types.Burner,
 	cdc codec.Codec,
 	portSource types.ICS20TransferPortSource,
@@ -52,6 +54,7 @@ func NewDefaultMessageHandler(
 	return NewMessageHandlerChain(
 		NewSDKMessageHandler(cdc, router, encoders),
 		NewIBCRawPacketHandler(ics4Wrapper, keeper),
+		NewIBC2RawPacketHandler(channelKeeperV2),
 		NewBurnCoinMessageHandler(bankKeeper),
 	)
 }
@@ -258,6 +261,75 @@ func (h IBCRawPacketHandler) DispatchMsg(ctx sdk.Context, _ sdk.AccAddress, cont
 	}
 }
 
+// IBC2RawPacketHandler handles IBC2Msg received from CosmWasm.
+type IBC2RawPacketHandler struct {
+	channelKeeperV2 types.ChannelKeeperV2
+}
+
+// NewIBCRawPacketHandler constructor
+func NewIBC2RawPacketHandler(channelKeeperV2 types.ChannelKeeperV2) IBC2RawPacketHandler {
+	return IBC2RawPacketHandler{
+		channelKeeperV2: channelKeeperV2,
+	}
+}
+
+// DispatchMsg publishes a raw IBC2 packet onto the channel.
+func (h IBC2RawPacketHandler) DispatchMsg(ctx sdk.Context,
+	contractAddr sdk.AccAddress, contractIBC2PortID string, msg wasmvmtypes.CosmosMsg,
+) ([]sdk.Event, [][]byte, [][]*codectypes.Any, error) {
+	if msg.IBC2 == nil {
+		return nil, nil, nil, types.ErrUnknownMsg
+	}
+	switch {
+	case msg.IBC2.SendPacket != nil:
+		if contractIBC2PortID == "" {
+			return nil, nil, nil, errorsmod.Wrapf(types.ErrUnsupportedForContract, "ibc2 not supported")
+		}
+		contractIBCChannelID := msg.IBC2.SendPacket.ChannelID
+		if contractIBCChannelID == "" {
+			return nil, nil, nil, errorsmod.Wrapf(types.ErrEmpty, "ibc2 channel")
+		}
+
+		var payloads []channeltypesv2.Payload
+		for _, payload := range msg.IBC2.SendPacket.Payloads {
+			payloads = append(payloads, channeltypesv2.Payload{
+				SourcePort:      payload.SourcePort,
+				DestinationPort: payload.DestinationPort,
+				Version:         payload.Version,
+				Encoding:        payload.Encoding,
+				Value:           payload.Value,
+			})
+		}
+		ibcGoMsg := &channeltypesv2.MsgSendPacket{
+			SourceClient:     msg.IBC2.SendPacket.ChannelID,
+			TimeoutTimestamp: msg.IBC2.SendPacket.Timeout,
+			Payloads:         payloads,
+			Signer:           contractAddr.String(),
+		}
+
+		ibcGoResp, err := h.channelKeeperV2.SendPacket(ctx, ibcGoMsg)
+		if err != nil {
+			return nil, nil, nil, errorsmod.Wrap(err, "channel")
+		}
+		moduleLogger(ctx).Debug("ibc2 packet set", "seq", ibcGoResp.Sequence)
+
+		resp := &types.MsgIBCSendResponse{Sequence: ibcGoResp.Sequence}
+		val, err := resp.Marshal()
+		if err != nil {
+			return nil, nil, nil, errorsmod.Wrap(err, "failed to marshal IBC2 send response")
+		}
+		any, err := codectypes.NewAnyWithValue(resp)
+		if err != nil {
+			return nil, nil, nil, errorsmod.Wrap(err, "failed to convert IBC2 send response to Any")
+		}
+		msgResponses := [][]*codectypes.Any{{any}}
+
+		return nil, [][]byte{val}, msgResponses, nil
+	default:
+		return nil, nil, nil, types.ErrUnknownMsg
+	}
+}
+
 var _ Messenger = MessageHandlerFunc(nil)
 
 // MessageHandlerFunc is a helper to construct a function based message handler.

x/wasm/keeper/handler_plugin.go

@@ -133,7 +133,7 @@ func (k Keeper) OnRecvIBC2Packet(
 	}
 
 	// note submessage reply results can overwrite the `Acknowledgement` data
-	data, err := k.handleContractResponse(ctx, contractAddr, contractInfo.IBCPortID, res.Ok.Messages, res.Ok.Attributes, res.Ok.Acknowledgement, res.Ok.Events)
+	data, err := k.handleContractResponse(ctx, contractAddr, contractInfo.IBC2PortID, res.Ok.Messages, res.Ok.Attributes, res.Ok.Acknowledgement, res.Ok.Events)
 	if err != nil {
 		// submessage errors result in error ACK with state reverted. Error message is redacted
 		return channeltypesv2.RecvPacketResult{