mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-08-19 10:22:23 +00:00
929 lines
34 KiB
Go
929 lines
34 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 ethash
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"runtime"
|
|
"time"
|
|
|
|
mapset "github.com/deckarep/golang-set"
|
|
"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"
|
|
)
|
|
|
|
// Ethash proof-of-work protocol constants.
|
|
var (
|
|
FrontierBlockReward *big.Int = big.NewInt(5e+18) // Block reward in wei for successfully mining a block
|
|
ByzantiumBlockReward *big.Int = big.NewInt(3e+18) // Block reward in wei for successfully mining a block upward from Byzantium
|
|
SocialBlockReward *big.Int = new(big.Int).Mul(big.NewInt(50), big.NewInt(1e+18)) // Block reward in wei for successfully mining a block upward for Ethereum Social
|
|
CLOMinerReward *big.Int = new(big.Int).Mul(big.NewInt(420), big.NewInt(1e+18)) // Block reward in wei for successfully mining a block upward for Callisto Network
|
|
CLOTreasuryReward *big.Int = new(big.Int).Mul(big.NewInt(120), big.NewInt(1e+18)) // Block reward in wei for successfully mining a block upward for Callisto Network
|
|
CLOStakeReward *big.Int = new(big.Int).Mul(big.NewInt(60), big.NewInt(1e+18)) // Block reward in wei for successfully mining a block upward for Callisto Network
|
|
CLOHF1TreasuryReward *big.Int = new(big.Int).Mul(big.NewInt(60), big.NewInt(1e+18)) // Block reward in wei for successfully mining a block upward for Callisto Network
|
|
CLOHF1StakeReward *big.Int = new(big.Int).Mul(big.NewInt(120), big.NewInt(1e+18)) // Block reward in wei for successfully mining a block upward for Callisto Network
|
|
maxUncles = 2 // Maximum number of uncles allowed in a single block
|
|
allowedFutureBlockTime = 15 * time.Second // Max time from current time allowed for blocks, before they're considered future blocks
|
|
DisinflationRateQuotient = big.NewInt(4) // Disinflation rate quotient for ECIP1017
|
|
DisinflationRateDivisor = big.NewInt(5) // Disinflation rate divisor for ECIP1017
|
|
ExpDiffPeriod = big.NewInt(100000) // Exponential diff period for ECIP1010
|
|
)
|
|
|
|
// 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.
|
|
var (
|
|
errLargeBlockTime = errors.New("timestamp too big")
|
|
errZeroBlockTime = errors.New("timestamp equals parent's")
|
|
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")
|
|
)
|
|
|
|
// 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
|
|
}
|
|
|
|
// VerifyHeader checks whether a header conforms to the consensus rules of the
|
|
// stock Ethereum ethash engine.
|
|
func (ethash *Ethash) VerifyHeader(chain consensus.ChainReader, header *types.Header, seal bool) error {
|
|
// If we're running a full engine faking, accept any input as valid
|
|
if ethash.config.PowMode == ModeFullFake {
|
|
return nil
|
|
}
|
|
// Short circuit if the header is known, or it's parent not
|
|
number := header.Number.Uint64()
|
|
if chain.GetHeader(header.Hash(), number) != nil {
|
|
return nil
|
|
}
|
|
parent := chain.GetHeader(header.ParentHash, number-1)
|
|
if parent == nil {
|
|
return consensus.ErrUnknownAncestor
|
|
}
|
|
// Sanity checks passed, do a proper verification
|
|
return ethash.verifyHeader(chain, header, parent, false, seal)
|
|
}
|
|
|
|
// 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.
|
|
func (ethash *Ethash) VerifyHeaders(chain consensus.ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) {
|
|
// If we're running a full engine faking, accept any input as valid
|
|
if ethash.config.PowMode == ModeFullFake || len(headers) == 0 {
|
|
abort, results := make(chan struct{}), make(chan error, len(headers))
|
|
for i := 0; i < len(headers); i++ {
|
|
results <- nil
|
|
}
|
|
return abort, results
|
|
}
|
|
|
|
// Spawn as many workers as allowed threads
|
|
workers := runtime.GOMAXPROCS(0)
|
|
if len(headers) < workers {
|
|
workers = len(headers)
|
|
}
|
|
|
|
// Create a task channel and spawn the verifiers
|
|
var (
|
|
inputs = make(chan int)
|
|
done = make(chan int, workers)
|
|
errors = make([]error, len(headers))
|
|
abort = make(chan struct{})
|
|
)
|
|
for i := 0; i < workers; i++ {
|
|
go func() {
|
|
for index := range inputs {
|
|
errors[index] = ethash.verifyHeaderWorker(chain, headers, seals, index)
|
|
done <- index
|
|
}
|
|
}()
|
|
}
|
|
|
|
errorsOut := make(chan error, len(headers))
|
|
go func() {
|
|
defer close(inputs)
|
|
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
|
|
}
|
|
case index := <-done:
|
|
for checked[index] = true; checked[out]; out++ {
|
|
errorsOut <- errors[out]
|
|
if out == len(headers)-1 {
|
|
return
|
|
}
|
|
}
|
|
case <-abort:
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
return abort, errorsOut
|
|
}
|
|
|
|
func (ethash *Ethash) verifyHeaderWorker(chain consensus.ChainReader, headers []*types.Header, seals []bool, index int) error {
|
|
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
|
|
}
|
|
if chain.GetHeader(headers[index].Hash(), headers[index].Number.Uint64()) != nil {
|
|
return nil // known block
|
|
}
|
|
return ethash.verifyHeader(chain, headers[index], parent, false, seals[index])
|
|
}
|
|
|
|
// 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
|
|
if ethash.config.PowMode == ModeFullFake {
|
|
return nil
|
|
}
|
|
// Verify that there are at most 2 uncles included in this block
|
|
if len(block.Uncles()) > maxUncles {
|
|
return errTooManyUncles
|
|
}
|
|
// Gather the set of past uncles and ancestors
|
|
uncles, ancestors := mapset.NewSet(), make(map[common.Hash]*types.Header)
|
|
|
|
number, parent := block.NumberU64()-1, block.ParentHash()
|
|
for i := 0; i < 7; i++ {
|
|
ancestor := chain.GetBlock(parent, number)
|
|
if ancestor == nil {
|
|
break
|
|
}
|
|
ancestors[ancestor.Hash()] = ancestor.Header()
|
|
for _, uncle := range ancestor.Uncles() {
|
|
uncles.Add(uncle.Hash())
|
|
}
|
|
parent, number = ancestor.ParentHash(), number-1
|
|
}
|
|
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()
|
|
if uncles.Contains(hash) {
|
|
return errDuplicateUncle
|
|
}
|
|
uncles.Add(hash)
|
|
|
|
// Make sure the uncle has a valid ancestry
|
|
if ancestors[hash] != nil {
|
|
return errUncleIsAncestor
|
|
}
|
|
if ancestors[uncle.ParentHash] == nil || uncle.ParentHash == block.ParentHash() {
|
|
return errDanglingUncle
|
|
}
|
|
if err := ethash.verifyHeader(chain, uncle, ancestors[uncle.ParentHash], true, true); err != nil {
|
|
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"
|
|
func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *types.Header, uncle bool, seal bool) error {
|
|
// 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
|
|
if uncle {
|
|
if header.Time.Cmp(math.MaxBig256) > 0 {
|
|
return errLargeBlockTime
|
|
}
|
|
} else {
|
|
if header.Time.Cmp(big.NewInt(time.Now().Add(allowedFutureBlockTime).Unix())) > 0 {
|
|
return consensus.ErrFutureBlock
|
|
}
|
|
}
|
|
if header.Time.Cmp(parent.Time) <= 0 {
|
|
return errZeroBlockTime
|
|
}
|
|
// Verify the block's difficulty based in it's timestamp and parent's difficulty
|
|
expected := ethash.CalcDifficulty(chain, header.Time.Uint64(), parent)
|
|
|
|
if expected.Cmp(header.Difficulty) != 0 {
|
|
return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficulty, expected)
|
|
}
|
|
// Verify that the gas limit is <= 2^63-1
|
|
cap := uint64(0x7fffffffffffffff)
|
|
if header.GasLimit > cap {
|
|
return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, cap)
|
|
}
|
|
// Verify that the gasUsed is <= gasLimit
|
|
if header.GasUsed > header.GasLimit {
|
|
return fmt.Errorf("invalid gasUsed: have %d, gasLimit %d", header.GasUsed, header.GasLimit)
|
|
}
|
|
|
|
// Verify that the gas limit remains within allowed bounds
|
|
diff := int64(parent.GasLimit) - int64(header.GasLimit)
|
|
if diff < 0 {
|
|
diff *= -1
|
|
}
|
|
limit := parent.GasLimit / params.GasLimitBoundDivisor
|
|
|
|
if uint64(diff) >= limit || header.GasLimit < params.MinGasLimit {
|
|
return fmt.Errorf("invalid gas limit: have %d, want %d += %d", header.GasLimit, parent.GasLimit, limit)
|
|
}
|
|
// 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 {
|
|
return consensus.ErrInvalidNumber
|
|
}
|
|
// Verify the engine specific seal securing the block
|
|
if seal {
|
|
if err := ethash.VerifySeal(chain, header); err != nil {
|
|
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
|
|
}
|
|
|
|
// 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.
|
|
func (ethash *Ethash) CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Header) *big.Int {
|
|
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.
|
|
func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int {
|
|
next := new(big.Int).Add(parent.Number, big1)
|
|
switch {
|
|
case config.IsCLOHF1(next):
|
|
return calcDifficultyCLOHF1(time, parent)
|
|
case config.IsBombDisposal(next):
|
|
return calcDifficultyBombDisposal(time, parent)
|
|
case config.IsByzantium(next):
|
|
return calcDifficultyByzantium(time, parent)
|
|
case config.IsECIP1010(next):
|
|
return calcDifficultyECIP1010(time, parent, next, config.ECIP1010PauseBlock, config.ECIP1010Length)
|
|
case config.IsHomestead(next):
|
|
return calcDifficultyHomestead(time, parent)
|
|
default:
|
|
return calcDifficultyFrontier(time, parent)
|
|
}
|
|
}
|
|
|
|
// Some weird constants to avoid constant memory allocs for them.
|
|
var (
|
|
expDiffPeriod = big.NewInt(100000)
|
|
big1 = big.NewInt(1)
|
|
big2 = big.NewInt(2)
|
|
big9 = big.NewInt(9)
|
|
big10 = big.NewInt(10)
|
|
bigMinus99 = big.NewInt(-99)
|
|
big2999999 = big.NewInt(2999999)
|
|
)
|
|
|
|
// calcDifficultyCLOHF1 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 CLOHF1 rules.
|
|
func calcDifficultyCLOHF1(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))
|
|
// )
|
|
|
|
bigTime := new(big.Int).SetUint64(time)
|
|
bigParentTime := new(big.Int).Set(parent.Time)
|
|
|
|
// 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)
|
|
}
|
|
return x
|
|
}
|
|
|
|
// 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.
|
|
func calcDifficultyByzantium(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)
|
|
bigParentTime := new(big.Int).Set(parent.Time)
|
|
|
|
// 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)
|
|
}
|
|
// calculate a fake block number for the ice-age delay:
|
|
// https://github.com/ethereum/EIPs/pull/669
|
|
// fake_block_number = max(0, block.number - 3_000_000)
|
|
fakeBlockNumber := new(big.Int)
|
|
if parent.Number.Cmp(big2999999) >= 0 {
|
|
fakeBlockNumber = fakeBlockNumber.Sub(parent.Number, big2999999) // Note, parent is 1 less than the actual block number
|
|
}
|
|
// 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
|
|
}
|
|
|
|
// calcDifficultyBombDisposal 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/Bomb
|
|
// Disposal rules.
|
|
func calcDifficultyBombDisposal(time uint64, parent *types.Header) *big.Int {
|
|
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.md
|
|
// algorithm:
|
|
// diff = (parent_diff +
|
|
// (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
|
|
// )
|
|
|
|
bigTime := new(big.Int).SetUint64(time)
|
|
bigParentTime := new(big.Int).Set(parent.Time)
|
|
|
|
// holds intermediate values to make the algo easier to read & audit
|
|
x := new(big.Int)
|
|
y := new(big.Int)
|
|
|
|
// 1 - (block_timestamp - parent_timestamp) // 10
|
|
x.Sub(bigTime, bigParentTime)
|
|
x.Div(x, big10)
|
|
x.Sub(big1, x)
|
|
|
|
// max(1 - (block_timestamp - parent_timestamp) // 10, -99)
|
|
if x.Cmp(bigMinus99) < 0 {
|
|
x.Set(bigMinus99)
|
|
}
|
|
// (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -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)
|
|
}
|
|
|
|
return x
|
|
}
|
|
|
|
func calcDifficultyECIP1010(time uint64, parent *types.Header, nextBlock *big.Int, pauseBlock *big.Int, length *big.Int) *big.Int {
|
|
explosionBlock := big.NewInt(0).Add(pauseBlock, length)
|
|
if nextBlock.Cmp(explosionBlock) < 0 {
|
|
return calcDifficultyDiehard(time, parent.Time.Uint64(), parent.Difficulty, pauseBlock)
|
|
} else {
|
|
return calcDifficultyExplosion(time, parent.Time.Uint64(), parent.Number, parent.Difficulty, pauseBlock, explosionBlock)
|
|
}
|
|
}
|
|
|
|
func calcDifficultyDiehard(time, parentTime uint64, parentDiff *big.Int, diehardBlock *big.Int) *big.Int {
|
|
// https://github.com/ethereumproject/ECIPs/blob/master/ECIPS/ECIP-1010.md
|
|
// algorithm:
|
|
// diff = (parent_diff +
|
|
// (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
|
|
// ) + 2^(fixed_diff)
|
|
|
|
bigTime := new(big.Int).SetUint64(time)
|
|
bigParentTime := new(big.Int).SetUint64(parentTime)
|
|
|
|
// holds intermediate values to make the algo easier to read & audit
|
|
x := new(big.Int)
|
|
y := new(big.Int)
|
|
|
|
// 1 - (block_timestamp -parent_timestamp) // 10
|
|
x.Sub(bigTime, bigParentTime)
|
|
x.Div(x, big10)
|
|
x.Sub(common.Big1, x)
|
|
|
|
// max(1 - (block_timestamp - parent_timestamp) // 10, -99)))
|
|
if x.Cmp(bigMinus99) < 0 {
|
|
x.Set(bigMinus99)
|
|
}
|
|
|
|
// (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
|
|
y.Div(parentDiff, params.DifficultyBoundDivisor)
|
|
x.Mul(y, x)
|
|
x.Add(parentDiff, x)
|
|
|
|
// minimum difficulty can ever be (before exponential factor)
|
|
if x.Cmp(params.MinimumDifficulty) < 0 {
|
|
x.Set(params.MinimumDifficulty)
|
|
}
|
|
|
|
// for the exponential factor
|
|
fixedCount := new(big.Int).Div(diehardBlock, ExpDiffPeriod)
|
|
|
|
// the exponential factor, commonly referred to as "the bomb"
|
|
// diff = diff + 2^(periodCount - 2)
|
|
if fixedCount.Cmp(common.Big1) > 0 {
|
|
y.Sub(fixedCount, common.Big2)
|
|
y.Exp(common.Big2, y, nil)
|
|
x.Add(x, y)
|
|
}
|
|
|
|
return x
|
|
}
|
|
|
|
func calcDifficultyExplosion(time, parentTime uint64, parentNumber, parentDiff *big.Int, delayBlock *big.Int, continueBlock *big.Int) *big.Int {
|
|
// https://github.com/ethereumproject/ECIPs/blob/master/ECIPs/ECIP-1010.md
|
|
// algorithm:
|
|
// diff = (parent_diff +
|
|
// (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
|
|
// ) + 2^(delayedCount - 2)
|
|
|
|
bigTime := new(big.Int).SetUint64(time)
|
|
bigParentTime := new(big.Int).SetUint64(parentTime)
|
|
|
|
// holds intermediate values to make the algo easier to read & audit
|
|
x := new(big.Int)
|
|
y := new(big.Int)
|
|
|
|
// 1 - (block_timestamp -parent_timestamp) // 10
|
|
x.Sub(bigTime, bigParentTime)
|
|
x.Div(x, big10)
|
|
x.Sub(common.Big1, x)
|
|
|
|
// max(1 - (block_timestamp - parent_timestamp) // 10, -99)))
|
|
if x.Cmp(bigMinus99) < 0 {
|
|
x.Set(bigMinus99)
|
|
}
|
|
|
|
// (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
|
|
y.Div(parentDiff, params.DifficultyBoundDivisor)
|
|
x.Mul(y, x)
|
|
x.Add(parentDiff, x)
|
|
|
|
// minimum difficulty can ever be (before exponential factor)
|
|
if x.Cmp(params.MinimumDifficulty) < 0 {
|
|
x.Set(params.MinimumDifficulty)
|
|
}
|
|
|
|
// for the exponential factor...
|
|
|
|
delayedCount := new(big.Int).Add(parentNumber, common.Big1)
|
|
delayedCount.Sub(delayedCount, continueBlock)
|
|
delayedCount.Add(delayedCount, delayBlock)
|
|
delayedCount.Div(delayedCount, ExpDiffPeriod)
|
|
|
|
// the exponential factor, commonly referred to as "the bomb"
|
|
// diff = diff + 2^(periodCount - 2)
|
|
if delayedCount.Cmp(common.Big1) > 0 {
|
|
y.Sub(delayedCount, common.Big2)
|
|
y.Exp(common.Big2, y, nil)
|
|
x.Add(x, y)
|
|
}
|
|
|
|
return x
|
|
}
|
|
|
|
// 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.
|
|
func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int {
|
|
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.md
|
|
// algorithm:
|
|
// diff = (parent_diff +
|
|
// (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
|
|
// ) + 2^(periodCount - 2)
|
|
|
|
bigTime := new(big.Int).SetUint64(time)
|
|
bigParentTime := new(big.Int).Set(parent.Time)
|
|
|
|
// holds intermediate values to make the algo easier to read & audit
|
|
x := new(big.Int)
|
|
y := new(big.Int)
|
|
|
|
// 1 - (block_timestamp - parent_timestamp) // 10
|
|
x.Sub(bigTime, bigParentTime)
|
|
x.Div(x, big10)
|
|
x.Sub(big1, x)
|
|
|
|
// max(1 - (block_timestamp - parent_timestamp) // 10, -99)
|
|
if x.Cmp(bigMinus99) < 0 {
|
|
x.Set(bigMinus99)
|
|
}
|
|
// (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -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)
|
|
}
|
|
// for the exponential factor
|
|
periodCount := new(big.Int).Add(parent.Number, big1)
|
|
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
|
|
}
|
|
|
|
// 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.
|
|
func calcDifficultyFrontier(time uint64, parent *types.Header) *big.Int {
|
|
diff := new(big.Int)
|
|
adjust := new(big.Int).Div(parent.Difficulty, params.DifficultyBoundDivisor)
|
|
bigTime := new(big.Int)
|
|
bigParentTime := new(big.Int)
|
|
|
|
bigTime.SetUint64(time)
|
|
bigParentTime.Set(parent.Time)
|
|
|
|
if bigTime.Sub(bigTime, bigParentTime).Cmp(params.DurationLimit) < 0 {
|
|
diff.Add(parent.Difficulty, adjust)
|
|
} else {
|
|
diff.Sub(parent.Difficulty, adjust)
|
|
}
|
|
if diff.Cmp(params.MinimumDifficulty) < 0 {
|
|
diff.Set(params.MinimumDifficulty)
|
|
}
|
|
|
|
periodCount := new(big.Int).Add(parent.Number, big1)
|
|
periodCount.Div(periodCount, expDiffPeriod)
|
|
if periodCount.Cmp(big1) > 0 {
|
|
// diff = diff + 2^(periodCount - 2)
|
|
expDiff := periodCount.Sub(periodCount, big2)
|
|
expDiff.Exp(big2, expDiff, nil)
|
|
diff.Add(diff, expDiff)
|
|
diff = math.BigMax(diff, params.MinimumDifficulty)
|
|
}
|
|
return diff
|
|
}
|
|
|
|
// VerifySeal implements consensus.Engine, checking whether the given block satisfies
|
|
// the PoW difficulty requirements.
|
|
func (ethash *Ethash) VerifySeal(chain consensus.ChainReader, header *types.Header) error {
|
|
// If we're running a fake PoW, accept any seal as valid
|
|
if ethash.config.PowMode == ModeFake || ethash.config.PowMode == ModeFullFake {
|
|
time.Sleep(ethash.fakeDelay)
|
|
if ethash.fakeFail == header.Number.Uint64() {
|
|
return errInvalidPoW
|
|
}
|
|
return nil
|
|
}
|
|
// If we're running a shared PoW, delegate verification to it
|
|
if ethash.shared != nil {
|
|
return ethash.shared.VerifySeal(chain, header)
|
|
}
|
|
// Ensure that we have a valid difficulty for the block
|
|
if header.Difficulty.Sign() <= 0 {
|
|
return errInvalidDifficulty
|
|
}
|
|
// Recompute the digest and PoW value and verify against the header
|
|
number := header.Number.Uint64()
|
|
|
|
cache := ethash.cache(number)
|
|
size := datasetSize(number)
|
|
if ethash.config.PowMode == ModeTest {
|
|
size = 32 * 1024
|
|
}
|
|
digest, result := hashimotoLight(size, cache.cache, header.HashNoNonce().Bytes(), header.Nonce.Uint64())
|
|
// Caches are unmapped in a finalizer. Ensure that the cache stays live
|
|
// until after the call to hashimotoLight so it's not unmapped while being used.
|
|
runtime.KeepAlive(cache)
|
|
|
|
if !bytes.Equal(header.MixDigest[:], digest) {
|
|
return errInvalidMixDigest
|
|
}
|
|
target := new(big.Int).Div(maxUint256, header.Difficulty)
|
|
if new(big.Int).SetBytes(result).Cmp(target) > 0 {
|
|
return errInvalidPoW
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// default accumulateRewards()
|
|
var accumulateRewards func(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) = defaultAccumulateRewards
|
|
|
|
// Prepare implements consensus.Engine, initializing the difficulty field of a
|
|
// header to conform to the ethash protocol. The changes are done inline.
|
|
func (ethash *Ethash) Prepare(chain consensus.ChainReader, header *types.Header) error {
|
|
if chain.GetHeaderByNumber(0).Hash() == params.SocialGenesisHash {
|
|
// setup accumulateRewards for Ethereum Social
|
|
accumulateRewards = socialAccumulateRewards
|
|
}
|
|
if chain.GetHeaderByNumber(0).Hash() == params.CallistoGenesisHash {
|
|
// setup accumulateRewards for Callisto Network
|
|
accumulateRewards = callistoAccumulateRewards
|
|
}
|
|
parent := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1)
|
|
if parent == nil {
|
|
return consensus.ErrUnknownAncestor
|
|
}
|
|
header.Difficulty = ethash.CalcDifficulty(chain, header.Time.Uint64(), parent)
|
|
return nil
|
|
}
|
|
|
|
// Finalize implements consensus.Engine, accumulating the block and uncle rewards,
|
|
// setting the final state and assembling the block.
|
|
func (ethash *Ethash) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
|
|
// 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))
|
|
|
|
// Header seems complete, assemble into a block and return
|
|
return types.NewBlock(header, txs, uncles, receipts), nil
|
|
}
|
|
|
|
// 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.
|
|
func defaultAccumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
|
|
// Select the correct block reward based on chain progression
|
|
blockReward := FrontierBlockReward
|
|
if config.IsByzantium(header.Number) {
|
|
blockReward = ByzantiumBlockReward
|
|
}
|
|
if config.HasECIP1017() {
|
|
// Ensure value 'era' is configured.
|
|
eraLen := config.ECIP1017EraRounds
|
|
era := GetBlockEra(header.Number, eraLen)
|
|
wr := GetBlockWinnerRewardByEra(era, blockReward) // wr "winner reward". 5, 4, 3.2, 2.56, ...
|
|
wurs := GetBlockWinnerRewardForUnclesByEra(era, uncles, blockReward) // wurs "winner uncle rewards"
|
|
wr.Add(wr, wurs)
|
|
state.AddBalance(header.Coinbase, wr) // $$
|
|
|
|
// Reward uncle miners.
|
|
for _, uncle := range uncles {
|
|
ur := GetBlockUncleRewardByEra(era, header, uncle, blockReward)
|
|
state.AddBalance(uncle.Coinbase, ur) // $$
|
|
}
|
|
} else {
|
|
// Accumulate the rewards for the miner and any included uncles
|
|
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)
|
|
}
|
|
}
|
|
|
|
// socialAccumulateRewards 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.
|
|
func socialAccumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
|
|
// Select the correct block reward based on chain progression
|
|
blockReward := SocialBlockReward
|
|
if config.HasECIP1017() {
|
|
// Ensure value 'era' is configured.
|
|
eraLen := config.ECIP1017EraRounds
|
|
era := GetBlockEra(header.Number, eraLen)
|
|
wr := GetBlockWinnerRewardByEra(era, blockReward) // wr "winner reward". 5, 4, 3.2, 2.56, ...
|
|
wurs := GetBlockWinnerRewardForUnclesByEra(era, uncles, blockReward) // wurs "winner uncle rewards"
|
|
wr.Add(wr, wurs)
|
|
state.AddBalance(header.Coinbase, wr) // $$
|
|
|
|
// Reward uncle miners.
|
|
for _, uncle := range uncles {
|
|
ur := GetBlockUncleRewardByEra(era, header, uncle, blockReward)
|
|
state.AddBalance(uncle.Coinbase, ur) // $$
|
|
}
|
|
} else {
|
|
// Accumulate the rewards for the miner and any included uncles
|
|
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)
|
|
}
|
|
}
|
|
|
|
// As of "Era 2" (zero-index era 1), uncle miners and winners are rewarded equally for each included block.
|
|
// So they share this function.
|
|
func getEraUncleBlockReward(era *big.Int, blockReward *big.Int) *big.Int {
|
|
return new(big.Int).Div(GetBlockWinnerRewardByEra(era, blockReward), big32)
|
|
}
|
|
|
|
// GetBlockUncleRewardByEra gets called _for each uncle miner_ associated with a winner block's uncles.
|
|
func GetBlockUncleRewardByEra(era *big.Int, header, uncle *types.Header, blockReward *big.Int) *big.Int {
|
|
// Era 1 (index 0):
|
|
// An extra reward to the winning miner for including uncles as part of the block, in the form of an extra 1/32 (0.15625ETC) per uncle included, up to a maximum of two (2) uncles.
|
|
if era.Cmp(big.NewInt(0)) == 0 {
|
|
r := new(big.Int)
|
|
r.Add(uncle.Number, big8) // 2,534,998 + 8 = 2,535,006
|
|
r.Sub(r, header.Number) // 2,535,006 - 2,534,999 = 7
|
|
r.Mul(r, blockReward) // 7 * 5e+18 = 35e+18
|
|
r.Div(r, big8) // 35e+18 / 8 = 7/8 * 5e+18
|
|
|
|
return r
|
|
}
|
|
return getEraUncleBlockReward(era, blockReward)
|
|
}
|
|
|
|
// GetBlockWinnerRewardForUnclesByEra gets called _per winner_, and accumulates rewards for each included uncle.
|
|
// Assumes uncles have been validated and limited (@ func (v *BlockValidator) VerifyUncles).
|
|
func GetBlockWinnerRewardForUnclesByEra(era *big.Int, uncles []*types.Header, blockReward *big.Int) *big.Int {
|
|
r := big.NewInt(0)
|
|
|
|
for range uncles {
|
|
r.Add(r, getEraUncleBlockReward(era, blockReward)) // can reuse this, since 1/32 for winner's uncles remain unchanged from "Era 1"
|
|
}
|
|
return r
|
|
}
|
|
|
|
// GetRewardByEra gets a block reward at disinflation rate.
|
|
// Constants MaxBlockReward, DisinflationRateQuotient, and DisinflationRateDivisor assumed.
|
|
func GetBlockWinnerRewardByEra(era *big.Int, blockReward *big.Int) *big.Int {
|
|
if era.Cmp(big.NewInt(0)) == 0 {
|
|
return new(big.Int).Set(blockReward)
|
|
}
|
|
|
|
// MaxBlockReward _r_ * (4/5)**era == MaxBlockReward * (4**era) / (5**era)
|
|
// since (q/d)**n == q**n / d**n
|
|
// qed
|
|
var q, d, r *big.Int = new(big.Int), new(big.Int), new(big.Int)
|
|
|
|
q.Exp(DisinflationRateQuotient, era, nil)
|
|
d.Exp(DisinflationRateDivisor, era, nil)
|
|
|
|
r.Mul(blockReward, q)
|
|
r.Div(r, d)
|
|
|
|
return r
|
|
}
|
|
|
|
// GetBlockEra gets which "Era" a given block is within, given an era length (ecip-1017 has era=5,000,000 blocks)
|
|
// Returns a zero-index era number, so "Era 1": 0, "Era 2": 1, "Era 3": 2 ...
|
|
func GetBlockEra(blockNum, eraLength *big.Int) *big.Int {
|
|
// If genesis block or impossible negative-numbered block, return zero-val.
|
|
if blockNum.Sign() < 1 {
|
|
return new(big.Int)
|
|
}
|
|
|
|
remainder := big.NewInt(0).Mod(big.NewInt(0).Sub(blockNum, big.NewInt(1)), eraLength)
|
|
base := big.NewInt(0).Sub(blockNum, remainder)
|
|
|
|
d := big.NewInt(0).Div(base, eraLength)
|
|
dremainder := big.NewInt(0).Mod(d, big.NewInt(1))
|
|
|
|
return new(big.Int).Sub(d, dremainder)
|
|
}
|
|
|
|
// callistoAccumulateRewards()
|
|
func callistoAccumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
|
|
// Select the correct block reward based on chain progression
|
|
blockReward := CLOMinerReward
|
|
clotreasury := CLOTreasuryReward
|
|
clostake := CLOStakeReward
|
|
clohf1treasury := CLOHF1TreasuryReward
|
|
clohf1stake := CLOHF1StakeReward
|
|
|
|
// Accumulate the rewards for the miner and any included uncles
|
|
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)
|
|
}
|
|
// Activate Callisto hardfork
|
|
if config.IsCLOHF1(header.Number) {
|
|
state.AddBalance(header.Coinbase, reward)
|
|
state.AddBalance(common.HexToAddress("0x74682Fc32007aF0b6118F259cBe7bCCC21641600"), clohf1treasury)
|
|
state.AddBalance(common.HexToAddress("0x3c06f218Ce6dD8E2c535a8925A2eDF81674984D9"), clohf1stake)
|
|
} else {
|
|
state.AddBalance(header.Coinbase, reward)
|
|
state.AddBalance(common.HexToAddress("0x74682Fc32007aF0b6118F259cBe7bCCC21641600"), clotreasury)
|
|
state.AddBalance(common.HexToAddress("0x3c06f218Ce6dD8E2c535a8925A2eDF81674984D9"), clostake)
|
|
}
|
|
}
|