copy the vm first in case new blocks are executed during the call

Author: ryanio

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

@@ -117,27 +117,31 @@ export class Eth {
   async call(params: [RpcCallTx, string]) {
     const [transaction, blockOpt] = params
 
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    // use a copy of the vm in case new blocks are executed,
+    // and to not make any underlying changes during the call
+    const vm = this._vm.copy()
+
     if (blockOpt !== 'latest') {
-      const latest = await this.blockNumber()
-      if (blockOpt !== latest) {
+      const latest = await vm.blockchain.getLatestHeader()
+      const number = latest.number.toString(16)
+      if (blockOpt !== `0x${number}`) {
         return {
           code: INVALID_PARAMS,
           message: `Currently only "latest" block 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 latest = await vm.blockchain.getLatestHeader()
+      transaction.gas = latest.gasLimit as any
     }
 
-    const vm = this._vm.copy()
     const txData = { ...transaction, gasLimit: transaction.gas }
     const tx = Transaction.fromTxData(txData, { common: vm._common, freeze: false })
 
@@ -171,27 +175,30 @@ export class Eth {
   async estimateGas(params: [RpcCallTx, string]) {
     const [transaction, blockOpt] = params
 
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    // use a copy of the vm in case new blocks are executed
+    const vm = this._vm.copy()
+
     if (blockOpt !== 'latest') {
-      const latest = await this.blockNumber()
-      if (blockOpt !== latest) {
+      const latest = await vm.blockchain.getLatestHeader()
+      const number = latest.number.toString(16)
+      if (blockOpt !== `0x${number}`) {
         return {
           code: INVALID_PARAMS,
           message: `Currently only "latest" block 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 latest = await this._chain.getLatestHeader()
+      transaction.gas = latest.gasLimit as any
     }
 
-    const vm = this._vm.copy()
     const txData = { ...transaction, gasLimit: transaction.gas }
     const tx = Transaction.fromTxData(txData, { common: vm._common, freeze: false })
 
@@ -220,22 +227,26 @@ export class Eth {
   async getBalance(params: [string, string]) {
     const [addressHex, blockOpt] = params
 
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    // use a copy of the vm in case new blocks are sync'd
+    const vm = this._vm.copy()
+
     if (blockOpt !== 'latest') {
-      const latest = await this.blockNumber()
-      if (blockOpt !== latest) {
+      const latest = await vm.blockchain.getLatestHeader()
+      const number = latest.number.toString(16)
+      if (blockOpt !== `0x${number}`) {
         return {
           code: INVALID_PARAMS,
           message: `Currently only "latest" block 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)
+    const account: Account = await vm.stateManager.getAccount(address)
     return `0x${account.balance.toString(16)}`
   }
 
@@ -294,21 +305,26 @@ export class Eth {
   async getCode(params: [string, string]) {
     const [addressHex, blockOpt] = params
 
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    // use a copy of the vm in case new blocks are sync'd
+    const vm = this._vm.copy()
+
     if (blockOpt !== 'latest') {
-      const latest = await this.blockNumber()
-      if (blockOpt !== latest) {
+      const latest = await vm.blockchain.getLatestHeader()
+      const number = latest.number.toString(16)
+      if (blockOpt !== `0x${number}`) {
         return {
           code: INVALID_PARAMS,
           message: `Currently only "latest" block supported`,
         }
       }
     }
 
-    if (!this._vm) {
-      throw new Error('missing vm')
-    }
     const address = Address.fromString(addressHex)
-    const code = await (this._vm.stateManager as any).getContractCode(address)
+    const code = await vm.stateManager.getContractCode(address)
     return bufferToHex(code)
   }
 
@@ -323,22 +339,26 @@ export class Eth {
   async getStorageAt(params: [string, string, string]) {
     const [addressHex, positionHex, blockOpt] = params
 
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    // use a copy of the vm in case new blocks are executed
+    const vm = this._vm.copy()
+
     if (blockOpt !== 'latest') {
-      const latest = await this.blockNumber()
-      if (blockOpt !== latest) {
+      const latest = await vm.blockchain.getLatestHeader()
+      const number = latest.number.toString(16)
+      if (blockOpt !== `0x${number}`) {
         return {
           code: INVALID_PARAMS,
           message: `Currently only "latest" block 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 storageTrie = await (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'
@@ -354,22 +374,26 @@ export class Eth {
   async getTransactionCount(params: [string, string]) {
     const [addressHex, blockOpt] = params
 
+    if (!this._vm) {
+      throw new Error('missing vm')
+    }
+
+    // use a copy of the vm in case new blocks are executed
+    const vm = this._vm.copy()
+
     if (blockOpt !== 'latest') {
-      const latest = await this.blockNumber()
-      if (blockOpt !== latest) {
+      const latest = await vm.blockchain.getLatestHeader()
+      const number = latest.number.toString(16)
+      if (blockOpt !== `0x${number}`) {
         return {
           code: INVALID_PARAMS,
           message: `Currently only "latest" block 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)
+    const account: Account = await vm.stateManager.getAccount(address)
     return `0x${account.nonce.toString(16)}`
   }
 

packages/client/test/rpc/eth/call.spec.ts

@@ -1,5 +1,5 @@
 import tape from 'tape'
-import { Address, BN, bufferToHex, unpadBuffer } from 'ethereumjs-util'
+import { Address, BN, bufferToHex } from 'ethereumjs-util'
 import Blockchain from '@ethereumjs/blockchain'
 import { Transaction } from '@ethereumjs/tx'
 import { FullSynchronizer } from '../../../lib/sync'