Eip225 clique/PoA consensus protocol
details: formal port from go-lang sources, compiles but will not do anything useful yet
This commit is contained in:
Jordan Hrycaj
Jordan Hrycaj
parent
aef7a25174
commit
491149c6d5
|
|
@ -10,6 +10,7 @@ type
|
|||
canonicalHeadHash
|
||||
slotHashToSlot
|
||||
contractHash
|
||||
cliqueSnapshot
|
||||
|
||||
DbKey* = object
|
||||
# The first byte stores the key type. The rest are key-specific values
|
||||
|
|
@ -52,6 +53,11 @@ proc contractHashKey*(h: Hash256): DbKey {.inline.} =
|
|||
result.data[1 .. 32] = h.data
|
||||
result.dataEndPos = uint8 32
|
||||
|
||||
proc cliqueSnapshotKey*(h: Hash256): DbKey {.inline.} =
|
||||
result.data[0] = byte ord(cliqueSnapshot)
|
||||
result.data[1 .. 32] = h.data
|
||||
result.dataEndPos = uint8 32
|
||||
|
||||
template toOpenArray*(k: DbKey): openarray[byte] =
|
||||
k.data.toOpenArray(0, int(k.dataEndPos))
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,591 @@
|
|||
# Nimbus
|
||||
# Copyright (c) 2018 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.
|
||||
|
||||
##
|
||||
## EIP-225 Clique PoA Consensus Protocol
|
||||
## =====================================
|
||||
##
|
||||
## For details see
|
||||
## `EIP-225 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
## and
|
||||
## `go-ethereum <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
##
|
||||
|
||||
import
|
||||
../db/db_chain,
|
||||
../utils,
|
||||
./clique/[clique_cfg, clique_defs, clique_utils, ec_recover, recent_snaps],
|
||||
chronicles,
|
||||
chronos,
|
||||
eth/[common, keys, rlp],
|
||||
# ethash,
|
||||
nimcrypto,
|
||||
random,
|
||||
sequtils,
|
||||
strformat,
|
||||
tables,
|
||||
times
|
||||
|
||||
type
|
||||
# clique/clique.go(142): type SignerFn func(signer [..]
|
||||
CliqueSignerFn* = ## Hashes and signs the data to be signed by
|
||||
## a backing account
|
||||
proc(signer: EthAddress;
|
||||
message: openArray[byte]): Result[Hash256,cstring] {.gcsafe.}
|
||||
|
||||
Proposals = Table[EthAddress,bool]
|
||||
|
||||
# clique/clique.go(172): type Clique struct { [..]
|
||||
Clique* = object ## Clique is the proof-of-authority consensus engine
|
||||
## proposed to support the Ethereum testnet following
|
||||
## the Ropsten attacks.
|
||||
cfg: CliqueCfg ## Consensus engine parameters to fine tune behaviour
|
||||
|
||||
recents: RecentSnaps ## Snapshots for recent block to speed up reorgs
|
||||
# signatures => see CliqueCfg
|
||||
|
||||
proposals: Proposals ## Current list of proposals we are pushing
|
||||
|
||||
signer: EthAddress ## Ethereum address of the signing key
|
||||
signFn: CliqueSignerFn ## Signer function to authorize hashes with
|
||||
lock: AsyncLock ## Protects the signer fields
|
||||
|
||||
fakeDiff: bool ## Testing only: skip difficulty verifications
|
||||
stopSealReq: bool ## Stop running `seal()` function
|
||||
stopVHeaderReq: bool ## Stop running `verifyHeader()` function
|
||||
|
||||
{.push raises: [Defect,CatchableError].}
|
||||
|
||||
logScope:
|
||||
topics = "clique PoA"
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Private Helpers
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
template doExclusively(c: var Clique; action: untyped) =
|
||||
waitFor c.lock.acquire
|
||||
action
|
||||
c.lock.release
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Private functions
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
# clique/clique.go(145): func ecrecover(header [..]
|
||||
proc ecrecover(header: BlockHeader;
|
||||
sigcache: var EcRecover): Result[EthAddress,CliqueError] =
|
||||
## ecrecover extracts the Ethereum account address from a signed header.
|
||||
sigcache.getEcRecover(header)
|
||||
|
||||
|
||||
# clique/clique.go(369): func (c *Clique) snapshot(chain [..]
|
||||
proc snapshot(c: var Clique; blockNumber: BlockNumber; hash: Hash256;
|
||||
parents: openArray[Blockheader]): Result[Snapshot,CliqueError] =
|
||||
## snapshot retrieves the authorization snapshot at a given point in time.
|
||||
c.recents.getRecentSnaps:
|
||||
RecentArgs(blockHash: hash,
|
||||
blockNumber: blockNumber,
|
||||
parents: toSeq(parents))
|
||||
|
||||
|
||||
# clique/clique.go(463): func (c *Clique) verifySeal(chain [..]
|
||||
proc verifySeal(c: var Clique; header: BlockHeader;
|
||||
parents: openArray[BlockHeader]): CliqueResult =
|
||||
## Check whether the signature contained in the header satisfies the
|
||||
## consensus protocol requirements. The method accepts an optional list of
|
||||
## parent headers that aren't yet part of the local blockchain to generate
|
||||
## the snapshots from.
|
||||
|
||||
# Verifying the genesis block is not supported
|
||||
if header.blockNumber.isZero:
|
||||
return err((errUnknownBlock,""))
|
||||
|
||||
# Retrieve the snapshot needed to verify this header and cache it
|
||||
var snap = c.snapshot(header.blockNumber-1, header.parentHash, parents)
|
||||
if snap.isErr:
|
||||
return err(snap.error)
|
||||
|
||||
# Resolve the authorization key and check against signers
|
||||
let signer = ecrecover(header,c.cfg.signatures)
|
||||
if signer.isErr:
|
||||
return err(signer.error)
|
||||
|
||||
if not snap.value.isSigner(signer.value):
|
||||
return err((errUnauthorizedSigner,""))
|
||||
|
||||
let seen = snap.value.recent(signer.value)
|
||||
if seen.isOk:
|
||||
# Signer is among recents, only fail if the current block does not
|
||||
# shift it out
|
||||
if header.blockNumber - snap.value.signersThreshold.u256 < seen.value:
|
||||
return err((errRecentlySigned,""))
|
||||
|
||||
# Ensure that the difficulty corresponds to the turn-ness of the signer
|
||||
if not c.fakeDiff:
|
||||
if snap.value.inTurn(header.blockNumber, signer.value):
|
||||
if header.difficulty != DIFF_INTURN:
|
||||
return err((errWrongDifficulty,""))
|
||||
else:
|
||||
if header.difficulty != DIFF_NOTURN:
|
||||
return err((errWrongDifficulty,""))
|
||||
|
||||
return ok()
|
||||
|
||||
|
||||
# clique/clique.go(314): func (c *Clique) verifyCascadingFields(chain [..]
|
||||
proc verifyCascadingFields(c: var Clique; header: BlockHeader;
|
||||
parents: openArray[BlockHeader]): CliqueResult =
|
||||
## Verify all the header fields that are not standalone, rather depend on a
|
||||
## batch of previous headers. The caller may optionally pass in a batch of
|
||||
## parents (ascending order) to avoid looking those up from the database.
|
||||
## This is useful for concurrently verifying a batch of new headers.
|
||||
|
||||
# The genesis block is the always valid dead-end
|
||||
if header.blockNumber.isZero:
|
||||
return err((errZeroBlockNumberRejected,""))
|
||||
|
||||
# Ensure that the block's timestamp isn't too close to its parent
|
||||
var parent: BlockHeader
|
||||
if 0 < parents.len:
|
||||
parent = parents[^1]
|
||||
else:
|
||||
let rc = c.cfg.dbChain.getBlockHeaderResult(header.blockNumber-1)
|
||||
if rc.isErr:
|
||||
return err((errUnknownAncestor,""))
|
||||
parent = rc.value
|
||||
|
||||
if parent.blockNumber != header.blockNumber-1 or
|
||||
parent.hash != header.parentHash:
|
||||
return err((errUnknownAncestor,""))
|
||||
|
||||
if header.timestamp < parent.timestamp + c.cfg.period:
|
||||
return err((errInvalidTimestamp,""))
|
||||
|
||||
# Verify that the gasUsed is <= gasLimit
|
||||
if header.gasLimit < header.gasUsed:
|
||||
return err((errCliqueExceedsGasLimit,
|
||||
&"invalid gasUsed: have {header.gasUsed}, " &
|
||||
&"gasLimit {header.gasLimit}"))
|
||||
|
||||
if not c.cfg.dbChain.config.isLondonOrLater(header.blockNumber):
|
||||
# Verify BaseFee not present before EIP-1559 fork.
|
||||
if not header.baseFee.isZero:
|
||||
return err((errCliqueUnsupportedBaseFee,
|
||||
"invalid baseFee before London fork: have " &
|
||||
&"{header.baseFee}, want <0>"))
|
||||
let rc = c.cfg.dbChain.validateGasLimit(header)
|
||||
if rc.isErr:
|
||||
return err(rc.error)
|
||||
else:
|
||||
let rc = c.cfg.dbChain.config.verify1559Header(parent = parent,
|
||||
header = header)
|
||||
if rc.isErr:
|
||||
return err(rc.error)
|
||||
|
||||
# Retrieve the snapshot needed to verify this header and cache it
|
||||
var snap = c.snapshot(header.blockNumber-1, header.parentHash, parents)
|
||||
if snap.isErr:
|
||||
return err(snap.error)
|
||||
|
||||
# If the block is a checkpoint block, verify the signer list
|
||||
if (header.blockNumber mod c.cfg.epoch.u256) == 0:
|
||||
let
|
||||
signersList = snap.value.signers
|
||||
extraList = header.extraData.extraDataSigners
|
||||
if signersList != extraList:
|
||||
return err((errMismatchingCheckpointSigners,""))
|
||||
|
||||
# All basic checks passed, verify the seal and return
|
||||
return c.verifySeal(header, parents)
|
||||
|
||||
|
||||
# clique/clique.go(145): func ecrecover(header [..]
|
||||
proc verifyHeader(c: var Clique; header: BlockHeader;
|
||||
parents: openArray[BlockHeader]): CliqueResult =
|
||||
## Check whether a header conforms to the consensus rules.The caller may
|
||||
## optionally pass in a batch of parents (ascending order) to avoid looking
|
||||
## those up from the database. This is useful for concurrently verifying
|
||||
## a batch of new headers.
|
||||
if header.blockNumber.isZero:
|
||||
return err((errUnknownBlock,""))
|
||||
|
||||
# Don't waste time checking blocks from the future
|
||||
if getTime() < header.timestamp:
|
||||
return err((errFutureBlock,""))
|
||||
|
||||
# Checkpoint blocks need to enforce zero beneficiary
|
||||
let isCheckPoint = (header.blockNumber mod c.cfg.epoch.u256) == 0
|
||||
if isCheckPoint and not header.coinbase.isZero:
|
||||
return err((errInvalidCheckpointBeneficiary,""))
|
||||
|
||||
# Nonces must be 0x00..0 or 0xff..f, zeroes enforced on checkpoints
|
||||
if header.nonce != NONCE_AUTH and header.nonce != NONCE_DROP:
|
||||
return err((errInvalidVote,""))
|
||||
if isCheckPoint and header.nonce != NONCE_DROP:
|
||||
return err((errInvalidCheckpointVote,""))
|
||||
|
||||
# Check that the extra-data contains both the vanity and signature
|
||||
if header.extraData.len < EXTRA_VANITY:
|
||||
return err((errMissingVanity,""))
|
||||
if header.extraData.len < EXTRA_VANITY + EXTRA_SEAL:
|
||||
return err((errMissingSignature,""))
|
||||
|
||||
# Ensure that the extra-data contains a signer list on checkpoint,
|
||||
# but none otherwise
|
||||
let signersBytes = header.extraData.len - EXTRA_VANITY - EXTRA_SEAL
|
||||
if not isCheckPoint and signersBytes != 0:
|
||||
return err((errExtraSigners,""))
|
||||
|
||||
if isCheckPoint and (signersBytes mod EthAddress.len) != 0:
|
||||
return err((errInvalidCheckpointSigners,""))
|
||||
|
||||
# Ensure that the mix digest is zero as we do not have fork protection
|
||||
# currently
|
||||
if not header.mixDigest.isZero:
|
||||
return err((errInvalidMixDigest,""))
|
||||
|
||||
# Ensure that the block does not contain any uncles which are meaningless
|
||||
# in PoA
|
||||
if header.ommersHash != UNCLE_HASH:
|
||||
return err((errInvalidUncleHash,""))
|
||||
|
||||
# Ensure that the block's difficulty is meaningful (may not be correct at
|
||||
# this point)
|
||||
if not header.blockNumber.isZero:
|
||||
if header.difficulty.isZero or
|
||||
(header.difficulty != DIFF_INTURN and
|
||||
header.difficulty != DIFF_NOTURN):
|
||||
return err((errInvalidDifficulty,""))
|
||||
|
||||
# verify that the gas limit is <= 2^63-1
|
||||
when header.gasLimit.typeof isnot int64:
|
||||
if int64.high < header.gasLimit:
|
||||
return err((errCliqueExceedsGasLimit,
|
||||
&"invalid gasLimit: have {header.gasLimit}, must be int64"))
|
||||
|
||||
# If all checks passed, validate any special fields for hard forks
|
||||
let rc = c.cfg.dbChain.config.verifyForkHashes(header)
|
||||
if rc.isErr:
|
||||
return err(rc.error)
|
||||
|
||||
# All basic checks passed, verify cascading fields
|
||||
return c.verifyCascadingFields(header, parents)
|
||||
|
||||
|
||||
# clique/clique.go(681): func calcDifficulty(snap [..]
|
||||
proc calcDifficulty(snap: var Snapshot; signer: EthAddress): DifficultyInt =
|
||||
if snap.inTurn(snap.blockNumber + 1, signer):
|
||||
DIFF_INTURN
|
||||
else:
|
||||
DIFF_NOTURN
|
||||
|
||||
# clique/clique.go(730): func encodeSigHeader(w [..]
|
||||
proc encodeSigHeader(header: BlockHeader): seq[byte] =
|
||||
## Cut sigature off `extraData` header field and consider new `baseFee`
|
||||
## field for Eip1559.
|
||||
doAssert EXTRA_SEAL < header.extraData.len
|
||||
|
||||
var rlpHeader = header
|
||||
rlpHeader.extraData.setLen(header.extraData.len - EXTRA_SEAL)
|
||||
|
||||
rlpHeader.encode1559
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Public functions
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
# clique/clique.go(191): func New(config [..]
|
||||
proc initClique*(c: var Clique; cfg: CliqueCfg) =
|
||||
## Initialiser for Clique proof-of-authority consensus engine with the
|
||||
## initial signers set to the ones provided by the user.
|
||||
c.cfg = cfg
|
||||
c.recents = initRecentSnaps(cfg)
|
||||
c.proposals = initTable[EthAddress,bool]()
|
||||
c.lock = newAsyncLock()
|
||||
|
||||
proc initClique*(cfg: CliqueCfg): Clique =
|
||||
result.initClique(cfg)
|
||||
|
||||
|
||||
# clique/clique.go(212): func (c *Clique) Author(header [..]
|
||||
proc author*(c: var Clique;
|
||||
header: BlockHeader): Result[EthAddress,CliqueError] =
|
||||
## Implements consensus.Engine, returning the Ethereum address recovered
|
||||
## from the signature in the header's extra-data section.
|
||||
ecrecover(header, c.cfg.signatures)
|
||||
|
||||
|
||||
# clique/clique.go(217): func (c *Clique) VerifyHeader(chain [..]
|
||||
proc verifyHeader*(c: var Clique; header: BlockHeader): CliqueResult =
|
||||
## Checks whether a header conforms to the consensus rules.
|
||||
c.verifyHeader(header, @[])
|
||||
|
||||
# clique/clique.go(224): func (c *Clique) VerifyHeader(chain [..]
|
||||
proc verifyHeader*(c: var Clique; headers: openArray[BlockHeader]):
|
||||
Future[seq[CliqueResult]] {.async,gcsafe.} =
|
||||
## Checks whether a header conforms to the consensus rules. It verifies
|
||||
## a batch of headers. If running in the background, the process can be
|
||||
## stopped by calling the `stopVerifyHeader()` function.
|
||||
c.doExclusively:
|
||||
c.stopVHeaderReq = false
|
||||
for n in 0 ..< headers.len:
|
||||
c.doExclusively:
|
||||
let isStopRequest = c.stopVHeaderReq
|
||||
if isStopRequest:
|
||||
result.add cliqueResultErr((errCliqueStopped,""))
|
||||
break ;
|
||||
result.add c.verifyHeader(headers[n], headers[0 ..< n])
|
||||
c.doExclusively:
|
||||
c.stopVHeaderReq = false
|
||||
|
||||
proc stopVerifyHeader*(c: var Clique): bool {.discardable.} =
|
||||
## Activate the stop flag for running `verifyHeader()` function.
|
||||
## Returns `true` if the stop flag could be activated.
|
||||
c.doExclusively:
|
||||
if not c.stopVHeaderReq:
|
||||
c.stopVHeaderReq = true
|
||||
result = true
|
||||
|
||||
|
||||
# clique/clique.go(450): func (c *Clique) VerifyUncles(chain [..]
|
||||
proc verifyUncles*(c: var Clique; ethBlock: EthBlock): CliqueResult =
|
||||
## Always returning an error for any uncles as this consensus mechanism
|
||||
## doesn't permit uncles.
|
||||
if 0 < ethBlock.uncles.len:
|
||||
return err((errCliqueUnclesNotAllowed,""))
|
||||
result = ok()
|
||||
|
||||
|
||||
# clique/clique.go(506): func (c *Clique) Prepare(chain [..]
|
||||
proc prepare*(c: var Clique; header: var BlockHeader): CliqueResult =
|
||||
## Peparing all the consensus fields of the header for running the
|
||||
## transactions on top.
|
||||
|
||||
# If the block isn't a checkpoint, cast a random vote (good enough for now)
|
||||
header.coinbase.reset
|
||||
header.nonce.reset
|
||||
|
||||
# Assemble the voting snapshot to check which votes make sense
|
||||
var snap = c.snapshot(header.blockNumber-1, header.parentHash, @[])
|
||||
if snap.isErr:
|
||||
return err(snap.error)
|
||||
|
||||
if (header.blockNumber mod c.cfg.epoch.u256) != 0:
|
||||
c.doExclusively:
|
||||
# Gather all the proposals that make sense voting on
|
||||
var addresses: seq[EthAddress]
|
||||
for (address,authorize) in c.proposals.pairs:
|
||||
if snap.value.validVote(address, authorize):
|
||||
addresses.add address
|
||||
|
||||
# If there's pending proposals, cast a vote on them
|
||||
if 0 < addresses.len:
|
||||
header.coinbase = addresses[c.cfg.prng.rand(addresses.len-1)]
|
||||
header.nonce = if header.coinbase in c.proposals: NONCE_AUTH
|
||||
else: NONCE_DROP
|
||||
|
||||
# Set the correct difficulty
|
||||
header.difficulty = snap.value.calcDifficulty(c.signer)
|
||||
|
||||
# Ensure the extra data has all its components
|
||||
header.extraData.setLen(EXTRA_VANITY)
|
||||
|
||||
if (header.blockNumber mod c.cfg.epoch.u256) == 0:
|
||||
for a in snap.value.signers:
|
||||
header.extraData.add a
|
||||
header.extraData.add 0.byte.repeat(EXTRA_SEAL)
|
||||
|
||||
# Mix digest is reserved for now, set to empty
|
||||
header.mixDigest.reset
|
||||
|
||||
# Ensure the timestamp has the correct delay
|
||||
let parent = c.cfg.dbChain.getBlockHeaderResult(header.blockNumber-1)
|
||||
if parent.isErr:
|
||||
return err((errUnknownAncestor,""))
|
||||
|
||||
header.timestamp = parent.value.timestamp + c.cfg.period
|
||||
if header.timestamp < getTime():
|
||||
header.timestamp = getTime()
|
||||
|
||||
return ok()
|
||||
|
||||
|
||||
# clique/clique.go(571): func (c *Clique) Finalize(chain [..]
|
||||
#proc finalize*(c: var Clique; header: BlockHeader; state: StateDB;
|
||||
# txs: openArray[Transaction]; uncles: openArray[BlockHeader]) =
|
||||
# ## Ensuring no uncles are set, nor block rewards given.
|
||||
#
|
||||
# # No block rewards in PoA, so the state remains as is and uncles are dropped
|
||||
# header.Root =
|
||||
# state.intermediateRoot(c.cfg.config.eip158block <= header.BlockNumber)
|
||||
# header.UncleHash = types.CalcUncleHash(nil)
|
||||
|
||||
# clique/clique.go(579): func (c *Clique) FinalizeAndAssemble(chain [..]
|
||||
#proc finalizeAndAssemble*(c: var Clique; header: BlockHeader; state: StateDB;
|
||||
# txs: openArray[Transaction];
|
||||
# uncles: openArray[BlockHeader];
|
||||
# receipts: openArray[Receipts]):
|
||||
# Result[EthBlock,CliqueError] =
|
||||
# ## Ensuring no uncles are set, nor block rewards given, and returns the
|
||||
# ## final block.
|
||||
#
|
||||
# # Finalize block
|
||||
# c.finalize(header, state, txs, uncles)
|
||||
#
|
||||
# # Assemble and return the final block for sealing
|
||||
# return types.NewBlock(header, txs, nil, receipts,
|
||||
# trie.NewStackTrie(nil)), nil
|
||||
|
||||
|
||||
# clique/clique.go(589): func (c *Clique) Authorize(signer [..]
|
||||
proc authorize*(c: var Clique; signer: EthAddress; signFn: CliqueSignerFn) =
|
||||
## Injects private key into the consensus engine to mint new blocks with.
|
||||
c.doExclusively:
|
||||
c.signer = signer
|
||||
c.signFn = signFn
|
||||
|
||||
|
||||
# clique/clique.go(724): func CliqueRLP(header [..]
|
||||
proc cliqueRlp*(header: BlockHeader): seq[byte] =
|
||||
## Returns the rlp bytes which needs to be signed for the proof-of-authority
|
||||
## sealing. The RLP to sign consists of the entire header apart from the 65
|
||||
## byte signature contained at the end of the extra data.
|
||||
##
|
||||
## Note, the method requires the extra data to be at least 65 bytes,
|
||||
## otherwise it panics. This is done to avoid accidentally using both forms
|
||||
## (signature present or not), which could be abused to produce different
|
||||
##hashes for the same header.
|
||||
header.encodeSigHeader
|
||||
|
||||
|
||||
# clique/clique.go(688): func SealHash(header *types.Header) common.Hash {
|
||||
proc sealHash(header: BlockHeader): Hash256 =
|
||||
## SealHash returns the hash of a block prior to it being sealed.
|
||||
header.encodeSigHeader.keccakHash
|
||||
|
||||
|
||||
# clique/clique.go(599): func (c *Clique) Seal(chain [..]
|
||||
proc seal*(c: var Clique; ethBlock: EthBlock):
|
||||
Future[Result[EthBlock,CliqueError]] {.async,gcsafe.} =
|
||||
## Attempt to create a sealed block using the local signing credentials. If
|
||||
## running in the background, the process can be stopped by calling the
|
||||
## `stopSeal()` function.
|
||||
|
||||
c.doExclusively:
|
||||
c.stopSealReq = false
|
||||
var header = ethBlock.header
|
||||
|
||||
# Sealing the genesis block is not supported
|
||||
if header.blockNumber.isZero:
|
||||
return err((errUnknownBlock,""))
|
||||
|
||||
# For 0-period chains, refuse to seal empty blocks (no reward but would spin
|
||||
# sealing)
|
||||
if c.cfg.period.isZero and ethBlock.txs.len == 0:
|
||||
info $nilCliqueSealNoBlockYet
|
||||
return err((nilCliqueSealNoBlockYet,""))
|
||||
|
||||
# Don't hold the signer fields for the entire sealing procedure
|
||||
c.doExclusively:
|
||||
let
|
||||
signer = c.signer
|
||||
signFn = c.signFn
|
||||
|
||||
# Bail out if we're unauthorized to sign a block
|
||||
var snap = c.snapshot(header.blockNumber-1, header.parentHash, @[])
|
||||
if snap.isErr:
|
||||
return err(snap.error)
|
||||
if not snap.value.isSigner(signer):
|
||||
return err((errUnauthorizedSigner,""))
|
||||
|
||||
# If we're amongst the recent signers, wait for the next block
|
||||
let seen = snap.value.recent(signer)
|
||||
if seen.isOk:
|
||||
# Signer is among recents, only wait if the current block does not
|
||||
# shift it out
|
||||
if header.blockNumber < seen.value + snap.value.signersThreshold.u256:
|
||||
info $nilCliqueSealSignedRecently
|
||||
return err((nilCliqueSealSignedRecently,""))
|
||||
|
||||
# Sweet, the protocol permits us to sign the block, wait for our time
|
||||
var delay = header.timestamp - getTime()
|
||||
if header.difficulty == DIFF_NOTURN:
|
||||
# It's not our turn explicitly to sign, delay it a bit
|
||||
let wiggle = snap.value.signersThreshold.int64 * WIGGLE_TIME
|
||||
# Kludge for limited rand() argument range
|
||||
if wiggle.inSeconds < (int.high div 1000).int64:
|
||||
let rndWiggleMs = c.cfg.prng.rand(wiggle.inMilliSeconds.int)
|
||||
delay += initDuration(milliseconds = rndWiggleMs)
|
||||
else:
|
||||
let rndWiggleSec = c.cfg.prng.rand((wiggle.inSeconds and int.high).int)
|
||||
delay += initDuration(seconds = rndWiggleSec)
|
||||
|
||||
trace "Out-of-turn signing requested",
|
||||
wiggle = $wiggle
|
||||
|
||||
# Sign all the things!
|
||||
let sigHash = signFn(signer,header.cliqueRlp)
|
||||
if sigHash.isErr:
|
||||
return err((errCliqueSealSigFn,$sigHash.error))
|
||||
let extraLen = header.extraData.len
|
||||
if EXTRA_SEAL < extraLen:
|
||||
header.extraData.setLen(extraLen - EXTRA_SEAL)
|
||||
header.extraData.add sigHash.value.data
|
||||
|
||||
# Wait until sealing is terminated or delay timeout.
|
||||
trace "Waiting for slot to sign and propagate",
|
||||
delay = $delay
|
||||
|
||||
# FIXME: double check
|
||||
let timeOutTime = getTime() + delay
|
||||
while getTime() < timeOutTime:
|
||||
c.doExclusively:
|
||||
let isStopRequest = c.stopVHeaderReq
|
||||
if isStopRequest:
|
||||
warn "Sealing result is not read by miner",
|
||||
sealhash = sealHash(header)
|
||||
return err((errCliqueStopped,""))
|
||||
poll()
|
||||
|
||||
c.doExclusively:
|
||||
c.stopSealReq = false
|
||||
return ok(ethBlock.withHeader(header))
|
||||
|
||||
proc stopSeal*(c: var Clique): bool {.discardable.} =
|
||||
## Activate the stop flag for running `seal()` function.
|
||||
## Returns `true` if the stop flag could be activated.
|
||||
c.doExclusively:
|
||||
if not c.stopSealReq:
|
||||
c.stopSealReq = true
|
||||
result =true
|
||||
|
||||
|
||||
# clique/clique.go(673): func (c *Clique) CalcDifficulty(chain [..]
|
||||
proc calcDifficulty(c: var Clique;
|
||||
parent: BlockHeader): Result[DifficultyInt,CliqueError] =
|
||||
## The difficulty adjustment algorithm. It returns the difficulty
|
||||
## that a new block should have:
|
||||
## * DIFF_NOTURN(2) if BLOCK_NUMBER % SIGNER_COUNT != SIGNER_INDEX
|
||||
## * DIFF_INTURN(1) if BLOCK_NUMBER % SIGNER_COUNT == SIGNER_INDEX
|
||||
var snap = c.snapshot(parent.blockNumber, parent.blockHash, @[])
|
||||
if snap.isErr:
|
||||
return err(snap.error)
|
||||
return ok(snap.value.calcDifficulty(c.signer))
|
||||
|
||||
|
||||
# # clique/clique.go(710): func (c *Clique) SealHash(header [..]
|
||||
# proc sealHash(c: var Clique; header: BlockHeader): Hash256 =
|
||||
# ## SealHash returns the hash of a block prior to it being sealed.
|
||||
# header.encodeSigHeader.keccakHash
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
# Nimbus
|
||||
# Copyright (c) 2018 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.
|
||||
|
||||
##
|
||||
## Clique PoA Conmmon Config
|
||||
## =========================
|
||||
##
|
||||
## Constants used by Clique proof-of-authority consensus protocol, see
|
||||
## `EIP-225 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
## and
|
||||
## `go-ethereum <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
##
|
||||
|
||||
import
|
||||
../../db/db_chain,
|
||||
./clique_defs,
|
||||
./ec_recover,
|
||||
random,
|
||||
times
|
||||
|
||||
const
|
||||
prngSeed = 42
|
||||
|
||||
type
|
||||
CliqueCfg* = ref object
|
||||
dbChain*: BaseChainDB
|
||||
signatures*: EcRecover ## Recent block signatures to speed up mining
|
||||
period*: Duration ## time between blocks to enforce
|
||||
epoch*: uint64 ## Epoch length to reset votes and checkpoint
|
||||
prng*: Rand ## PRNG state
|
||||
|
||||
{.push raises: [Defect,CatchableError].}
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Public functions
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc newCliqueCfg*(dbChain: BaseChainDB;
|
||||
period = BLOCK_PERIOD; epoch = EPOCH_LENGTH): CliqueCfg =
|
||||
CliqueCfg(
|
||||
dbChain: dbChain,
|
||||
period: period,
|
||||
epoch: epoch,
|
||||
signatures: initEcRecover(),
|
||||
prng: initRand(prngSeed))
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -0,0 +1,281 @@
|
|||
# Nimbus
|
||||
# Copyright (c) 2018 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.
|
||||
|
||||
##
|
||||
## Clique PoA Constants & Types
|
||||
## ============================
|
||||
##
|
||||
## Constants used by Clique proof-of-authority consensus protocol, see
|
||||
## `EIP-225 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
## and
|
||||
## `go-ethereum <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
##
|
||||
|
||||
const
|
||||
# debugging, enable with: nim c -r -d:noisy:3 ...
|
||||
noisy {.intdefine.}: int = 0
|
||||
isMainOk {.used.} = noisy > 2
|
||||
|
||||
import
|
||||
eth/common,
|
||||
ethash,
|
||||
nimcrypto,
|
||||
stew/results,
|
||||
times
|
||||
|
||||
{.push raises: [].}
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Constants copied from eip-225 specs & implementation
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
# clique/clique.go(48): const ( [..]
|
||||
const
|
||||
CHECKPOINT_INTERVAL* = ## Number of blocks after which to save the vote
|
||||
## snapshot to the database
|
||||
1024
|
||||
|
||||
INMEMORY_SNAPSHOTS* = ## Number of recent vote snapshots to keep in memory
|
||||
128
|
||||
|
||||
INMEMORY_SIGNATURES* = ## Number of recent block signatures to keep in memory
|
||||
4096
|
||||
|
||||
WIGGLE_TIME* = ## Random delay (per signer) to allow concurrent
|
||||
## signers
|
||||
initDuration(seconds = 0, milliseconds = 500)
|
||||
|
||||
# clique/clique.go(57): var ( [..]
|
||||
const
|
||||
EPOCH_LENGTH* = ## Number of blocks after which to checkpoint and reset
|
||||
## the pending votes.Suggested 30000 for the testnet to
|
||||
## remain analogous to the mainnet ethash epoch.
|
||||
ethash.EPOCH_LENGTH.uint64
|
||||
|
||||
BLOCK_PERIOD* = ## Minimum difference in seconds between two consecutive
|
||||
## block's timestamps. Suggested 15s for the testnet to
|
||||
## remain analogous to the mainnet ethash target.
|
||||
initDuration(seconds = 15)
|
||||
|
||||
EXTRA_VANITY* = ## Fixed number of extra-data prefix bytes reserved for
|
||||
## signer vanity. Suggested 32 bytes to retain the current
|
||||
## extra-data allowance and/or use.
|
||||
32
|
||||
|
||||
EXTRA_SEAL* = ## Fixed number of extra-data suffix bytes reserved for
|
||||
## signer seal. 65 bytes fixed as signatures are based on
|
||||
## the standard secp256k1 curve.
|
||||
65
|
||||
|
||||
NONCE_AUTH* = ## Magic nonce number 0xffffffffffffffff to vote on adding a
|
||||
## new signer.
|
||||
0xffffffffffffffffu64.toBlockNonce
|
||||
|
||||
NONCE_DROP* = ## Magic nonce number 0x0000000000000000 to vote on removing
|
||||
## a signer.
|
||||
0x0000000000000000u64.toBlockNonce
|
||||
|
||||
UNCLE_HASH* = ## Always Keccak256(RLP([])) as uncles are meaningless
|
||||
## outside of PoW.
|
||||
rlpHash[seq[BlockHeader]](@[])
|
||||
|
||||
DIFF_NOTURN* = ## Block score (difficulty) for blocks containing out-of-turn
|
||||
## signatures. Suggested 1 since it just needs to be an
|
||||
## arbitrary baseline constant.
|
||||
1.u256
|
||||
|
||||
DIFF_INTURN* = ## Block score (difficulty) for blocks containing in-turn
|
||||
## signatures. Suggested 2 to show a slight preference over
|
||||
## out-of-turn signatures.
|
||||
2.u256
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Additional constants copied from eip-225 go implementation
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
const
|
||||
# params/network_params.go(60): FullImmutabilityThreshold = 90000
|
||||
FULL_IMMUTABILITY_THRESHOLD* = ## Number of blocks after which a chain
|
||||
## segment is considered immutable
|
||||
## (i.e. soft finality). It is used by
|
||||
## the downloader as a hard limit
|
||||
## against deep ancestors, by the
|
||||
## blockchain against deep reorgs, by
|
||||
## the freezer as the cutoff threshold
|
||||
## and by clique as the snapshot trust
|
||||
## limit.
|
||||
90000
|
||||
|
||||
# params/protocol_params.go(121): BaseFeeChangeDenominator = 8 [..]
|
||||
EIP1559_BASE_FEE_CHANGE_DENOMINATOR* = ## Bounds the amount the base fee can
|
||||
## change between blocks.
|
||||
8
|
||||
|
||||
# params/protocol_params.go(122): ElasticityMultiplier = 2 [..]
|
||||
EIP1559_ELASTICITY_MULTIPLIER* = ## Bounds the maximum gas limit an
|
||||
## EIP-1559 block may have.
|
||||
2
|
||||
|
||||
# params/protocol_params.go(123): InitialBaseFee = 1000000000 [..]
|
||||
EIP1559_INITIAL_BASE_FEE* = ## Initial base fee for Eip1559 blocks.
|
||||
1000000000i64
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Error tokens
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
# clique/clique.go(76): var ( [..]
|
||||
type
|
||||
CliqueErrorType* = enum
|
||||
errUnknownBlock = ## is returned when the list of signers is
|
||||
## requested for a block that is not part of
|
||||
## the local blockchain.
|
||||
"unknown block"
|
||||
|
||||
errInvalidCheckpointBeneficiary = ## is returned if a checkpoint/epoch
|
||||
## transition block has a beneficiary
|
||||
## set to non-zeroes.
|
||||
"beneficiary in checkpoint block non-zero"
|
||||
|
||||
errInvalidVote = ## is returned if a nonce value is something
|
||||
## else that the two allowed constants of
|
||||
## 0x00..0 or 0xff..f.
|
||||
"vote nonce not 0x00..0 or 0xff..f"
|
||||
|
||||
errInvalidCheckpointVote = ## is returned if a checkpoint/epoch
|
||||
## transition block has a vote nonce set to
|
||||
## non-zeroes.
|
||||
"vote nonce in checkpoint block non-zero"
|
||||
|
||||
errMissingVanity = ## is returned if a block's extra-data section
|
||||
## is shorter than 32 bytes, which is required
|
||||
## to store the signer vanity.
|
||||
"extra-data 32 byte vanity prefix missing"
|
||||
|
||||
errMissingSignature = ## is returned if a block's extra-data section
|
||||
## doesn't seem to contain a 65 byte secp256k1
|
||||
## signature.
|
||||
"extra-data 65 byte signature suffix missing"
|
||||
|
||||
errExtraSigners = ## is returned if non-checkpoint block contain
|
||||
## signer data in their extra-data fields.
|
||||
"non-checkpoint block contains extra signer list"
|
||||
|
||||
errInvalidCheckpointSigners = ## is returned if a checkpoint block contains
|
||||
## an invalid list of signers (i.e. non
|
||||
## divisible by 20 bytes).
|
||||
"invalid signer list on checkpoint block"
|
||||
|
||||
errMismatchingCheckpointSigners = ## is returned if a checkpoint block
|
||||
## contains a list of signers different
|
||||
## than the one the local node calculated.
|
||||
"mismatching signer list on checkpoint block"
|
||||
|
||||
errInvalidMixDigest = ## is returned if a block's mix digest is
|
||||
## non-zero.
|
||||
"non-zero mix digest"
|
||||
|
||||
errInvalidUncleHash = ## is returned if a block contains an
|
||||
## non-empty uncle list.
|
||||
"non empty uncle hash"
|
||||
|
||||
errInvalidDifficulty = ## is returned if the difficulty of a block
|
||||
## neither 1 or 2.
|
||||
"invalid difficulty"
|
||||
|
||||
errWrongDifficulty = ## is returned if the difficulty of a block
|
||||
## doesn't match the turn of the signer.
|
||||
"wrong difficulty"
|
||||
|
||||
errInvalidTimestamp = ## is returned if the timestamp of a block is
|
||||
## lower than the previous block's timestamp
|
||||
## + the minimum block period.
|
||||
"invalid timestamp"
|
||||
|
||||
errInvalidVotingChain = ## is returned if an authorization list is
|
||||
## attempted to be modified via out-of-range
|
||||
## or non-contiguous headers.
|
||||
"invalid voting chain"
|
||||
|
||||
errUnauthorizedSigner = ## is returned if a header is signed by a
|
||||
## non-authorized entity.
|
||||
"unauthorized signer"
|
||||
|
||||
errRecentlySigned = ## is returned if a header is signed by an
|
||||
## authorized entity that already signed a
|
||||
## header recently, thus is temporarily not
|
||||
## allowed to.
|
||||
"recently signed"
|
||||
|
||||
|
||||
# additional errors sources elsewhere
|
||||
# -----------------------------------
|
||||
|
||||
errPublicKeyToShort = ## Cannot retrieve public key
|
||||
"cannot retrieve public key: too short"
|
||||
|
||||
# imported from consensus/errors.go
|
||||
errUnknownAncestor = ## is returned when validating a block
|
||||
## requires an ancestor that is unknown.
|
||||
"unknown ancestor"
|
||||
|
||||
#errPrunedAncestor = ## is returned when validating a block
|
||||
# ## requires an ancestor that is known, but
|
||||
# ## the state of which is not available.
|
||||
# "pruned ancestor"
|
||||
|
||||
errFutureBlock = ## is returned when a block's timestamp is in
|
||||
## the future according to the current node.
|
||||
"block in the future"
|
||||
|
||||
#errInvalidNumber = ## is returned if a block's number doesn't
|
||||
# ## equal its parent's plus one.
|
||||
# "invalid block number"
|
||||
|
||||
|
||||
# additional errors, manually added
|
||||
# ---------------------------------
|
||||
|
||||
errZeroBlockNumberRejected =
|
||||
"Block number must not be Zero"
|
||||
|
||||
errSkSigResult ## eth/keys subsytem error: signature
|
||||
errSkPubKeyResult ## eth/keys subsytem error: public key
|
||||
errSnapshotLoad ## DB subsytem error
|
||||
errSnapshotStore ## ..
|
||||
errSnapshotClone
|
||||
|
||||
errCliqueExceedsGasLimit
|
||||
errCliqueUnsupportedBaseFee
|
||||
errCliqueBaseFeeError
|
||||
errCliqueGasRepriceFork
|
||||
errCliqueSealSigFn
|
||||
|
||||
errCliqueStopped = "Process was interrupted"
|
||||
errCliqueExpectedBaseFee = "header is missing baseFee"
|
||||
errCliqueGasLimitTooLow = "gas limit is too low"
|
||||
errCliqueGasLimitTooHigh = "gas limit is too high"
|
||||
errCliqueUnclesNotAllowed = "uncles not allowed"
|
||||
|
||||
# not really an error
|
||||
nilCliqueSealNoBlockYet = "Sealing paused, waiting for transactions"
|
||||
nilCliqueSealSignedRecently = "Signed recently, must wait for others"
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# More types
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
type
|
||||
CliqueError* = (CliqueErrorType,string)
|
||||
CliqueResult* = Result[void,CliqueError]
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -0,0 +1,173 @@
|
|||
# Nimbus
|
||||
# Copyright (c) 2018 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.
|
||||
|
||||
##
|
||||
## Votes Management for Clique PoA Consensus Protocol
|
||||
## =================================================
|
||||
##
|
||||
## For details see
|
||||
## `EIP-225 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
## and
|
||||
## `go-ethereum <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
##
|
||||
|
||||
import
|
||||
algorithm,
|
||||
eth/common,
|
||||
sequtils,
|
||||
tables
|
||||
|
||||
type
|
||||
Vote* = object ## Vote represent single votes that an authorized
|
||||
## signer made to modify the list of authorizations.
|
||||
signer*: EthAddress ## authorized signer that cast this vote
|
||||
address*: EthAddress ## account being voted on to change its
|
||||
## authorization type (`true` or `false`)
|
||||
blockNumber*: BlockNumber ## block number the vote was cast in
|
||||
## (expire old votes)
|
||||
authorize*: bool ## authorization type, whether to authorize or
|
||||
## deauthorize the voted account
|
||||
|
||||
Tally = tuple
|
||||
authorize: bool
|
||||
signers: Table[EthAddress,Vote]
|
||||
|
||||
CliquePoll* = object
|
||||
votes: Table[EthAddress,Tally] ## votes by account -> signer
|
||||
authSig: Table[EthAddress,bool] ## currently authorised signers
|
||||
authRemoved: bool ## last `addVote()` action was removing an
|
||||
## authorised signer from the `authSig` list
|
||||
|
||||
{.push raises: [Defect,CatchableError].}
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Public
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc initCliquePoll*(t: var CliquePoll) =
|
||||
## Ininialise an empty `CliquePoll` descriptor.
|
||||
t.votes = initTable[EthAddress,Tally]()
|
||||
t.authSig = initTable[EthAddress,bool]()
|
||||
|
||||
proc initCliquePoll*(t: var CliquePoll; signers: openArray[EthAddress]) =
|
||||
## Ininialise `CliquePoll` with a given authorised signers list
|
||||
t.initCliquePoll
|
||||
for a in signers:
|
||||
t.authSig[a] = true
|
||||
|
||||
proc authSigners*(t: var CliquePoll): seq[EthAddress] =
|
||||
## Sorted ascending list of authorised signer addresses
|
||||
result = toSeq(t.authSig.keys)
|
||||
result.sort do (x, y: EthAddress) -> int:
|
||||
for n in 0 ..< x.len:
|
||||
if x[n] < y[n]:
|
||||
return -1
|
||||
elif y[n] < x[n]:
|
||||
return 1
|
||||
|
||||
proc isAuthSigner*(t: var CliquePoll; address: EthAddress): bool =
|
||||
## Check whether `address` is an authorised signer
|
||||
address in t.authSig
|
||||
|
||||
proc authSignersShrunk*(t: var CliquePoll): bool =
|
||||
## Check whether the authorised signers list was shrunk recently after
|
||||
## appying `addVote()`
|
||||
t.authRemoved
|
||||
|
||||
proc authSignersThreshold*(t: var CliquePoll): int =
|
||||
## Returns the minimum number of authorised signers needed for authorising
|
||||
## a addres for voting. This is currently
|
||||
## ::
|
||||
## 1 + half of the number of authorised signers
|
||||
##
|
||||
1 + (t.authSig.len div 2)
|
||||
|
||||
|
||||
proc delVote*(t: var CliquePoll; signer, address: EthAddress) =
|
||||
## Remove a particular previously added vote.
|
||||
if address in t.votes:
|
||||
if signer in t.votes[address].signers:
|
||||
if t.votes[address].signers.len <= 1:
|
||||
t.votes.del(address)
|
||||
else:
|
||||
t.votes[address].signers.del(signer)
|
||||
|
||||
|
||||
# clique/snapshot.go(141): func (s *Snapshot) validVote(address [..]
|
||||
proc validVote*(t: var CliquePoll; address: EthAddress; authorize: bool): bool =
|
||||
## Check whether voting would have an effect in `addVote()`
|
||||
if address in t.authSig: not authorize else: authorize
|
||||
|
||||
|
||||
proc addVote*(t: var CliquePoll; vote: Vote) =
|
||||
## Add a new vote collecting the signers for the particular voting address.
|
||||
##
|
||||
## Unless it is the first vote for this address, the authorisation type
|
||||
## `true` or `false` of the vote must match the previous one. For the first
|
||||
## vote, the authorisation type `true` is accepted if the address is not an
|
||||
## authorised signer, and `false` if it is an authorised signer. Otherwise
|
||||
## the vote is ignored.
|
||||
##
|
||||
## If the number of signers for the particular address are at least
|
||||
## `authSignersThreshold()`, the status of this address will change as
|
||||
## follows.
|
||||
## * If the authorisation type is `true`, the address is added
|
||||
## to the list of authorised signers.
|
||||
## * If the authorisation type is `false`, the address is removed
|
||||
## from the list of authorised signers.
|
||||
t.authRemoved = false
|
||||
|
||||
# clique/snapshot.go(147): if !s.validVote(address, [..]
|
||||
if not t.validVote(vote.address, vote.authorize):
|
||||
# Voting has no effect
|
||||
return
|
||||
|
||||
# clique/snapshot.go(253): if snap.cast(header.Coinbase, [..]
|
||||
|
||||
# Collect vote
|
||||
var numVotes = 0
|
||||
if not t.votes.hasKey(vote.address):
|
||||
t.votes[vote.address] = (vote.authorize, {vote.signer: vote}.toTable)
|
||||
numVotes = 1
|
||||
elif t.votes[vote.address].authorize == vote.authorize:
|
||||
t.votes[vote.address].signers[vote.signer] = vote
|
||||
numVotes = t.votes[vote.address].signers.len
|
||||
else:
|
||||
return
|
||||
|
||||
# clique/snapshot.go(262): if tally := snap.Tally[header.Coinbase]; [..]
|
||||
|
||||
# Vote passed, update the list of authorised signers if enough votes
|
||||
if numVotes < t.authSignersThreshold:
|
||||
return
|
||||
|
||||
var obsolete = @[vote.address]
|
||||
if vote.authorize:
|
||||
# Has minimum votes, so add it
|
||||
t.authSig[vote.address] = true
|
||||
else:
|
||||
# clique/snapshot.go(266): delete(snap.Signers, [..]
|
||||
t.authSig.del(vote.address)
|
||||
t.authRemoved = true
|
||||
|
||||
# Not a signer anymore => remove it everywhere
|
||||
for key,value in t.votes.mpairs:
|
||||
if vote.address in value.signers:
|
||||
if 1 < value.signers.len:
|
||||
value.signers.del(vote.address)
|
||||
else:
|
||||
obsolete.add key
|
||||
|
||||
for key in obsolete:
|
||||
t.votes.del(key)
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -0,0 +1,216 @@
|
|||
# Nimbus
|
||||
# Copyright (c) 2018 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.
|
||||
|
||||
##
|
||||
## Tuoole & Utils for Clique PoA Consensus Protocol
|
||||
## ================================================
|
||||
##
|
||||
## For details see
|
||||
## `EIP-225 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
## and
|
||||
## `go-ethereum <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
##
|
||||
## Caveat: Not supporting RLP serialisation encode()/decode()
|
||||
##
|
||||
|
||||
import
|
||||
../../chain_config,
|
||||
../../config,
|
||||
../../constants,
|
||||
../../db/db_chain,
|
||||
../../utils,
|
||||
../../vm_types2,
|
||||
./clique_defs,
|
||||
eth/[common, rlp],
|
||||
stew/results,
|
||||
stint,
|
||||
strformat,
|
||||
times
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Private helpers
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc toEthAddress(a: openArray[byte]; start: int): EthAddress =
|
||||
## Concert seq[..] => Array[..]
|
||||
doAssert start + EthAddress.len <= a.len
|
||||
for n in 0 ..< EthAddress.len:
|
||||
result[n] = a[start + n]
|
||||
|
||||
proc gasLimitBounds(limit: GasInt): (GasInt, GasInt) =
|
||||
## See also utils.header.gasLimitBounds()
|
||||
let
|
||||
bndRange = limit div GAS_LIMIT_ADJUSTMENT_FACTOR
|
||||
upperBound = if GAS_LIMIT_MAXIMUM - bndRange < limit: GAS_LIMIT_MAXIMUM
|
||||
else: limit + bndRange
|
||||
lowerBound = max(GAS_LIMIT_MINIMUM, limit - bndRange)
|
||||
|
||||
return (lowerBound, upperBound)
|
||||
|
||||
proc validateGasLimit(header: BlockHeader; limit: GasInt): CliqueResult =
|
||||
let (lowBound, highBound) = gasLimitBounds(limit)
|
||||
if header.gasLimit < lowBound:
|
||||
return err((errCliqueGasLimitTooLow,""))
|
||||
if highBound < header.gasLimit:
|
||||
return err((errCliqueGasLimitTooHigh,""))
|
||||
return ok()
|
||||
|
||||
func zeroItem[T](t: typedesc[T]): T {.inline.} =
|
||||
discard
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Public functions
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc isZero*[T: EthAddress|Hash256|Duration](a: T): bool =
|
||||
## `true` if `a` is all zero
|
||||
a == zeroItem(T)
|
||||
|
||||
proc cliqueResultErr*(w: CliqueError): CliqueResult =
|
||||
## Return error result (syntactic sugar)
|
||||
err(w)
|
||||
|
||||
|
||||
proc extraDataSigners*(extraData: Blob): seq[EthAddress] =
|
||||
## Extract signer addresses from extraData header field
|
||||
if EXTRA_VANITY + EXTRA_SEAL < extraData.len:
|
||||
var addrOffset = EXTRA_VANITY
|
||||
while addrOffset + EthAddress.len <= EXTRA_SEAL:
|
||||
result.add extraData.toEthAddress(addrOffset)
|
||||
addrOffset += EthAddress.len
|
||||
|
||||
proc getBlockHeaderResult*(c: BaseChainDB;
|
||||
number: BlockNumber): Result[BlockHeader,void] =
|
||||
## Slightly re-phrased dbChain.getBlockHeader(..) command
|
||||
var header: BlockHeader
|
||||
if c.getBlockHeader(number, header):
|
||||
return ok(header)
|
||||
result = err()
|
||||
|
||||
# core/types/block.go(343): func (b *Block) WithSeal(header [..]
|
||||
proc withHeader*(b: EthBlock; header: BlockHeader): EthBlock =
|
||||
## New block with the data from `b` but the header replaced with the
|
||||
## argument one.
|
||||
EthBlock(
|
||||
header: header,
|
||||
txs: b.txs,
|
||||
uncles: b.uncles)
|
||||
|
||||
# consensus/misc/forks.go(30): func VerifyForkHashes(config [..]
|
||||
proc verifyForkHashes*(c: var ChainConfig; header: BlockHeader): CliqueResult =
|
||||
## Verify that blocks conforming to network hard-forks do have the correct
|
||||
## hashes, to avoid clients going off on different chains.
|
||||
|
||||
# If the homestead reprice hash is set, validate it
|
||||
if c.eip150Block.isZero or c.eip150Block != header.blockNumber:
|
||||
return ok()
|
||||
|
||||
let hash = header.hash
|
||||
if c.eip150Hash.isZero or c.eip150Hash == hash:
|
||||
return ok()
|
||||
|
||||
return err((errCliqueGasRepriceFork,
|
||||
&"Homestead gas reprice fork: have {c.eip150Hash}, want {hash}"))
|
||||
|
||||
proc validateGasLimit*(c: var BaseChainDB; header: BlockHeader): CliqueResult =
|
||||
## See also private function p2p.validate.validateGasLimit()
|
||||
let parent = c.getBlockHeader(header.parentHash)
|
||||
header.validateGasLimit(parent.gasLimit)
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Eip 1559 support
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
# params/config.go(450): func (c *ChainConfig) IsLondon(num [..]
|
||||
proc isLondonOrLater*(c: var ChainConfig; number: BlockNumber): bool =
|
||||
## FIXME: London is not defined yet, will come after Berlin
|
||||
FkBerlin < c.toFork(number)
|
||||
|
||||
proc baseFee*(header: BlockHeader): GasInt =
|
||||
# FIXME: `baseFee` header field not defined before `London` fork
|
||||
0.GasInt
|
||||
|
||||
# clique/clique.go(730): func encodeSigHeader(w [..]
|
||||
proc encode1559*(header: BlockHeader): seq[byte] =
|
||||
## Encode header field and considering new `baseFee` field for Eip1559.
|
||||
var writer = initRlpWriter()
|
||||
writer.append(header)
|
||||
if not header.baseFee.isZero:
|
||||
writer.append(header.baseFee)
|
||||
result = writer.finish
|
||||
|
||||
# consensus/misc/eip1559.go(55): func CalcBaseFee(config [..]
|
||||
proc calc1599BaseFee*(c: var ChainConfig; parent: BlockHeader): GasInt =
|
||||
## calculates the basefee of the header.
|
||||
|
||||
# If the current block is the first EIP-1559 block, return the
|
||||
# initial base fee.
|
||||
if not c.isLondonOrLater(parent.blockNumber):
|
||||
return EIP1559_INITIAL_BASE_FEE
|
||||
|
||||
let parentGasTarget = parent.gasLimit div EIP1559_ELASTICITY_MULTIPLIER
|
||||
|
||||
# If the parent gasUsed is the same as the target, the baseFee remains
|
||||
# unchanged.
|
||||
if parent.gasUsed == parentGasTarget:
|
||||
return parent.baseFee
|
||||
|
||||
let parentGasDenom = parentGasTarget.i128 *
|
||||
EIP1559_BASE_FEE_CHANGE_DENOMINATOR.i128
|
||||
|
||||
if parentGasTarget < parent.gasUsed:
|
||||
# If the parent block used more gas than its target, the baseFee should
|
||||
# increase.
|
||||
let
|
||||
gasUsedDelta = (parent.gasUsed - parentGasTarget).i128
|
||||
baseFeeDelta = (parent.baseFee.i128 * gasUsedDelta) div parentGasDenom
|
||||
|
||||
return parent.baseFee + max(baseFeeDelta.truncate(GasInt), 1)
|
||||
|
||||
else:
|
||||
# Otherwise if the parent block used less gas than its target, the
|
||||
# baseFee should decrease.
|
||||
let
|
||||
gasUsedDelta = (parentGasTarget - parent.gasUsed).i128
|
||||
baseFeeDelta = (parent.baseFee.i128 * gasUsedDelta) div parentGasDenom
|
||||
|
||||
return max(parent.baseFee - baseFeeDelta.truncate(GasInt), 0)
|
||||
|
||||
|
||||
# consensus/misc/eip1559.go(32): func VerifyEip1559Header(config [..]
|
||||
proc verify1559Header*(c: var ChainConfig;
|
||||
parent, header: BlockHeader): CliqueResult =
|
||||
## Verify that the gas limit remains within allowed bounds
|
||||
let limit = if c.isLondonOrLater(parent.blockNumber):
|
||||
parent.gasLimit
|
||||
else:
|
||||
parent.gasLimit * EIP1559_ELASTICITY_MULTIPLIER
|
||||
let rc = header.validateGasLimit(limit)
|
||||
if rc.isErr:
|
||||
return err(rc.error)
|
||||
|
||||
# Verify the header is not malformed
|
||||
if header.baseFee.isZero:
|
||||
return err((errCliqueExpectedBaseFee,""))
|
||||
|
||||
# Verify the baseFee is correct based on the parent header.
|
||||
var expectedBaseFee = c.calc1599BaseFee(parent)
|
||||
if header.baseFee != expectedBaseFee:
|
||||
return err((errCliqueBaseFeeError,
|
||||
&"invalid baseFee: have {expectedBaseFee}, "&
|
||||
&"want {header.baseFee}, " &
|
||||
&"parent.baseFee {parent.baseFee}, "&
|
||||
&"parent.gasUsed {parent.gasUsed}"))
|
||||
|
||||
return ok()
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
# Nimbus
|
||||
# Copyright (c) 2018 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.
|
||||
|
||||
##
|
||||
## Address Cache for Clique PoA Consensus Protocol
|
||||
## ===============================================
|
||||
##
|
||||
## For details see
|
||||
## `EIP-225 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
## and
|
||||
## `go-ethereum <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
##
|
||||
|
||||
import
|
||||
../../utils,
|
||||
../../utils/lru_cache,
|
||||
./clique_defs,
|
||||
eth/[common, keys, rlp],
|
||||
stint
|
||||
|
||||
type
|
||||
# simplify Hash256 for rlp serialisation
|
||||
EcKey32 = array[32, byte]
|
||||
|
||||
EcRecover* = LruCache[BlockHeader,EcKey32,EthAddress,CliqueError]
|
||||
|
||||
{.push raises: [Defect,CatchableError].}
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Public functions
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc initEcRecover*(cache: var EcRecover) {.gcsafe, raises: [Defect].} =
|
||||
|
||||
var toKey: LruKey[BlockHeader,EcKey32] =
|
||||
|
||||
# Use the seal hash for cache lookup
|
||||
proc(header:BlockHeader): EcKey32 =
|
||||
## If the signature's already cached, return that
|
||||
# clique/clique.go(148): hash := header.Hash()
|
||||
header.hash.data
|
||||
|
||||
var toValue: LruValue[BlockHeader,EthAddress,CliqueError] =
|
||||
|
||||
# Retrieve signature from the header's extra data fields
|
||||
proc(header: BlockHeader): Result[EthAddress,CliqueError] =
|
||||
|
||||
# Extract signature from extra data field (last 65 bytes)
|
||||
let msg = header.extraData
|
||||
|
||||
# clique/clique.go(153): if len(header.Extra) < extraSeal {
|
||||
if msg.len < EXTRA_SEAL:
|
||||
return err((errMissingSignature,""))
|
||||
let signature = Signature.fromRaw(
|
||||
msg.toOpenArray(msg.len - EXTRA_SEAL, msg.high))
|
||||
if signature.isErr:
|
||||
return err((errSkSigResult,$signature.error))
|
||||
|
||||
# Recover the public key from signature and seal hash
|
||||
# clique/clique.go(159): pubkey, err := crypto.Ecrecover( [..]
|
||||
let pubKey = recover(signature.value, SKMessage(header.hash.data))
|
||||
if pubKey.isErr:
|
||||
return err((errSkPubKeyResult,$pubKey.error))
|
||||
|
||||
# Convert public key to address.
|
||||
return ok(pubKey.value.toCanonicalAddress)
|
||||
|
||||
cache.initLruCache(toKey, toValue, INMEMORY_SIGNATURES)
|
||||
|
||||
proc initEcRecover*: EcRecover {.gcsafe, raises: [Defect].} =
|
||||
result.initEcRecover
|
||||
|
||||
|
||||
# clique/clique.go(145): func ecrecover(header [..]
|
||||
proc getEcRecover*(addrCache: var EcRecover; header: BlockHeader): auto =
|
||||
## extract Ethereum account address from a signed header block, the relevant
|
||||
## signature used is appended to the re-purposed extra data field
|
||||
addrCache.getLruItem(header)
|
||||
|
||||
|
||||
proc append*(rw: var RlpWriter; ecRec: EcRecover) {.inline.} =
|
||||
## Generic support for `rlp.encode(ecRec)`
|
||||
rw.append(ecRec.data)
|
||||
|
||||
proc read*(rlp: var Rlp; Q: type EcRecover): Q {.inline.} =
|
||||
## Generic support for `rlp.decode(bytes)` for loading the cache from a
|
||||
## serialised data stream.
|
||||
result.initEcRecover
|
||||
result.data = rlp.read(type result.data)
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -0,0 +1,206 @@
|
|||
# Nimbus
|
||||
# Copyright (c) 2018 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.
|
||||
|
||||
##
|
||||
## Snapshot Cache for Clique PoA Consensus Protocol
|
||||
## ================================================
|
||||
##
|
||||
## For details see
|
||||
## `EIP-225 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
## and
|
||||
## `go-ethereum <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
##
|
||||
## Caveat: Not supporting RLP serialisation encode()/decode()
|
||||
##
|
||||
|
||||
import
|
||||
../../utils,
|
||||
../../utils/lru_cache,
|
||||
./clique_cfg,
|
||||
./clique_defs,
|
||||
./clique_utils,
|
||||
./snapshot,
|
||||
chronicles,
|
||||
eth/[common, keys],
|
||||
nimcrypto,
|
||||
stint
|
||||
|
||||
export
|
||||
snapshot
|
||||
|
||||
type
|
||||
RecentArgs* = ref object
|
||||
blockHash*: Hash256
|
||||
blockNumber*: BlockNumber
|
||||
parents*: seq[BlockHeader]
|
||||
|
||||
# Internal, temporary state variables
|
||||
LocalArgs = ref object
|
||||
headers: seq[BlockHeader]
|
||||
|
||||
# Internal type, simplify Hash256 for rlp serialisation
|
||||
RecentKey = array[32, byte]
|
||||
|
||||
# Internal descriptor used by toValue()
|
||||
RecentDesc = object
|
||||
cfg: CliqueCfg
|
||||
args: RecentArgs
|
||||
local: LocalArgs
|
||||
|
||||
RecentSnaps* = object
|
||||
cfg: CliqueCfg
|
||||
cache: LruCache[RecentDesc,RecentKey,Snapshot,CliqueError]
|
||||
|
||||
{.push raises: [Defect,CatchableError].}
|
||||
|
||||
logScope:
|
||||
topics = "clique snap cache"
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Private helpers
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
# clique/clique.go(394): if number == 0 || (number%c.config.Epoch [..]
|
||||
proc canDiskCheckPointOk(d: RecentDesc): bool =
|
||||
# If we're at the genesis, snapshot the initial state.
|
||||
if d.args.blockNumber.isZero:
|
||||
return true
|
||||
|
||||
# Alternatively if we're at a checkpoint block without a parent
|
||||
# (light client CHT), or we have piled up more headers than allowed
|
||||
# to be re-orged (chain reinit from a freezer), consider the
|
||||
# checkpoint trusted and snapshot it.
|
||||
if (d.args.blockNumber mod d.cfg.epoch.u256) == 0:
|
||||
if (FULL_IMMUTABILITY_THRESHOLD < d.local.headers.len) or
|
||||
d.cfg.dbChain.getBlockHeaderResult(d.args.blockNumber - 1).isErr:
|
||||
return true
|
||||
|
||||
proc isCheckPointOk(number: BlockNumber): bool =
|
||||
number mod CHECKPOINT_INTERVAL == 0
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Private functions
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
# clique/clique.go(383): if number%checkpointInterval == 0 [..]
|
||||
proc tryDiskSnapshot(d: RecentDesc; snap: var Snapshot): bool =
|
||||
if d.args.blockNumber.isCheckPointOk:
|
||||
if snap.loadSnapshot(d.cfg, d.args.blockHash).isOk:
|
||||
trace "Loaded voting snapshot from disk",
|
||||
blockNumber = d.args.blockNumber,
|
||||
blockHash = d.args.blockHash
|
||||
return true
|
||||
|
||||
proc tryDiskCheckPoint(d: RecentDesc; snap: var Snapshot): bool =
|
||||
if d.canDiskCheckPointOk:
|
||||
# clique/clique.go(395): checkpoint := chain.GetHeaderByNumber [..]
|
||||
let checkPoint = d.cfg.dbChain.getBlockHeaderResult(d.args.blockNumber)
|
||||
if checkPoint.isErr:
|
||||
return false
|
||||
let
|
||||
hash = checkPoint.value.hash
|
||||
signersList = checkPoint.value.extraData.extraDataSigners
|
||||
snap.initSnapshot(d.cfg, d.args.blockNumber, hash, signersList)
|
||||
|
||||
if snap.storeSnapshot.isOk:
|
||||
info "Stored checkpoint snapshot to disk",
|
||||
blockNumber = d.args.blockNumber,
|
||||
blockHash = hash
|
||||
return true
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Public functions
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc initRecentSnaps*(rs: var RecentSnaps;
|
||||
cfg: CliqueCfg) {.gcsafe,raises: [Defect].} =
|
||||
|
||||
var toKey: LruKey[RecentDesc,RecentKey] =
|
||||
proc(d: RecentDesc): RecentKey =
|
||||
d.args.blockHash.data
|
||||
|
||||
var toValue: LruValue[RecentDesc,Snapshot,CliqueError] =
|
||||
proc(d: RecentDesc): Result[Snapshot,CliqueError] =
|
||||
var snap: Snapshot
|
||||
|
||||
while true:
|
||||
# If an on-disk checkpoint snapshot can be found, use that
|
||||
if d.tryDiskSnapshot(snap):
|
||||
# clique/clique.go(386): snap = s
|
||||
break
|
||||
|
||||
# Save checkpoint e.g. when at the genesis ..
|
||||
if d.tryDiskCheckPoint(snap):
|
||||
# clique/clique.go(407): log.Info("Stored [..]
|
||||
break
|
||||
|
||||
# No snapshot for this header, gather the header and move backward
|
||||
var header: BlockHeader
|
||||
if 0 < d.args.parents.len:
|
||||
# If we have explicit parents, pick from there (enforced)
|
||||
header = d.args.parents[^1]
|
||||
|
||||
# clique/clique.go(416): if header.Hash() != hash [..]
|
||||
if header.hash != d.args.blockHash and
|
||||
header.blockNumber != d.args.blockNumber:
|
||||
return err((errUnknownAncestor,""))
|
||||
d.args.parents.setLen(d.args.parents.len-1)
|
||||
|
||||
else:
|
||||
# No explicit parents (or no more left), reach out to the database
|
||||
let rc = d.cfg.dbChain.getBlockHeaderResult(d.args.blockNumber)
|
||||
if rc.isErr:
|
||||
return err((errUnknownAncestor,""))
|
||||
header = rc.value
|
||||
|
||||
d.local.headers.add header
|
||||
d.args.blockNumber -= 1.u256
|
||||
d.args.blockHash = header.parentHash
|
||||
# => while loop
|
||||
|
||||
# Previous snapshot found, apply any pending headers on top of it
|
||||
for i in 0 ..< d.local.headers.len div 2:
|
||||
swap(d.local.headers[i], d.local.headers[^(1+i)])
|
||||
block:
|
||||
# clique/clique.go(434): snap, err := snap.apply(headers)
|
||||
let rc = snap.applySnapshot(d.local.headers)
|
||||
if rc.isErr:
|
||||
return err(rc.error)
|
||||
|
||||
# If we've generated a new checkpoint snapshot, save to disk
|
||||
if snap.blockNumber.isCheckPointOk and 0 < d.local.headers.len:
|
||||
var rc = snap.storeSnapshot
|
||||
if rc.isErr:
|
||||
return err(rc.error)
|
||||
trace "Stored voting snapshot to disk",
|
||||
blockNumber = d.blockNumber,
|
||||
blockHash = hash
|
||||
|
||||
# clique/clique.go(438): c.recents.Add(snap.Hash, snap)
|
||||
return ok(snap)
|
||||
|
||||
rs.cfg = cfg
|
||||
rs.cache.initLruCache(toKey, toValue, INMEMORY_SNAPSHOTS)
|
||||
|
||||
|
||||
proc initRecentSnaps*(cfg: CliqueCfg): RecentSnaps {.gcsafe,raises: [Defect].} =
|
||||
result.initRecentSnaps(cfg)
|
||||
|
||||
|
||||
proc getRecentSnaps*(rs: var RecentSnaps; args: RecentArgs): auto =
|
||||
## Get snapshot from cache or disk
|
||||
rs.cache.getLruItem:
|
||||
RecentDesc(cfg: rs.cfg,
|
||||
args: args,
|
||||
local: LocalArgs())
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -0,0 +1,285 @@
|
|||
# Nimbus
|
||||
# Copyright (c) 2018 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.
|
||||
|
||||
##
|
||||
## Snapshot Structure for Clique PoA Consensus Protocol
|
||||
## ====================================================
|
||||
##
|
||||
## For details see
|
||||
## `EIP-225 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
## and
|
||||
## `go-ethereum <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
|
||||
##
|
||||
|
||||
const
|
||||
# debugging, enable with: nim c -r -d:noisy:3 ...
|
||||
noisy {.intdefine.}: int = 0
|
||||
isMainOk {.used.} = noisy > 2
|
||||
|
||||
import
|
||||
../../db/[storage_types, db_chain],
|
||||
../../utils/lru_cache,
|
||||
./clique_cfg,
|
||||
./clique_defs,
|
||||
./clique_poll,
|
||||
./ec_recover,
|
||||
chronicles,
|
||||
eth/[common, rlp, trie/db],
|
||||
sequtils,
|
||||
tables,
|
||||
times
|
||||
|
||||
type
|
||||
AddressHistory = Table[BlockNumber,EthAddress]
|
||||
|
||||
SnapshotData* = object
|
||||
blockNumber: BlockNumber ## truncated block num where snapshot was created
|
||||
blockHash: Hash256 ## block hash where snapshot was created
|
||||
recents: AddressHistory ## recent signers for spam protections
|
||||
|
||||
# clique/snapshot.go(58): Recents map[uint64]common.Address [..]
|
||||
ballot: CliquePoll ## Votes => authorised signers
|
||||
|
||||
# clique/snapshot.go(50): type Snapshot struct [..]
|
||||
Snapshot* = object ## Snapshot is the state of the authorization voting at
|
||||
## a given point in time.
|
||||
cfg: CliqueCfg ## parameters to fine tune behavior
|
||||
data*: SnapshotData ## real snapshot
|
||||
|
||||
{.push raises: [Defect,CatchableError].}
|
||||
|
||||
logScope:
|
||||
topics = "clique snapshot"
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Private functions needed to support RLP conversion
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc append[K,V](rw: var RlpWriter; tab: Table[K,V]) {.inline.} =
|
||||
rw.startList(tab.len)
|
||||
for key,value in tab.pairs:
|
||||
rw.append((key,value))
|
||||
|
||||
proc read[K,V](rlp: var Rlp;
|
||||
Q: type Table[K,V]): Q {.inline, raises: [Defect,CatchableError].} =
|
||||
for w in rlp.items:
|
||||
let (key,value) = w.read((K,V))
|
||||
result[key] = value
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Public functions
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
# clique/snapshot.go(72): func newSnapshot(config [..]
|
||||
proc initSnapshot*(s: var Snapshot; cfg: CliqueCfg;
|
||||
number: BlockNumber; hash: Hash256; signers: openArray[EthAddress]) =
|
||||
## This creates a new snapshot with the specified startup parameters. The
|
||||
## method does not initialize the set of recent signers, so only ever use
|
||||
## if for the genesis block.
|
||||
s.cfg = cfg
|
||||
s.data.blockNumber = number
|
||||
s.data.blockHash = hash
|
||||
s.data.recents = initTable[BlockNumber,EthAddress]()
|
||||
s.data.ballot.initCliquePoll(signers)
|
||||
|
||||
proc initSnapshot*(cfg: CliqueCfg; number: BlockNumber; hash: Hash256;
|
||||
signers: openArray[EthAddress]): Snapshot =
|
||||
result.initSnapshot(cfg, number, hash, signers)
|
||||
|
||||
|
||||
proc blockNumber*(s: var Snapshot): BlockNumber =
|
||||
## Getter
|
||||
s.data.blockNumber
|
||||
|
||||
# clique/snapshot.go(88): func loadSnapshot(config [..]
|
||||
proc loadSnapshot*(s: var Snapshot; cfg: CliqueCfg;
|
||||
hash: Hash256): CliqueResult {.gcsafe, raises: [Defect].} =
|
||||
## Load an existing snapshot from the database.
|
||||
try:
|
||||
let
|
||||
key = hash.cliqueSnapshotKey
|
||||
value = cfg.dbChain.db.get(key.toOpenArray)
|
||||
s.data = value.decode(SnapshotData)
|
||||
s.cfg = cfg
|
||||
except CatchableError as e:
|
||||
return err((errSnapshotLoad,e.msg))
|
||||
result = ok()
|
||||
|
||||
|
||||
# clique/snapshot.go(104): func (s *Snapshot) store(db [..]
|
||||
proc storeSnapshot*(s: var Snapshot): CliqueResult {.gcsafe,raises: [Defect].} =
|
||||
## Insert the snapshot into the database.
|
||||
try:
|
||||
let
|
||||
key = s.data.blockHash.cliqueSnapshotKey
|
||||
value = rlp.encode(s.data)
|
||||
s.cfg.dbChain.db.put(key.toOpenArray, value)
|
||||
except CatchableError as e:
|
||||
return err((errSnapshotStore,e.msg))
|
||||
result = ok()
|
||||
|
||||
|
||||
# clique/snapshot.go(185): func (s *Snapshot) apply(headers [..]
|
||||
proc applySnapshot*(s: var Snapshot;
|
||||
headers: openArray[BlockHeader]): CliqueResult =
|
||||
## Initialises an authorization snapshot `snap` by applying the `headers`
|
||||
## to the argument snapshot `s`.
|
||||
|
||||
# Allow passing in no headers for cleaner code
|
||||
if headers.len == 0:
|
||||
return ok()
|
||||
|
||||
# Sanity check that the headers can be applied
|
||||
if headers[0].blockNumber != s.data.blockNumber + 1:
|
||||
return err((errInvalidVotingChain,""))
|
||||
for i in 0 ..< headers.len:
|
||||
if headers[i+1].blockNumber != headers[i].blockNumber+1:
|
||||
return err((errInvalidVotingChain,""))
|
||||
|
||||
# Iterate through the headers and create a new snapshot
|
||||
let
|
||||
start = getTime()
|
||||
logInterval = initDuration(seconds = 8)
|
||||
var
|
||||
logged = start
|
||||
|
||||
# clique/snapshot.go(206): for i, header := range headers [..]
|
||||
for headersIndex in 0 ..< headers.len:
|
||||
let
|
||||
# headersIndex => also used for logging at the end of this loop
|
||||
header = headers[headersIndex]
|
||||
number = header.blockNumber
|
||||
|
||||
# Remove any votes on checkpoint blocks
|
||||
if number mod s.cfg.epoch.u256 == 0:
|
||||
s.data.ballot.initCliquePoll
|
||||
|
||||
# Delete the oldest signer from the recent list to allow it signing again
|
||||
block:
|
||||
let limit = s.data.ballot.authSignersThreshold.u256
|
||||
if limit <= number:
|
||||
s.data.recents.del(number - limit)
|
||||
|
||||
# Resolve the authorization key and check against signers
|
||||
let signer = ? s.cfg.signatures.getEcRecover(header)
|
||||
if not s.data.ballot.isAuthSigner(signer):
|
||||
return err((errUnauthorizedSigner,""))
|
||||
for recent in s.data.recents.values:
|
||||
if recent == signer:
|
||||
return err((errRecentlySigned,""))
|
||||
s.data.recents[number] = signer
|
||||
|
||||
# Header authorized, discard any previous vote from the signer
|
||||
s.data.ballot.delVote(signer = signer, address = header.coinbase)
|
||||
|
||||
# Tally up the new vote from the signer
|
||||
var authOk = false
|
||||
if header.nonce == NONCE_AUTH:
|
||||
authOk = true
|
||||
elif header.nonce != NONCE_DROP:
|
||||
return err((errInvalidVote,""))
|
||||
s.data.ballot.addVote:
|
||||
Vote(address: header.coinbase,
|
||||
signer: signer,
|
||||
blockNumber: number,
|
||||
authorize: authOk)
|
||||
|
||||
# clique/snapshot.go(269): if limit := uint64(len(snap.Signers)/2 [..]
|
||||
if s.data.ballot.authSignersShrunk:
|
||||
# Signer list shrunk, delete any leftover recent caches
|
||||
let limit = s.data.ballot.authSignersThreshold.u256
|
||||
if limit <= number:
|
||||
s.data.recents.del(number - limit)
|
||||
|
||||
# If we're taking too much time (ecrecover), notify the user once a while
|
||||
if logInterval < logged - getTime():
|
||||
info "Reconstructing voting history",
|
||||
processed = headersIndex,
|
||||
total = headers.len,
|
||||
elapsed = start - getTime()
|
||||
logged = getTime()
|
||||
|
||||
let sinceStart = start - getTime()
|
||||
if logInterval < sinceStart:
|
||||
info "Reconstructed voting history",
|
||||
processed = headers.len,
|
||||
elapsed = sinceStart
|
||||
|
||||
# clique/snapshot.go(303): snap.Number += uint64(len(headers))
|
||||
s.data.blockNumber += headers.len.u256
|
||||
s.data.blockHash = headers[^1].blockHash
|
||||
result = ok()
|
||||
|
||||
proc validVote*(s: var Snapshot; address: EthAddress; authorize: bool): bool =
|
||||
## Returns `true` if voting makes sense, at all.
|
||||
s.data.ballot.validVote(address, authorize)
|
||||
|
||||
proc recent*(s: var Snapshot; address: EthAddress): Result[BlockNumber,void] =
|
||||
## Return `BlockNumber` for `address` argument (if any)
|
||||
for (number,recent) in s.data.recents.pairs:
|
||||
if recent == address:
|
||||
return ok(number)
|
||||
return err()
|
||||
|
||||
proc signersThreshold*(s: var Snapshot): int =
|
||||
## Forward to `CliquePoll`: Minimum number of authorised signers needed.
|
||||
s.data.ballot.authSignersThreshold
|
||||
|
||||
proc isSigner*(s: var Snapshot; address: EthAddress): bool =
|
||||
## Checks whether argukment ``address` is in signers list
|
||||
s.data.ballot.isAuthSigner(address)
|
||||
|
||||
proc signers*(s: var Snapshot): seq[EthAddress] =
|
||||
## Retrieves the sorted list of authorized signers
|
||||
s.data.ballot.authSigners
|
||||
|
||||
|
||||
# clique/snapshot.go(319): func (s *Snapshot) inturn(number [..]
|
||||
proc inTurn*(s: var Snapshot; number: BlockNumber, signer: EthAddress): bool =
|
||||
## Returns `true` if a signer at a given block height is in-turn or not.
|
||||
let ascSignersList = s.data.ballot.authSigners
|
||||
for offset in 0 ..< ascSignersList.len:
|
||||
if ascSignersList[offset] == signer:
|
||||
return (number mod ascSignersList.len.u256) == offset.u256
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Debugging/testing
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
when isMainModule and isMainOK:
|
||||
|
||||
var
|
||||
cfg = newMemoryDB().newBaseChainDB.newCliqueCfg
|
||||
ssh, ss1, ss2: Snapshot
|
||||
key: Hash256
|
||||
hdr: BlockHeader
|
||||
|
||||
ssh.init(cfg, 0.u256, key, @[])
|
||||
ssh.data.blockNumber = 77.u256
|
||||
key = ssh.data.blockHash
|
||||
|
||||
ssh.store.expect("store failed")
|
||||
echo ">>> ", rlp.encode(ssh.data)
|
||||
|
||||
ss2.init(cfg, 0.u256, key, @[])
|
||||
ss2.load(cfg,key).expect("load failed")
|
||||
|
||||
echo ">>> ", rlp.encode(ss2.data)
|
||||
|
||||
doAssert rlp.encode(ssh.data) == rlp.encode(ss2.data)
|
||||
#discard ss1.data.sigcache.getEcRecover(hdr)
|
||||
|
||||
ss1 = ss2
|
||||
echo "ss1.data: ", ss1.data.repr
|
||||
echo "ss2.data: ", ss2.data.repr
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
# ------------------------------------------------------------------------------
|
||||
Loading…
Reference in New Issue