Rename stateDB to ledger (#2966)

* Rename stateDB to ledger

* Fix readOnlyLedger

Author: jangko

hive_integration/nodocker/engine/node.nim

@@ -48,7 +48,7 @@ proc processBlock(
   let com = vmState.com
   if com.daoForkSupport and
      com.daoForkBlock.get == header.number:
-    vmState.mutateStateDB:
+    vmState.mutateLedger:
       db.applyDAOHardFork()
 
   if header.parentBeaconBlockRoot.isSome:
@@ -58,7 +58,7 @@ proc processBlock(
 
   if com.isShanghaiOrLater(header.timestamp):
     for withdrawal in blk.withdrawals.get:
-      vmState.stateDB.addBalance(withdrawal.address, withdrawal.weiAmount)
+      vmState.ledger.addBalance(withdrawal.address, withdrawal.weiAmount)
 
   if header.ommersHash != EMPTY_UNCLE_HASH:
     discard com.db.persistUncles(blk.uncles)
@@ -67,7 +67,7 @@ proc processBlock(
   if com.proofOfStake(header):
     vmState.calculateReward(header, blk.uncles)
 
-  vmState.mutateStateDB:
+  vmState.mutateLedger:
     let clearEmptyAccount = com.isSpuriousOrLater(header.number)
     db.persist(clearEmptyAccount)
 

hive_integration/nodocker/pyspec/test_env.nim

@@ -37,12 +37,12 @@ proc genesisHeader(node: JsonNode): Header =
 proc initializeDb(memDB: CoreDbRef, node: JsonNode): Hash32 =
   let
     genesisHeader = node.genesisHeader
-    stateDB = LedgerRef.init(memDB)
+    ledger = LedgerRef.init(memDB)
 
   memDB.persistHeaderAndSetHead(genesisHeader).expect("persistHeader no error")
-  setupStateDB(node["pre"], stateDB)
-  stateDB.persist()
-  doAssert stateDB.getStateRoot == genesisHeader.stateRoot
+  setupLedger(node["pre"], ledger)
+  ledger.persist()
+  doAssert ledger.getStateRoot == genesisHeader.stateRoot
 
   genesisHeader.blockHash
 

nimbus/core/dao.nim

@@ -145,9 +145,9 @@ const
 # ApplyDAOHardFork modifies the state database according to the DAO hard-fork
 # rules, transferring all balances of a set of DAO accounts to a single refund
 # contract.
-proc applyDAOHardFork*(statedb: LedgerRef) =
+proc applyDAOHardFork*(ledger: LedgerRef) =
   const zero = 0.u256
   # Move every DAO account and extra-balance account funds into the refund contract
   for address in DAODrainList:
-    statedb.addBalance(DAORefundContract, statedb.getBalance(address))
-    statedb.setBalance(address, zero)
+    ledger.addBalance(DAORefundContract, ledger.getBalance(address))
+    ledger.setBalance(address, zero)

nimbus/core/executor/calculate_reward.nim

@@ -59,11 +59,11 @@ proc calculateReward*(vmState: BaseVMState; account: Address;
     uncleReward -= number.u256
     uncleReward = uncleReward * blockReward
     uncleReward = uncleReward div 8.u256
-    vmState.mutateStateDB:
+    vmState.mutateLedger:
       db.addBalance(uncle.coinbase, uncleReward)
     mainReward += blockReward div 32.u256
 
-  vmState.mutateStateDB:
+  vmState.mutateLedger:
     db.addBalance(account, mainReward)
 
 

nimbus/core/executor/executor_helpers.nim

@@ -53,7 +53,7 @@ proc makeReceipt*(vmState: BaseVMState; txType: TxType): Receipt =
     rec.status = vmState.status
   else:
     rec.isHash = true
-    rec.hash   = vmState.stateDB.getStateRoot()
+    rec.hash   = vmState.ledger.getStateRoot()
     # we set the status for the t8n output consistency
     rec.status = vmState.status
 

nimbus/core/executor/process_block.nim

@@ -113,7 +113,7 @@ proc procBlkPreamble(
 
   let com = vmState.com
   if com.daoForkSupport and com.daoForkBlock.get == header.number:
-    vmState.mutateStateDB:
+    vmState.mutateLedger:
       db.applyDAOHardFork()
 
   if not skipValidation: # Expensive!
@@ -156,7 +156,7 @@ proc procBlkPreamble(
       return err("Post-Shanghai block body must have withdrawals")
 
     for withdrawal in blk.withdrawals.get:
-      vmState.stateDB.addBalance(withdrawal.address, withdrawal.weiAmount)
+      vmState.ledger.addBalance(withdrawal.address, withdrawal.weiAmount)
   else:
     if header.withdrawalsRoot.isSome:
       return err("Pre-Shanghai block header must not have withdrawalsRoot")
@@ -190,7 +190,7 @@ proc procBlkEpilogue(
     blk.header
 
   # Reward beneficiary
-  vmState.mutateStateDB:
+  vmState.mutateLedger:
     if vmState.collectWitnessData:
       db.collectWitnessData()
 
@@ -212,7 +212,7 @@ proc procBlkEpilogue(
     consolidationReqs = processDequeueConsolidationRequests(vmState)
 
   if not skipValidation:
-    let stateRoot = vmState.stateDB.getStateRoot()
+    let stateRoot = vmState.ledger.getStateRoot()
     if header.stateRoot != stateRoot:
       # TODO replace logging with better error
       debug "wrong state root in block",

nimbus/core/executor/process_transaction.nim

@@ -50,12 +50,12 @@ proc commitOrRollbackDependingOnGasUsed(
   # an early stop. It would rather detect differing values for the  block
   # header `gasUsed` and the `vmState.cumulativeGasUsed` at a later stage.
   if header.gasLimit < vmState.cumulativeGasUsed + gasBurned:
-    vmState.stateDB.rollback(accTx)
+    vmState.ledger.rollback(accTx)
     err(&"invalid tx: block header gasLimit reached. gasLimit={header.gasLimit}, gasUsed={vmState.cumulativeGasUsed}, addition={gasBurned}")
   else:
     # Accept transaction and collect mining fee.
-    vmState.stateDB.commit(accTx)
-    vmState.stateDB.addBalance(vmState.coinbase(), gasBurned.u256 * priorityFee.u256)
+    vmState.ledger.commit(accTx)
+    vmState.ledger.addBalance(vmState.coinbase(), gasBurned.u256 * priorityFee.u256)
     vmState.cumulativeGasUsed += gasBurned
 
     # Return remaining gas to the block gas counter so it is
@@ -75,7 +75,7 @@ proc processTransactionImpl(
 
   let
     fork = vmState.fork
-    roDB = vmState.readOnlyStateDB
+    roDB = vmState.readOnlyLedger
     baseFee256 = header.eip1559BaseFee(fork)
     baseFee = baseFee256.truncate(GasInt)
     priorityFee = min(tx.maxPriorityFeePerGasNorm(), tx.maxFeePerGasNorm() - baseFee)
@@ -106,12 +106,12 @@ proc processTransactionImpl(
     txRes = roDB.validateTransaction(tx, sender, header.gasLimit, baseFee256, excessBlobGas, fork)
     res = if txRes.isOk:
       # EIP-1153
-      vmState.stateDB.clearTransientStorage()
+      vmState.ledger.clearTransientStorage()
 
       # Execute the transaction.
       vmState.captureTxStart(tx.gasLimit)
       let
-        accTx = vmState.stateDB.beginSavepoint
+        accTx = vmState.ledger.beginSavepoint
         gasBurned = tx.txCallEvm(sender, vmState, baseFee)
       vmState.captureTxEnd(tx.gasLimit - gasBurned)
 
@@ -120,9 +120,9 @@ proc processTransactionImpl(
       err(txRes.error)
 
   if vmState.collectWitnessData:
-    vmState.stateDB.collectWitnessData()
+    vmState.ledger.collectWitnessData()
 
-  vmState.stateDB.persist(clearEmptyAccount = fork >= FkSpurious)
+  vmState.ledger.persist(clearEmptyAccount = fork >= FkSpurious)
 
   res
 
@@ -137,7 +137,7 @@ proc processBeaconBlockRoot*(vmState: BaseVMState, beaconRoot: Hash32):
   ## If EIP-4788 is enabled, we need to invoke the beaconroot storage
   ## contract with the new root.
   let
-    statedb = vmState.stateDB
+    ledger = vmState.ledger
     call = CallParams(
       vmState  : vmState,
       sender   : SYSTEM_ADDRESS,
@@ -159,15 +159,15 @@ proc processBeaconBlockRoot*(vmState: BaseVMState, beaconRoot: Hash32):
   if res.len > 0:
     return err("processBeaconBlockRoot: " & res)
 
-  statedb.persist(clearEmptyAccount = true)
+  ledger.persist(clearEmptyAccount = true)
   ok()
 
 proc processParentBlockHash*(vmState: BaseVMState, prevHash: Hash32):
                               Result[void, string] =
   ## processParentBlockHash stores the parent block hash in the
   ## history storage contract as per EIP-2935.
   let
-    statedb = vmState.stateDB
+    ledger = vmState.ledger
     call = CallParams(
       vmState  : vmState,
       sender   : SYSTEM_ADDRESS,
@@ -189,14 +189,14 @@ proc processParentBlockHash*(vmState: BaseVMState, prevHash: Hash32):
   if res.len > 0:
     return err("processParentBlockHash: " & res)
 
-  statedb.persist(clearEmptyAccount = true)
+  ledger.persist(clearEmptyAccount = true)
   ok()
 
 proc processDequeueWithdrawalRequests*(vmState: BaseVMState): seq[byte] =
   ## processDequeueWithdrawalRequests applies the EIP-7002 system call
   ## to the withdrawal requests contract.
   let
-    statedb = vmState.stateDB
+    ledger = vmState.ledger
     call = CallParams(
       vmState  : vmState,
       sender   : SYSTEM_ADDRESS,
@@ -214,13 +214,13 @@ proc processDequeueWithdrawalRequests*(vmState: BaseVMState): seq[byte] =
 
   # runComputation a.k.a syscall/evm.call
   result = call.runComputation(seq[byte])
-  statedb.persist(clearEmptyAccount = true)
+  ledger.persist(clearEmptyAccount = true)
 
 proc processDequeueConsolidationRequests*(vmState: BaseVMState): seq[byte] =
   ## processDequeueConsolidationRequests applies the EIP-7251 system call
   ## to the consolidation requests contract.
   let
-    statedb = vmState.stateDB
+    ledger = vmState.ledger
     call = CallParams(
       vmState  : vmState,
       sender   : SYSTEM_ADDRESS,
@@ -238,7 +238,7 @@ proc processDequeueConsolidationRequests*(vmState: BaseVMState): seq[byte] =
 
   # runComputation a.k.a syscall/evm.call
   result = call.runComputation(seq[byte])
-  statedb.persist(clearEmptyAccount = true)
+  ledger.persist(clearEmptyAccount = true)
 
 proc processTransaction*(
     vmState: BaseVMState; ## Parent accounts environment for transaction

nimbus/core/tx_pool/tx_desc.nim

@@ -208,19 +208,19 @@ func excessBlobGas*(xp: TxPoolRef): GasInt =
   xp.vmState.blockCtx.excessBlobGas
 
 proc getBalance*(xp: TxPoolRef; account: Address): UInt256 =
-  ## Wrapper around `vmState.readOnlyStateDB.getBalance()` for a `vmState`
+  ## Wrapper around `vmState.readOnlyLedger.getBalance()` for a `vmState`
   ## descriptor positioned at the `dh.head`. This might differ from the
-  ## `dh.vmState.readOnlyStateDB.getBalance()` which returnes the current
+  ## `dh.vmState.readOnlyLedger.getBalance()` which returnes the current
   ## balance relative to what has been accumulated by the current packing
   ## procedure.
-  xp.vmState.stateDB.getBalance(account)
+  xp.vmState.ledger.getBalance(account)
 
 proc getNonce*(xp: TxPoolRef; account: Address): AccountNonce =
-  ## Wrapper around `vmState.readOnlyStateDB.getNonce()` for a `vmState`
+  ## Wrapper around `vmState.readOnlyLedger.getNonce()` for a `vmState`
   ## descriptor positioned at the `dh.head`. This might differ from the
-  ## `dh.vmState.readOnlyStateDB.getNonce()` which returnes the current balance
+  ## `dh.vmState.readOnlyLedger.getNonce()` which returnes the current balance
   ## relative to what has been accumulated by the current packing procedure.
-  xp.vmState.stateDB.getNonce(account)
+  xp.vmState.ledger.getNonce(account)
 
 func head*(xp: TxPoolRef): Header =
   ## Getter, cached block chain insertion point. Typocally, this should be the

nimbus/core/tx_pool/tx_packer.nim

@@ -69,15 +69,15 @@ proc persist(pst: var TxPacker)
   let vmState = pst.vmState
   if not pst.cleanState:
     let clearEmptyAccount = vmState.fork >= FkSpurious
-    vmState.stateDB.persist(clearEmptyAccount)
+    vmState.ledger.persist(clearEmptyAccount)
     pst.cleanState = true
 
 proc classifyValidatePacked(vmState: BaseVMState; item: TxItemRef): bool =
   ## Verify the argument `item` against the accounts database. This function
   ## is a wrapper around the `verifyTransaction()` call to be used in a similar
   ## fashion as in `asyncProcessTransactionImpl()`.
   let
-    roDB = vmState.readOnlyStateDB
+    roDB = vmState.readOnlyLedger
     baseFee = vmState.blockCtx.baseFeePerGas.get(0.u256)
     fork = vmState.fork
     gasLimit = vmState.blockCtx.gasLimit
@@ -142,7 +142,7 @@ proc runTxCommit(pst: var TxPacker; item: TxItemRef; gasBurned: GasInt)
   # are vetted for profitability before entering that bucket.
   assert 0 <= gasTip
   let reward = gasBurned.u256 * gasTip.u256
-  vmState.stateDB.addBalance(pst.feeRecipient, reward)
+  vmState.ledger.addBalance(pst.feeRecipient, reward)
   pst.blockValue += reward
 
   # Save accounts via persist() is not needed unless the fork is smaller
@@ -236,23 +236,23 @@ proc vmExecGrabItem(pst: var TxPacker; item: TxItemRef): GrabResult
     return ContinueWithNextAccount
 
   # EIP-1153
-  vmState.stateDB.clearTransientStorage()
+  vmState.ledger.clearTransientStorage()
 
   let
-    accTx = vmState.stateDB.beginSavepoint
+    accTx = vmState.ledger.beginSavepoint
     gasUsed = pst.runTx(item) # this is the crucial part, running the tx
 
   # Find out what to do next: accepting this tx or trying the next account
   if not vmState.classifyPacked(gasUsed):
-    vmState.stateDB.rollback(accTx)
+    vmState.ledger.rollback(accTx)
     if vmState.classifyPackedNext():
       return ContinueWithNextAccount
     return StopCollecting
 
   # Commit account state DB
-  vmState.stateDB.commit(accTx)
+  vmState.ledger.commit(accTx)
 
-  vmState.stateDB.persist(clearEmptyAccount = vmState.fork >= FkSpurious)
+  vmState.ledger.persist(clearEmptyAccount = vmState.fork >= FkSpurious)
 
   # Finish book-keeping and move item to `packed` bucket
   pst.runTxCommit(item, gasUsed)
@@ -262,29 +262,29 @@ proc vmExecGrabItem(pst: var TxPacker; item: TxItemRef): GrabResult
 proc vmExecCommit(pst: var TxPacker): Result[void, string] =
   let
     vmState = pst.vmState
-    stateDB = vmState.stateDB
+    ledger = vmState.ledger
 
   # EIP-4895
   if vmState.fork >= FkShanghai:
     for withdrawal in vmState.com.pos.withdrawals:
-      stateDB.addBalance(withdrawal.address, withdrawal.weiAmount)
+      ledger.addBalance(withdrawal.address, withdrawal.weiAmount)
 
   # EIP-6110, EIP-7002, EIP-7251
   if vmState.fork >= FkPrague:
     pst.withdrawalReqs = processDequeueWithdrawalRequests(vmState)
     pst.consolidationReqs = processDequeueConsolidationRequests(vmState)
     pst.depositReqs = ?parseDepositLogs(vmState.allLogs, vmState.com.depositContractAddress)
 
-  # Finish up, then vmState.stateDB.stateRoot may be accessed
-  stateDB.persist(clearEmptyAccount = vmState.fork >= FkSpurious)
+  # Finish up, then vmState.ledger.stateRoot may be accessed
+  ledger.persist(clearEmptyAccount = vmState.fork >= FkSpurious)
 
   # Update flexi-array, set proper length
   let nItems = pst.txDB.byStatus.eq(txItemPacked).nItems
   vmState.receipts.setLen(nItems)
 
   pst.receiptsRoot = vmState.receipts.calcReceiptsRoot
   pst.logsBloom = vmState.receipts.createBloom
-  pst.stateRoot = vmState.stateDB.getStateRoot()
+  pst.stateRoot = vmState.ledger.getStateRoot()
   ok()
 
 # ------------------------------------------------------------------------------

nimbus/core/validate.nim

@@ -285,7 +285,7 @@ proc validateTxBasic*(
   ok()
 
 proc validateTransaction*(
-    roDB:     ReadOnlyStateDB; ## Parent accounts environment for transaction
+    roDB:     ReadOnlyLedger; ## Parent accounts environment for transaction
     tx:       Transaction;     ## tx to validate
     sender:   Address;         ## tx.recoverSender
     maxLimit: GasInt;          ## gasLimit from block header