feat: added implementation of MsgExecutePayload

Author: 0xNilesh

api/crosschain/v1/params.pulsar.go

@@ -29,4 +29,20 @@ message AdminParams {
 
   // The verifier precompile contract address (EVM).
   string verifier_precompile = 2;
+}
+
+// CrossChainPayload mirrors the Solidity struct
+message CrossChainPayload {
+  option (amino.name) = "crosschain/crosschain_payload";
+  option (gogoproto.equal) = true;
+  option (gogoproto.goproto_stringer) = false;
+
+  string target = 1;                 // EVM address as hex string (0x...)
+  string value = 2;                  // Amount in wei as string (uint256)
+  bytes data = 3;                    // ABI-encoded calldata
+  string gas_limit = 4;             // uint256 as string
+  string max_fee_per_gas = 5;       // uint256 as string
+  string max_priority_fee_per_gas = 6; // uint256 as string
+  string nonce = 7;                 // uint256 as string
+  string deadline = 8;              // uint256 as string
 }

api/crosschain/v1/tx.pulsar.go

@@ -26,6 +26,9 @@ service Msg {
 
   // MintPush defines a message to mint PUSH tokens to a smart account,
   rpc MintPush(MsgMintPush) returns (MsgMintPushResponse);
+
+  // ExecutePayload defines a message for executing a cross-chain payload
+  rpc ExecutePayload(MsgExecutePayload) returns (MsgExecutePayloadResponse);
 }
 
 // MsgUpdateParams is the Msg/UpdateParams request type.
@@ -108,4 +111,25 @@ message MsgMintPush {
 }
 
 // MsgMintPushResponse defines the response for MsgMintPush.
-message MsgMintPushResponse {}
+message MsgMintPushResponse {}
+
+// MsgExecutePayload defines a message for executing a cross-chain payload
+message MsgExecutePayload {
+  option (amino.name) = "crosschain/MsgExecutePayload";
+  option (cosmos.msg.v1.signer) = "signer";
+
+  // signer is the Cosmos address initiating the tx (used for tx signing)
+  string signer = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+
+  // caip_string is used for generating deterministic salt for the smart account
+  string caip_string = 2;
+
+  // payload is the crosschain payload to be executed
+  CrossChainPayload crosschain_payload = 3;
+
+  // signature is the signature of the payload by user
+  bytes signature = 4;
+}
+
+// MsgExecutePayloadResponse defines the response for MsgExecutePayload.
+message MsgExecutePayloadResponse {}

api/crosschain/v1/tx_grpc.pb.go

@@ -42,6 +42,10 @@ func (am AppModule) AutoCLIOptions() *autocliv1.ModuleOptions {
 					RpcMethod: "MintPush",
 					Use:       "mint-push [tx-hash] [caip-string]",
 				},
+				{
+					RpcMethod: "ExecutePayload",
+					Use:       "execute-payload [caip-string] [target] [value] [data-hex] [gas-limit] [max-fee-per-gas] [max-priority-fee-per-gas] [nonce] [deadline] [signature-hex]",
+				},
 			},
 		},
 	}

proto/crosschain/v1/params.proto

