# Nimbus # Copyright (c) 2021 Status Research & Development GmbH # Licensed under either of # * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or # http://www.apache.org/licenses/LICENSE-2.0) # * MIT license ([LICENSE-MIT](LICENSE-MIT) or # http://opensource.org/licenses/MIT) # at your option. This file may not be copied, modified, or distributed except # according to those terms. import std/[sequtils, times, typetraits], pkg/[chronos, stew/results, chronicles, eth/keys, eth/rlp], ".."/[config, constants], "."/[ chain, tx_pool, casper, validate], "."/clique/[ clique_desc, clique_cfg, clique_sealer], ../utils/utils, ../common/[common, context] from web3/ethtypes as web3types import nil, TypedTransaction, WithdrawalV1, ExecutionPayloadV1OrV2, toExecutionPayloadV1OrV2, toExecutionPayloadV1 from web3/engine_api_types import PayloadAttributesV1, ExecutionPayloadV1, PayloadAttributesV2, ExecutionPayloadV2 export # generateExecutionPayload caller will need this casper type EngineState* = enum EngineStopped, EngineRunning, EnginePostMerge Web3BlockHash = web3types.BlockHash Web3Address = web3types.Address Web3Bloom = web3types.FixedBytes[256] Web3Quantity = web3types.Quantity SealingEngineRef* = ref SealingEngineObj SealingEngineObj = object of RootObj state: EngineState engineLoop: Future[void] chain*: ChainRef ctx: EthContext signer: EthAddress txPool: TxPoolRef proc validateSealer*(conf: NimbusConf, ctx: EthContext, chain: ChainRef): Result[void, string] = if conf.engineSigner == ZERO_ADDRESS: return err("signer address should not zero, use --engine-signer to set signer address") let res = ctx.am.getAccount(conf.engineSigner) if res.isErr: return err("signer address not in registered accounts, use --import-key/account to register the account") let acc = res.get() if not acc.unlocked: return err("signer account not unlocked, please unlock it first via rpc/password file") let com = chain.com if com.consensus != ConsensusType.POA: return err("currently only PoA engine is supported") ok() proc generateBlock(engine: SealingEngineRef, outBlock: var EthBlock): Result[void, string] = outBlock = engine.txPool.ethBlock() if engine.chain.com.consensus == ConsensusType.POS: # Stop the block generator if we reach TTD engine.state = EnginePostMerge if engine.state != EnginePostMerge: # Post merge, Clique should not be executing let sealRes = engine.chain.clique.seal(outBlock) if sealRes.isErr: return err("error sealing block header: " & $sealRes.error) debug "generated block", blockNumber = outBlock.header.blockNumber, blockHash = blockHash(outBlock.header) ok() proc sealingLoop(engine: SealingEngineRef): Future[void] {.async.} = let clique = engine.chain.clique proc signerFunc(signer: EthAddress, message: openArray[byte]): Result[RawSignature, cstring] {.gcsafe.} = let hashData = keccakHash(message) ctx = engine.ctx acc = ctx.am.getAccount(signer).tryGet() rawSign = sign(acc.privateKey, SkMessage(hashData.data)).toRaw ok(rawSign) clique.authorize(engine.signer, signerFunc) # convert times.Duration to chronos.Duration let period = chronos.seconds(clique.cfg.period.inSeconds) while engine.state == EngineRunning: # the sealing engine will tick every `cliquePeriod` seconds await sleepAsync(period) if engine.state != EngineRunning: break # deviation from 'correct' sealing engine: # - no queue for chain reorgs # - no async lock/guard against race with sync algo var blk: EthBlock let blkRes = engine.generateBlock(blk) if blkRes.isErr: error "sealing engine generateBlock error", msg=blkRes.error break let res = engine.chain.persistBlocks([blk.header], [ BlockBody(transactions: blk.txs, uncles: blk.uncles) ]) if res == ValidationResult.Error: error "sealing engine: persistBlocks error" break discard engine.txPool.smartHead(blk.header) # add transactions update jobs info "block generated", number=blk.header.blockNumber template unsafeQuantityToInt64(q: web3types.Quantity): int64 = int64 q proc toTypedTransaction(tx: Transaction): TypedTransaction = web3types.TypedTransaction(rlp.encode(tx.removeNetworkPayload)) func toWithdrawal(x: WithdrawalV1): Withdrawal = result.index = x.index.uint64 result.validatorIndex = x.validatorIndex.uint64 result.address = x.address.EthAddress result.amount = x.amount.uint64 func toWithdrawals(list: openArray[WithdrawalV1]): seq[Withdrawal] = result = newSeqOfCap[Withdrawal](list.len) for x in list: result.add toWithdrawal(x) proc generateExecutionPayload*(engine: SealingEngineRef, payloadAttrs: PayloadAttributesV1 | PayloadAttributesV2): Result[ExecutionPayloadV1OrV2, string] = let headBlock = try: engine.chain.db.getCanonicalHead() except CatchableError: return err "No head block in database" pos = engine.chain.com.pos pos.prevRandao = Hash256(data: distinctBase payloadAttrs.prevRandao) pos.timestamp = fromUnix(payloadAttrs.timestamp.unsafeQuantityToInt64) pos.feeRecipient = EthAddress payloadAttrs.suggestedFeeRecipient when payloadAttrs is PayloadAttributesV2: engine.txPool.withdrawals = payloadAttrs.withdrawals.toWithdrawals else: engine.txPool.withdrawals = @[] if headBlock.blockHash != engine.txPool.head.blockHash: # reorg discard engine.txPool.smartHead(headBlock) var blk: EthBlock let res = engine.generateBlock(blk) if res.isErr: error "sealing engine generateBlock error", msg = res.error return err(res.error) # make sure both generated block header and payloadRes(ExecutionPayloadV2) # produce the same blockHash blk.header.fee = some(blk.header.fee.get(UInt256.zero)) # force it with some(UInt256) let blockHash = rlpHash(blk.header) if blk.header.extraData.len > 32: return err "extraData length should not exceed 32 bytes" let transactions = blk.txs.map(toTypedTransaction) let withdrawals = when payloadAttrs is PayloadAttributesV2: some(payloadAttrs.withdrawals) else: none[seq[WithdrawalV1]]() return ok(ExecutionPayloadV1OrV2( parentHash: Web3BlockHash blk.header.parentHash.data, feeRecipient: Web3Address blk.header.coinbase, stateRoot: Web3BlockHash blk.header.stateRoot.data, receiptsRoot: Web3BlockHash blk.header.receiptRoot.data, logsBloom: Web3Bloom blk.header.bloom, prevRandao: payloadAttrs.prevRandao, blockNumber: Web3Quantity blk.header.blockNumber.truncate(uint64), gasLimit: Web3Quantity blk.header.gasLimit, gasUsed: Web3Quantity blk.header.gasUsed, timestamp: payloadAttrs.timestamp, extraData: web3types.DynamicBytes[0, 32] blk.header.extraData, baseFeePerGas: blk.header.fee.get(UInt256.zero), blockHash: Web3BlockHash blockHash.data, transactions: transactions, withdrawals: withdrawals )) proc generateExecutionPayloadV1*(engine: SealingEngineRef, payloadAttrs: PayloadAttributesV1): Result[ExecutionPayloadV1, string] = return generateExecutionPayload(engine, payloadAttrs).map(toExecutionPayloadV1) proc new*(_: type SealingEngineRef, chain: ChainRef, ctx: EthContext, signer: EthAddress, txPool: TxPoolRef, initialState: EngineState): SealingEngineRef = SealingEngineRef( chain: chain, ctx: ctx, signer: signer, txPool: txPool, state: initialState ) proc start*(engine: SealingEngineRef) = ## Starts sealing engine. if engine.state == EngineStopped: engine.state = EngineRunning engine.engineLoop = sealingLoop(engine) info "sealing engine started" proc stop*(engine: SealingEngineRef) {.async.} = ## Stop sealing engine from producing more blocks. if engine.state == EngineRunning: engine.state = EngineStopped await engine.engineLoop.cancelAndWait() info "sealing engine stopped"