[POC] Cian & Nikolas Retreat Week

e2e/tests/transfer/forwarding_test.go

@@ -197,8 +197,10 @@ func (s *TransferForwardingTestSuite) TestForwardingWithUnwindSucceeds() {
 			if err != nil {
 				return false, err
 			}
+			t.Logf("expected balance of %d, got %d", testvalues.IBCTransferAmount, balance.Int64())
 			return balance.Int64() == testvalues.IBCTransferAmount, nil
 		})
+
 		s.Require().NoError(err)
 		// packet from B to C is relayed
 		s.AssertPacketRelayed(ctx, chainB, channelBtoC.PortID, channelBtoC.ChannelID, 1)

e2e/testsuite/testconfig.go

@@ -359,7 +359,8 @@ func fromFile() (TestConfig, bool) {
 func populateDefaults(tc TestConfig) TestConfig {
 	for i := range tc.ChainConfigs {
 		if tc.ChainConfigs[i].ChainID == "" {
-			tc.ChainConfigs[i].ChainID = fmt.Sprintf("chain-%d", i+1)
+			// explicitly ensure that all chainIDs have the same revision number.
+			tc.ChainConfigs[i].ChainID = fmt.Sprintf("chain%d-1", i)
 		}
 		if tc.ChainConfigs[i].Binary == "" {
 			tc.ChainConfigs[i].Binary = defaultBinary

modules/core/04-channel/keeper/events.go

@@ -126,7 +126,7 @@ func emitChannelCloseConfirmEvent(ctx context.Context, portID string, channelID
 	})
 }
 
-// emitSendPacketEvent emits an event with packet data along with other packet information for relayer
+// EmitSendPacketEvent emits an event with packet data along with other packet information for relayer
 // to pick up and relay to other chain
 func EmitSendPacketEvent(ctx context.Context, packet types.Packet, channel *types.Channel, timeoutHeight exported.Height) {
 	sdkCtx := sdk.UnwrapSDKContext(ctx) // TODO: https://github.com/cosmos/ibc-go/issues/5917
@@ -139,6 +139,9 @@ func EmitSendPacketEvent(ctx context.Context, packet types.Packet, channel *type
 		sdk.NewAttribute(types.AttributeKeySrcChannel, packet.GetSourceChannel()),
 		sdk.NewAttribute(types.AttributeKeyDstPort, packet.GetDestPort()),
 		sdk.NewAttribute(types.AttributeKeyDstChannel, packet.GetDestChannel()),
+		sdk.NewAttribute(types.AttributeKeyEncoding, packet.Encoding),
+		sdk.NewAttribute(types.AttributeKeyProtocolVersion, packet.ProtocolVersion.String()),
+		sdk.NewAttribute(types.AttributeKeyAppVersion, packet.AppVersion),
 	}
 
 	if channel != nil {
@@ -176,6 +179,9 @@ func EmitRecvPacketEvent(ctx context.Context, packet types.Packet, channel *type
 		sdk.NewAttribute(types.AttributeKeySrcChannel, packet.GetSourceChannel()),
 		sdk.NewAttribute(types.AttributeKeyDstPort, packet.GetDestPort()),
 		sdk.NewAttribute(types.AttributeKeyDstChannel, packet.GetDestChannel()),
+		sdk.NewAttribute(types.AttributeKeyEncoding, packet.Encoding),
+		sdk.NewAttribute(types.AttributeKeyProtocolVersion, packet.ProtocolVersion.String()),
+		sdk.NewAttribute(types.AttributeKeyAppVersion, packet.AppVersion),
 	}
 
 	if channel != nil {

modules/core/04-channel/keeper/packet.go

@@ -14,6 +14,7 @@ import (
 	connectiontypes "github.com/cosmos/ibc-go/v9/modules/core/03-connection/types"
 	"github.com/cosmos/ibc-go/v9/modules/core/04-channel/types"
 	"github.com/cosmos/ibc-go/v9/modules/core/exported"
+	"github.com/cosmos/ibc-go/v9/modules/core/legacy"
 )
 
 // SendPacket is called by a module in order to send an IBC packet on a channel.
@@ -283,6 +284,20 @@ func (k *Keeper) WriteAcknowledgement(
 	packet exported.PacketI,
 	acknowledgement exported.Acknowledgement,
 ) error {
+	v1Packet, ok := packet.(types.Packet)
+	if !ok {
+		return errorsmod.Wrapf(types.ErrInvalidPacket, "expected packet type %T, got %T", types.Packet{}, packet)
+	}
+
+	// if an acknowledgement is being written for a V2 packet, we need to ensure that the acknowledgement
+	// structure uses the multi ack structure.
+	// TODO: this is a bit gross / hacky, can we ensure that async acks will always have the correct structure?
+	if v1Packet.ProtocolVersion == types.IBC_VERSION_2 {
+		if _, ok := acknowledgement.(*legacy.MultiAck); !ok {
+			acknowledgement = legacy.NewLMultiAck(k.cdc, acknowledgement, packet.GetDestPort())
+		}
+	}
+
 	channel, found := k.GetChannel(ctx, packet.GetDestPort(), packet.GetDestChannel())
 	if !found {
 		return errorsmod.Wrap(types.ErrChannelNotFound, packet.GetDestChannel())

modules/core/04-channel/types/errors.go

@@ -58,4 +58,5 @@ var (
 	ErrTimeoutElapsed                  = errorsmod.Register(SubModuleName, 40, "timeout elapsed")
 	ErrPruningSequenceStartNotFound    = errorsmod.Register(SubModuleName, 41, "pruning sequence start not found")
 	ErrRecvStartSequenceNotFound       = errorsmod.Register(SubModuleName, 42, "recv start sequence not found")
+	ErrInvalidPayload                  = errorsmod.Register(SubModuleName, 43, "invalid payload")
 )

modules/core/04-channel/types/events.go

@@ -42,6 +42,9 @@ const (
 	AttributeKeyDstChannel       = "packet_dst_channel"
 	AttributeKeyChannelOrdering  = "packet_channel_ordering"
 	AttributeKeyConnection       = "packet_connection"
+	AttributeKeyEncoding         = "packet_data_encoding"
+	AttributeKeyProtocolVersion  = "packet_protocol_version"
+	AttributeKeyAppVersion       = "packet_app_version"
 )
 
 // IBC channel events vars

modules/core/04-channel/types/packet.go

@@ -102,7 +102,7 @@ func commitV2Packet(packet Packet) []byte {
 }
 
 // CommitPacketV2 returns the V2 packet commitment bytes. The commitment consists of:
-// sha256_hash(timeout) + sha256_hash(destinationID) + sha256_hash(packetData) from a given packet.
+// sha256_hash(timeout) + sha256_hash(destinationID) + sha256_hash(packetData) for a given packet.
 // This results in a fixed length preimage.
 // NOTE: A fixed length preimage is ESSENTIAL to prevent relayers from being able
 // to malleate the packet fields and create a commitment hash that matches the original packet.
@@ -137,6 +137,56 @@ func hashPacketData(data PacketData) []byte {
 	return hash[:]
 }
 
+func (p PacketV2) ValidateBasic() error {
+	// TODO: temporarily assume a single packet data
+	if len(p.Data) != 1 {
+		return errorsmod.Wrap(ErrInvalidPacket, "packet data length must be 1")
+	}
+
+	for _, pd := range p.Data {
+		if err := host.PortIdentifierValidator(pd.SourcePort); err != nil {
+			return errorsmod.Wrap(err, "invalid source port ID")
+		}
+		if err := host.PortIdentifierValidator(pd.DestinationPort); err != nil {
+			return errorsmod.Wrap(err, "invalid destination port ID")
+		}
+
+		if err := pd.Payload.Validate(); err != nil {
+			return err
+		}
+	}
+
+	if err := host.ChannelIdentifierValidator(p.SourceId); err != nil {
+		return errorsmod.Wrap(err, "invalid source channel ID")
+	}
+	if err := host.ChannelIdentifierValidator(p.DestinationId); err != nil {
+		return errorsmod.Wrap(err, "invalid destination channel ID")
+	}
+
+	if p.Sequence == 0 {
+		return errorsmod.Wrap(ErrInvalidPacket, "packet sequence cannot be 0")
+	}
+	if p.TimeoutTimestamp == 0 {
+		return errorsmod.Wrap(ErrInvalidPacket, "packet timeout timestamp cannot be 0")
+	}
+
+	return nil
+}
+
+// Validate validates a PacketV2 Payload.
+func (p Payload) Validate() error {
+	if strings.TrimSpace(p.Version) == "" {
+		return errorsmod.Wrap(ErrInvalidPayload, "payload version cannot be empty")
+	}
+	if strings.TrimSpace(p.Encoding) == "" {
+		return errorsmod.Wrap(ErrInvalidPayload, "payload encoding cannot be empty")
+	}
+	if len(p.Value) == 0 {
+		return errorsmod.Wrap(ErrInvalidPayload, "payload value cannot be empty")
+	}
+	return nil
+}
+
 // CommitAcknowledgement returns the hash of commitment bytes
 func CommitAcknowledgement(data []byte) []byte {
 	hash := sha256.Sum256(data)
@@ -271,6 +321,10 @@ func ConvertPacketV1toV2(packet Packet) (PacketV2, error) {
 		return PacketV2{}, errorsmod.Wrapf(ErrInvalidPacket, "expected protocol version %s, got %s instead", IBC_VERSION_2, packet.ProtocolVersion)
 	}
 
+	if !packet.TimeoutHeight.IsZero() {
+		return PacketV2{}, errorsmod.Wrap(ErrInvalidPacket, "timeout height must be zero")
+	}
+
 	encoding := strings.TrimSpace(packet.Encoding)
 	if encoding == "" {
 		encoding = "json"

modules/core/04-channel/types/timeout.go

@@ -14,6 +14,11 @@ func NewTimeout(height clienttypes.Height, timestamp uint64) Timeout {
 	}
 }
 
+// NewTimeoutWithTimestamp returns a new Timeout instance with a timestamp.
+func NewTimeoutWithTimestamp(timestamp uint64) Timeout {
+	return NewTimeout(clienttypes.ZeroHeight(), timestamp)
+}
+
 // IsValid returns true if either the height or timestamp is non-zero.
 func (t Timeout) IsValid() bool {
 	return !t.Height.IsZero() || t.Timestamp != 0

modules/core/24-host/packet_keys.go

@@ -12,6 +12,7 @@ const (
 	KeyPacketReceiptPrefix    = "receipts"
 	KeyPruningSequenceStart   = "pruningSequenceStart"
 	KeyRecvStartSequence      = "recvStartSequence"
+	KeyMultiAck               = "multiAck"
 )
 
 // ICS04

modules/core/keeper/msg_server.go

@@ -4,19 +4,18 @@ import (
 	"context"
 	"errors"
 	"fmt"
-
 	errorsmod "cosmossdk.io/errors"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
-	capabilitytypes "github.com/cosmos/ibc-go/modules/capability/types"
 	clienttypes "github.com/cosmos/ibc-go/v9/modules/core/02-client/types"
 	connectiontypes "github.com/cosmos/ibc-go/v9/modules/core/03-connection/types"
 	"github.com/cosmos/ibc-go/v9/modules/core/04-channel/keeper"
 	channeltypes "github.com/cosmos/ibc-go/v9/modules/core/04-channel/types"
 	porttypes "github.com/cosmos/ibc-go/v9/modules/core/05-port/types"
 	ibcerrors "github.com/cosmos/ibc-go/v9/modules/core/errors"
 	"github.com/cosmos/ibc-go/v9/modules/core/internal/telemetry"
+	"github.com/cosmos/ibc-go/v9/modules/core/legacy"
 	packetservertypes "github.com/cosmos/ibc-go/v9/modules/core/packet-server/types"
 	coretypes "github.com/cosmos/ibc-go/v9/modules/core/types"
 )
@@ -431,7 +430,7 @@ func (k *Keeper) RecvPacket(goCtx context.Context, msg *channeltypes.MsgRecvPack
 		return nil, errorsmod.Wrap(err, "Invalid address for msg Signer")
 	}
 
-	packetHandler, _, _, err = k.getPacketHandlerAndModule(ctx, msg.Packet.ProtocolVersion, msg.Packet.DestinationPort, msg.Packet.DestinationChannel)
+	packetHandler, err = k.getPacketHandler(msg.Packet.ProtocolVersion)
 	if err != nil {
 		ctx.Logger().Error("receive packet failed", "port-id", msg.Packet.DestinationPort, "channel-id", msg.Packet.DestinationChannel, "error", errorsmod.Wrap(err, "could not retrieve module from port-id"))
 		return nil, errorsmod.Wrap(err, "could not retrieve module from port-id")
@@ -480,6 +479,11 @@ func (k *Keeper) RecvPacket(goCtx context.Context, msg *channeltypes.MsgRecvPack
 	// NOTE: IBC applications modules may call the WriteAcknowledgement asynchronously if the
 	// acknowledgement is nil.
 	if ack != nil {
+		// the ack structure for V2 uses multi ack, so we need to convert the old structure to the new.
+		if msg.Packet.ProtocolVersion == channeltypes.IBC_VERSION_2 {
+			ack = legacy.NewLMultiAck(k.cdc, ack, msg.Packet.DestinationPort)
+		}
+
 		if err := packetHandler.WriteAcknowledgement(ctx, msg.Packet, ack); err != nil {
 			return nil, err
 		}
@@ -503,7 +507,7 @@ func (k *Keeper) Timeout(goCtx context.Context, msg *channeltypes.MsgTimeout) (*
 		return nil, errorsmod.Wrap(err, "Invalid address for msg Signer")
 	}
 
-	packetHandler, _, _, err = k.getPacketHandlerAndModule(ctx, msg.Packet.ProtocolVersion, msg.Packet.SourcePort, msg.Packet.SourceChannel)
+	packetHandler, err = k.getPacketHandler(msg.Packet.ProtocolVersion)
 	if err != nil {
 		ctx.Logger().Error("timeout failed", "port-id", msg.Packet.SourcePort, "channel-id", msg.Packet.SourceChannel, "error", errorsmod.Wrap(err, "could not retrieve module from port-id"))
 		return nil, errorsmod.Wrap(err, "could not retrieve module from port-id")
@@ -612,7 +616,7 @@ func (k *Keeper) Acknowledgement(goCtx context.Context, msg *channeltypes.MsgAck
 		return nil, errorsmod.Wrap(err, "Invalid address for msg Signer")
 	}
 
-	packetHandler, _, _, err = k.getPacketHandlerAndModule(ctx, msg.Packet.ProtocolVersion, msg.Packet.SourcePort, msg.Packet.SourceChannel)
+	packetHandler, err = k.getPacketHandler(msg.Packet.ProtocolVersion)
 	if err != nil {
 		ctx.Logger().Error("acknowledgement failed", "port-id", msg.Packet.SourcePort, "channel-id", msg.Packet.SourceChannel, "error", errorsmod.Wrap(err, "could not retrieve module from port-id"))
 		return nil, errorsmod.Wrap(err, "could not retrieve module from port-id")
@@ -1050,17 +1054,15 @@ func convertToErrorEvents(events sdk.Events) sdk.Events {
 	return newEvents
 }
 
-// getPacketHandlerAndModule returns the appropriate packet handler, module name, and capability
-// given the provided port and channel identifiers. The packet handler is determined by the
-// provided protocol version. An error is returned if the module cannot be found or if the protocol
-// version is not supported.
-func (k *Keeper) getPacketHandlerAndModule(ctx sdk.Context, protocolVersion channeltypes.IBCVersion, port, channel string) (PacketHandler, string, *capabilitytypes.Capability, error) {
+// getPacketHandler returns the appropriate packet handler given the provided protocol version.
+// An error is returned if the module cannot be found or if the protocol version is not supported.
+func (k *Keeper) getPacketHandler(protocolVersion channeltypes.IBCVersion) (PacketHandler, error) {
 	switch protocolVersion {
 	case channeltypes.IBC_VERSION_UNSPECIFIED, channeltypes.IBC_VERSION_1:
-		return k.ChannelKeeper, "", nil, nil
+		return k.ChannelKeeper, nil
 	case channeltypes.IBC_VERSION_2:
-		return k.PacketServerKeeper, port, nil, nil
+		return k.PacketServerKeeper, nil
 	default:
-		return nil, "", nil, fmt.Errorf("unsupported protocol %s", protocolVersion)
+		return nil, fmt.Errorf("unsupported protocol %s", protocolVersion)
 	}
 }