346 lines
11 KiB
Nim
346 lines
11 KiB
Nim
# Nimbus
|
|
# Copyright (c) 2018-2024 Status Research & Development GmbH
|
|
# Licensed under either of
|
|
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
|
|
# http://www.apache.org/licenses/LICENSE-2.0)
|
|
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or
|
|
# http://opensource.org/licenses/MIT)
|
|
# at your option. This file may not be copied, modified, or distributed except
|
|
# according to those terms.
|
|
|
|
## Transaction Pool Tasklets: Packer, VM execute and compact txs
|
|
## =============================================================
|
|
##
|
|
|
|
{.push raises: [].}
|
|
|
|
import
|
|
eth/[keys, rlp],
|
|
stew/sorted_set,
|
|
../../db/[ledger, core_db],
|
|
../../common/common,
|
|
../../utils/utils,
|
|
../../constants,
|
|
".."/[executor, validate, casper],
|
|
../../transaction/call_evm,
|
|
../../transaction,
|
|
../../evm/state,
|
|
../../evm/types,
|
|
../eip4844,
|
|
"."/[tx_desc, tx_item, tx_tabs, tx_tabs/tx_status, tx_info],
|
|
tx_tasks/[tx_bucket]
|
|
|
|
type
|
|
TxPacker = object
|
|
# Packer state
|
|
vmState: BaseVMState
|
|
txDB: TxTabsRef
|
|
tr: CoreDbMptRef
|
|
cleanState: bool
|
|
numBlobPerBlock: int
|
|
|
|
# Packer results
|
|
blockValue: UInt256
|
|
stateRoot: Hash256
|
|
txRoot: Hash256
|
|
receiptsRoot: Hash256
|
|
logsBloom: BloomFilter
|
|
|
|
GrabResult = enum
|
|
FetchNextItem
|
|
ContinueWithNextAccount
|
|
StopCollecting
|
|
|
|
const
|
|
receiptsExtensionSize = ##\
|
|
## Number of slots to extend the `receipts[]` at the same time.
|
|
20
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Private helpers
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc persist(pst: var TxPacker)
|
|
{.gcsafe,raises: [].} =
|
|
## Smart wrapper
|
|
let vmState = pst.vmState
|
|
if not pst.cleanState:
|
|
let clearEmptyAccount = vmState.fork >= FkSpurious
|
|
vmState.stateDB.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
|
|
baseFee = vmState.blockCtx.baseFeePerGas.get(0.u256)
|
|
fork = vmState.fork
|
|
gasLimit = vmState.blockCtx.gasLimit
|
|
tx = item.tx.eip1559TxNormalization(baseFee.truncate(GasInt))
|
|
excessBlobGas = calcExcessBlobGas(vmState.parent)
|
|
|
|
roDB.validateTransaction(
|
|
tx, item.sender, gasLimit, baseFee, excessBlobGas, fork).isOk
|
|
|
|
proc classifyPacked(vmState: BaseVMState; moreBurned: GasInt): bool =
|
|
## Classifier for *packing* (i.e. adding up `gasUsed` values after executing
|
|
## in the VM.) This function checks whether the sum of the arguments
|
|
## `gasBurned` and `moreGasBurned` is within acceptable constraints.
|
|
let totalGasUsed = vmState.cumulativeGasUsed + moreBurned
|
|
totalGasUsed < vmState.blockCtx.gasLimit
|
|
|
|
proc classifyPackedNext(vmState: BaseVMState): bool =
|
|
## Classifier for *packing* (i.e. adding up `gasUsed` values after executing
|
|
## in the VM.) This function returns `true` if the packing level is still
|
|
## low enough to proceed trying to accumulate more items.
|
|
##
|
|
## This function is typically called as a follow up after a `false` return of
|
|
## `classifyPack()`.
|
|
vmState.cumulativeGasUsed < vmState.blockCtx.gasLimit
|
|
|
|
func baseFee(pst: TxPacker): GasInt =
|
|
## Getter, baseFee for the next bock header. This value is auto-generated
|
|
## when a new insertion point is set via `head=`.
|
|
if pst.vmState.blockCtx.baseFeePerGas.isSome:
|
|
pst.vmState.blockCtx.baseFeePerGas.get.truncate(GasInt)
|
|
else:
|
|
0.GasInt
|
|
|
|
func feeRecipient(pst: TxPacker): EthAddress =
|
|
pst.vmState.com.pos.feeRecipient
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Private functions
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc runTx(pst: var TxPacker; item: TxItemRef): GasInt =
|
|
## Execute item transaction and update `vmState` book keeping. Returns the
|
|
## `gasUsed` after executing the transaction.
|
|
let
|
|
baseFee = pst.baseFee
|
|
|
|
let gasUsed = item.tx.txCallEvm(item.sender, pst.vmState, baseFee)
|
|
pst.cleanState = false
|
|
doAssert 0 <= gasUsed
|
|
gasUsed
|
|
|
|
proc runTxCommit(pst: var TxPacker; item: TxItemRef; gasBurned: GasInt)
|
|
{.gcsafe,raises: [CatchableError].} =
|
|
## Book keeping after executing argument `item` transaction in the VM. The
|
|
## function returns the next number of items `nItems+1`.
|
|
let
|
|
vmState = pst.vmState
|
|
inx = pst.txDB.byStatus.eq(txItemPacked).nItems
|
|
gasTip = item.tx.effectiveGasTip(pst.baseFee)
|
|
|
|
# The gas tip cannot get negative as all items in the `staged` bucket
|
|
# are vetted for profitability before entering that bucket.
|
|
assert 0 <= gasTip
|
|
let reward = gasBurned.u256 * gasTip.u256
|
|
vmState.stateDB.addBalance(pst.feeRecipient, reward)
|
|
pst.blockValue += reward
|
|
|
|
# Save accounts via persist() is not needed unless the fork is smaller
|
|
# than `FkByzantium` in which case, the `rootHash()` function is called
|
|
# by `makeReceipt()`. As the `rootHash()` function asserts unconditionally
|
|
# that the account cache has been saved, the `persist()` call is
|
|
# obligatory here.
|
|
if vmState.fork < FkByzantium:
|
|
pst.persist()
|
|
|
|
# Update receipts sequence
|
|
if vmState.receipts.len <= inx:
|
|
vmState.receipts.setLen(inx + receiptsExtensionSize)
|
|
|
|
# Return remaining gas to the block gas counter so it is
|
|
# available for the next transaction.
|
|
vmState.gasPool += item.tx.gasLimit - gasBurned
|
|
|
|
# gasUsed accounting
|
|
vmState.cumulativeGasUsed += gasBurned
|
|
vmState.receipts[inx] = vmState.makeReceipt(item.tx.txType)
|
|
|
|
# Update txRoot
|
|
pst.tr.merge(rlp.encode(inx.uint64), rlp.encode(item.tx)).isOkOr:
|
|
raiseAssert "runTxCommit(): merge failed, " & $$error
|
|
|
|
# Add the item to the `packed` bucket. This implicitely increases the
|
|
# receipts index `inx` at the next visit of this function.
|
|
discard pst.txDB.reassign(item,txItemPacked)
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Private functions: packer packerVmExec() helpers
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc vmExecInit(xp: TxPoolRef): Result[TxPacker, string]
|
|
{.gcsafe,raises: [CatchableError].} =
|
|
|
|
# Flush `packed` bucket
|
|
xp.bucketFlushPacked
|
|
|
|
let packer = TxPacker(
|
|
vmState: xp.vmState,
|
|
txDB: xp.txDB,
|
|
tr: AristoDbMemory.newCoreDbRef().ctx.getGeneric(clearData=true),
|
|
numBlobPerBlock: 0,
|
|
blockValue: 0.u256,
|
|
txRoot: EMPTY_ROOT_HASH,
|
|
stateRoot: xp.vmState.parent.stateRoot,
|
|
)
|
|
|
|
# EIP-4788
|
|
if xp.nextFork >= FkCancun:
|
|
let beaconRoot = xp.vmState.com.pos.parentBeaconBlockRoot
|
|
xp.vmState.processBeaconBlockRoot(beaconRoot).isOkOr:
|
|
return err(error)
|
|
|
|
ok(packer)
|
|
|
|
proc vmExecGrabItem(pst: var TxPacker; item: TxItemRef): GrabResult
|
|
{.gcsafe,raises: [CatchableError].} =
|
|
## Greedily collect & compact items as long as the accumulated `gasLimit`
|
|
## values are below the maximum block size.
|
|
let vmState = pst.vmState
|
|
|
|
if not item.tx.validateChainId(vmState.com.chainId):
|
|
discard pst.txDB.dispose(item, txInfoChainIdMismatch)
|
|
return ContinueWithNextAccount
|
|
|
|
# EIP-4844
|
|
if pst.numBlobPerBlock + item.tx.versionedHashes.len > MAX_BLOBS_PER_BLOCK:
|
|
return ContinueWithNextAccount
|
|
pst.numBlobPerBlock += item.tx.versionedHashes.len
|
|
|
|
# Verify we have enough gas in gasPool
|
|
if vmState.gasPool < item.tx.gasLimit:
|
|
# skip this transaction and
|
|
# continue with next account
|
|
# if we don't have enough gas
|
|
return ContinueWithNextAccount
|
|
vmState.gasPool -= item.tx.gasLimit
|
|
|
|
# Validate transaction relative to the current vmState
|
|
if not vmState.classifyValidatePacked(item):
|
|
return ContinueWithNextAccount
|
|
|
|
# EIP-1153
|
|
vmState.stateDB.clearTransientStorage()
|
|
|
|
let
|
|
accTx = vmState.stateDB.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)
|
|
if vmState.classifyPackedNext():
|
|
return ContinueWithNextAccount
|
|
return StopCollecting
|
|
|
|
# Commit account state DB
|
|
vmState.stateDB.commit(accTx)
|
|
|
|
vmState.stateDB.persist(clearEmptyAccount = vmState.fork >= FkSpurious)
|
|
|
|
# Finish book-keeping and move item to `packed` bucket
|
|
pst.runTxCommit(item, gasUsed)
|
|
|
|
FetchNextItem
|
|
|
|
proc vmExecCommit(pst: var TxPacker) =
|
|
let
|
|
vmState = pst.vmState
|
|
stateDB = vmState.stateDB
|
|
|
|
# EIP-4895
|
|
if vmState.fork >= FkShanghai:
|
|
for withdrawal in vmState.com.pos.withdrawals:
|
|
stateDB.addBalance(withdrawal.address, withdrawal.weiAmount)
|
|
|
|
# Finish up, then vmState.stateDB.rootHash may be accessed
|
|
stateDB.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.txRoot = pst.tr.state(updateOk=true).valueOr:
|
|
raiseAssert "vmExecCommit(): state() failed " & $$error
|
|
pst.stateRoot = vmState.stateDB.rootHash
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Public functions
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc packerVmExec*(xp: TxPoolRef): Result[TxPacker, string]
|
|
{.gcsafe,raises: [CatchableError].} =
|
|
## Rebuild `packed` bucket by selection items from the `staged` bucket
|
|
## after executing them in the VM.
|
|
let db = xp.vmState.com.db
|
|
let dbTx = db.ctx.newTransaction()
|
|
defer: dbTx.dispose()
|
|
|
|
var pst = xp.vmExecInit.valueOr:
|
|
return err(error)
|
|
|
|
block loop:
|
|
for (_,nonceList) in xp.txDB.packingOrderAccounts(txItemStaged):
|
|
|
|
block account:
|
|
for item in nonceList.incNonce:
|
|
let rc = pst.vmExecGrabItem(item)
|
|
if rc == StopCollecting:
|
|
break loop # stop
|
|
if rc == ContinueWithNextAccount:
|
|
break account # continue with next account
|
|
|
|
pst.vmExecCommit()
|
|
ok(pst)
|
|
# Block chain will roll back automatically
|
|
|
|
proc assembleHeader*(pst: TxPacker): BlockHeader =
|
|
## Generate a new header, a child of the cached `head`
|
|
let
|
|
vmState = pst.vmState
|
|
com = vmState.com
|
|
pos = com.pos
|
|
|
|
result = BlockHeader(
|
|
parentHash: vmState.parent.blockHash,
|
|
ommersHash: EMPTY_UNCLE_HASH,
|
|
coinbase: pos.feeRecipient,
|
|
stateRoot: pst.stateRoot,
|
|
transactionsRoot: pst.txRoot,
|
|
receiptsRoot: pst.receiptsRoot,
|
|
logsBloom: pst.logsBloom,
|
|
difficulty: UInt256.zero(),
|
|
number: vmState.blockNumber,
|
|
gasLimit: vmState.blockCtx.gasLimit,
|
|
gasUsed: vmState.cumulativeGasUsed,
|
|
timestamp: pos.timestamp,
|
|
extraData: @[],
|
|
mixHash: pos.prevRandao,
|
|
nonce: default(BlockNonce),
|
|
baseFeePerGas: vmState.blockCtx.baseFeePerGas,
|
|
)
|
|
|
|
if com.isShanghaiOrLater(pos.timestamp):
|
|
result.withdrawalsRoot = Opt.some(calcWithdrawalsRoot(pos.withdrawals))
|
|
|
|
if com.isCancunOrLater(pos.timestamp):
|
|
result.parentBeaconBlockRoot = Opt.some(pos.parentBeaconBlockRoot)
|
|
result.blobGasUsed = Opt.some vmState.blobGasUsed
|
|
result.excessBlobGas = Opt.some vmState.blockCtx.excessBlobGas
|
|
|
|
func blockValue*(pst: TxPacker): UInt256 =
|
|
pst.blockValue
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# End
|
|
# ------------------------------------------------------------------------------
|