feat: add memo to IBC transfers of ICS rewards

Author: masonmcbride

x/ccv/consumer/keeper/distribution.go

@@ -121,6 +121,11 @@ func (k Keeper) SendRewardsToProvider(ctx sdk.Context) error {
 
 	sentCoins := sdk.NewCoins()
 	var allBalances sdk.Coins
+	rewardMemo, err := ccv.CreateTransferMemo(ctx.ChainID())
+	if err != nil {
+		return err
+	}
+
 	// iterate over all whitelisted reward denoms
 	for _, denom := range k.AllowedRewardDenoms(ctx) {
 		// get the balance of the denom in the toSendToProviderTokens address
@@ -137,7 +142,7 @@ func (k Keeper) SendRewardsToProvider(ctx sdk.Context) error {
 				Receiver:         providerAddr,                  // provider fee pool address to send to
 				TimeoutHeight:    timeoutHeight,                 // timeout height disabled
 				TimeoutTimestamp: timeoutTimestamp,
-				Memo:             "consumer chain rewards distribution",
+				Memo:             rewardMemo,
 			}
 
 			// validate MsgTransfer before calling Transfer()

x/ccv/provider/ibc_middleware.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/cosmos/interchain-security/v5/x/ccv/provider/keeper"
 	"github.com/cosmos/interchain-security/v5/x/ccv/provider/types"
+	ccvtypes "github.com/cosmos/interchain-security/v5/x/ccv/types"
 )
 
 var _ porttypes.Middleware = &IBCMiddleware{}
@@ -111,6 +112,7 @@ func (im IBCMiddleware) OnRecvPacket(
 	packet channeltypes.Packet,
 	relayer sdk.AccAddress,
 ) exported.Acknowledgement {
+	logger := im.keeper.Logger(ctx)
 	// IBC v10: Added channelID parameter
 	ack := im.app.OnRecvPacket(ctx, channelID, packet, relayer)
 
@@ -119,12 +121,6 @@ func (im IBCMiddleware) OnRecvPacket(
 	// that the packet data is valid and can be safely
 	// deserialized without checking errors.
 	if ack.Success() {
-		// execute the middleware logic only if the sender is a consumer chain
-		consumerID, err := im.keeper.IdentifyConsumerChainIDFromIBCPacket(ctx, packet)
-		if err != nil {
-			return ack
-		}
-
 		// extract the coin info received from the packet data
 		var data ibctransfertypes.FungibleTokenPacketData
 		_ = types.ModuleCdc.UnmarshalJSON(packet.GetData(), &data)
@@ -135,20 +131,44 @@ func (im IBCMiddleware) OnRecvPacket(
 			return ack
 		}
 
+		chainID := ""
+		// check if the transfer has the reward memo
+		if rewardMemo, err := ccvtypes.GetRewardMemoFromTransferMemo(data.Memo); err != nil {
+			// check if the transfer is on a channel with the same underlying
+			// client as the CCV channel
+			chainID, err = im.keeper.IdentifyConsumerChainIDFromIBCPacket(ctx, packet)
+			if err != nil {
+				if data.Memo == "consumer chain rewards distribution" {
+					// log error message
+					logger.Error(
+						"received token transfer with ICS reward from unknown consumer",
+						"packet", packet.String(),
+						"fungibleTokenPacketData", data.String(),
+						"error", err.Error(),
+					)
+				}
+
+				return ack
+			}
+		} else {
+			logger.Info("transfer memo:%#+v", rewardMemo)
+			chainID = rewardMemo.ChainID
+		}
+
 		coinAmt, _ := math.NewIntFromString(data.Amount)
 		coinDenom := GetProviderDenom(data.Denom, packet)
 
 		// verify that the coin's denom is a whitelisted consumer denom,
 		// and if so, adds it to the consumer chain rewards allocation,
 		// otherwise the prohibited coin just stays in the pool forever.
 		if im.keeper.ConsumerRewardDenomExists(ctx, coinDenom) {
-			alloc := im.keeper.GetConsumerRewardsAllocation(ctx, consumerID)
+			alloc := im.keeper.GetConsumerRewardsAllocation(ctx, chainID)
 			alloc.Rewards = alloc.Rewards.Add(
 				sdk.NewDecCoinsFromCoins(sdk.Coin{
 					Denom:  coinDenom,
 					Amount: coinAmt,
 				})...)
-			im.keeper.SetConsumerRewardsAllocation(ctx, consumerID, alloc)
+			im.keeper.SetConsumerRewardsAllocation(ctx, chainID, alloc)
 		}
 	}
 

x/ccv/types/wire.go

@@ -1,6 +1,7 @@
 package types
 
 import (
+	"encoding/json"
 	"fmt"
 
 	errorsmod "cosmossdk.io/errors"
@@ -194,3 +195,45 @@ func NewConsumerPacketData(cpdType ConsumerPacketDataType, data isConsumerPacket
 		Data: data,
 	}
 }
+
+type RewardMemo struct {
+	ChainID string `json:"chainId"`
+	Memo    string `json:"memo"`
+}
+
+// CreateTransferMemo creates a memo for the IBC transfer of ICS rewards.
+// Note that the memo follows the Fungible Token Transfer v2 standard
+// https://github.com/cosmos/ibc/blob/main/spec/app/ics-020-fungible-token-transfer/README.md#using-the-memo-field
+func CreateTransferMemo(chainID string) (string, error) {
+	memo := RewardMemo{ChainID: chainID, Memo: "ICS rewards"}
+	memoBytes, err := json.Marshal(memo)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf(`{
+			"provider": %s
+		}`,
+		string(memoBytes),
+	), nil
+}
+
+func GetRewardMemoFromTransferMemo(memo string) (RewardMemo, error) {
+	memoData := map[string]json.RawMessage{}
+	err := json.Unmarshal([]byte(memo), &memoData)
+	if err != nil {
+		return RewardMemo{}, err
+	}
+
+	providerMemo, ok := memoData["provider"]
+	if !ok {
+		return RewardMemo{}, err
+	}
+
+	rewardMemo := RewardMemo{}
+	err = json.Unmarshal([]byte(providerMemo), &rewardMemo)
+	if err != nil {
+		return RewardMemo{}, err
+	}
+
+	return rewardMemo, nil
+}

x/ccv/types/wire_test.go

@@ -223,3 +223,15 @@ func TestVSCMaturedPacketDataWireBytes(t *testing.T) {
 
 	require.Equal(t, expectedStr, str)
 }
+
+func TestCreateTransferMemo(t *testing.T) {
+	chainID := "chain-13"
+
+	transferMemo, err := types.CreateTransferMemo(chainID)
+	require.NoError(t, err)
+
+	rewardMemo, err := types.GetRewardMemoFromTransferMemo(transferMemo)
+	require.NoError(t, err)
+	require.Equal(t, chainID, rewardMemo.ChainID)
+	require.Equal(t, "ICS rewards", rewardMemo.Memo)
+}