@@ -1,7 +1,9 @@
 package cli
 
 import (
+	"encoding/hex"
 	"strconv"
+	"strings"
 
 	"github.com/spf13/cobra"
 
@@ -192,3 +194,64 @@ func MsgMintPush() *cobra.Command {
 	flags.AddTxFlagsToCmd(cmd)
 	return cmd
 }
+
+func MsgExecutePayload() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "execute-payload [caip-string] [target] [value] [data-hex] [gas-limit] [max-fee-per-gas] [max-priority-fee-per-gas] [nonce] [deadline] [signature-hex]",
+		Short: "Execute a cross-chain payload with a signature",
+		Args:  cobra.ExactArgs(9),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			senderAddress := cliCtx.GetFromAddress()
+
+			caipString := args[0]
+			target := args[1]
+			value := args[2]
+
+			data, err := hex.DecodeString(strings.TrimPrefix(args[3], "0x"))
+			if err != nil {
+				return err
+			}
+
+			gasLimit := args[4]
+			maxFeePerGas := args[5]
+			maxPriorityFeePerGas := args[6]
+			nonce := args[7]
+			deadline := args[8]
+
+			signature, err := hex.DecodeString(strings.TrimPrefix(args[9], "0x"))
+			if err != nil {
+				return err
+			}
+
+			msg := &types.MsgExecutePayload{
+				Signer:     senderAddress.String(),
+				CaipString: caipString,
+				CrosschainPayload: &types.CrossChainPayload{
+					Target:               target,
+					Value:                value,
+					Data:                 data,
+					GasLimit:             gasLimit,
+					MaxFeePerGas:         maxFeePerGas,
+					MaxPriorityFeePerGas: maxPriorityFeePerGas,
+					Nonce:                nonce,
+					Deadline:             deadline,
+				},
+				Signature: signature,
+			}
+
+			if err := msg.Validate(); err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(cliCtx, cmd.Flags(), msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+	return cmd
+}

proto/crosschain/v1/tx.proto

@@ -87,10 +87,10 @@ func SetupTest(t *testing.T) *testFixture {
 	registerBaseSDKModules(logger, f, encCfg, keys, accountAddressCodec, validatorAddressCodec, consensusAddressCodec)
 
 	// Setup Keeper.
-	f.k = keeper.NewKeeper(encCfg.Codec, runtime.NewKVStoreService(keys[types.ModuleName]), logger, f.govModAddr, &evmkeeper.Keeper{})
+	f.k = keeper.NewKeeper(encCfg.Codec, runtime.NewKVStoreService(keys[types.ModuleName]), logger, f.govModAddr, &evmkeeper.Keeper{}, f.bankkeeper)
 	f.msgServer = keeper.NewMsgServerImpl(f.k)
 	f.queryServer = keeper.NewQuerier(f.k)
-	f.appModule = module.NewAppModule(encCfg.Codec, f.k, &evmkeeper.Keeper{})
+	f.appModule = module.NewAppModule(encCfg.Codec, f.k, &evmkeeper.Keeper{}, &f.bankkeeper)
 
 	return f
 }

x/crosschain/autocli.go

@@ -3,6 +3,7 @@ package keeper
 import (
 	"context"
 	"encoding/hex"
+	"math/big"
 	"strings"
 
 	"fmt"
@@ -28,9 +29,16 @@ var _ types.MsgServer = msgServer{}
 
 func hexToBytes(hexStr string) ([]byte, error) {
 	hexStr = strings.TrimPrefix(hexStr, "0x")
+	fmt.Println("Hex string:", hexStr)
+	fmt.Println(hex.DecodeString(hexStr))
 	return hex.DecodeString(hexStr)
 }
 
+func stringToBigInt(s string) *big.Int {
+	bi, _ := new(big.Int).SetString(s, 10)
+	return bi
+}
+
 func evmToCosmosAddress(evmAddr string) (sdk.AccAddress, error) {
 	if len(evmAddr) != 42 {
 		return nil, fmt.Errorf("invalid EVM address length")
@@ -119,14 +127,19 @@ func (ms msgServer) DeployNMSC(ctx context.Context, msg *types.MsgDeployNMSC) (*
 	if err != nil {
 		return nil, err
 	}
+
 	caipString := msg.CaipString
 	ownerType := uint8(msg.OwnerType)
 	factoryAddress := common.HexToAddress(adminParams.FactoryAddress)
 	verifierPrecompile := common.HexToAddress(adminParams.VerifierPrecompile)
 
+	userKeys := common.HexToAddress("0x778D3206374f8AC265728E18E3fE2Ae6b93E4ce4").Bytes()
+	fmt.Println("User key:", userKeys)
+
 	fmt.Println("Factory address:", factoryAddress)
 	fmt.Println("Verifier precompile address:", verifierPrecompile)
 	fmt.Println("User key:", userKey)
+	fmt.Println(msg.UserKey)
 	fmt.Println("CAIP string:", caipString)
 	fmt.Println("Owner type:", ownerType)
 	fmt.Println("EVM from address:", evmFromAddress)
@@ -247,3 +260,100 @@ func (ms msgServer) MintPush(ctx context.Context, msg *types.MsgMintPush) (*type
 
 	return &types.MsgMintPushResponse{}, nil
 }
+
+// ExecutePayload implements types.MsgServer.
+func (ms msgServer) ExecutePayload(ctx context.Context, msg *types.MsgExecutePayload) (*types.MsgExecutePayloadResponse, error) {
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+
+	// Retrieve the current Params
+	adminParams, err := ms.k.AdminParams.Get(ctx)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get admin params")
+	}
+
+	// Get the Cosmos address in Bech32 format (from the signer in MsgDeployNMSC)
+	signer := msg.Signer
+
+	// Convert the Bech32 address to sdk.AccAddress
+	cosmosAddr, err := sdk.AccAddressFromBech32(signer)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to convert Bech32 address")
+	}
+
+	// Now convert the Cosmos address to an EVM address
+	evmFromAddress := common.BytesToAddress(cosmosAddr.Bytes()[len(cosmosAddr)-20:])
+	factoryAddress := common.HexToAddress(adminParams.FactoryAddress)
+
+	// Parse ABI once
+	parsedFactoryABI, err := abi.JSON(strings.NewReader(types.FactoryV1ABI))
+	if err != nil {
+		return nil, err
+	}
+
+	// Calling factory contract to compute the smart account address
+	receipt, err := ms.k.evmKeeper.CallEVM(
+		sdkCtx,
+		parsedFactoryABI,
+		evmFromAddress, // who is sending the transaction
+		factoryAddress, // destination: FactoryV1 contract
+		false,          // commit = false
+		"computeSmartAccountAddress",
+		msg.CaipString,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if receipt.VmError != "" {
+		fmt.Println("VM Error:", receipt.VmError)
+	}
+
+	returnedBytesHex := common.Bytes2Hex(receipt.Ret)
+	addressBytes := returnedBytesHex[24:] // last 20 bytes
+	nmscComputedAddress := "0x" + addressBytes
+	nmscAddr := common.HexToAddress(nmscComputedAddress)
+
+	parsedNMSCABI, err := abi.JSON(strings.NewReader(types.SmartAccountV1ABI))
+	if err != nil {
+		return nil, err
+	}
+
+	protoPayload := msg.CrosschainPayload // your existing proto-generated struct
+
+	payload := types.AbiCrossChainPayload{
+		Target:               common.HexToAddress(protoPayload.Target),
+		Value:                stringToBigInt(protoPayload.Value),
+		Data:                 protoPayload.Data,
+		GasLimit:             stringToBigInt(protoPayload.GasLimit),
+		MaxFeePerGas:         stringToBigInt(protoPayload.MaxFeePerGas),
+		MaxPriorityFeePerGas: stringToBigInt(protoPayload.MaxPriorityFeePerGas),
+		Nonce:                stringToBigInt(protoPayload.Nonce),
+		Deadline:             stringToBigInt(protoPayload.Deadline),
+	}
+
+	// Calling the NMSC contract
+	receipt, err = ms.k.evmKeeper.CallEVM(
+		sdkCtx,
+		parsedNMSCABI,
+		evmFromAddress, // who is sending the transaction
+		nmscAddr,       // destination: nmsc contract
+		true,           // commit = true
+		"executePayload",
+		payload,
+		msg.Signature,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	fmt.Println("EVM tx hash:", receipt.Hash)
+	fmt.Println("Gas used:", receipt.GasUsed)
+	fmt.Println("Logs:", receipt.Logs)
+	fmt.Println("Returned data:", receipt.Ret)
+	if receipt.VmError != "" {
+		fmt.Println("VM Error:", receipt.VmError)
+	}
+	fmt.Println("Return data:", common.Bytes2Hex(receipt.Ret))
+
+	return &types.MsgExecutePayloadResponse{}, nil
+}