refactor: ibc port router for app callbacks

modules/apps/27-interchain-accounts/controller/ibc_middleware.go

@@ -170,6 +170,56 @@ func (im IBCMiddleware) OnChanCloseConfirm(
 	return nil
 }
 
+// OnSendPacket implements the IBCModule interface.
+func (im IBCMiddleware) OnSendPacket(
+	ctx sdk.Context,
+	portID string,
+	channelID string,
+	sequence uint64,
+	timeoutHeight clienttypes.Height,
+	timeoutTimestamp uint64,
+	data []byte,
+	signer string,
+) error {
+	if !im.keeper.GetParams(ctx).ControllerEnabled {
+		return types.ErrControllerSubModuleDisabled
+	}
+
+	controllerPortID, err := icatypes.NewControllerPortID(signer)
+	if err != nil {
+		return err
+	}
+
+	if controllerPortID != portID {
+		return errorsmod.Wrap(ibcerrors.ErrUnauthorized, "signer is not owner of interchain account channel")
+	}
+
+	connectionID, err := im.keeper.GetConnectionID(ctx, portID, channelID)
+	if err != nil {
+		return err
+	}
+
+	activeChannelID, found := im.keeper.GetOpenActiveChannel(ctx, connectionID, portID)
+	if !found {
+		return errorsmod.Wrapf(icatypes.ErrActiveChannelNotFound, "failed to retrieve active channel on connection %s for port %s", connectionID, portID)
+	}
+
+	if activeChannelID != channelID {
+		return errorsmod.Wrapf(ibcerrors.ErrUnauthorized, "active channel ID does not match provided channelID. expected %s, got %s", activeChannelID, channelID)
+	}
+
+	var icaPacketData icatypes.InterchainAccountPacketData
+	if err := icaPacketData.UnmarshalJSON(data); err != nil {
+		return err
+	}
+
+	if err := icaPacketData.ValidateBasic(); err != nil {
+		return errorsmod.Wrap(err, "invalid interchain account packet data")
+	}
+
+	return nil
+}
+
 // OnRecvPacket implements the IBCMiddleware interface
 func (IBCMiddleware) OnRecvPacket(
 	ctx sdk.Context,

modules/apps/27-interchain-accounts/host/ibc_module.go

@@ -11,6 +11,7 @@ import (
 	"github.com/cosmos/ibc-go/v8/modules/apps/27-interchain-accounts/host/keeper"
 	"github.com/cosmos/ibc-go/v8/modules/apps/27-interchain-accounts/host/types"
 	icatypes "github.com/cosmos/ibc-go/v8/modules/apps/27-interchain-accounts/types"
+	clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
 	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
 	porttypes "github.com/cosmos/ibc-go/v8/modules/core/05-port/types"
 	ibcerrors "github.com/cosmos/ibc-go/v8/modules/core/errors"
@@ -110,6 +111,20 @@ func (im IBCModule) OnChanCloseConfirm(
 	return im.keeper.OnChanCloseConfirm(ctx, portID, channelID)
 }
 
+// OnSendPacket implements the IBCModule interface.
+func (IBCModule) OnSendPacket(
+	ctx sdk.Context,
+	portID string,
+	channelID string,
+	sequence uint64,
+	timeoutHeight clienttypes.Height,
+	timeoutTimestamp uint64,
+	data []byte,
+	signer string,
+) error {
+	return errorsmod.Wrap(ibcerrors.ErrInvalidRequest, "cannot send packet on icahost")
+}
+
 // OnRecvPacket implements the IBCModule interface
 func (im IBCModule) OnRecvPacket(
 	ctx sdk.Context,

modules/apps/29-fee/ibc_middleware.go

@@ -212,6 +212,20 @@ func (im IBCMiddleware) OnChanCloseConfirm(
 	return im.keeper.RefundFeesOnChannelClosure(ctx, portID, channelID)
 }
 
+// OnSendPacket implements the IBCModule interface.
+func (IBCMiddleware) OnSendPacket(
+	ctx sdk.Context,
+	portID string,
+	channelID string,
+	sequence uint64,
+	timeoutHeight clienttypes.Height,
+	timeoutTimestamp uint64,
+	data []byte,
+	signer string,
+) error {
+	return nil
+}
+
 // OnRecvPacket implements the IBCMiddleware interface.
 // If fees are not enabled, this callback will default to the ibc-core packet callback
 func (im IBCMiddleware) OnRecvPacket(

modules/apps/callbacks/ibc_middleware.go

@@ -99,12 +99,31 @@ func (im IBCMiddleware) SendPacket(
 		return 0, err
 	}
 
+	if err := im.OnSendPacket(ctx, sourcePort, sourceChannel, seq, timeoutHeight, timeoutTimestamp, data, ""); err != nil {
+		return 0, err
+	}
+
+	return seq, nil
+}
+
+// OnSendPacket implements the IBCModule interface.
+func (im IBCMiddleware) OnSendPacket(
+	ctx sdk.Context,
+	sourcePort string,
+	sourceChannel string,
+	sequence uint64,
+	timeoutHeight clienttypes.Height,
+	timeoutTimestamp uint64,
+	data []byte,
+	signer string,
+) error {
 	callbackData, err := types.GetSourceCallbackData(im.app, data, sourcePort, ctx.GasMeter().GasRemaining(), im.maxCallbackGas)
 	// SendPacket is not blocked if the packet does not opt-in to callbacks
 	if err != nil {
-		return seq, nil
+		return nil
 	}
 
+	// TODO: the packet sender is now passed in, it is possible to remove `GetPacketSender` in favour of this arg
 	callbackExecutor := func(cachedCtx sdk.Context) error {
 		return im.contractKeeper.IBCSendPacketCallback(
 			cachedCtx, sourcePort, sourceChannel, timeoutHeight, timeoutTimestamp, data, callbackData.CallbackAddress, callbackData.SenderAddress,
@@ -114,11 +133,11 @@ func (im IBCMiddleware) SendPacket(
 	err = im.processCallback(ctx, types.CallbackTypeSendPacket, callbackData, callbackExecutor)
 	// contract keeper is allowed to reject the packet send.
 	if err != nil {
-		return 0, err
+		return err
 	}
 
-	types.EmitCallbackEvent(ctx, sourcePort, sourceChannel, seq, types.CallbackTypeSendPacket, callbackData, nil)
-	return seq, nil
+	types.EmitCallbackEvent(ctx, sourcePort, sourceChannel, sequence, types.CallbackTypeSendPacket, callbackData, nil)
+	return nil
 }
 
 // OnAcknowledgementPacket implements source callbacks for acknowledgement packets.

modules/apps/transfer/ibc_module.go

@@ -13,6 +13,7 @@ import (
 	capabilitytypes "github.com/cosmos/ibc-go/modules/capability/types"
 	"github.com/cosmos/ibc-go/v8/modules/apps/transfer/keeper"
 	"github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
+	clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
 	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
 	porttypes "github.com/cosmos/ibc-go/v8/modules/core/05-port/types"
 	host "github.com/cosmos/ibc-go/v8/modules/core/24-host"
@@ -172,6 +173,30 @@ func (IBCModule) OnChanCloseConfirm(
 	return nil
 }
 
+// OnSendPacket implements the IBCModule interface.
+func (im IBCModule) OnSendPacket(
+	ctx sdk.Context,
+	portID string,
+	channelID string,
+	_ uint64,
+	_ clienttypes.Height,
+	_ uint64,
+	dataBz []byte,
+	signer string,
+) error {
+	var data types.FungibleTokenPacketData
+	if err := json.Unmarshal(dataBz, &data); err != nil {
+		return errorsmod.Wrapf(ibcerrors.ErrInvalidType, "cannot unmarshal ICS-20 transfer packet data")
+	}
+
+	sender, err := sdk.AccAddressFromBech32(signer)
+	if err != nil {
+		return errorsmod.Wrapf(ibcerrors.ErrInvalidAddress, "cannot convert signer address to sdk.AccAddress")
+	}
+
+	return im.keeper.OnSendPacket(ctx, portID, channelID, data, sender)
+}
+
 // OnRecvPacket implements the IBCModule interface. A successful acknowledgement
 // is returned if the packet data is successfully decoded and the receive application
 // logic returns without error.

modules/apps/transfer/keeper/msg_server.go

@@ -2,12 +2,14 @@ package keeper
 
 import (
 	"context"
+	"strings"
 
 	errorsmod "cosmossdk.io/errors"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
+	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
 	ibcerrors "github.com/cosmos/ibc-go/v8/modules/core/errors"
 )
 
@@ -34,6 +36,34 @@ func (k Keeper) Transfer(goCtx context.Context, msg *types.MsgTransfer) (*types.
 		return nil, errorsmod.Wrapf(ibcerrors.ErrUnauthorized, "%s is not allowed to send funds", sender)
 	}
 
+	// NOTE: denomination and hex hash correctness checked during msg.ValidateBasic
+	fullDenomPath := msg.Token.Denom
+
+	// deconstruct the token denomination into the denomination trace info
+	// to determine if the sender is the source chain
+	if strings.HasPrefix(msg.Token.Denom, "ibc/") {
+		fullDenomPath, err = k.DenomPathFromHash(ctx, msg.Token.Denom)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	packetData := types.NewFungibleTokenPacketData(
+		fullDenomPath, msg.Token.Amount.String(), sender.String(), msg.Receiver, msg.Memo,
+	)
+
+	msgSendPacket := channeltypes.MsgSendPacket{
+		PortId:           msg.SourcePort,
+		ChannelId:        msg.SourceChannel,
+		TimeoutHeight:    msg.TimeoutHeight,
+		TimeoutTimestamp: msg.TimeoutTimestamp,
+		Data:             packetData.GetBytes(),
+		Signer:           sender.String(),
+	}
+
+	// TODO: route msgSendPacket to core which calls OnSendPacket
+	_ = msgSendPacket
+
 	sequence, err := k.sendTransfer(
 		ctx, msg.SourcePort, msg.SourceChannel, msg.Token, sender, msg.Receiver, msg.TimeoutHeight, msg.TimeoutTimestamp,
 		msg.Memo)

modules/apps/transfer/keeper/relay.go

@@ -158,6 +158,84 @@ func (k Keeper) sendTransfer(
 	return sequence, nil
 }
 
+// OnSendPacket handles transfer sending logic.
+// TODO: Copy godoc from above sendTransfer function.
+func (k Keeper) OnSendPacket(ctx sdk.Context,
+	sourcePort string,
+	sourceChannel string,
+	packetData types.FungibleTokenPacketData,
+	sender sdk.AccAddress,
+) error {
+	channel, found := k.channelKeeper.GetChannel(ctx, sourcePort, sourceChannel)
+	if !found {
+		return errorsmod.Wrapf(channeltypes.ErrChannelNotFound, "port ID (%s) channel ID (%s)", sourcePort, sourceChannel)
+	}
+
+	// begin createOutgoingPacket logic
+	// See spec for this logic: https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#packet-relay
+	labels := []metrics.Label{
+		telemetry.NewLabel(coretypes.LabelDestinationPort, channel.Counterparty.PortId),
+		telemetry.NewLabel(coretypes.LabelDestinationChannel, channel.Counterparty.ChannelId),
+	}
+
+	amount, ok := sdkmath.NewIntFromString(packetData.Amount)
+	if !ok {
+		return errorsmod.Wrapf(types.ErrInvalidAmount, "cannot convert packet data amount to int: %s", packetData.Amount)
+	}
+
+	token := sdk.NewCoin(packetData.Denom, amount)
+
+	// NOTE: SendTransfer simply sends the denomination as it exists on its own
+	// chain inside the packet data. The receiving chain will perform denom
+	// prefixing as necessary.
+	if types.SenderChainIsSource(sourcePort, sourceChannel, packetData.Denom) {
+		labels = append(labels, telemetry.NewLabel(coretypes.LabelSource, "true"))
+
+		// obtain the escrow address for the source channel end
+		escrowAddress := types.GetEscrowAddress(sourcePort, sourceChannel)
+		if err := k.escrowToken(ctx, sender, escrowAddress, token); err != nil {
+			return err
+		}
+
+	} else {
+		labels = append(labels, telemetry.NewLabel(coretypes.LabelSource, "false"))
+
+		// transfer the coins to the module account and burn them
+		if err := k.bankKeeper.SendCoinsFromAccountToModule(
+			ctx, sender, types.ModuleName, sdk.NewCoins(token),
+		); err != nil {
+			return err
+		}
+
+		if err := k.bankKeeper.BurnCoins(
+			ctx, types.ModuleName, sdk.NewCoins(token),
+		); err != nil {
+			// NOTE: should not happen as the module account was
+			// retrieved on the step above and it has enough balance
+			// to burn.
+			panic(fmt.Errorf("cannot burn coins after a successful send to a module account: %v", err))
+		}
+	}
+
+	defer func() {
+		if token.Amount.IsInt64() {
+			telemetry.SetGaugeWithLabels(
+				[]string{"tx", "msg", "ibc", "transfer"},
+				float32(token.Amount.Int64()),
+				[]metrics.Label{telemetry.NewLabel(coretypes.LabelDenom, packetData.Denom)},
+			)
+		}
+
+		telemetry.IncrCounterWithLabels(
+			[]string{"ibc", types.ModuleName, "send"},
+			1,
+			labels,
+		)
+	}()
+
+	return nil
+}
+
 // OnRecvPacket processes a cross chain fungible token transfer. If the
 // sender chain is the source of minted tokens then vouchers will be minted
 // and sent to the receiving address. Otherwise if the sender chain is sending