perf: minimize logic on rechecktx for recvpacket

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

@@ -0,0 +1,22 @@
+package keeper
+
+import (
+	errorsmod "cosmossdk.io/errors"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
+)
+
+// RecvPacketReCheckTx applies replay protection ensuring that when relay messages are
+// re-executed in ReCheckTx, we can appropriately filter out redundant relay transactions.
+func (k *Keeper) RecvPacketReCheckTx(ctx sdk.Context, packet types.Packet) error {
+	channel, found := k.GetChannel(ctx, packet.GetDestPort(), packet.GetDestChannel())
+	if !found {
+		return errorsmod.Wrap(types.ErrChannelNotFound, packet.GetDestChannel())
+	}
+
+	if err := k.applyReplayProtection(ctx, packet, channel); err != nil {
+		return err
+	}
+
+	return nil
+}

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

@@ -0,0 +1,66 @@
+package keeper_test
+
+import (
+	"github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
+	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
+	ibctesting "github.com/cosmos/ibc-go/v8/testing"
+)
+
+func (suite *KeeperTestSuite) TestRecvPacketReCheckTx() {
+	var (
+		path   *ibctesting.Path
+		packet types.Packet
+	)
+
+	testCases := []struct {
+		name     string
+		malleate func()
+		expError error
+	}{
+		{
+			"success",
+			func() {},
+			nil,
+		},
+		{
+			"channel not found",
+			func() {
+				packet.DestinationPort = "invalid-port"
+			},
+			channeltypes.ErrChannelNotFound,
+		},
+		{
+			"redundant relay",
+			func() {
+				err := suite.chainB.App.GetIBCKeeper().ChannelKeeper.RecvPacketReCheckTx(suite.chainB.GetContext(), packet)
+				suite.Require().NoError(err)
+			},
+			channeltypes.ErrNoOpMsg,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		suite.Run(tc.name, func() {
+			suite.SetupTest() // reset
+			path = ibctesting.NewPath(suite.chainA, suite.chainB)
+			path.Setup()
+
+			sequence, err := path.EndpointA.SendPacket(defaultTimeoutHeight, disabledTimeoutTimestamp, ibctesting.MockPacketData)
+			suite.Require().NoError(err)
+			packet = types.NewPacket(ibctesting.MockPacketData, sequence, path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID, path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID, defaultTimeoutHeight, disabledTimeoutTimestamp)
+
+			tc.malleate()
+
+			err = suite.chainB.App.GetIBCKeeper().ChannelKeeper.RecvPacketReCheckTx(suite.chainB.GetContext(), packet)
+
+			expPass := tc.expError == nil
+			if expPass {
+				suite.Require().NoError(err)
+			} else {
+				suite.Require().ErrorIs(err, tc.expError)
+			}
+		})
+	}
+
+}

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

@@ -188,6 +188,29 @@ func (k *Keeper) RecvPacket(
 		return errorsmod.Wrap(err, "couldn't verify counterparty packet commitment")
 	}
 
+	if err := k.applyReplayProtection(ctx, packet, channel); err != nil {
+		return err
+	}
+
+	// log that a packet has been received & executed
+	k.Logger(ctx).Info(
+		"packet received",
+		"sequence", strconv.FormatUint(packet.GetSequence(), 10),
+		"src_port", packet.GetSourcePort(),
+		"src_channel", packet.GetSourceChannel(),
+		"dst_port", packet.GetDestPort(),
+		"dst_channel", packet.GetDestChannel(),
+	)
+
+	// emit an event that the relayer can query for
+	emitRecvPacketEvent(ctx, packet, channel)
+
+	return nil
+}
+
+// applyReplayProtection ensures a packet has not already been received
+// and performs the necessary state changes to ensure it cannot be received again.
+func (k *Keeper) applyReplayProtection(ctx sdk.Context, packet types.Packet, channel types.Channel) error {
 	// REPLAY PROTECTION: The recvStartSequence will prevent historical proofs from allowing replay
 	// attacks on packets processed in previous lifecycles of a channel. After a successful channel
 	// upgrade all packets under the recvStartSequence will have been processed and thus should be
@@ -253,19 +276,6 @@ func (k *Keeper) RecvPacket(
 		k.SetNextSequenceRecv(ctx, packet.GetDestPort(), packet.GetDestChannel(), nextSequenceRecv)
 	}
 
-	// log that a packet has been received & executed
-	k.Logger(ctx).Info(
-		"packet received",
-		"sequence", strconv.FormatUint(packet.GetSequence(), 10),
-		"src_port", packet.GetSourcePort(),
-		"src_channel", packet.GetSourceChannel(),
-		"dst_port", packet.GetDestPort(),
-		"dst_channel", packet.GetDestChannel(),
-	)
-
-	// emit an event that the relayer can query for
-	emitRecvPacketEvent(ctx, packet, channel)
-
 	return nil
 }
 

modules/core/ante/ante.go

