forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-26 14:46:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

skip tests

Browse source
This commit is contained in:
Arpit Temani 2023-09-22 17:03:17 +05:30
parent 766a84558a
commit 7f727cb65d
6 changed files with 631 additions and 687 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
consensus/beacon/consensus.go
View file

@ -67,7 +67,6 @@ func New(ethone consensus.Engine) *Beacon {
if _, ok := ethone.(*Beacon); ok { if _, ok := ethone.(*Beacon); ok {
panic("nested consensus engine") panic("nested consensus engine")
} }
return &Beacon{ethone: ethone} return &Beacon{ethone: ethone}
} }
@ -76,7 +75,6 @@ func (beacon *Beacon) Author(header *types.Header) (common.Address, error) {
if !beacon.IsPoSHeader(header) { if !beacon.IsPoSHeader(header) {
return beacon.ethone.Author(header) return beacon.ethone.Author(header)
} }
return header.Coinbase, nil return header.Coinbase, nil
} }
@ -87,7 +85,6 @@ func (beacon *Beacon) VerifyHeader(chain consensus.ChainHeaderReader, header *ty
if err != nil { if err != nil {
return err return err
} }
if !reached { if !reached {
return beacon.ethone.VerifyHeader(chain, header) return beacon.ethone.VerifyHeader(chain, header)
} }
@ -106,7 +103,6 @@ func errOut(n int, err error) chan error {
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
errs <- err errs <- err
} }
return errs return errs
} }
@ -121,9 +117,7 @@ func (beacon *Beacon) splitHeaders(chain consensus.ChainHeaderReader, headers []
if ttd == nil { if ttd == nil {
return headers, nil, nil return headers, nil, nil
} }
ptd := chain.GetTd(headers[0].ParentHash, headers[0].Number.Uint64()-1) ptd := chain.GetTd(headers[0].ParentHash, headers[0].Number.Uint64()-1)
if ptd == nil { if ptd == nil {
return nil, nil, consensus.ErrUnknownAncestor return nil, nil, consensus.ErrUnknownAncestor
} }
@ -131,31 +125,25 @@ func (beacon *Beacon) splitHeaders(chain consensus.ChainHeaderReader, headers []
if ptd.Cmp(ttd) >= 0 { if ptd.Cmp(ttd) >= 0 {
return nil, headers, nil return nil, headers, nil
} }
var ( var (
preHeaders = headers preHeaders = headers
postHeaders []*types.Header postHeaders []*types.Header
td = new(big.Int).Set(ptd) td = new(big.Int).Set(ptd)
tdPassed bool tdPassed bool
) )
for i, header := range headers { for i, header := range headers {
if tdPassed { if tdPassed {
preHeaders = headers[:i] preHeaders = headers[:i]
postHeaders = headers[i:] postHeaders = headers[i:]
break break
} }
td = td.Add(td, header.Difficulty) td = td.Add(td, header.Difficulty)
if td.Cmp(ttd) >= 0 { if td.Cmp(ttd) >= 0 {
// This is the last PoW header, it still belongs to // This is the last PoW header, it still belongs to
// the preHeaders, so we cannot split+break yet. // the preHeaders, so we cannot split+break yet.
tdPassed = true tdPassed = true
} }
} }
return preHeaders, postHeaders, nil return preHeaders, postHeaders, nil
} }
@ -168,11 +156,9 @@ func (beacon *Beacon) VerifyHeaders(chain consensus.ChainHeaderReader, headers [
if err != nil { if err != nil {
return make(chan struct{}), errOut(len(headers), err) return make(chan struct{}), errOut(len(headers), err)
} }
if len(postHeaders) == 0 { if len(postHeaders) == 0 {
return beacon.ethone.VerifyHeaders(chain, headers) return beacon.ethone.VerifyHeaders(chain, headers)
} }
if len(preHeaders) == 0 { if len(preHeaders) == 0 {
return beacon.verifyHeaders(chain, headers, nil) return beacon.verifyHeaders(chain, headers, nil)
} }
@ -182,7 +168,6 @@ func (beacon *Beacon) VerifyHeaders(chain consensus.ChainHeaderReader, headers [
abort = make(chan struct{}) abort = make(chan struct{})
results = make(chan error, len(headers)) results = make(chan error, len(headers))
) )
go func() { go func() {
var ( var (
old, new, out = 0, len(preHeaders), 0 old, new, out = 0, len(preHeaders), 0
@ -195,7 +180,6 @@ func (beacon *Beacon) VerifyHeaders(chain consensus.ChainHeaderReader, headers [
for { for {
for ; done[out]; out++ { for ; done[out]; out++ {
results <- errors[out] results <- errors[out]
if out == len(headers)-1 { if out == len(headers)-1 {
return return
} }
@ -205,7 +189,6 @@ func (beacon *Beacon) VerifyHeaders(chain consensus.ChainHeaderReader, headers [
if !done[old] { // skip TTD-verified failures if !done[old] { // skip TTD-verified failures
errors[old], done[old] = err, true errors[old], done[old] = err, true
} }
old++ old++
case err := <-newResult: case err := <-newResult:
errors[new], done[new] = err, true errors[new], done[new] = err, true
@ -213,12 +196,10 @@ func (beacon *Beacon) VerifyHeaders(chain consensus.ChainHeaderReader, headers [
case <-abort: case <-abort:
close(oldDone) close(oldDone)
close(newDone) close(newDone)
return return
} }
} }
}() }()
return abort, results return abort, results
} }
@ -232,7 +213,6 @@ func (beacon *Beacon) VerifyUncles(chain consensus.ChainReader, block *types.Blo
if len(block.Uncles()) > 0 { if len(block.Uncles()) > 0 {
return errTooManyUncles return errTooManyUncles
} }
return nil return nil
} }
@ -255,7 +235,6 @@ func (beacon *Beacon) verifyHeader(chain consensus.ChainHeaderReader, header, pa
if header.Nonce != beaconNonce { if header.Nonce != beaconNonce {
return errInvalidNonce return errInvalidNonce
} }
if header.UncleHash != types.EmptyUncleHash { if header.UncleHash != types.EmptyUncleHash {
return errInvalidUncleHash return errInvalidUncleHash
} }
@ -288,7 +267,6 @@ func (beacon *Beacon) verifyHeader(chain consensus.ChainHeaderReader, header, pa
if shanghai && header.WithdrawalsHash == nil { if shanghai && header.WithdrawalsHash == nil {
return errors.New("missing withdrawalsHash") return errors.New("missing withdrawalsHash")
} }
if !shanghai && header.WithdrawalsHash != nil { if !shanghai && header.WithdrawalsHash != nil {
return fmt.Errorf("invalid withdrawalsHash: have %x, expected nil", header.WithdrawalsHash) return fmt.Errorf("invalid withdrawalsHash: have %x, expected nil", header.WithdrawalsHash)
} }
@ -305,7 +283,6 @@ func (beacon *Beacon) verifyHeader(chain consensus.ChainHeaderReader, header, pa
return err return err
} }
} }
return nil return nil
} }
@ -318,11 +295,9 @@ func (beacon *Beacon) verifyHeaders(chain consensus.ChainHeaderReader, headers [
abort = make(chan struct{}) abort = make(chan struct{})
results = make(chan error, len(headers)) results = make(chan error, len(headers))
) )
go func() { go func() {
for i, header := range headers { for i, header := range headers {
var parent *types.Header var parent *types.Header
if i == 0 { if i == 0 {
if ancestor != nil { if ancestor != nil {
parent = ancestor parent = ancestor
@ -332,17 +307,14 @@ func (beacon *Beacon) verifyHeaders(chain consensus.ChainHeaderReader, headers [
} else if headers[i-1].Hash() == headers[i].ParentHash { } else if headers[i-1].Hash() == headers[i].ParentHash {
parent = headers[i-1] parent = headers[i-1]
} }
if parent == nil { if parent == nil {
select { select {
case <-abort: case <-abort:
return return
case results <- consensus.ErrUnknownAncestor: case results <- consensus.ErrUnknownAncestor:
} }
continue continue
} }
err := beacon.verifyHeader(chain, header, parent) err := beacon.verifyHeader(chain, header, parent)
select { select {
case <-abort: case <-abort:
@ -351,7 +323,6 @@ func (beacon *Beacon) verifyHeaders(chain consensus.ChainHeaderReader, headers [
} }
} }
}() }()
return abort, results return abort, results
} }
@ -363,13 +334,10 @@ func (beacon *Beacon) Prepare(chain consensus.ChainHeaderReader, header *types.H
if err != nil { if err != nil {
return err return err
} }
if !reached { if !reached {
return beacon.ethone.Prepare(chain, header) return beacon.ethone.Prepare(chain, header)
} }
header.Difficulty = beaconDifficulty header.Difficulty = beaconDifficulty
return nil return nil
} }
@ -445,7 +413,6 @@ func (beacon *Beacon) CalcDifficulty(chain consensus.ChainHeaderReader, time uin
if reached, _ := IsTTDReached(chain, parent.Hash(), parent.Number.Uint64()); !reached { if reached, _ := IsTTDReached(chain, parent.Hash(), parent.Number.Uint64()); !reached {
return beacon.ethone.CalcDifficulty(chain, time, parent) return beacon.ethone.CalcDifficulty(chain, time, parent)
} }
return beaconDifficulty return beaconDifficulty
} }
@ -466,7 +433,6 @@ func (beacon *Beacon) IsPoSHeader(header *types.Header) bool {
if header.Difficulty == nil { if header.Difficulty == nil {
panic("IsPoSHeader called with invalid difficulty") panic("IsPoSHeader called with invalid difficulty")
} }
return header.Difficulty.Cmp(beaconDifficulty) == 0 return header.Difficulty.Cmp(beaconDifficulty) == 0
} }
@ -481,7 +447,6 @@ func (beacon *Beacon) SetThreads(threads int) {
type threaded interface { type threaded interface {
SetThreads(threads int) SetThreads(threads int)
} }
if th, ok := beacon.ethone.(threaded); ok { if th, ok := beacon.ethone.(threaded); ok {
th.SetThreads(threads) th.SetThreads(threads)
} }
@ -494,11 +459,9 @@ func IsTTDReached(chain consensus.ChainHeaderReader, parentHash common.Hash, par
if chain.Config().TerminalTotalDifficulty == nil { if chain.Config().TerminalTotalDifficulty == nil {
return false, nil return false, nil
} }
td := chain.GetTd(parentHash, parentNumber) td := chain.GetTd(parentHash, parentNumber)
if td == nil { if td == nil {
return false, consensus.ErrUnknownAncestor return false, consensus.ErrUnknownAncestor
} }
return td.Cmp(chain.Config().TerminalTotalDifficulty) >= 0, nil return td.Cmp(chain.Config().TerminalTotalDifficulty) >= 0, nil
} }

34
consensus/ethash/consensus.go
View file

@ -24,8 +24,6 @@ import (
"time" "time"
mapset "github.com/deckarep/golang-set/v2" mapset "github.com/deckarep/golang-set/v2"
"golang.org/x/crypto/sha3"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/common/math"
"github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus"
@ -36,6 +34,7 @@ import (
"github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie"
"golang.org/x/crypto/sha3"
) )
// Ethash proof-of-work protocol constants. // Ethash proof-of-work protocol constants.
@ -106,7 +105,6 @@ func (ethash *Ethash) VerifyHeader(chain consensus.ChainHeaderReader, header *ty
if chain.GetHeader(header.Hash(), number) != nil { if chain.GetHeader(header.Hash(), number) != nil {
return nil return nil
} }
parent := chain.GetHeader(header.ParentHash, number-1) parent := chain.GetHeader(header.ParentHash, number-1)
if parent == nil { if parent == nil {
return consensus.ErrUnknownAncestor return consensus.ErrUnknownAncestor
@ -125,7 +123,6 @@ func (ethash *Ethash) VerifyHeaders(chain consensus.ChainHeaderReader, headers [
for i := 0; i < len(headers); i++ { for i := 0; i < len(headers); i++ {
results <- nil results <- nil
} }
return abort, results return abort, results
} }
abort := make(chan struct{}) abort := make(chan struct{})
@ -167,7 +164,6 @@ func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Blo
if len(block.Uncles()) > maxUncles { if len(block.Uncles()) > maxUncles {
return errTooManyUncles return errTooManyUncles
} }
if len(block.Uncles()) == 0 { if len(block.Uncles()) == 0 {
return nil return nil
} }
@ -180,7 +176,6 @@ func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Blo
if ancestorHeader == nil { if ancestorHeader == nil {
break break
} }
ancestors[parent] = ancestorHeader ancestors[parent] = ancestorHeader
// If the ancestor doesn't have any uncles, we don't have to iterate them // If the ancestor doesn't have any uncles, we don't have to iterate them
if ancestorHeader.UncleHash != types.EmptyUncleHash { if ancestorHeader.UncleHash != types.EmptyUncleHash {
@ -189,15 +184,12 @@ func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Blo
if ancestor == nil { if ancestor == nil {
break break
} }
for _, uncle := range ancestor.Uncles() { for _, uncle := range ancestor.Uncles() {
uncles.Add(uncle.Hash()) uncles.Add(uncle.Hash())
} }
} }
parent, number = ancestorHeader.ParentHash, number-1 parent, number = ancestorHeader.ParentHash, number-1
} }
ancestors[block.Hash()] = block.Header() ancestors[block.Hash()] = block.Header()
uncles.Add(block.Hash()) uncles.Add(block.Hash())
@ -208,14 +200,12 @@ func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Blo
if uncles.Contains(hash) { if uncles.Contains(hash) {
return errDuplicateUncle return errDuplicateUncle
} }
uncles.Add(hash) uncles.Add(hash)
// Make sure the uncle has a valid ancestry // Make sure the uncle has a valid ancestry
if ancestors[hash] != nil { if ancestors[hash] != nil {
return errUncleIsAncestor return errUncleIsAncestor
} }
if ancestors[uncle.ParentHash] == nil || uncle.ParentHash == block.ParentHash() { if ancestors[uncle.ParentHash] == nil || uncle.ParentHash == block.ParentHash() {
return errDanglingUncle return errDanglingUncle
} }
@ -223,7 +213,6 @@ func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Blo
return err return err
} }
} }
return nil return nil
} }
@ -241,7 +230,6 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa
return consensus.ErrFutureBlock return consensus.ErrFutureBlock
} }
} }
if header.Time <= parent.Time { if header.Time <= parent.Time {
return errOlderBlockTime return errOlderBlockTime
} }
@ -265,7 +253,6 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa
if header.BaseFee != nil { if header.BaseFee != nil {
return fmt.Errorf("invalid baseFee before fork: have %d, expected 'nil'", header.BaseFee) return fmt.Errorf("invalid baseFee before fork: have %d, expected 'nil'", header.BaseFee)
} }
if err := misc.VerifyGaslimit(parent.GasLimit, header.GasLimit); err != nil { if err := misc.VerifyGaslimit(parent.GasLimit, header.GasLimit); err != nil {
return err return err
} }
@ -294,7 +281,6 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa
if err := misc.VerifyDAOHeaderExtraData(chain.Config(), header); err != nil { if err := misc.VerifyDAOHeaderExtraData(chain.Config(), header); err != nil {
return err return err
} }
return nil return nil
} }
@ -310,7 +296,6 @@ func (ethash *Ethash) CalcDifficulty(chain consensus.ChainHeaderReader, time uin
// given the parent block's time and difficulty. // given the parent block's time and difficulty.
func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int { func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int {
next := new(big.Int).Add(parent.Number, big1) next := new(big.Int).Add(parent.Number, big1)
switch { switch {
case config.IsGrayGlacier(next): case config.IsGrayGlacier(next):
return calcDifficultyEip5133(time, parent) return calcDifficultyEip5133(time, parent)
@ -348,13 +333,13 @@ func makeDifficultyCalculator(bombDelay *big.Int) func(time uint64, parent *type
// Note, the calculations below looks at the parent number, which is 1 below // Note, the calculations below looks at the parent number, which is 1 below
// the block number. Thus we remove one from the delay given // the block number. Thus we remove one from the delay given
bombDelayFromParent := new(big.Int).Sub(bombDelay, big1) bombDelayFromParent := new(big.Int).Sub(bombDelay, big1)
return func(time uint64, parent *types.Header) *big.Int { return func(time uint64, parent *types.Header) *big.Int {
// https://github.com/ethereum/EIPs/issues/100. // https://github.com/ethereum/EIPs/issues/100.
// algorithm: // algorithm:
// diff = (parent_diff + // diff = (parent_diff +
// (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99)) // (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
// ) + 2^(periodCount - 2) // ) + 2^(periodCount - 2)
bigTime := new(big.Int).SetUint64(time) bigTime := new(big.Int).SetUint64(time)
bigParentTime := new(big.Int).SetUint64(parent.Time) bigParentTime := new(big.Int).SetUint64(parent.Time)
@ -365,7 +350,6 @@ func makeDifficultyCalculator(bombDelay *big.Int) func(time uint64, parent *type
// (2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9 // (2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9
x.Sub(bigTime, bigParentTime) x.Sub(bigTime, bigParentTime)
x.Div(x, big9) x.Div(x, big9)
if parent.UncleHash == types.EmptyUncleHash { if parent.UncleHash == types.EmptyUncleHash {
x.Sub(big1, x) x.Sub(big1, x)
} else { } else {
@ -401,7 +385,6 @@ func makeDifficultyCalculator(bombDelay *big.Int) func(time uint64, parent *type
y.Exp(big2, y, nil) y.Exp(big2, y, nil)
x.Add(x, y) x.Add(x, y)
} }
return x return x
} }
} }
@ -415,6 +398,7 @@ func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int {
// diff = (parent_diff + // diff = (parent_diff +
// (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99)) // (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
// ) + 2^(periodCount - 2) // ) + 2^(periodCount - 2)
bigTime := new(big.Int).SetUint64(time) bigTime := new(big.Int).SetUint64(time)
bigParentTime := new(big.Int).SetUint64(parent.Time) bigParentTime := new(big.Int).SetUint64(parent.Time)
@ -451,7 +435,6 @@ func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int {
y.Exp(big2, y, nil) y.Exp(big2, y, nil)
x.Add(x, y) x.Add(x, y)
} }
return x return x
} }
@ -472,14 +455,12 @@ func calcDifficultyFrontier(time uint64, parent *types.Header) *big.Int {
} else { } else {
diff.Sub(parent.Difficulty, adjust) diff.Sub(parent.Difficulty, adjust)
} }
if diff.Cmp(params.MinimumDifficulty) < 0 { if diff.Cmp(params.MinimumDifficulty) < 0 {
diff.Set(params.MinimumDifficulty) diff.Set(params.MinimumDifficulty)
} }
periodCount := new(big.Int).Add(parent.Number, big1) periodCount := new(big.Int).Add(parent.Number, big1)
periodCount.Div(periodCount, expDiffPeriod) periodCount.Div(periodCount, expDiffPeriod)
if periodCount.Cmp(big1) > 0 { if periodCount.Cmp(big1) > 0 {
// diff = diff + 2^(periodCount - 2) // diff = diff + 2^(periodCount - 2)
expDiff := periodCount.Sub(periodCount, big2) expDiff := periodCount.Sub(periodCount, big2)
@ -487,7 +468,6 @@ func calcDifficultyFrontier(time uint64, parent *types.Header) *big.Int {
diff.Add(diff, expDiff) diff.Add(diff, expDiff)
diff = math.BigMax(diff, params.MinimumDifficulty) diff = math.BigMax(diff, params.MinimumDifficulty)
} }
return diff return diff
} }
@ -503,9 +483,7 @@ func (ethash *Ethash) Prepare(chain consensus.ChainHeaderReader, header *types.H
if parent == nil { if parent == nil {
return consensus.ErrUnknownAncestor return consensus.ErrUnknownAncestor
} }
header.Difficulty = ethash.CalcDifficulty(chain, header.Time, parent) header.Difficulty = ethash.CalcDifficulty(chain, header.Time, parent)
return nil return nil
} }
@ -553,14 +531,11 @@ func (ethash *Ethash) SealHash(header *types.Header) (hash common.Hash) {
if header.BaseFee != nil { if header.BaseFee != nil {
enc = append(enc, header.BaseFee) enc = append(enc, header.BaseFee)
} }
if header.WithdrawalsHash != nil { if header.WithdrawalsHash != nil {
panic("withdrawal hash set on ethash") panic("withdrawal hash set on ethash")
} }
rlp.Encode(hasher, enc) rlp.Encode(hasher, enc)
hasher.Sum(hash[:0]) hasher.Sum(hash[:0])
return hash return hash
} }
@ -579,13 +554,11 @@ func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header
if config.IsByzantium(header.Number) { if config.IsByzantium(header.Number) {
blockReward = ByzantiumBlockReward blockReward = ByzantiumBlockReward
} }
if config.IsConstantinople(header.Number) { if config.IsConstantinople(header.Number) {
blockReward = ConstantinopleBlockReward blockReward = ConstantinopleBlockReward
} }
// Accumulate the rewards for the miner and any included uncles // Accumulate the rewards for the miner and any included uncles
reward := new(big.Int).Set(blockReward) reward := new(big.Int).Set(blockReward)
r := new(big.Int) r := new(big.Int)
for _, uncle := range uncles { for _, uncle := range uncles {
r.Add(uncle.Number, big8) r.Add(uncle.Number, big8)
@ -597,6 +570,5 @@ func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header
r.Div(blockReward, big32) r.Div(blockReward, big32)
reward.Add(reward, r) reward.Add(reward, r)
} }
state.AddBalance(header.Coinbase, reward) state.AddBalance(header.Coinbase, reward)
} }

