[WIP] RPC simulation for high gas wanted txs

contracts/test/CW20toERC20PointerTest.js

@@ -60,7 +60,7 @@ describe("CW20 to ERC20 Pointer", function () {
                         await deployErc20PointerForCw20(hre.ethers.provider, pointer, 5);
                         expect.fail(`Expected to be prevented from creating a pointer`);
                     } catch(e){
-                        expect(e.message).to.include("contract deployment failed");
+                        expect(e.message).to.include("execution reverted");
                     }
                 });
             });

contracts/test/ERC20toNativePointerTest.js

@@ -1,6 +1,7 @@
 const {setupSigners, deployErc20PointerNative, getAdmin, createTokenFactoryTokenAndMint, ABI, generateWallet,
     fundAddress, getSeiAddress,
-    delay
+    delay,
+    adminKeyName
 } = require("./lib");
 const {expect} = require("chai");
 
@@ -20,7 +21,7 @@ describe("ERC20 to Native Pointer", function () {
         denom = await createTokenFactoryTokenAndMint(`native-pointer-test-${random_num}`, 1000, accounts[0].seiAddress)
 
         // deploy TestToken
-        const pointerAddr = await deployErc20PointerNative(hre.ethers.provider, denom)
+        const pointerAddr = await deployErc20PointerNative(hre.ethers.provider, denom, from=adminKeyName, evmRpc="", gasLimit=1370000)
         const contract = new hre.ethers.Contract(pointerAddr, ABI.ERC20, hre.ethers.provider);
         pointer = contract.connect(accounts[0].signer)
     })

contracts/test/EVMCompatabilityTest.js

