refactor: ibc port router for app callbacks

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

@@ -170,6 +170,18 @@ func (im IBCMiddleware) OnChanCloseConfirm(
 	return nil
 }
 
+// OnSendPacket implements the IBCModule interface.
+func (IBCMiddleware) OnSendPacket(
+	ctx sdk.Context,
+	portID string,
+	channelID string,
+	sequence uint64,
+	data []byte,
+	signer string,
+) error {
+	return nil
+}
+
 // OnRecvPacket implements the IBCMiddleware interface
 func (IBCMiddleware) OnRecvPacket(
 	ctx sdk.Context,

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

@@ -110,6 +110,18 @@ 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,
+	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,18 @@ 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,
+	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/transfer/ibc_module.go

@@ -172,6 +172,18 @@ func (IBCModule) OnChanCloseConfirm(
 	return nil
 }
 
+// OnSendPacket implements the IBCModule interface.
+func (IBCModule) OnSendPacket(
+	ctx sdk.Context,
+	portID string,
+	channelID string,
+	sequence uint64,
+	data []byte,
+	signer string,
+) error {
+	return nil
+}
+
 // 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/core/05-port/types/module.go

@@ -81,6 +81,15 @@ type IBCModule interface {
 		channelID string,
 	) error
 
+	OnSendPacket(
+		ctx sdk.Context,
+		portID string,
+		channelID string,
+		sequence uint64,
+		data []byte,
+		signer string,
+	) error
+
 	// OnRecvPacket must return an acknowledgement that implements the Acknowledgement interface.
 	// In the case of an asynchronous acknowledgement, nil should be returned.
 	// If the acknowledgement returned is successful, the state changes on callback are written,
@@ -159,6 +168,7 @@ type UpgradableModule interface {
 
 // ICS4Wrapper implements the ICS4 interfaces that IBC applications use to send packets and acknowledgements.
 type ICS4Wrapper interface {
+	// TODO: Leave in place to avoid compiler errors and incrementally work to remove. We can then delete these methods
 	SendPacket(
 		ctx sdk.Context,
 		chanCap *capabilitytypes.Capability,

modules/core/keeper/msg_server.go

@@ -445,6 +445,40 @@ func (k *Keeper) ChannelCloseConfirm(goCtx context.Context, msg *channeltypes.Ms
 	return &channeltypes.MsgChannelCloseConfirmResponse{}, nil
 }
 
+// SendPacket defines a rpc handler method for MsgSendPacket.
+func (k *Keeper) SendPacket(goCtx context.Context, msg *channeltypes.MsgSendPacket) (*channeltypes.MsgSendPacketResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	module, capability, err := k.ChannelKeeper.LookupModuleByChannel(ctx, msg.PortId, msg.ChannelId)
+	if err != nil {
+		ctx.Logger().Error("send packet failed", "port-id", msg.PortId, "channel-id", msg.ChannelId, "error", errorsmod.Wrap(err, "could not retrieve module from port-id"))
+		return nil, errorsmod.Wrap(err, "could not retrieve module from port-id")
+	}
+
+	// Retrieve callbacks from router
+	cbs, ok := k.PortKeeper.Route(module)
+	if !ok {
+		ctx.Logger().Error("send packet failed", "port-id", msg.PortId, "error", errorsmod.Wrapf(porttypes.ErrInvalidRoute, "route not found to module: %s", module))
+		return nil, errorsmod.Wrapf(porttypes.ErrInvalidRoute, "route not found to module: %s", module)
+	}
+
+	sequence, err := k.ChannelKeeper.SendPacket(ctx, capability, msg.PortId, msg.ChannelId, msg.TimeoutHeight, uint64(msg.TimeoutTimestamp.UnixNano()), msg.PacketData)
+	if err != nil {
+		ctx.Logger().Error("send packet failed", "port-id", msg.PortId, "channel-id", msg.ChannelId, "error", errorsmod.Wrap(err, "send packet failed"))
+		return nil, errorsmod.Wrapf(err, "send packet failed for module: %s", module)
+	}
+
+	// TODO: Make port router have list of ordered callbacks
+	// Loop over cbs in-order calling OnSendPacket on each IBCModule. To be done for RecvPacket handler as well in opposite order.
+	// Adjust app logic to account for what should be done before MsgSendPacket and what should be done in OnSendPacket.
+	if err := cbs.OnSendPacket(ctx, msg.PortId, msg.ChannelId, sequence, msg.PacketData, msg.Signer); err != nil {
+		ctx.Logger().Error("send packet callback failed", "port-id", msg.PortId, "channel-id", msg.ChannelId, "error", errorsmod.Wrap(err, "send packet callback failed"))
+		return nil, errorsmod.Wrapf(err, "send packet callback failed for module: %s", module)
+	}
+
+	return &channeltypes.MsgSendPacketResponse{Sequence: sequence}, nil
+}
+
 // RecvPacket defines a rpc handler method for MsgRecvPacket.
 func (k *Keeper) RecvPacket(goCtx context.Context, msg *channeltypes.MsgRecvPacket) (*channeltypes.MsgRecvPacketResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)

modules/core/keeper/msg_server_test.go

@@ -31,6 +31,10 @@ var (
 	maxSequence   = uint64(10)
 )
 
+func (suite *KeeperTestSuite) TestHandleSendPacket() {
+	suite.T().Skip("todo: handle test send packet rpc")
+}
+
 // tests the IBC handler receiving a packet on ordered and unordered channels.
 // It verifies that the storing of an acknowledgement on success occurs. It
 // tests high level properties like ordering and basic sanity checks. More

proto/ibc/core/channel/v1/tx.proto

@@ -4,6 +4,7 @@ package ibc.core.channel.v1;
 
 option go_package = "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types";
 
+import "google/protobuf/timestamp.proto";
 import "gogoproto/gogo.proto";
 import "cosmos/msg/v1/msg.proto";
 import "ibc/core/client/v1/client.proto";
@@ -33,6 +34,9 @@ service Msg {
   // MsgChannelCloseConfirm.
   rpc ChannelCloseConfirm(MsgChannelCloseConfirm) returns (MsgChannelCloseConfirmResponse);
 
+  // SendPacket defines a rpc handler method for MsgSendPacket.
+  rpc SendPacket(MsgSendPacket) returns (MsgSendPacketResponse);
+
   // RecvPacket defines a rpc handler method for MsgRecvPacket.
   rpc RecvPacket(MsgRecvPacket) returns (MsgRecvPacketResponse);
 
@@ -208,6 +212,27 @@ message MsgChannelCloseConfirm {
 // type.
 message MsgChannelCloseConfirmResponse {}
 
+// MsgSendPacket sends an outgoing IBC packet
+message MsgSendPacket {
+  option (cosmos.msg.v1.signer) = "signer";
+
+  option (gogoproto.goproto_getters) = false;
+
+  string                    port_id           = 1;
+  string                    channel_id        = 2;
+  ibc.core.client.v1.Height timeout_height    = 3 [(gogoproto.nullable) = false];
+  google.protobuf.Timestamp timeout_timestamp = 4 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+  bytes                     packet_data       = 5;
+  string                    signer            = 6;
+}
+
+// MsgSendPacketReponse defines the Msg/SendPacket response type.
+message MsgSendPacketResponse {
+  option (gogoproto.goproto_getters) = false;
+
+  uint64 sequence = 1;
+}
+
 // MsgRecvPacket receives incoming IBC packet
 message MsgRecvPacket {
   option (cosmos.msg.v1.signer) = "signer";

testing/mock/ibc_app.go

@@ -62,6 +62,15 @@ type IBCApp struct {
 		channelID string,
 	) error
 
+	OnSendPacket func(
+		ctx sdk.Context,
+		portID string,
+		channelID string,
+		sequence uint64,
+		data []byte,
+		signer string,
+	) error
+
 	// OnRecvPacket must return an acknowledgement that implements the Acknowledgement interface.
 	// In the case of an asynchronous acknowledgement, nil should be returned.
 	// If the acknowledgement returned is successful, the state changes on callback are written,

testing/mock/ibc_module.go

@@ -122,6 +122,15 @@ func (im IBCModule) OnChanCloseConfirm(ctx sdk.Context, portID, channelID string
 	return nil
 }
 
+// OnSendPacket implements the IBCModule interface.
+func (im IBCModule) OnSendPacket(ctx sdk.Context, portID string, channelID string, sequence uint64, data []byte, signer string) error {
+	if im.IBCApp.OnSendPacket != nil {
+		return im.IBCApp.OnSendPacket(ctx, portID, channelID, sequence, data, signer)
+	}
+
+	return nil
+}
+
 // OnRecvPacket implements the IBCModule interface.
 func (im IBCModule) OnRecvPacket(ctx sdk.Context, packet channeltypes.Packet, relayer sdk.AccAddress) exported.Acknowledgement {
 	if im.IBCApp.OnRecvPacket != nil {

testing/mock/middleware.go

@@ -113,6 +113,15 @@ func (im BlockUpgradeMiddleware) OnChanCloseConfirm(ctx sdk.Context, portID, cha
 	return nil
 }
 
+// OnSendPacket implements the IBCModule interface.
+func (im BlockUpgradeMiddleware) OnSendPacket(ctx sdk.Context, portID string, channelID string, sequence uint64, data []byte, signer string) error {
+	if im.IBCApp.OnSendPacket != nil {
+		return im.IBCApp.OnSendPacket(ctx, portID, channelID, sequence, data, signer)
+	}
+
+	return nil
+}
+
 // OnRecvPacket implements the IBCModule interface.
 func (im BlockUpgradeMiddleware) OnRecvPacket(ctx sdk.Context, packet channeltypes.Packet, relayer sdk.AccAddress) exported.Acknowledgement {
 	if im.IBCApp.OnRecvPacket != nil {