@@ -1,6 +1,8 @@
 package ante
 
 import (
+	errorsmod "cosmossdk.io/errors"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
@@ -30,10 +32,19 @@ func (rrd RedundantRelayDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simula
 		for _, m := range tx.GetMsgs() {
 			switch msg := m.(type) {
 			case *channeltypes.MsgRecvPacket:
-				response, err := rrd.k.RecvPacket(ctx, msg)
+				var (
+					response *channeltypes.MsgRecvPacketResponse
+					err      error
+				)
+				if ctx.IsReCheckTx() {
+					response, err = rrd.recvPacketReCheckTx(ctx, msg)
+				} else {
+					response, err = rrd.k.RecvPacket(ctx, msg)
+				}
 				if err != nil {
 					return ctx, err
 				}
+
 				if response.Result == channeltypes.NOOP {
 					redundancies++
 				}
@@ -90,3 +101,18 @@ func (rrd RedundantRelayDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simula
 	}
 	return next(ctx, tx, simulate)
 }
+
+// recvPacketReCheckTx runs a subset of ibc recv packet logic to be used specifically within the RedundantRelayDecorator AnteHandler.
+// It only performs core IBC receiving logic and skips any application logic.
+func (rrd RedundantRelayDecorator) recvPacketReCheckTx(ctx sdk.Context, msg *channeltypes.MsgRecvPacket) (*channeltypes.MsgRecvPacketResponse, error) {
+	err := rrd.k.ChannelKeeper.RecvPacketReCheckTx(ctx, msg.Packet)
+
+	switch err {
+	case nil:
+		return &channeltypes.MsgRecvPacketResponse{Result: channeltypes.SUCCESS}, nil
+	case channeltypes.ErrNoOpMsg:
+		return &channeltypes.MsgRecvPacketResponse{Result: channeltypes.NOOP}, nil
+	default:
+		return nil, errorsmod.Wrap(err, "receive packet verification failed")
+	}
+}

modules/core/ante/ante_test.go

@@ -1,6 +1,7 @@
 package ante_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -46,7 +47,7 @@ func TestAnteTestSuite(t *testing.T) {
 }
 
 // createRecvPacketMessage creates a RecvPacket message for a packet sent from chain A to chain B.
-func (suite *AnteTestSuite) createRecvPacketMessage(isRedundant bool) sdk.Msg {
+func (suite *AnteTestSuite) createRecvPacketMessage(isRedundant bool) *channeltypes.MsgRecvPacket {
 	sequence, err := suite.path.EndpointA.SendPacket(clienttypes.NewHeight(2, 0), 0, ibctesting.MockPacketData)
 	suite.Require().NoError(err)
 
@@ -174,7 +175,7 @@ func (suite *AnteTestSuite) createUpdateClientMessage() sdk.Msg {
 	return msg
 }
 
-func (suite *AnteTestSuite) TestAnteDecorator() {
+func (suite *AnteTestSuite) TestAnteDecoratorCheckTx() {
 	testCases := []struct {
 		name     string
 		malleate func(suite *AnteTestSuite) []sdk.Msg
@@ -488,3 +489,95 @@ func (suite *AnteTestSuite) TestAnteDecorator() {
 		})
 	}
 }
+
+func (suite *AnteTestSuite) TestAnteDecoratorReCheckTx() {
+	testCases := []struct {
+		name     string
+		malleate func(suite *AnteTestSuite) []sdk.Msg
+		expPass  bool
+	}{
+		{
+			"success on one new RecvPacket message",
+			func(suite *AnteTestSuite) []sdk.Msg {
+				// the RecvPacket message has not been submitted to the chain yet, so it will succeed
+				return []sdk.Msg{suite.createRecvPacketMessage(false)}
+			},
+			true,
+		},
+		{
+			"success on one redundant and one new RecvPacket message",
+			func(suite *AnteTestSuite) []sdk.Msg {
+				return []sdk.Msg{
+					suite.createRecvPacketMessage(true),
+					suite.createRecvPacketMessage(false),
+				}
+			},
+			true,
+		},
+		{
+			"success on invalid proof (proof checks occur in checkTx)",
+			func(suite *AnteTestSuite) []sdk.Msg {
+				msg := suite.createRecvPacketMessage(false)
+				msg.ProofCommitment = []byte("invalid-proof")
+				return []sdk.Msg{msg}
+			},
+			true,
+		},
+		{
+			"success on app callback error, app callbacks are skipped for performance",
+			func(suite *AnteTestSuite) []sdk.Msg {
+				suite.chainB.GetSimApp().IBCMockModule.IBCApp.OnRecvPacket = func(
+					ctx sdk.Context, packet channeltypes.Packet, relayer sdk.AccAddress,
+				) exported.Acknowledgement {
+					panic(fmt.Errorf("failed OnRecvPacket mock callback"))
+				}
+
+				// the RecvPacket message has not been submitted to the chain yet, so it will succeed
+				return []sdk.Msg{suite.createRecvPacketMessage(false)}
+			},
+			true,
+		},
+		{
+			"no success on one redundant RecvPacket message",
+			func(suite *AnteTestSuite) []sdk.Msg {
+				return []sdk.Msg{suite.createRecvPacketMessage(true)}
+			},
+			false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		suite.Run(tc.name, func() {
+			// reset suite
+			suite.SetupTest()
+
+			k := suite.chainB.App.GetIBCKeeper()
+			decorator := ante.NewRedundantRelayDecorator(k)
+
+			msgs := tc.malleate(suite)
+
+			deliverCtx := suite.chainB.GetContext().WithIsCheckTx(false)
+			reCheckCtx := suite.chainB.GetContext().WithIsReCheckTx(true)
+
+			// create multimsg tx
+			txBuilder := suite.chainB.TxConfig.NewTxBuilder()
+			err := txBuilder.SetMsgs(msgs...)
+			suite.Require().NoError(err)
+			tx := txBuilder.GetTx()
+
+			next := func(ctx sdk.Context, tx sdk.Tx, simulate bool) (newCtx sdk.Context, err error) { return ctx, nil }
+
+			_, err = decorator.AnteHandle(deliverCtx, tx, false, next)
+			suite.Require().NoError(err, "antedecorator should not error on DeliverTx")
+
+			_, err = decorator.AnteHandle(reCheckCtx, tx, false, next)
+			if tc.expPass {
+				suite.Require().NoError(err, "non-strict decorator did not pass as expected")
+			} else {
+				suite.Require().Error(err, "non-strict antehandler did not return error as expected")
+			}
+		})
+	}
+}