github.com/ConsenSys/Quorum@v20.10.0+incompatible/consensus/ethash/consensus.go (about) 1 // Copyright 2017 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package ethash 18 19 import ( 20 "bytes" 21 "errors" 22 "fmt" 23 "math/big" 24 "runtime" 25 "time" 26 27 mapset "github.com/deckarep/golang-set" 28 "github.com/ethereum/go-ethereum/common" 29 "github.com/ethereum/go-ethereum/common/math" 30 "github.com/ethereum/go-ethereum/consensus" 31 "github.com/ethereum/go-ethereum/consensus/misc" 32 "github.com/ethereum/go-ethereum/core/state" 33 "github.com/ethereum/go-ethereum/core/types" 34 "github.com/ethereum/go-ethereum/params" 35 "github.com/ethereum/go-ethereum/rlp" 36 "golang.org/x/crypto/sha3" 37 ) 38 39 // Ethash proof-of-work protocol constants. 40 var ( 41 FrontierBlockReward = big.NewInt(5e+18) // Block reward in wei for successfully mining a block 42 ByzantiumBlockReward = big.NewInt(3e+18) // Block reward in wei for successfully mining a block upward from Byzantium 43 ConstantinopleBlockReward = big.NewInt(2e+18) // Block reward in wei for successfully mining a block upward from Constantinople 44 maxUncles = 2 // Maximum number of uncles allowed in a single block 45 allowedFutureBlockTime = 15 * time.Second // Max time from current time allowed for blocks, before they're considered future blocks 46 47 // calcDifficultyConstantinople is the difficulty adjustment algorithm for Constantinople. 48 // It returns the difficulty that a new block should have when created at time given the 49 // parent block's time and difficulty. The calculation uses the Byzantium rules, but with 50 // bomb offset 5M. 51 // Specification EIP-1234: https://eips.ethereum.org/EIPS/eip-1234 52 calcDifficultyConstantinople = makeDifficultyCalculator(big.NewInt(5000000)) 53 54 // calcDifficultyByzantium is the difficulty adjustment algorithm. It returns 55 // the difficulty that a new block should have when created at time given the 56 // parent block's time and difficulty. The calculation uses the Byzantium rules. 57 // Specification EIP-649: https://eips.ethereum.org/EIPS/eip-649 58 calcDifficultyByzantium = makeDifficultyCalculator(big.NewInt(3000000)) 59 ) 60 61 // Various error messages to mark blocks invalid. These should be private to 62 // prevent engine specific errors from being referenced in the remainder of the 63 // codebase, inherently breaking if the engine is swapped out. Please put common 64 // error types into the consensus package. 65 var ( 66 errZeroBlockTime = errors.New("timestamp equals parent's") 67 errTooManyUncles = errors.New("too many uncles") 68 errDuplicateUncle = errors.New("duplicate uncle") 69 errUncleIsAncestor = errors.New("uncle is ancestor") 70 errDanglingUncle = errors.New("uncle's parent is not ancestor") 71 errInvalidDifficulty = errors.New("non-positive difficulty") 72 errInvalidMixDigest = errors.New("invalid mix digest") 73 errInvalidPoW = errors.New("invalid proof-of-work") 74 ) 75 76 // Author implements consensus.Engine, returning the header's coinbase as the 77 // proof-of-work verified author of the block. 78 func (ethash *Ethash) Author(header *types.Header) (common.Address, error) { 79 return header.Coinbase, nil 80 } 81 82 // VerifyHeader checks whether a header conforms to the consensus rules of the 83 // stock Ethereum ethash engine. 84 func (ethash *Ethash) VerifyHeader(chain consensus.ChainReader, header *types.Header, seal bool) error { 85 // If we're running a full engine faking, accept any input as valid 86 if ethash.config.PowMode == ModeFullFake { 87 return nil 88 } 89 // Short circuit if the header is known, or its parent not 90 number := header.Number.Uint64() 91 if chain.GetHeader(header.Hash(), number) != nil { 92 return nil 93 } 94 parent := chain.GetHeader(header.ParentHash, number-1) 95 if parent == nil { 96 return consensus.ErrUnknownAncestor 97 } 98 // Sanity checks passed, do a proper verification 99 return ethash.verifyHeader(chain, header, parent, false, seal) 100 } 101 102 // VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers 103 // concurrently. The method returns a quit channel to abort the operations and 104 // a results channel to retrieve the async verifications. 105 func (ethash *Ethash) VerifyHeaders(chain consensus.ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) { 106 // If we're running a full engine faking, accept any input as valid 107 if ethash.config.PowMode == ModeFullFake || len(headers) == 0 { 108 abort, results := make(chan struct{}), make(chan error, len(headers)) 109 for i := 0; i < len(headers); i++ { 110 results <- nil 111 } 112 return abort, results 113 } 114 115 // Spawn as many workers as allowed threads 116 workers := runtime.GOMAXPROCS(0) 117 if len(headers) < workers { 118 workers = len(headers) 119 } 120 121 // Create a task channel and spawn the verifiers 122 var ( 123 inputs = make(chan int) 124 done = make(chan int, workers) 125 errors = make([]error, len(headers)) 126 abort = make(chan struct{}) 127 ) 128 for i := 0; i < workers; i++ { 129 go func() { 130 for index := range inputs { 131 errors[index] = ethash.verifyHeaderWorker(chain, headers, seals, index) 132 done <- index 133 } 134 }() 135 } 136 137 errorsOut := make(chan error, len(headers)) 138 go func() { 139 defer close(inputs) 140 var ( 141 in, out = 0, 0 142 checked = make([]bool, len(headers)) 143 inputs = inputs 144 ) 145 for { 146 select { 147 case inputs <- in: 148 if in++; in == len(headers) { 149 // Reached end of headers. Stop sending to workers. 150 inputs = nil 151 } 152 case index := <-done: 153 for checked[index] = true; checked[out]; out++ { 154 errorsOut <- errors[out] 155 if out == len(headers)-1 { 156 return 157 } 158 } 159 case <-abort: 160 return 161 } 162 } 163 }() 164 return abort, errorsOut 165 } 166 167 func (ethash *Ethash) verifyHeaderWorker(chain consensus.ChainReader, headers []*types.Header, seals []bool, index int) error { 168 var parent *types.Header 169 if index == 0 { 170 parent = chain.GetHeader(headers[0].ParentHash, headers[0].Number.Uint64()-1) 171 } else if headers[index-1].Hash() == headers[index].ParentHash { 172 parent = headers[index-1] 173 } 174 if parent == nil { 175 return consensus.ErrUnknownAncestor 176 } 177 if chain.GetHeader(headers[index].Hash(), headers[index].Number.Uint64()) != nil { 178 return nil // known block 179 } 180 return ethash.verifyHeader(chain, headers[index], parent, false, seals[index]) 181 } 182 183 // VerifyUncles verifies that the given block's uncles conform to the consensus 184 // rules of the stock Ethereum ethash engine. 185 func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Block) error { 186 // If we're running a full engine faking, accept any input as valid 187 if ethash.config.PowMode == ModeFullFake { 188 return nil 189 } 190 // Verify that there are at most 2 uncles included in this block 191 if len(block.Uncles()) > maxUncles { 192 return errTooManyUncles 193 } 194 if len(block.Uncles()) == 0 { 195 return nil 196 } 197 // Gather the set of past uncles and ancestors 198 uncles, ancestors := mapset.NewSet(), make(map[common.Hash]*types.Header) 199 200 number, parent := block.NumberU64()-1, block.ParentHash() 201 for i := 0; i < 7; i++ { 202 ancestor := chain.GetBlock(parent, number) 203 if ancestor == nil { 204 break 205 } 206 ancestors[ancestor.Hash()] = ancestor.Header() 207 for _, uncle := range ancestor.Uncles() { 208 uncles.Add(uncle.Hash()) 209 } 210 parent, number = ancestor.ParentHash(), number-1 211 } 212 ancestors[block.Hash()] = block.Header() 213 uncles.Add(block.Hash()) 214 215 // Verify each of the uncles that it's recent, but not an ancestor 216 for _, uncle := range block.Uncles() { 217 // Make sure every uncle is rewarded only once 218 hash := uncle.Hash() 219 if uncles.Contains(hash) { 220 return errDuplicateUncle 221 } 222 uncles.Add(hash) 223 224 // Make sure the uncle has a valid ancestry 225 if ancestors[hash] != nil { 226 return errUncleIsAncestor 227 } 228 if ancestors[uncle.ParentHash] == nil || uncle.ParentHash == block.ParentHash() { 229 return errDanglingUncle 230 } 231 if err := ethash.verifyHeader(chain, uncle, ancestors[uncle.ParentHash], true, true); err != nil { 232 return err 233 } 234 } 235 return nil 236 } 237 238 // verifyHeader checks whether a header conforms to the consensus rules of the 239 // stock Ethereum ethash engine. 240 // See YP section 4.3.4. "Block Header Validity" 241 func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *types.Header, uncle bool, seal bool) error { 242 // Quorum: ethash consensus is only used in raft for Quorum, skip verifyHeader 243 if chain != nil && chain.Config().IsQuorum { 244 return nil 245 } 246 247 // Ensure that the header's extra-data section is of a reasonable size 248 if uint64(len(header.Extra)) > params.MaximumExtraDataSize { 249 return fmt.Errorf("extra-data too long: %d > %d", len(header.Extra), params.MaximumExtraDataSize) 250 } 251 // Verify the header's timestamp 252 if !uncle { 253 if header.Time > uint64(time.Now().Add(allowedFutureBlockTime).Unix()) { 254 return consensus.ErrFutureBlock 255 } 256 } 257 if header.Time <= parent.Time { 258 return errZeroBlockTime 259 } 260 // Verify the block's difficulty based in its timestamp and parent's difficulty 261 expected := ethash.CalcDifficulty(chain, header.Time, parent) 262 263 if expected.Cmp(header.Difficulty) != 0 { 264 return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficulty, expected) 265 } 266 // Verify that the gas limit is <= 2^63-1 267 cap := uint64(0x7fffffffffffffff) 268 if header.GasLimit > cap { 269 return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, cap) 270 } 271 // Verify that the gasUsed is <= gasLimit 272 if header.GasUsed > header.GasLimit { 273 return fmt.Errorf("invalid gasUsed: have %d, gasLimit %d", header.GasUsed, header.GasLimit) 274 } 275 276 // Verify that the gas limit remains within allowed bounds 277 diff := int64(parent.GasLimit) - int64(header.GasLimit) 278 if diff < 0 { 279 diff *= -1 280 } 281 limit := parent.GasLimit / params.OriginalGasLimitBoundDivisor 282 283 if uint64(diff) >= limit || header.GasLimit < params.OriginalMinGasLimit { 284 return fmt.Errorf("invalid gas limit: have %d, want %d += %d", header.GasLimit, parent.GasLimit, limit) 285 } 286 // Verify that the block number is parent's +1 287 if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 { 288 return consensus.ErrInvalidNumber 289 } 290 // Verify the engine specific seal securing the block 291 if seal { 292 if err := ethash.VerifySeal(chain, header); err != nil { 293 return err 294 } 295 } 296 // If all checks passed, validate any special fields for hard forks 297 if err := misc.VerifyDAOHeaderExtraData(chain.Config(), header); err != nil { 298 return err 299 } 300 if err := misc.VerifyForkHashes(chain.Config(), header, uncle); err != nil { 301 return err 302 } 303 return nil 304 } 305 306 // CalcDifficulty is the difficulty adjustment algorithm. It returns 307 // the difficulty that a new block should have when created at time 308 // given the parent block's time and difficulty. 309 func (ethash *Ethash) CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Header) *big.Int { 310 return CalcDifficulty(chain.Config(), time, parent) 311 } 312 313 // CalcDifficulty is the difficulty adjustment algorithm. It returns 314 // the difficulty that a new block should have when created at time 315 // given the parent block's time and difficulty. 316 func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int { 317 next := new(big.Int).Add(parent.Number, big1) 318 switch { 319 case config.IsConstantinople(next): 320 return calcDifficultyConstantinople(time, parent) 321 case config.IsByzantium(next): 322 return calcDifficultyByzantium(time, parent) 323 case config.IsHomestead(next): 324 return calcDifficultyHomestead(time, parent) 325 default: 326 return calcDifficultyFrontier(time, parent) 327 } 328 } 329 330 // Some weird constants to avoid constant memory allocs for them. 331 var ( 332 expDiffPeriod = big.NewInt(100000) 333 big1 = big.NewInt(1) 334 big2 = big.NewInt(2) 335 big9 = big.NewInt(9) 336 big10 = big.NewInt(10) 337 bigMinus99 = big.NewInt(-99) 338 ) 339 340 // makeDifficultyCalculator creates a difficultyCalculator with the given bomb-delay. 341 // the difficulty is calculated with Byzantium rules, which differs from Homestead in 342 // how uncles affect the calculation 343 func makeDifficultyCalculator(bombDelay *big.Int) func(time uint64, parent *types.Header) *big.Int { 344 // Note, the calculations below looks at the parent number, which is 1 below 345 // the block number. Thus we remove one from the delay given 346 bombDelayFromParent := new(big.Int).Sub(bombDelay, big1) 347 return func(time uint64, parent *types.Header) *big.Int { 348 // https://github.com/ethereum/EIPs/issues/100. 349 // algorithm: 350 // diff = (parent_diff + 351 // (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99)) 352 // ) + 2^(periodCount - 2) 353 354 bigTime := new(big.Int).SetUint64(time) 355 bigParentTime := new(big.Int).SetUint64(parent.Time) 356 357 // holds intermediate values to make the algo easier to read & audit 358 x := new(big.Int) 359 y := new(big.Int) 360 361 // (2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9 362 x.Sub(bigTime, bigParentTime) 363 x.Div(x, big9) 364 if parent.UncleHash == types.EmptyUncleHash { 365 x.Sub(big1, x) 366 } else { 367 x.Sub(big2, x) 368 } 369 // max((2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9, -99) 370 if x.Cmp(bigMinus99) < 0 { 371 x.Set(bigMinus99) 372 } 373 // parent_diff + (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99)) 374 y.Div(parent.Difficulty, params.DifficultyBoundDivisor) 375 x.Mul(y, x) 376 x.Add(parent.Difficulty, x) 377 378 // minimum difficulty can ever be (before exponential factor) 379 if x.Cmp(params.MinimumDifficulty) < 0 { 380 x.Set(params.MinimumDifficulty) 381 } 382 // calculate a fake block number for the ice-age delay 383 // Specification: https://eips.ethereum.org/EIPS/eip-1234 384 fakeBlockNumber := new(big.Int) 385 if parent.Number.Cmp(bombDelayFromParent) >= 0 { 386 fakeBlockNumber = fakeBlockNumber.Sub(parent.Number, bombDelayFromParent) 387 } 388 // for the exponential factor 389 periodCount := fakeBlockNumber 390 periodCount.Div(periodCount, expDiffPeriod) 391 392 // the exponential factor, commonly referred to as "the bomb" 393 // diff = diff + 2^(periodCount - 2) 394 if periodCount.Cmp(big1) > 0 { 395 y.Sub(periodCount, big2) 396 y.Exp(big2, y, nil) 397 x.Add(x, y) 398 } 399 return x 400 } 401 } 402 403 // calcDifficultyHomestead is the difficulty adjustment algorithm. It returns 404 // the difficulty that a new block should have when created at time given the 405 // parent block's time and difficulty. The calculation uses the Homestead rules. 406 func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int { 407 // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.md 408 // algorithm: 409 // diff = (parent_diff + 410 // (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99)) 411 // ) + 2^(periodCount - 2) 412 413 bigTime := new(big.Int).SetUint64(time) 414 bigParentTime := new(big.Int).SetUint64(parent.Time) 415 416 // holds intermediate values to make the algo easier to read & audit 417 x := new(big.Int) 418 y := new(big.Int) 419 420 // 1 - (block_timestamp - parent_timestamp) // 10 421 x.Sub(bigTime, bigParentTime) 422 x.Div(x, big10) 423 x.Sub(big1, x) 424 425 // max(1 - (block_timestamp - parent_timestamp) // 10, -99) 426 if x.Cmp(bigMinus99) < 0 { 427 x.Set(bigMinus99) 428 } 429 // (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99)) 430 y.Div(parent.Difficulty, params.DifficultyBoundDivisor) 431 x.Mul(y, x) 432 x.Add(parent.Difficulty, x) 433 434 // minimum difficulty can ever be (before exponential factor) 435 if x.Cmp(params.MinimumDifficulty) < 0 { 436 x.Set(params.MinimumDifficulty) 437 } 438 // for the exponential factor 439 periodCount := new(big.Int).Add(parent.Number, big1) 440 periodCount.Div(periodCount, expDiffPeriod) 441 442 // the exponential factor, commonly referred to as "the bomb" 443 // diff = diff + 2^(periodCount - 2) 444 if periodCount.Cmp(big1) > 0 { 445 y.Sub(periodCount, big2) 446 y.Exp(big2, y, nil) 447 x.Add(x, y) 448 } 449 return x 450 } 451 452 // calcDifficultyFrontier is the difficulty adjustment algorithm. It returns the 453 // difficulty that a new block should have when created at time given the parent 454 // block's time and difficulty. The calculation uses the Frontier rules. 455 func calcDifficultyFrontier(time uint64, parent *types.Header) *big.Int { 456 diff := new(big.Int) 457 adjust := new(big.Int).Div(parent.Difficulty, params.DifficultyBoundDivisor) 458 bigTime := new(big.Int) 459 bigParentTime := new(big.Int) 460 461 bigTime.SetUint64(time) 462 bigParentTime.SetUint64(parent.Time) 463 464 if bigTime.Sub(bigTime, bigParentTime).Cmp(params.DurationLimit) < 0 { 465 diff.Add(parent.Difficulty, adjust) 466 } else { 467 diff.Sub(parent.Difficulty, adjust) 468 } 469 if diff.Cmp(params.MinimumDifficulty) < 0 { 470 diff.Set(params.MinimumDifficulty) 471 } 472 473 periodCount := new(big.Int).Add(parent.Number, big1) 474 periodCount.Div(periodCount, expDiffPeriod) 475 if periodCount.Cmp(big1) > 0 { 476 // diff = diff + 2^(periodCount - 2) 477 expDiff := periodCount.Sub(periodCount, big2) 478 expDiff.Exp(big2, expDiff, nil) 479 diff.Add(diff, expDiff) 480 diff = math.BigMax(diff, params.MinimumDifficulty) 481 } 482 return diff 483 } 484 485 // VerifySeal implements consensus.Engine, checking whether the given block satisfies 486 // the PoW difficulty requirements. 487 func (ethash *Ethash) VerifySeal(chain consensus.ChainReader, header *types.Header) error { 488 return ethash.verifySeal(chain, header, false) 489 } 490 491 // verifySeal checks whether a block satisfies the PoW difficulty requirements, 492 // either using the usual ethash cache for it, or alternatively using a full DAG 493 // to make remote mining fast. 494 func (ethash *Ethash) verifySeal(chain consensus.ChainReader, header *types.Header, fulldag bool) error { 495 // Quorum: ethash consensus is only used in raft for Quorum, skip verifySeal 496 if chain != nil && chain.Config().IsQuorum { 497 return nil 498 } 499 500 // If we're running a fake PoW, accept any seal as valid 501 if ethash.config.PowMode == ModeFake || ethash.config.PowMode == ModeFullFake { 502 time.Sleep(ethash.fakeDelay) 503 if ethash.fakeFail == header.Number.Uint64() { 504 return errInvalidPoW 505 } 506 return nil 507 } 508 // If we're running a shared PoW, delegate verification to it 509 if ethash.shared != nil { 510 return ethash.shared.verifySeal(chain, header, fulldag) 511 } 512 // Ensure that we have a valid difficulty for the block 513 if header.Difficulty.Sign() <= 0 { 514 return errInvalidDifficulty 515 } 516 // Recompute the digest and PoW values 517 number := header.Number.Uint64() 518 519 var ( 520 digest []byte 521 result []byte 522 ) 523 // If fast-but-heavy PoW verification was requested, use an ethash dataset 524 if fulldag { 525 dataset := ethash.dataset(number, true) 526 if dataset.generated() { 527 digest, result = hashimotoFull(dataset.dataset, ethash.SealHash(header).Bytes(), header.Nonce.Uint64()) 528 529 // Datasets are unmapped in a finalizer. Ensure that the dataset stays alive 530 // until after the call to hashimotoFull so it's not unmapped while being used. 531 runtime.KeepAlive(dataset) 532 } else { 533 // Dataset not yet generated, don't hang, use a cache instead 534 fulldag = false 535 } 536 } 537 // If slow-but-light PoW verification was requested (or DAG not yet ready), use an ethash cache 538 if !fulldag { 539 cache := ethash.cache(number) 540 541 size := datasetSize(number) 542 if ethash.config.PowMode == ModeTest { 543 size = 32 * 1024 544 } 545 digest, result = hashimotoLight(size, cache.cache, ethash.SealHash(header).Bytes(), header.Nonce.Uint64()) 546 547 // Caches are unmapped in a finalizer. Ensure that the cache stays alive 548 // until after the call to hashimotoLight so it's not unmapped while being used. 549 runtime.KeepAlive(cache) 550 } 551 // Verify the calculated values against the ones provided in the header 552 if !bytes.Equal(header.MixDigest[:], digest) { 553 return errInvalidMixDigest 554 } 555 target := new(big.Int).Div(two256, header.Difficulty) 556 if new(big.Int).SetBytes(result).Cmp(target) > 0 { 557 return errInvalidPoW 558 } 559 return nil 560 } 561 562 // Prepare implements consensus.Engine, initializing the difficulty field of a 563 // header to conform to the ethash protocol. The changes are done inline. 564 func (ethash *Ethash) Prepare(chain consensus.ChainReader, header *types.Header) error { 565 parent := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1) 566 if parent == nil { 567 return consensus.ErrUnknownAncestor 568 } 569 header.Difficulty = ethash.CalcDifficulty(chain, header.Time, parent) 570 return nil 571 } 572 573 // Finalize implements consensus.Engine, accumulating the block and uncle rewards, 574 // setting the final state on the header 575 func (ethash *Ethash) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header) { 576 // Accumulate any block and uncle rewards and commit the final state root 577 accumulateRewards(chain.Config(), state, header, uncles) 578 header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) 579 } 580 581 // FinalizeAndAssemble implements consensus.Engine, accumulating the block and 582 // uncle rewards, setting the final state and assembling the block. 583 func (ethash *Ethash) FinalizeAndAssemble(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) { 584 // Accumulate any block and uncle rewards and commit the final state root 585 accumulateRewards(chain.Config(), state, header, uncles) 586 header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) 587 588 // Header seems complete, assemble into a block and return 589 return types.NewBlock(header, txs, uncles, receipts), nil 590 } 591 592 // SealHash returns the hash of a block prior to it being sealed. 593 func (ethash *Ethash) SealHash(header *types.Header) (hash common.Hash) { 594 hasher := sha3.NewLegacyKeccak256() 595 596 rlp.Encode(hasher, []interface{}{ 597 header.ParentHash, 598 header.UncleHash, 599 header.Coinbase, 600 header.Root, 601 header.TxHash, 602 header.ReceiptHash, 603 header.Bloom, 604 header.Difficulty, 605 header.Number, 606 header.GasLimit, 607 header.GasUsed, 608 header.Time, 609 header.Extra, 610 }) 611 hasher.Sum(hash[:0]) 612 return hash 613 } 614 615 // Some weird constants to avoid constant memory allocs for them. 616 var ( 617 big8 = big.NewInt(8) 618 big32 = big.NewInt(32) 619 ) 620 621 // AccumulateRewards credits the coinbase of the given block with the mining 622 // reward. The total reward consists of the static block reward and rewards for 623 // included uncles. The coinbase of each uncle block is also rewarded. 624 func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) { 625 // Select the correct block reward based on chain progression 626 blockReward := FrontierBlockReward 627 if config.IsByzantium(header.Number) { 628 blockReward = ByzantiumBlockReward 629 } 630 if config.IsConstantinople(header.Number) { 631 blockReward = ConstantinopleBlockReward 632 } 633 // Accumulate the rewards for the miner and any included uncles 634 reward := new(big.Int).Set(blockReward) 635 r := new(big.Int) 636 for _, uncle := range uncles { 637 r.Add(uncle.Number, big8) 638 r.Sub(r, header.Number) 639 r.Mul(r, blockReward) 640 r.Div(r, big8) 641 state.AddBalance(uncle.Coinbase, r) 642 643 r.Div(blockReward, big32) 644 reward.Add(reward, r) 645 } 646 state.AddBalance(header.Coinbase, reward) 647 } 648 649 // Quorum: wrapper for accumulateRewards to be called by raft minter 650 func AccumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) { 651 accumulateRewards(config, state, header, uncles) 652 }