Merge PR #81: Backport #81, #78 into v3

* Fix same bool being used for all 3 (#81)

* fix: middleware panic upon receiving amount that is not int64; added test (#78)

resolves #77

* fix test

* remove unused make command

---------

Co-authored-by: Andrew Gouin <andrew@gouin.io>
Co-authored-by: Max Kupriianov <max@kc.vc>

Author: 3 people

Makefile

@@ -177,7 +177,7 @@ go.sum: go.mod
 ###############################################################################
 
 test: test-unit
-test-all: test-unit test-ledger-mock test-race test-cover
+test-all: test-unit test-ledger-mock test-race
 
 TEST_PACKAGES=./...
 TEST_TARGETS := test-unit test-unit-amino test-unit-proto test-ledger-mock test-race test-ledger test-race

router/ibc_middleware.go

@@ -118,6 +118,18 @@ func getDenomForThisChain(port, channel, counterpartyPort, counterpartyChannel,
 	return transfertypes.ParseDenomTrace(prefixedDenom).IBCDenom()
 }
 
+// getBoolFromAny returns the bool value is any is a valid bool, otherwise false.
+func getBoolFromAny(value any) bool {
+	if value == nil {
+		return false
+	}
+	boolVal, ok := value.(bool)
+	if !ok {
+		return false
+	}
+	return boolVal
+}
+
 // OnRecvPacket checks the memo field on this packet and if the metadata inside's root key indicates this packet
 // should be handled by the swap middleware it attempts to perform a swap. If the swap is successful
 // the underlying application's OnRecvPacket callback is invoked, an ack error is returned otherwise.
@@ -153,27 +165,10 @@ func (im IBCMiddleware) OnRecvPacket(
 
 	metadata := m.Forward
 
-	var processed, nonrefundable, disableDenomComposition bool
 	goCtx := ctx.Context()
-	p := goCtx.Value(types.ProcessedKey{})
-	nr := goCtx.Value(types.NonrefundableKey{})
-	ddc := goCtx.Value(types.DisableDenomCompositionKey{})
-
-	if p != nil {
-		if pb, ok := p.(bool); ok {
-			processed = pb
-		}
-	}
-	if nr != nil {
-		if nrb, ok := p.(bool); ok {
-			nonrefundable = nrb
-		}
-	}
-	if ddc != nil {
-		if ddcb, ok := p.(bool); ok {
-			disableDenomComposition = ddcb
-		}
-	}
+	processed := getBoolFromAny(goCtx.Value(types.ProcessedKey{}))
+	nonrefundable := getBoolFromAny(goCtx.Value(types.NonrefundableKey{}))
+	disableDenomComposition := getBoolFromAny(goCtx.Value(types.DisableDenomCompositionKey{}))
 
 	if err := metadata.Validate(); err != nil {
 		return channeltypes.NewErrorAcknowledgement(err.Error())

router/keeper/keeper.go

@@ -302,11 +302,13 @@ func (k *Keeper) ForwardTransferPacket(
 	store.Set(key, bz)
 
 	defer func() {
-		telemetry.SetGaugeWithLabels(
-			[]string{"tx", "msg", "ibc", "transfer"},
-			float32(token.Amount.Int64()),
-			[]metrics.Label{telemetry.NewLabel(coretypes.LabelDenom, token.Denom)},
-		)
+		if token.Amount.IsInt64() {
+			telemetry.SetGaugeWithLabels(
+				[]string{"tx", "msg", "ibc", "transfer"},
+				float32(token.Amount.Int64()),
+				[]metrics.Label{telemetry.NewLabel(coretypes.LabelDenom, token.Denom)},
+			)
+		}
 
 		telemetry.IncrCounterWithLabels(
 			[]string{"ibc", types.ModuleName, "send"},

router/module_test.go

@@ -17,8 +17,9 @@ import (
 )
 
 var (
-	testDenom  = "uatom"
-	testAmount = "100"
+	testDenom     = "uatom"
+	testAmount    = "100"
+	testAmount256 = "100000000000000000000"
 
 	testSourcePort         = "transfer"
 	testSourceChannel      = "channel-10"
@@ -64,6 +65,36 @@ func transferPacket(t *testing.T, receiver string, metadata any) channeltypes.Pa
 	}
 }
 
+func transferPacket256(t *testing.T, receiver string, metadata any) channeltypes.Packet {
+	t.Helper()
+	transferPacket := transfertypes.FungibleTokenPacketData{
+		Denom:    testDenom,
+		Amount:   testAmount256,
+		Receiver: receiver,
+	}
+
+	if metadata != nil {
+		if mStr, ok := metadata.(string); ok {
+			transferPacket.Memo = mStr
+		} else {
+			memo, err := json.Marshal(metadata)
+			require.NoError(t, err)
+			transferPacket.Memo = string(memo)
+		}
+	}
+
+	transferData, err := transfertypes.ModuleCdc.MarshalJSON(&transferPacket)
+	require.NoError(t, err)
+
+	return channeltypes.Packet{
+		SourcePort:         testSourcePort,
+		SourceChannel:      testSourceChannel,
+		DestinationPort:    testDestinationPort,
+		DestinationChannel: testDestinationChannel,
+		Data:               transferData,
+	}
+}
+
 func TestOnRecvPacket_EmptyPacket(t *testing.T) {
 	ctl := gomock.NewController(t)
 	defer ctl.Finish()
@@ -254,6 +285,72 @@ func TestOnRecvPacket_ForwardNoFee(t *testing.T) {
 	require.NoError(t, err)
 }
 
+func TestOnRecvPacket_ForwardAmountInt256(t *testing.T) {
+	var err error
+	ctl := gomock.NewController(t)
+	defer ctl.Finish()
+	setup := test.NewTestSetup(t, ctl)
+	ctx := setup.Initializer.Ctx
+	cdc := setup.Initializer.Marshaler
+	forwardMiddleware := setup.ForwardMiddleware
+
+	// Test data
+	const (
+		hostAddr = "cosmos1vzxkv3lxccnttr9rs0002s93sgw72h7ghukuhs"
+		destAddr = "cosmos16plylpsgxechajltx9yeseqexzdzut9g8vla4k"
+		port     = "transfer"
+		channel  = "channel-0"
+	)
+	denom := makeIBCDenom(testDestinationPort, testDestinationChannel, testDenom)
+	senderAccAddr := test.AccAddress()
+
+	amount256, ok := sdk.NewIntFromString(testAmount256)
+	require.True(t, ok)
+
+	testCoin := sdk.NewCoin(denom, amount256)
+	packetOrig := transferPacket256(t, hostAddr, &types.PacketMetadata{
+		Forward: &types.ForwardMetadata{
+			Receiver: destAddr,
+			Port:     port,
+			Channel:  channel,
+		},
+	})
+	packetFwd := transferPacket256(t, destAddr, nil)
+
+	acknowledgement := channeltypes.NewResultAcknowledgement([]byte("test"))
+	successAck := cdc.MustMarshalJSON(&acknowledgement)
+
+	// Expected mocks
+	gomock.InOrder(
+		setup.Mocks.IBCModuleMock.EXPECT().OnRecvPacket(ctx, packetOrig, senderAccAddr).
+			Return(acknowledgement),
+
+		setup.Mocks.TransferKeeperMock.EXPECT().Transfer(
+			sdk.WrapSDKContext(ctx),
+			transfertypes.NewMsgTransfer(
+				port,
+				channel,
+				testCoin,
+				hostAddr,
+				destAddr,
+				keeper.DefaultTransferPacketTimeoutHeight,
+				uint64(ctx.BlockTime().UnixNano())+uint64(keeper.DefaultForwardTransferPacketTimeoutTimestamp.Nanoseconds()),
+			),
+		).Return(&transfertypes.MsgTransferResponse{Sequence: 0}, nil),
+
+		setup.Mocks.IBCModuleMock.EXPECT().OnAcknowledgementPacket(ctx, packetFwd, successAck, senderAccAddr).
+			Return(nil),
+	)
+
+	// chain B with router module receives packet and forwards. ack should be nil so that it is not written yet.
+	ack := forwardMiddleware.OnRecvPacket(ctx, packetOrig, senderAccAddr)
+	require.Nil(t, ack)
+
+	// ack returned from chain C
+	err = forwardMiddleware.OnAcknowledgementPacket(ctx, packetFwd, successAck, senderAccAddr)
+	require.NoError(t, err)
+}
+
 func TestOnRecvPacket_ForwardWithFee(t *testing.T) {
 	var err error
 	ctl := gomock.NewController(t)