Add host cli to generate ica packet data

modules/apps/27-interchain-accounts/client/cli/cli.go

@@ -37,6 +37,7 @@ func NewTxCmd() *cobra.Command {
 
 	icaTxCmd.AddCommand(
 		controllercli.NewTxCmd(),
+		hostcli.NewTxCmd(),
 	)
 
 	return icaTxCmd

modules/apps/27-interchain-accounts/host/client/cli/cli.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/spf13/cobra"
 )
 
@@ -20,3 +21,20 @@ func GetQueryCmd() *cobra.Command {
 
 	return queryCmd
 }
+
+// NewTxCmd creates and returns the tx command
+func NewTxCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:                        "host",
+		Short:                      "interchain-accounts host subcommands",
+		DisableFlagParsing:         true,
+		SuggestionsMinimumDistance: 2,
+		RunE:                       client.ValidateCmd,
+	}
+
+	cmd.AddCommand(
+		generatePacketDataCmd(),
+	)
+
+	return cmd
+}

modules/apps/27-interchain-accounts/host/client/cli/tx.go

@@ -0,0 +1,66 @@
+package cli
+
+import (
+	"strings"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/spf13/cobra"
+
+	icatypes "github.com/cosmos/ibc-go/v5/modules/apps/27-interchain-accounts/types"
+)
+
+const (
+	memoFlag string = "memo"
+)
+
+func generatePacketDataCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "generate-packet-data [message]",
+		Short: "Generate ICA packet data.",
+		Long:  strings.TrimSpace(`Generate ICA packet data.`), // TODO write more here
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			cdc := codec.NewProtoCodec(clientCtx.InterfaceRegistry)
+			memo, err := cmd.Flags().GetString(memoFlag)
+			if err != nil {
+				return err
+			}
+			packetDataBytes, err := generatePacketData(cdc, []byte(args[0]), memo)
+			cmd.Println(string(packetDataBytes))
+			return nil
+		},
+	}
+
+	cmd.Flags().String(memoFlag, "", "")
+	return cmd
+}
+
+func generatePacketData(cdc *codec.ProtoCodec, msgBytes []byte, memo string) ([]byte, error) {
+	var msg sdk.Msg
+	if err := cdc.UnmarshalInterfaceJSON(msgBytes, &msg); err != nil {
+		return nil, err
+	}
+
+	icaPacketDataBytes, err := icatypes.SerializeCosmosTx(cdc, []sdk.Msg{msg})
+	if err != nil {
+		return nil, err
+	}
+
+	icaPacketData := icatypes.InterchainAccountPacketData{
+		Type: icatypes.EXECUTE_TX,
+		Data: icaPacketDataBytes,
+		Memo: memo,
+	}
+
+	if err := icaPacketData.ValidateBasic(); err != nil {
+		return nil, err
+	}
+
+	return cdc.MarshalJSON(&icaPacketData)
+}

modules/apps/27-interchain-accounts/host/client/cli/tx_test.go

