mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-05-09 09:36:40 +00:00
d422ab39d5
This PR removes `FinalizeAndAssemble` from the consensus engine interface and relocates block assembly logic outside of the consensus engine. Block assembly is consensus-agnostic. Most validations can be performed by the caller. For example: - Withdrawals must be nil prior to Shanghai - After Shanghai upgrade, withdrawals must be non-nil, even if empty. The only notable consensus-specific validation is related to uncles. In clique, the concept of uncles does not exist, and any block containing uncles should be considered invalid. Within the block production package, the policy is to produce blocks according to the latest chain specification. As a result, Clique-specific block production is no longer supported. This tradeoff is considered acceptable.
105 lines
4.4 KiB
Go
105 lines
4.4 KiB
Go
// Copyright 2017 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
// Package consensus implements different Ethereum consensus engines.
|
|
package consensus
|
|
|
|
import (
|
|
"math/big"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
"github.com/ethereum/go-ethereum/params"
|
|
)
|
|
|
|
// ChainHeaderReader defines a small collection of methods needed to access the local
|
|
// blockchain during header verification.
|
|
type ChainHeaderReader interface {
|
|
// Config retrieves the blockchain's chain configuration.
|
|
Config() *params.ChainConfig
|
|
|
|
// CurrentHeader retrieves the current header from the local chain.
|
|
CurrentHeader() *types.Header
|
|
|
|
// GetHeader retrieves a block header from the database by hash and number.
|
|
GetHeader(hash common.Hash, number uint64) *types.Header
|
|
|
|
// GetHeaderByNumber retrieves a block header from the database by number.
|
|
GetHeaderByNumber(number uint64) *types.Header
|
|
|
|
// GetHeaderByHash retrieves a block header from the database by its hash.
|
|
GetHeaderByHash(hash common.Hash) *types.Header
|
|
}
|
|
|
|
// ChainReader defines a small collection of methods needed to access the local
|
|
// blockchain during header and/or uncle verification.
|
|
type ChainReader interface {
|
|
ChainHeaderReader
|
|
|
|
// GetBlock retrieves a block from the database by hash and number.
|
|
GetBlock(hash common.Hash, number uint64) *types.Block
|
|
}
|
|
|
|
// Engine is an algorithm agnostic consensus engine.
|
|
type Engine interface {
|
|
// Author retrieves the Ethereum address of the account that minted the given
|
|
// block, which may be different from the header's coinbase if a consensus
|
|
// engine is based on signatures.
|
|
Author(header *types.Header) (common.Address, error)
|
|
|
|
// VerifyHeader checks whether a header conforms to the consensus rules of a
|
|
// given engine.
|
|
VerifyHeader(chain ChainHeaderReader, header *types.Header) error
|
|
|
|
// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers
|
|
// concurrently. The method returns a quit channel to abort the operations and
|
|
// a results channel to retrieve the async verifications (the order is that of
|
|
// the input slice).
|
|
VerifyHeaders(chain ChainHeaderReader, headers []*types.Header) (chan<- struct{}, <-chan error)
|
|
|
|
// VerifyUncles verifies that the given block's uncles conform to the consensus
|
|
// rules of a given engine.
|
|
VerifyUncles(chain ChainReader, block *types.Block) error
|
|
|
|
// Prepare initializes the consensus fields of a block header according to the
|
|
// rules of a particular engine. The changes are executed inline.
|
|
Prepare(chain ChainHeaderReader, header *types.Header) error
|
|
|
|
// Finalize runs any post-transaction state modifications (e.g. block rewards
|
|
// or process withdrawals) but does not assemble the block.
|
|
//
|
|
// Note: The state database might be updated to reflect any consensus rules
|
|
// that happen at finalization (e.g. block rewards).
|
|
Finalize(chain ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body)
|
|
|
|
// Seal generates a new sealing request for the given input block and pushes
|
|
// the result into the given channel.
|
|
//
|
|
// Note, the method returns immediately and will send the result async. More
|
|
// than one result may also be returned depending on the consensus algorithm.
|
|
Seal(chain ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error
|
|
|
|
// SealHash returns the hash of a block prior to it being sealed.
|
|
SealHash(header *types.Header) common.Hash
|
|
|
|
// CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty
|
|
// that a new block should have.
|
|
CalcDifficulty(chain ChainHeaderReader, time uint64, parent *types.Header) *big.Int
|
|
|
|
// Close terminates any background threads maintained by the consensus engine.
|
|
Close() error
|
|
}
|