status-im
/
nimbus-eth1
mirror of https://github.com/status-im/nimbus-eth1.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

move poa and pow from ChainRef to CommonRef

This commit is contained in:
jangko 2022-12-05 18:25:44 +07:00
parent 53e71e8837
commit b81511fcfc
No known key found for this signature in database
GPG Key ID: 31702AE10541E6B9
14 changed files with 160 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
nimbus/common/common.nim
View File

@ -16,7 +16,8 @@ import
./evmforks,
./genesis,
../utils/[utils, ec_recover],
../db/[db_chain, storage_types]
../db/[db_chain, storage_types],
../core/[pow, clique]
export
chain_config,
@ -65,13 +66,27 @@ type
# one of POW/POA/POS, updated after calling `hardForkTransition`
consensusType: ConsensusType
pow: PowRef ##\
## Wrapper around `hashimotoLight()` and lookup cache
poa: Clique ##\
## For non-PoA networks this descriptor is ignored.
# ------------------------------------------------------------------------------
# Private helper functions
# Forward declarations
# ------------------------------------------------------------------------------
proc hardForkTransition*(com: CommonRef,
number: BlockNumber, td: Option[DifficultyInt]) {.gcsafe.}
func cliquePeriod*(com: CommonRef): int
func cliqueEpoch*(com: CommonRef): int
# ------------------------------------------------------------------------------
# Private helper functions
# ------------------------------------------------------------------------------
proc consensusTransition(com: CommonRef, fork: HardFork) =
if fork >= MergeFork:
com.consensusType = ConsensusType.POS
@ -124,6 +139,13 @@ proc init(com : CommonRef,
com.currentFork, com.db.db)
com.setForkId(com.genesisHeader)
# Initalise the PoA state regardless of whether it is needed on the current
# network. For non-PoA networks this descriptor is ignored.
com.poa = newClique(com.db, com.cliquePeriod, com.cliqueEpoch)
# Always initialise the PoW epoch cache even though it migh no be used
com.pow = PowRef.new
# ------------------------------------------------------------------------------
# Public constructors
# ------------------------------------------------------------------------------
@ -226,8 +248,10 @@ proc hardForkTransition*(com: CommonRef, parentHash: Hash256,
number: BlockNumber)
{.gcsafe, raises: [Defect, CatchableError].} =
# if mergeForkBlock is present, it has higher
# priority than TTD
if com.config.mergeForkBlock.isSome or
com.config.terminalTotalDifficulty.isSome:
com.config.terminalTotalDifficulty.isNone:
let fork = com.toHardFork(number)
com.currentFork = fork
com.consensusTransition(fork)
@ -325,6 +349,13 @@ proc initializeEmptyDb*(com: CommonRef)
# ------------------------------------------------------------------------------
# Getters
# ------------------------------------------------------------------------------
proc poa*(com: CommonRef): Clique =
## Getter
com.poa
proc pow*(com: CommonRef): PowRef =
## Getter
com.pow
func db*(com: CommonRef): ChainDBRef =
com.db

46
nimbus/core/chain/chain_desc.nim
View File

