878 lines
30 KiB
Nim
878 lines
30 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.
|
|
|
|
import
|
|
std/[algorithm, random, sequtils, strformat, strutils, tables, times],
|
|
../nimbus/core/chain, # must be early (compilation annoyance)
|
|
../nimbus/common/common,
|
|
../nimbus/core/[casper, tx_pool, tx_pool/tx_item],
|
|
../nimbus/config,
|
|
./test_txpool/[helpers, setup, sign_helper],
|
|
chronos,
|
|
eth/[keys, p2p],
|
|
stew/[keyed_queue, sorted_set],
|
|
stint,
|
|
unittest2
|
|
|
|
const
|
|
prngSeed = 42
|
|
|
|
# 75% <= #local/#remote <= 1/75%
|
|
# note: by law of big numbers, the ratio will exceed any upper or lower
|
|
# on a +1/-1 random walk if running long enough (with expectation
|
|
# value 0)
|
|
randInitRatioBandPC = 75
|
|
|
|
# 95% <= #remote-deleted/#remote-present <= 1/95%
|
|
deletedItemsRatioBandPC = 95
|
|
|
|
# With a large enough block size, decreasing it should not decrease the
|
|
# profitability (very much) as the number of blocks availabe increases
|
|
# (and a better choice might be available?) A good value for the next
|
|
# parameter should be above 100%.
|
|
decreasingBlockProfitRatioPC = 92
|
|
|
|
# Make some percentage of the accounts local accouns.
|
|
accountExtractPC = 10
|
|
|
|
var
|
|
minGasPrice = GasPrice.high
|
|
maxGasPrice = GasPrice.low
|
|
|
|
prng = prngSeed.initRand
|
|
|
|
# To be set up in runTxLoader()
|
|
statCount: array[TxItemStatus,int] # per status bucket
|
|
|
|
txList: seq[TxItemRef]
|
|
effGasTips: seq[GasPrice]
|
|
|
|
# Running block chain
|
|
bcCom: CommonRef
|
|
|
|
# Accounts to be considered local
|
|
localAccounts: seq[Address]
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Helpers
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc randStatusRatios: seq[int] =
|
|
for n in 1 .. statCount.len:
|
|
let
|
|
inx = (n mod statCount.len).TxItemStatus
|
|
prv = (n - 1).TxItemStatus
|
|
if statCount[inx] == 0:
|
|
result.add int.high
|
|
else:
|
|
result.add (statCount[prv] * 100 / statCount[inx]).int
|
|
|
|
proc randStatus: TxItemStatus =
|
|
result = prng.rand(TxItemStatus.high.ord).TxItemStatus
|
|
statCount[result].inc
|
|
|
|
template wrapException(info: string; action: untyped) =
|
|
try:
|
|
action
|
|
except CatchableError:
|
|
raiseAssert info & " has problems: " & getCurrentExceptionMsg()
|
|
|
|
proc addOrFlushGroupwise(xp: TxPoolRef;
|
|
grpLen: int; seen: var seq[TxItemRef]; w: TxItemRef;
|
|
noisy = true): bool =
|
|
# to be run as call back inside `itemsApply()`
|
|
wrapException("addOrFlushGroupwise()"):
|
|
seen.add w
|
|
if grpLen <= seen.len:
|
|
# clear waste basket
|
|
discard xp.txDB.flushRejects
|
|
|
|
# flush group-wise
|
|
let xpLen = xp.nItems.total
|
|
noisy.say "*** updateSeen: deleting ", seen.mapIt($it.itemID).join(" ")
|
|
for item in seen:
|
|
doAssert xp.txDB.dispose(item,txInfoErrUnspecified)
|
|
doAssert xpLen == seen.len + xp.nItems.total
|
|
doAssert seen.len == xp.nItems.disposed
|
|
seen.setLen(0)
|
|
|
|
# clear waste basket
|
|
discard xp.txDB.flushRejects
|
|
|
|
return true
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Test Runners
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc runTxLoader() =
|
|
# Reset/initialise
|
|
statCount.reset
|
|
txList.reset
|
|
effGasTips.reset
|
|
|
|
suite "TxPool: Transactions from file capture":
|
|
var
|
|
xp: TxPoolRef
|
|
nTxs: int
|
|
|
|
test "Import txs for pooling":
|
|
(bcCom, xp, nTxs) = setupTxPool(randStatus)
|
|
|
|
# Extract some of the least profitable accounts and hold them so
|
|
# they could be made local at a later stage
|
|
let
|
|
accr = xp.accountRanks
|
|
nExtract = (accr.remote.len * accountExtractPC + 50) div 100
|
|
localAccounts = accr.remote[accr.remote.len - nExtract .. ^1]
|
|
|
|
# Make sure that sample extraction from file was ok
|
|
check nTxs == xp.nItems.total
|
|
|
|
# Set txs to pseudo random status
|
|
check xp.verify.isOk
|
|
xp.setItemStatusFromInfo
|
|
|
|
# Boundary conditions regarding nonces might be violated by running
|
|
# setItemStatusFromInfo() => xp.txDB.verify() rather than xp.verify()
|
|
check xp.txDB.verify.isOk
|
|
|
|
check txList.len == 0
|
|
check xp.nItems.disposed == 0
|
|
|
|
#noisy.say "***",
|
|
# "Latest item: <", xp.txDB.byItemID.last.value.data.info, ">"
|
|
|
|
check xp.nItems.total == foldl(@[0]&statCount.toSeq, a+b)
|
|
# ^^^ sum up statCount[] values
|
|
|
|
# make sure that PRNG did not go bonkers
|
|
for statusRatio in randStatusRatios():
|
|
check randInitRatioBandPC < statusRatio
|
|
check statusRatio < (10000 div randInitRatioBandPC)
|
|
|
|
# Load txList[]
|
|
txList = xp.toItems
|
|
check txList.len == xp.nItems.total
|
|
|
|
for item in txList:
|
|
if item.tx.gasPrice.GasPrice < minGasPrice and 0 < item.tx.gasPrice:
|
|
minGasPrice = item.tx.gasPrice.GasPrice
|
|
if maxGasPrice < item.tx.gasPrice.GasPrice:
|
|
maxGasPrice = item.tx.gasPrice.GasPrice
|
|
|
|
check 0.GasPrice <= minGasPrice
|
|
check minGasPrice <= maxGasPrice
|
|
|
|
proc runTxPoolTests(noisy = false) =
|
|
let elapNoisy = false
|
|
|
|
suite "TxPool: Play with pool functions and primitives":
|
|
|
|
block:
|
|
const groupLen = 13
|
|
let veryNoisy = noisy and false
|
|
|
|
test "Load/forward walk ID queue, deleting groups of at most {groupLen}":
|
|
var
|
|
xq = bcCom.toTxPool(txList, noisy = noisy)
|
|
seen: seq[TxItemRef]
|
|
|
|
# Set txs to pseudo random status
|
|
xq.setItemStatusFromInfo
|
|
|
|
check xq.txDB.verify.isOk
|
|
elapNoisy.showElapsed("Forward delete-walk ID queue"):
|
|
for item in xq.txDB.byItemID.nextValues:
|
|
if not xq.addOrFlushGroupwise(groupLen, seen, item, veryNoisy):
|
|
break
|
|
check xq.txDB.verify.isOk
|
|
check seen.len == xq.nItems.total
|
|
check seen.len < groupLen
|
|
|
|
test &"Load/reverse walk ID queue, " &
|
|
&"deleting in groups of at most {groupLen}":
|
|
var
|
|
xq = bcCom.toTxPool(txList, noisy = noisy)
|
|
seen: seq[TxItemRef]
|
|
|
|
# Set txs to pseudo random status
|
|
xq.setItemStatusFromInfo
|
|
|
|
check xq.txDB.verify.isOk
|
|
elapNoisy.showElapsed("Revese delete-walk ID queue"):
|
|
for item in xq.txDB.byItemID.nextValues:
|
|
if not xq.addOrFlushGroupwise(groupLen, seen, item, veryNoisy):
|
|
break
|
|
check xq.txDB.verify.isOk
|
|
check seen.len == xq.nItems.total
|
|
check seen.len < groupLen
|
|
|
|
block:
|
|
var
|
|
xq = TxPoolRef.new(bcCom)
|
|
testTxs: array[5,(TxItemRef,Transaction,Transaction)]
|
|
|
|
test "Superseding txs with sender and nonce variants":
|
|
var
|
|
testInx = 0
|
|
let
|
|
testBump = xq.priceBump
|
|
lastBump = testBump - 1 # implies underpriced item
|
|
|
|
# load a set of suitable txs into testTxs[]
|
|
for n in 0 ..< txList.len:
|
|
let
|
|
item = txList[n]
|
|
bump = if testInx < testTxs.high: testBump else: lastBump
|
|
rc = item.txModPair(testInx,bump.int)
|
|
if not rc[0].isNil:
|
|
testTxs[testInx] = rc
|
|
testInx.inc
|
|
if testTxs.high < testInx:
|
|
break
|
|
|
|
# verify that test does not degenerate
|
|
check testInx == testTxs.len
|
|
check 0 < lastBump # => 0 < testBump
|
|
|
|
# insert some txs
|
|
for triple in testTxs:
|
|
xq.add(PooledTransaction(tx: triple[1]), triple[0].info)
|
|
|
|
check xq.nItems.total == testTxs.len
|
|
check xq.nItems.disposed == 0
|
|
let infoLst = testTxs.toSeq.mapIt(it[0].info).sorted
|
|
check infoLst == xq.toItems.toSeq.mapIt(it.info).sorted
|
|
|
|
# re-insert modified transactions
|
|
for triple in testTxs:
|
|
xq.add(PooledTransaction(tx: triple[2]), "alt " & triple[0].info)
|
|
|
|
check xq.nItems.total == testTxs.len
|
|
check xq.nItems.disposed == testTxs.len
|
|
|
|
if false: # Temporarily disabled, see `supersede` in `tx_add.nim`
|
|
# last update item was underpriced, so it must not have been
|
|
# replaced
|
|
var altLst = testTxs.toSeq.mapIt("alt " & it[0].info)
|
|
altLst[^1] = testTxs[^1][0].info
|
|
check altLst.sorted == xq.toItems.toSeq.mapIt(it.info).sorted
|
|
|
|
test "Deleting tx => also delete higher nonces":
|
|
|
|
let
|
|
# From the data base, get the one before last item. This was
|
|
# replaced earlier by the second transaction in the triple, i.e.
|
|
# testTxs[^2][2]. FYI, the last transaction is testTxs[^1][1] as
|
|
# it could not be replaced earlier by testTxs[^1][2].
|
|
item = xq.getItem(testTxs[^2][2].itemID).value
|
|
|
|
nWasteBasket = xq.nItems.disposed
|
|
|
|
# make sure the test makes sense, nonces were 0 ..< testTxs.len
|
|
check (item.tx.nonce + 2).int == testTxs.len
|
|
|
|
xq.disposeItems(item)
|
|
|
|
check xq.nItems.total + 2 == testTxs.len
|
|
check nWasteBasket + 2 == xq.nItems.disposed
|
|
|
|
# --------------------------
|
|
|
|
block:
|
|
var
|
|
gap: Time
|
|
nItems: int
|
|
xq = bcCom.toTxPool(timeGap = gap,
|
|
nGapItems = nItems,
|
|
itList = txList,
|
|
itemsPC = 35, # arbitrary
|
|
delayMSecs = 100, # large enough to process
|
|
noisy = noisy)
|
|
|
|
# Set txs to pseudo random status. Note that this functon will cause
|
|
# a violation of boundary conditions regarding nonces. So database
|
|
# integrily check needs xq.txDB.verify() rather than xq.verify().
|
|
xq.setItemStatusFromInfo
|
|
|
|
test &"Auto delete about {nItems} expired txs out of {xq.nItems.total}":
|
|
|
|
# Make sure that the test did not collapse
|
|
check 0 < nItems
|
|
xq.lifeTime = getTime() - gap
|
|
xq.flags = xq.flags + {autoZombifyPacked}
|
|
|
|
# Evict and pick items from the wastbasket
|
|
let
|
|
disposedBase = xq.nItems.disposed
|
|
evictedBase = evictionMeter.value
|
|
impliedBase = impliedEvictionMeter.value
|
|
|
|
# Zombify the items that are older than the artificial time gap. The
|
|
# move to the waste basket takes place with the `xq.add()` directive
|
|
# (which is empty as there are no new txs.)
|
|
xq.add @[]
|
|
|
|
let
|
|
disposedItems = xq.nItems.disposed - disposedBase
|
|
evictedItems = (evictionMeter.value - evictedBase).int
|
|
impliedItems = (impliedEvictionMeter.value - impliedBase).int
|
|
|
|
check xq.txDB.verify.isOk
|
|
check disposedItems + disposedBase + xq.nItems.total == txList.len
|
|
check 0 < evictedItems
|
|
check evictedItems <= disposedItems
|
|
check disposedItems == evictedItems + impliedItems
|
|
|
|
# make sure that deletion was sort of expected
|
|
let deleteExpextRatio = (evictedItems * 100 / nItems).int
|
|
check deletedItemsRatioBandPC < deleteExpextRatio
|
|
check deleteExpextRatio < (10000 div deletedItemsRatioBandPC)
|
|
|
|
# --------------------
|
|
|
|
block:
|
|
var
|
|
xq = bcCom.toTxPool(txList, noisy = noisy)
|
|
maxAddr: Address
|
|
nAddrItems = 0
|
|
|
|
nAddrPendingItems = 0
|
|
nAddrStagedItems = 0
|
|
nAddrPackedItems = 0
|
|
|
|
fromNumItems = nAddrPendingItems
|
|
fromBucketInfo = "pending"
|
|
fromBucket = txItemPending
|
|
toBucketInfo = "staged"
|
|
toBucket = txItemStaged
|
|
|
|
# Set txs to pseudo random status
|
|
xq.setItemStatusFromInfo
|
|
|
|
# find address with max number of transactions
|
|
for (address,nonceList) in xq.txDB.incAccount:
|
|
if nAddrItems < nonceList.nItems:
|
|
maxAddr = address
|
|
nAddrItems = nonceList.nItems
|
|
|
|
# count items
|
|
nAddrPendingItems = xq.txDB.bySender.eq(maxAddr).eq(txItemPending).nItems
|
|
nAddrStagedItems = xq.txDB.bySender.eq(maxAddr).eq(txItemStaged).nItems
|
|
nAddrPackedItems = xq.txDB.bySender.eq(maxAddr).eq(txItemPacked).nItems
|
|
|
|
# find the largest from-bucket
|
|
if fromNumItems < nAddrStagedItems:
|
|
fromNumItems = nAddrStagedItems
|
|
fromBucketInfo = "staged"
|
|
fromBucket = txItemStaged
|
|
toBucketInfo = "packed"
|
|
toBucket = txItemPacked
|
|
if fromNumItems < nAddrPackedItems:
|
|
fromNumItems = nAddrPackedItems
|
|
fromBucketInfo = "packed"
|
|
fromBucket = txItemPacked
|
|
toBucketInfo = "pending"
|
|
toBucket = txItemPending
|
|
|
|
let moveNumItems = fromNumItems div 2
|
|
|
|
test &"Reassign {moveNumItems} of {fromNumItems} items "&
|
|
&"from \"{fromBucketInfo}\" to \"{toBucketInfo}\"":
|
|
|
|
# requite mimimum => there is a status queue with at least 2 entries
|
|
check 3 < nAddrItems
|
|
|
|
check nAddrPendingItems +
|
|
nAddrStagedItems +
|
|
nAddrPackedItems == nAddrItems
|
|
|
|
check 0 < moveNumItems
|
|
check 1 < fromNumItems
|
|
|
|
var count = 0
|
|
let nonceList = xq.txDB.bySender.eq(maxAddr).eq(fromBucket).value.data
|
|
block collect:
|
|
for item in nonceList.incNonce:
|
|
count.inc
|
|
check xq.txDB.reassign(item, toBucket)
|
|
if moveNumItems <= count:
|
|
break collect
|
|
check xq.txDB.verify.isOk
|
|
|
|
case fromBucket
|
|
of txItemPending:
|
|
check nAddrPendingItems - moveNumItems ==
|
|
xq.txDB.bySender.eq(maxAddr).eq(txItemPending).nItems
|
|
check nAddrStagedItems + moveNumItems ==
|
|
xq.txDB.bySender.eq(maxAddr).eq(txItemStaged).nItems
|
|
check nAddrPackedItems ==
|
|
xq.txDB.bySender.eq(maxAddr).eq(txItemPacked).nItems
|
|
of txItemStaged:
|
|
check nAddrStagedItems - moveNumItems ==
|
|
xq.txDB.bySender.eq(maxAddr).eq(txItemStaged).nItems
|
|
check nAddrPackedItems + moveNumItems ==
|
|
xq.txDB.bySender.eq(maxAddr).eq(txItemPacked).nItems
|
|
check nAddrPendingItems ==
|
|
xq.txDB.bySender.eq(maxAddr).eq(txItemPending).nItems
|
|
else:
|
|
check nAddrPackedItems - moveNumItems ==
|
|
xq.txDB.bySender.eq(maxAddr).eq(txItemPacked).nItems
|
|
check nAddrPendingItems + moveNumItems ==
|
|
xq.txDB.bySender.eq(maxAddr).eq(txItemPending).nItems
|
|
check nAddrStagedItems ==
|
|
xq.txDB.bySender.eq(maxAddr).eq(txItemStaged).nItems
|
|
|
|
# --------------------
|
|
|
|
let expect = (
|
|
xq.txDB.byStatus.eq(txItemPending).nItems,
|
|
xq.txDB.byStatus.eq(txItemStaged).nItems,
|
|
xq.txDB.byStatus.eq(txItemPacked).nItems)
|
|
|
|
test &"Verify #items per bucket ({expect[0]},{expect[1]},{expect[2]})":
|
|
let status = xq.nItems
|
|
check expect == (status.pending,status.staged,status.packed)
|
|
|
|
test "Recycling from waste basket":
|
|
|
|
let
|
|
basketPrefill = xq.nItems.disposed
|
|
numDisposed = min(50,txList.len)
|
|
|
|
# make sure to work on a copy of the pivot item (to see changes)
|
|
thisItem = xq.getItem(txList[^numDisposed].itemID).value.dup
|
|
|
|
# move to wastebasket
|
|
xq.maxRejects = txList.len
|
|
for n in 1 .. numDisposed:
|
|
# use from top avoiding extra deletes (higer nonces per account)
|
|
xq.disposeItems(txList[^n])
|
|
|
|
# make sure that the pivot item is in the waste basket
|
|
check xq.getItem(thisItem.itemID).isErr
|
|
check xq.txDB.byRejects.hasKey(thisItem.itemID)
|
|
check basketPrefill + numDisposed == xq.nItems.disposed
|
|
check txList.len == xq.nItems.total + xq.nItems.disposed
|
|
|
|
# re-add item
|
|
xq.add(thisItem.pooledTx)
|
|
|
|
# verify that the pivot item was moved out from the waste basket
|
|
check not xq.txDB.byRejects.hasKey(thisItem.itemID)
|
|
check basketPrefill + numDisposed == xq.nItems.disposed + 1
|
|
check txList.len == xq.nItems.total + xq.nItems.disposed
|
|
|
|
# verify that a new item was derived from the waste basket pivot item
|
|
let wbItem = xq.getItem(thisItem.itemID).value
|
|
check thisItem.info == wbItem.info
|
|
check thisItem.timeStamp < wbItem.timeStamp
|
|
|
|
proc runTxPackerTests(noisy = true) =
|
|
suite "TxPool: Block packer tests":
|
|
var
|
|
ntBaseFee = 0.GasPrice
|
|
ntNextFee = 0.GasPrice
|
|
|
|
test "Calculate some non-trivial base fee":
|
|
var
|
|
feesList = SortedSet[GasPrice,bool].init()
|
|
|
|
# provide a sorted list of gas fees
|
|
for item in txList:
|
|
discard feesList.insert(item.tx.effectiveGasTip(0.GasPrice))
|
|
|
|
let
|
|
minKey = max(0, feesList.ge(GasPrice.low).value.key.int64)
|
|
lowKey = feesList.gt(minKey.GasPrice).value.key.uint64
|
|
highKey = feesList.le(GasPrice.high).value.key.uint64
|
|
keyRange = highKey - lowKey
|
|
keyStep = max(1u64, keyRange div 500_000)
|
|
|
|
# what follows is a rather crude partitioning so that
|
|
# * ntBaseFee partititions non-zero numbers of pending and staged txs
|
|
# * ntNextFee decreases the number of staged txs
|
|
ntBaseFee = (lowKey + keyStep).GasPrice
|
|
|
|
# the following might throw an exception if the table is de-generated
|
|
var nextKey = ntBaseFee
|
|
for _ in [1, 2, 3]:
|
|
let rcNextKey = feesList.gt(nextKey.GasPrice)
|
|
check rcNextKey.isOk
|
|
nextKey = rcNextKey.value.key.uint64.GasPrice
|
|
|
|
ntNextFee = nextKey + keyStep.GasPrice
|
|
|
|
# of course ...
|
|
check ntBaseFee < ntNextFee
|
|
|
|
block:
|
|
var
|
|
xq = bcCom.toTxPool(txList, ntBaseFee, noisy = noisy)
|
|
xr = bcCom.toTxPool(txList, ntNextFee, noisy = noisy)
|
|
block:
|
|
let
|
|
pending = xq.nItems.pending
|
|
staged = xq.nItems.staged
|
|
packed = xq.nItems.packed
|
|
|
|
test &"Load txs with baseFee={ntBaseFee}, "&
|
|
&"buckets={pending}/{staged}/{packed}":
|
|
|
|
check 0 < pending
|
|
check 0 < staged
|
|
check xq.nItems.total == txList.len
|
|
check xq.nItems.disposed == 0
|
|
|
|
block:
|
|
let
|
|
pending = xr.nItems.pending
|
|
staged = xr.nItems.staged
|
|
packed = xr.nItems.packed
|
|
|
|
test &"Re-org txs previous buckets setting baseFee={ntNextFee}, "&
|
|
&"buckets={pending}/{staged}/{packed}":
|
|
|
|
check 0 < pending
|
|
check 0 < staged
|
|
check xr.nItems.total == txList.len
|
|
check xr.nItems.disposed == 0
|
|
|
|
# having the same set of txs, setting the xq database to the same
|
|
# base fee as the xr one, the bucket fills of both database must
|
|
# be the same after re-org
|
|
xq.baseFee = ntNextFee
|
|
xq.triggerReorg
|
|
|
|
# now, xq should look like xr
|
|
check xq.verify.isOk
|
|
check xq.nItems == xr.nItems
|
|
|
|
block:
|
|
# get some value below the middle
|
|
let
|
|
packPrice = ((minGasPrice + maxGasPrice).uint64 div 3).GasPrice
|
|
lowerPrice = minGasPrice + 1.GasPrice
|
|
|
|
test &"Packing txs, baseFee=0 minPrice={packPrice} "&
|
|
&"targetBlockSize={xq.trgGasLimit}":
|
|
|
|
# verify that the test does not degenerate
|
|
check 0 < minGasPrice
|
|
check minGasPrice < maxGasPrice
|
|
|
|
# ignore base limit so that the `packPrice` below becomes effective
|
|
xq.baseFee = 0.GasPrice
|
|
check xq.nItems.disposed == 0
|
|
|
|
# set minimum target price
|
|
xq.minPreLondonGasPrice = packPrice
|
|
check xq.minPreLondonGasPrice == packPrice
|
|
|
|
# employ packer
|
|
# xq.jobCommit(forceMaintenance = true)
|
|
check xq.packerVmExec.isOk
|
|
check xq.verify.isOk
|
|
|
|
# verify that the test did not degenerate
|
|
check 0 < xq.gasTotals.packed
|
|
check xq.nItems.disposed == 0
|
|
|
|
# assemble block from `packed` bucket
|
|
let
|
|
items = xq.toItems(txItemPacked)
|
|
total = foldl(@[0.GasInt] & items.mapIt(it.tx.gasLimit), a+b)
|
|
check xq.gasTotals.packed == total
|
|
|
|
noisy.say "***", "1st bLock size=", total, " stats=", xq.nItems.pp
|
|
|
|
test &"Clear and re-pack bucket":
|
|
# prepare for POS transition in txpool
|
|
xq.chain.com.pos.timestamp = EthTime.now()
|
|
|
|
let
|
|
items0 = xq.toItems(txItemPacked)
|
|
saveState0 = foldl(@[0.GasInt] & items0.mapIt(it.tx.gasLimit), a+b)
|
|
check 0 < xq.nItems.packed
|
|
|
|
# re-pack bucket
|
|
#xq.jobCommit(forceMaintenance = true)
|
|
check xq.packerVmExec.isOk
|
|
check xq.verify.isOk
|
|
|
|
let
|
|
items1 = xq.toItems(txItemPacked)
|
|
saveState1 = foldl(@[0.GasInt] & items1.mapIt(it.tx.gasLimit), a+b)
|
|
check items0 == items1
|
|
check saveState0 == saveState1
|
|
|
|
test &"Delete item and re-pack bucket/w lower minPrice={lowerPrice}":
|
|
# verify that the test does not degenerate
|
|
check 0 < lowerPrice
|
|
check lowerPrice < packPrice
|
|
check 0 < xq.nItems.packed
|
|
|
|
let
|
|
saveStats = xq.nItems
|
|
lastItem = xq.toItems(txItemPacked)[^1]
|
|
|
|
# delete last item from packed bucket
|
|
xq.disposeItems(lastItem)
|
|
check xq.verify.isOk
|
|
|
|
# set new minimum target price
|
|
xq.minPreLondonGasPrice = lowerPrice
|
|
check xq.minPreLondonGasPrice == lowerPrice
|
|
|
|
# re-pack bucket, packer needs extra trigger because there is
|
|
# not necessarily a buckets re-org resulting in a change
|
|
#xq.jobCommit(forceMaintenance = true)
|
|
check xq.packerVmExec.isOk
|
|
check xq.verify.isOk
|
|
|
|
let
|
|
items = xq.toItems(txItemPacked)
|
|
newTotal = foldl(@[0.GasInt] & items.mapIt(it.tx.gasLimit), a+b)
|
|
newStats = xq.nItems
|
|
newItem = xq.toItems(txItemPacked)[^1]
|
|
|
|
# for sanity assert the obvoius
|
|
check 0 < xq.gasTotals.packed
|
|
check xq.gasTotals.packed == newTotal
|
|
|
|
# verify incremental packing
|
|
check lastItem.info != newItem.info
|
|
check saveStats.packed >= newStats.packed
|
|
|
|
noisy.say "***", "2st bLock size=", newTotal, " stats=", newStats.pp
|
|
|
|
# -------------------------------------------------
|
|
|
|
# After we wired ForkedChainRef with TxPool, we can
|
|
# try to enable these test
|
|
|
|
#[block:
|
|
var
|
|
xq = bcCom.toTxPool(txList, ntBaseFee,
|
|
local = localAccounts,
|
|
noisy = noisy)
|
|
|
|
test "Assemble few blocks so we can backtrack":
|
|
let w = xq.chain.com.db.getCanonicalHead
|
|
let c = bcCom.newChain(extraValidation = false)
|
|
|
|
var count = 0
|
|
while true:
|
|
let r = xq.assembleBlock()
|
|
if r.isErr:
|
|
break
|
|
|
|
let blk = r.get.blk
|
|
check c.persistBlocks([blk]).isOk
|
|
|
|
check xq.smartHead(blk.header)
|
|
inc count
|
|
if count >= 2:
|
|
break
|
|
|
|
# make sure we generate some block
|
|
check count > 0
|
|
|
|
let
|
|
(nMinTxs, nTrgTxs) = (15, 15)
|
|
(nMinAccounts, nTrgAccounts) = (1, 8)
|
|
canonicalHead = xq.chain.com.db.getCanonicalHead
|
|
|
|
test &"Back track block chain head (at least "&
|
|
&"{nMinTxs} txs, {nMinAccounts} known accounts)":
|
|
|
|
# get the environment of a state back in the block chain, preferably
|
|
# at least `nTrgTxs` txs and `nTrgAccounts` known accounts
|
|
let
|
|
(backHeader,backTxs,accLst) = xq.getBackHeader(nTrgTxs,nTrgAccounts)
|
|
nBackBlocks = xq.head.number - backHeader.number
|
|
stats = xq.nItems
|
|
|
|
# verify that the test would not degenerate
|
|
check nMinAccounts <= accLst.len
|
|
check nMinTxs <= backTxs.len
|
|
|
|
noisy.say "***",
|
|
&"back tracked block chain:" &
|
|
&" {backTxs.len} txs, {nBackBlocks} blocks," &
|
|
&" {accLst.len} known accounts"
|
|
|
|
check xq.smartHead(backHeader) # move insertion point
|
|
|
|
# make sure that all txs have been added to the pool
|
|
check stats.disposed == 0
|
|
check stats.total + backTxs.len == xq.nItems.total
|
|
|
|
test &"Run packer, profitability will not increase with block size":
|
|
|
|
xq.flags = xq.flags - {packItemsMaxGasLimit}
|
|
check xq.packerVmExec.isOk
|
|
let
|
|
smallerBlockProfitability = xq.profitability
|
|
smallerBlockSize = xq.gasCumulative
|
|
|
|
noisy.say "***", "trg-packing",
|
|
" profitability=", xq.profitability,
|
|
" used=", xq.gasCumulative,
|
|
" trg=", xq.trgGasLimit,
|
|
" slack=", xq.trgGasLimit - xq.gasCumulative
|
|
|
|
xq.flags = xq.flags + {packItemsMaxGasLimit}
|
|
check xq.packerVmExec.isOk
|
|
|
|
noisy.say "***", "max-packing",
|
|
" profitability=", xq.profitability,
|
|
" used=", xq.gasCumulative,
|
|
" max=", xq.maxGasLimit,
|
|
" slack=", xq.maxGasLimit - xq.gasCumulative
|
|
|
|
check smallerBlockSize <= xq.gasCumulative
|
|
check 0 < xq.profitability
|
|
|
|
# Well, this ratio should be above 100 but might be slightly less
|
|
# with small data samples (pathological case.)
|
|
let blockProfitRatio =
|
|
(((smallerBlockProfitability.uint64 * 1000) div
|
|
(max(1u64,xq.profitability.uint64))) + 5) div 10
|
|
check decreasingBlockProfitRatioPC <= blockProfitRatio
|
|
|
|
noisy.say "***", "cmp",
|
|
" increase=", xq.gasCumulative - smallerBlockSize,
|
|
" trg/max=", blockProfitRatio, "%"
|
|
|
|
# if true: return
|
|
test "Store generated block in block chain database":
|
|
|
|
noisy.say "***", "locality",
|
|
" locals=", xq.accountRanks.local.len,
|
|
" remotes=", xq.accountRanks.remote.len
|
|
|
|
# Force maximal block size. Accidentally, the latest tx should have
|
|
# a `gasLimit` exceeding the available space on the block `gasLimit`
|
|
# which will be checked below.
|
|
xq.flags = xq.flags #+ {packItemsMaxGasLimit}
|
|
|
|
# Invoke packer
|
|
let r = xq.assembleBlock()
|
|
if r.isErr:
|
|
debugEcho r.error
|
|
check false
|
|
return
|
|
|
|
let blk = r.get.blk
|
|
# Make sure that there are at least two txs on the packed block so
|
|
# this test does not degenerate.
|
|
check 1 < xq.chain.receipts.len
|
|
|
|
var overlap = -1
|
|
for n in countDown(blk.txs.len - 1, 0):
|
|
let total = xq.chain.receipts[n].cumulativeGasUsed
|
|
if blk.header.gasUsed < total + blk.txs[n].gasLimit:
|
|
overlap = n
|
|
break
|
|
|
|
noisy.say "***",
|
|
"overlap=#", overlap,
|
|
" tx=#", blk.txs.len,
|
|
" gasUsed=", blk.header.gasUsed,
|
|
" gasLimit=", blk.header.gasLimit
|
|
|
|
if 0 <= overlap:
|
|
let
|
|
n = overlap
|
|
mostlySize = xq.chain.receipts[n].cumulativeGasUsed
|
|
noisy.say "***", "overlap",
|
|
" size=", mostlySize + blk.txs[n].gasLimit - blk.header.gasUsed
|
|
|
|
let
|
|
bdy = BlockBody(transactions: blk.txs, withdrawals: blk.withdrawals)
|
|
hdr = block:
|
|
var rc = blk.header
|
|
rc.gasLimit = blk.header.gasLimit
|
|
rc.testKeySign
|
|
|
|
# Make certain that some tx was set up so that its gasLimit overlaps
|
|
# with the total block size. Of course, running it in the VM will burn
|
|
# much less than permitted so this block will be accepted.
|
|
check 0 < overlap
|
|
|
|
setTraceLevel()
|
|
|
|
# Test low-level function for adding the new block to the database
|
|
#xq.chain.maxMode = (packItemsMaxGasLimit in xq.flags)
|
|
xq.chain.clearAccounts
|
|
check xq.chain.vmState.processBlock(EthBlock.init(hdr, bdy)).isOk
|
|
|
|
setErrorLevel()
|
|
|
|
# Re-allocate using VM environment from `persistBlocks()`
|
|
let res = BaseVMState.new(hdr, bcCom)
|
|
check res.isOk
|
|
let vmState2 = res.get
|
|
check vmState2.processBlock(EthBlock.init(hdr, bdy)).isOk
|
|
|
|
# This should not have changed
|
|
check canonicalHead == xq.chain.com.db.getCanonicalHead
|
|
|
|
# Using the high-level library function, re-append the block while
|
|
# turning off header verification.
|
|
let c = bcCom.newChain(extraValidation = false)
|
|
|
|
check c.persistBlocks([EthBlock.init(hdr, bdy)]).isOk
|
|
|
|
if bcCom.consensus == ConsensusType.POS:
|
|
# PoS consensus will force the new blockheader as head
|
|
# even though the difficulty or the blocknumber is lower than
|
|
# previous canonical head
|
|
check hdr.blockHash == xq.chain.com.db.getCanonicalHead.blockHash
|
|
|
|
# Is the withdrawals persisted and loaded properly?
|
|
var blockBody: BlockBody
|
|
check xq.chain.com.db.getBlockBody(hdr, blockBody)
|
|
check bdy == blockBody
|
|
else:
|
|
# The canonical head will be set to hdr if it scores high enough
|
|
# (see implementation of db_chain.persistHeader()).
|
|
let
|
|
canonScore = xq.chain.com.db.getScore(canonicalHead.blockHash)
|
|
headerScore = xq.chain.com.db.getScore(hdr.blockHash)
|
|
|
|
check canonScore.isSome
|
|
check headerScore.isSome
|
|
|
|
if canonScore.get < headerScore.get:
|
|
# Note that the updated canonical head is equivalent to hdr but not
|
|
# necessarily binary equal.
|
|
check hdr.blockHash == xq.chain.com.db.getCanonicalHead.blockHash
|
|
else:
|
|
check canonicalHead == xq.chain.com.db.getCanonicalHead]#
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Main function(s)
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc txPoolMain*() =
|
|
runTxLoader()
|
|
runTxPoolTests()
|
|
runTxPackerTests()
|
|
|
|
when isMainModule:
|
|
txPoolMain()
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# End
|
|
# ------------------------------------------------------------------------------
|