EVM refactor (old)

packages/client/lib/execution/vmexecution.ts

@@ -75,7 +75,7 @@ export class VMExecution extends Execution {
     this.hardfork = this.config.execCommon.hardfork()
     this.config.logger.info(`Initializing VM execution hardfork=${this.hardfork}`)
     if (number === BigInt(0)) {
-      await this.vm.vmState.generateCanonicalGenesis()
+      await this.vm.eei.state.generateCanonicalGenesis()
     }
   }
 

packages/client/lib/miner/miner.ts

@@ -209,7 +209,7 @@ export class Miner {
 
     // Set the state root to ensure the resulting state
     // is based on the parent block's state
-    await vmCopy.vmState.setStateRoot(parentBlock.header.stateRoot)
+    await vmCopy.eei.state.setStateRoot(parentBlock.header.stateRoot)
 
     let difficulty
     let cliqueSigner

packages/client/lib/miner/pendingBlock.ts

@@ -45,7 +45,7 @@ export class PendingBlock {
 
     // Set the state root to ensure the resulting state
     // is based on the parent block's state
-    await vm.vmState.setStateRoot(parentBlock.header.stateRoot)
+    await vm.eei.state.setStateRoot(parentBlock.header.stateRoot)
 
     const td = await vm.blockchain.getTotalDifficulty(parentBlock.hash())
     vm._common.setHardforkByBlockNumber(parentBlock.header.number, td)

packages/client/lib/service/txpool.ts

@@ -499,7 +499,7 @@ export class TxPool {
         .map((obj) => obj.tx)
         .sort((a, b) => Number(a.nonce - b.nonce))
       // Check if the account nonce matches the lowest known tx nonce
-      const { nonce } = await this.vm.vmState.getAccount(new Address(Buffer.from(address, 'hex')))
+      const { nonce } = await this.vm.eei.state.getAccount(new Address(Buffer.from(address, 'hex')))
       if (txsSortedByNonce[0].nonce !== nonce) {
         // Account nonce does not match the lowest known tx nonce,
         // therefore no txs from this address are currently exectuable

packages/vm/package.json

@@ -72,6 +72,7 @@
     "@types/node": "^16.11.7",
     "@types/node-dir": "^0.0.34",
     "@types/tape": "^4.13.2",
+    "@types/async-eventemitter": "^0.2.1",
     "benchmark": "^2.1.4",
     "eslint": "^6.8.0",
     "karma": "^6.3.2",

packages/vm/src/buildBlock.ts

@@ -155,7 +155,7 @@ export class BlockBuilder {
     const coinbase = this.headerData.coinbase
       ? new Address(toBuffer(this.headerData.coinbase))
       : Address.zero()
-    await rewardAccount(this.vm.vmState, coinbase, reward)
+    await rewardAccount(this.vm.eei.state, coinbase, reward)
   }
 
   /**

packages/vm/src/eei/eei.ts

@@ -0,0 +1,134 @@
+import { Address, bufferToBigInt } from 'ethereumjs-util'
+import Common from '@ethereumjs/common'
+
+import { VmState } from './vmState'
+import TransientStorage from './transientStorage'
+import { addressToBuffer } from '../evm/opcodes'
+import { StateManager } from '@ethereumjs/statemanager'
+import { EEIInterface } from '../evm/types'
+
+type Block = {
+  hash(): Buffer
+}
+
+type Blockchain = {
+  getBlock(blockId: number): Promise<Block>
+}
+
+/**
+ * External interface made available to EVM bytecode. Modeled after
+ * the ewasm EEI [spec](https://github.com/ewasm/design/blob/master/eth_interface.md).
+ * It includes methods for accessing/modifying state, calling or creating contracts, access
+ * to environment data among other things.
+ * The EEI instance also keeps artifacts produced by the bytecode such as logs
+ * and to-be-selfdestructed addresses.
+ */
+export default class EEI implements EEIInterface {
+  readonly state: VmState // TODO this is part of the interface, remove underscore (search .ei._state, replace all)
+  protected _common: Common
+  _transientStorage: TransientStorage
+  protected _blockchain: Blockchain
+
+  constructor(stateManager: StateManager, common: Common, blockchain: Blockchain) {
+    this._common = common
+    this._transientStorage = new TransientStorage()
+    this._blockchain = blockchain
+    this.state = new VmState({ common, stateManager })
+  }
+
+  /**
+   * Returns balance of the given account.
+   * @param address - Address of account
+   */
+  async getExternalBalance(address: Address): Promise<bigint> {
+    const account = await this.state.getAccount(address)
+    return account.balance
+  }
+
+  /**
+   * Get size of an account’s code.
+   * @param address - Address of account
+   */
+  async getExternalCodeSize(address: bigint): Promise<bigint> {
+    const addr = new Address(addressToBuffer(address))
+    const code = await this.state.getContractCode(addr)
+    return BigInt(code.length)
+  }
+
+  /**
+   * Returns code of an account.
+   * @param address - Address of account
+   */
+  async getExternalCode(address: bigint): Promise<Buffer> {
+    const addr = new Address(addressToBuffer(address))
+    return this.state.getContractCode(addr)
+  }
+
+  /**
+   * Returns Gets the hash of one of the 256 most recent complete blocks.
+   * @param num - Number of block
+   */
+  async getBlockHash(num: bigint): Promise<bigint> {
+    const block = await this._blockchain.getBlock(Number(num))
+    return bufferToBigInt(block.hash())
+  }
+
+  /**
+   * Storage 256-bit value into storage of an address
+   * @param address Address to store into
+   * @param key Storage key
+   * @param value Storage value
+   */
+  async storageStore(address: Address, key: Buffer, value: Buffer): Promise<void> {
+    await this.state.putContractStorage(address, key, value)
+  }
+
+  /**
+   * Loads a 256-bit value to memory from persistent storage.
+   * @param address Address to get storage key value from
+   * @param key Storage key
+   * @param original If true, return the original storage value (default: false)
+   */
+  async storageLoad(address: Address, key: Buffer, original = false): Promise<Buffer> {
+    if (original) {
+      return this.state.getOriginalContractStorage(address, key)
+    } else {
+      return this.state.getContractStorage(address, key)
+    }
+  }
+
+  /**
+   * Store 256-bit a value in memory to transient storage.
+   * @param address Address to use
+   * @param key Storage key
+   * @param value Storage value
+   */
+  transientStorageStore(address: Address, key: Buffer, value: Buffer): void {
+    return this._transientStorage.put(address, key, value)
+  }
+
+  /**
+   * Loads a 256-bit value to memory from transient storage.
+   * @param address Address to use
+   * @param key Storage key
+   */
+  transientStorageLoad(address: Address, key: Buffer): Buffer {
+    return this._transientStorage.get(address, key)
+  }
+
+  /**
+   * Returns true if account is empty or non-existent (according to EIP-161).
+   * @param address - Address of account
+   */
+  async isAccountEmpty(address: Address): Promise<boolean> {
+    return this.state.accountIsEmpty(address)
+  }
+
+  /**
+   * Returns true if account exists in the state trie (it can be empty). Returns false if the account is `null`.
+   * @param address - Address of account
+   */
+  async accountExists(address: Address): Promise<boolean> {
+    return this.state.accountExists(address)
+  }
+}

packages/vm/src/state/transientStorage.ts → packages/vm/src/eei/transientStorage.ts

@@ -1,4 +1,5 @@
 import { Address } from 'ethereumjs-util'
+import { TransientStorageInterface } from '../evm/types'
 
 type TransientStorageCurrent = Map<string, Map<string, Buffer>>
 
@@ -10,7 +11,7 @@ interface TransientStorageModification {
 
 type TransientStorageJournal = TransientStorageModification[]
 
-export default class TransientStorage {
+export default class TransientStorage implements TransientStorageInterface {
   /**
    * The current values of the transient storage, keyed by contract address and then slot
    */

packages/vm/src/vmState.ts → packages/vm/src/eei/vmState.ts

@@ -3,26 +3,14 @@ import { AccessList, AccessListItem } from '@ethereumjs/tx'
 import { Account, Address, toBuffer } from 'ethereumjs-util'
 const Set = require('core-js-pure/es/set')
 
-import { StateManager, StateAccess, AccountFields } from '@ethereumjs/statemanager'
+import { StateManager, AccountFields } from '@ethereumjs/statemanager'
 
-import { ripemdPrecompileAddress } from './evm/precompiles'
+import { ripemdPrecompileAddress } from '../evm/precompiles'
 import { debug as createDebugLogger, Debugger } from 'debug'
+import { VmStateAccess } from '../evm/types'
 
 type AddressHex = string
 
-interface VmStateAccess extends StateAccess {
-  touchAccount(address: Address): void
-  addWarmedAddress(address: Buffer): void
-  isWarmedAddress(address: Buffer): boolean
-  addWarmedStorage(address: Buffer, slot: Buffer): void
-  isWarmedStorage(address: Buffer, slot: Buffer): boolean
-  clearWarmedAccounts(): void
-  generateAccessList?(addressesRemoved: Address[], addressesOnlyStorage: Address[]): AccessList
-  getOriginalContractStorage(address: Address, key: Buffer): Promise<Buffer>
-  clearOriginalStorageCache(): void
-  cleanupTouchedAccounts(): Promise<void>
-}
-
 export class VmState implements VmStateAccess {
   _common: Common
   _debug: Debugger