@ -38,58 +38,31 @@ type
## First block to when `extraValidation` will be applied (only
## effective if `extraValidation` is true.)
pow: PowRef ##\
## Wrapper around `hashimotoLight()` and lookup cache
poa: Clique ##\
## For non-PoA networks (when `db.config.poaEngine` is `false`),
## this descriptor is ignored.
{.push raises: [Defect].}
# ------------------------------------------------------------------------------
# Private constructor helper
# ------------------------------------------------------------------------------
proc initChain(c: ChainRef; com: CommonRef; poa: Clique; extraValidation: bool)
proc initChain(c: ChainRef; com: CommonRef; extraValidation: bool)
{.gcsafe, raises: [Defect,CatchableError].} =
## Constructor for the `Chain` descriptor object. For most applications,
## the `poa` argument is transparent and should be initilaised on the fly
## which is available below.
## Constructor for the `Chain` descriptor object.
c.com = com
c.validateBlock = true
c.extraValidation = extraValidation
# Initalise the PoA state regardless of whether it is needed on the current
# network. For non-PoA networks (when `db.config.poaEngine` is `false`),
# this descriptor is ignored.
c.poa = com.newClique
# Always initialise the PoW epoch cache even though it migh no be used
# unless `extraValidation` is set `true`.
c.pow = PowRef.new
# ------------------------------------------------------------------------------
# Public constructors
# ------------------------------------------------------------------------------
proc newChain*(com: CommonRef; poa: Clique; extraValidation: bool): ChainRef
{.gcsafe, raises: [Defect,CatchableError].} =
## Constructor for the `Chain` descriptor object. For most applications,
## the `poa` argument is transparent and should be initilaised on the fly
## which is available below. The argument `extraValidation` enables extra
## block chain validation if set `true`.
new result
result.initChain(com, poa, extraValidation)
proc newChain*(com: CommonRef, extraValidation: bool): ChainRef
{.gcsafe, raises: [Defect,CatchableError].} =
## Constructor for the `Chain` descriptor object with default initialisation
## for the PoA handling. The argument `extraValidation` enables extra block
## Constructor for the `Chain` descriptor object.
## The argument `extraValidation` enables extra block
## chain validation if set `true`.
new result
result.initChain(com, com.newClique, extraValidation)
result.initChain(com, extraValidation)
proc newChain*(com: CommonRef): ChainRef
{.gcsafe, raises: [Defect,CatchableError].} =
@ -98,19 +71,18 @@ proc newChain*(com: CommonRef): ChainRef
## * `enabled` for PoA networks (such as Goerli)
## * `disabled` for non-PaA networks
new result
result.initChain(com, com.newClique, com.consensus == ConsensusType.POA)
result.initChain(com, com.consensus == ConsensusType.POA)
# ------------------------------------------------------------------------------
# Public `Chain` getters
# ------------------------------------------------------------------------------
proc clique*(c: ChainRef): var Clique =
proc clique*(c: ChainRef): Clique =
## Getter
c.poa
c.com.poa
proc pow*(c: ChainRef): PowRef =
## Getter
c.pow
c.com.pow
proc db*(c: ChainRef): ChainDBRef =
## Getter

3
nimbus/core/chain/persist_blocks.nim
View File

