Implement gasLimit Precheck

packages/relay/src/lib/constants.ts

@@ -45,5 +45,12 @@ export default {
  TYPE_ACCOUNT: 'account',
 
  FEE_HISTORY_MAX_RESULTS: Number(process.env.FEE_HISTORY_MAX_RESULTS || 10),
- ORDER
+ ORDER,
+
+ BLOCK_GAS_LIMIT: 15_000_000,
+ ISTANBUL_TX_DATA_NON_ZERO_COST: 16,
+ TX_BASE_COST: 21_000,
+ TX_DEFAULT_GAS: 400_000,
+ TX_CREATE_EXTRA: 32_000,
+ TX_DATA_ZERO_COST: 4,
 };

packages/relay/src/lib/errors.ts

@@ -71,6 +71,16 @@ export const predefined = {
  code: -32006,
  message: 'Incorrect nonce'
  }),
+ 'GAS_LIMIT_TOO_HIGH': new JsonRpcError({
+ name: 'gasLimit too high',
+ code: -32005,
+ message: 'Transaction gas limit exceeds block gas limit'
+ }),
+ 'GAS_LIMIT_TOO_LOW': new JsonRpcError({
+ name: 'gasLimit too low',
+ code: -32003,
+ message: 'Intrinsic gas exceeds gas limit'
+ }),
  'REQUEST_BEYOND_HEAD_BLOCK': (requested: number, latest: number) => new JsonRpcError({
  name: 'Incorrect block',
  code: -32000,
@@ -91,4 +101,4 @@ export const predefined = {
  code: -32000,
  message: 'Insufficient funds for transfer'
  }),
-};
+};

packages/relay/src/lib/eth.ts

