add getEthResources

eth-providers/src/__tests__/e2e/tx.test.ts

@@ -60,6 +60,54 @@ describe('transaction tests', () => {
     await provider.disconnect();
   });
 
+  describe('test eth gas', () => {
+    it('getEthResources', async () => {
+      const randomWallet = Wallet.createRandom().connect(provider);
+
+      const amount = '1000000000000000000';
+      const resources = await provider.getEthResources({
+        type: 0,
+        from: wallet3.address,
+        to: randomWallet.address,
+        value: BigNumber.from(amount)
+      });
+
+      await wallet3.sendTransaction({
+        type: 0,
+        to: randomWallet.address,
+        value: BigNumber.from(amount),
+        ...resources
+      });
+
+      expect((await randomWallet.getBalance()).toString()).eq(amount);
+    });
+
+    it('getPrice', async () => {
+      const randomWallet = Wallet.createRandom().connect(provider);
+
+      const amount = '1000000000000000000';
+
+      const params = await wallet3.populateTransaction({
+        type: 0,
+        to: randomWallet.address,
+        value: BigNumber.from(amount)
+      });
+
+      const data = provider.validSubstrateResources({
+        gasLimit: params.gasLimit,
+        gasPrice: params.gasPrice
+      });
+
+      console.log({
+        gasLimit: data.gasLimit.toString(),
+        storageLimit: data.storageLimit.toString(),
+        validUntil: data.validUntil.toString()
+      });
+
+      // expect((await randomWallet.getBalance()).toString()).eq(amount);
+    });
+  });
+
   describe('test the error tx', () => {
     it('InvalidDecimals', async () => {
       await expect(

eth-providers/src/base-provider.ts

@@ -55,7 +55,8 @@ import {
   findEvmEvent,
   getIndexerMetadata,
   filterLog,
-  toHex
+  toHex,
+  calcEthereumTransactionParams
 } from './utils';
 import { TransactionReceipt as TransactionReceiptGQL } from './utils/gqlTypes';
 import { UnfinalizedBlockCache } from './utils/unfinalizedBlockCache';
@@ -650,6 +651,79 @@ export abstract class BaseProvider extends AbstractProvider {
     return resources.gas.add(storageGasLimit);
   };
 
+  /**
+   * Get the gas for eth transactions
+   * @returns The gas used by eth transaction
+   */
+  getEthResources = async (
+    transaction: Deferrable<TransactionRequest>,
+    {
+      gasLimit,
+      storageLimit,
+      validUntil
+    }: {
+      gasLimit?: BigNumberish;
+      storageLimit?: BigNumberish;
+      validUntil?: BigNumberish;
+    } = {}
+  ): Promise<{
+    gasPrice: BigNumber;
+    gasLimit: BigNumber;
+  }> => {
+    if (!gasLimit || !storageLimit) {
+      const { gas, storage } = await this.estimateResources(transaction);
+      gasLimit = gasLimit ?? gas;
+      storageLimit = storageLimit ?? storage;
+    }
+
+    if (!validUntil) {
+      const blockNumber = await this.getBlockNumber();
+      // Expires after 100 blocks by default
+      validUntil = blockNumber + 100;
+    }
+
+    const storageByteDeposit = (this.api.consts.evm.storageDepositPerByte as UInt).toBigInt();
+    const txFeePerGas = (this.api.consts.evm.txFeePerGas as UInt).toBigInt();
+
+    const { txGasLimit, txGasPrice } = calcEthereumTransactionParams({
+      gasLimit,
+      storageLimit,
+      validUntil,
+      storageByteDeposit,
+      txFeePerGas
+    });
+
+    return {
+      gasLimit: txGasLimit,
+      gasPrice: txGasPrice
+    };
+  };
+
+  /**
+   * Validate substrate transaction parameters
+   */
+  validSubstrateResources = ({
+    gasLimit,
+    gasPrice
+  }: {
+    gasLimit: BigNumberish;
+    gasPrice: BigNumberish;
+  }): {
+    gasLimit: BigNumber;
+    storageLimit: BigNumber;
+    validUntil: BigNumber;
+  } => {
+    const storageByteDeposit = (this.api.consts.evm.storageDepositPerByte as UInt).toBigInt();
+    const txFeePerGas = (this.api.consts.evm.txFeePerGas as UInt).toBigInt();
+
+    return calcSubstrateTransactionParams({
+      txGasPrice: gasPrice,
+      txGasLimit: gasLimit,
+      storageByteDeposit,
+      txFeePerGas
+    });
+  };
+
   /**
    * Estimate resources for a transaction.
    * @param transaction The transaction to estimate the resources of
@@ -664,10 +738,6 @@ export abstract class BaseProvider extends AbstractProvider {
   }> => {
     const ethTx = await this._getTransactionRequest(transaction);
 
-    if (!ethTx.from) {
-      return logger.throwArgumentError('missing from address', 'transaction', ethTx);
-    }
-
     const { from, to, data, value } = ethTx;
 
     const extrinsic = !to