Stateless: Simplify the witness table data structure (#3446)

bhartnett · web-flow · commit 1b1f07e23bd9 · 2025-07-03T22:41:03.000+08:00
diff --git a/execution_chain/db/ledger.nim b/execution_chain/db/ledger.nim
@@ -42,13 +42,13 @@ const
 
 when statelessEnabled:
   type
-    WitnessKey* = object
-      storageMode*: bool
-      address*: Address
-      codeTouched*: bool
-      storageSlot*: UInt256
+    WitnessKey* = tuple[
+      address: Address,
+      slot: Opt[UInt256]
+    ]
 
-    WitnessTable* = OrderedTable[(Address, Hash32), WitnessKey]
+    # Maps witness keys to the codeTouched flag
+    WitnessTable* = OrderedTable[WitnessKey, bool]
 
 type
   AccountFlag = enum
@@ -98,8 +98,7 @@ type
     when statelessEnabled:
       witnessKeys: WitnessTable
         ## Used to collect the keys of all read accounts, code and storage slots.
-        ## Maps a tuple of address and hash of the key (address or slot) to the
-        ## witness key which can be either a storage key or an account key
+        ## Maps a tuple of address and slot (optional) to the codeTouched flag.
 
 
   ReadOnlyLedger* = distinct LedgerRef
@@ -171,12 +170,9 @@ proc getAccount(
     shouldCreate = true;
       ): AccountRef =
   when statelessEnabled:
-    let lookupKey = (address, address.toAccountKey)
+    let lookupKey = (address, Opt.none(UInt256))
     if not ac.witnessKeys.contains(lookupKey):
-      ac.witnessKeys[lookupKey] = WitnessKey(
-        storageMode: false,
-        address: address,
-        codeTouched: false)
+      ac.witnessKeys[lookupKey] = false
 
   # search account from layers of cache
   var sp = ac.savePoint
@@ -465,13 +461,10 @@ proc getCode*(ac: LedgerRef,
               address: Address,
               returnHash: static[bool] = false): auto =
   when statelessEnabled:
-    let lookupKey = (address, address.toAccountKey)
+    let lookupKey = (address, Opt.none(UInt256))
     # We overwrite any existing record here so that codeTouched is always set to
     # true even if an account was previously accessed without touching the code
-    ac.witnessKeys[lookupKey] = WitnessKey(
-      storageMode: false,
-      address: address,
-      codeTouched: true)
+    ac.witnessKeys[lookupKey] = true
 
   let acc = ac.getAccount(address, false)
   if acc.isNil:
@@ -532,11 +525,9 @@ proc getCommittedStorage*(ac: LedgerRef, address: Address, slot: UInt256): UInt2
   let acc = ac.getAccount(address, false)
 
   when statelessEnabled:
-    let lookupKey = (address, slot.toSlotKey)
+    let lookupKey = (address, Opt.some(slot))
     if not ac.witnessKeys.contains(lookupKey):
-      ac.witnessKeys[lookupKey] = WitnessKey(
-        storageMode: true,
-        storageSlot: slot)
+      ac.witnessKeys[lookupKey] = false
 
   if acc.isNil:
     return
@@ -546,11 +537,9 @@ proc getStorage*(ac: LedgerRef, address: Address, slot: UInt256): UInt256 =
   let acc = ac.getAccount(address, false)
 
   when statelessEnabled:
-    let lookupKey = (address, slot.toSlotKey)
+    let lookupKey = (address, Opt.some(slot))
     if not ac.witnessKeys.contains(lookupKey):
-      ac.witnessKeys[lookupKey] = WitnessKey(
-        storageMode: true,
-        storageSlot: slot)
+      ac.witnessKeys[lookupKey] = false
 
   if acc.isNil:
     return
@@ -635,11 +624,9 @@ proc setStorage*(ac: LedgerRef, address: Address, slot, value: UInt256) =
   acc.flags.incl {Alive}
 
   when statelessEnabled:
-    let lookupKey = (address, slot.toSlotKey)
+    let lookupKey = (address, Opt.some(slot))
     if not ac.witnessKeys.contains(lookupKey):
-      ac.witnessKeys[lookupKey] = WitnessKey(
-        storageMode: true,
-        storageSlot: slot)
+      ac.witnessKeys[lookupKey] = false
 
   let oldValue = acc.storageValue(slot, ac)
   if oldValue != value:
diff --git a/portal/evm/async_evm.nim b/portal/evm/async_evm.nim
@@ -180,23 +180,21 @@ proc callFetchingState(
       # state queries are still issued in the background just incase the state is
       # needed in the next iteration.
       var stateFetchDone = false
-      for k, v in witnessKeys:
-        let (adr, _) = k
+      for k, codeTouched in witnessKeys:
+        let (adr, maybeSlot) = k
         if adr == default(Address):
           continue
 
-        if v.storageMode:
-          let slotIdx = (adr, v.storageSlot)
-          if slotIdx notin fetchedStorage:
-            debug "Fetching storage slot", address = adr, slotKey = v.storageSlot
-            let storageFut = evm.backend.getStorage(header, adr, v.storageSlot)
+        if maybeSlot.isSome():
+          let slot = maybeSlot.get()
+          if (adr, slot) notin fetchedStorage:
+            debug "Fetching storage slot", address = adr, slot
+            let storageFut = evm.backend.getStorage(header, adr, slot)
             if not stateFetchDone:
-              storageQueries.add(StorageQuery.init(adr, v.storageSlot, storageFut))
+              storageQueries.add(StorageQuery.init(adr, slot, storageFut))
               if not optimisticStateFetch:
                 stateFetchDone = true
         else:
-          doAssert(adr == v.address)
-
           if adr notin fetchedAccounts:
             debug "Fetching account", address = adr
             let accFut = evm.backend.getAccount(header, adr)
@@ -205,7 +203,7 @@ proc callFetchingState(
               if not optimisticStateFetch:
                 stateFetchDone = true
 
-          if v.codeTouched and adr notin fetchedCode:
+          if codeTouched and adr notin fetchedCode:
             debug "Fetching code", address = adr
             let codeFut = evm.backend.getCode(header, adr)
             if not stateFetchDone:
@@ -336,13 +334,13 @@ proc createAccessList*(
   # returned in the callResult.
 
   var al = access_list.AccessList.init()
-  for lookupKey, witnessKey in witnessKeys:
-    let (adr, _) = lookupKey
+  for k, codeTouched in witnessKeys:
+    let (adr, maybeSlot) = k
     if adr == fromAdr:
       continue
 
-    if witnessKey.storageMode:
-      al.add(adr, witnessKey.storageSlot)
+    if maybeSlot.isSome():
+      al.add(adr, maybeSlot.get())
     else:
       al.add(adr)
 
diff --git a/tests/test_ledger.nim b/tests/test_ledger.nim
@@ -657,11 +657,11 @@ proc runLedgerBasicOperationsTests() =
 
         let
           witnessKeys = ac.getWitnessKeys()
-          keyData = witnessKeys.getOrDefault((addr1, addr1.toAccountKey))
+          key = (addr1, Opt.none(UInt256))
         check:
           witnessKeys.len() == 1
-          keyData.address == addr1
-          keyData.codeTouched == false
+          witnessKeys.contains(key)
+          witnessKeys.getOrDefault(key) == false
 
       test "Witness keys - Get code":
         var
@@ -672,11 +672,11 @@ proc runLedgerBasicOperationsTests() =
 
         let
           witnessKeys = ac.getWitnessKeys()
-          keyData = witnessKeys.getOrDefault((addr1, addr1.toAccountKey))
+          key = (addr1, Opt.none(UInt256))
         check:
           witnessKeys.len() == 1
-          keyData.address == addr1
-          keyData.codeTouched == true
+          witnessKeys.contains(key)
+          witnessKeys.getOrDefault(key) == true
 
       test "Witness keys - Get storage":
         var
@@ -688,10 +688,11 @@ proc runLedgerBasicOperationsTests() =
 
         let
           witnessKeys = ac.getWitnessKeys()
-          keyData = witnessKeys.getOrDefault((addr1, slot1.toSlotKey))
+          key = (addr1, Opt.some(slot1))
         check:
           witnessKeys.len() == 2
-          keyData.storageSlot == slot1
+          witnessKeys.contains(key)
+          witnessKeys.getOrDefault(key) == false
 
       test "Witness keys - Set storage":
         var
@@ -703,10 +704,11 @@ proc runLedgerBasicOperationsTests() =
 
         let
           witnessKeys = ac.getWitnessKeys()
-          keyData = witnessKeys.getOrDefault((addr1, slot1.toSlotKey))
+          key = (addr1, Opt.some(slot1))
         check:
           witnessKeys.len() == 2
-          keyData.storageSlot == slot1
+          witnessKeys.contains(key)
+          witnessKeys.getOrDefault(key) == false
 
       test "Witness keys - Get account, code and storage":
         var
@@ -728,31 +730,30 @@ proc runLedgerBasicOperationsTests() =
         let witnessKeys = ac.getWitnessKeys()
         check witnessKeys.len() == 5
 
-        var keysList = newSeq[(Address, WitnessKey)]()
+        var keysList = newSeq[(WitnessKey, bool)]()
         for k, v in witnessKeys:
-          let (adr, _) = k
-          keysList.add((adr, v))
+          keysList.add((k, v))
 
         check:
-          keysList[0][0] == addr1
-          keysList[0][1].address == addr1
-          keysList[0][1].codeTouched == true
+          keysList[0][0].address == addr1
+          keysList[0][0].slot == Opt.none(UInt256)
+          keysList[0][1] == true
 
-          keysList[1][0] == addr2
-          keysList[1][1].address == addr2
-          keysList[1][1].codeTouched == true
+          keysList[1][0].address == addr2
+          keysList[1][0].slot == Opt.none(UInt256)
+          keysList[1][1] == true
 
-          keysList[2][0] == addr2
-          keysList[2][1].storageSlot == slot1
-
-          keysList[3][0] == addr1
-          keysList[3][1].storageSlot == slot1
-
-          keysList[4][0] == addr3
-          keysList[4][1].address == addr3
-          keysList[4][1].codeTouched == false
+          keysList[2][0].address == addr2
+          keysList[2][0].slot == Opt.some(slot1)
+          keysList[2][1] == false
 
+          keysList[3][0].address == addr1
+          keysList[3][0].slot == Opt.some(slot1)
+          keysList[3][1] == false
 
+          keysList[4][0].address == addr3
+          keysList[4][0].slot == Opt.none(UInt256)
+          keysList[4][1] == false
 
 
 # ------------------------------------------------------------------------------
