EVM Hardhat gas test (#1254)

* balances around 1usei - test currently failing

* remove unused imports

* cleanup

* cleanup

* cleanup

* eip1559 gas seems to not work

* both eip1559 tests work

* added test for sending many eip1559 tests, base fee should be positive, table tests for eip1559

* cleanup prints

* small fix

* remove it.only

* fix test

* remove base fee test

* add back some prints

* move min gas price from 1 wei to 1 gwei

* fix gas unit test

Author: jewei1997

contracts/hardhat.config.js

@@ -21,11 +21,11 @@ module.exports = {
       address: ["0xF87A299e6bC7bEba58dbBe5a5Aa21d49bCD16D52"],
       accounts: ["0x57acb95d82739866a5c29e40b0aa2590742ae50425b7dd5b5d279a986370189e"], // Replace with your private key
     },
-    // sei: {
-    //   url: "https://evm-warroom-test.seinetwork.io:18545", // Replace with your JSON-RPC URL
-    //   address: ["0x07dc55085b721947d5c1645a07929eac9f1cc750"],
-    //   accounts: [process.env.TEST_PRIVATE_KEY], // Replace with your private key
-    // },
+    sei: {
+      url: "https://evm-devnet.seinetwork.io", // Replace with your JSON-RPC URL
+      address: ["0x07dc55085b721947d5c1645a07929eac9f1cc750"],
+      accounts: ["0x57acb95d82739866a5c29e40b0aa2590742ae50425b7dd5b5d279a986370189e"], // Replace with your private key
+    },
     seilocal: {
       url: "http://127.0.0.1:8545",
       address: ["0xF87A299e6bC7bEba58dbBe5a5Aa21d49bCD16D52", "0x70997970C51812dc3A010C7d01b50e0d17dc79C8"],

contracts/package-lock.json

@@ -1,6 +1,8 @@
 const { expect } = require("chai");
 const {isBigNumber} = require("hardhat/common");
+const { ethers } = require("hardhat");
 const {uniq, shuffle} = require("lodash");
+
 function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -14,6 +16,31 @@ function debug(msg) {
   //console.log(msg)
 }
 
+async function sendTransactionAndCheckGas(sender, recipient, amount) {
+  // Get the balance of the sender before the transaction
+  const balanceBefore = await ethers.provider.getBalance(sender.address);
+
+  // Send the transaction
+  const tx = await sender.sendTransaction({
+    to: recipient.address,
+    value: amount
+  });
+
+  // Wait for the transaction to be mined and get the receipt
+  const receipt = await tx.wait();
+
+  // Get the balance of the sender after the transaction
+  const balanceAfter = await ethers.provider.getBalance(sender.address);
+
+  // Calculate the total cost of the transaction (amount + gas fees)
+  const gasPrice = receipt.gasPrice;
+  const gasUsed = receipt.gasUsed;
+  const totalCost = gasPrice * gasUsed + BigInt(amount);
+
+  // Check that the sender's balance decreased by the total cost
+  return balanceBefore - balanceAfter === totalCost
+}
+
 function generateWallet() {
   const wallet = ethers.Wallet.createRandom();
   return wallet.connect(ethers.provider);
@@ -103,7 +130,7 @@ describe("EVM Test", function () {
         return
       }
       let signers = await ethers.getSigners();
-      owner = signers[0]
+      owner = signers[0];
       debug(`OWNER = ${owner.address}`)
 
       const TestToken = await ethers.getContractFactory("TestToken")
@@ -311,8 +338,139 @@ describe("EVM Test", function () {
       });
     })
 
-    describe("JSON-RPC", function() {
+    describe("Gas tests", function() {
+      it("Should deduct correct amount of gas on transfer", async function () {
+        const balanceBefore = await ethers.provider.getBalance(owner);
 
+        const feeData = await ethers.provider.getFeeData();
+        const gasPrice = Number(feeData.gasPrice);
+
+        const zero = ethers.parseUnits('0', 'ether')
+        const txResponse = await owner.sendTransaction({
+          to: owner.address,
+          gasPrice: gasPrice,
+          value: zero,
+          type: 1,
+        });
+        await txResponse.wait();
+
+        const balanceAfter = await ethers.provider.getBalance(owner);
+
+        const diff = balanceBefore - balanceAfter;
+        expect(diff).to.equal(21000 * gasPrice);
+
+        const success = await sendTransactionAndCheckGas(owner, owner, 0)
+        expect(success).to.be.true
+      });
+
+      it("Should fail if insufficient gas is provided", async function () {
+        const feeData = await ethers.provider.getFeeData();
+        const gasPrice = Number(feeData.gasPrice);
+        const zero = ethers.parseUnits('0', 'ether')
+        expect(owner.sendTransaction({
+          to: owner.address,
+          gasPrice: gasPrice - 1,
+          value: zero,
+          type: 1,
+        })).to.be.reverted;
+      });
+
+      it("Should deduct correct amount even if higher gas price is used", async function () {
+        const balanceBefore = await ethers.provider.getBalance(owner);
+
+        const feeData = await ethers.provider.getFeeData();
+        const gasPrice = Number(feeData.gasPrice);
+        const higherGasPrice = Number(gasPrice + 9)
+        console.log(`gasPrice = ${gasPrice}`)
+
+        const zero = ethers.parseUnits('0', 'ether')
+        const txResponse = await owner.sendTransaction({
+          to: owner.address,
+          value: zero,
+          gasPrice: higherGasPrice,
+          type: 1,
+        });
+        const receipt = await txResponse.wait();
+
+        const balanceAfter = await ethers.provider.getBalance(owner);
+
+        const diff = balanceBefore - balanceAfter;
+        expect(diff).to.equal(21000 * higherGasPrice);
+
+        const success = await sendTransactionAndCheckGas(owner, owner, 0)
+        expect(success).to.be.true
+      });
+
+      describe("EIP-1559", async function() {
+        const zero = ethers.parseUnits('0', 'ether')
+        const twoGwei = ethers.parseUnits("2", "gwei");
+        const oneGwei = ethers.parseUnits("1", "gwei");
+
+        const testCases = [
+          ["No truncation from max priority fee", oneGwei, oneGwei],
+          ["With truncation from max priority fee", oneGwei, twoGwei],
+          ["With complete truncation from max priority fee", zero, twoGwei]
+        ];
+
+        it("Should be able to send many EIP-1559 txs", async function () {
+          const oneGwei = ethers.parseUnits("1", "gwei");
+          const zero = ethers.parseUnits('0', 'ether')
+          for (let i = 0; i < 10; i++) {
+            const txResponse = await owner.sendTransaction({
+              to: owner.address,
+              value: zero,
+              maxPriorityFeePerGas: oneGwei,
+              maxFeePerGas: oneGwei,
+              type: 2
+            });
+            await txResponse.wait();
+          }
+        });
+
+        describe("Differing maxPriorityFeePerGas and maxFeePerGas", async function() {
+          testCases.forEach(async ([name, maxPriorityFeePerGas, maxFeePerGas]) => {
+            it(`EIP-1559 test: ${name}`, async function() {
+              console.log(`maxPriorityFeePerGas = ${maxPriorityFeePerGas}`)
+              console.log(`maxFeePerGas = ${maxFeePerGas}`)
+              const balanceBefore = await ethers.provider.getBalance(owner);
+              const feeData = await ethers.provider.getFeeData();
+              const gasPrice = Number(feeData.gasPrice); 
+
+              console.log(`gasPrice = ${gasPrice}`)
+
+              const zero = ethers.parseUnits('0', 'ether')
+              const txResponse = await owner.sendTransaction({
+                to: owner.address,
+                value: zero,
+                maxPriorityFeePerGas: maxPriorityFeePerGas,
+                maxFeePerGas: maxFeePerGas,
+                type: 2
+              });
+              const receipt = await txResponse.wait();
+
+              expect(receipt).to.not.be.null;
+              expect(receipt.status).to.equal(1);
+
+              const balanceAfter = await ethers.provider.getBalance(owner);
+
+              const tip = Math.min(
+                Number(maxFeePerGas) - gasPrice,
+                Number(maxPriorityFeePerGas)
+              );
+              console.log(`tip = ${tip}`)
+              const effectiveGasPrice = tip + gasPrice;
+              console.log(`effectiveGasPrice = ${effectiveGasPrice}`)
+            
+              const diff = balanceBefore - balanceAfter;
+              console.log(`diff = ${diff}`)
+              expect(diff).to.equal(21000 * effectiveGasPrice);
+            });
+          });
+        });
+      });
+    });
+
+    describe("JSON-RPC", function() {
       it("Should retrieve a transaction by its hash", async function () {
         // Send a transaction to get its hash
         const txResponse = await evmTester.setBoolVar(true);
@@ -481,11 +639,6 @@ describe("EVM Test", function () {
         const isContract = code !== '0x';
         expect(isContract).to.be.true;
       });
-
     });
-
-
-
   });
-
 });

contracts/test/EVMCompatabilityTester.js

@@ -82,10 +82,10 @@ func verifyBlockResult(t *testing.T, resObj map[string]interface{}) {
 	require.Equal(t, "0x0", tx["type"])
 	require.Equal(t, []interface{}{}, tx["accessList"])
 	require.Equal(t, "0xae3f3", tx["chainId"])
-	require.Equal(t, "0x1b", tx["v"])
+	require.Equal(t, "0x0", tx["v"])
 	require.Equal(t, "0xa1ac0e5b8202742e54ae7af350ed855313cc4f9861c2d75a0e541b4aff7c981e", tx["r"])
 	require.Equal(t, "0x288b16881aed9640cd360403b9db1ce3961b29af0b00158311856d1446670996", tx["s"])
-	require.Equal(t, "0x1", tx["yParity"])
+	require.Equal(t, "0x0", tx["yParity"])
 	require.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000002", resObj["transactionsRoot"])
 	require.Equal(t, []interface{}{}, resObj["uncles"])
 	require.Equal(t, "0x0", resObj["baseFeePerGas"])

evmrpc/block_test.go

@@ -125,10 +125,10 @@ func TestGetTransaction(t *testing.T) {
 		require.Equal(t, "0x0", resObj["type"].(string))
 		require.Equal(t, 0, len(resObj["accessList"].([]interface{})))
 		require.Equal(t, "0xae3f3", resObj["chainId"].(string))
-		require.Equal(t, "0x1b", resObj["v"].(string))
+		require.Equal(t, "0x0", resObj["v"].(string))
 		require.Equal(t, "0xa1ac0e5b8202742e54ae7af350ed855313cc4f9861c2d75a0e541b4aff7c981e", resObj["r"].(string))
 		require.Equal(t, "0x288b16881aed9640cd360403b9db1ce3961b29af0b00158311856d1446670996", resObj["s"].(string))
-		require.Equal(t, "0x1", resObj["yParity"].(string))
+		require.Equal(t, "0x0", resObj["yParity"].(string))
 	}
 
 	for _, body := range []string{bodyByBlockNumberAndIndex, bodyByBlockHashAndIndex, bodyByHash} {

evmrpc/tx_test.go

@@ -69,7 +69,6 @@ func hydrateTransaction(
 	idx := hexutil.Uint64(receipt.TransactionIndex)
 	al := tx.AccessList()
 	v, r, s := tx.RawSignatureValues()
-	v = ante.AdjustV(v, tx.Type(), tx.ChainId())
 	var yparity *hexutil.Uint64
 	if tx.Type() != ethtypes.LegacyTxType {
 		yp := hexutil.Uint64(v.Sign())

evmrpc/utils.go

@@ -68,7 +68,7 @@ func TestInstantiate(t *testing.T) {
 	require.Equal(t, 2, len(outputs))
 	require.Equal(t, "sei14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sh9m79m", outputs[0].(string))
 	require.Empty(t, outputs[1].([]byte))
-	require.Equal(t, uint64(899594), g)
+	require.Equal(t, uint64(899567), g)
 
 	// non-existent code ID
 	args, _ = instantiateMethod.Inputs.Pack(
@@ -128,7 +128,7 @@ func TestExecute(t *testing.T) {
 	require.Nil(t, err)
 	require.Equal(t, 1, len(outputs))
 	require.Equal(t, fmt.Sprintf("received test msg from %s with 1000usei", mockAddr.String()), string(outputs[0].([]byte)))
-	require.Equal(t, uint64(912476), g)
+	require.Equal(t, uint64(912449), g)
 
 	// allowed delegatecall
 	fmt.Println(testApp.BankKeeper.GetBalance(ctx, mockAddr, "usei"))
@@ -189,7 +189,7 @@ func TestQuery(t *testing.T) {
 	require.Nil(t, err)
 	require.Equal(t, 1, len(outputs))
 	require.Equal(t, "{\"message\":\"query test\"}", string(outputs[0].([]byte)))
-	require.Equal(t, uint64(927062), g)
+	require.Equal(t, uint64(927035), g)
 
 	// bad contract address
 	args, _ = queryMethod.Inputs.Pack(mockAddr.String(), []byte("{\"info\":{}}"))

precompiles/wasmd/wasmd_test.go

@@ -32,7 +32,7 @@ var DefaultPriorityNormalizer = sdk.NewDec(1)
 // burnt rather than go to validators (similar to base fee on
 // Ethereum).
 var DefaultBaseFeePerGas = sdk.NewDec(0)
-var DefaultMinFeePerGas = sdk.NewDec(1)
+var DefaultMinFeePerGas = sdk.NewDec(1000000000)
 var DefaultChainID = sdk.NewInt(713715)
 var DefaultWhitelistedCodeHashesBankSend = generateDefaultWhitelistedCodeHashesBankSend()
 var DefaultWhitelistedCwCodeHashesForDelegateCall = [][]byte{}