add rpc methods, add new rpc input validators and tests, refactor rpc test helper code

Author: ryanio

packages/client/lib/rpc/modules/eth.ts

@@ -1,28 +1,66 @@
+import {
+  Account,
+  Address,
+  BN,
+  bufferToHex,
+  toBuffer,
+  stripHexPrefix,
+  unpadBuffer,
+  setLengthLeft,
+} from 'ethereumjs-util'
+import { Transaction } from '@ethereumjs/tx'
+import { decode } from 'rlp'
 import { Chain } from '../../blockchain'
 import { middleware, validators } from '../validation'
-import { BN, bufferToHex, toBuffer, stripHexPrefix } from 'ethereumjs-util'
 import { EthereumClient } from '../..'
+import { INVALID_PARAMS } from '../error-code'
+import { RpcCallTx } from '../types'
+import type VM from '@ethereumjs/vm'
 
 /**
  * eth_* RPC module
  * @memberof module:rpc/modules
  */
 export class Eth {
   private _chain: Chain
+  private _vm: VM | undefined
   public ethVersion: number
 
   /**
    * Create eth_* RPC module
-   * @param {Node} Node to which the module binds
+   * @param client Client to which the module binds
    */
-  constructor(node: EthereumClient) {
-    const service = node.services.find((s) => s.name === 'eth')
-    this._chain = service!.chain
-    const ethProtocol = service!.protocols.find((p) => p.name === 'eth')
-    this.ethVersion = Math.max.apply(Math, ethProtocol!.versions)
+  constructor(client: EthereumClient) {
+    const service = client.services.find((s) => s.name === 'eth')
+    if (!service) {
+      throw new Error('cannot find eth service')
+    }
+    this._chain = service.chain
+    this._vm = (service.synchronizer as any)?.execution?.vm
+
+    const ethProtocol = service.protocols.find((p) => p.name === 'eth')
+    if (!ethProtocol) {
+      throw new Error('cannot find eth protocol')
+    }
+    this.ethVersion = Math.max(...ethProtocol.versions)
 
     this.blockNumber = middleware(this.blockNumber.bind(this), 0)
 
+    this.call = middleware(this.call.bind(this), 2, [
+      [validators.transaction(['to'])],
+      [validators.blockOption],
+    ])
+
+    this.estimateGas = middleware(this.estimateGas.bind(this), 2, [
+      [validators.transaction(['to'])],
+      [validators.blockOption],
+    ])
+
+    this.getBalance = middleware(this.getBalance.bind(this), 2, [
+      [validators.address],
+      [validators.blockOption],
+    ])
+
     this.getBlockByNumber = middleware(this.getBlockByNumber.bind(this), 2, [
       [validators.hex],
       [validators.bool],
@@ -39,24 +77,174 @@ export class Eth {
       [[validators.hex, validators.blockHash]]
     )
 
+    this.getCode = middleware(this.getCode.bind(this), 2, [
+      [validators.address],
+      [validators.blockOption],
+    ])
+
+    this.getStorageAt = middleware(this.getStorageAt.bind(this), 3, [
+      [validators.address],
+      [validators.hex],
+      [validators.blockOption],
+    ])
+
+    this.getTransactionCount = middleware(this.getTransactionCount.bind(this), 2, [
+      [validators.address],
+      [validators.blockOption],
+    ])
+
     this.protocolVersion = middleware(this.protocolVersion.bind(this), 0, [])
   }
 
   /**
    * Returns number of the most recent block.
-   * @param  {Array<*>} [params] An empty array
-   * @return {Promise}
+   * @param params An empty array
    */
   async blockNumber(_params = []) {
     const latestHeader = await this._chain.getLatestHeader()
     return `0x${latestHeader.number.toString(16)}`
   }
 
   /**
-   * Returns information about a block by block number
-   * @param  {Array<BN|bool>} [params] An array of two parameters: An big integer of a block number and a
-   * boolean determining whether it returns full transaction objects or just the transaction hashes
-   * @return {Promise}
+   * Executes a new message call immediately without creating a transaction on the block chain.
+   * Currently only "latest" block number is supported.
+   * @param params An array of two parameters:
+   *   1. The transaction object
+   *       * from (optional) - The address the transaction is sent from
+   *       * to - The address the transaction is directed to
+   *       * gas (optional) - Integer of the gas provided for the transaction execution
+   *       * gasPrice (optional) - Integer of the gasPrice used for each paid gas
+   *       * value (optional) - Integer of the value sent with this transaction
+   *       * data (optional) - Hash of the method signature and encoded parameters.
+   *   2. integer block number, or the string "latest", "earliest" or "pending"
+   * @returns The return value of the executed contract.
+   */
+  async call(params: [RpcCallTx, string]) {
+    const [transaction, blockOpt] = params
+
+    const latestBlockNumber = await this.blockNumber()
+    if (blockOpt !== 'latest' && blockOpt !== latestBlockNumber) {
+      // todo: this can be resolved with some kind of functionality of stateAt(blockNumber)
+      return {
+        code: INVALID_PARAMS,
+        message: `Currently only block option "latest" supported`,
+      }
+    }
+
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    if (!transaction.gas) {
+      // If no gas limit is specified use the last block gas limit as an upper bound.
+      const latestHeader = await this._chain.getLatestHeader()
+      transaction.gas = latestHeader.gasLimit as any
+    }
+
+    const vm = this._vm.copy()
+    const txData = { ...transaction, gasLimit: transaction.gas }
+    const tx = Transaction.fromTxData(txData, { common: vm._common, freeze: false })
+
+    // set from address
+    const from = transaction.from ? Address.fromString(transaction.from) : Address.zero()
+    tx.getSenderAddress = () => {
+      return from
+    }
+
+    const { execResult } = await vm.runTx({ tx })
+    return bufferToHex(unpadBuffer(execResult.returnValue))
+  }
+
+  /**
+   * Generates and returns an estimate of how much gas is necessary to allow the transaction to complete.
+   * The transaction will not be added to the blockchain.
+   * Note that the estimate may be significantly more than the amount of gas actually used by the transaction, for a variety of reasons including EVM mechanics and node performance.
+   * Currently only "latest" block number is supported.
+   * @param params An array of two parameters:
+   *   1. The transaction object
+   *       * from (optional) - The address the transaction is sent from
+   *       * to - The address the transaction is directed to
+   *       * gas (optional) - Integer of the gas provided for the transaction execution
+   *       * gasPrice (optional) - Integer of the gasPrice used for each paid gas
+   *       * value (optional) - Integer of the value sent with this transaction
+   *       * data (optional) - Hash of the method signature and encoded parameters.
+   *   2. integer block number, or the string "latest", "earliest" or "pending"
+   * @returns The amount of gas used.
+   */
+  async estimateGas(params: [RpcCallTx, string]) {
+    const [transaction, blockOpt] = params
+
+    const latestBlockNumber = await this.blockNumber()
+    if (blockOpt !== 'latest' && blockOpt !== latestBlockNumber) {
+      // todo: this can be resolved with some kind of functionality of stateAt(blockNumber)
+      return {
+        code: INVALID_PARAMS,
+        message: `Currently only block option "latest" supported`,
+      }
+    }
+
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    if (!transaction.gas) {
+      // If no gas limit is specified use the last block gas limit as an upper bound.
+      const latestHeader = await this._chain.getLatestHeader()
+      transaction.gas = latestHeader.gasLimit as any
+    }
+
+    const vm = this._vm.copy()
+    const txData = { ...transaction, gasLimit: transaction.gas }
+    const tx = Transaction.fromTxData(txData, { common: vm._common, freeze: false })
+
+    // set from address
+    const from = transaction.from ? Address.fromString(transaction.from) : Address.zero()
+    tx.getSenderAddress = () => {
+      return from
+    }
+
+    const { gasUsed } = await vm.runTx({
+      tx,
+      skipNonce: true,
+      skipBalance: true,
+      skipBlockGasLimitValidation: true,
+    })
+    return `0x${gasUsed.toString(16)}`
+  }
+
+  /**
+   * Returns the balance of the account at the given address.
+   * Currently only "latest" block number is supported.
+   * @param params An array of two parameters:
+   *   1. address of the account
+   *   2. integer block number, or the string "latest", "earliest" or "pending"
+   */
+  async getBalance(params: [string, string]) {
+    const [addressHex, blockOpt] = params
+
+    const latestBlockNumber = await this.blockNumber()
+    if (blockOpt !== 'latest' && blockOpt !== latestBlockNumber) {
+      // todo: this can be resolved with some kind of functionality of stateAt(blockNumber)
+      return {
+        code: INVALID_PARAMS,
+        message: `Currently only block option "latest" supported`,
+      }
+    }
+
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    const address = Address.fromString(addressHex)
+    const account: Account = await (this._vm.stateManager as any).getAccount(address)
+    return `0x${account.balance.toString(16)}`
+  }
+
+  /**
+   * Returns information about a block by block number.
+   * @param params An array of two parameters:
+   *   1. integer of a block number
+   *   2. boolean determining whether it returns full transaction objects or just the transaction hashes
    */
   async getBlockByNumber(params: [string, boolean]) {
     const [blockNumber, includeTransactions] = params
@@ -70,10 +258,10 @@ export class Eth {
   }
 
   /**
-   * Returns information about a block by hash
-   * @param  {Array<string|bool>} [params] An array of two parameters: A block hash as the first argument and a
-   * boolean determining whether it returns full transaction objects or just the transaction hashes
-   * @return {Promise}
+   * Returns information about a block by hash.
+   * @param params An array of two parameters:
+   *   1. a block hash
+   *   2. boolean to determine returning full transaction objects or just transaction hashes
    */
   async getBlockByHash(params: [string, boolean]) {
     const [blockHash, includeTransactions] = params
@@ -87,9 +275,8 @@ export class Eth {
   }
 
   /**
-   * Returns the transaction count for a block given by the block hash
-   * @param  {Array<string>} [params] An array of one parameter: A block hash
-   * @return {Promise}
+   * Returns the transaction count for a block given by the block hash.
+   * @param params An array of one parameter: A block hash
    */
   async getBlockTransactionCountByHash(params: [string]) {
     const [blockHash] = params
@@ -98,6 +285,92 @@ export class Eth {
     return `0x${json.transactions!.length.toString(16)}`
   }
 
+  /**
+   * Returns code of the account at the given address.
+   * Currently only "latest" block number is supported.
+   * @param params An array of two parameters:
+   *   1. address of the account
+   *   2. integer block number, or the string "latest", "earliest" or "pending"
+   */
+  async getCode(params: [string, string]) {
+    const [addressHex, blockOpt] = params
+
+    const latestBlockNumber = await this.blockNumber()
+    if (blockOpt !== 'latest' && blockOpt !== latestBlockNumber) {
+      // todo: this can be resolved with some kind of functionality of stateAt(blockNumber)
+      return {
+        code: INVALID_PARAMS,
+        message: `Currently only block option "latest" supported`,
+      }
+    }
+
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+    const address = Address.fromString(addressHex)
+    const code = await (this._vm.stateManager as any).getContractCode(address)
+    return bufferToHex(code)
+  }
+
+  /**
+   * Returns the value from a storage position at a given address.
+   * Currently only "latest" block number is supported.
+   * @param  {Array<string>} [params] An array of three parameters:
+   *   1. address of the storage
+   *   2. integer of the position in the storage
+   *   3. integer block number, or the string "latest", "earliest" or "pending"
+   */
+  async getStorageAt(params: [string, string, string]) {
+    const [addressHex, positionHex, blockOpt] = params
+
+    const latestBlockNumber = await this.blockNumber()
+    if (blockOpt !== 'latest' && blockOpt !== latestBlockNumber) {
+      // todo: this can be resolved with some kind of functionality of stateAt(blockNumber)
+      return {
+        code: INVALID_PARAMS,
+        message: `Currently only block option "latest" supported`,
+      }
+    }
+
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    const address = Address.fromString(addressHex)
+    const storageTrie = await (this._vm.stateManager as any)._getStorageTrie(address)
+    const position = setLengthLeft(toBuffer(positionHex), 32)
+    const storage = await storageTrie.get(position)
+    return storage ? bufferToHex(setLengthLeft(decode(storage), 32)) : '0x'
+  }
+
+  /**
+   * Returns the number of transactions sent from an address.
+   * Currently only "latest" block number is supported.
+   * @param params An array of two parameters:
+   *   1. address of the account
+   *   2. integer block number, or the string "latest", "earliest" or "pending"
+   */
+  async getTransactionCount(params: [string, string]) {
+    const [addressHex, blockOpt] = params
+
+    const latestBlockNumber = await this.blockNumber()
+    if (blockOpt !== 'latest' && blockOpt !== latestBlockNumber) {
+      // todo: this can be resolved with some kind of functionality of stateAt(blockNumber)
+      return {
+        code: INVALID_PARAMS,
+        message: `Currently only block option "latest" supported`,
+      }
+    }
+
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    const address = Address.fromString(addressHex)
+    const account: Account = await (this._vm.stateManager as any).getAccount(address)
+    return `0x${account.nonce.toString(16)}`
+  }
+
   /**
    * Returns the current ethereum protocol version as a hex-encoded string
    * @param  {Array<*>} [params] An empty array

packages/client/lib/rpc/types.ts

@@ -0,0 +1,8 @@
+export interface RpcCallTx {
+  from?: string
+  to: string
+  gas?: string
+  gasPrice?: string
+  value?: string
+  data?: string
+}