Support BLOCKHASH opcode in Async EVM (#3512)

bhartnett · web-flow · commit a30ff4a84afb · 2025-07-30T16:20:02.000+08:00
* Update async evm to support blockhash opcode.

* Add blockHashProc AsyncEvmStateBackend to the verified proxy. Get block hashes from the header store. Increase the default cache size to 256.
diff --git a/execution_chain/evm/async_evm.nim b/execution_chain/evm/async_evm.nim
@@ -14,6 +14,7 @@ import
   chronicles,
   stint,
   results,
+  minilru,
   eth/common/[base, addresses, accounts, headers, transactions],
   ../db/[ledger, access_list],
   ../common/common,
@@ -56,12 +57,6 @@ logScope:
 #   default approach where the state lookups are wired directly into the EVM gives
 #   the worst case performance because all state accesses inside the EVM are
 #   completely sequential.
-#
-# Note: The BLOCKHASH opt code is not yet supported by this implementation and so
-# transactions which use this opt code will simply get the empty/default hash
-# for any requested block. After the Pectra hard fork this opt code will be
-# implemented using a system contract with the data stored in the Ethereum state
-# trie/s and at that point it should just work without changes to the async evm here.
 
 const
   EVM_CALL_LIMIT = 10_000
@@ -81,6 +76,10 @@ type
     address: Address
     codeFut: Future[Opt[seq[byte]]]
 
+  BlockHashQuery = object
+    number: BlockNumber
+    blockHashFut: Future[Opt[Hash32]]
+
   AsyncEvm* = ref object
     com: CommonRef
     backend: AsyncEvmStateBackend
@@ -96,6 +95,9 @@ func init(
 func init(T: type CodeQuery, adr: Address, fut: Future[Opt[seq[byte]]]): T =
   T(address: adr, codeFut: fut)
 
+func init(T: type BlockHashQuery, number: BlockNumber, fut: Future[Opt[Hash32]]): T =
+  T(number: number, blockHashFut: fut)
+
 proc init*(
     T: type AsyncEvm, backend: AsyncEvmStateBackend, networkId: NetworkId = MainNet
 ): T =
@@ -138,6 +140,7 @@ proc callFetchingState(
     fetchedAccounts = initHashSet[Address]()
     fetchedStorage = initHashSet[(Address, UInt256)]()
     fetchedCode = initHashSet[Address]()
+    fetchedBlockHashes = initHashSet[BlockNumber]()
 
   # Set code of the 'to' address in the EVM so that we can execute the transaction
   let code = (await evm.backend.getCode(header, to)).valueOr:
@@ -158,6 +161,8 @@ proc callFetchingState(
     debug "Starting AsyncEvm execution", evmCallCount
 
     vmState.ledger.clearWitnessKeys()
+    vmState.ledger.clearBlockHashesCache()
+
     let sp = vmState.ledger.beginSavepoint()
     evmResult = rpcCallEvm(tx, header, vmState, EVM_CALL_GAS_CAP)
     inc evmCallCount
@@ -172,6 +177,7 @@ proc callFetchingState(
         accountQueries = newSeq[AccountQuery]()
         storageQueries = newSeq[StorageQuery]()
         codeQueries = newSeq[CodeQuery]()
+        blockHashQueries = newSeq[BlockHashQuery]()
 
       # Loop through the collected keys and fetch the state concurrently.
       # If optimisticStateFetch is enabled then we fetch state for all the witness
@@ -212,6 +218,13 @@ proc callFetchingState(
               if not optimisticStateFetch:
                 stateFetchDone = true
 
+      for number, blockHash in vmState.ledger.getBlockHashesCache():
+        if number notin fetchedBlockHashes:
+          debug "Fetching block hash", blockNumber = number
+          let blockHashFut = evm.backend.getBlockHash(header, number)
+          blockHashQueries.add(BlockHashQuery.init(number, blockHashFut))
+
+
       if optimisticStateFetch:
         # If the witness keys did not change after the last execution then we can
         # stop the execution loop because we have already executed the transaction
@@ -245,6 +258,13 @@ proc callFetchingState(
           return err("Unable to get code")
         vmState.ledger.setCode(q.address, code)
         fetchedCode.incl(q.address)
+
+      for q in blockHashQueries:
+        let blockHash = (await q.blockHashFut).valueOr:
+          return err("Unable to get block hash")
+        vmState.ledger.txFrame.addBlockNumberToHashLookup(q.number, blockHash)
+        fetchedBlockHashes.incl(q.number)
+        
     except CancelledError as e:
       raise e
     except CatchableError as e:
diff --git a/execution_chain/evm/async_evm_backend.nim b/execution_chain/evm/async_evm_backend.nim
@@ -24,15 +24,25 @@ type
     async: (raises: [CancelledError])
   .}
 
+  GetBlockHashProc* = proc(header: Header, number: BlockNumber): Future[Opt[Hash32]] {.
+    async: (raises: [CancelledError])
+  .}
+
   AsyncEvmStateBackend* = ref object
     getAccount*: GetAccountProc
     getStorage*: GetStorageProc
     getCode*: GetCodeProc
+    getBlockHash*: GetBlockHashProc
 
 proc init*(
     T: type AsyncEvmStateBackend,
     accProc: GetAccountProc,
     storageProc: GetStorageProc,
     codeProc: GetCodeProc,
+    blockHashProc: GetBlockHashProc,
 ): T =
-  AsyncEvmStateBackend(getAccount: accProc, getStorage: storageProc, getCode: codeProc)
+  AsyncEvmStateBackend(
+    getAccount: accProc,
+    getStorage: storageProc,
+    getCode: codeProc,
+    getBlockHash: blockHashProc)
diff --git a/nimbus_verified_proxy/header_store.nim b/nimbus_verified_proxy/header_store.nim
@@ -48,7 +48,7 @@ func convLCHeader*(lcHeader: ForkedLightClientHeader): Result[Header, string] =
         parentBeaconBlockRoot = Opt.none(Hash32)
 
     when lcDataFork >= LightClientDataFork.Electra:
-      # INFO: there is no visibility of the execution requests hash in light client header 
+      # INFO: there is no visibility of the execution requests hash in light client header
       let requestsHash = Opt.none(Hash32)
     else:
       const requestsHash = Opt.none(Hash32)
@@ -189,6 +189,9 @@ func latestHash*(self: HeaderStore): Opt[Hash32] =
 
   Opt.none(Hash32)
 
+func getHash*(self: HeaderStore, number: base.BlockNumber): Opt[Hash32] =
+  self.hashes.peek(number)
+
 func get*(self: HeaderStore, number: base.BlockNumber): Opt[Header] =
   let hash = self.hashes.peek(number).valueOr:
     return Opt.none(Header)
diff --git a/nimbus_verified_proxy/nimbus_verified_proxy_conf.nim b/nimbus_verified_proxy/nimbus_verified_proxy_conf.nim
@@ -65,11 +65,13 @@ type VerifiedProxyConf* = object # Config
   .}: OutDir
 
   # In-Memory Cache Size
+  # In order to support the BLOCKHASH opcode for eth_call we need at least
+  # MAX_PREV_HEADER_DEPTH headers in the header cache.
   cacheLen* {.
     hidden,
     desc: "Length of the header cache maintained in memory",
-    defaultValue: 64,
-    defaultValueDesc: "64",
+    defaultValue: MAX_PREV_HEADER_DEPTH,
+    defaultValueDesc: "256",
     name: "debug-cache-len"
   .}: int
 
diff --git a/nimbus_verified_proxy/rpc/evm.nim b/nimbus_verified_proxy/rpc/evm.nim
@@ -12,6 +12,7 @@ import
   ../../execution_chain/evm/async_evm_backend,
   ../../execution_chain/evm/async_evm,
   ./accounts,
+  ../header_store,
   ../types
 
 logScope:
@@ -66,4 +67,9 @@ proc toAsyncEvmStateBackend*(vp: VerifiedRpcProxy): AsyncEvmStateBackend =
 
       Opt.none(seq[byte])
 
-  AsyncEvmStateBackend.init(accProc, storageProc, codeProc)
+    blockHashProc = proc(
+        header: Header, number: BlockNumber
+    ): Future[Opt[Hash32]] {.async: (raises: [CancelledError]).} =
+      vp.headerStore.getHash(number)
+
+  AsyncEvmStateBackend.init(accProc, storageProc, codeProc, blockHashProc)
diff --git a/nimbus_verified_proxy/rpc/rpc_eth_api.nim b/nimbus_verified_proxy/rpc/rpc_eth_api.nim
@@ -233,7 +233,6 @@ proc installEthApiHandlers*(vp: VerifiedRpcProxy) =
   # Following methods are forwarded directly to the web3 provider and therefore
   # are not validated in any way.
   vp.proxy.registerProxyMethod("net_version")
-  vp.proxy.registerProxyMethod("eth_call")
   vp.proxy.registerProxyMethod("eth_sendRawTransaction")
   vp.proxy.registerProxyMethod("eth_getTransactionReceipt")
 
diff --git a/tests/async_evm_test_backend.nim b/tests/async_evm_test_backend.nim
@@ -13,6 +13,7 @@ type TestEvmState* = ref object
   accounts: Table[Address, Account]
   storage: Table[Address, Table[UInt256, UInt256]]
   code: Table[Address, seq[byte]]
+  blockHashes: Table[BlockNumber, Hash32]
 
 proc init*(T: type TestEvmState): T =
   TestEvmState()
@@ -30,6 +31,9 @@ proc setStorage*(
 proc setCode*(backend: TestEvmState, address: Address, code: seq[byte]) =
   backend.code[address] = code
 
+proc setBlockHash*(backend: TestEvmState, number: BlockNumber, blockHash: Hash32) =
+  backend.blockHashes[number] = blockHash
+
 proc getAccount*(backend: TestEvmState, address: Address): Account =
   backend.accounts.getOrDefault(address)
 
@@ -39,8 +43,11 @@ proc getStorage*(backend: TestEvmState, address: Address, slotKey: UInt256): UIn
 proc getCode*(backend: TestEvmState, address: Address): seq[byte] =
   backend.code.getOrDefault(address)
 
+proc getBlockHash*(backend: TestEvmState, number: BlockNumber): Hash32 =
+  backend.blockHashes.getOrDefault(number)
+
 proc toAsyncEvmStateBackend*(testState: TestEvmState): AsyncEvmStateBackend =
-  # State root is ignored because TestEvmState only stores a single state
+  # header is ignored because TestEvmState only stores a single state
   let
     accProc = proc(
         header: Header, address: Address
@@ -54,5 +61,9 @@ proc toAsyncEvmStateBackend*(testState: TestEvmState): AsyncEvmStateBackend =
         header: Header, address: Address
     ): Future[Opt[seq[byte]]] {.async: (raises: [CancelledError]).} =
       Opt.some(testState.getCode(address))
+    blockHashProc = proc(
+        header: Header, number: BlockNumber
+    ): Future[Opt[Hash32]] {.async: (raises: [CancelledError]).} =
+      Opt.some(testState.getBlockHash(number))
 
-  AsyncEvmStateBackend.init(accProc, storageProc, codeProc)
+  AsyncEvmStateBackend.init(accProc, storageProc, codeProc, blockHashProc)
diff --git a/tests/test_async_evm.nim b/tests/test_async_evm.nim
@@ -11,6 +11,7 @@ import
   std/[tables, sets],
   stew/byteutils,
   unittest2,
+  eth/common/times,
   ../execution_chain/evm/async_evm,
   ./async_evm_test_backend
 
@@ -25,24 +26,63 @@ type
   TestAccount =
     tuple[balance: string, nonce: string, code: string, storage: TestStorage]
 
+  TestBlockNumber = string
+  TestBlockHash = string
+  TestBlockHashes = Table[TestBlockNumber, TestBlockHash]
+
   TestTxArgs = tuple[to: string, input: string]
 
-  TestResult = tuple[output: string, accessList: Table[TestAddress, TestStorageKeys]]
+  TestAccessList = Table[TestAddress, TestStorageKeys]
+  TestResult = tuple[output: string, accessList: TestAccessList]
 
   TestCase =
     tuple[
       preState: Table[TestAddress, TestAccount],
+      blockHashes: TestBlockHashes,
       blockNumber: string,
       txArgs: TestTxArgs,
       expected: TestResult,
     ]
 
 const
-  emptyStorage = default(Table[string, string])
-  emptyStorageKeys = default(HashSet[string])
+  emptyStorage = default(TestStorage)
+  emptyStorageKeys = default(TestStorageKeys)
+  emptyAccessList = default(TestAccessList)
+  emptyBlockHashes = default(TestBlockHashes)
 
 const testCases: seq[TestCase] =
   @[
+    # Block hash test which executes bytecode compiled from the following solidity:
+    #
+    # pragma solidity >=0.8.30 <0.9.0;
+    #
+    # contract BlockHashContract {
+    #   function  getBlockHash() public view returns(bytes32)  {
+    #     return blockhash(block.number - 10);
+    #   }
+    # }
+    (
+      preState: {
+        "0x358aa13c52544eccef6b0add0f801012adad5ee3": (
+          balance: "0x",
+          nonce: "0x",
+          code:
+            "0x6080604052348015600e575f5ffd5b50600436106026575f3560e01c80639663f88f14602a575b5f5ffd5b60306044565b604051603b9190606c565b60405180910390f35b5f600a436050919060b9565b40905090565b5f819050919050565b6066816056565b82525050565b5f602082019050607d5f830184605f565b92915050565b5f819050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f60c1826083565b915060ca836083565b925082820390508181111560df5760de608c565b5b9291505056fea26469706673582212205d02238b0582fce570b72434d696e873371bf590e00d5deed50555a523df0e8764736f6c634300081e0033",
+          storage: emptyStorage,
+        ),
+      }.toTable,
+      blockHashes: {
+        "0x015EE5A0": "0x536174697366792056616c756573207468726f75676820467269656e64736869",
+      }.toTable,
+      blockNumber: "0x015EE5A9",
+      txArgs: (to: "0x358aa13c52544eccef6b0add0f801012adad5ee3", input: "0x9663f88f"),
+      expected: (
+        output: "0x536174697366792056616c756573207468726f75676820467269656e64736869",
+        accessList: {
+          "0x358aa13c52544eccef6b0add0f801012adad5ee3": emptyStorageKeys,
+        }.toTable,
+      )
+    ),
     # Test state from mainnet contract 0x1a875Da9e86506999A2931400475C34c27185Dd1 at block 700_000
     (
       preState: {
@@ -61,6 +101,7 @@ const testCases: seq[TestCase] =
           storage: emptyStorage,
         ),
       }.toTable,
+      blockHashes: emptyBlockHashes,
       blockNumber: "0x0AAE60",
       txArgs: (to: "0x1a875da9e86506999a2931400475c34c27185dd1", input: "0x"),
       expected: (
@@ -95,6 +136,7 @@ const testCases: seq[TestCase] =
           }.toTable,
         )
       }.toTable,
+      blockHashes: emptyBlockHashes,
       blockNumber: "0x0F4240",
       txArgs: (
         to: "0x6e38a457c722c6011b2dfa06d49240e797844d66",
@@ -133,6 +175,9 @@ proc setupTestEvmState(testCase: TestCase): TestEvmState =
     for k, v in acc.storage:
       testState.setStorage(address, k.hexToUInt256(), v.hexToUInt256())
 
+  for number, blockHash in testCase.blockHashes:
+    testState.setBlockHash(number.hexToUInt256().truncate(BlockNumber), Hash32.fromHex(blockHash))
+
   return testState
 
 suite "Async EVM":
@@ -143,6 +188,7 @@ suite "Async EVM":
         evm = AsyncEvm.init(testState.toAsyncEvmStateBackend())
         header = Header(
           number: testCase.blockNumber.hexToUInt256().truncate(uint64),
+          timestamp: 1_746_612_312.EthTime, # pragueTime: Opt.some(1_746_612_311.EthTime)
           gasLimit: EVM_CALL_GAS_CAP,
         )
         tx = TransactionArgs(
@@ -161,6 +207,7 @@ suite "Async EVM":
         evm = AsyncEvm.init(testState.toAsyncEvmStateBackend())
         header = Header(
           number: testCase.blockNumber.hexToUInt256().truncate(uint64),
+          timestamp: 1_746_612_312.EthTime, # pragueTime: Opt.some(1_746_612_311.EthTime)
           gasLimit: EVM_CALL_GAS_CAP,
         )
         tx = TransactionArgs(
@@ -179,6 +226,7 @@ suite "Async EVM":
         evm = AsyncEvm.init(testState.toAsyncEvmStateBackend())
         header = Header(
           number: testCase.blockNumber.hexToUInt256().truncate(uint64),
+          timestamp: 1_746_612_312.EthTime, # pragueTime: Opt.some(1_746_612_311.EthTime)
           gasLimit: EVM_CALL_GAS_CAP,
         )
         tx = TransactionArgs(
@@ -214,6 +262,7 @@ suite "Async EVM":
         evm = AsyncEvm.init(testState.toAsyncEvmStateBackend())
         header = Header(
           number: testCase.blockNumber.hexToUInt256().truncate(uint64),
+          timestamp: 1_746_612_312.EthTime, # pragueTime: Opt.some(1_746_612_311.EthTime)
           gasLimit: EVM_CALL_GAS_CAP,
         )
         tx = TransactionArgs(
@@ -249,6 +298,7 @@ suite "Async EVM":
         evm = AsyncEvm.init(testState.toAsyncEvmStateBackend())
         header = Header(
           number: testCase.blockNumber.hexToUInt256().truncate(uint64),
+          timestamp: 1_746_612_312.EthTime, # pragueTime: Opt.some(1_746_612_311.EthTime)
           gasLimit: EVM_CALL_GAS_CAP,
         )
         tx = TransactionArgs(
@@ -268,6 +318,7 @@ suite "Async EVM":
         evm = AsyncEvm.init(testState.toAsyncEvmStateBackend())
         header = Header(
           number: testCase.blockNumber.hexToUInt256().truncate(uint64),
+          timestamp: 1_746_612_312.EthTime, # pragueTime: Opt.some(1_746_612_311.EthTime)
           gasLimit: EVM_CALL_GAS_CAP,
         )
         tx = TransactionArgs(
@@ -289,6 +340,7 @@ suite "Async EVM":
         evm = AsyncEvm.init(testState.toAsyncEvmStateBackend())
         header = Header(
           number: testCase.blockNumber.hexToUInt256().truncate(uint64),
+          timestamp: 1_746_612_312.EthTime, # pragueTime: Opt.some(1_746_612_311.EthTime)
           gasLimit: EVM_CALL_GAS_CAP,
         )
         tx = TransactionArgs(