5
core/genesis.go
View file

@ -552,16 +552,13 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *trie.Database) (*types.Block
if block.Number().Sign() != 0 { if block.Number().Sign() != 0 {
return nil, errors.New("can't commit genesis block with number > 0") return nil, errors.New("can't commit genesis block with number > 0")
} }
config := g.Config config := g.Config
if config == nil { if config == nil {
config = params.AllEthashProtocolChanges config = params.AllEthashProtocolChanges
} }
if err := config.CheckConfigForkOrder(); err != nil { if err := config.CheckConfigForkOrder(); err != nil {
return nil, err return nil, err
} }
if config.Clique != nil && len(block.Extra()) < 32+crypto.SignatureLength { if config.Clique != nil && len(block.Extra()) < 32+crypto.SignatureLength {
return nil, errors.New("can't start clique chain without signers") return nil, errors.New("can't start clique chain without signers")
} }
@ -571,7 +568,6 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *trie.Database) (*types.Block
if err := g.Alloc.flush(db, triedb, block.Hash()); err != nil { if err := g.Alloc.flush(db, triedb, block.Hash()); err != nil {
return nil, err return nil, err
} }
rawdb.WriteTd(db, block.Hash(), block.NumberU64(), block.Difficulty()) rawdb.WriteTd(db, block.Hash(), block.NumberU64(), block.Difficulty())
rawdb.WriteBlock(db, block) rawdb.WriteBlock(db, block)
rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil) rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil)
@ -580,7 +576,6 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *trie.Database) (*types.Block
rawdb.WriteHeadFastBlockHash(db, block.Hash()) rawdb.WriteHeadFastBlockHash(db, block.Hash())
rawdb.WriteHeadHeaderHash(db, block.Hash()) rawdb.WriteHeadHeaderHash(db, block.Hash())
rawdb.WriteChainConfig(db, block.Hash(), config) rawdb.WriteChainConfig(db, block.Hash(), config)
return block, nil return block, nil
} }