@@ -50,8 +50,8 @@ export class EthImpl implements Eth {
  static emptyArrayHex = '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347';
  static zeroAddressHex = '0x0000000000000000000000000000000000000000';
  static emptyBloom = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
- static defaultGas = EthImpl.numberTo0x(400_000);
- static gasTxBaseCost = EthImpl.numberTo0x(21_000);
+ static defaultGas = EthImpl.numberTo0x(constants.TX_DEFAULT_GAS);
+ static gasTxBaseCost = EthImpl.numberTo0x(constants.TX_BASE_COST);
  static ethTxType = 'EthereumTransaction';
  static ethEmptyTrie = '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421';
  static defaultGasUsedRatio = EthImpl.numberTo0x(0.5);
@@ -629,11 +629,14 @@ export class EthImpl implements Eth {
  */
  async sendRawTransaction(transaction: string): Promise<string | JsonRpcError> {
  this.logger.trace('sendRawTransaction(transaction=%s)', transaction);
- await this.precheck.nonce(transaction);
 
- const chainIdPrecheckRes = this.precheck.chainId(transaction);
- if (!chainIdPrecheckRes.passes) {
- return chainIdPrecheckRes.error;
+ try {
+ await this.precheck.gasLimit(transaction);
+ await this.precheck.nonce(transaction);
+ this.precheck.chainId(transaction);
+ }
+ catch(e: any) {
+ return e;
  }
 
  const gasPrice = await this.getFeeWeibars(EthImpl.ethSendRawTransaction);

packages/relay/src/lib/precheck.ts

@@ -21,8 +21,9 @@
 import * as ethers from 'ethers';
 import { predefined } from './errors';
 import { MirrorNodeClient, SDKClient } from './clients';
-import {EthImpl} from "./eth";
-import {Logger} from "pino";
+import { EthImpl } from "./eth";
+import { Logger } from "pino";
+import constants from './constants';
 
 export class Precheck {
  private mirrorNodeClient: MirrorNodeClient;
@@ -65,18 +66,15 @@ export class Precheck {
  }
  }
 
+
  chainId(transaction: string) {
  const tx = ethers.utils.parseTransaction(transaction);
  const txChainId = EthImpl.prepend0x(Number(tx.chainId).toString(16));
  const passes = txChainId === this.chain;
  if (!passes) {
  this.logger.trace('Failed chainId precheck for sendRawTransaction(transaction=%s, chainId=%s)', transaction, txChainId);
+ throw predefined.UNSUPPORTED_CHAIN_ID(txChainId, this.chain);
  }
-
- return {
- passes,
- error: predefined.UNSUPPORTED_CHAIN_ID(txChainId, this.chain)
- };
  }
 
  gasPrice(transaction: string, gasPrice: number) {
@@ -116,11 +114,55 @@ export class Precheck {
  }
  } catch (error: any) {
  this.logger.trace('Error on balance precheck for sendRawTransaction(transaction=%s, totalValue=%s, error=%s)', transaction, txTotalValue, error.message);
- 
+
  result.passes = false;
  result.error = predefined.INTERNAL_ERROR;
  }
 
  return result;
  }
+
+ /**
+ * @param transaction
+ */
+ async gasLimit(transaction: string) {
+ const tx = ethers.utils.parseTransaction(transaction);
+ const gasLimit = tx.gasLimit.toNumber();
+ const failBaseLog = 'Failed gasLimit precheck for sendRawTransaction(transaction=%s).';
+
+ const intrinsicGasCost = Precheck.transactionIntrinsicGasCost(tx.data, tx.to);
+
+
+ if (gasLimit > constants.BLOCK_GAS_LIMIT) {
+ this.logger.trace(`${failBaseLog} Gas Limit was too high: %s, block gas limit: %s`, transaction, gasLimit, constants.BLOCK_GAS_LIMIT);
+ throw predefined.GAS_LIMIT_TOO_HIGH;
+ } else if (gasLimit < intrinsicGasCost) {
+ this.logger.trace(`${failBaseLog} Gas Limit was too low: %s, intrinsic gas cost: %s`, transaction, gasLimit, intrinsicGasCost);
+ throw predefined.GAS_LIMIT_TOO_LOW;
+ }
+ }
+
+ /**
+ * Calculates the intrinsic gas cost based on the number of empty bytes and whether the transaction is CONTRACT_CREATE
+ * @param data
+ * @param to
+ * @private
+ */
+ private static transactionIntrinsicGasCost(data: string, to: string | undefined) {
+ const isCreate = (to == undefined) || (to.length == 0);
+
+ let zeros = 0;
+
+ const dataBytes = Buffer.from(data, "hex");
+
+ for (const c of dataBytes) {
+ if (c == 0) {
+ zeros++;
+ }
+ }
+
+ const nonZeros = data.replace('0x', '').length - zeros;
+ const cost = constants.TX_BASE_COST + constants.TX_DATA_ZERO_COST * zeros + constants.ISTANBUL_TX_DATA_NON_ZERO_COST * nonZeros;
+ return isCreate ? cost + constants.TX_CREATE_EXTRA : cost;
+ }
 }

packages/relay/tests/helpers.ts

@@ -19,6 +19,10 @@
  */
 
 import {expect} from "chai";
+import {ethers} from 'ethers';
+
+// Randomly generated key
+const defaultPrivateKey = '8841e004c6f47af679c91d9282adc62aeb9fabd19cdff6a9da5a358d0613c30a';
 
 const expectUnsupportedMethod = (result) => {
  expect(result).to.have.property('code');
@@ -29,6 +33,15 @@ const expectUnsupportedMethod = (result) => {
  expect(result.message).to.be.equal('Unsupported JSON-RPC method');
 };
 
+const expectedError = () => {
+ expect(true).to.eq(false);
+};
+
+const signTransaction = async (transaction, key = defaultPrivateKey) => {
+ const wallet = new ethers.Wallet(key);
+ return wallet.signTransaction(transaction);
+};
+
 const mockData = {
  accountEvmAddress: '0x00000000000000000000000000000000000003f6',
  account: {
@@ -80,4 +93,4 @@ const mockData = {
  }
 };
 
-export {expectUnsupportedMethod, mockData};
+export {expectUnsupportedMethod, expectedError, signTransaction, mockData};

packages/relay/tests/lib/precheck.spec.ts

@@ -24,18 +24,22 @@ const registry = new Registry();
 
 import sinon from 'sinon';
 import pino from 'pino';
-import {Precheck} from "../../src/lib/precheck";
-import {MirrorNodeClient, SDKClient} from "../../src/lib/clients";
+import { Precheck } from "../../src/lib/precheck";
+import { expectedError, signTransaction } from "../helpers";
+import { MirrorNodeClient, SDKClient } from "../../src/lib/clients";
 import axios from "axios";
 import MockAdapter from "axios-mock-adapter";
+import { ethers } from "ethers";
 import constants from '../../src/lib/constants';
 const logger = pino();
 
 describe('Precheck', async function() {
 
  const txWithMatchingChainId = '0x02f87482012a0485a7a358200085a7a3582000832dc6c09400000000000000000000000000000000000003f78502540be40080c001a006f4cd8e6f84b76a05a5c1542a08682c928108ef7163d9c1bf1f3b636b1cd1fba032097cbf2dda17a2dcc40f62c97964d9d930cdce2e8a9df9a8ba023cda28e4ad';
  const txWithNonMatchingChainId = '0xf86a0385a7a3582000832dc6c09400000000000000000000000000000000000003f78502540be400801ca06750e92db52fa708e27f94f27e0cfb7f5800f9b657180bb2e94c1520cfb1fb6da01bec6045068b6db38b55017bb8b50166699384bc1791fd8331febab0cf629a2a';
+ const oneTinyBar = ethers.utils.parseUnits('1', 10);
  const defaultGasPrice = 720_000_000_000;
+ const defaultChainId = Number('0x12a');
 
  let precheck: Precheck;
  let mock: MockAdapter;
@@ -61,19 +65,119 @@ describe('Precheck', async function() {
  });
 
  describe('chainId', async function() {
- it('should return true for matching chainId', async function() {
- const result = precheck.chainId(txWithMatchingChainId);
+ it('should pass for matching chainId', async function() {
+ try {
+ precheck.chainId(txWithMatchingChainId);
+ }
+ catch(e) {
+ expect(e).to.not.exist;
+ }
+ });
+
+ it('should not pass for non-matching chainId', async function() {
+ try {
+ precheck.chainId(txWithNonMatchingChainId);
+ expectedError();
+ }
+ catch(e: any) {
+ expect(e).to.exist;
+ expect(e.code).to.eq(-32000);
+ expect(e.message).to.eq('ChainId (0x0) not supported. The correct chainId is 0x12a');
+ }
+ });
+ });
+
+ describe('gas price', async function() {
+ it('should return true for gas price gt to required gas price', async function() {
+ const result = precheck.gasPrice(txWithMatchingChainId, 10);
  expect(result).to.exist;
+ expect(result.error).to.exist;
  expect(result.passes).to.eq(true);
  });
 
- it('should return false for non-matching chainId', async function() {
- const result = precheck.chainId(txWithNonMatchingChainId);
+ it('should return true for gas price equal to required gas price', async function() {
+ const result = precheck.gasPrice(txWithMatchingChainId, defaultGasPrice);
  expect(result).to.exist;
+ expect(result.error).to.exist;
+ expect(result.passes).to.eq(true);
+ });
+
+ it('should not pass for non-matching chainId', async function() {
+ try {
+ precheck.chainId(txWithNonMatchingChainId);
+ expectedError();
+ }
+ catch(e: any) {
+ expect(e).to.exist;
+ expect(e.code).to.eq(-32000);
+ expect(e.message).to.eq('ChainId (0x0) not supported. The correct chainId is 0x12a');
+ }
+ });
+
+ it('should return false for gas price not enough', async function() {
+ const minGasPrice = 1000 * constants.TINYBAR_TO_WEIBAR_COEF;
+ const result = precheck.gasPrice(txWithMatchingChainId, minGasPrice);
+ expect(result).to.exist;
+ expect(result.error).to.exist;
  expect(result.passes).to.eq(false);
  });
  });
 
+ describe('gasLimit', async function() {
+ const defaultTx = {
+ value: oneTinyBar,
+ gasPrice: defaultGasPrice,
+ chainId: defaultChainId
+ };
+
+ function testFailingGasLimitPrecheck(gasLimits, errorCode, errorMessage) {
+ for (const gasLimit of gasLimits) {
+ it(`should fail for gasLimit: ${gasLimit}`, async function () {
+ const tx = {
+ ...defaultTx,
+ gasLimit: gasLimit
+ };
+ const signed = await signTransaction(tx);
+
+ try {
+ await precheck.gasLimit(signed);
+ expectedError();
+ } catch (e: any) {
+ expect(e).to.exist;
+ expect(e.code).to.eq(errorCode);
+ expect(e.message).to.eq(errorMessage);
+ }
+ });
+ }
+ }
+
+ function testPassingGasLimitPrecheck(gasLimits) {
+ for (const gasLimit of gasLimits) {
+ it(`should pass for gasLimit: ${gasLimit}`, async function () {
+ const tx = {
+ ...defaultTx,
+ gasLimit: gasLimit
+ };
+ const signed = await signTransaction(tx);
+
+ try {
+ await precheck.gasLimit(signed);
+ } catch (e: any) {
+ expect(e).to.not.exist;
+ }
+ });
+ }
+ }
+
+ const validGasLimits = [60000, 100000, 500000, 1000000, 5000000, 10000000];
+ const lowGasLimits = [1, 10, 100, 1000, 10000, 30000, 50000];
+ const highGasLimits = [20000000, 100000000, 999999999999];
+
+ testPassingGasLimitPrecheck(validGasLimits);
+ testFailingGasLimitPrecheck(lowGasLimits, -32003, 'Intrinsic gas exceeds gas limit');
+ testFailingGasLimitPrecheck(highGasLimits, -32005, 'Transaction gas limit exceeds block gas limit');
+ });
+
  describe('gas price', async function() {
  it('should return true for gas price gt to required gas price', async function() {
  const result = precheck.gasPrice(txWithMatchingChainId, 10);
@@ -96,5 +200,5 @@ describe('Precheck', async function() {
  expect(result.error).to.exist;
  expect(result.passes).to.eq(false);
  });
- })
+ });
 });