@ -11,6 +11,7 @@
import
../../vm_state,
../../vm_types,
../clique/clique_verify,
../clique,
../executor,
../validate,
@ -96,7 +97,7 @@ proc persistBlocksImpl(c: ChainRef; headers: openArray[BlockHeader];
if c.com.consensus == ConsensusType.POA:
var parent = if 0 < i: @[headers[i-1]] else: @[]
let rc = c.clique.cliqueVerify(header,parent)
let rc = c.clique.cliqueVerify(c.com, header,parent)
if rc.isOk:
# mark it off so it would not auto-restore previous state
c.clique.cliqueDispose(cliqueState)

75
nimbus/core/clique.nim
View File

@ -19,8 +19,8 @@
##
import
std/[sequtils, times],
./clique/[clique_cfg, clique_defs, clique_desc, clique_verify],
std/[times],
./clique/[clique_cfg, clique_defs, clique_desc],
./clique/snapshot/[ballot, snapshot_desc],
stew/results
@ -44,7 +44,7 @@ type
# Public
# ------------------------------------------------------------------------------
proc newClique*(com: CommonRef): Clique =
proc newClique*(db: ChainDBRef, cliquePeriod, cliqueEpoch: int): Clique =
## Constructor for a new Clique proof-of-authority consensus engine. The
## initial state of the engine is `empty`, there are no authorised signers.
##
@ -52,20 +52,20 @@ proc newClique*(com: CommonRef): Clique =
## will be taken from chain_config. Otherwise, default value in `newCliqueCfg`
## will be used
let cfg = com.newCliqueCfg
if com.cliquePeriod > 0:
cfg.period = initDuration(seconds = com.cliquePeriod)
if com.cliqueEpoch > 0:
cfg.epoch = com.cliqueEpoch
let cfg = db.newCliqueCfg
if cliquePeriod > 0:
cfg.period = initDuration(seconds = cliquePeriod)
if cliqueEpoch > 0:
cfg.epoch = cliqueEpoch
cfg.newClique
proc cliqueSave*(c: var Clique): CliqueState =
proc cliqueSave*(c: Clique): CliqueState =
## Save current `Clique` state. This state snapshot saves the internal
## data that make up the list of authorised signers (see `cliqueSigners()`
## below.)
ok(c.snapshot)
proc cliqueRestore*(c: var Clique; state: var CliqueState) =
proc cliqueRestore*(c: Clique; state: var CliqueState) =
## Restore current `Clique` state from a saved snapshot.
##
## For the particular `state` argument this fuction is disabled with
@ -74,7 +74,7 @@ proc cliqueRestore*(c: var Clique; state: var CliqueState) =
if state.isOk:
c.snapshot = state.value
proc cliqueDispose*(c: var Clique; state: var CliqueState) =
proc cliqueDispose*(c: Clique; state: var CliqueState) =
## Disable the function `cliqueDispose()` for the particular `state`
## argument.
##
@ -82,59 +82,6 @@ proc cliqueDispose*(c: var Clique; state: var CliqueState) =
## `cliqueRestore()` was wrapped in a `defer:` statement.
state = err(CliqueState)
proc cliqueVerify*(c: Clique; header: BlockHeader;
parents: openArray[BlockHeader]): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## Check whether a header conforms to the consensus rules. The caller may
## optionally pass on a batch of parents (ascending order) to avoid looking
## those up from the database. This function updates the list of authorised
## signers (see `cliqueSigners()` below.)
##
## On success, the latest authorised signers list is available via the
## fucntion `c.cliqueSigners()`. Otherwise, the latest error is also stored
## in the `Clique` descriptor and is accessible as `c.failed`.
##
## This function is not transaction-save, that is the internal state of
## the authorised signers list has the state of the last update after a
## successful header verification. The hash of the failing header together
## with the error message is then accessible as `c.failed`.
##
## Use the directives `cliqueSave()`, `cliqueDispose()`, and/or
## `cliqueRestore()` for transaction.
var list = toSeq(parents)
c.cliqueVerifySeq(header, list)
# clique/clique.go(217): func (c *Clique) VerifyHeader(chain [..]
proc cliqueVerify*(c: Clique; header: BlockHeader): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## Consensus rules verifier without optional parents list.
var blind: seq[BlockHeader]
c.cliqueVerifySeq(header, blind)
proc cliqueVerify*(c: Clique;
headers: openArray[BlockHeader]): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## This function verifies a batch of headers checking each header for
## consensus rules conformance (see also the other `cliqueVerify()` function
## instance.) The `headers` list is supposed to contain a chain of headers,
## i.e. `headers[i]` is parent to `headers[i+1]`.
##
## On success, the latest authorised signers list is available via the
## fucntion `c.cliqueSigners()`. Otherwise, the latest error is also stored
## in the `Clique` descriptor and is accessible as `c.failed`.
##
## This function is not transaction-save, that is the internal state of
## the authorised signers list has the state of the last update after a
## successful header verification. The hash of the failing header together
## with the error message is then accessible as `c.failed`.
##
## Use the directives `cliqueSave()`, `cliqueDispose()`, and/or
## `cliqueRestore()` for transaction.
var list = toSeq(headers)
c.cliqueVerifySeq(list)
proc cliqueSigners*(c: Clique): seq[EthAddress] {.inline.} =
## Retrieve the sorted list of authorized signers for the current state
## of the `Clique` descriptor.

12
nimbus/core/clique/clique_cfg.nim
View File

@ -22,20 +22,20 @@ import
std/[random, times],
ethash,
stew/results,
../../common/common,
../../db/db_chain,
../../utils/ec_recover,
./clique_defs
export
common
db_chain
const
prngSeed = 42
type
CliqueCfg* = ref object of RootRef
com*: CommonRef ##\
## Configuration, database.
db*: ChainDBRef ##\
## All purpose (incl. blockchain) database.
nSnaps*: uint64 ##\
## Number of snapshots stored on disk (for logging troublesshoting)
@ -79,9 +79,9 @@ type
# Public constructor
# ------------------------------------------------------------------------------
proc newCliqueCfg*(com: CommonRef): CliqueCfg =
proc newCliqueCfg*(db: ChainDBRef): CliqueCfg =
result = CliqueCfg(
com: com,
db: db,
epoch: EPOCH_LENGTH,
period: BLOCK_PERIOD,
ckpInterval: CHECKPOINT_INTERVAL,

8
nimbus/core/clique/clique_desc.nim
View File

@ -159,9 +159,9 @@ proc cfg*(c: Clique): CliqueCfg =
## Getter
c.cfg
proc com*(c: Clique): CommonRef =
proc db*(c: Clique): ChainDBRef =
## Getter
c.cfg.com
c.cfg.db
proc applySnapsMinBacklog*(c: Clique): bool =
## Getter.
@ -180,9 +180,9 @@ proc applySnapsMinBacklog*(c: Clique): bool =
# Public setters
# ------------------------------------------------------------------------------
proc `com=`*(c: Clique; com: CommonRef) =
proc `db=`*(c: Clique; db: ChainDBRef) =
## Setter, re-set database
c.cfg.com = com
c.cfg.db = db
c.proposals = initTable[EthAddress,bool]()
proc `snapshot=`*(c: Clique; snaps: Snapshot) =

2
nimbus/core/clique/clique_genvote.nim
View File

@ -198,7 +198,7 @@ proc cliqueGenvote*(
## [..]
##
c.clique_genvote(voter, seal,
parent = c.cfg.com.db.getCanonicalHead,
parent = c.cfg.db.getCanonicalHead,
elapsed = elapsed,
voteInOk = voteInOk,
outOfTurn = outOfTurn,

15
nimbus/core/clique/clique_sealer.nim
View File

@ -22,8 +22,9 @@ import
std/[sequtils, times],
chronicles,
chronos,
eth/[common, keys, rlp],
eth/[keys, rlp],
"../.."/[constants, utils/ec_recover],
../../common/common,
./clique_cfg,
./clique_defs,
./clique_desc,
@ -53,18 +54,18 @@ template syncExceptionWrap(action: untyped) =
# clique/clique.go(217): func (c *Clique) VerifyHeader(chain [..]
proc verifyHeader(c: Clique; header: BlockHeader): CliqueOkResult
proc verifyHeader(c: Clique; com: CommonRef; header: BlockHeader): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## See `clique.cliqueVerify()`
var blind: seq[BlockHeader]
c.cliqueVerifySeq(header, blind)
c.cliqueVerifySeq(com, header, blind)
proc verifyHeader(c: Clique; header: BlockHeader;
proc verifyHeader(c: Clique; com: CommonRef; header: BlockHeader;
parents: openArray[BlockHeader]): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## See `clique.cliqueVerify()`
var list = toSeq(parents)
c.cliqueVerifySeq(header, list)
c.cliqueVerifySeq(com, header, list)
proc isValidVote(s: Snapshot; a: EthAddress; authorize: bool): bool =
@ -118,7 +119,7 @@ proc author*(c: Clique; header: BlockHeader): Result[EthAddress,UtilsError]
# clique/clique.go(224): func (c *Clique) VerifyHeader(chain [..]
proc verifyHeaders*(c: Clique; headers: openArray[BlockHeader]):
proc verifyHeaders*(c: Clique; com: CommonRef; headers: openArray[BlockHeader]):
Future[seq[CliqueOkResult]] {.async,gcsafe.} =
## For the Consensus Engine, `verifyHeader()` s similar to VerifyHeader, but
## verifies a batch of headers concurrently. This method is accompanied
@ -136,7 +137,7 @@ proc verifyHeaders*(c: Clique; headers: openArray[BlockHeader]):
if isStopRequest:
result.add cliqueResultErr((errCliqueStopped,""))
break
result.add c.verifyHeader(headers[n], headers[0 ..< n])
result.add c.verifyHeader(com, headers[n], headers[0 ..< n])
c.doExclusively:
c.stopVHeaderReq = false

4
nimbus/core/clique/clique_snapshot.nim
View File

@ -221,7 +221,7 @@ proc findSnapshot(d: var LocalSnaps): bool
return false
# No explicit parents (or no more parents left), reach out to the database
elif not d.c.cfg.com.db.getBlockHeader(hash, header):
elif not d.c.cfg.db.getBlockHeader(hash, header):
d.trail.error = (errUnknownAncestor,"")
return false
@ -377,7 +377,7 @@ proc cliqueSnapshotSeq*(c: Clique; hash: Hash256;
return ok(rc.value)
var header: BlockHeader
if not c.cfg.com.db.getBlockHeader(hash, header):
if not c.cfg.db.getBlockHeader(hash, header):
return err((errUnknownHash,""))
# Avoid deep copy, sequence will not be changed by `updateSnapshot()`

93
nimbus/core/clique/clique_verify.nim
View File

@ -21,8 +21,9 @@
##
import
std/[strformat, times],
std/[strformat, times, sequtils],
../../utils/utils,
../../common/common,
../gaslimit,
./clique_cfg,
./clique_defs,
@ -43,17 +44,17 @@ logScope:
# ------------------------------------------------------------------------------
# consensus/misc/forks.go(30): func VerifyForkHashes(config [..]
proc verifyForkHashes(c: Clique; header: BlockHeader): CliqueOkResult
proc verifyForkHashes(com: CommonRef; header: BlockHeader): CliqueOkResult
{.gcsafe, raises: [Defect,ValueError].} =
## Verify that blocks conforming to network hard-forks do have the correct
## hashes, to avoid clients going off on different chains.
if c.com.eip150Block.isSome and
c.com.eip150Block.get == header.blockNumber:
if com.eip150Block.isSome and
com.eip150Block.get == header.blockNumber:
# If the homestead reprice hash is set, validate it
let
eip150 = c.com.eip150Hash
eip150 = com.eip150Hash
hash = header.blockHash
if eip150 != hash:
@ -138,7 +139,7 @@ proc verifySeal(c: Clique; header: BlockHeader): CliqueOkResult
# clique/clique.go(314): func (c *Clique) verifyCascadingFields(chain [..]
proc verifyCascadingFields(c: Clique; header: BlockHeader;
proc verifyCascadingFields(c: Clique; com: CommonRef; header: BlockHeader;
parents: var seq[BlockHeader]): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## Verify all the header fields that are not standalone, rather depend on a
@ -154,7 +155,7 @@ proc verifyCascadingFields(c: Clique; header: BlockHeader;
var parent: BlockHeader
if 0 < parents.len:
parent = parents[^1]
elif not c.com.db.getBlockHeader(header.blockNumber-1, parent):
elif not c.db.getBlockHeader(header.blockNumber-1, parent):
return err((errUnknownAncestor,""))
if parent.blockNumber != header.blockNumber-1 or
@ -177,7 +178,7 @@ proc verifyCascadingFields(c: Clique; header: BlockHeader;
# EIP-1559/London fork.
block:
# clique/clique.go(337): if !chain.Config().IsLondon(header.Number) {
let rc = c.com.validateGasLimitOrBaseFee(header, parent)
let rc = com.validateGasLimitOrBaseFee(header, parent)
if rc.isErr:
return err((errCliqueGasLimitOrBaseFee, rc.error))
@ -264,7 +265,7 @@ proc verifyHeaderFields(c: Clique; header: BlockHeader): CliqueOkResult
# clique/clique.go(246): func (c *Clique) verifyHeader(chain [..]
proc cliqueVerifyImpl*(c: Clique; header: BlockHeader;
proc cliqueVerifyImpl(c: Clique; com: CommonRef; header: BlockHeader;
parents: var seq[BlockHeader]): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## Check whether a header conforms to the consensus rules. The caller may
@ -282,21 +283,17 @@ proc cliqueVerifyImpl*(c: Clique; header: BlockHeader;
block:
# If all checks passed, validate any special fields for hard forks
let rc = c.verifyForkHashes(header)
let rc = com.verifyForkHashes(header)
if rc.isErr:
c.failed = (header.blockHash, rc.error)
return err(rc.error)
# All basic checks passed, verify cascading fields
result = c.verifyCascadingFields(header, parents)
result = c.verifyCascadingFields(com, header, parents)
if result.isErr:
c.failed = (header.blockHash, result.error)
# ------------------------------------------------------------------------------
# Public function
# ------------------------------------------------------------------------------
proc cliqueVerifySeq*(c: Clique; header: BlockHeader;
proc cliqueVerifySeq*(c: Clique; com: CommonRef; header: BlockHeader;
parents: var seq[BlockHeader]): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## Check whether a header conforms to the consensus rules. The caller may
@ -312,7 +309,7 @@ proc cliqueVerifySeq*(c: Clique; header: BlockHeader;
## descriptor and can be retrieved via `c.failed` along with the hash/ID of
## the failed block header.
block:
let rc = c.cliqueVerifyImpl(header, parents)
let rc = c.cliqueVerifyImpl(com, header, parents)
if rc.isErr:
return rc
@ -325,8 +322,7 @@ proc cliqueVerifySeq*(c: Clique; header: BlockHeader;
ok()
proc cliqueVerifySeq*(c: Clique;
proc cliqueVerifySeq(c: Clique; com: CommonRef;
headers: var seq[BlockHeader]): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## This function verifies a batch of headers checking each header for
@ -348,13 +344,13 @@ proc cliqueVerifySeq*(c: Clique;
block:
var blind: seq[BlockHeader]
let rc = c.cliqueVerifyImpl(headers[0],blind)
let rc = c.cliqueVerifyImpl(com, headers[0],blind)
if rc.isErr:
return rc
for n in 1 ..< headers.len:
var parent = headers[n-1 .. n-1] # is actually a single item squence
let rc = c.cliqueVerifyImpl(headers[n],parent)
let rc = c.cliqueVerifyImpl(com, headers[n],parent)
if rc.isErr:
return rc
@ -367,6 +363,61 @@ proc cliqueVerifySeq*(c: Clique;
ok()
# ------------------------------------------------------------------------------
# Public functions
# ------------------------------------------------------------------------------
proc cliqueVerify*(c: Clique; com: CommonRef; header: BlockHeader;
parents: openArray[BlockHeader]): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## Check whether a header conforms to the consensus rules. The caller may
## optionally pass on a batch of parents (ascending order) to avoid looking
## those up from the database. This function updates the list of authorised
## signers (see `cliqueSigners()` below.)
##
## On success, the latest authorised signers list is available via the
## fucntion `c.cliqueSigners()`. Otherwise, the latest error is also stored
## in the `Clique` descriptor and is accessible as `c.failed`.
##
## This function is not transaction-save, that is the internal state of
## the authorised signers list has the state of the last update after a
## successful header verification. The hash of the failing header together
## with the error message is then accessible as `c.failed`.
##
## Use the directives `cliqueSave()`, `cliqueDispose()`, and/or
## `cliqueRestore()` for transaction.
var list = toSeq(parents)
c.cliqueVerifySeq(com, header, list)
# clique/clique.go(217): func (c *Clique) VerifyHeader(chain [..]
proc cliqueVerify*(c: Clique; com: CommonRef; header: BlockHeader): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## Consensus rules verifier without optional parents list.
var blind: seq[BlockHeader]
c.cliqueVerifySeq(com, header, blind)
proc cliqueVerify*(c: Clique; com: CommonRef;
headers: openArray[BlockHeader]): CliqueOkResult
{.gcsafe, raises: [Defect,CatchableError].} =
## This function verifies a batch of headers checking each header for
## consensus rules conformance (see also the other `cliqueVerify()` function
## instance.) The `headers` list is supposed to contain a chain of headers,
## i.e. `headers[i]` is parent to `headers[i+1]`.
##
## On success, the latest authorised signers list is available via the
## fucntion `c.cliqueSigners()`. Otherwise, the latest error is also stored
## in the `Clique` descriptor and is accessible as `c.failed`.
##
## This function is not transaction-save, that is the internal state of
## the authorised signers list has the state of the last update after a
## successful header verification. The hash of the failing header together
## with the error message is then accessible as `c.failed`.
##
## Use the directives `cliqueSave()`, `cliqueDispose()`, and/or
## `cliqueRestore()` for transaction.
var list = toSeq(headers)
c.cliqueVerifySeq(com, list)
# ------------------------------------------------------------------------------
# End
# ------------------------------------------------------------------------------

4
nimbus/core/clique/snapshot/snapshot_desc.nim
View File

@ -144,7 +144,7 @@ proc loadSnapshot*(cfg: CliqueCfg; hash: Hash256):
## Load an existing snapshot from the database.
var s = Snapshot(cfg: cfg)
try:
let db = s.cfg.com.db.db
let db = s.cfg.db.db
let rlpData = db.get(hash.cliqueSnapshotKey.toOpenArray)
# The following check is only needed for Github/CI for 64bit Windows (not
@ -168,7 +168,7 @@ proc storeSnapshot*(cfg: CliqueCfg; s: Snapshot): CliqueOkResult =
let
key = s.data.blockHash.cliqueSnapshotKey
val = rlp.encode(s.data)
db = s.cfg.com.db.db
db = s.cfg.db.db
db.put(key.toOpenArray, val)
cfg.nSnaps.inc

5
nimbus/core/tx_pool/tx_chain.nim
View File

@ -80,6 +80,10 @@ proc resetTxEnv(dh: TxChainRef; parent: BlockHeader; fee: Option[UInt256])
{.gcsafe,raises: [Defect,CatchableError].} =
dh.txEnv.reset
# do hardfork transition before
# BaseVMState querying any hardfork/consensus from CommonRef
dh.com.hardForkTransition(parent.blockHash, parent.blockNumber+1)
let timestamp = getTime().utc.toTime
# we don't consider PoS difficulty here
# because that is handled in vmState
@ -95,7 +99,6 @@ proc resetTxEnv(dh: TxChainRef; parent: BlockHeader; fee: Option[UInt256])
dh.txEnv.txRoot = EMPTY_ROOT_HASH
dh.txEnv.stateRoot = dh.txEnv.vmState.parent.stateRoot
dh.com.hardForkTransition(parent.blockHash, parent.blockNumber+1)
proc update(dh: TxChainRef; parent: BlockHeader)
{.gcsafe,raises: [Defect,CatchableError].} =

8
tests/test_clique/pool.nim
View File

@ -59,11 +59,11 @@ type
proc getBlockHeader(ap: TesterPool; number: BlockNumber): BlockHeader =
## Shortcut => db/db_chain.getBlockHeader()
doAssert ap.chain.clique.com.db.getBlockHeader(number, result)
doAssert ap.chain.clique.db.getBlockHeader(number, result)
proc getBlockHeader(ap: TesterPool; hash: Hash256): BlockHeader =
## Shortcut => db/db_chain.getBlockHeader()
doAssert ap.chain.clique.com.db.getBlockHeader(hash, result)
doAssert ap.chain.clique.db.getBlockHeader(hash, result)
proc isZero(a: openArray[byte]): bool =
result = true
@ -306,7 +306,7 @@ proc clique*(ap: TesterPool): Clique =
proc db*(ap: TesterPool): ChainDBRef =
## Getter
ap.clique.com.db
ap.clique.db
proc cliqueSigners*(ap: TesterPool): seq[EthAddress] =
## Getter
@ -443,7 +443,7 @@ proc commitVoterChain*(ap: TesterPool; postProcessOk = false;
# Realign rest of transaction to existing block chain
if reChainOk:
var parent = ap.chain.clique.com.db.getCanonicalHead
var parent = ap.chain.clique.db.getCanonicalHead
for i in 0 ..< headers.len:
headers[i].parentHash = parent.blockHash
headers[i].blockNumber = parent.blockNumber + 1

2
tests/test_txpool.nim
View File

@ -818,7 +818,7 @@ proc runTxPackerTests(noisy = true) =
" size=", mostlySize + blk.txs[n].gasLimit - blk.header.gasUsed
let
poa = bcCom.newClique
poa = bcCom.poa
bdy = BlockBody(transactions: blk.txs)
hdr = block:
var rc = blk.header