@@ -93,7 +93,10 @@ describe("EVM Test", function () {
       testToken = await TestToken.deploy("TestToken", "TTK");
 
       const EVMCompatibilityTester = await ethers.getContractFactory("EVMCompatibilityTester");
+      console.log("DEBUG: deploying evmTester")
       evmTester = await EVMCompatibilityTester.deploy({ gasPrice: ethers.parseUnits('100', 'gwei') });
+      // evmTester = await EVMCompatibilityTester.deploy();
+      console.log("DEBUG: deployed evmTester")
 
       await Promise.all([evmTester.waitForDeployment(), testToken.waitForDeployment()])
 
@@ -1221,7 +1224,7 @@ describe("EVM throughput", function(){
 
   it("send 100 transactions from one account", async function(){
     const wallet = generateWallet()
-    const toAddress =await wallet.getAddress()
+    const toAddress = await wallet.getAddress()
     const sender = accounts[0].signer
     const address = accounts[0].evmAddress;
     const txCount = 100;

contracts/test/lib.js

@@ -278,8 +278,8 @@ async function getPointerForCw1155(cw1155Address) {
     return JSON.parse(output);
 }
 
-async function deployErc20PointerForCw20(provider, cw20Address, attempts=10, from=adminKeyName, evmRpc="") {
-    let command = `seid tx evm register-evm-pointer CW20 ${cw20Address} --from=${from} -b block`
+async function deployErc20PointerForCw20(provider, cw20Address, attempts=10, from=adminKeyName, evmRpc="", gasLimit=2700000) {
+    let command = `seid tx evm register-evm-pointer CW20 ${cw20Address} --gas-limit=${gasLimit} --from=${from} -b block`
     if (evmRpc) {
         command = command + ` --evm-rpc=${evmRpc}`
     }
@@ -299,8 +299,8 @@ async function deployErc20PointerForCw20(provider, cw20Address, attempts=10, fro
     throw new Error("contract deployment failed")
 }
 
-async function deployErc20PointerNative(provider, name, from=adminKeyName, evmRpc="") {
-    let command = `seid tx evm call-precompile pointer addNativePointer ${name} --from=${from} -b block`
+async function deployErc20PointerNative(provider, name, from=adminKeyName, evmRpc="", gasLimit=300000) {
+    let command = `seid tx evm call-precompile pointer addNativePointer ${name} --gas-limit=${gasLimit} --from=${from} -b block`
     if (evmRpc) {
         command = command + ` --evm-rpc=${evmRpc}`
     }

evmrpc/send.go

@@ -3,6 +3,7 @@
 import (
 	"context"
 	"errors"
+	"fmt"
 	"time"
 
 	"github.com/cosmos/cosmos-sdk/client"
@@ -12,7 +13,9 @@
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/lib/ethapi"
+	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/signer/core/apitypes"
+	"github.com/sei-protocol/sei-chain/precompiles/wasmd"
 	"github.com/sei-protocol/sei-chain/x/evm/keeper"
 	"github.com/sei-protocol/sei-chain/x/evm/types"
 	"github.com/sei-protocol/sei-chain/x/evm/types/ethtx"
@@ -32,9 +35,21 @@
 
 type SendConfig struct {
 	slow bool
+	// the threshold for the gas wanted to be considered "high" and sendRawTransaction will simulate the tx
+	// to check if the gas wanted is reasonable
+	simulationGasThreshold uint64
+	// the minimum percentage that the estimate gas used needs to be of the gas wanted for the tx to be sent
+	// For example, if the gasWantedVsGasUsedPercentDiff is .8 then the estimate gas used must be at least 80% of the gas wanted
+	gasWantedVsGasUsedPercentDiff float64
 }
 
 func NewSendAPI(tmClient rpcclient.Client, txConfig client.TxConfig, sendConfig *SendConfig, k *keeper.Keeper, ctxProvider func(int64) sdk.Context, homeDir string, simulateConfig *SimulateConfig, connectionType ConnectionType) *SendAPI {
+	if sendConfig.simulationGasThreshold == 0 {
+		panic("simulationGasThreshold must be greater than 0")
+	}
+	if sendConfig.gasWantedVsGasUsedPercentDiff > 1 || sendConfig.gasWantedVsGasUsedPercentDiff < 0 {
+		panic("minHGWPercentDiff must be between 0 and 1")
+	}
 	return &SendAPI{
 		tmClient:       tmClient,
 		txConfig:       txConfig,
@@ -72,7 +87,21 @@
 		return hash, encodeErr
 	}
 
+	if tx.Gas() > s.sendConfig.simulationGasThreshold {
+		fmt.Println("DEBUG: tx.Gas() = ", tx.Gas(), "gas threshold = ", s.sendConfig.simulationGasThreshold)
+		estimate, err := s.simulateTx(ctx, tx)
+		if err != nil {
+			return hash, err
+		}
+		fmt.Println("DEBUG: estimate = ", estimate)
+		percentDiff := float64(estimate) / float64(tx.Gas())
+		if percentDiff < s.sendConfig.gasWantedVsGasUsedPercentDiff {
+			return hash, fmt.Errorf("Estimated gas used (%d) differs too much from gas limit (%d). Please try again with a more accurate gas limit.", estimate, tx.Gas())
+		}
+	}
+
 	if s.sendConfig.slow {
+		fmt.Println("slow")
 		res, broadcastError := s.tmClient.BroadcastTxCommit(ctx, txbz)
 		if broadcastError != nil {
 			err = broadcastError
@@ -82,6 +111,7 @@
 			err = sdkerrors.ABCIError(sdkerrors.RootCodespace, res.CheckTx.Code, "")
 		}
 	} else {
+		fmt.Println("fast")
 		res, broadcastError := s.tmClient.BroadcastTx(ctx, txbz)
 		if broadcastError != nil {
 			err = broadcastError
@@ -94,6 +124,75 @@
 	return
 }
 
+func (s *SendAPI) simulateTx(ctx context.Context, tx *ethtypes.Transaction) (estimate uint64, err error) {
+	defer func() {
+		fmt.Println("DEBUG: estimate = ", estimate, "err = ", err)
+	}()
+	var from common.Address
+	if tx.Type() == ethtypes.DynamicFeeTxType {
+		signer := ethtypes.NewLondonSigner(s.keeper.ChainID(s.ctxProvider(LatestCtxHeight)))
+		from, err = signer.Sender(tx)
+		if err != nil {
+			err = fmt.Errorf("failed to get sender for dynamic fee tx: %w", err)
+			return
+		}
+	} else if tx.Protected() {
+		signer := ethtypes.NewEIP155Signer(s.keeper.ChainID(s.ctxProvider(LatestCtxHeight)))
+		from, err = signer.Sender(tx)
+		if err != nil {
+			err = fmt.Errorf("failed to get sender for protected tx: %w", err)
+			return
+		}
+	} else {
+		signer := ethtypes.HomesteadSigner{}
+		from, err = signer.Sender(tx)
+		if err != nil {
+			err = fmt.Errorf("failed to get sender for homestead tx: %w", err)
+			return
+		}
+	}
+	input_ := (hexutil.Bytes)(tx.Data())
+	gas_ := hexutil.Uint64(tx.Gas())
+	nonce_ := hexutil.Uint64(tx.Nonce())
+	al := tx.AccessList()
+	bNrOrHash := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
+	ctx = context.WithValue(ctx, CtxIsWasmdPrecompileCallKey, wasmd.IsWasmdCall(tx.To()))
+	fmt.Println("DEBUG: gas price = ", tx.GasPrice())
+	fmt.Println("DEBUG: gas fee cap = ", tx.GasFeeCap())
+	fmt.Println("DEBUG: gas tip cap = ", tx.GasTipCap())
+	gp := tx.GasPrice()
+	maxFeePerGas := tx.GasFeeCap()
+	maxPriorityFeePerGas := tx.GasTipCap()
+	if gp != nil {
+		maxFeePerGas = nil
+		maxPriorityFeePerGas = nil
+	} else {
+		gp = nil
+	}
+	fmt.Println("DEBUG: gp = ", gp)
+	fmt.Println("DEBUG: maxFeePerGas = ", maxFeePerGas)
+	fmt.Println("DEBUG: maxPriorityFeePerGas = ", maxPriorityFeePerGas)
+	txArgs := ethapi.TransactionArgs{
+		From:                 &from,
+		To:                   tx.To(),
+		Gas:                  &gas_,
+		GasPrice:             (*hexutil.Big)(gp),
+		MaxFeePerGas:         (*hexutil.Big)(maxFeePerGas),
+		MaxPriorityFeePerGas: (*hexutil.Big)(maxPriorityFeePerGas),
+		Value:                (*hexutil.Big)(tx.Value()),
+		Nonce:                &nonce_,
+		Input:                &input_,
+		AccessList:           &al,
+		ChainID:              (*hexutil.Big)(tx.ChainId()),
+	}
+	estimate_, err := ethapi.DoEstimateGas(ctx, s.backend, txArgs, bNrOrHash, nil, s.backend.RPCGasCap())
+	if err != nil {
+		err = fmt.Errorf("failed to estimate gas: %w", err)
+		return
+	}
+	return uint64(estimate_), nil
+}
+
 func (s *SendAPI) SignTransaction(_ context.Context, args apitypes.SendTxArgs, _ *string) (result *ethapi.SignTransactionResult, returnErr error) {
 	startTime := time.Now()
 	defer recordMetrics("eth_signTransaction", s.connectionType, startTime, returnErr == nil)

evmrpc/send_test.go

@@ -2,6 +2,7 @@ package evmrpc_test
 
 import (
 	"encoding/hex"
+	"fmt"
 	"math/big"
 	"testing"
 
@@ -35,20 +36,7 @@ func TestSendRawTransaction(t *testing.T) {
 		Data:      []byte("abc"),
 		ChainID:   EVMKeeper.ChainID(Ctx),
 	}
-	mnemonic := "fish mention unlock february marble dove vintage sand hub ordinary fade found inject room embark supply fabric improve spike stem give current similar glimpse"
-	derivedPriv, _ := hd.Secp256k1.Derive()(mnemonic, "", "")
-	privKey := hd.Secp256k1.Generate()(derivedPriv)
-	testPrivHex := hex.EncodeToString(privKey.Bytes())
-	key, _ := crypto.HexToECDSA(testPrivHex)
-	ethCfg := types.DefaultChainConfig().EthereumConfig(EVMKeeper.ChainID(Ctx))
-	signer := ethtypes.MakeSigner(ethCfg, big.NewInt(Ctx.BlockHeight()), uint64(Ctx.BlockTime().Unix()))
-	tx := ethtypes.NewTx(&txData)
-	tx, err := ethtypes.SignTx(tx, signer, key)
-	require.Nil(t, err)
-	bz, err := tx.MarshalBinary()
-	require.Nil(t, err)
-	payload := "0x" + hex.EncodeToString(bz)
-
+	tx, payload := signTxData(t, txData)
 	resObj := sendRequestGood(t, "sendRawTransaction", payload)
 	result := resObj["result"].(string)
 	require.Equal(t, tx.Hash().Hex(), result)
@@ -63,3 +51,40 @@ func TestSendRawTransaction(t *testing.T) {
 	errMap = resObj["error"].(map[string]interface{})
 	require.Equal(t, ": invalid sequence", errMap["message"].(string))
 }
+
+func TestSendRawTransactionHighGasWanted(t *testing.T) {
+	to := common.HexToAddress("010203")
+	txData := ethtypes.DynamicFeeTx{
+		Nonce:     1,
+		GasFeeCap: big.NewInt(10),
+		Gas:       1200000,
+		To:        &to,
+		Value:     big.NewInt(1000),
+		Data:      []byte("abc"),
+		ChainID:   EVMKeeper.ChainID(Ctx),
+	}
+	_, payload := signTxData(t, txData)
+	resObj := sendRequestGood(t, "sendRawTransaction", payload)
+	fmt.Println(resObj)
+	require.NotNil(t, resObj["error"])
+	// expect an error
+	errMap := resObj["error"].(map[string]interface{})
+	require.Equal(t, "Estimated gas used (1200000) differs too much from gas limit (1000000). Please try again with a more accurate gas limit.", errMap["message"].(string))
+}
+
+func signTxData(t *testing.T, txData ethtypes.DynamicFeeTx) (*ethtypes.Transaction, string) {
+	mnemonic := "fish mention unlock february marble dove vintage sand hub ordinary fade found inject room embark supply fabric improve spike stem give current similar glimpse"
+	derivedPriv, _ := hd.Secp256k1.Derive()(mnemonic, "", "")
+	privKey := hd.Secp256k1.Generate()(derivedPriv)
+	testPrivHex := hex.EncodeToString(privKey.Bytes())
+	key, _ := crypto.HexToECDSA(testPrivHex)
+	ethCfg := types.DefaultChainConfig().EthereumConfig(EVMKeeper.ChainID(Ctx))
+	signer := ethtypes.MakeSigner(ethCfg, big.NewInt(Ctx.BlockHeight()), uint64(Ctx.BlockTime().Unix()))
+	tx := ethtypes.NewTx(&txData)
+	tx, err := ethtypes.SignTx(tx, signer, key)
+	require.Nil(t, err)
+	bz, err := tx.MarshalBinary()
+	require.Nil(t, err)
+	payload := "0x" + hex.EncodeToString(bz)
+	return tx, payload
+}

evmrpc/server.go

@@ -45,7 +45,8 @@ func NewEVMHTTPServer(
 		return nil, err
 	}
 	simulateConfig := &SimulateConfig{GasCap: config.SimulationGasLimit, EVMTimeout: config.SimulationEVMTimeout}
-	sendAPI := NewSendAPI(tmClient, txConfig, &SendConfig{slow: config.Slow}, k, ctxProvider, homeDir, simulateConfig, ConnectionTypeHTTP)
+	sendConfig := &SendConfig{slow: config.Slow, simulationGasThreshold: 1000000, gasWantedVsGasUsedPercentDiff: 0.8}
+	sendAPI := NewSendAPI(tmClient, txConfig, sendConfig, k, ctxProvider, homeDir, simulateConfig, ConnectionTypeHTTP)
 	ctx := ctxProvider(LatestCtxHeight)
 
 	txAPI := NewTransactionAPI(tmClient, k, ctxProvider, txConfig, homeDir, ConnectionTypeHTTP)
@@ -171,6 +172,7 @@ func NewEVMWebSocketServer(
 		return nil, err
 	}
 	simulateConfig := &SimulateConfig{GasCap: config.SimulationGasLimit, EVMTimeout: config.SimulationEVMTimeout}
+	sendConfig := &SendConfig{slow: config.Slow, simulationGasThreshold: 1000000, gasWantedVsGasUsedPercentDiff: 0.8}
 	apis := []rpc.API{
 		{
 			Namespace: "echo",
@@ -194,7 +196,7 @@ func NewEVMWebSocketServer(
 		},
 		{
 			Namespace: "eth",
-			Service:   NewSendAPI(tmClient, txConfig, &SendConfig{slow: config.Slow}, k, ctxProvider, homeDir, simulateConfig, ConnectionTypeWS),
+			Service:   NewSendAPI(tmClient, txConfig, sendConfig, k, ctxProvider, homeDir, simulateConfig, ConnectionTypeWS),
 		},
 		{
 			Namespace: "eth",

integration_test/dapp_tests/hardhat.config.js

@@ -20,7 +20,7 @@ module.exports = {
       url: "http://127.0.0.1:8545",
       accounts: {
         mnemonic: process.env.DAPP_TESTS_MNEMONIC,
-        path: "m/44'/118'/0'/0/0",
+        path: "m/44'/118'/0'/0",
         initialIndex: 0,
         count: 1
       },
@@ -29,7 +29,7 @@ module.exports = {
       url: "https://evm-rpc-testnet.sei-apis.com",
       accounts: {
         mnemonic: process.env.DAPP_TESTS_MNEMONIC,
-        path: "m/44'/118'/0'/0/0",
+        path: "m/44'/118'/0'/0",
         initialIndex: 0,
         count: 1
       },
@@ -38,7 +38,7 @@ module.exports = {
       url: "https://evm-rpc-arctic-1.sei-apis.com",
       accounts: {
         mnemonic: process.env.DAPP_TESTS_MNEMONIC,
-        path: "m/44'/118'/0'/0/0",
+        path: "m/44'/118'/0'/0",
         initialIndex: 0,
         count: 1
       },

x/evm/client/cli/tx.go

@@ -436,7 +436,7 @@ func CmdERC20Send() *cobra.Command {
 
 func CmdCallPrecompile() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "call-precompile [precompile name] [method] [args...] --value=<payment> --from=<sender> --gas-fee-cap=<cap> --gas-limt=<limit> --evm-rpc=<url>",
+		Use:   "call-precompile [precompile name] [method] [args...] --value=<payment> --from=<sender> --gas-fee-cap=<cap> --gas-limit=<limit> --evm-rpc=<url>",
 		Short: "call method on precompile",
 		Long:  "",
 		Args:  cobra.MinimumNArgs(2),