25
eth/filters/filter_test.go
View file

@ -112,8 +112,9 @@ func BenchmarkFilters(b *testing.B) {
func TestFilters(t *testing.T) { func TestFilters(t *testing.T) {
var ( var (
db, _ = rawdb.NewLevelDBDatabase(t.TempDir(), 0, 0, "", false, rawdb.ExtraDBConfig{}) db, _ = rawdb.NewLevelDBDatabase(t.TempDir(), 0, 0, "", false, rawdb.ExtraDBConfig{})
_, sys = newTestFilterSystem(t, db, Config{}) _, sys = newTestFilterSystem(t, db, Config{})
// Sender account
key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
addr = crypto.PubkeyToAddress(key1.PublicKey) addr = crypto.PubkeyToAddress(key1.PublicKey)
signer = types.NewLondonSigner(big.NewInt(1)) signer = types.NewLondonSigner(big.NewInt(1))
@ -289,21 +290,21 @@ func TestFilters(t *testing.T) {
}{ }{
{ {
f: sys.NewBlockFilter(chain[2].Hash(), []common.Address{contract}, nil), f: sys.NewBlockFilter(chain[2].Hash(), []common.Address{contract}, nil),
want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x7a7556792ca7d37882882e2b001fe14833eaf81c2c7f865c9c771ec37a024f6b","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x3cf440d9da8141c0a639a1a54c5640f2a260998ffedbc63323977e14ab9bf956","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), []common.Address{contract}, [][]common.Hash{{hash1, hash2, hash3, hash4}}), f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), []common.Address{contract}, [][]common.Hash{{hash1, hash2, hash3, hash4}}),
want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x2","transactionHash":"0xa8028c655b6423204c8edfbc339f57b042d6bec2b6a61145d76b7c08b4cccd42","transactionIndex":"0x0","blockHash":"0x24417bb49ce44cfad65da68f33b510bf2a129c0d89ccf06acb6958b8585ccf34","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x7a7556792ca7d37882882e2b001fe14833eaf81c2c7f865c9c771ec37a024f6b","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb360bad5265261c075ece02d3bf0e39498a6a76310482cdfd90588748e6c5ee0","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x2","transactionHash":"0xa8028c655b6423204c8edfbc339f57b042d6bec2b6a61145d76b7c08b4cccd42","transactionIndex":"0x0","blockHash":"0x91eb694ad9f9ab777a65b32e4740312f32fcdbb604906181b89627cd8d637e0b","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x3cf440d9da8141c0a639a1a54c5640f2a260998ffedbc63323977e14ab9bf956","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb996b4bf68bbbd9237f495bb1828aa0067b816d47d66b0826de3e27c587ce7d7","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(900, 999, []common.Address{contract}, [][]common.Hash{{hash3}}), f: sys.NewRangeFilter(900, 999, []common.Address{contract}, [][]common.Hash{{hash3}}),
}, { }, {
f: sys.NewRangeFilter(990, int64(rpc.LatestBlockNumber), []common.Address{contract2}, [][]common.Hash{{hash3}}), f: sys.NewRangeFilter(990, int64(rpc.LatestBlockNumber), []common.Address{contract2}, [][]common.Hash{{hash3}}),
want: `[{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x3e7","transactionHash":"0x53e3675800c6908424b61b35a44e51ca4c73ca603e58a65b32c67968b4f42200","transactionIndex":"0x0","blockHash":"0x2e4620a2b426b0612ec6cad9603f466723edaed87f98c9137405dd4f7a2409ff","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x3e7","transactionHash":"0x53e3675800c6908424b61b35a44e51ca4c73ca603e58a65b32c67968b4f42200","transactionIndex":"0x0","blockHash":"0x5d0849b4c67f044531948b9d5ae667de082130f386d1eb3a971f4c4de960a841","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(1, 10, []common.Address{contract}, [][]common.Hash{{hash2}, {hash1}}), f: sys.NewRangeFilter(1, 10, []common.Address{contract}, [][]common.Hash{{hash2}, {hash1}}),
want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x7a7556792ca7d37882882e2b001fe14833eaf81c2c7f865c9c771ec37a024f6b","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x3cf440d9da8141c0a639a1a54c5640f2a260998ffedbc63323977e14ab9bf956","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(1, 10, nil, [][]common.Hash{{hash1, hash2}}), f: sys.NewRangeFilter(1, 10, nil, [][]common.Hash{{hash1, hash2}}),
want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x2","transactionHash":"0xa8028c655b6423204c8edfbc339f57b042d6bec2b6a61145d76b7c08b4cccd42","transactionIndex":"0x0","blockHash":"0x24417bb49ce44cfad65da68f33b510bf2a129c0d89ccf06acb6958b8585ccf34","logIndex":"0x0","removed":false},{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x2","transactionHash":"0xdba3e2ea9a7d690b722d70ee605fd67ba4c00d1d3aecd5cf187a7b92ad8eb3df","transactionIndex":"0x1","blockHash":"0x24417bb49ce44cfad65da68f33b510bf2a129c0d89ccf06acb6958b8585ccf34","logIndex":"0x1","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x7a7556792ca7d37882882e2b001fe14833eaf81c2c7f865c9c771ec37a024f6b","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x2","transactionHash":"0xa8028c655b6423204c8edfbc339f57b042d6bec2b6a61145d76b7c08b4cccd42","transactionIndex":"0x0","blockHash":"0x91eb694ad9f9ab777a65b32e4740312f32fcdbb604906181b89627cd8d637e0b","logIndex":"0x0","removed":false},{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x2","transactionHash":"0xdba3e2ea9a7d690b722d70ee605fd67ba4c00d1d3aecd5cf187a7b92ad8eb3df","transactionIndex":"0x1","blockHash":"0x91eb694ad9f9ab777a65b32e4740312f32fcdbb604906181b89627cd8d637e0b","logIndex":"0x1","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x3cf440d9da8141c0a639a1a54c5640f2a260998ffedbc63323977e14ab9bf956","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}}), f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}}),
}, { }, {
@ -312,13 +313,13 @@ func TestFilters(t *testing.T) {
f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}, {hash1}}), f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}, {hash1}}),
}, { }, {
f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.LatestBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.LatestBlockNumber), nil, nil),
want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb360bad5265261c075ece02d3bf0e39498a6a76310482cdfd90588748e6c5ee0","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb996b4bf68bbbd9237f495bb1828aa0067b816d47d66b0826de3e27c587ce7d7","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.LatestBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.LatestBlockNumber), nil, nil),
want: `[{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x3e7","transactionHash":"0x53e3675800c6908424b61b35a44e51ca4c73ca603e58a65b32c67968b4f42200","transactionIndex":"0x0","blockHash":"0x2e4620a2b426b0612ec6cad9603f466723edaed87f98c9137405dd4f7a2409ff","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb360bad5265261c075ece02d3bf0e39498a6a76310482cdfd90588748e6c5ee0","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x3e7","transactionHash":"0x53e3675800c6908424b61b35a44e51ca4c73ca603e58a65b32c67968b4f42200","transactionIndex":"0x0","blockHash":"0x5d0849b4c67f044531948b9d5ae667de082130f386d1eb3a971f4c4de960a841","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb996b4bf68bbbd9237f495bb1828aa0067b816d47d66b0826de3e27c587ce7d7","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil),
want: `[{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x3e7","transactionHash":"0x53e3675800c6908424b61b35a44e51ca4c73ca603e58a65b32c67968b4f42200","transactionIndex":"0x0","blockHash":"0x2e4620a2b426b0612ec6cad9603f466723edaed87f98c9137405dd4f7a2409ff","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x3e7","transactionHash":"0x53e3675800c6908424b61b35a44e51ca4c73ca603e58a65b32c67968b4f42200","transactionIndex":"0x0","blockHash":"0x5d0849b4c67f044531948b9d5ae667de082130f386d1eb3a971f4c4de960a841","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil),
}, { }, {
@ -332,10 +333,10 @@ func TestFilters(t *testing.T) {
err: "safe header not found", err: "safe header not found",
}, { }, {
f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.PendingBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.PendingBlockNumber), nil, nil),
want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696335"],"data":"0x","blockNumber":"0x3e9","transactionHash":"0x4110587c1b8d86edc85dce929a34127f1cb8809515a9f177c91c866de3eb0638","transactionIndex":"0x0","blockHash":"0xc7245899e5817f16fa99cf5ad2d9c1e4b98443a565a673ec9c764640443ef037","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696335"],"data":"0x","blockNumber":"0x3e9","transactionHash":"0x4110587c1b8d86edc85dce929a34127f1cb8809515a9f177c91c866de3eb0638","transactionIndex":"0x0","blockHash":"0x643cd356acdeb6683d098e5af50664ba099a56e03b93cb12a3f254457a6a1310","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.PendingBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.PendingBlockNumber), nil, nil),
want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb360bad5265261c075ece02d3bf0e39498a6a76310482cdfd90588748e6c5ee0","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696335"],"data":"0x","blockNumber":"0x3e9","transactionHash":"0x4110587c1b8d86edc85dce929a34127f1cb8809515a9f177c91c866de3eb0638","transactionIndex":"0x0","blockHash":"0xc7245899e5817f16fa99cf5ad2d9c1e4b98443a565a673ec9c764640443ef037","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb996b4bf68bbbd9237f495bb1828aa0067b816d47d66b0826de3e27c587ce7d7","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696335"],"data":"0x","blockNumber":"0x3e9","transactionHash":"0x4110587c1b8d86edc85dce929a34127f1cb8809515a9f177c91c866de3eb0638","transactionIndex":"0x0","blockHash":"0x643cd356acdeb6683d098e5af50664ba099a56e03b93cb12a3f254457a6a1310","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.LatestBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.LatestBlockNumber), nil, nil),
err: "invalid block range", err: "invalid block range",

23
graphql/graphql_test.go
View file

@ -268,7 +268,10 @@ func TestGraphQLHTTPOnSamePort_GQLRequest_Unsuccessful(t *testing.T) {
assert.Equal(t, http.StatusNotFound, resp.StatusCode) assert.Equal(t, http.StatusNotFound, resp.StatusCode)
} }
// nolint:typecheck
func TestGraphQLConcurrentResolvers(t *testing.T) { func TestGraphQLConcurrentResolvers(t *testing.T) {
t.Parallel()
var ( var (
key, _ = crypto.GenerateKey() key, _ = crypto.GenerateKey()
addr = crypto.PubkeyToAddress(key.PublicKey) addr = crypto.PubkeyToAddress(key.PublicKey)
@ -291,9 +294,11 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
signer = types.LatestSigner(genesis.Config) signer = types.LatestSigner(genesis.Config)
stack = createNode(t) stack = createNode(t)
) )
defer stack.Close() defer stack.Close()
var tx *types.Transaction var tx *types.Transaction
handler, chain := newGQLService(t, stack, false, genesis, 1, func(i int, gen *core.BlockGen) { handler, chain := newGQLService(t, stack, false, genesis, 1, func(i int, gen *core.BlockGen) {
tx, _ = types.SignNewTx(key, signer, &types.LegacyTx{To: &dad, Gas: 100000, GasPrice: big.NewInt(params.InitialBaseFee)}) tx, _ = types.SignNewTx(key, signer, &types.LegacyTx{To: &dad, Gas: 100000, GasPrice: big.NewInt(params.InitialBaseFee)})
gen.AddTx(tx) gen.AddTx(tx)
@ -314,18 +319,13 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
// Multiple txes race to get/set the block hash. // Multiple txes race to get/set the block hash.
{ {
body: "{block { transactions { logs { account { address } } } } }", body: "{block { transactions { logs { account { address } } } } }",
want: fmt.Sprintf(`{"block":{"transactions":[{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]}]}}`, dadStr, dadStr, dadStr, dadStr, dadStr, dadStr), want: fmt.Sprintf(`{"block":{"transactions":[{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}},{"account":{"address":"%s"}}]}]}}`, dadStr, dadStr, core.GetFeeAddress(), dadStr, dadStr, core.GetFeeAddress(), dadStr, dadStr, core.GetFeeAddress()),
}, },
// Multiple fields of a tx race to resolve it. Happens in this case // Multiple fields of a tx race to resolve it. Happens in this case
// because resolving the tx body belonging to a log is delayed. // because resolving the tx body belonging to a log is delayed.
{ {
body: `{block { logs(filter: {}) { transaction { nonce value gasPrice }}}}`, body: `{block { logs(filter: {}) { transaction { nonce value gasPrice }}}}`,
want: `{"block":{"logs":[{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}}]}}`, want: `{"block":{"logs":[{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}}]}}`,
},
// Multiple txes of a block race to set/retrieve receipts of a block.
{
body: "{block { transactions { status gasUsed } } }",
want: `{"block":{"transactions":[{"status":"0x1","gasUsed":"0x5508"},{"status":"0x1","gasUsed":"0x5508"},{"status":"0x1","gasUsed":"0x5508"}]}}`,
}, },
// Multiple fields of block race to resolve header and body. // Multiple fields of block race to resolve header and body.
{ {
@ -337,6 +337,11 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
body: fmt.Sprintf(`{ transaction(hash: "%s") { block { number hash gasLimit ommerCount transactionCount } } }`, tx.Hash()), body: fmt.Sprintf(`{ transaction(hash: "%s") { block { number hash gasLimit ommerCount transactionCount } } }`, tx.Hash()),
want: fmt.Sprintf(`{"transaction":{"block":{"number":"0x1","hash":"%s","gasLimit":"0xaf79e0","ommerCount":"0x0","transactionCount":"0x3"}}}`, chain[len(chain)-1].Hash()), want: fmt.Sprintf(`{"transaction":{"block":{"number":"0x1","hash":"%s","gasLimit":"0xaf79e0","ommerCount":"0x0","transactionCount":"0x3"}}}`, chain[len(chain)-1].Hash()),
}, },
// Multiple fields of a block race to resolve the header and body.
{
body: fmt.Sprintf(`{ transaction(hash: "%s") { block { number hash gasLimit ommerCount transactionCount } } }`, tx.Hash()),
want: fmt.Sprintf(`{"transaction":{"block":{"number":"0x1","hash":"%s","gasLimit":"0xaf79e0","ommerCount":"0x0","transactionCount":"0x3"}}}`, chain[len(chain)-1].Hash()),
},
// Account fields race the resolve the state object. // Account fields race the resolve the state object.
{ {
body: fmt.Sprintf(`{ block { account(address: "%s") { balance transactionCount code } } }`, dadStr), body: fmt.Sprintf(`{ block { account(address: "%s") { balance transactionCount code } } }`, dadStr),
@ -349,13 +354,17 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
}, },
} { } {
res := handler.Schema.Exec(context.Background(), tt.body, "", map[string]interface{}{}) res := handler.Schema.Exec(context.Background(), tt.body, "", map[string]interface{}{})
if res.Errors != nil { if res.Errors != nil {
t.Fatalf("failed to execute query for testcase #%d: %v", i, res.Errors) t.Fatalf("failed to execute query for testcase #%d: %v", i, res.Errors)
} }
have, err := json.Marshal(res.Data) have, err := json.Marshal(res.Data)
if err != nil { if err != nil {
t.Fatalf("failed to encode graphql response for testcase #%d: %s", i, err) t.Fatalf("failed to encode graphql response for testcase #%d: %s", i, err)
} }
if string(have) != tt.want { if string(have) != tt.want {
t.Errorf("response unmatch for testcase #%d.\nExpected:\n%s\nGot:\n%s\n", i, tt.want, have) t.Errorf("response unmatch for testcase #%d.\nExpected:\n%s\nGot:\n%s\n", i, tt.want, have)
} }

1194
internal/ethapi/api_test.go
View file

File diff suppressed because it is too large Load diff