2017-04-04 22:16:29 +00:00
|
|
|
// 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 ethash
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
|
|
|
"math/big"
|
|
|
|
"runtime"
|
|
|
|
"time"
|
|
|
|
|
2018-07-16 07:54:19 +00:00
|
|
|
mapset "github.com/deckarep/golang-set"
|
2017-04-04 22:16:29 +00:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"github.com/ethereum/go-ethereum/common/math"
|
|
|
|
"github.com/ethereum/go-ethereum/consensus"
|
|
|
|
"github.com/ethereum/go-ethereum/consensus/misc"
|
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2018-08-23 13:02:57 +00:00
|
|
|
"github.com/ethereum/go-ethereum/rlp"
|
2020-08-21 12:10:40 +00:00
|
|
|
"github.com/ethereum/go-ethereum/trie"
|
2019-01-03 22:15:26 +00:00
|
|
|
"golang.org/x/crypto/sha3"
|
2017-04-04 22:16:29 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// Ethash proof-of-work protocol constants.
|
|
|
|
var (
|
2021-01-26 11:17:11 +00:00
|
|
|
FrontierBlockReward = big.NewInt(5e+18) // Block reward in wei for successfully mining a block
|
|
|
|
ByzantiumBlockReward = big.NewInt(3e+18) // Block reward in wei for successfully mining a block upward from Byzantium
|
|
|
|
ConstantinopleBlockReward = big.NewInt(2e+18) // Block reward in wei for successfully mining a block upward from Constantinople
|
|
|
|
maxUncles = 2 // Maximum number of uncles allowed in a single block
|
|
|
|
allowedFutureBlockTimeSeconds = int64(15) // Max seconds from current time allowed for blocks, before they're considered future blocks
|
2018-09-15 21:44:25 +00:00
|
|
|
|
2021-10-28 20:18:14 +00:00
|
|
|
// calcDifficultyEip4345 is the difficulty adjustment algorithm as specified by EIP 4345.
|
|
|
|
// It offsets the bomb a total of 10.7M blocks.
|
|
|
|
// Specification EIP-4345: https://eips.ethereum.org/EIPS/eip-4345
|
|
|
|
calcDifficultyEip4345 = makeDifficultyCalculator(big.NewInt(10_700_000))
|
|
|
|
|
2021-05-07 12:04:54 +00:00
|
|
|
// calcDifficultyEip3554 is the difficulty adjustment algorithm as specified by EIP 3554.
|
2021-05-17 08:49:23 +00:00
|
|
|
// It offsets the bomb a total of 9.7M blocks.
|
2021-05-07 12:04:54 +00:00
|
|
|
// Specification EIP-3554: https://eips.ethereum.org/EIPS/eip-3554
|
2021-05-17 08:49:23 +00:00
|
|
|
calcDifficultyEip3554 = makeDifficultyCalculator(big.NewInt(9700000))
|
2021-05-07 12:04:54 +00:00
|
|
|
|
2019-12-06 09:36:40 +00:00
|
|
|
// calcDifficultyEip2384 is the difficulty adjustment algorithm as specified by EIP 2384.
|
|
|
|
// It offsets the bomb 4M blocks from Constantinople, so in total 9M blocks.
|
|
|
|
// Specification EIP-2384: https://eips.ethereum.org/EIPS/eip-2384
|
|
|
|
calcDifficultyEip2384 = makeDifficultyCalculator(big.NewInt(9000000))
|
|
|
|
|
2018-09-15 21:44:25 +00:00
|
|
|
// calcDifficultyConstantinople is the difficulty adjustment algorithm for Constantinople.
|
|
|
|
// It returns the difficulty that a new block should have when created at time given the
|
2018-09-17 09:49:39 +00:00
|
|
|
// parent block's time and difficulty. The calculation uses the Byzantium rules, but with
|
|
|
|
// bomb offset 5M.
|
|
|
|
// Specification EIP-1234: https://eips.ethereum.org/EIPS/eip-1234
|
|
|
|
calcDifficultyConstantinople = makeDifficultyCalculator(big.NewInt(5000000))
|
2018-09-15 21:44:25 +00:00
|
|
|
|
|
|
|
// calcDifficultyByzantium is the difficulty adjustment algorithm. It returns
|
|
|
|
// the difficulty that a new block should have when created at time given the
|
|
|
|
// parent block's time and difficulty. The calculation uses the Byzantium rules.
|
2018-09-17 09:49:39 +00:00
|
|
|
// Specification EIP-649: https://eips.ethereum.org/EIPS/eip-649
|
|
|
|
calcDifficultyByzantium = makeDifficultyCalculator(big.NewInt(3000000))
|
2017-04-04 22:16:29 +00:00
|
|
|
)
|
|
|
|
|
2017-04-10 10:24:12 +00:00
|
|
|
// Various error messages to mark blocks invalid. These should be private to
|
|
|
|
// prevent engine specific errors from being referenced in the remainder of the
|
|
|
|
// codebase, inherently breaking if the engine is swapped out. Please put common
|
|
|
|
// error types into the consensus package.
|
2017-04-04 22:16:29 +00:00
|
|
|
var (
|
2020-01-07 17:19:21 +00:00
|
|
|
errOlderBlockTime = errors.New("timestamp older than parent")
|
2017-04-10 10:24:12 +00:00
|
|
|
errTooManyUncles = errors.New("too many uncles")
|
|
|
|
errDuplicateUncle = errors.New("duplicate uncle")
|
|
|
|
errUncleIsAncestor = errors.New("uncle is ancestor")
|
|
|
|
errDanglingUncle = errors.New("uncle's parent is not ancestor")
|
|
|
|
errInvalidDifficulty = errors.New("non-positive difficulty")
|
|
|
|
errInvalidMixDigest = errors.New("invalid mix digest")
|
|
|
|
errInvalidPoW = errors.New("invalid proof-of-work")
|
2017-04-04 22:16:29 +00:00
|
|
|
)
|
|
|
|
|
2017-04-12 13:38:31 +00:00
|
|
|
// Author implements consensus.Engine, returning the header's coinbase as the
|
|
|
|
// proof-of-work verified author of the block.
|
|
|
|
func (ethash *Ethash) Author(header *types.Header) (common.Address, error) {
|
|
|
|
return header.Coinbase, nil
|
|
|
|
}
|
|
|
|
|
2017-04-04 22:16:29 +00:00
|
|
|
// VerifyHeader checks whether a header conforms to the consensus rules of the
|
|
|
|
// stock Ethereum ethash engine.
|
2020-07-28 15:02:35 +00:00
|
|
|
func (ethash *Ethash) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, seal bool) error {
|
2017-04-04 22:16:29 +00:00
|
|
|
// If we're running a full engine faking, accept any input as valid
|
2017-11-24 14:10:27 +00:00
|
|
|
if ethash.config.PowMode == ModeFullFake {
|
2017-04-04 22:16:29 +00:00
|
|
|
return nil
|
|
|
|
}
|
2019-10-28 07:57:34 +00:00
|
|
|
// Short circuit if the header is known, or its parent not
|
2017-04-04 22:16:29 +00:00
|
|
|
number := header.Number.Uint64()
|
|
|
|
if chain.GetHeader(header.Hash(), number) != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
parent := chain.GetHeader(header.ParentHash, number-1)
|
|
|
|
if parent == nil {
|
2017-04-06 11:58:03 +00:00
|
|
|
return consensus.ErrUnknownAncestor
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
// Sanity checks passed, do a proper verification
|
2021-01-26 11:17:11 +00:00
|
|
|
return ethash.verifyHeader(chain, header, parent, false, seal, time.Now().Unix())
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
2020-07-28 15:02:35 +00:00
|
|
|
func (ethash *Ethash) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) {
|
2017-04-04 22:16:29 +00:00
|
|
|
// If we're running a full engine faking, accept any input as valid
|
2017-11-24 14:10:27 +00:00
|
|
|
if ethash.config.PowMode == ModeFullFake || len(headers) == 0 {
|
2017-04-04 22:16:29 +00:00
|
|
|
abort, results := make(chan struct{}), make(chan error, len(headers))
|
|
|
|
for i := 0; i < len(headers); i++ {
|
|
|
|
results <- nil
|
|
|
|
}
|
|
|
|
return abort, results
|
|
|
|
}
|
2017-04-12 16:48:49 +00:00
|
|
|
|
2017-04-04 22:16:29 +00:00
|
|
|
// Spawn as many workers as allowed threads
|
|
|
|
workers := runtime.GOMAXPROCS(0)
|
|
|
|
if len(headers) < workers {
|
|
|
|
workers = len(headers)
|
|
|
|
}
|
|
|
|
|
2017-04-12 16:48:49 +00:00
|
|
|
// Create a task channel and spawn the verifiers
|
|
|
|
var (
|
2021-01-26 11:17:11 +00:00
|
|
|
inputs = make(chan int)
|
|
|
|
done = make(chan int, workers)
|
|
|
|
errors = make([]error, len(headers))
|
|
|
|
abort = make(chan struct{})
|
|
|
|
unixNow = time.Now().Unix()
|
2017-04-12 16:48:49 +00:00
|
|
|
)
|
2017-04-04 22:16:29 +00:00
|
|
|
for i := 0; i < workers; i++ {
|
|
|
|
go func() {
|
|
|
|
for index := range inputs {
|
2021-01-26 11:17:11 +00:00
|
|
|
errors[index] = ethash.verifyHeaderWorker(chain, headers, seals, index, unixNow)
|
2017-04-12 16:48:49 +00:00
|
|
|
done <- index
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
2017-04-12 16:48:49 +00:00
|
|
|
errorsOut := make(chan error, len(headers))
|
2017-04-04 22:16:29 +00:00
|
|
|
go func() {
|
|
|
|
defer close(inputs)
|
2017-04-12 16:48:49 +00:00
|
|
|
var (
|
|
|
|
in, out = 0, 0
|
|
|
|
checked = make([]bool, len(headers))
|
|
|
|
inputs = inputs
|
|
|
|
)
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case inputs <- in:
|
|
|
|
if in++; in == len(headers) {
|
|
|
|
// Reached end of headers. Stop sending to workers.
|
|
|
|
inputs = nil
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2017-04-12 16:48:49 +00:00
|
|
|
case index := <-done:
|
|
|
|
for checked[index] = true; checked[out]; out++ {
|
|
|
|
errorsOut <- errors[out]
|
|
|
|
if out == len(headers)-1 {
|
|
|
|
return
|
|
|
|
}
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2017-04-12 16:48:49 +00:00
|
|
|
case <-abort:
|
|
|
|
return
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
2017-04-12 16:48:49 +00:00
|
|
|
return abort, errorsOut
|
|
|
|
}
|
|
|
|
|
2021-01-26 11:17:11 +00:00
|
|
|
func (ethash *Ethash) verifyHeaderWorker(chain consensus.ChainHeaderReader, headers []*types.Header, seals []bool, index int, unixNow int64) error {
|
2017-04-12 16:48:49 +00:00
|
|
|
var parent *types.Header
|
|
|
|
if index == 0 {
|
|
|
|
parent = chain.GetHeader(headers[0].ParentHash, headers[0].Number.Uint64()-1)
|
|
|
|
} else if headers[index-1].Hash() == headers[index].ParentHash {
|
|
|
|
parent = headers[index-1]
|
|
|
|
}
|
|
|
|
if parent == nil {
|
|
|
|
return consensus.ErrUnknownAncestor
|
|
|
|
}
|
2021-01-26 11:17:11 +00:00
|
|
|
return ethash.verifyHeader(chain, headers[index], parent, false, seals[index], unixNow)
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// VerifyUncles verifies that the given block's uncles conform to the consensus
|
|
|
|
// rules of the stock Ethereum ethash engine.
|
|
|
|
func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Block) error {
|
|
|
|
// If we're running a full engine faking, accept any input as valid
|
2017-11-24 14:10:27 +00:00
|
|
|
if ethash.config.PowMode == ModeFullFake {
|
2017-04-04 22:16:29 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
// Verify that there are at most 2 uncles included in this block
|
|
|
|
if len(block.Uncles()) > maxUncles {
|
2017-04-10 10:24:12 +00:00
|
|
|
return errTooManyUncles
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2019-04-08 07:13:05 +00:00
|
|
|
if len(block.Uncles()) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
2017-04-04 22:16:29 +00:00
|
|
|
// Gather the set of past uncles and ancestors
|
2018-07-16 07:54:19 +00:00
|
|
|
uncles, ancestors := mapset.NewSet(), make(map[common.Hash]*types.Header)
|
2017-04-04 22:16:29 +00:00
|
|
|
|
|
|
|
number, parent := block.NumberU64()-1, block.ParentHash()
|
|
|
|
for i := 0; i < 7; i++ {
|
2020-08-20 18:34:31 +00:00
|
|
|
ancestorHeader := chain.GetHeader(parent, number)
|
|
|
|
if ancestorHeader == nil {
|
2017-04-04 22:16:29 +00:00
|
|
|
break
|
|
|
|
}
|
2020-08-20 18:34:31 +00:00
|
|
|
ancestors[parent] = ancestorHeader
|
|
|
|
// If the ancestor doesn't have any uncles, we don't have to iterate them
|
|
|
|
if ancestorHeader.UncleHash != types.EmptyUncleHash {
|
2021-07-29 08:17:40 +00:00
|
|
|
// Need to add those uncles to the banned list too
|
2020-08-20 18:34:31 +00:00
|
|
|
ancestor := chain.GetBlock(parent, number)
|
|
|
|
if ancestor == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
for _, uncle := range ancestor.Uncles() {
|
|
|
|
uncles.Add(uncle.Hash())
|
|
|
|
}
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2020-08-20 18:34:31 +00:00
|
|
|
parent, number = ancestorHeader.ParentHash, number-1
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
ancestors[block.Hash()] = block.Header()
|
|
|
|
uncles.Add(block.Hash())
|
|
|
|
|
|
|
|
// Verify each of the uncles that it's recent, but not an ancestor
|
|
|
|
for _, uncle := range block.Uncles() {
|
|
|
|
// Make sure every uncle is rewarded only once
|
|
|
|
hash := uncle.Hash()
|
2018-07-16 07:54:19 +00:00
|
|
|
if uncles.Contains(hash) {
|
2017-04-10 10:24:12 +00:00
|
|
|
return errDuplicateUncle
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
uncles.Add(hash)
|
|
|
|
|
|
|
|
// Make sure the uncle has a valid ancestry
|
|
|
|
if ancestors[hash] != nil {
|
2017-04-10 10:24:12 +00:00
|
|
|
return errUncleIsAncestor
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
if ancestors[uncle.ParentHash] == nil || uncle.ParentHash == block.ParentHash() {
|
2017-04-10 10:24:12 +00:00
|
|
|
return errDanglingUncle
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2021-01-26 11:17:11 +00:00
|
|
|
if err := ethash.verifyHeader(chain, uncle, ancestors[uncle.ParentHash], true, true, time.Now().Unix()); err != nil {
|
2017-04-04 22:16:29 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// verifyHeader checks whether a header conforms to the consensus rules of the
|
|
|
|
// stock Ethereum ethash engine.
|
|
|
|
// See YP section 4.3.4. "Block Header Validity"
|
2021-01-26 11:17:11 +00:00
|
|
|
func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, parent *types.Header, uncle bool, seal bool, unixNow int64) error {
|
2017-04-04 22:16:29 +00:00
|
|
|
// Ensure that the header's extra-data section is of a reasonable size
|
|
|
|
if uint64(len(header.Extra)) > params.MaximumExtraDataSize {
|
|
|
|
return fmt.Errorf("extra-data too long: %d > %d", len(header.Extra), params.MaximumExtraDataSize)
|
|
|
|
}
|
|
|
|
// Verify the header's timestamp
|
2019-04-02 20:28:48 +00:00
|
|
|
if !uncle {
|
2021-01-26 11:17:11 +00:00
|
|
|
if header.Time > uint64(unixNow+allowedFutureBlockTimeSeconds) {
|
2017-04-06 11:58:03 +00:00
|
|
|
return consensus.ErrFutureBlock
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
}
|
2019-04-02 20:28:48 +00:00
|
|
|
if header.Time <= parent.Time {
|
2020-01-07 17:19:21 +00:00
|
|
|
return errOlderBlockTime
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2020-01-07 17:19:21 +00:00
|
|
|
// Verify the block's difficulty based on its timestamp and parent's difficulty
|
2019-04-02 20:28:48 +00:00
|
|
|
expected := ethash.CalcDifficulty(chain, header.Time, parent)
|
2017-12-22 12:37:50 +00:00
|
|
|
|
2017-04-04 22:16:29 +00:00
|
|
|
if expected.Cmp(header.Difficulty) != 0 {
|
|
|
|
return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficulty, expected)
|
|
|
|
}
|
2017-05-04 10:53:42 +00:00
|
|
|
// Verify that the gas limit is <= 2^63-1
|
2021-12-14 09:17:25 +00:00
|
|
|
if header.GasLimit > params.MaxGasLimit {
|
|
|
|
return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, params.MaxGasLimit)
|
2017-05-04 10:53:42 +00:00
|
|
|
}
|
|
|
|
// Verify that the gasUsed is <= gasLimit
|
2017-11-13 11:47:27 +00:00
|
|
|
if header.GasUsed > header.GasLimit {
|
|
|
|
return fmt.Errorf("invalid gasUsed: have %d, gasLimit %d", header.GasUsed, header.GasLimit)
|
2017-05-04 10:53:42 +00:00
|
|
|
}
|
2021-05-17 13:13:22 +00:00
|
|
|
// Verify the block's gas usage and (if applicable) verify the base fee.
|
|
|
|
if !chain.Config().IsLondon(header.Number) {
|
|
|
|
// Verify BaseFee not present before EIP-1559 fork.
|
|
|
|
if header.BaseFee != nil {
|
|
|
|
return fmt.Errorf("invalid baseFee before fork: have %d, expected 'nil'", header.BaseFee)
|
|
|
|
}
|
|
|
|
if err := misc.VerifyGaslimit(parent.GasLimit, header.GasLimit); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
} else if err := misc.VerifyEip1559Header(chain.Config(), parent, header); err != nil {
|
|
|
|
// Verify the header's EIP-1559 attributes.
|
|
|
|
return err
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
// Verify that the block number is parent's +1
|
|
|
|
if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 {
|
2017-04-06 11:58:03 +00:00
|
|
|
return consensus.ErrInvalidNumber
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
// Verify the engine specific seal securing the block
|
|
|
|
if seal {
|
2021-02-05 18:44:34 +00:00
|
|
|
if err := ethash.verifySeal(chain, header, false); err != nil {
|
2017-04-04 22:16:29 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If all checks passed, validate any special fields for hard forks
|
|
|
|
if err := misc.VerifyDAOHeaderExtraData(chain.Config(), header); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err := misc.VerifyForkHashes(chain.Config(), header, uncle); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-01 21:36:51 +00:00
|
|
|
// CalcDifficulty is the difficulty adjustment algorithm. It returns
|
|
|
|
// the difficulty that a new block should have when created at time
|
|
|
|
// given the parent block's time and difficulty.
|
2020-07-28 15:02:35 +00:00
|
|
|
func (ethash *Ethash) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent *types.Header) *big.Int {
|
2017-12-22 12:37:50 +00:00
|
|
|
return CalcDifficulty(chain.Config(), time, parent)
|
|
|
|
}
|
|
|
|
|
|
|
|
// CalcDifficulty is the difficulty adjustment algorithm. It returns
|
|
|
|
// the difficulty that a new block should have when created at time
|
|
|
|
// given the parent block's time and difficulty.
|
2017-02-01 21:36:51 +00:00
|
|
|
func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int {
|
2017-06-29 10:13:00 +00:00
|
|
|
next := new(big.Int).Add(parent.Number, big1)
|
2017-02-01 21:36:51 +00:00
|
|
|
switch {
|
2021-10-28 20:18:14 +00:00
|
|
|
case config.IsArrowGlacier(next):
|
|
|
|
return calcDifficultyEip4345(time, parent)
|
2021-05-07 12:04:54 +00:00
|
|
|
case config.IsLondon(next):
|
|
|
|
return calcDifficultyEip3554(time, parent)
|
2019-12-06 09:36:40 +00:00
|
|
|
case config.IsMuirGlacier(next):
|
|
|
|
return calcDifficultyEip2384(time, parent)
|
2018-09-12 10:33:57 +00:00
|
|
|
case config.IsConstantinople(next):
|
|
|
|
return calcDifficultyConstantinople(time, parent)
|
2017-09-14 07:07:31 +00:00
|
|
|
case config.IsByzantium(next):
|
|
|
|
return calcDifficultyByzantium(time, parent)
|
2017-02-01 21:36:51 +00:00
|
|
|
case config.IsHomestead(next):
|
|
|
|
return calcDifficultyHomestead(time, parent)
|
|
|
|
default:
|
|
|
|
return calcDifficultyFrontier(time, parent)
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Some weird constants to avoid constant memory allocs for them.
|
|
|
|
var (
|
|
|
|
expDiffPeriod = big.NewInt(100000)
|
2017-06-29 10:13:00 +00:00
|
|
|
big1 = big.NewInt(1)
|
|
|
|
big2 = big.NewInt(2)
|
2017-06-30 13:39:18 +00:00
|
|
|
big9 = big.NewInt(9)
|
2017-04-04 22:16:29 +00:00
|
|
|
big10 = big.NewInt(10)
|
|
|
|
bigMinus99 = big.NewInt(-99)
|
|
|
|
)
|
|
|
|
|
2018-09-15 21:44:25 +00:00
|
|
|
// makeDifficultyCalculator creates a difficultyCalculator with the given bomb-delay.
|
|
|
|
// the difficulty is calculated with Byzantium rules, which differs from Homestead in
|
|
|
|
// how uncles affect the calculation
|
|
|
|
func makeDifficultyCalculator(bombDelay *big.Int) func(time uint64, parent *types.Header) *big.Int {
|
2018-09-17 09:49:39 +00:00
|
|
|
// Note, the calculations below looks at the parent number, which is 1 below
|
|
|
|
// the block number. Thus we remove one from the delay given
|
|
|
|
bombDelayFromParent := new(big.Int).Sub(bombDelay, big1)
|
2018-09-15 21:44:25 +00:00
|
|
|
return func(time uint64, parent *types.Header) *big.Int {
|
|
|
|
// https://github.com/ethereum/EIPs/issues/100.
|
|
|
|
// algorithm:
|
|
|
|
// diff = (parent_diff +
|
|
|
|
// (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
|
|
|
|
// ) + 2^(periodCount - 2)
|
|
|
|
|
|
|
|
bigTime := new(big.Int).SetUint64(time)
|
2019-04-02 20:28:48 +00:00
|
|
|
bigParentTime := new(big.Int).SetUint64(parent.Time)
|
2018-09-15 21:44:25 +00:00
|
|
|
|
|
|
|
// holds intermediate values to make the algo easier to read & audit
|
|
|
|
x := new(big.Int)
|
|
|
|
y := new(big.Int)
|
|
|
|
|
|
|
|
// (2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9
|
|
|
|
x.Sub(bigTime, bigParentTime)
|
|
|
|
x.Div(x, big9)
|
|
|
|
if parent.UncleHash == types.EmptyUncleHash {
|
|
|
|
x.Sub(big1, x)
|
|
|
|
} else {
|
|
|
|
x.Sub(big2, x)
|
|
|
|
}
|
|
|
|
// max((2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9, -99)
|
|
|
|
if x.Cmp(bigMinus99) < 0 {
|
|
|
|
x.Set(bigMinus99)
|
|
|
|
}
|
|
|
|
// parent_diff + (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
|
|
|
|
y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
|
|
|
|
x.Mul(y, x)
|
|
|
|
x.Add(parent.Difficulty, x)
|
|
|
|
|
|
|
|
// minimum difficulty can ever be (before exponential factor)
|
|
|
|
if x.Cmp(params.MinimumDifficulty) < 0 {
|
|
|
|
x.Set(params.MinimumDifficulty)
|
|
|
|
}
|
2018-09-17 09:49:39 +00:00
|
|
|
// calculate a fake block number for the ice-age delay
|
|
|
|
// Specification: https://eips.ethereum.org/EIPS/eip-1234
|
2018-09-15 21:44:25 +00:00
|
|
|
fakeBlockNumber := new(big.Int)
|
2018-09-17 09:49:39 +00:00
|
|
|
if parent.Number.Cmp(bombDelayFromParent) >= 0 {
|
|
|
|
fakeBlockNumber = fakeBlockNumber.Sub(parent.Number, bombDelayFromParent)
|
2018-09-15 21:44:25 +00:00
|
|
|
}
|
|
|
|
// for the exponential factor
|
|
|
|
periodCount := fakeBlockNumber
|
|
|
|
periodCount.Div(periodCount, expDiffPeriod)
|
|
|
|
|
|
|
|
// the exponential factor, commonly referred to as "the bomb"
|
|
|
|
// diff = diff + 2^(periodCount - 2)
|
|
|
|
if periodCount.Cmp(big1) > 0 {
|
|
|
|
y.Sub(periodCount, big2)
|
|
|
|
y.Exp(big2, y, nil)
|
|
|
|
x.Add(x, y)
|
|
|
|
}
|
|
|
|
return x
|
2017-06-30 13:39:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-04 22:16:29 +00:00
|
|
|
// calcDifficultyHomestead is the difficulty adjustment algorithm. It returns
|
|
|
|
// the difficulty that a new block should have when created at time given the
|
|
|
|
// parent block's time and difficulty. The calculation uses the Homestead rules.
|
2017-02-01 21:36:51 +00:00
|
|
|
func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int {
|
2017-12-31 11:38:39 +00:00
|
|
|
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.md
|
2017-04-04 22:16:29 +00:00
|
|
|
// algorithm:
|
|
|
|
// diff = (parent_diff +
|
|
|
|
// (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
|
|
|
|
// ) + 2^(periodCount - 2)
|
|
|
|
|
2017-05-12 19:35:45 +00:00
|
|
|
bigTime := new(big.Int).SetUint64(time)
|
2019-04-02 20:28:48 +00:00
|
|
|
bigParentTime := new(big.Int).SetUint64(parent.Time)
|
2017-04-04 22:16:29 +00:00
|
|
|
|
|
|
|
// holds intermediate values to make the algo easier to read & audit
|
|
|
|
x := new(big.Int)
|
|
|
|
y := new(big.Int)
|
|
|
|
|
2017-06-29 10:13:00 +00:00
|
|
|
// 1 - (block_timestamp - parent_timestamp) // 10
|
2017-04-04 22:16:29 +00:00
|
|
|
x.Sub(bigTime, bigParentTime)
|
|
|
|
x.Div(x, big10)
|
2017-06-29 10:13:00 +00:00
|
|
|
x.Sub(big1, x)
|
2017-04-04 22:16:29 +00:00
|
|
|
|
2017-06-29 10:13:00 +00:00
|
|
|
// max(1 - (block_timestamp - parent_timestamp) // 10, -99)
|
2017-04-04 22:16:29 +00:00
|
|
|
if x.Cmp(bigMinus99) < 0 {
|
|
|
|
x.Set(bigMinus99)
|
|
|
|
}
|
|
|
|
// (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
|
2017-02-01 21:36:51 +00:00
|
|
|
y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
|
2017-04-04 22:16:29 +00:00
|
|
|
x.Mul(y, x)
|
2017-02-01 21:36:51 +00:00
|
|
|
x.Add(parent.Difficulty, x)
|
2017-04-04 22:16:29 +00:00
|
|
|
|
|
|
|
// minimum difficulty can ever be (before exponential factor)
|
|
|
|
if x.Cmp(params.MinimumDifficulty) < 0 {
|
|
|
|
x.Set(params.MinimumDifficulty)
|
|
|
|
}
|
|
|
|
// for the exponential factor
|
2017-06-29 10:13:00 +00:00
|
|
|
periodCount := new(big.Int).Add(parent.Number, big1)
|
2017-04-04 22:16:29 +00:00
|
|
|
periodCount.Div(periodCount, expDiffPeriod)
|
|
|
|
|
|
|
|
// the exponential factor, commonly referred to as "the bomb"
|
|
|
|
// diff = diff + 2^(periodCount - 2)
|
2017-06-29 10:13:00 +00:00
|
|
|
if periodCount.Cmp(big1) > 0 {
|
|
|
|
y.Sub(periodCount, big2)
|
|
|
|
y.Exp(big2, y, nil)
|
2017-04-04 22:16:29 +00:00
|
|
|
x.Add(x, y)
|
|
|
|
}
|
|
|
|
return x
|
|
|
|
}
|
|
|
|
|
|
|
|
// calcDifficultyFrontier is the difficulty adjustment algorithm. It returns the
|
|
|
|
// difficulty that a new block should have when created at time given the parent
|
|
|
|
// block's time and difficulty. The calculation uses the Frontier rules.
|
2017-02-01 21:36:51 +00:00
|
|
|
func calcDifficultyFrontier(time uint64, parent *types.Header) *big.Int {
|
2017-04-04 22:16:29 +00:00
|
|
|
diff := new(big.Int)
|
2017-02-01 21:36:51 +00:00
|
|
|
adjust := new(big.Int).Div(parent.Difficulty, params.DifficultyBoundDivisor)
|
2017-04-04 22:16:29 +00:00
|
|
|
bigTime := new(big.Int)
|
|
|
|
bigParentTime := new(big.Int)
|
|
|
|
|
|
|
|
bigTime.SetUint64(time)
|
2019-04-02 20:28:48 +00:00
|
|
|
bigParentTime.SetUint64(parent.Time)
|
2017-04-04 22:16:29 +00:00
|
|
|
|
|
|
|
if bigTime.Sub(bigTime, bigParentTime).Cmp(params.DurationLimit) < 0 {
|
2017-02-01 21:36:51 +00:00
|
|
|
diff.Add(parent.Difficulty, adjust)
|
2017-04-04 22:16:29 +00:00
|
|
|
} else {
|
2017-02-01 21:36:51 +00:00
|
|
|
diff.Sub(parent.Difficulty, adjust)
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
if diff.Cmp(params.MinimumDifficulty) < 0 {
|
|
|
|
diff.Set(params.MinimumDifficulty)
|
|
|
|
}
|
|
|
|
|
2017-06-29 10:13:00 +00:00
|
|
|
periodCount := new(big.Int).Add(parent.Number, big1)
|
2017-04-04 22:16:29 +00:00
|
|
|
periodCount.Div(periodCount, expDiffPeriod)
|
2017-06-29 10:13:00 +00:00
|
|
|
if periodCount.Cmp(big1) > 0 {
|
2017-04-04 22:16:29 +00:00
|
|
|
// diff = diff + 2^(periodCount - 2)
|
2017-06-29 10:13:00 +00:00
|
|
|
expDiff := periodCount.Sub(periodCount, big2)
|
|
|
|
expDiff.Exp(big2, expDiff, nil)
|
2017-04-04 22:16:29 +00:00
|
|
|
diff.Add(diff, expDiff)
|
|
|
|
diff = math.BigMax(diff, params.MinimumDifficulty)
|
|
|
|
}
|
|
|
|
return diff
|
|
|
|
}
|
|
|
|
|
2020-12-11 10:06:44 +00:00
|
|
|
// Exported for fuzzing
|
2022-04-26 08:16:57 +00:00
|
|
|
var FrontierDifficultyCalculator = calcDifficultyFrontier
|
|
|
|
var HomesteadDifficultyCalculator = calcDifficultyHomestead
|
2020-12-11 10:06:44 +00:00
|
|
|
var DynamicDifficultyCalculator = makeDifficultyCalculator
|
|
|
|
|
2018-08-15 10:50:16 +00:00
|
|
|
// verifySeal checks whether a block satisfies the PoW difficulty requirements,
|
|
|
|
// either using the usual ethash cache for it, or alternatively using a full DAG
|
|
|
|
// to make remote mining fast.
|
2020-07-28 15:02:35 +00:00
|
|
|
func (ethash *Ethash) verifySeal(chain consensus.ChainHeaderReader, header *types.Header, fulldag bool) error {
|
2017-04-04 22:16:29 +00:00
|
|
|
// If we're running a fake PoW, accept any seal as valid
|
2017-11-24 14:10:27 +00:00
|
|
|
if ethash.config.PowMode == ModeFake || ethash.config.PowMode == ModeFullFake {
|
2017-04-04 22:16:29 +00:00
|
|
|
time.Sleep(ethash.fakeDelay)
|
|
|
|
if ethash.fakeFail == header.Number.Uint64() {
|
2017-04-10 10:24:12 +00:00
|
|
|
return errInvalidPoW
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
// If we're running a shared PoW, delegate verification to it
|
|
|
|
if ethash.shared != nil {
|
2018-08-15 10:50:16 +00:00
|
|
|
return ethash.shared.verifySeal(chain, header, fulldag)
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
// Ensure that we have a valid difficulty for the block
|
|
|
|
if header.Difficulty.Sign() <= 0 {
|
2017-04-10 10:24:12 +00:00
|
|
|
return errInvalidDifficulty
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2018-08-15 10:50:16 +00:00
|
|
|
// Recompute the digest and PoW values
|
2018-02-27 16:25:56 +00:00
|
|
|
number := header.Number.Uint64()
|
|
|
|
|
2018-08-15 10:50:16 +00:00
|
|
|
var (
|
|
|
|
digest []byte
|
|
|
|
result []byte
|
|
|
|
)
|
|
|
|
// If fast-but-heavy PoW verification was requested, use an ethash dataset
|
|
|
|
if fulldag {
|
|
|
|
dataset := ethash.dataset(number, true)
|
|
|
|
if dataset.generated() {
|
2018-08-23 13:02:57 +00:00
|
|
|
digest, result = hashimotoFull(dataset.dataset, ethash.SealHash(header).Bytes(), header.Nonce.Uint64())
|
2018-08-15 10:50:16 +00:00
|
|
|
|
|
|
|
// Datasets are unmapped in a finalizer. Ensure that the dataset stays alive
|
|
|
|
// until after the call to hashimotoFull so it's not unmapped while being used.
|
|
|
|
runtime.KeepAlive(dataset)
|
|
|
|
} else {
|
|
|
|
// Dataset not yet generated, don't hang, use a cache instead
|
|
|
|
fulldag = false
|
|
|
|
}
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2018-08-15 10:50:16 +00:00
|
|
|
// If slow-but-light PoW verification was requested (or DAG not yet ready), use an ethash cache
|
|
|
|
if !fulldag {
|
|
|
|
cache := ethash.cache(number)
|
|
|
|
|
|
|
|
size := datasetSize(number)
|
|
|
|
if ethash.config.PowMode == ModeTest {
|
|
|
|
size = 32 * 1024
|
|
|
|
}
|
2018-08-23 13:02:57 +00:00
|
|
|
digest, result = hashimotoLight(size, cache.cache, ethash.SealHash(header).Bytes(), header.Nonce.Uint64())
|
2018-01-23 10:05:30 +00:00
|
|
|
|
2018-08-15 10:50:16 +00:00
|
|
|
// Caches are unmapped in a finalizer. Ensure that the cache stays alive
|
|
|
|
// until after the call to hashimotoLight so it's not unmapped while being used.
|
|
|
|
runtime.KeepAlive(cache)
|
|
|
|
}
|
|
|
|
// Verify the calculated values against the ones provided in the header
|
2017-04-04 22:16:29 +00:00
|
|
|
if !bytes.Equal(header.MixDigest[:], digest) {
|
2017-04-10 10:24:12 +00:00
|
|
|
return errInvalidMixDigest
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2018-08-08 09:15:08 +00:00
|
|
|
target := new(big.Int).Div(two256, header.Difficulty)
|
2017-04-04 22:16:29 +00:00
|
|
|
if new(big.Int).SetBytes(result).Cmp(target) > 0 {
|
2017-04-10 10:24:12 +00:00
|
|
|
return errInvalidPoW
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Prepare implements consensus.Engine, initializing the difficulty field of a
|
|
|
|
// header to conform to the ethash protocol. The changes are done inline.
|
2020-07-28 15:02:35 +00:00
|
|
|
func (ethash *Ethash) Prepare(chain consensus.ChainHeaderReader, header *types.Header) error {
|
2017-04-04 22:16:29 +00:00
|
|
|
parent := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1)
|
|
|
|
if parent == nil {
|
2017-04-06 11:58:03 +00:00
|
|
|
return consensus.ErrUnknownAncestor
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
2019-04-02 20:28:48 +00:00
|
|
|
header.Difficulty = ethash.CalcDifficulty(chain, header.Time, parent)
|
2017-04-04 22:16:29 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finalize implements consensus.Engine, accumulating the block and uncle rewards,
|
2019-04-30 13:42:36 +00:00
|
|
|
// setting the final state on the header
|
2020-07-28 15:02:35 +00:00
|
|
|
func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header) {
|
2019-04-30 13:42:36 +00:00
|
|
|
// Accumulate any block and uncle rewards and commit the final state root
|
|
|
|
accumulateRewards(chain.Config(), state, header, uncles)
|
|
|
|
header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
|
|
|
|
}
|
|
|
|
|
|
|
|
// FinalizeAndAssemble implements consensus.Engine, accumulating the block and
|
|
|
|
// uncle rewards, setting the final state and assembling the block.
|
2020-07-28 15:02:35 +00:00
|
|
|
func (ethash *Ethash) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
|
2020-12-11 14:49:44 +00:00
|
|
|
// Finalize block
|
|
|
|
ethash.Finalize(chain, header, state, txs, uncles)
|
2017-04-04 22:16:29 +00:00
|
|
|
|
|
|
|
// Header seems complete, assemble into a block and return
|
2021-02-02 12:09:23 +00:00
|
|
|
return types.NewBlock(header, txs, uncles, receipts, trie.NewStackTrie(nil)), nil
|
2017-04-04 22:16:29 +00:00
|
|
|
}
|
|
|
|
|
2018-08-23 13:02:57 +00:00
|
|
|
// SealHash returns the hash of a block prior to it being sealed.
|
|
|
|
func (ethash *Ethash) SealHash(header *types.Header) (hash common.Hash) {
|
2019-01-03 22:15:26 +00:00
|
|
|
hasher := sha3.NewLegacyKeccak256()
|
2018-08-23 13:02:57 +00:00
|
|
|
|
2021-05-17 13:13:22 +00:00
|
|
|
enc := []interface{}{
|
2018-08-23 13:02:57 +00:00
|
|
|
header.ParentHash,
|
|
|
|
header.UncleHash,
|
|
|
|
header.Coinbase,
|
|
|
|
header.Root,
|
|
|
|
header.TxHash,
|
|
|
|
header.ReceiptHash,
|
|
|
|
header.Bloom,
|
|
|
|
header.Difficulty,
|
|
|
|
header.Number,
|
|
|
|
header.GasLimit,
|
|
|
|
header.GasUsed,
|
|
|
|
header.Time,
|
|
|
|
header.Extra,
|
2021-05-17 13:13:22 +00:00
|
|
|
}
|
|
|
|
if header.BaseFee != nil {
|
|
|
|
enc = append(enc, header.BaseFee)
|
|
|
|
}
|
|
|
|
rlp.Encode(hasher, enc)
|
2018-08-23 13:02:57 +00:00
|
|
|
hasher.Sum(hash[:0])
|
|
|
|
return hash
|
|
|
|
}
|
|
|
|
|
2017-04-04 22:16:29 +00:00
|
|
|
// Some weird constants to avoid constant memory allocs for them.
|
|
|
|
var (
|
|
|
|
big8 = big.NewInt(8)
|
|
|
|
big32 = big.NewInt(32)
|
|
|
|
)
|
|
|
|
|
|
|
|
// AccumulateRewards credits the coinbase of the given block with the mining
|
|
|
|
// reward. The total reward consists of the static block reward and rewards for
|
|
|
|
// included uncles. The coinbase of each uncle block is also rewarded.
|
2017-12-22 12:37:50 +00:00
|
|
|
func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
|
2017-08-24 09:26:06 +00:00
|
|
|
// Select the correct block reward based on chain progression
|
2017-10-20 08:14:10 +00:00
|
|
|
blockReward := FrontierBlockReward
|
2017-09-14 07:07:31 +00:00
|
|
|
if config.IsByzantium(header.Number) {
|
2017-10-20 08:14:10 +00:00
|
|
|
blockReward = ByzantiumBlockReward
|
2017-08-24 09:26:06 +00:00
|
|
|
}
|
2018-09-12 10:33:57 +00:00
|
|
|
if config.IsConstantinople(header.Number) {
|
|
|
|
blockReward = ConstantinopleBlockReward
|
|
|
|
}
|
2017-08-24 09:26:06 +00:00
|
|
|
// Accumulate the rewards for the miner and any included uncles
|
2017-04-04 22:16:29 +00:00
|
|
|
reward := new(big.Int).Set(blockReward)
|
|
|
|
r := new(big.Int)
|
|
|
|
for _, uncle := range uncles {
|
|
|
|
r.Add(uncle.Number, big8)
|
|
|
|
r.Sub(r, header.Number)
|
|
|
|
r.Mul(r, blockReward)
|
|
|
|
r.Div(r, big8)
|
|
|
|
state.AddBalance(uncle.Coinbase, r)
|
|
|
|
|
|
|
|
r.Div(blockReward, big32)
|
|
|
|
reward.Add(reward, r)
|
|
|
|
}
|
|
|
|
state.AddBalance(header.Coinbase, reward)
|
|
|
|
}
|