From 3c9b6c868db38977cc35810a6aa42484553f1c3a Mon Sep 17 00:00:00 2001 From: tersec Date: Tue, 28 May 2024 11:20:55 +0000 Subject: [PATCH] remove expicit PoW support from tx pool; tighten tx pool exceptions specs --- .../nodocker/engine/engine_env.nim | 2 +- .../nodocker/graphql/graphql_sim.nim | 2 +- hive_integration/nodocker/pyspec/test_env.nim | 5 +- hive_integration/nodocker/rpc/test_env.nim | 2 +- nimbus/core/tx_pool.nim | 78 ++++++------ nimbus/core/tx_pool/tx_chain.nim | 116 +++++++----------- nimbus/core/tx_pool/tx_desc.nim | 41 +++---- nimbus/core/tx_pool/tx_tasks/tx_packer.nim | 7 -- nimbus/nimbus.nim | 2 +- 9 files changed, 107 insertions(+), 148 deletions(-) diff --git a/hive_integration/nodocker/engine/engine_env.nim b/hive_integration/nodocker/engine/engine_env.nim index f148431de1..a95d01860e 100644 --- a/hive_integration/nodocker/engine/engine_env.nim +++ b/hive_integration/nodocker/engine/engine_env.nim @@ -91,7 +91,7 @@ proc newEngineEnv*(conf: var NimbusConf, chainFile: string, enableAuth: bool): E chain = newChain(com) com.initializeEmptyDb() - let txPool = TxPoolRef.new(com, ZERO_ADDRESS) + let txPool = TxPoolRef.new(com) node.addEthHandlerCapability( node.peerPool, diff --git a/hive_integration/nodocker/graphql/graphql_sim.nim b/hive_integration/nodocker/graphql/graphql_sim.nim index 3326b9312b..ba2c919d24 100644 --- a/hive_integration/nodocker/graphql/graphql_sim.nim +++ b/hive_integration/nodocker/graphql/graphql_sim.nim @@ -84,7 +84,7 @@ proc main() = ) com.initializeEmptyDb() - let txPool = TxPoolRef.new(com, ZERO_ADDRESS) + let txPool = TxPoolRef.new(com) discard importRlpBlock(blocksFile, com) let ctx = setupGraphqlContext(com, ethNode, txPool) diff --git a/hive_integration/nodocker/pyspec/test_env.nim b/hive_integration/nodocker/pyspec/test_env.nim index ff91733645..1c418d6525 100644 --- a/hive_integration/nodocker/pyspec/test_env.nim +++ b/hive_integration/nodocker/pyspec/test_env.nim @@ -39,9 +39,6 @@ type rpcServer: RpcHttpServer rpcClient*: RpcHttpClient -const - engineSigner = hexToByteArray[20]("0x658bdf435d810c91414ec09147daa6db62406379") - proc genesisHeader(node: JsonNode): BlockHeader = let genesisRLP = hexToSeqByte(node["genesisRLP"].getStr) rlp.decode(genesisRLP, EthBlock).header @@ -68,7 +65,7 @@ proc setupELClient*(t: TestEnv, conf: ChainConfig, node: JsonNode) = t.com.consensus == ConsensusType.POS) doAssert(t.com.db.getCanonicalHead().blockHash == genesisHeader.blockHash) - let txPool = TxPoolRef.new(t.com, engineSigner) + let txPool = TxPoolRef.new(t.com) t.rpcServer = newRpcHttpServer(["127.0.0.1:8545"]) let beaconEngine = BeaconEngineRef.new(txPool, t.chainRef) diff --git a/hive_integration/nodocker/rpc/test_env.nim b/hive_integration/nodocker/rpc/test_env.nim index da1c0cc2d4..7110b45bb3 100644 --- a/hive_integration/nodocker/rpc/test_env.nim +++ b/hive_integration/nodocker/rpc/test_env.nim @@ -84,7 +84,7 @@ proc setupEnv*(): TestEnv = com.initializeEmptyDb() let chainRef = newChain(com) - let txPool = TxPoolRef.new(com, ZERO_ADDRESS) + let txPool = TxPoolRef.new(com) # txPool must be informed of active head # so it can know the latest account state diff --git a/nimbus/core/tx_pool.nim b/nimbus/core/tx_pool.nim index b4f176505a..419207d034 100644 --- a/nimbus/core/tx_pool.nim +++ b/nimbus/core/tx_pool.nim @@ -504,12 +504,11 @@ proc setHead(xp: TxPoolRef; val: BlockHeader) # Public constructor/destructor # ------------------------------------------------------------------------------ -proc new*(T: type TxPoolRef; com: CommonRef; miner: EthAddress): T +proc new*(T: type TxPoolRef; com: CommonRef): T {.gcsafe,raises: [CatchableError].} = - ## Constructor, returns a new tx-pool descriptor. The `miner` argument is - ## the fee beneficiary for informational purposes only. + ## Constructor, returns a new tx-pool descriptor. new result - result.init(com, miner) + result.init(com) # ------------------------------------------------------------------------------ # Public functions, task manager, pool actions serialiser @@ -594,15 +593,15 @@ proc triggerReorg*(xp: TxPoolRef) # Public functions, getters # ------------------------------------------------------------------------------ -proc com*(xp: TxPoolRef): CommonRef = +func com*(xp: TxPoolRef): CommonRef = ## Getter xp.chain.com -proc baseFee*(xp: TxPoolRef): GasPrice = +func baseFee*(xp: TxPoolRef): GasPrice = ## Getter, this parameter modifies/determines the expected gain when packing xp.chain.baseFee -proc dirtyBuckets*(xp: TxPoolRef): bool = +func dirtyBuckets*(xp: TxPoolRef): bool = ## Getter, bucket database is ready for re-org if the `autoUpdateBucketsDB` ## flag is also set. xp.pDirtyBuckets @@ -669,52 +668,52 @@ proc assembleBlock*( blk: blk, blobsBundle: blobsBundleOpt) -proc gasCumulative*(xp: TxPoolRef): GasInt = +func gasCumulative*(xp: TxPoolRef): GasInt = ## Getter, retrieves the gas that will be burned in the block after ## retrieving it via `ethBlock`. xp.chain.gasUsed -proc gasTotals*(xp: TxPoolRef): TxTabsGasTotals = +func gasTotals*(xp: TxPoolRef): TxTabsGasTotals = ## Getter, retrieves the current gas limit totals per bucket. xp.txDB.gasTotals -proc lwmTrgPercent*(xp: TxPoolRef): int = +func lwmTrgPercent*(xp: TxPoolRef): int = ## Getter, `trgGasLimit` percentage for `lwmGasLimit` which is ## `max(minGasLimit, trgGasLimit * lwmTrgPercent / 100)` xp.chain.lhwm.lwmTrg -proc flags*(xp: TxPoolRef): set[TxPoolFlags] = +func flags*(xp: TxPoolRef): set[TxPoolFlags] = ## Getter, retrieves strategy symbols for how to process items and buckets. xp.pFlags -proc head*(xp: TxPoolRef): BlockHeader = +func head*(xp: TxPoolRef): BlockHeader = ## Getter, cached block chain insertion point. Typocally, this should be the ## the same header as retrieved by the `getCanonicalHead()` (unless in the ## middle of a mining update.) xp.chain.head -proc hwmMaxPercent*(xp: TxPoolRef): int = +func hwmMaxPercent*(xp: TxPoolRef): int = ## Getter, `maxGasLimit` percentage for `hwmGasLimit` which is ## `max(trgGasLimit, maxGasLimit * hwmMaxPercent / 100)` xp.chain.lhwm.hwmMax -proc maxGasLimit*(xp: TxPoolRef): GasInt = +func maxGasLimit*(xp: TxPoolRef): GasInt = ## Getter, hard size limit when packing blocks (see also `trgGasLimit`.) xp.chain.limits.maxLimit # core/tx_pool.go(435): func (pool *TxPool) GasPrice() *big.Int { -proc minFeePrice*(xp: TxPoolRef): GasPrice = +func minFeePrice*(xp: TxPoolRef): GasPrice = ## Getter, retrieves minimum for the current gas fee enforced by the ## transaction pool for txs to be packed. This is an EIP-1559 only ## parameter (see `stage1559MinFee` strategy.) xp.pMinFeePrice -proc minPreLondonGasPrice*(xp: TxPoolRef): GasPrice = +func minPreLondonGasPrice*(xp: TxPoolRef): GasPrice = ## Getter. retrieves, the current gas price enforced by the transaction ## pool. This is a pre-London parameter (see `packedPlMinPrice` strategy.) xp.pMinPlGasPrice -proc minTipPrice*(xp: TxPoolRef): GasPrice = +func minTipPrice*(xp: TxPoolRef): GasPrice = ## Getter, retrieves minimum for the current gas tip (or priority fee) ## enforced by the transaction pool. This is an EIP-1559 parameter but it ## comes with a fall back interpretation (see `stage1559MinTip` strategy.) @@ -725,12 +724,12 @@ proc minTipPrice*(xp: TxPoolRef): GasPrice = # core/tx_pool.go(1728): func (t *txLookup) Count() int { # core/tx_pool.go(1737): func (t *txLookup) LocalCount() int { # core/tx_pool.go(1745): func (t *txLookup) RemoteCount() int { -proc nItems*(xp: TxPoolRef): TxTabsItemsCount = +func nItems*(xp: TxPoolRef): TxTabsItemsCount = ## Getter, retrieves the current number of items per bucket and ## some totals. xp.txDB.nItems -proc profitability*(xp: TxPoolRef): GasPrice = +func profitability*(xp: TxPoolRef): GasPrice = ## Getter, a calculation of the average *price* per gas to be rewarded after ## packing the last block (see `ethBlock`). This *price* is only based on ## execution transaction in the VM without *PoW* specific rewards. The net @@ -741,7 +740,7 @@ proc profitability*(xp: TxPoolRef): GasPrice = else: 0.GasPrice -proc trgGasLimit*(xp: TxPoolRef): GasInt = +func trgGasLimit*(xp: TxPoolRef): GasInt = ## Getter, soft size limit when packing blocks (might be extended to ## `maxGasLimit`) xp.chain.limits.trgLimit @@ -750,8 +749,7 @@ proc trgGasLimit*(xp: TxPoolRef): GasInt = # Public functions, setters # ------------------------------------------------------------------------------ -proc `baseFee=`*(xp: TxPoolRef; val: GasPrice) - {.gcsafe,raises: [KeyError].} = +func `baseFee=`*(xp: TxPoolRef; val: GasPrice) {.raises: [KeyError].} = ## Setter, sets `baseFee` explicitely witout triggering a packer update. ## Stil a database update might take place when updating account ranks. ## @@ -761,7 +759,7 @@ proc `baseFee=`*(xp: TxPoolRef; val: GasPrice) xp.txDB.baseFee = val xp.chain.baseFee = val -proc `lwmTrgPercent=`*(xp: TxPoolRef; val: int) = +func `lwmTrgPercent=`*(xp: TxPoolRef; val: int) = ## Setter, `val` arguments outside `0..100` are ignored if 0 <= val and val <= 100: xp.chain.lhwm = ( @@ -771,11 +769,11 @@ proc `lwmTrgPercent=`*(xp: TxPoolRef; val: int) = gasCeil: xp.chain.lhwm.gasCeil ) -proc `flags=`*(xp: TxPoolRef; val: set[TxPoolFlags]) = +func `flags=`*(xp: TxPoolRef; val: set[TxPoolFlags]) = ## Setter, strategy symbols for how to process items and buckets. xp.pFlags = val -proc `hwmMaxPercent=`*(xp: TxPoolRef; val: int) = +func `hwmMaxPercent=`*(xp: TxPoolRef; val: int) = ## Setter, `val` arguments outside `0..100` are ignored if 0 <= val and val <= 100: xp.chain.lhwm = ( @@ -785,13 +783,13 @@ proc `hwmMaxPercent=`*(xp: TxPoolRef; val: int) = gasCeil: xp.chain.lhwm.gasCeil ) -proc `maxRejects=`*(xp: TxPoolRef; val: int) = +func `maxRejects=`*(xp: TxPoolRef; val: int) = ## Setter, the size of the waste basket. This setting becomes effective with ## the next move of an item into the waste basket. xp.txDB.maxRejects = val # core/tx_pool.go(444): func (pool *TxPool) SetGasPrice(price *big.Int) { -proc `minFeePrice=`*(xp: TxPoolRef; val: GasPrice) = +func `minFeePrice=`*(xp: TxPoolRef; val: GasPrice) = ## Setter for `minFeePrice`. If there was a value change, this function ## implies `triggerReorg()`. if xp.pMinFeePrice != val: @@ -799,7 +797,7 @@ proc `minFeePrice=`*(xp: TxPoolRef; val: GasPrice) = xp.pDirtyBuckets = true # core/tx_pool.go(444): func (pool *TxPool) SetGasPrice(price *big.Int) { -proc `minPreLondonGasPrice=`*(xp: TxPoolRef; val: GasPrice) = +func `minPreLondonGasPrice=`*(xp: TxPoolRef; val: GasPrice) = ## Setter for `minPlGasPrice`. If there was a value change, this function ## implies `triggerReorg()`. if xp.pMinPlGasPrice != val: @@ -807,7 +805,7 @@ proc `minPreLondonGasPrice=`*(xp: TxPoolRef; val: GasPrice) = xp.pDirtyBuckets = true # core/tx_pool.go(444): func (pool *TxPool) SetGasPrice(price *big.Int) { -proc `minTipPrice=`*(xp: TxPoolRef; val: GasPrice) = +func `minTipPrice=`*(xp: TxPoolRef; val: GasPrice) = ## Setter for `minTipPrice`. If there was a value change, this function ## implies `triggerReorg()`. if xp.pMinTipPrice != val: @@ -820,11 +818,11 @@ proc `minTipPrice=`*(xp: TxPoolRef; val: GasPrice) = # core/tx_pool.go(979): func (pool *TxPool) Get(hash common.Hash) .. # core/tx_pool.go(985): func (pool *TxPool) Has(hash common.Hash) bool { -proc getItem*(xp: TxPoolRef; hash: Hash256): Result[TxItemRef,void] = +func getItem*(xp: TxPoolRef; hash: Hash256): Result[TxItemRef,void] = ## Returns a transaction if it is contained in the pool. xp.txDB.byItemID.eq(hash) -proc disposeItems*(xp: TxPoolRef; item: TxItemRef; +func disposeItems*(xp: TxPoolRef; item: TxItemRef; reason = txInfoExplicitDisposal; otherReason = txInfoImpliedDisposal): int {.discardable,gcsafe,raises: [CatchableError].} = @@ -842,10 +840,10 @@ iterator okPairs*(xp: TxPoolRef): (Hash256, TxItemRef) = if x.data.reject == txInfoOk: yield (x.key, x.data) -proc numTxs*(xp: TxPoolRef): int = +func numTxs*(xp: TxPoolRef): int = xp.txDB.byItemID.len -proc disposeAll*(xp: TxPoolRef) {.gcsafe,raises: [CatchableError].} = +func disposeAll*(xp: TxPoolRef) {.raises: [CatchableError].} = let numTx = xp.numTxs var list = newSeqOfCap[TxItemRef](numTx) for x in nextPairs(xp.txDB.byItemID): @@ -857,27 +855,27 @@ proc disposeAll*(xp: TxPoolRef) {.gcsafe,raises: [CatchableError].} = # Public functions, local/remote accounts # ------------------------------------------------------------------------------ -proc isLocal*(xp: TxPoolRef; account: EthAddress): bool = +func isLocal*(xp: TxPoolRef; account: EthAddress): bool = ## This function returns `true` if argument `account` is tagged local. xp.txDB.isLocal(account) -proc setLocal*(xp: TxPoolRef; account: EthAddress) = +func setLocal*(xp: TxPoolRef; account: EthAddress) = ## Tag argument `account` local which means that the transactions from this ## account -- together with all other local accounts -- will be considered ## first for packing. xp.txDB.setLocal(account) -proc resLocal*(xp: TxPoolRef; account: EthAddress) = +func resLocal*(xp: TxPoolRef; account: EthAddress) = ## Untag argument `account` as local which means that the transactions from ## this account -- together with all other untagged accounts -- will be ## considered for packing after the locally tagged accounts. xp.txDB.resLocal(account) -proc flushLocals*(xp: TxPoolRef) = +func flushLocals*(xp: TxPoolRef) = ## Untag all *local* addresses on the system. xp.txDB.flushLocals -proc accountRanks*(xp: TxPoolRef): TxTabsLocality = +func accountRanks*(xp: TxPoolRef): TxTabsLocality = ## Returns two lists, one for local and the other for non-local accounts. ## Any of these lists is sorted by the highest rank first. This sorting ## means that the order may be out-dated after adding transactions. @@ -951,12 +949,12 @@ proc addLocal*(xp: TxPoolRef; xp.add(tx, "local tx") ok() -proc inPoolAndOk*(xp: TxPoolRef; txHash: Hash256): bool = +func inPoolAndOk*(xp: TxPoolRef; txHash: Hash256): bool = let res = xp.getItem(txHash) if res.isErr: return false res.get().reject == txInfoOk -proc inPoolAndReason*(xp: TxPoolRef; txHash: Hash256): Result[void, string] = +func inPoolAndReason*(xp: TxPoolRef; txHash: Hash256): Result[void, string] = let res = xp.getItem(txHash) if res.isErr: # try to look in rejecteds diff --git a/nimbus/core/tx_pool/tx_chain.nim b/nimbus/core/tx_pool/tx_chain.nim index 46b6c25e21..ec4759a24f 100644 --- a/nimbus/core/tx_pool/tx_chain.nim +++ b/nimbus/core/tx_pool/tx_chain.nim @@ -61,7 +61,6 @@ type ## block. This state is typically synchrionised with the canonical\ ## block chain head when updated. com: CommonRef ## Block chain config - miner: EthAddress ## Address of fee beneficiary lhwm: TxChainGasLimitsPc ## Hwm/lwm gas limit percentage maxMode: bool ## target or maximal limit for next block header @@ -73,38 +72,20 @@ type # ------------------------------------------------------------------------------ # Private functions # ------------------------------------------------------------------------------ -proc prepareHeader(dh: TxChainRef; parent: BlockHeader, timestamp: EthTime) - {.gcsafe, raises: [CatchableError].} = - - case dh.com.consensus - of ConsensusType.POW: - dh.prepHeader.timestamp = timestamp - dh.prepHeader.difficulty = dh.com.calcDifficulty( - dh.prepHeader.timestamp, parent) - dh.prepHeader.coinbase = dh.miner - dh.prepHeader.mixDigest.reset - of ConsensusType.POS: - dh.com.pos.prepare(dh.prepHeader) - -proc prepareForSeal(dh: TxChainRef; header: var BlockHeader) {.gcsafe, raises: [].} = - case dh.com.consensus - of ConsensusType.POW: - # do nothing, tx pool was designed with POW in mind - discard - of ConsensusType.POS: - dh.com.pos.prepareForSeal(header) - -proc getTimestamp(dh: TxChainRef, parent: BlockHeader): EthTime = - case dh.com.consensus - of ConsensusType.POW: - EthTime.now() - of ConsensusType.POS: - dh.com.pos.timestamp - -proc feeRecipient*(dh: TxChainRef): EthAddress {.gcsafe.} +func prepareHeader(dh: TxChainRef; parent: BlockHeader, timestamp: EthTime) + {.raises: [].} = + dh.com.pos.prepare(dh.prepHeader) + +func prepareForSeal(dh: TxChainRef; header: var BlockHeader) {.raises: [].} = + dh.com.pos.prepareForSeal(header) + +func getTimestamp(dh: TxChainRef, parent: BlockHeader): EthTime = + dh.com.pos.timestamp + +func feeRecipient*(dh: TxChainRef): EthAddress proc resetTxEnv(dh: TxChainRef; parent: BlockHeader; fee: Option[UInt256]) - {.gcsafe,raises: [CatchableError].} = + {.gcsafe,raises: [].} = dh.txEnv.reset # do hardfork transition before @@ -137,7 +118,7 @@ proc resetTxEnv(dh: TxChainRef; parent: BlockHeader; fee: Option[UInt256]) dh.txEnv.excessBlobGas = none(uint64) proc update(dh: TxChainRef; parent: BlockHeader) - {.gcsafe,raises: [CatchableError].} = + {.gcsafe,raises: [].} = let timestamp = dh.getTimestamp(parent) @@ -158,13 +139,12 @@ proc update(dh: TxChainRef; parent: BlockHeader) # Public functions, constructor # ------------------------------------------------------------------------------ -proc new*(T: type TxChainRef; com: CommonRef; miner: EthAddress): T - {.gcsafe,raises: [CatchableError].} = +proc new*(T: type TxChainRef; com: CommonRef): T + {.gcsafe, raises: [EVMError].} = ## Constructor new result result.com = com - result.miner = miner result.lhwm.lwmTrg = TRG_THRESHOLD_PER_CENT result.lhwm.hwmMax = MAX_THRESHOLD_PER_CENT result.lhwm.gasFloor = DEFAULT_GAS_LIMIT @@ -225,7 +205,7 @@ proc getHeader*(dh: TxChainRef): BlockHeader dh.prepareForSeal(result) proc clearAccounts*(dh: TxChainRef) - {.gcsafe,raises: [CatchableError].} = + {.gcsafe,raises: [].} = ## Reset transaction environment, e.g. before packing a new block dh.resetTxEnv(dh.txEnv.vmState.parent, dh.txEnv.vmState.blockCtx.fee) @@ -233,34 +213,31 @@ proc clearAccounts*(dh: TxChainRef) # Public functions, getters # ------------------------------------------------------------------------------ -proc com*(dh: TxChainRef): CommonRef = +func com*(dh: TxChainRef): CommonRef = ## Getter dh.com -proc head*(dh: TxChainRef): BlockHeader = +func head*(dh: TxChainRef): BlockHeader = ## Getter dh.txEnv.vmState.parent -proc limits*(dh: TxChainRef): TxChainGasLimits = +func limits*(dh: TxChainRef): TxChainGasLimits = ## Getter dh.limits -proc lhwm*(dh: TxChainRef): TxChainGasLimitsPc = +func lhwm*(dh: TxChainRef): TxChainGasLimitsPc = ## Getter dh.lhwm -proc maxMode*(dh: TxChainRef): bool = +func maxMode*(dh: TxChainRef): bool = ## Getter dh.maxMode -proc feeRecipient*(dh: TxChainRef): EthAddress {.gcsafe.} = +func feeRecipient*(dh: TxChainRef): EthAddress = ## Getter - if dh.com.consensus == ConsensusType.POS: - dh.com.pos.feeRecipient - else: - dh.miner + dh.com.pos.feeRecipient -proc baseFee*(dh: TxChainRef): GasPrice = +func baseFee*(dh: TxChainRef): GasPrice = ## Getter, baseFee for the next bock header. This value is auto-generated ## when a new insertion point is set via `head=`. if dh.txEnv.vmState.blockCtx.fee.isSome: @@ -268,41 +245,41 @@ proc baseFee*(dh: TxChainRef): GasPrice = else: 0.GasPrice -proc excessBlobGas*(dh: TxChainRef): uint64 = +func excessBlobGas*(dh: TxChainRef): uint64 = ## Getter, baseFee for the next bock header. This value is auto-generated ## when a new insertion point is set via `head=`. dh.txEnv.excessBlobGas.get(0'u64) -proc nextFork*(dh: TxChainRef): EVMFork = +func nextFork*(dh: TxChainRef): EVMFork = ## Getter, fork of next block dh.com.toEVMFork(dh.txEnv.vmState.forkDeterminationInfoForVMState) -proc gasUsed*(dh: TxChainRef): GasInt = +func gasUsed*(dh: TxChainRef): GasInt = ## Getter, accumulated gas burned for collected blocks if 0 < dh.txEnv.receipts.len: return dh.txEnv.receipts[^1].cumulativeGasUsed -proc profit*(dh: TxChainRef): UInt256 = +func profit*(dh: TxChainRef): UInt256 = ## Getter dh.txEnv.profit -proc receipts*(dh: TxChainRef): seq[Receipt] = +func receipts*(dh: TxChainRef): seq[Receipt] = ## Getter, receipts for collected blocks dh.txEnv.receipts -proc reward*(dh: TxChainRef): UInt256 = +func reward*(dh: TxChainRef): UInt256 = ## Getter, reward for collected blocks dh.txEnv.reward -proc stateRoot*(dh: TxChainRef): Hash256 = +func stateRoot*(dh: TxChainRef): Hash256 = ## Getter, accounting DB state root hash for the next block header dh.txEnv.stateRoot -proc txRoot*(dh: TxChainRef): Hash256 = +func txRoot*(dh: TxChainRef): Hash256 = ## Getter, transaction state root hash for the next block header dh.txEnv.txRoot -proc vmState*(dh: TxChainRef): BaseVMState = +func vmState*(dh: TxChainRef): BaseVMState = ## Getter, `BaseVmState` descriptor based on the current insertion point. dh.txEnv.vmState @@ -310,7 +287,7 @@ proc vmState*(dh: TxChainRef): BaseVMState = # Public functions, setters # ------------------------------------------------------------------------------ -proc `baseFee=`*(dh: TxChainRef; val: GasPrice) = +func `baseFee=`*(dh: TxChainRef; val: GasPrice) = ## Setter, temorarily overwrites parameter until next `head=` update. This ## function would be called in exceptional cases only as this parameter is ## determined by the `head=` update. @@ -320,12 +297,12 @@ proc `baseFee=`*(dh: TxChainRef; val: GasPrice) = dh.txEnv.vmState.blockCtx.fee = UInt256.none() proc `head=`*(dh: TxChainRef; val: BlockHeader) - {.gcsafe,raises: [CatchableError].} = + {.gcsafe,raises: [].} = ## Setter, updates descriptor. This setter re-positions the `vmState` and ## account caches to a new insertion point on the block chain database. dh.update(val) -proc `lhwm=`*(dh: TxChainRef; val: TxChainGasLimitsPc) = +func `lhwm=`*(dh: TxChainRef; val: TxChainGasLimitsPc) = ## Setter, tuple `(lwmTrg,hwmMax)` will allow the packer to continue ## up until the percentage level has been reached of the `trgLimit`, or ## `maxLimit` depending on what has been activated. @@ -336,43 +313,38 @@ proc `lhwm=`*(dh: TxChainRef; val: TxChainGasLimitsPc) = dh.txEnv.vmState.blockCtx.gasLimit = if dh.maxMode: dh.limits.maxLimit else: dh.limits.trgLimit -proc `maxMode=`*(dh: TxChainRef; val: bool) = +func `maxMode=`*(dh: TxChainRef; val: bool) = ## Setter, the packing mode (maximal or target limit) for the next block ## header dh.maxMode = val dh.txEnv.vmState.blockCtx.gasLimit = if dh.maxMode: dh.limits.maxLimit else: dh.limits.trgLimit -proc `miner=`*(dh: TxChainRef; val: EthAddress) = - ## Setter - dh.miner = val - dh.txEnv.vmState.blockCtx.coinbase = val - -proc `profit=`*(dh: TxChainRef; val: UInt256) = +func `profit=`*(dh: TxChainRef; val: UInt256) = ## Setter dh.txEnv.profit = val -proc `receipts=`*(dh: TxChainRef; val: seq[Receipt]) = +func `receipts=`*(dh: TxChainRef; val: seq[Receipt]) = ## Setter, implies `gasUsed` dh.txEnv.receipts = val -proc `reward=`*(dh: TxChainRef; val: UInt256) = +func `reward=`*(dh: TxChainRef; val: UInt256) = ## Getter dh.txEnv.reward = val -proc `stateRoot=`*(dh: TxChainRef; val: Hash256) = +func `stateRoot=`*(dh: TxChainRef; val: Hash256) = ## Setter dh.txEnv.stateRoot = val -proc `txRoot=`*(dh: TxChainRef; val: Hash256) = +func `txRoot=`*(dh: TxChainRef; val: Hash256) = ## Setter dh.txEnv.txRoot = val -proc `excessBlobGas=`*(dh: TxChainRef; val: Option[uint64]) = +func `excessBlobGas=`*(dh: TxChainRef; val: Option[uint64]) = ## Setter dh.txEnv.excessBlobGas = val -proc `blobGasUsed=`*(dh: TxChainRef; val: Option[uint64]) = +func `blobGasUsed=`*(dh: TxChainRef; val: Option[uint64]) = ## Setter dh.txEnv.blobGasUsed = val diff --git a/nimbus/core/tx_pool/tx_desc.nim b/nimbus/core/tx_pool/tx_desc.nim index 44e934aac3..d83bb651d9 100644 --- a/nimbus/core/tx_pool/tx_desc.nim +++ b/nimbus/core/tx_pool/tx_desc.nim @@ -1,5 +1,5 @@ # Nimbus -# Copyright (c) 2018 Status Research & Development GmbH +# 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) @@ -127,13 +127,12 @@ const # Public functions, constructor # ------------------------------------------------------------------------------ -proc init*(xp: TxPoolRef; com: CommonRef; miner: EthAddress) +proc init*(xp: TxPoolRef; com: CommonRef) {.gcsafe,raises: [CatchableError].} = - ## Constructor, returns new tx-pool descriptor. The `miner` argument is - ## the fee beneficiary for informational purposes only. + ## Constructor, returns new tx-pool descriptor. xp.startDate = getTime().utc.toTime - xp.chain = TxChainRef.new(com, miner) + xp.chain = TxChainRef.new(com) xp.txDB = TxTabsRef.new xp.lifeTime = txItemLifeTime @@ -148,40 +147,40 @@ proc init*(xp: TxPoolRef; com: CommonRef; miner: EthAddress) # Public functions, getters # ------------------------------------------------------------------------------ -proc chain*(xp: TxPoolRef): TxChainRef = +func chain*(xp: TxPoolRef): TxChainRef = ## Getter, block chain DB xp.chain -proc pFlags*(xp: TxPoolRef): set[TxPoolFlags] = +func pFlags*(xp: TxPoolRef): set[TxPoolFlags] = ## Returns the set of algorithm strategy symbols for labelling items ## as`packed` xp.param.flags -proc pDirtyBuckets*(xp: TxPoolRef): bool = +func pDirtyBuckets*(xp: TxPoolRef): bool = ## Getter, buckets need update xp.param.dirtyBuckets -proc pDoubleCheck*(xp: TxPoolRef): seq[TxItemRef] = +func pDoubleCheck*(xp: TxPoolRef): seq[TxItemRef] = ## Getter, cached block chain head was moved back xp.param.doubleCheck -proc pMinFeePrice*(xp: TxPoolRef): GasPrice = +func pMinFeePrice*(xp: TxPoolRef): GasPrice = ## Getter xp.param.minFeePrice -proc pMinTipPrice*(xp: TxPoolRef): GasPrice = +func pMinTipPrice*(xp: TxPoolRef): GasPrice = ## Getter xp.param.minTipPrice -proc pMinPlGasPrice*(xp: TxPoolRef): GasPrice = +func pMinPlGasPrice*(xp: TxPoolRef): GasPrice = ## Getter xp.param.minPlGasPrice -proc startDate*(xp: TxPoolRef): Time = +func startDate*(xp: TxPoolRef): Time = ## Getter xp.startDate -proc txDB*(xp: TxPoolRef): TxTabsRef = +func txDB*(xp: TxPoolRef): TxTabsRef = ## Getter, pool database xp.txDB @@ -189,31 +188,31 @@ proc txDB*(xp: TxPoolRef): TxTabsRef = # Public functions, setters # ------------------------------------------------------------------------------ -proc `pDirtyBuckets=`*(xp: TxPoolRef; val: bool) = +func `pDirtyBuckets=`*(xp: TxPoolRef; val: bool) = ## Setter xp.param.dirtyBuckets = val -proc pDoubleCheckAdd*(xp: TxPoolRef; val: seq[TxItemRef]) = +func pDoubleCheckAdd*(xp: TxPoolRef; val: seq[TxItemRef]) = ## Pseudo setter xp.param.doubleCheck.add val -proc pDoubleCheckFlush*(xp: TxPoolRef) = +func pDoubleCheckFlush*(xp: TxPoolRef) = ## Pseudo setter xp.param.doubleCheck.setLen(0) -proc `pFlags=`*(xp: TxPoolRef; val: set[TxPoolFlags]) = +func `pFlags=`*(xp: TxPoolRef; val: set[TxPoolFlags]) = ## Install a set of algorithm strategy symbols for labelling items as`packed` xp.param.flags = val -proc `pMinFeePrice=`*(xp: TxPoolRef; val: GasPrice) = +func `pMinFeePrice=`*(xp: TxPoolRef; val: GasPrice) = ## Setter xp.param.minFeePrice = val -proc `pMinTipPrice=`*(xp: TxPoolRef; val: GasPrice) = +func `pMinTipPrice=`*(xp: TxPoolRef; val: GasPrice) = ## Setter xp.param.minTipPrice = val -proc `pMinPlGasPrice=`*(xp: TxPoolRef; val: GasPrice) = +func `pMinPlGasPrice=`*(xp: TxPoolRef; val: GasPrice) = ## Setter xp.param.minPlGasPrice = val diff --git a/nimbus/core/tx_pool/tx_tasks/tx_packer.nim b/nimbus/core/tx_pool/tx_tasks/tx_packer.nim index 75d0d69745..e1ec855be1 100644 --- a/nimbus/core/tx_pool/tx_tasks/tx_packer.nim +++ b/nimbus/core/tx_pool/tx_tasks/tx_packer.nim @@ -249,13 +249,6 @@ proc vmExecCommit(pst: TxPackerStateRef) for withdrawal in xp.chain.com.pos.withdrawals: vmState.stateDB.addBalance(withdrawal.address, withdrawal.weiAmount) - # EIP-3675: no reward for miner in POA/POS - if vmState.com.consensus == ConsensusType.POW: - let - number = xp.chain.head.blockNumber + 1 - uncles: seq[BlockHeader] = @[] # no uncles yet - vmState.calculateReward(xp.chain.feeRecipient, number + 1, uncles) - # Reward beneficiary vmState.mutateStateDB: if vmState.generateWitness: diff --git a/nimbus/nimbus.nim b/nimbus/nimbus.nim index 89e07500fb..441cdccf5a 100644 --- a/nimbus/nimbus.nim +++ b/nimbus/nimbus.nim @@ -47,7 +47,7 @@ proc importBlocks(conf: NimbusConf, com: CommonRef) = proc basicServices(nimbus: NimbusNode, conf: NimbusConf, com: CommonRef) = - nimbus.txPool = TxPoolRef.new(com, ZERO_ADDRESS) + nimbus.txPool = TxPoolRef.new(com) # txPool must be informed of active head # so it can know the latest account state