@@ -0,0 +1,132 @@
+package cli
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/stretchr/testify/require"
+
+	icatypes "github.com/cosmos/ibc-go/v5/modules/apps/27-interchain-accounts/types"
+)
+
+const msgDelegateMessage = `{
+  "@type": "/cosmos.staking.v1beta1.MsgDelegate",
+  "delegator_address": "cosmos15ccshhmp0gsx29qpqq6g4zmltnnvgmyu9ueuadh9y2nc5zj0szls5gtddz",
+  "validator_address": "cosmosvaloper1qnk2n4nlkpw9xfqntladh74w6ujtulwnmxnh3k",
+  "amount": {
+    "denom": "stake",
+    "amount": "1000"
+  }
+}`
+
+const bankSendMessage = `{
+    "@type":"/cosmos.bank.v1beta1.MsgSend",
+    "from_address":"cosmos15ccshhmp0gsx29qpqq6g4zmltnnvgmyu9ueuadh9y2nc5zj0szls5gtddz",
+    "to_address":"cosmos10h9stc5v6ntgeygf5xf945njqq5h32r53uquvw",
+    "amount": [
+        {
+            "denom": "stake",
+            "amount": "1000"
+        }
+    ]
+}`
+
+func TestGeneratePacketData(t *testing.T) {
+	tests := []struct {
+		name                string
+		memo                string
+		expectedPass        bool
+		message             string
+		registerInterfaceFn func(registry codectypes.InterfaceRegistry)
+		assertionFn         func(msg sdk.Msg)
+	}{
+		{
+			name:                "packet data generation succeeds (MsgDelegate)",
+			memo:                "non-empty-memo",
+			expectedPass:        true,
+			message:             msgDelegateMessage,
+			registerInterfaceFn: stakingtypes.RegisterInterfaces,
+			assertionFn: func(msg sdk.Msg) {
+				msgDelegate := msg.(*stakingtypes.MsgDelegate)
+				require.Equal(t, "cosmos15ccshhmp0gsx29qpqq6g4zmltnnvgmyu9ueuadh9y2nc5zj0szls5gtddz", msgDelegate.DelegatorAddress)
+				require.Equal(t, "cosmosvaloper1qnk2n4nlkpw9xfqntladh74w6ujtulwnmxnh3k", msgDelegate.ValidatorAddress)
+				require.Equal(t, "stake", msgDelegate.Amount.Denom)
+				require.Equal(t, uint64(1000), msgDelegate.Amount.Amount.Uint64())
+			},
+		},
+		{
+			name:                "packet data generation succeeds (MsgSend)",
+			memo:                "non-empty-memo",
+			expectedPass:        true,
+			message:             bankSendMessage,
+			registerInterfaceFn: banktypes.RegisterInterfaces,
+			assertionFn: func(msg sdk.Msg) {
+				bankSendMsg := msg.(*banktypes.MsgSend)
+				require.Equal(t, "cosmos15ccshhmp0gsx29qpqq6g4zmltnnvgmyu9ueuadh9y2nc5zj0szls5gtddz", bankSendMsg.FromAddress)
+				require.Equal(t, "cosmos10h9stc5v6ntgeygf5xf945njqq5h32r53uquvw", bankSendMsg.ToAddress)
+				require.Equal(t, "stake", bankSendMsg.Amount.GetDenomByIndex(0))
+				require.Equal(t, uint64(1000), bankSendMsg.Amount[0].Amount.Uint64())
+			},
+		},
+		{
+			name:                "empty memo is valid",
+			memo:                "",
+			expectedPass:        true,
+			message:             msgDelegateMessage,
+			registerInterfaceFn: stakingtypes.RegisterInterfaces,
+			assertionFn: func(msg sdk.Msg) {
+				msgDelegate := msg.(*stakingtypes.MsgDelegate)
+				require.Equal(t, "cosmos15ccshhmp0gsx29qpqq6g4zmltnnvgmyu9ueuadh9y2nc5zj0szls5gtddz", msgDelegate.DelegatorAddress)
+				require.Equal(t, "cosmosvaloper1qnk2n4nlkpw9xfqntladh74w6ujtulwnmxnh3k", msgDelegate.ValidatorAddress)
+				require.Equal(t, "stake", msgDelegate.Amount.Denom)
+				require.Equal(t, uint64(1000), msgDelegate.Amount.Amount.Uint64())
+			},
+		},
+		{
+			name:                "invalid message string",
+			memo:                "",
+			expectedPass:        false,
+			message:             "{}",
+			registerInterfaceFn: func(codectypes.InterfaceRegistry) {},
+			assertionFn:         func(sdk.Msg) {},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		ir := codectypes.NewInterfaceRegistry()
+		tt.registerInterfaceFn(ir)
+
+		cdc := codec.NewProtoCodec(ir)
+		t.Run(tt.name, func(t *testing.T) {
+			bz, err := generatePacketData(cdc, []byte(tt.message), tt.memo)
+			if !tt.expectedPass {
+				require.Error(t, err)
+				require.Nil(t, bz)
+				return
+			}
+			require.NoError(t, err)
+			require.NotNil(t, bz)
+
+			packetData := icatypes.InterchainAccountPacketData{}
+			err = cdc.UnmarshalJSON(bz, &packetData)
+			require.NoError(t, err)
+
+			require.NoError(t, err)
+			require.Equal(t, icatypes.EXECUTE_TX, packetData.Type)
+			require.Equal(t, tt.memo, packetData.Memo)
+
+			data := packetData.Data
+			messages, err := icatypes.DeserializeCosmosTx(cdc, data)
+
+			require.NoError(t, err)
+			require.NotNil(t, messages)
+
+			tt.assertionFn(messages[0])
+		})
+	}
+}