feat(eip712): Create LedgerPreprocessHook to reformat EIP-712 payloads (

#1277)

* Create ReformatLedgerTx to reformat EIP-712 payloads

* Fix issue with public key; minor refactors

* Refactor naming; add test case

* Update preprocess_test

* Add tests and fix lint

* Refactor preprocess test

* Implement minor fix and add changelog entry

Co-authored-by: Freddy Caceres <facs95@gmail.com>
Co-authored-by: Federico Kunze Küllmer <31522760+fedekunze@users.noreply.github.com>

CHANGELOG.md

@@ -61,6 +61,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (cli) [#1230](https://github.com/evmos/ethermint/pull/1230) Remove redundant positional height parameter from feemarket's query cli.
 * (ante) [#1289](https://github.com/evmos/ethermint/pull/1289) Change the fallback tx priority mechanism to be based on gas price.
 * (test) [#1311](https://github.com/evmos/ethermint/pull/1311) add integration test for the rollback cmd
+* (ledger) [#1277](https://github.com/evmos/ethermint/pull/1277) Add Ledger preprocessing transaction hook for EIP-712-signed Cosmos payloads.
 * (rpc) [#1296](https://github.com/evmos/ethermint/pull/1296) add backend blocks.go unit tests.
 
 ### Bug Fixes

ethereum/eip712/preprocess.go

@@ -0,0 +1,83 @@
+package eip712
+
+import (
+ "fmt"
+
+ "github.com/cosmos/cosmos-sdk/client"
+ codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+ cosmoskr "github.com/cosmos/cosmos-sdk/crypto/keyring"
+ "github.com/cosmos/cosmos-sdk/types/tx/signing"
+ authtx "github.com/cosmos/cosmos-sdk/x/auth/tx"
+ "github.com/evmos/ethermint/types"
+)
+
+// PreprocessLedgerTx reformats Ledger-signed Cosmos transactions to match the fork expected by Ethermint
+// by including the signature in a Web3Tx extension and sending a blank signature in the body.
+func PreprocessLedgerTx(chainID string, keyType cosmoskr.KeyType, txBuilder client.TxBuilder) error {
+ // Only process Ledger transactions
+ if keyType != cosmoskr.TypeLedger {
+ return nil
+ }
+
+ // Init extension builder to set Web3 extension
+ extensionBuilder, ok := txBuilder.(authtx.ExtensionOptionsTxBuilder)
+ if !ok {
+ return fmt.Errorf("cannot cast TxBuilder to ExtensionOptionsTxBuilder")
+ }
+
+ // Get signatures from TxBuilder
+ sigs, err := txBuilder.GetTx().GetSignaturesV2()
+ if err != nil {
+ return fmt.Errorf("could not get signatures: %w", err)
+ }
+
+ // Verify single-signer
+ if len(sigs) != 1 {
+ return fmt.Errorf("invalid number of signatures, expected 1 and got %v", len(sigs))
+ }
+
+ signature := sigs[0]
+ sigData, ok := signature.Data.(*signing.SingleSignatureData)
+ if !ok {
+ return fmt.Errorf("unexpected signature type, expected SingleSignatureData")
+ }
+ sigBytes := sigData.Signature
+
+ // Parse Chain ID as big.Int
+ chainIDInt, err := types.ParseChainID(chainID)
+ if err != nil {
+ return fmt.Errorf("could not parse chain id: %w", err)
+ }
+
+ // Add ExtensionOptionsWeb3Tx extension with signature
+ var option *codectypes.Any
+ option, err = codectypes.NewAnyWithValue(&types.ExtensionOptionsWeb3Tx{
+ FeePayer: txBuilder.GetTx().FeePayer().String(),
+ TypedDataChainID: chainIDInt.Uint64(),
+ FeePayerSig: sigBytes,
+ })
+ if err != nil {
+ return fmt.Errorf("could not set extension as any: %w", err)
+ }
+
+ extensionBuilder.SetExtensionOptions(option)
+
+ // Set blank signature with Amino Sign Type
+ // (Regardless of input signMode, Evmos requires Amino signature type for Ledger)
+ blankSig := signing.SingleSignatureData{
+ SignMode: signing.SignMode_SIGN_MODE_LEGACY_AMINO_JSON,
+ Signature: nil,
+ }
+ sig := signing.SignatureV2{
+ PubKey: signature.PubKey,
+ Data: &blankSig,
+ Sequence: signature.Sequence,
+ }
+
+ err = txBuilder.SetSignatures(sig)
+ if err != nil {
+ return fmt.Errorf("unable to set signatures on payload: %w", err)
+ }
+
+ return nil
+}

ethereum/eip712/preprocess_test.go

@@ -0,0 +1,220 @@
+package eip712_test
+
+import (
+ "encoding/hex"
+ "strings"
+ "testing"
+
+ "cosmossdk.io/math"
+ "github.com/cosmos/cosmos-sdk/client"
+ codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+ "github.com/cosmos/cosmos-sdk/crypto/keyring"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/cosmos/cosmos-sdk/types/tx/signing"
+ "github.com/cosmos/cosmos-sdk/x/auth/ante"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+ "github.com/evmos/ethermint/app"
+ "github.com/evmos/ethermint/encoding"
+ "github.com/evmos/ethermint/ethereum/eip712"
+ "github.com/evmos/ethermint/tests"
+ "github.com/evmos/ethermint/types"
+ evmtypes "github.com/evmos/ethermint/x/evm/types"
+ "github.com/stretchr/testify/require"
+)
+
+// Testing Constants
+var chainId = "ethermint_9000-1"
+var ctx = client.Context{}.WithTxConfig(
+ encoding.MakeConfig(app.ModuleBasics).TxConfig,
+)
+var feePayerAddress = "ethm17xpfvakm2amg962yls6f84z3kell8c5lthdzgl"
+
+type TestCaseStruct struct {
+ txBuilder client.TxBuilder
+ expectedFeePayer string
+ expectedGas uint64
+ expectedFee math.Int
+ expectedMemo string
+ expectedMsg string
+ expectedSignatureBytes []byte
+}
+
+func TestLedgerPreprocessing(t *testing.T) {
+ // Update bech32 prefix
+ sdk.GetConfig().SetBech32PrefixForAccount("ethm", "")
+
+ testCases := []TestCaseStruct{
+ createBasicTestCase(t),
+ createPopulatedTestCase(t),
+ }
+
+ for _, tc := range testCases {
+ // Run pre-processing
+ err := eip712.PreprocessLedgerTx(
+ chainId,
+ keyring.TypeLedger,
+ tc.txBuilder,
+ )
+
+ require.NoError(t, err)
+
+ // Verify Web3 extension matches expected
+ hasExtOptsTx, ok := tc.txBuilder.(ante.HasExtensionOptionsTx)
+ require.True(t, ok)
+ require.True(t, len(hasExtOptsTx.GetExtensionOptions()) == 1)
+
+ expectedExt := types.ExtensionOptionsWeb3Tx{
+ TypedDataChainID: 9000,
+ FeePayer: feePayerAddress,
+ FeePayerSig: tc.expectedSignatureBytes,
+ }
+
+ expectedExtAny, err := codectypes.NewAnyWithValue(&expectedExt)
+ require.NoError(t, err)
+
+ actualExtAny := hasExtOptsTx.GetExtensionOptions()[0]
+ require.Equal(t, expectedExtAny, actualExtAny)
+
+ // Verify signature type matches expected
+ signatures, err := tc.txBuilder.GetTx().GetSignaturesV2()
+ require.NoError(t, err)
+ require.Equal(t, len(signatures), 1)
+
+ txSig := signatures[0].Data.(*signing.SingleSignatureData)
+ require.Equal(t, txSig.SignMode, signing.SignMode_SIGN_MODE_LEGACY_AMINO_JSON)
+
+ // Verify signature is blank
+ require.Equal(t, len(txSig.Signature), 0)
+
+ // Verify tx fields are unchanged
+ tx := tc.txBuilder.GetTx()
+
+ require.Equal(t, tx.FeePayer().String(), tc.expectedFeePayer)
+ require.Equal(t, tx.GetGas(), tc.expectedGas)
+ require.Equal(t, tx.GetFee().AmountOf(evmtypes.DefaultParams().EvmDenom), tc.expectedFee)
+ require.Equal(t, tx.GetMemo(), tc.expectedMemo)
+
+ // Verify message is unchanged
+ if tc.expectedMsg != "" {
+ require.Equal(t, len(tx.GetMsgs()), 1)
+ require.Equal(t, tx.GetMsgs()[0].String(), tc.expectedMsg)
+ } else {
+ require.Equal(t, len(tx.GetMsgs()), 0)
+ }
+ }
+}
+
+func TestBlankTxBuilder(t *testing.T) {
+ txBuilder := ctx.TxConfig.NewTxBuilder()
+
+ err := eip712.PreprocessLedgerTx(
+ chainId,
+ keyring.TypeLedger,
+ txBuilder,
+ )
+
+ require.Error(t, err)
+}
+
+func TestNonLedgerTxBuilder(t *testing.T) {
+ txBuilder := ctx.TxConfig.NewTxBuilder()
+
+ err := eip712.PreprocessLedgerTx(
+ chainId,
+ keyring.TypeLocal,
+ txBuilder,
+ )
+
+ require.NoError(t, err)
+}
+
+func TestInvalidChainId(t *testing.T) {
+ txBuilder := ctx.TxConfig.NewTxBuilder()
+
+ err := eip712.PreprocessLedgerTx(
+ "invalid-chain-id",
+ keyring.TypeLedger,
+ txBuilder,
+ )
+
+ require.Error(t, err)
+}
+
+func createBasicTestCase(t *testing.T) TestCaseStruct {
+ t.Helper()
+ txBuilder := ctx.TxConfig.NewTxBuilder()
+
+ feePayer, err := sdk.AccAddressFromBech32(feePayerAddress)
+ require.NoError(t, err)
+
+ txBuilder.SetFeePayer(feePayer)
+
+ // Create signature unrelated to payload for testing
+ signatureHex := strings.Repeat("01", 65)
+ signatureBytes, err := hex.DecodeString(signatureHex)
+ require.NoError(t, err)
+
+ _, privKey := tests.NewAddrKey()
+ sigsV2 := signing.SignatureV2{
+ PubKey: privKey.PubKey(), // Use unrelated public key for testing
+ Data: &signing.SingleSignatureData{
+ SignMode: signing.SignMode_SIGN_MODE_DIRECT,
+ Signature: signatureBytes,
+ },
+ Sequence: 0,
+ }
+
+ txBuilder.SetSignatures(sigsV2)
+ return TestCaseStruct{
+ txBuilder: txBuilder,
+ expectedFeePayer: feePayer.String(),
+ expectedGas: 0,
+ expectedFee: math.NewInt(0),
+ expectedMemo: "",
+ expectedMsg: "",
+ expectedSignatureBytes: signatureBytes,
+ }
+}
+
+func createPopulatedTestCase(t *testing.T) TestCaseStruct {
+ t.Helper()
+ basicTestCase := createBasicTestCase(t)
+ txBuilder := basicTestCase.txBuilder
+
+ gasLimit := uint64(200000)
+ memo := ""
+ denom := evmtypes.DefaultParams().EvmDenom
+ feeAmount := math.NewInt(2000)
+
+ txBuilder.SetFeeAmount(sdk.NewCoins(
+ sdk.NewCoin(
+ denom,
+ feeAmount,
+ )))
+
+ txBuilder.SetGasLimit(gasLimit)
+ txBuilder.SetMemo(memo)
+
+ msgSend := banktypes.MsgSend{
+ FromAddress: feePayerAddress,
+ ToAddress: "ethm12luku6uxehhak02py4rcz65zu0swh7wjun6msa",
+ Amount: sdk.NewCoins(
+ sdk.NewCoin(
+ evmtypes.DefaultParams().EvmDenom,
+ math.NewInt(10000000),
+ ),
+ ),
+ }
+
+ txBuilder.SetMsgs(&msgSend)
+
+ return TestCaseStruct{
+ txBuilder: txBuilder,
+ expectedFeePayer: basicTestCase.expectedFeePayer,
+ expectedGas: gasLimit,
+ expectedFee: feeAmount,
+ expectedMemo: memo,
+ expectedMsg: msgSend.String(),
+ expectedSignatureBytes: basicTestCase.expectedSignatureBytes,
+ }
+}