forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-27 15:16:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

fix testcase syntax

Browse source
This commit is contained in:
Arpit Temani 2023-09-20 15:57:37 +05:30
parent feea10a820
commit 3626e5f7e4
37 changed files with 2728 additions and 3079 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Makefile
View file

@ -58,7 +58,7 @@ ios:
@echo "Import \"$(GOBIN)/Geth.framework\" to use the library." @echo "Import \"$(GOBIN)/Geth.framework\" to use the library."
test: test:
$(GOTEST) --timeout 5m -cover -short -coverprofile=cover.out -covermode=atomic $(TESTALL) $(GOTEST) --timeout 15m -cover -short -coverprofile=cover.out -covermode=atomic $(TESTALL)
test-txpool-race: test-txpool-race:
$(GOTEST) -run=TestPoolMiningDataRaces --timeout 600m -race -v ./core/ $(GOTEST) -run=TestPoolMiningDataRaces --timeout 600m -race -v ./core/

2
common/gererics/empty.go → common/generics/empty.go
View file

@ -1,4 +1,4 @@
package gererics package generics
func Empty[T any]() (t T) { func Empty[T any]() (t T) {
return return

2
core/bench_test.go
View file

@ -315,7 +315,7 @@ func benchReadChain(b *testing.B, full bool, count uint64) {
makeChainForBench(db, full, count) makeChainForBench(db, full, count)
db.Close() db.Close()
cacheConfig := *DefaultCacheConfig cacheConfig := *defaultCacheConfig
cacheConfig.TrieDirtyDisabled = true cacheConfig.TrieDirtyDisabled = true
b.ReportAllocs() b.ReportAllocs()

10
core/blockchain.go
View file

@ -157,9 +157,9 @@ type CacheConfig struct {
SnapshotWait bool // Wait for snapshot construction on startup. TODO(karalabe): This is a dirty hack for testing, nuke it SnapshotWait bool // Wait for snapshot construction on startup. TODO(karalabe): This is a dirty hack for testing, nuke it
} }
// DefaultCacheConfig are the default caching values if none are specified by the // defaultCacheConfig are the default caching values if none are specified by the
// user (also used during testing). // user (also used during testing).
var DefaultCacheConfig = &CacheConfig{ var defaultCacheConfig = &CacheConfig{
TrieCleanLimit: 256, TrieCleanLimit: 256,
TrieDirtyLimit: 256, TrieDirtyLimit: 256,
TrieTimeLimit: 5 * time.Minute, TrieTimeLimit: 5 * time.Minute,
@ -168,6 +168,8 @@ var DefaultCacheConfig = &CacheConfig{
TriesInMemory: 1024, TriesInMemory: 1024,
} }
var DefaultCacheConfig = defaultCacheConfig
// BlockChain represents the canonical chain given a database with a genesis // BlockChain represents the canonical chain given a database with a genesis
// block. The Blockchain manages chain imports, reverts, chain reorganisations. // block. The Blockchain manages chain imports, reverts, chain reorganisations.
// //
@ -257,11 +259,11 @@ type BlockChain struct {
//nolint:gocognit //nolint:gocognit
func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis, overrides *ChainOverrides, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(header *types.Header) bool, txLookupLimit *uint64, checker ethereum.ChainValidator) (*BlockChain, error) { func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis, overrides *ChainOverrides, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(header *types.Header) bool, txLookupLimit *uint64, checker ethereum.ChainValidator) (*BlockChain, error) {
if cacheConfig == nil { if cacheConfig == nil {
cacheConfig = DefaultCacheConfig cacheConfig = defaultCacheConfig
} }
if cacheConfig.TriesInMemory <= 0 { if cacheConfig.TriesInMemory <= 0 {
cacheConfig.TriesInMemory = DefaultCacheConfig.TriesInMemory cacheConfig.TriesInMemory = defaultCacheConfig.TriesInMemory
} }
// Open trie database with provided config // Open trie database with provided config
triedb := trie.NewDatabaseWithConfig(db, &trie.Config{ triedb := trie.NewDatabaseWithConfig(db, &trie.Config{

176
core/tests/blockchain_repair_test.go → core/blockchain_repair_test.go
View file

@ -18,28 +18,19 @@
// the database in some strange state with gaps in the chain, nor with block data // the database in some strange state with gaps in the chain, nor with block data
// dangling in the future. // dangling in the future.
package tests package core
import ( import (
"math/big" "math/big"
"testing" "testing"
"time" "time"
"github.com/golang/mock/gomock"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus/bor"
"github.com/ethereum/go-ethereum/consensus/bor/api"
"github.com/ethereum/go-ethereum/consensus/bor/valset"
"github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/consensus/ethash"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/miner"
"github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/tests/bor/mocks"
) )
// Tests a recovery for a short canonical chain where a recent block was already // Tests a recovery for a short canonical chain where a recent block was already
@ -1757,17 +1748,7 @@ func testLongReorgedSnapSyncingDeepRepair(t *testing.T, snapshots bool) {
}, snapshots) }, snapshots)
} }
var (
testKey1, _ = crypto.GenerateKey()
testAddress1 = crypto.PubkeyToAddress(testKey1.PublicKey)
testKey2, _ = crypto.GenerateKey()
testAddress2 = crypto.PubkeyToAddress(testKey2.PublicKey) //nolint:unused,varcheck
)
func testRepair(t *testing.T, tt *rewindTest, snapshots bool) { func testRepair(t *testing.T, tt *rewindTest, snapshots bool) {
t.Skip("need to add a proper signer for Bor consensus")
// It's hard to follow the test case, visualize the input // It's hard to follow the test case, visualize the input
//log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true)))) //log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
// fmt.Println(tt.dump(true)) // fmt.Println(tt.dump(true))
@ -1784,102 +1765,71 @@ func testRepair(t *testing.T, tt *rewindTest, snapshots bool) {
} }
defer db.Close() // Might double close, should be fine defer db.Close() // Might double close, should be fine
chainConfig := params.BorUnittestChainConfig // Initialize a fresh chain
var (
ctrl := gomock.NewController(t) gspec = &Genesis{
defer ctrl.Finish() BaseFee: big.NewInt(params.InitialBaseFee),
Config: params.AllEthashProtocolChanges,
ethAPIMock := api.NewMockCaller(ctrl) }
ethAPIMock.EXPECT().Call(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() engine = ethash.NewFullFaker()
config = &CacheConfig{
spanner := bor.NewMockSpanner(ctrl) TrieCleanLimit: 256,
spanner.EXPECT().GetCurrentValidatorsByHash(gomock.Any(), gomock.Any(), gomock.Any()).Return([]*valset.Validator{ TrieDirtyLimit: 256,
{ TrieTimeLimit: 5 * time.Minute,
ID: 0, SnapshotLimit: 0, // Disable snapshot by default
Address: miner.TestBankAddress, }
VotingPower: 100, )
ProposerPriority: 0,
},
}, nil).AnyTimes()
heimdallClientMock := mocks.NewMockIHeimdallClient(ctrl)
heimdallClientMock.EXPECT().Close().Times(1)
contractMock := bor.NewMockGenesisContract(ctrl)
engine := miner.NewFakeBor(t, db, chainConfig, ethAPIMock, spanner, heimdallClientMock, contractMock)
defer engine.Close() defer engine.Close()
if snapshots {
chainConfig.LondonBlock = big.NewInt(0) config.SnapshotLimit = 256
config.SnapshotWait = true
_, back, closeFn := miner.NewTestWorker(t, chainConfig, engine, db, 0, false, 0, 0) }
defer closeFn() chain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil, nil)
if err != nil {
genesis := back.BlockChain().Genesis() t.Fatalf("Failed to create chain: %v", err)
}
// If sidechain blocks are needed, make a light chain and import it // If sidechain blocks are needed, make a light chain and import it
var sideblocks types.Blocks var sideblocks types.Blocks
if tt.sidechainBlocks > 0 { if tt.sidechainBlocks > 0 {
sideblocks, _ = core.GenerateChain(params.BorUnittestChainConfig, genesis, engine, rawdb.NewMemoryDatabase(), tt.sidechainBlocks, func(i int, b *core.BlockGen) { sideblocks, _ = GenerateChain(gspec.Config, gspec.ToBlock(), engine, rawdb.NewMemoryDatabase(), tt.sidechainBlocks, func(i int, b *BlockGen) {
b.SetCoinbase(testAddress1) b.SetCoinbase(common.Address{0x01})
if bor.IsSprintStart(b.Number().Uint64(), params.BorUnittestChainConfig.Bor.CalculateSprint(b.Number().Uint64())) {
b.SetExtra(back.Genesis.ExtraData)
} else {
b.SetExtra(make([]byte, 32+crypto.SignatureLength))
}
}) })
if _, err := back.BlockChain().InsertChain(sideblocks); err != nil { if _, err := chain.InsertChain(sideblocks); err != nil {
t.Fatalf("Failed to import side chain: %v", err) t.Fatalf("Failed to import side chain: %v", err)
} }
} }
canonblocks, _ := GenerateChain(gspec.Config, gspec.ToBlock(), engine, rawdb.NewMemoryDatabase(), tt.canonicalBlocks, func(i int, b *BlockGen) {
canonblocks, _ := core.GenerateChain(params.BorUnittestChainConfig, genesis, engine, rawdb.NewMemoryDatabase(), tt.canonicalBlocks, func(i int, b *core.BlockGen) { b.SetCoinbase(common.Address{0x02})
b.SetCoinbase(miner.TestBankAddress)
b.SetDifficulty(big.NewInt(1000000)) b.SetDifficulty(big.NewInt(1000000))
if bor.IsSprintStart(b.Number().Uint64(), params.BorUnittestChainConfig.Bor.CalculateSprint(b.Number().Uint64())) {
b.SetExtra(back.Genesis.ExtraData)
} else {
b.SetExtra(make([]byte, 32+crypto.SignatureLength))
}
}) })
if _, err := back.BlockChain().InsertChain(canonblocks[:tt.commitBlock]); err != nil { if _, err := chain.InsertChain(canonblocks[:tt.commitBlock]); err != nil {
t.Fatalf("Failed to import canonical chain start: %v", err) t.Fatalf("Failed to import canonical chain start: %v", err)
} }
if tt.commitBlock > 0 { if tt.commitBlock > 0 {
err = back.BlockChain().StateCache().TrieDB().Commit(canonblocks[tt.commitBlock-1].Root(), true) chain.stateCache.TrieDB().Commit(canonblocks[tt.commitBlock-1].Root(), false)
if err != nil {
t.Fatal("on trieDB.Commit", err)
}
if snapshots { if snapshots {
if err := back.BlockChain().Snaps().Cap(canonblocks[tt.commitBlock-1].Root(), 0); err != nil { if err := chain.snaps.Cap(canonblocks[tt.commitBlock-1].Root(), 0); err != nil {
t.Fatalf("Failed to flatten snapshots: %v", err) t.Fatalf("Failed to flatten snapshots: %v", err)
} }
} }
} }
if _, err := chain.InsertChain(canonblocks[tt.commitBlock:]); err != nil {
if _, err := back.BlockChain().InsertChain(canonblocks[tt.commitBlock:]); err != nil {
t.Fatalf("Failed to import canonical chain tail: %v", err) t.Fatalf("Failed to import canonical chain tail: %v", err)
} }
// Force run a freeze cycle // Force run a freeze cycle
type freezer interface { type freezer interface {
Freeze(threshold uint64) error Freeze(threshold uint64) error
Ancients() (uint64, error) Ancients() (uint64, error)
} }
db.(freezer).Freeze(tt.freezeThreshold) db.(freezer).Freeze(tt.freezeThreshold)
// Set the simulated pivot block // Set the simulated pivot block
if tt.pivotBlock != nil { if tt.pivotBlock != nil {
rawdb.WriteLastPivotNumber(db, *tt.pivotBlock) rawdb.WriteLastPivotNumber(db, *tt.pivotBlock)
} }
// Pull the plug on the database, simulating a hard crash // Pull the plug on the database, simulating a hard crash
db.Close() db.Close()
chain.stopWithoutSaving()
// Start a new blockchain back up and see where the repair leads us // Start a new blockchain back up and see where the repair leads us
db, err = rawdb.Open(rawdb.OpenOptions{ db, err = rawdb.Open(rawdb.OpenOptions{
@ -1890,28 +1840,12 @@ func testRepair(t *testing.T, tt *rewindTest, snapshots bool) {
if err != nil { if err != nil {
t.Fatalf("Failed to reopen persistent database: %v", err) t.Fatalf("Failed to reopen persistent database: %v", err)
} }
defer db.Close() defer db.Close()
var ( newChain, err := NewBlockChain(db, nil, gspec, nil, engine, vm.Config{}, nil, nil, nil)
gspec = &core.Genesis{
Config: params.TestChainConfig,
BaseFee: big.NewInt(params.InitialBaseFee),
}
config = &core.CacheConfig{
TrieCleanLimit: 256,
TrieDirtyLimit: 256,
TrieTimeLimit: 5 * time.Minute,
SnapshotLimit: 256,
SnapshotWait: true,
}
)
newChain, err := core.NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
defer newChain.Stop() defer newChain.Stop()
// Iterate over all the remaining blocks and ensure there are no gaps // Iterate over all the remaining blocks and ensure there are no gaps
@ -1923,15 +1857,12 @@ func testRepair(t *testing.T, tt *rewindTest, snapshots bool) {
if head := newChain.CurrentHeader(); head.Number.Uint64() != tt.expHeadHeader { if head := newChain.CurrentHeader(); head.Number.Uint64() != tt.expHeadHeader {
t.Errorf("Head header mismatch: have %d, want %d", head.Number, tt.expHeadHeader) t.Errorf("Head header mismatch: have %d, want %d", head.Number, tt.expHeadHeader)
} }
if head := newChain.CurrentSnapBlock(); head.Number.Uint64() != tt.expHeadFastBlock { if head := newChain.CurrentSnapBlock(); head.Number.Uint64() != tt.expHeadFastBlock {
t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, tt.expHeadFastBlock) t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, tt.expHeadFastBlock)
} }
if head := newChain.CurrentBlock(); head.Number.Uint64() != tt.expHeadBlock { if head := newChain.CurrentBlock(); head.Number.Uint64() != tt.expHeadBlock {
t.Errorf("Head block mismatch: have %d, want %d", head.Number, tt.expHeadBlock) t.Errorf("Head block mismatch: have %d, want %d", head.Number, tt.expHeadBlock)
} }
if frozen, err := db.(freezer).Ancients(); err != nil { if frozen, err := db.(freezer).Ancients(); err != nil {
t.Errorf("Failed to retrieve ancient count: %v\n", err) t.Errorf("Failed to retrieve ancient count: %v\n", err)
} else if int(frozen) != tt.expFrozen { } else if int(frozen) != tt.expFrozen {
@ -1956,6 +1887,7 @@ func testRepair(t *testing.T, tt *rewindTest, snapshots bool) {
func TestIssue23496(t *testing.T) { func TestIssue23496(t *testing.T) {
// It's hard to follow the test case, visualize the input // It's hard to follow the test case, visualize the input
//log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true)))) //log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
// Create a temporary persistent database // Create a temporary persistent database
datadir := t.TempDir() datadir := t.TempDir()
@ -1967,17 +1899,16 @@ func TestIssue23496(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("Failed to create persistent database: %v", err) t.Fatalf("Failed to create persistent database: %v", err)
} }
defer db.Close() // Might double close, should be fine defer db.Close() // Might double close, should be fine
// Initialize a fresh chain // Initialize a fresh chain
var ( var (
gspec = &core.Genesis{ gspec = &Genesis{
Config: params.TestChainConfig, Config: params.TestChainConfig,
BaseFee: big.NewInt(params.InitialBaseFee), BaseFee: big.NewInt(params.InitialBaseFee),
} }
engine = ethash.NewFullFaker() engine = ethash.NewFullFaker()
config = &core.CacheConfig{ config = &CacheConfig{
TrieCleanLimit: 256, TrieCleanLimit: 256,
TrieDirtyLimit: 256, TrieDirtyLimit: 256,
TrieTimeLimit: 5 * time.Minute, TrieTimeLimit: 5 * time.Minute,
@ -1985,13 +1916,11 @@ func TestIssue23496(t *testing.T) {
SnapshotWait: true, SnapshotWait: true,
} }
) )
chain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil, nil)
chain, err := core.NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to create chain: %v", err) t.Fatalf("Failed to create chain: %v", err)
} }
_, blocks, _ := GenerateChainWithGenesis(gspec, engine, 4, func(i int, b *BlockGen) {
_, blocks, _ := core.GenerateChainWithGenesis(gspec, engine, 4, func(i int, b *core.BlockGen) {
b.SetCoinbase(common.Address{0x02}) b.SetCoinbase(common.Address{0x02})
b.SetDifficulty(big.NewInt(1000000)) b.SetDifficulty(big.NewInt(1000000))
}) })
@ -2000,18 +1929,13 @@ func TestIssue23496(t *testing.T) {
if _, err := chain.InsertChain(blocks[:1]); err != nil { if _, err := chain.InsertChain(blocks[:1]); err != nil {
t.Fatalf("Failed to import canonical chain start: %v", err) t.Fatalf("Failed to import canonical chain start: %v", err)
} }
chain.stateCache.TrieDB().Commit(blocks[0].Root(), false)
err = chain.StateCache().TrieDB().Commit(blocks[0].Root(), true)
if err != nil {
t.Fatal("on trieDB.Commit", err)
}
// Insert block B2 and commit the snapshot into disk // Insert block B2 and commit the snapshot into disk
if _, err := chain.InsertChain(blocks[1:2]); err != nil { if _, err := chain.InsertChain(blocks[1:2]); err != nil {
t.Fatalf("Failed to import canonical chain start: %v", err) t.Fatalf("Failed to import canonical chain start: %v", err)
} }
if err := chain.snaps.Cap(blocks[1].Root(), 0); err != nil {
if err := chain.Snaps().Cap(blocks[1].Root(), 0); err != nil {
t.Fatalf("Failed to flatten snapshots: %v", err) t.Fatalf("Failed to flatten snapshots: %v", err)
} }
@ -2019,20 +1943,16 @@ func TestIssue23496(t *testing.T) {
if _, err := chain.InsertChain(blocks[2:3]); err != nil { if _, err := chain.InsertChain(blocks[2:3]); err != nil {
t.Fatalf("Failed to import canonical chain start: %v", err) t.Fatalf("Failed to import canonical chain start: %v", err)
} }
chain.stateCache.TrieDB().Commit(blocks[2].Root(), false)
_ = chain.StateCache().TrieDB().Commit(blocks[2].Root(), false)
// Insert the remaining blocks // Insert the remaining blocks
if _, err := chain.InsertChain(blocks[3:]); err != nil { if _, err := chain.InsertChain(blocks[3:]); err != nil {
t.Fatalf("Failed to import canonical chain tail: %v", err) t.Fatalf("Failed to import canonical chain tail: %v", err)
} }
err = chain.StateCache().TrieDB().Commit(blocks[2].Root(), true)
if err != nil {
t.Fatal("on trieDB.Commit", err)
}
// Pull the plug on the database, simulating a hard crash // Pull the plug on the database, simulating a hard crash
db.Close() db.Close()
chain.stopWithoutSaving()
// Start a new blockchain back up and see where the repair leads us // Start a new blockchain back up and see where the repair leads us
db, err = rawdb.Open(rawdb.OpenOptions{ db, err = rawdb.Open(rawdb.OpenOptions{
@ -2042,24 +1962,20 @@ func TestIssue23496(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("Failed to reopen persistent database: %v", err) t.Fatalf("Failed to reopen persistent database: %v", err)
} }
defer db.Close() defer db.Close()
chain, err = core.NewBlockChain(db, nil, gspec, nil, engine, vm.Config{}, nil, nil, nil) chain, err = NewBlockChain(db, nil, gspec, nil, engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
defer chain.Stop() defer chain.Stop()
if head := chain.CurrentHeader(); head.Number.Uint64() != uint64(4) { if head := chain.CurrentHeader(); head.Number.Uint64() != uint64(4) {
t.Errorf("Head header mismatch: have %d, want %d", head.Number, 4) t.Errorf("Head header mismatch: have %d, want %d", head.Number, 4)
} }
if head := chain.CurrentSnapBlock(); head.Number.Uint64() != uint64(4) { if head := chain.CurrentSnapBlock(); head.Number.Uint64() != uint64(4) {
t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, uint64(4)) t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, uint64(4))
} }
if head := chain.CurrentBlock(); head.Number.Uint64() != uint64(1) { if head := chain.CurrentBlock(); head.Number.Uint64() != uint64(1) {
t.Errorf("Head block mismatch: have %d, want %d", head.Number, uint64(1)) t.Errorf("Head block mismatch: have %d, want %d", head.Number, uint64(1))
} }
@ -2068,19 +1984,15 @@ func TestIssue23496(t *testing.T) {
if _, err := chain.InsertChain(blocks[1:]); err != nil { if _, err := chain.InsertChain(blocks[1:]); err != nil {
t.Fatalf("Failed to import canonical chain tail: %v", err) t.Fatalf("Failed to import canonical chain tail: %v", err)
} }
if head := chain.CurrentHeader(); head.Number.Uint64() != uint64(4) { if head := chain.CurrentHeader(); head.Number.Uint64() != uint64(4) {
t.Errorf("Head header mismatch: have %d, want %d", head.Number, 4) t.Errorf("Head header mismatch: have %d, want %d", head.Number, 4)
} }
if head := chain.CurrentSnapBlock(); head.Number.Uint64() != uint64(4) { if head := chain.CurrentSnapBlock(); head.Number.Uint64() != uint64(4) {
t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, uint64(4)) t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, uint64(4))
} }
if head := chain.CurrentBlock(); head.Number.Uint64() != uint64(4) { if head := chain.CurrentBlock(); head.Number.Uint64() != uint64(4) {
t.Errorf("Head block mismatch: have %d, want %d", head.Number, uint64(4)) t.Errorf("Head block mismatch: have %d, want %d", head.Number, uint64(4))
} }
if layer := chain.Snapshots().Snapshot(blocks[2].Root()); layer == nil { if layer := chain.Snapshots().Snapshot(blocks[2].Root()); layer == nil {
t.Error("Failed to regenerate the snapshot of known state") t.Error("Failed to regenerate the snapshot of known state")
} }

81
core/tests/blockchain_sethead_test.go → core/blockchain_sethead_test.go
View file

@ -17,7 +17,7 @@
// Tests that setting the chain head backwards doesn't leave the database in some // Tests that setting the chain head backwards doesn't leave the database in some
// strange state with gaps in the chain, nor with block data dangling in the future. // strange state with gaps in the chain, nor with block data dangling in the future.
package tests package core
import ( import (
"fmt" "fmt"
@ -28,7 +28,6 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/consensus/ethash"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/core/vm"
@ -57,26 +56,21 @@ func (tt *rewindTest) dump(crash bool) string {
buffer := new(strings.Builder) buffer := new(strings.Builder)
fmt.Fprint(buffer, "Chain:\n G") fmt.Fprint(buffer, "Chain:\n G")
for i := 0; i < tt.canonicalBlocks; i++ { for i := 0; i < tt.canonicalBlocks; i++ {
fmt.Fprintf(buffer, "->C%d", i+1) fmt.Fprintf(buffer, "->C%d", i+1)
} }
fmt.Fprint(buffer, " (HEAD)\n") fmt.Fprint(buffer, " (HEAD)\n")
if tt.sidechainBlocks > 0 { if tt.sidechainBlocks > 0 {
fmt.Fprintf(buffer, " └") fmt.Fprintf(buffer, " └")
for i := 0; i < tt.sidechainBlocks; i++ { for i := 0; i < tt.sidechainBlocks; i++ {
fmt.Fprintf(buffer, "->S%d", i+1) fmt.Fprintf(buffer, "->S%d", i+1)
} }
fmt.Fprintf(buffer, "\n") fmt.Fprintf(buffer, "\n")
} }
fmt.Fprintf(buffer, "\n") fmt.Fprintf(buffer, "\n")
if tt.canonicalBlocks > int(tt.freezeThreshold) { if tt.canonicalBlocks > int(tt.freezeThreshold) {
fmt.Fprint(buffer, "Frozen:\n G") fmt.Fprint(buffer, "Frozen:\n G")
for i := 0; i < tt.canonicalBlocks-int(tt.freezeThreshold); i++ { for i := 0; i < tt.canonicalBlocks-int(tt.freezeThreshold); i++ {
fmt.Fprintf(buffer, "->C%d", i+1) fmt.Fprintf(buffer, "->C%d", i+1)
} }
@ -84,13 +78,10 @@ func (tt *rewindTest) dump(crash bool) string {
} else { } else {
fmt.Fprintf(buffer, "Frozen: none\n") fmt.Fprintf(buffer, "Frozen: none\n")
} }
fmt.Fprintf(buffer, "Commit: G") fmt.Fprintf(buffer, "Commit: G")
if tt.commitBlock > 0 { if tt.commitBlock > 0 {
fmt.Fprintf(buffer, ", C%d", tt.commitBlock) fmt.Fprintf(buffer, ", C%d", tt.commitBlock)
} }
fmt.Fprint(buffer, "\n") fmt.Fprint(buffer, "\n")
if tt.pivotBlock == nil { if tt.pivotBlock == nil {
@ -98,38 +89,31 @@ func (tt *rewindTest) dump(crash bool) string {
} else { } else {
fmt.Fprintf(buffer, "Pivot : C%d\n", *tt.pivotBlock) fmt.Fprintf(buffer, "Pivot : C%d\n", *tt.pivotBlock)
} }
if crash { if crash {
fmt.Fprintf(buffer, "\nCRASH\n\n") fmt.Fprintf(buffer, "\nCRASH\n\n")
} else { } else {
fmt.Fprintf(buffer, "\nSetHead(%d)\n\n", tt.setheadBlock) fmt.Fprintf(buffer, "\nSetHead(%d)\n\n", tt.setheadBlock)
} }
fmt.Fprintf(buffer, "------------------------------\n\n") fmt.Fprintf(buffer, "------------------------------\n\n")
if tt.expFrozen > 0 { if tt.expFrozen > 0 {
fmt.Fprint(buffer, "Expected in freezer:\n G") fmt.Fprint(buffer, "Expected in freezer:\n G")
for i := 0; i < tt.expFrozen-1; i++ { for i := 0; i < tt.expFrozen-1; i++ {
fmt.Fprintf(buffer, "->C%d", i+1) fmt.Fprintf(buffer, "->C%d", i+1)
} }
fmt.Fprintf(buffer, "\n\n") fmt.Fprintf(buffer, "\n\n")
} }
if tt.expFrozen > 0 { if tt.expFrozen > 0 {
if tt.expFrozen >= tt.expCanonicalBlocks { if tt.expFrozen >= tt.expCanonicalBlocks {
fmt.Fprintf(buffer, "Expected in leveldb: none\n") fmt.Fprintf(buffer, "Expected in leveldb: none\n")
} else { } else {
fmt.Fprintf(buffer, "Expected in leveldb:\n C%d)", tt.expFrozen-1) fmt.Fprintf(buffer, "Expected in leveldb:\n C%d)", tt.expFrozen-1)
for i := tt.expFrozen - 1; i < tt.expCanonicalBlocks; i++ { for i := tt.expFrozen - 1; i < tt.expCanonicalBlocks; i++ {
fmt.Fprintf(buffer, "->C%d", i+1) fmt.Fprintf(buffer, "->C%d", i+1)
} }
fmt.Fprint(buffer, "\n") fmt.Fprint(buffer, "\n")
if tt.expSidechainBlocks > tt.expFrozen { if tt.expSidechainBlocks > tt.expFrozen {
fmt.Fprintf(buffer, " └") fmt.Fprintf(buffer, " └")
for i := tt.expFrozen - 1; i < tt.expSidechainBlocks; i++ { for i := tt.expFrozen - 1; i < tt.expSidechainBlocks; i++ {
fmt.Fprintf(buffer, "->S%d", i+1) fmt.Fprintf(buffer, "->S%d", i+1)
} }
@ -138,32 +122,26 @@ func (tt *rewindTest) dump(crash bool) string {
} }
} else { } else {
fmt.Fprint(buffer, "Expected in leveldb:\n G") fmt.Fprint(buffer, "Expected in leveldb:\n G")
for i := tt.expFrozen; i < tt.expCanonicalBlocks; i++ { for i := tt.expFrozen; i < tt.expCanonicalBlocks; i++ {
fmt.Fprintf(buffer, "->C%d", i+1) fmt.Fprintf(buffer, "->C%d", i+1)
} }
fmt.Fprint(buffer, "\n") fmt.Fprint(buffer, "\n")
if tt.expSidechainBlocks > tt.expFrozen { if tt.expSidechainBlocks > tt.expFrozen {
fmt.Fprintf(buffer, " └") fmt.Fprintf(buffer, " └")
for i := tt.expFrozen; i < tt.expSidechainBlocks; i++ { for i := tt.expFrozen; i < tt.expSidechainBlocks; i++ {
fmt.Fprintf(buffer, "->S%d", i+1) fmt.Fprintf(buffer, "->S%d", i+1)
} }
fmt.Fprintf(buffer, "\n") fmt.Fprintf(buffer, "\n")
} }
} }
fmt.Fprintf(buffer, "\n") fmt.Fprintf(buffer, "\n")
fmt.Fprintf(buffer, "Expected head header : C%d\n", tt.expHeadHeader) fmt.Fprintf(buffer, "Expected head header : C%d\n", tt.expHeadHeader)
fmt.Fprintf(buffer, "Expected head fast block: C%d\n", tt.expHeadFastBlock) fmt.Fprintf(buffer, "Expected head fast block: C%d\n", tt.expHeadFastBlock)
if tt.expHeadBlock == 0 { if tt.expHeadBlock == 0 {
fmt.Fprintf(buffer, "Expected head block : G\n") fmt.Fprintf(buffer, "Expected head block : G\n")
} else { } else {
fmt.Fprintf(buffer, "Expected head block : C%d\n", tt.expHeadBlock) fmt.Fprintf(buffer, "Expected head block : C%d\n", tt.expHeadBlock)
} }
return buffer.String() return buffer.String()
} }
@ -1974,6 +1952,7 @@ func testSetHead(t *testing.T, tt *rewindTest, snapshots bool) {
// It's hard to follow the test case, visualize the input // It's hard to follow the test case, visualize the input
// log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true)))) // log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
// fmt.Println(tt.dump(false)) // fmt.Println(tt.dump(false))
// Create a temporary persistent database // Create a temporary persistent database
datadir := t.TempDir() datadir := t.TempDir()
@ -1988,80 +1967,68 @@ func testSetHead(t *testing.T, tt *rewindTest, snapshots bool) {
// Initialize a fresh chain // Initialize a fresh chain
var ( var (
gspec = &core.Genesis{ gspec = &Genesis{
BaseFee: big.NewInt(params.InitialBaseFee), BaseFee: big.NewInt(params.InitialBaseFee),
Config: params.AllEthashProtocolChanges, Config: params.AllEthashProtocolChanges,
} }
engine = ethash.NewFullFaker() engine = ethash.NewFullFaker()
config = &core.CacheConfig{ config = &CacheConfig{
TrieCleanLimit: 256, TrieCleanLimit: 256,
TrieDirtyLimit: 256, TrieDirtyLimit: 256,
TrieTimeLimit: 5 * time.Minute, TrieTimeLimit: 5 * time.Minute,
SnapshotLimit: 0, // Disable snapshot SnapshotLimit: 0, // Disable snapshot
} }
) )
if snapshots { if snapshots {
config.SnapshotLimit = 256 config.SnapshotLimit = 256
config.SnapshotWait = true config.SnapshotWait = true
} }
chain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil, nil)
chain, err := core.NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to create chain: %v", err) t.Fatalf("Failed to create chain: %v", err)
} }
defer chain.Stop() defer chain.Stop()
// If sidechain blocks are needed, make a light chain and import it // If sidechain blocks are needed, make a light chain and import it
var sideblocks types.Blocks var sideblocks types.Blocks
if tt.sidechainBlocks > 0 { if tt.sidechainBlocks > 0 {
sideblocks, _ = core.GenerateChain(gspec.Config, gspec.ToBlock(), engine, rawdb.NewMemoryDatabase(), tt.sidechainBlocks, func(i int, b *core.BlockGen) { sideblocks, _ = GenerateChain(gspec.Config, gspec.ToBlock(), engine, rawdb.NewMemoryDatabase(), tt.sidechainBlocks, func(i int, b *BlockGen) {
b.SetCoinbase(common.Address{0x01}) b.SetCoinbase(common.Address{0x01})
}) })
if _, err := chain.InsertChain(sideblocks); err != nil { if _, err := chain.InsertChain(sideblocks); err != nil {
t.Fatalf("Failed to import side chain: %v", err) t.Fatalf("Failed to import side chain: %v", err)
} }
} }
canonblocks, _ := GenerateChain(gspec.Config, gspec.ToBlock(), engine, rawdb.NewMemoryDatabase(), tt.canonicalBlocks, func(i int, b *BlockGen) {
canonblocks, _ := core.GenerateChain(gspec.Config, gspec.ToBlock(), engine, rawdb.NewMemoryDatabase(), tt.canonicalBlocks, func(i int, b *core.BlockGen) {
b.SetCoinbase(common.Address{0x02}) b.SetCoinbase(common.Address{0x02})
b.SetDifficulty(big.NewInt(1000000)) b.SetDifficulty(big.NewInt(1000000))
}) })
if _, err := chain.InsertChain(canonblocks[:tt.commitBlock]); err != nil { if _, err := chain.InsertChain(canonblocks[:tt.commitBlock]); err != nil {
t.Fatalf("Failed to import canonical chain start: %v", err) t.Fatalf("Failed to import canonical chain start: %v", err)
} }
if tt.commitBlock > 0 { if tt.commitBlock > 0 {
err = chain.StateCache().TrieDB().Commit(canonblocks[tt.commitBlock-1].Root(), true) chain.stateCache.TrieDB().Commit(canonblocks[tt.commitBlock-1].Root(), false)
if err != nil {
t.Fatal("on trieDB.Commit", err)
}
if snapshots { if snapshots {
if err := chain.Snaps().Cap(canonblocks[tt.commitBlock-1].Root(), 0); err != nil { if err := chain.snaps.Cap(canonblocks[tt.commitBlock-1].Root(), 0); err != nil {
t.Fatalf("Failed to flatten snapshots: %v", err) t.Fatalf("Failed to flatten snapshots: %v", err)
} }
} }
} }
if _, err := chain.InsertChain(canonblocks[tt.commitBlock:]); err != nil { if _, err := chain.InsertChain(canonblocks[tt.commitBlock:]); err != nil {
t.Fatalf("Failed to import canonical chain tail: %v", err) t.Fatalf("Failed to import canonical chain tail: %v", err)
} }
// Manually dereference anything not committed to not have to work with 128+ tries // Manually dereference anything not committed to not have to work with 128+ tries
for _, block := range sideblocks { for _, block := range sideblocks {
chain.StateCache().TrieDB().Dereference(block.Root()) chain.stateCache.TrieDB().Dereference(block.Root())
} }
for _, block := range canonblocks { for _, block := range canonblocks {
chain.StateCache().TrieDB().Dereference(block.Root()) chain.stateCache.TrieDB().Dereference(block.Root())
} }
// Force run a freeze cycle // Force run a freeze cycle
type freezer interface { type freezer interface {
Freeze(threshold uint64) error Freeze(threshold uint64) error
Ancients() (uint64, error) Ancients() (uint64, error)
} }
db.(freezer).Freeze(tt.freezeThreshold) db.(freezer).Freeze(tt.freezeThreshold)
// Set the simulated pivot block // Set the simulated pivot block
@ -2080,15 +2047,12 @@ func testSetHead(t *testing.T, tt *rewindTest, snapshots bool) {
if head := chain.CurrentHeader(); head.Number.Uint64() != tt.expHeadHeader { if head := chain.CurrentHeader(); head.Number.Uint64() != tt.expHeadHeader {
t.Errorf("Head header mismatch: have %d, want %d", head.Number, tt.expHeadHeader) t.Errorf("Head header mismatch: have %d, want %d", head.Number, tt.expHeadHeader)
} }
if head := chain.CurrentSnapBlock(); head.Number.Uint64() != tt.expHeadFastBlock { if head := chain.CurrentSnapBlock(); head.Number.Uint64() != tt.expHeadFastBlock {
t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, tt.expHeadFastBlock) t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, tt.expHeadFastBlock)
} }
if head := chain.CurrentBlock(); head.Number.Uint64() != tt.expHeadBlock { if head := chain.CurrentBlock(); head.Number.Uint64() != tt.expHeadBlock {
t.Errorf("Head block mismatch: have %d, want %d", head.Number, tt.expHeadBlock) t.Errorf("Head block mismatch: have %d, want %d", head.Number, tt.expHeadBlock)
} }
if frozen, err := db.(freezer).Ancients(); err != nil { if frozen, err := db.(freezer).Ancients(); err != nil {
t.Errorf("Failed to retrieve ancient count: %v\n", err) t.Errorf("Failed to retrieve ancient count: %v\n", err)
} else if int(frozen) != tt.expFrozen { } else if int(frozen) != tt.expFrozen {
@ -2098,64 +2062,51 @@ func testSetHead(t *testing.T, tt *rewindTest, snapshots bool) {
// verifyNoGaps checks that there are no gaps after the initial set of blocks in // verifyNoGaps checks that there are no gaps after the initial set of blocks in
// the database and errors if found. // the database and errors if found.
// func verifyNoGaps(t *testing.T, chain *BlockChain, canonical bool, inserted types.Blocks) {
//nolint:gocognit
func verifyNoGaps(t *testing.T, chain *core.BlockChain, canonical bool, inserted types.Blocks) {
t.Helper() t.Helper()
var end uint64 var end uint64
for i := uint64(0); i <= uint64(len(inserted)); i++ { for i := uint64(0); i <= uint64(len(inserted)); i++ {
header := chain.GetHeaderByNumber(i) header := chain.GetHeaderByNumber(i)
if header == nil && end == 0 { if header == nil && end == 0 {
end = i end = i
} }
if header != nil && end > 0 { if header != nil && end > 0 {
if canonical { if canonical {
t.Errorf("Canonical header gap between #%d-#%d", end, i-1) t.Errorf("Canonical header gap between #%d-#%d", end, i-1)
} else { } else {
t.Errorf("Sidechain header gap between #%d-#%d", end, i-1) t.Errorf("Sidechain header gap between #%d-#%d", end, i-1)
} }
end = 0 // Reset for further gap detection end = 0 // Reset for further gap detection
} }
} }
end = 0 end = 0
for i := uint64(0); i <= uint64(len(inserted)); i++ { for i := uint64(0); i <= uint64(len(inserted)); i++ {
block := chain.GetBlockByNumber(i) block := chain.GetBlockByNumber(i)
if block == nil && end == 0 { if block == nil && end == 0 {
end = i end = i
} }
if block != nil && end > 0 { if block != nil && end > 0 {
if canonical { if canonical {
t.Errorf("Canonical block gap between #%d-#%d", end, i-1) t.Errorf("Canonical block gap between #%d-#%d", end, i-1)
} else { } else {
t.Errorf("Sidechain block gap between #%d-#%d", end, i-1) t.Errorf("Sidechain block gap between #%d-#%d", end, i-1)
} }
end = 0 // Reset for further gap detection end = 0 // Reset for further gap detection
} }
} }
end = 0 end = 0
for i := uint64(1); i <= uint64(len(inserted)); i++ { for i := uint64(1); i <= uint64(len(inserted)); i++ {
receipts := chain.GetReceiptsByHash(inserted[i-1].Hash()) receipts := chain.GetReceiptsByHash(inserted[i-1].Hash())
if receipts == nil && end == 0 { if receipts == nil && end == 0 {
end = i end = i
} }
if receipts != nil && end > 0 { if receipts != nil && end > 0 {
if canonical { if canonical {
t.Errorf("Canonical receipt gap between #%d-#%d", end, i-1) t.Errorf("Canonical receipt gap between #%d-#%d", end, i-1)
} else { } else {
t.Errorf("Sidechain receipt gap between #%d-#%d", end, i-1) t.Errorf("Sidechain receipt gap between #%d-#%d", end, i-1)
} }
end = 0 // Reset for further gap detection end = 0 // Reset for further gap detection
} }
} }
@ -2163,9 +2114,7 @@ func verifyNoGaps(t *testing.T, chain *core.BlockChain, canonical bool, inserted
// verifyCutoff checks that there are no chain data available in the chain after // verifyCutoff checks that there are no chain data available in the chain after
// the specified limit, but that it is available before. // the specified limit, but that it is available before.
// func verifyCutoff(t *testing.T, chain *BlockChain, canonical bool, inserted types.Blocks, head int) {
//nolint:gocognit
func verifyCutoff(t *testing.T, chain *core.BlockChain, canonical bool, inserted types.Blocks, head int) {
t.Helper() t.Helper()
for i := 1; i <= len(inserted); i++ { for i := 1; i <= len(inserted); i++ {
@ -2177,7 +2126,6 @@ func verifyCutoff(t *testing.T, chain *core.BlockChain, canonical bool, inserted
t.Errorf("Sidechain header #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head) t.Errorf("Sidechain header #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} }
} }
if block := chain.GetBlock(inserted[i-1].Hash(), uint64(i)); block == nil { if block := chain.GetBlock(inserted[i-1].Hash(), uint64(i)); block == nil {
if canonical { if canonical {
t.Errorf("Canonical block #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head) t.Errorf("Canonical block #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
@ -2185,7 +2133,6 @@ func verifyCutoff(t *testing.T, chain *core.BlockChain, canonical bool, inserted
t.Errorf("Sidechain block #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head) t.Errorf("Sidechain block #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} }
} }
if receipts := chain.GetReceiptsByHash(inserted[i-1].Hash()); receipts == nil { if receipts := chain.GetReceiptsByHash(inserted[i-1].Hash()); receipts == nil {
if canonical { if canonical {
t.Errorf("Canonical receipts #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head) t.Errorf("Canonical receipts #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
@ -2201,7 +2148,6 @@ func verifyCutoff(t *testing.T, chain *core.BlockChain, canonical bool, inserted
t.Errorf("Sidechain header #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head) t.Errorf("Sidechain header #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} }
} }
if block := chain.GetBlock(inserted[i-1].Hash(), uint64(i)); block != nil { if block := chain.GetBlock(inserted[i-1].Hash(), uint64(i)); block != nil {
if canonical { if canonical {
t.Errorf("Canonical block #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head) t.Errorf("Canonical block #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
@ -2209,7 +2155,6 @@ func verifyCutoff(t *testing.T, chain *core.BlockChain, canonical bool, inserted
t.Errorf("Sidechain block #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head) t.Errorf("Sidechain block #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
} }
} }
if receipts := chain.GetReceiptsByHash(inserted[i-1].Hash()); receipts != nil { if receipts := chain.GetReceiptsByHash(inserted[i-1].Hash()); receipts != nil {
if canonical { if canonical {
t.Errorf("Canonical receipts #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head) t.Errorf("Canonical receipts #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)

102
core/tests/blockchain_snapshot_test.go → core/blockchain_snapshot_test.go
View file

@ -17,7 +17,7 @@
// Tests that abnormal program termination (i.e.crash) and restart can recovery // Tests that abnormal program termination (i.e.crash) and restart can recovery
// the snapshot properly if the snapshot is enabled. // the snapshot properly if the snapshot is enabled.
package tests package core
import ( import (
"bytes" "bytes"
@ -30,7 +30,6 @@ import (
"github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/consensus/ethash"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/core/vm"
@ -55,12 +54,10 @@ type snapshotTestBasic struct {
db ethdb.Database db ethdb.Database
genDb ethdb.Database genDb ethdb.Database
engine consensus.Engine engine consensus.Engine
gspec *core.Genesis gspec *Genesis
} }
func (basic *snapshotTestBasic) prepare(t *testing.T) (*core.BlockChain, []*types.Block) { func (basic *snapshotTestBasic) prepare(t *testing.T) (*BlockChain, []*types.Block) {
t.Helper()
// Create a temporary persistent database // Create a temporary persistent database
datadir := t.TempDir() datadir := t.TempDir()
@ -73,7 +70,7 @@ func (basic *snapshotTestBasic) prepare(t *testing.T) (*core.BlockChain, []*type
} }
// Initialize a fresh chain // Initialize a fresh chain
var ( var (
gspec = &core.Genesis{ gspec = &Genesis{
BaseFee: big.NewInt(params.InitialBaseFee), BaseFee: big.NewInt(params.InitialBaseFee),
Config: params.AllEthashProtocolChanges, Config: params.AllEthashProtocolChanges,
} }
@ -82,15 +79,13 @@ func (basic *snapshotTestBasic) prepare(t *testing.T) (*core.BlockChain, []*type
// Snapshot is enabled, the first snapshot is created from the Genesis. // Snapshot is enabled, the first snapshot is created from the Genesis.
// The snapshot memory allowance is 256MB, it means no snapshot flush // The snapshot memory allowance is 256MB, it means no snapshot flush
// will happen during the block insertion. // will happen during the block insertion.
cacheConfig = core.DefaultCacheConfig cacheConfig = defaultCacheConfig
) )
chain, err := NewBlockChain(db, cacheConfig, gspec, nil, engine, vm.Config{}, nil, nil, nil)
chain, err := core.NewBlockChain(db, cacheConfig, gspec, nil, engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to create chain: %v", err) t.Fatalf("Failed to create chain: %v", err)
} }
genDb, blocks, _ := GenerateChainWithGenesis(gspec, engine, basic.chainBlocks, func(i int, b *BlockGen) {})
genDb, blocks, _ := core.GenerateChainWithGenesis(gspec, engine, basic.chainBlocks, func(i int, b *core.BlockGen) {})
// Insert the blocks with configured settings. // Insert the blocks with configured settings.
var breakpoints []uint64 var breakpoints []uint64
@ -99,38 +94,27 @@ func (basic *snapshotTestBasic) prepare(t *testing.T) (*core.BlockChain, []*type
} else { } else {
breakpoints = append(breakpoints, basic.commitBlock, basic.snapshotBlock) breakpoints = append(breakpoints, basic.commitBlock, basic.snapshotBlock)
} }
var startPoint uint64 var startPoint uint64
for _, point := range breakpoints { for _, point := range breakpoints {
if _, err := chain.InsertChain(blocks[startPoint:point]); err != nil { if _, err := chain.InsertChain(blocks[startPoint:point]); err != nil {
t.Fatalf("Failed to import canonical chain start: %v", err) t.Fatalf("Failed to import canonical chain start: %v", err)
} }
startPoint = point startPoint = point
if basic.commitBlock > 0 && basic.commitBlock == point { if basic.commitBlock > 0 && basic.commitBlock == point {
err = chain.StateCache().TrieDB().Commit(blocks[point-1].Root(), true) chain.stateCache.TrieDB().Commit(blocks[point-1].Root(), false)
if err != nil {
t.Fatal("on trieDB.Commit", err)
} }
}
if basic.snapshotBlock > 0 && basic.snapshotBlock == point { if basic.snapshotBlock > 0 && basic.snapshotBlock == point {
// Flushing the entire snap tree into the disk, the // Flushing the entire snap tree into the disk, the
// relevant (a) snapshot root and (b) snapshot generator // relevant (a) snapshot root and (b) snapshot generator
// will be persisted atomically. // will be persisted atomically.
err = chain.Snaps().Cap(blocks[point-1].Root(), 0) chain.snaps.Cap(blocks[point-1].Root(), 0)
if err != nil { diskRoot, blockRoot := chain.snaps.DiskRoot(), blocks[point-1].Root()
t.Fatal("on Snaps.Cap", err)
}
diskRoot, blockRoot := chain.Snaps().DiskRoot(), blocks[point-1].Root()
if !bytes.Equal(diskRoot.Bytes(), blockRoot.Bytes()) { if !bytes.Equal(diskRoot.Bytes(), blockRoot.Bytes()) {
t.Fatalf("Failed to flush disk layer change, want %x, got %x", blockRoot, diskRoot) t.Fatalf("Failed to flush disk layer change, want %x, got %x", blockRoot, diskRoot)
} }
} }
} }
if _, err := chain.InsertChain(blocks[startPoint:]); err != nil { if _, err := chain.InsertChain(blocks[startPoint:]); err != nil {
t.Fatalf("Failed to import canonical chain tail: %v", err) t.Fatalf("Failed to import canonical chain tail: %v", err)
} }
@ -141,13 +125,10 @@ func (basic *snapshotTestBasic) prepare(t *testing.T) (*core.BlockChain, []*type
basic.genDb = genDb basic.genDb = genDb
basic.engine = engine basic.engine = engine
basic.gspec = gspec basic.gspec = gspec
return chain, blocks return chain, blocks
} }
func (basic *snapshotTestBasic) verify(t *testing.T, chain *core.BlockChain, blocks []*types.Block) { func (basic *snapshotTestBasic) verify(t *testing.T, chain *BlockChain, blocks []*types.Block) {
t.Helper()
// Iterate over all the remaining blocks and ensure there are no gaps // Iterate over all the remaining blocks and ensure there are no gaps
verifyNoGaps(t, chain, true, blocks) verifyNoGaps(t, chain, true, blocks)
verifyCutoff(t, chain, true, blocks, basic.expCanonicalBlocks) verifyCutoff(t, chain, true, blocks, basic.expCanonicalBlocks)
@ -155,11 +136,9 @@ func (basic *snapshotTestBasic) verify(t *testing.T, chain *core.BlockChain, blo
if head := chain.CurrentHeader(); head.Number.Uint64() != basic.expHeadHeader { if head := chain.CurrentHeader(); head.Number.Uint64() != basic.expHeadHeader {
t.Errorf("Head header mismatch: have %d, want %d", head.Number, basic.expHeadHeader) t.Errorf("Head header mismatch: have %d, want %d", head.Number, basic.expHeadHeader)
} }
if head := chain.CurrentSnapBlock(); head.Number.Uint64() != basic.expHeadFastBlock { if head := chain.CurrentSnapBlock(); head.Number.Uint64() != basic.expHeadFastBlock {
t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, basic.expHeadFastBlock) t.Errorf("Head fast block mismatch: have %d, want %d", head.Number, basic.expHeadFastBlock)
} }
if head := chain.CurrentBlock(); head.Number.Uint64() != basic.expHeadBlock { if head := chain.CurrentBlock(); head.Number.Uint64() != basic.expHeadBlock {
t.Errorf("Head block mismatch: have %d, want %d", head.Number, basic.expHeadBlock) t.Errorf("Head block mismatch: have %d, want %d", head.Number, basic.expHeadBlock)
} }
@ -168,12 +147,12 @@ func (basic *snapshotTestBasic) verify(t *testing.T, chain *core.BlockChain, blo
block := chain.GetBlockByNumber(basic.expSnapshotBottom) block := chain.GetBlockByNumber(basic.expSnapshotBottom)
if block == nil { if block == nil {
t.Errorf("The corresponding block[%d] of snapshot disk layer is missing", basic.expSnapshotBottom) t.Errorf("The corresponding block[%d] of snapshot disk layer is missing", basic.expSnapshotBottom)
} else if !bytes.Equal(chain.Snaps().DiskRoot().Bytes(), block.Root().Bytes()) { } else if !bytes.Equal(chain.snaps.DiskRoot().Bytes(), block.Root().Bytes()) {
t.Errorf("The snapshot disk layer root is incorrect, want %x, get %x", block.Root(), chain.Snaps().DiskRoot()) t.Errorf("The snapshot disk layer root is incorrect, want %x, get %x", block.Root(), chain.snaps.DiskRoot())
} }
// Check the snapshot, ensure it's integrated // Check the snapshot, ensure it's integrated
if err := chain.Snaps().Verify(block.Root()); err != nil { if err := chain.snaps.Verify(block.Root()); err != nil {
t.Errorf("The disk layer is not integrated %v", err) t.Errorf("The disk layer is not integrated %v", err)
} }
} }
@ -183,26 +162,21 @@ func (basic *snapshotTestBasic) dump() string {
buffer := new(strings.Builder) buffer := new(strings.Builder)
fmt.Fprint(buffer, "Chain:\n G") fmt.Fprint(buffer, "Chain:\n G")
for i := 0; i < basic.chainBlocks; i++ { for i := 0; i < basic.chainBlocks; i++ {
fmt.Fprintf(buffer, "->C%d", i+1) fmt.Fprintf(buffer, "->C%d", i+1)
} }
fmt.Fprint(buffer, " (HEAD)\n\n") fmt.Fprint(buffer, " (HEAD)\n\n")
fmt.Fprintf(buffer, "Commit: G") fmt.Fprintf(buffer, "Commit: G")
if basic.commitBlock > 0 { if basic.commitBlock > 0 {
fmt.Fprintf(buffer, ", C%d", basic.commitBlock) fmt.Fprintf(buffer, ", C%d", basic.commitBlock)
} }
fmt.Fprint(buffer, "\n") fmt.Fprint(buffer, "\n")
fmt.Fprintf(buffer, "Snapshot: G") fmt.Fprintf(buffer, "Snapshot: G")
if basic.snapshotBlock > 0 { if basic.snapshotBlock > 0 {
fmt.Fprintf(buffer, ", C%d", basic.snapshotBlock) fmt.Fprintf(buffer, ", C%d", basic.snapshotBlock)
} }
fmt.Fprint(buffer, "\n") fmt.Fprint(buffer, "\n")
//if crash { //if crash {
@ -213,26 +187,22 @@ func (basic *snapshotTestBasic) dump() string {
fmt.Fprintf(buffer, "------------------------------\n\n") fmt.Fprintf(buffer, "------------------------------\n\n")
fmt.Fprint(buffer, "Expected in leveldb:\n G") fmt.Fprint(buffer, "Expected in leveldb:\n G")
for i := 0; i < basic.expCanonicalBlocks; i++ { for i := 0; i < basic.expCanonicalBlocks; i++ {
fmt.Fprintf(buffer, "->C%d", i+1) fmt.Fprintf(buffer, "->C%d", i+1)
} }
fmt.Fprintf(buffer, "\n\n") fmt.Fprintf(buffer, "\n\n")
fmt.Fprintf(buffer, "Expected head header : C%d\n", basic.expHeadHeader) fmt.Fprintf(buffer, "Expected head header : C%d\n", basic.expHeadHeader)
fmt.Fprintf(buffer, "Expected head fast block: C%d\n", basic.expHeadFastBlock) fmt.Fprintf(buffer, "Expected head fast block: C%d\n", basic.expHeadFastBlock)
if basic.expHeadBlock == 0 { if basic.expHeadBlock == 0 {
fmt.Fprintf(buffer, "Expected head block : G\n") fmt.Fprintf(buffer, "Expected head block : G\n")
} else { } else {
fmt.Fprintf(buffer, "Expected head block : C%d\n", basic.expHeadBlock) fmt.Fprintf(buffer, "Expected head block : C%d\n", basic.expHeadBlock)
} }
if basic.expSnapshotBottom == 0 { if basic.expSnapshotBottom == 0 {
fmt.Fprintf(buffer, "Expected snapshot disk : G\n") fmt.Fprintf(buffer, "Expected snapshot disk : G\n")
} else { } else {
fmt.Fprintf(buffer, "Expected snapshot disk : C%d\n", basic.expSnapshotBottom) fmt.Fprintf(buffer, "Expected snapshot disk : C%d\n", basic.expSnapshotBottom)
} }
return buffer.String() return buffer.String()
} }
@ -256,8 +226,7 @@ func (snaptest *snapshotTest) test(t *testing.T) {
// Restart the chain normally // Restart the chain normally
chain.Stop() chain.Stop()
newchain, err := NewBlockChain(snaptest.db, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
newchain, err := core.NewBlockChain(snaptest.db, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
@ -279,8 +248,9 @@ func (snaptest *crashSnapshotTest) test(t *testing.T) {
chain, blocks := snaptest.prepare(t) chain, blocks := snaptest.prepare(t)
// Pull the plug on the database, simulating a hard crash // Pull the plug on the database, simulating a hard crash
db := chain.DB() db := chain.db
db.Close() db.Close()
chain.stopWithoutSaving()
// Start a new blockchain back up and see where the repair leads us // Start a new blockchain back up and see where the repair leads us
newdb, err := rawdb.Open(rawdb.OpenOptions{ newdb, err := rawdb.Open(rawdb.OpenOptions{
@ -291,21 +261,19 @@ func (snaptest *crashSnapshotTest) test(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("Failed to reopen persistent database: %v", err) t.Fatalf("Failed to reopen persistent database: %v", err)
} }
defer newdb.Close() defer newdb.Close()
// The interesting thing is: instead of starting the blockchain after // The interesting thing is: instead of starting the blockchain after
// the crash, we do restart twice here: one after the crash and one // the crash, we do restart twice here: one after the crash and one
// after the normal stop. It's used to ensure the broken snapshot // after the normal stop. It's used to ensure the broken snapshot
// can be detected all the time. // can be detected all the time.
newchain, err := core.NewBlockChain(newdb, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil) newchain, err := NewBlockChain(newdb, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
newchain.Stop() newchain.Stop()
newchain, err = core.NewBlockChain(newdb, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil) newchain, err = NewBlockChain(newdb, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
@ -332,27 +300,24 @@ func (snaptest *gappedSnapshotTest) test(t *testing.T) {
// Insert blocks without enabling snapshot if gapping is required. // Insert blocks without enabling snapshot if gapping is required.
chain.Stop() chain.Stop()
gappedBlocks, _ := GenerateChain(params.TestChainConfig, blocks[len(blocks)-1], snaptest.engine, snaptest.genDb, snaptest.gapped, func(i int, b *BlockGen) {})
gappedBlocks, _ := core.GenerateChain(params.TestChainConfig, blocks[len(blocks)-1], snaptest.engine, snaptest.genDb, snaptest.gapped, func(i int, b *core.BlockGen) {})
// Insert a few more blocks without enabling snapshot // Insert a few more blocks without enabling snapshot
var cacheConfig = &core.CacheConfig{ var cacheConfig = &CacheConfig{
TrieCleanLimit: 256, TrieCleanLimit: 256,
TrieDirtyLimit: 256, TrieDirtyLimit: 256,
TrieTimeLimit: 5 * time.Minute, TrieTimeLimit: 5 * time.Minute,
SnapshotLimit: 0, SnapshotLimit: 0,
} }
newchain, err := NewBlockChain(snaptest.db, cacheConfig, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
newchain, err := core.NewBlockChain(snaptest.db, cacheConfig, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
newchain.InsertChain(gappedBlocks) newchain.InsertChain(gappedBlocks)
newchain.Stop() newchain.Stop()
// Restart the chain with enabling the snapshot // Restart the chain with enabling the snapshot
newchain, err = core.NewBlockChain(snaptest.db, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil) newchain, err = NewBlockChain(snaptest.db, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
@ -380,7 +345,7 @@ func (snaptest *setHeadSnapshotTest) test(t *testing.T) {
chain.SetHead(snaptest.setHead) chain.SetHead(snaptest.setHead)
chain.Stop() chain.Stop()
newchain, err := core.NewBlockChain(snaptest.db, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil) newchain, err := NewBlockChain(snaptest.db, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
@ -409,41 +374,40 @@ func (snaptest *wipeCrashSnapshotTest) test(t *testing.T) {
// and state committed. // and state committed.
chain.Stop() chain.Stop()
config := &core.CacheConfig{ config := &CacheConfig{
TrieCleanLimit: 256, TrieCleanLimit: 256,
TrieDirtyLimit: 256, TrieDirtyLimit: 256,
TrieTimeLimit: 5 * time.Minute, TrieTimeLimit: 5 * time.Minute,
SnapshotLimit: 0, SnapshotLimit: 0,
} }
newchain, err := NewBlockChain(snaptest.db, config, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
newchain, err := core.NewBlockChain(snaptest.db, config, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
newBlocks, _ := GenerateChain(params.TestChainConfig, blocks[len(blocks)-1], snaptest.engine, snaptest.genDb, snaptest.newBlocks, func(i int, b *BlockGen) {})
newBlocks, _ := core.GenerateChain(params.TestChainConfig, blocks[len(blocks)-1], snaptest.engine, snaptest.genDb, snaptest.newBlocks, func(i int, b *core.BlockGen) {})
newchain.InsertChain(newBlocks) newchain.InsertChain(newBlocks)
newchain.Stop() newchain.Stop()
// Restart the chain, the wiper should starts working // Restart the chain, the wiper should starts working
config = &core.CacheConfig{ config = &CacheConfig{
TrieCleanLimit: 256, TrieCleanLimit: 256,
TrieDirtyLimit: 256, TrieDirtyLimit: 256,
TrieTimeLimit: 5 * time.Minute, TrieTimeLimit: 5 * time.Minute,
SnapshotLimit: 256, SnapshotLimit: 256,
SnapshotWait: false, // Don't wait rebuild SnapshotWait: false, // Don't wait rebuild
} }
tmp, err := NewBlockChain(snaptest.db, config, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
_, err = core.NewBlockChain(snaptest.db, config, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
newchain, err = core.NewBlockChain(snaptest.db, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil) // Simulate the blockchain crash.
tmp.stopWithoutSaving()
newchain, err = NewBlockChain(snaptest.db, nil, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
t.Fatalf("Failed to recreate chain: %v", err) t.Fatalf("Failed to recreate chain: %v", err)
} }
defer newchain.Stop() defer newchain.Stop()
snaptest.verify(t, newchain, blocks) snaptest.verify(t, newchain, blocks)
} }

18
core/blockchain_test.go
View file

@ -980,7 +980,7 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
archiveDb := makeDb() archiveDb := makeDb()
defer archiveDb.Close() defer archiveDb.Close()
archiveCaching := *DefaultCacheConfig archiveCaching := *defaultCacheConfig
archiveCaching.TrieDirtyDisabled = true archiveCaching.TrieDirtyDisabled = true
archive, _ := NewBlockChain(archiveDb, &archiveCaching, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil, nil) archive, _ := NewBlockChain(archiveDb, &archiveCaching, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil, nil)
@ -1817,7 +1817,7 @@ func TestTrieForkGC(t *testing.T) {
Config: params.TestChainConfig, Config: params.TestChainConfig,
BaseFee: big.NewInt(params.InitialBaseFee), BaseFee: big.NewInt(params.InitialBaseFee),
} }
genDb, blocks, _ := GenerateChainWithGenesis(genesis, engine, 2*int(DefaultCacheConfig.TriesInMemory), func(i int, b *BlockGen) { b.SetCoinbase(common.Address{1}) }) genDb, blocks, _ := GenerateChainWithGenesis(genesis, engine, 2*int(defaultCacheConfig.TriesInMemory), func(i int, b *BlockGen) { b.SetCoinbase(common.Address{1}) })
// Generate a bunch of fork blocks, each side forking from the canonical chain // Generate a bunch of fork blocks, each side forking from the canonical chain
forks := make([]*types.Block, len(blocks)) forks := make([]*types.Block, len(blocks))
@ -1867,8 +1867,8 @@ func TestLargeReorgTrieGC(t *testing.T) {
BaseFee: big.NewInt(params.InitialBaseFee), BaseFee: big.NewInt(params.InitialBaseFee),
} }
genDb, shared, _ := GenerateChainWithGenesis(genesis, engine, 64, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{1}) }) genDb, shared, _ := GenerateChainWithGenesis(genesis, engine, 64, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{1}) })
original, _ := GenerateChain(genesis.Config, shared[len(shared)-1], engine, genDb, 2*int(DefaultCacheConfig.TriesInMemory), func(i int, b *BlockGen) { b.SetCoinbase(common.Address{2}) }) original, _ := GenerateChain(genesis.Config, shared[len(shared)-1], engine, genDb, 2*int(defaultCacheConfig.TriesInMemory), func(i int, b *BlockGen) { b.SetCoinbase(common.Address{2}) })
competitor, _ := GenerateChain(genesis.Config, shared[len(shared)-1], engine, genDb, 2*int(DefaultCacheConfig.TriesInMemory)+1, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{3}) }) competitor, _ := GenerateChain(genesis.Config, shared[len(shared)-1], engine, genDb, 2*int(defaultCacheConfig.TriesInMemory)+1, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{3}) })
// Import the shared chain and the original canonical one // Import the shared chain and the original canonical one
chain, err := NewBlockChain(rawdb.NewMemoryDatabase(), nil, genesis, nil, engine, vm.Config{}, nil, nil, nil) chain, err := NewBlockChain(rawdb.NewMemoryDatabase(), nil, genesis, nil, engine, vm.Config{}, nil, nil, nil)
@ -3106,7 +3106,7 @@ func TestSideImportPrunedBlocks(t *testing.T) {
BaseFee: big.NewInt(params.InitialBaseFee), BaseFee: big.NewInt(params.InitialBaseFee),
} }
// Generate and import the canonical chain // Generate and import the canonical chain
_, blocks, _ := GenerateChainWithGenesis(genesis, engine, 2*int(DefaultCacheConfig.TriesInMemory), nil) _, blocks, _ := GenerateChainWithGenesis(genesis, engine, 2*int(defaultCacheConfig.TriesInMemory), nil)
chain, err := NewBlockChain(rawdb.NewMemoryDatabase(), nil, genesis, nil, engine, vm.Config{}, nil, nil, nil) chain, err := NewBlockChain(rawdb.NewMemoryDatabase(), nil, genesis, nil, engine, vm.Config{}, nil, nil, nil)
if err != nil { if err != nil {
@ -4000,7 +4000,7 @@ func TestSetCanonical(t *testing.T) {
//log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StreamHandler(os.Stderr, log.TerminalFormat(true)))) //log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
// Generate and import the canonical chain // Generate and import the canonical chain
_, canon, _ := GenerateChainWithGenesis(gspec, engine, 2*int(DefaultCacheConfig.TriesInMemory), func(i int, gen *BlockGen) { _, canon, _ := GenerateChainWithGenesis(gspec, engine, 2*int(defaultCacheConfig.TriesInMemory), func(i int, gen *BlockGen) {
tx, err := types.SignTx(types.NewTransaction(gen.TxNonce(address), common.Address{0x00}, big.NewInt(1000), params.TxGas, gen.header.BaseFee, nil), signer, key) tx, err := types.SignTx(types.NewTransaction(gen.TxNonce(address), common.Address{0x00}, big.NewInt(1000), params.TxGas, gen.header.BaseFee, nil), signer, key)
if err != nil { if err != nil {
panic(err) panic(err)
@ -4021,7 +4021,7 @@ func TestSetCanonical(t *testing.T) {
} }
// Generate the side chain and import them // Generate the side chain and import them
_, side, _ := GenerateChainWithGenesis(gspec, engine, 2*int(DefaultCacheConfig.TriesInMemory), func(i int, gen *BlockGen) { _, side, _ := GenerateChainWithGenesis(gspec, engine, 2*int(defaultCacheConfig.TriesInMemory), func(i int, gen *BlockGen) {
tx, err := types.SignTx(types.NewTransaction(gen.TxNonce(address), common.Address{0x00}, big.NewInt(1), params.TxGas, gen.header.BaseFee, nil), signer, key) tx, err := types.SignTx(types.NewTransaction(gen.TxNonce(address), common.Address{0x00}, big.NewInt(1), params.TxGas, gen.header.BaseFee, nil), signer, key)
if err != nil { if err != nil {
panic(err) panic(err)
@ -4067,8 +4067,8 @@ func TestSetCanonical(t *testing.T) {
verify(side[len(side)-1]) verify(side[len(side)-1])
// Reset the chain head to original chain // Reset the chain head to original chain
_, _ = chain.SetCanonical(canon[int(DefaultCacheConfig.TriesInMemory)-1]) _, _ = chain.SetCanonical(canon[int(defaultCacheConfig.TriesInMemory)-1])
verify(canon[int(DefaultCacheConfig.TriesInMemory)-1]) verify(canon[int(defaultCacheConfig.TriesInMemory)-1])
} }
// TestCanonicalHashMarker tests all the canonical hash markers are updated/deleted // TestCanonicalHashMarker tests all the canonical hash markers are updated/deleted

4
core/rawdb/milestone.go
View file

@ -7,7 +7,7 @@ import (
json "github.com/json-iterator/go" json "github.com/json-iterator/go"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/gererics" "github.com/ethereum/go-ethereum/common/generics"
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
) )
@ -104,7 +104,7 @@ type BlockFinality[T any] interface {
} }
func getKey[T BlockFinality[T]]() (T, []byte) { func getKey[T BlockFinality[T]]() (T, []byte) {
lastT := gererics.Empty[T]().clone() lastT := generics.Empty[T]().clone()
var key []byte var key []byte

109
core/state_processor_test.go
View file

@ -47,11 +47,6 @@ func u64(val uint64) *uint64 { return &val }
// contain invalid transactions // contain invalid transactions
func TestStateProcessorErrors(t *testing.T) { func TestStateProcessorErrors(t *testing.T) {
var ( var (
cacheConfig = &CacheConfig{
TrieCleanLimit: 154,
Preimages: true,
}
config = &params.ChainConfig{ config = &params.ChainConfig{
ChainID: big.NewInt(1), ChainID: big.NewInt(1),
HomesteadBlock: big.NewInt(0), HomesteadBlock: big.NewInt(0),
@ -66,22 +61,20 @@ func TestStateProcessorErrors(t *testing.T) {
BerlinBlock: big.NewInt(0), BerlinBlock: big.NewInt(0),
LondonBlock: big.NewInt(0), LondonBlock: big.NewInt(0),
Ethash: new(params.EthashConfig), Ethash: new(params.EthashConfig),
Bor: &params.BorConfig{BurntContract: map[string]string{"0": "0x000000000000000000000000000000000000dead"}},
TerminalTotalDifficulty: big.NewInt(0), TerminalTotalDifficulty: big.NewInt(0),
TerminalTotalDifficultyPassed: true, TerminalTotalDifficultyPassed: true,
ShanghaiTime: new(uint64), ShanghaiTime: new(uint64),
CancunTime: new(uint64), CancunTime: new(uint64),
Bor: &params.BorConfig{BurntContract: map[string]string{"0": "0x000000000000000000000000000000000000dead"}},
} }
signer = types.LatestSigner(config) signer = types.LatestSigner(config)
key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
key2, _ = crypto.HexToECDSA("0202020202020202020202020202020202020202020202020202002020202020") key2, _ = crypto.HexToECDSA("0202020202020202020202020202020202020202020202020202002020202020")
) )
var makeTx = func(key *ecdsa.PrivateKey, nonce uint64, to common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *types.Transaction { var makeTx = func(key *ecdsa.PrivateKey, nonce uint64, to common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *types.Transaction {
tx, _ := types.SignTx(types.NewTransaction(nonce, to, amount, gasLimit, gasPrice, data), signer, key) tx, _ := types.SignTx(types.NewTransaction(nonce, to, amount, gasLimit, gasPrice, data), signer, key)
return tx return tx
} }
var mkDynamicTx = func(nonce uint64, to common.Address, gasLimit uint64, gasTipCap, gasFeeCap *big.Int) *types.Transaction { var mkDynamicTx = func(nonce uint64, to common.Address, gasLimit uint64, gasTipCap, gasFeeCap *big.Int) *types.Transaction {
tx, _ := types.SignTx(types.NewTx(&types.DynamicFeeTx{ tx, _ := types.SignTx(types.NewTx(&types.DynamicFeeTx{
Nonce: nonce, Nonce: nonce,
@ -93,7 +86,6 @@ func TestStateProcessorErrors(t *testing.T) {
}), signer, key1) }), signer, key1)
return tx return tx
} }
var mkDynamicCreationTx = func(nonce uint64, gasLimit uint64, gasTipCap, gasFeeCap *big.Int, data []byte) *types.Transaction { var mkDynamicCreationTx = func(nonce uint64, gasLimit uint64, gasTipCap, gasFeeCap *big.Int, data []byte) *types.Transaction {
tx, _ := types.SignTx(types.NewTx(&types.DynamicFeeTx{ tx, _ := types.SignTx(types.NewTx(&types.DynamicFeeTx{
Nonce: nonce, Nonce: nonce,
@ -142,11 +134,9 @@ func TestStateProcessorErrors(t *testing.T) {
) )
defer blockchain.Stop() defer blockchain.Stop()
bigNumber := new(big.Int).SetBytes(common.FromHex("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) bigNumber := new(big.Int).SetBytes(common.FromHex("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"))
tooBigNumber := new(big.Int).Set(bigNumber) tooBigNumber := new(big.Int).Set(bigNumber)
tooBigNumber.Add(tooBigNumber, common.Big1) tooBigNumber.Add(tooBigNumber, common.Big1)
for i, tt := range []struct { for i, tt := range []struct {
txs []*types.Transaction txs []*types.Transaction
want string want string
@ -269,7 +259,6 @@ func TestStateProcessorErrors(t *testing.T) {
if err == nil { if err == nil {
t.Fatal("block imported without errors") t.Fatal("block imported without errors")
} }
if have, want := err.Error(), tt.want; have != want { if have, want := err.Error(), tt.want; have != want {
t.Errorf("test %d:\nhave \"%v\"\nwant \"%v\"\n", i, have, want) t.Errorf("test %d:\nhave \"%v\"\nwant \"%v\"\n", i, have, want)
} }
@ -301,13 +290,8 @@ func TestStateProcessorErrors(t *testing.T) {
}, },
} }
blockchain, _ = NewBlockChain(db, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil, nil) blockchain, _ = NewBlockChain(db, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil, nil)
parallelBlockchain, _ = NewParallelBlockChain(db, cacheConfig, gspec, nil, ethash.NewFaker(), vm.Config{ParallelEnable: true, ParallelSpeculativeProcesses: 8}, nil, nil, nil)
) )
defer blockchain.Stop() defer blockchain.Stop()
defer parallelBlockchain.Stop()
for _, bc := range []*BlockChain{blockchain, parallelBlockchain} {
for i, tt := range []struct { for i, tt := range []struct {
txs []*types.Transaction txs []*types.Transaction
want string want string
@ -320,18 +304,15 @@ func TestStateProcessorErrors(t *testing.T) {
}, },
} { } {
block := GenerateBadBlock(gspec.ToBlock(), ethash.NewFaker(), tt.txs, gspec.Config) block := GenerateBadBlock(gspec.ToBlock(), ethash.NewFaker(), tt.txs, gspec.Config)
_, err := blockchain.InsertChain(types.Blocks{block})
_, err := bc.InsertChain(types.Blocks{block})
if err == nil { if err == nil {
t.Fatal("block imported without errors") t.Fatal("block imported without errors")
} }
if have, want := err.Error(), tt.want; have != want { if have, want := err.Error(), tt.want; have != want {
t.Errorf("test %d:\nhave \"%v\"\nwant \"%v\"\n", i, have, want) t.Errorf("test %d:\nhave \"%v\"\nwant \"%v\"\n", i, have, want)
} }
} }
} }
}
// ErrSenderNoEOA, for this we need the sender to have contract code // ErrSenderNoEOA, for this we need the sender to have contract code
{ {
@ -347,14 +328,9 @@ func TestStateProcessorErrors(t *testing.T) {
}, },
}, },
} }
parallelBlockchain, _ = NewParallelBlockChain(db, cacheConfig, gspec, nil, ethash.NewFaker(), vm.Config{ParallelEnable: true, ParallelSpeculativeProcesses: 8}, nil, nil, nil)
blockchain, _ = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil, nil) blockchain, _ = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil, nil)
) )
defer blockchain.Stop() defer blockchain.Stop()
defer parallelBlockchain.Stop()
for _, bc := range []*BlockChain{blockchain, parallelBlockchain} {
for i, tt := range []struct { for i, tt := range []struct {
txs []*types.Transaction txs []*types.Transaction
want string want string
@ -367,94 +343,15 @@ func TestStateProcessorErrors(t *testing.T) {
}, },
} { } {
block := GenerateBadBlock(gspec.ToBlock(), beacon.New(ethash.NewFaker()), tt.txs, gspec.Config) block := GenerateBadBlock(gspec.ToBlock(), beacon.New(ethash.NewFaker()), tt.txs, gspec.Config)
_, err := blockchain.InsertChain(types.Blocks{block})
_, err := bc.InsertChain(types.Blocks{block})
if err == nil { if err == nil {
t.Fatal("block imported without errors") t.Fatal("block imported without errors")
} }
if have, want := err.Error(), tt.want; have != want { if have, want := err.Error(), tt.want; have != want {
t.Errorf("test %d:\nhave \"%v\"\nwant \"%v\"\n", i, have, want) t.Errorf("test %d:\nhave \"%v\"\nwant \"%v\"\n", i, have, want)
} }
} }
} }
}
// ErrMaxInitCodeSizeExceeded, for this we need extra Shanghai (EIP-3860) enabled.
{
var (
db = rawdb.NewMemoryDatabase()
gspec = &Genesis{
Config: &params.ChainConfig{
ChainID: big.NewInt(1),
HomesteadBlock: big.NewInt(0),
EIP150Block: big.NewInt(0),
EIP155Block: big.NewInt(0),
EIP158Block: big.NewInt(0),
ByzantiumBlock: big.NewInt(0),
ConstantinopleBlock: big.NewInt(0),
PetersburgBlock: big.NewInt(0),
IstanbulBlock: big.NewInt(0),
MuirGlacierBlock: big.NewInt(0),
BerlinBlock: big.NewInt(0),
LondonBlock: big.NewInt(0),
ArrowGlacierBlock: big.NewInt(0),
GrayGlacierBlock: big.NewInt(0),
MergeNetsplitBlock: big.NewInt(0),
TerminalTotalDifficulty: big.NewInt(0),
TerminalTotalDifficultyPassed: true,
// TODO marcello double check
ShanghaiTime: u64(0),
Bor: &params.BorConfig{BurntContract: map[string]string{"0": "0x000000000000000000000000000000000000dead"}},
},
Alloc: GenesisAlloc{
common.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7"): GenesisAccount{
Balance: big.NewInt(1000000000000000000), // 1 ether
Nonce: 0,
},
},
}
genesis = gspec.MustCommit(db)
blockchain, _ = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil, nil)
parallelBlockchain, _ = NewParallelBlockChain(db, cacheConfig, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{ParallelEnable: true, ParallelSpeculativeProcesses: 8}, nil, nil, nil)
tooBigInitCode = [params.MaxInitCodeSize + 1]byte{}
smallInitCode = [320]byte{}
)
defer blockchain.Stop()
defer parallelBlockchain.Stop()
for _, bc := range []*BlockChain{blockchain, parallelBlockchain} {
for i, tt := range []struct {
txs []*types.Transaction
want string
}{
{ // ErrMaxInitCodeSizeExceeded
txs: []*types.Transaction{
mkDynamicCreationTx(0, 500000, common.Big0, eip1559.CalcBaseFee(config, genesis.Header()), tooBigInitCode[:]),
},
want: "could not apply tx 0 [0x832b54a6c3359474a9f504b1003b2cc1b6fcaa18e4ef369eb45b5d40dad6378f]: max initcode size exceeded: code size 49153 limit 49152",
},
{ // ErrIntrinsicGas: Not enough gas to cover init code
txs: []*types.Transaction{
mkDynamicCreationTx(0, 54299, common.Big0, eip1559.CalcBaseFee(config, genesis.Header()), smallInitCode[:]),
},
want: "could not apply tx 0 [0x39b7436cb432d3662a25626474282c5c4c1a213326fd87e4e18a91477bae98b2]: intrinsic gas too low: have 54299, want 54300",
},
} {
block := GenerateBadBlock(genesis, beacon.New(ethash.NewFaker()), tt.txs, gspec.Config)
_, err := bc.InsertChain(types.Blocks{block})
if err == nil {
t.Fatal("block imported without errors")
}
if have, want := err.Error(), tt.want; have != want {
t.Errorf("test %d:\nhave \"%v\"\nwant \"%v\"\n", i, have, want)
}
}
}
}
} }
// GenerateBadBlock constructs a "block" which contains the transactions. The transactions are not expected to be // GenerateBadBlock constructs a "block" which contains the transactions. The transactions are not expected to be

0
core/triecache/data.0.bin
View file

BIN
core/triecache/data.1.bin
View file

Binary file not shown.

0
core/triecache/data.2.bin
View file

BIN
core/triecache/data.3.bin
View file

Binary file not shown.

BIN
core/triecache/data.4.bin
View file

Binary file not shown.

BIN
core/triecache/data.5.bin
View file

Binary file not shown.

0
core/triecache/data.6.bin
View file

BIN
core/triecache/data.7.bin
View file

Binary file not shown.

BIN
core/triecache/metadata.bin
View file

Binary file not shown.

2
core/txpool/blobpool/blobpool_test.go
View file

@ -73,7 +73,7 @@ var testChainConfig *params.ChainConfig
func init() { func init() {
testChainConfig = new(params.ChainConfig) testChainConfig = new(params.ChainConfig)
*testChainConfig = *params.MainnetChainConfig *testChainConfig = *params.TestChainConfig
testChainConfig.CancunTime = new(uint64) testChainConfig.CancunTime = new(uint64)
*testChainConfig.CancunTime = uint64(time.Now().Unix()) *testChainConfig.CancunTime = uint64(time.Now().Unix())

10
core/txpool/legacypool/legacypool2_test.go
View file

@ -50,7 +50,6 @@ func fillPool(t testing.TB, pool *LegacyPool) {
// Create a number of test accounts, fund them and make transactions // Create a number of test accounts, fund them and make transactions
executableTxs := types.Transactions{} executableTxs := types.Transactions{}
nonExecutableTxs := types.Transactions{} nonExecutableTxs := types.Transactions{}
for i := 0; i < 384; i++ { for i := 0; i < 384; i++ {
key, _ := crypto.GenerateKey() key, _ := crypto.GenerateKey()
pool.currentState.AddBalance(crypto.PubkeyToAddress(key.PublicKey), big.NewInt(10000000000)) pool.currentState.AddBalance(crypto.PubkeyToAddress(key.PublicKey), big.NewInt(10000000000))
@ -66,15 +65,14 @@ func fillPool(t testing.TB, pool *LegacyPool) {
slots := pool.all.Slots() slots := pool.all.Slots()
// sanity-check that the test prerequisites are ok (pending full) // sanity-check that the test prerequisites are ok (pending full)
if have, want := pending, slots; have != want { if have, want := pending, slots; have != want {
tb.Fatalf("have %d, want %d", have, want) t.Fatalf("have %d, want %d", have, want)
} }
if have, want := queued, 0; have != want { if have, want := queued, 0; have != want {
tb.Fatalf("have %d, want %d", have, want) t.Fatalf("have %d, want %d", have, want)
} }
tb.Logf("pool.config: GlobalSlots=%d, GlobalQueue=%d\n", pool.config.GlobalSlots, pool.config.GlobalQueue) t.Logf("pool.config: GlobalSlots=%d, GlobalQueue=%d\n", pool.config.GlobalSlots, pool.config.GlobalQueue)
tb.Logf("pending: %d queued: %d, all: %d\n", pending, queued, slots) t.Logf("pending: %d queued: %d, all: %d\n", pending, queued, slots)
} }
// Tests that if a batch high-priced of non-executables arrive, they do not kick out // Tests that if a batch high-priced of non-executables arrive, they do not kick out

2246
core/txpool/legacypool/legacypool_test.go
View file

File diff suppressed because it is too large Load diff

2
eth/downloader/downloader_test.go
View file

@ -94,7 +94,7 @@ func newTesterWithNotification(t *testing.T, success func()) *downloadTester {
} }
//nolint: staticcheck //nolint: staticcheck
tester.downloader = New(0, db, new(event.TypeMux), tester.chain, nil, tester.dropPeer, success, whitelist.NewService(db)) tester.downloader = New(db, new(event.TypeMux), tester.chain, nil, tester.dropPeer, success, whitelist.NewService(db))
return tester return tester
} }

15
eth/filters/IBackend.go
View file

@ -174,21 +174,6 @@ func (mr *MockBackendMockRecorder) GetReceipts(arg0, arg1 interface{}) *gomock.C
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReceipts", reflect.TypeOf((*MockBackend)(nil).GetReceipts), arg0, arg1) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReceipts", reflect.TypeOf((*MockBackend)(nil).GetReceipts), arg0, arg1)
} }
// GetVoteOnHash mocks base method.
func (m *MockBackend) GetVoteOnHash(arg0 context.Context, arg1, arg2 uint64, arg3, arg4 string) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetVoteOnHash", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetVoteOnHash indicates an expected call of GetVoteOnHash.
func (mr *MockBackendMockRecorder) GetVoteOnHash(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVoteOnHash", reflect.TypeOf((*MockBackend)(nil).GetVoteOnHash), arg0, arg1, arg2, arg3, arg4)
}
// HeaderByHash mocks base method. // HeaderByHash mocks base method.
func (m *MockBackend) HeaderByHash(arg0 context.Context, arg1 common.Hash) (*types.Header, error) { func (m *MockBackend) HeaderByHash(arg0 context.Context, arg1 common.Hash) (*types.Header, error) {
m.ctrl.T.Helper() m.ctrl.T.Helper()

47
internal/ethapi/api_test.go
View file

@ -536,6 +536,51 @@ func (b testBackend) ServiceFilter(ctx context.Context, session *bloombits.Match
panic("implement me") panic("implement me")
} }
// GetBorBlockTransaction returns bor block tx
func (b testBackend) GetBorBlockTransaction(ctx context.Context, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
panic("implement me")
}
func (b testBackend) GetBorBlockTransactionWithBlockHash(ctx context.Context, txHash common.Hash, blockHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
panic("implement me")
}
func (b testBackend) GetRootHash(ctx context.Context, starBlockNr uint64, endBlockNr uint64) (string, error) {
panic("implement me")
}
func (b testBackend) GetVoteOnHash(ctx context.Context, starBlockNr uint64, endBlockNr uint64, hash string, milestoneId string) (bool, error) {
panic("implement me")
}
func (b testBackend) GetWhitelistedCheckpoint() (bool, uint64, common.Hash) {
panic("implement me")
}
func (b testBackend) GetWhitelistedMilestone() (bool, uint64, common.Hash) {
panic("implement me")
}
func (b testBackend) PurgeWhitelistedMilestone() {
panic("implement me")
}
func (b testBackend) PurgeWhitelistedCheckpoint() {
panic("implement me")
}
func (b testBackend) RPCRpcReturnDataLimit() uint64 {
panic("implement me")
}
func (b testBackend) SubscribeChain2HeadEvent(ch chan<- core.Chain2HeadEvent) event.Subscription {
panic("implement me")
}
func (b testBackend) SubscribeStateSyncEvent(ch chan<- core.StateSyncEvent) event.Subscription {
panic("implement me")
}
func (b testBackend) GetBorBlockLogs(ctx context.Context, hash common.Hash) ([]*types.Log, error) { func (b testBackend) GetBorBlockLogs(ctx context.Context, hash common.Hash) ([]*types.Log, error) {
receipt, err := b.GetBorBlockReceipt(ctx, hash) receipt, err := b.GetBorBlockReceipt(ctx, hash)
if err != nil || receipt == nil { if err != nil || receipt == nil {
@ -1055,7 +1100,7 @@ func TestRPCMarshalBlock(t *testing.T) {
} }
for i, tc := range testSuite { for i, tc := range testSuite {
resp := RPCMarshalBlock(block, tc.inclTx, tc.fullTx, params.MainnetChainConfig) resp := RPCMarshalBlock(block, tc.inclTx, tc.fullTx, params.MainnetChainConfig, nil)
out, err := json.Marshal(resp) out, err := json.Marshal(resp)
if err != nil { if err != nil {
t.Errorf("test %d: json marshal error: %v", i, err) t.Errorf("test %d: json marshal error: %v", i, err)

4
les/handler_test.go
View file

@ -317,7 +317,7 @@ func TestGetStaleCodeLes4(t *testing.T) { testGetStaleCode(t, 4) }
func testGetStaleCode(t *testing.T, protocol int) { func testGetStaleCode(t *testing.T, protocol int) {
netconfig := testnetConfig{ netconfig := testnetConfig{
blocks: int(core.DefaultCacheConfig.TriesInMemory) + 4, blocks: int(core.DefaultCacheConfig.TriesInMemory + 4),
protocol: protocol, protocol: protocol,
nopruning: true, nopruning: true,
} }
@ -431,7 +431,7 @@ func TestGetStaleProofLes4(t *testing.T) { testGetStaleProof(t, 4) }
func testGetStaleProof(t *testing.T, protocol int) { func testGetStaleProof(t *testing.T, protocol int) {
netconfig := testnetConfig{ netconfig := testnetConfig{
blocks: int(core.DefaultCacheConfig.TriesInMemory) + 4, blocks: int(core.DefaultCacheConfig.TriesInMemory + 4),
protocol: protocol, protocol: protocol,
nopruning: true, nopruning: true,
} }

181
miner/fake_miner.go
View file

@ -1,40 +1,33 @@
package miner package miner
import (
"github.com/golang/mock/gomock"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/consensus/bor"
"github.com/ethereum/go-ethereum/consensus/bor/api"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/ethdb/memorydb"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/trie"
)
type DefaultBorMiner struct {
Miner *Miner
Mux *event.TypeMux //nolint:staticcheck
Cleanup func(skipMiner bool)
Ctrl *gomock.Controller
EthAPIMock api.Caller
HeimdallClientMock bor.IHeimdallClient
ContractMock bor.GenesisContract
}
// TODO - Arpit // TODO - Arpit
// import (
// "testing"
// "github.com/golang/mock/gomock"
// "github.com/ethereum/go-ethereum/common"
// "github.com/ethereum/go-ethereum/consensus"
// "github.com/ethereum/go-ethereum/consensus/bor"
// "github.com/ethereum/go-ethereum/consensus/bor/api"
// "github.com/ethereum/go-ethereum/consensus/bor/valset"
// "github.com/ethereum/go-ethereum/core"
// "github.com/ethereum/go-ethereum/core/rawdb"
// "github.com/ethereum/go-ethereum/core/state"
// "github.com/ethereum/go-ethereum/core/txpool"
// "github.com/ethereum/go-ethereum/core/vm"
// "github.com/ethereum/go-ethereum/ethdb"
// "github.com/ethereum/go-ethereum/ethdb/memorydb"
// "github.com/ethereum/go-ethereum/event"
// "github.com/ethereum/go-ethereum/params"
// "github.com/ethereum/go-ethereum/tests/bor/mocks"
// "github.com/ethereum/go-ethereum/trie"
// )
// type DefaultBorMiner struct {
// Miner *Miner
// Mux *event.TypeMux //nolint:staticcheck
// Cleanup func(skipMiner bool)
// Ctrl *gomock.Controller
// EthAPIMock api.Caller
// HeimdallClientMock bor.IHeimdallClient
// ContractMock bor.GenesisContract
// }
// func NewBorDefaultMiner(t *testing.T) *DefaultBorMiner { // func NewBorDefaultMiner(t *testing.T) *DefaultBorMiner {
// t.Helper() // t.Helper()
@ -71,21 +64,11 @@ package miner
// } // }
// } // }
// TODO - Arpit
// //nolint:staticcheck // //nolint:staticcheck
// func createBorMiner(t *testing.T, ethAPIMock api.Caller, spanner bor.Spanner, heimdallClientMock bor.IHeimdallClient, contractMock bor.GenesisContract) (*Miner, *event.TypeMux, func(skipMiner bool)) { // func createBorMiner(t *testing.T, ethAPIMock api.Caller, spanner bor.Spanner, heimdallClientMock bor.IHeimdallClient, contractMock bor.GenesisContract) (*Miner, *event.TypeMux, func(skipMiner bool)) {
// t.Helper() // t.Helper()
// // addr0 := common.Address{0x1}
// // genspec := &core.Genesis{
// // Alloc: map[common.Address]core.GenesisAccount{
// // addr0: {
// // Balance: big.NewInt(0),
// // Code: []byte{0x1, 0x1},
// // },
// // },
// // }
// // Create Ethash config // // Create Ethash config
// chainDB, genspec, chainConfig := NewDBForFakes(t) // chainDB, genspec, chainConfig := NewDBForFakes(t)
@ -100,8 +83,22 @@ package miner
// statedb, _ := state.New(common.Hash{}, state.NewDatabase(chainDB), nil) // statedb, _ := state.New(common.Hash{}, state.NewDatabase(chainDB), nil)
// blockchain := &testBlockChain{statedb, 10000000, new(event.Feed)} // blockchain := &testBlockChain{statedb, 10000000, new(event.Feed)}
// pool := txpool.NewTxPool(testTxPoolConfig, chainConfig, blockchain) // // blockchain := &blobpool.testBlockChain{
// backend := NewMockBackend(bc, pool) // // config: blobpool.testChainConfig,
// // basefee: uint256.NewInt(params.InitialBaseFee),
// // blobfee: uint256.NewInt(params.BlobTxMinBlobGasprice),
// // statedb: statedb,
// // }
// // pool := legacypool.New(testTxPoolConfig, blockchain)
// // pool.Init(new(big.Int).SetUint64(testTxPoolConfig.PriceLimit), blockchain.CurrentBlock(), makeAddressReserver())
// pool := legacypool.New(testTxPoolConfig, blockchain)
// txpool, _ := txpool.New(new(big.Int).SetUint64(blobpool.testTxPoolConfig.PriceLimit), blockchain, []txpool.SubPool{pool})
// defer pool.Close()
// // pool := txpool.NewTxPool(testTxPoolConfig, chainConfig, blockchain)
// backend := NewMockBackend(bc, txpool)
// // Create event Mux // // Create event Mux
// mux := new(event.TypeMux) // mux := new(event.TypeMux)
@ -116,7 +113,6 @@ package miner
// cleanup := func(skipMiner bool) { // cleanup := func(skipMiner bool) {
// bc.Stop() // bc.Stop()
// engine.Close() // engine.Close()
// pool.Stop()
// if !skipMiner { // if !skipMiner {
// miner.Close() // miner.Close()
@ -126,42 +122,42 @@ package miner
// return miner, mux, cleanup // return miner, mux, cleanup
// } // }
// type TensingObject interface { type TensingObject interface {
// Helper() Helper()
// Fatalf(format string, args ...any) Fatalf(format string, args ...any)
// } }
// func NewDBForFakes(t TensingObject) (ethdb.Database, *core.Genesis, *params.ChainConfig) { func NewDBForFakes(t TensingObject) (ethdb.Database, *core.Genesis, *params.ChainConfig) {
// t.Helper() t.Helper()
// memdb := memorydb.New() memdb := memorydb.New()
// chainDB := rawdb.NewDatabase(memdb) chainDB := rawdb.NewDatabase(memdb)
// genesis := core.DeveloperGenesisBlock(11_500_000, common.HexToAddress("12345")) genesis := core.DeveloperGenesisBlock(11_500_000, common.HexToAddress("12345"))
// chainConfig, _, err := core.SetupGenesisBlock(chainDB, trie.NewDatabase(chainDB), genesis) chainConfig, _, err := core.SetupGenesisBlock(chainDB, trie.NewDatabase(chainDB), genesis)
// if err != nil { if err != nil {
// t.Fatalf("can't create new chain config: %v", err) t.Fatalf("can't create new chain config: %v", err)
// } }
// chainConfig.Bor.Period = map[string]uint64{ chainConfig.Bor.Period = map[string]uint64{
// "0": 1, "0": 1,
// } }
// chainConfig.Bor.Sprint = map[string]uint64{ chainConfig.Bor.Sprint = map[string]uint64{
// "0": 64, "0": 64,
// } }
// return chainDB, genesis, chainConfig return chainDB, genesis, chainConfig
// } }
// func NewFakeBor(t TensingObject, chainDB ethdb.Database, chainConfig *params.ChainConfig, ethAPIMock api.Caller, spanner bor.Spanner, heimdallClientMock bor.IHeimdallClient, contractMock bor.GenesisContract) consensus.Engine { func NewFakeBor(t TensingObject, chainDB ethdb.Database, chainConfig *params.ChainConfig, ethAPIMock api.Caller, spanner bor.Spanner, heimdallClientMock bor.IHeimdallClient, contractMock bor.GenesisContract) consensus.Engine {
// t.Helper() t.Helper()
// if chainConfig.Bor == nil { if chainConfig.Bor == nil {
// chainConfig.Bor = params.BorUnittestChainConfig.Bor chainConfig.Bor = params.BorUnittestChainConfig.Bor
// } }
// return bor.New(chainConfig, chainDB, ethAPIMock, spanner, heimdallClientMock, contractMock, false) return bor.New(chainConfig, chainDB, ethAPIMock, spanner, heimdallClientMock, contractMock, false)
// } }
// type mockBackend struct { // type mockBackend struct {
// bc *core.BlockChain // bc *core.BlockChain
@ -217,15 +213,15 @@ package miner
// return bc.chainHeadFeed.Subscribe(ch) // return bc.chainHeadFeed.Subscribe(ch)
// } // }
// var ( var (
// // Test chain configurations // Test chain configurations
// testTxPoolConfig txpool.Config // testTxPoolConfig txpool.Config
// ethashChainConfig *params.ChainConfig // ethashChainConfig *params.ChainConfig
// cliqueChainConfig *params.ChainConfig // cliqueChainConfig *params.ChainConfig
// // Test accounts // // Test accounts
// testBankKey, _ = crypto.GenerateKey() // testBankKey, _ = crypto.GenerateKey()
// TestBankAddress = crypto.PubkeyToAddress(testBankKey.PublicKey)
// testBankFunds = big.NewInt(9000000000000000000) // testBankFunds = big.NewInt(9000000000000000000)
// testUserKey, _ = crypto.GenerateKey() // testUserKey, _ = crypto.GenerateKey()
@ -240,17 +236,18 @@ package miner
// GasCeil: params.GenesisGasLimit, // GasCeil: params.GenesisGasLimit,
// CommitInterruptFlag: true, // CommitInterruptFlag: true,
// } // }
// ) )
// func init() { func init() {
// testTxPoolConfig = txpool.DefaultConfig // testTxPoolConfig = txpool.DefaultConfig
// testTxPoolConfig.Journal = "" // testTxPoolConfig.Journal = ""
// ethashChainConfig = new(params.ChainConfig) // ethashChainConfig = new(params.ChainConfig)
// *ethashChainConfig = *params.TestChainConfig // *ethashChainConfig = *params.TestChainConfig
// cliqueChainConfig = new(params.ChainConfig) // cliqueChainConfig = new(params.ChainConfig)
// *cliqueChainConfig = *params.TestChainConfig // *cliqueChainConfig = *params.TestChainConfig
// cliqueChainConfig.Clique = &params.CliqueConfig{ //
// Period: 10, // cliqueChainConfig.Clique = &params.CliqueConfig{
// Epoch: 30000, // Period: 10,
// } // Epoch: 30000,
// } // }
}

348
miner/miner_test.go
View file

@ -33,7 +33,6 @@ import (
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth/downloader"
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie"
@ -55,6 +54,11 @@ func (m *mockBackend) BlockChain() *core.BlockChain {
return m.bc return m.bc
} }
// PeerCount implements Backend.
func (*mockBackend) PeerCount() int {
panic("unimplemented")
}
func (m *mockBackend) TxPool() *txpool.TxPool { func (m *mockBackend) TxPool() *txpool.TxPool {
return m.txPool return m.txPool
} }
@ -93,227 +97,234 @@ func (bc *testBlockChain) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent)
return bc.chainHeadFeed.Subscribe(ch) return bc.chainHeadFeed.Subscribe(ch)
} }
func TestMiner(t *testing.T) { // // TODO - Arpit
t.Parallel() // func TestMiner(t *testing.T) {
// t.Parallel()
minerBor := NewBorDefaultMiner(t) // minerBor := NewBorDefaultMiner(t)
defer func() { // defer func() {
minerBor.Cleanup(false) // minerBor.Cleanup(false)
minerBor.Ctrl.Finish() // minerBor.Ctrl.Finish()
}() // }()
miner := minerBor.Miner // miner := minerBor.Miner
mux := minerBor.Mux // mux := minerBor.Mux
miner.Start() // miner.Start()
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
// Start the downloader // // Start the downloader
mux.Post(downloader.StartEvent{}) // mux.Post(downloader.StartEvent{})
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
// Stop the downloader and wait for the update loop to run // // Stop the downloader and wait for the update loop to run
mux.Post(downloader.DoneEvent{}) // mux.Post(downloader.DoneEvent{})
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
// Subsequent downloader events after a successful DoneEvent should not cause the // // Subsequent downloader events after a successful DoneEvent should not cause the
// miner to start or stop. This prevents a security vulnerability // // miner to start or stop. This prevents a security vulnerability
// that would allow entities to present fake high blocks that would // // that would allow entities to present fake high blocks that would
// stop mining operations by causing a downloader sync // // stop mining operations by causing a downloader sync
// until it was discovered they were invalid, whereon mining would resume. // // until it was discovered they were invalid, whereon mining would resume.
mux.Post(downloader.StartEvent{}) // mux.Post(downloader.StartEvent{})
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
mux.Post(downloader.FailedEvent{}) // mux.Post(downloader.FailedEvent{})
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
} // }
// TestMinerDownloaderFirstFails tests that mining is only // // TODO - Arpit
// permitted to run indefinitely once the downloader sees a DoneEvent (success). // // TestMinerDownloaderFirstFails tests that mining is only
// An initial FailedEvent should allow mining to stop on a subsequent // // permitted to run indefinitely once the downloader sees a DoneEvent (success).
// downloader StartEvent. // // An initial FailedEvent should allow mining to stop on a subsequent
func TestMinerDownloaderFirstFails(t *testing.T) { // // downloader StartEvent.
t.Parallel() // func TestMinerDownloaderFirstFails(t *testing.T) {
// t.Parallel()
minerBor := NewBorDefaultMiner(t) // minerBor := NewBorDefaultMiner(t)
defer func() { // defer func() {
minerBor.Cleanup(false) // minerBor.Cleanup(false)
minerBor.Ctrl.Finish() // minerBor.Ctrl.Finish()
}() // }()
miner := minerBor.Miner // miner := minerBor.Miner
mux := minerBor.Mux // mux := minerBor.Mux
miner.Start() // miner.Start()
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
// Start the downloader // // Start the downloader
mux.Post(downloader.StartEvent{}) // mux.Post(downloader.StartEvent{})
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
// Stop the downloader and wait for the update loop to run // // Stop the downloader and wait for the update loop to run
mux.Post(downloader.FailedEvent{}) // mux.Post(downloader.FailedEvent{})
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
// Since the downloader hasn't yet emitted a successful DoneEvent, // // Since the downloader hasn't yet emitted a successful DoneEvent,
// we expect the miner to stop on next StartEvent. // // we expect the miner to stop on next StartEvent.
mux.Post(downloader.StartEvent{}) // mux.Post(downloader.StartEvent{})
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
// Downloader finally succeeds. // // Downloader finally succeeds.
mux.Post(downloader.DoneEvent{}) // mux.Post(downloader.DoneEvent{})
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
// Downloader starts again. // // Downloader starts again.
// Since it has achieved a DoneEvent once, we expect miner // // Since it has achieved a DoneEvent once, we expect miner
// state to be unchanged. // // state to be unchanged.
mux.Post(downloader.StartEvent{}) // mux.Post(downloader.StartEvent{})
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
mux.Post(downloader.FailedEvent{}) // mux.Post(downloader.FailedEvent{})
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
} // }
func TestMinerStartStopAfterDownloaderEvents(t *testing.T) { // // TODO - Arpit
t.Parallel() // func TestMinerStartStopAfterDownloaderEvents(t *testing.T) {
// t.Parallel()
minerBor := NewBorDefaultMiner(t) // minerBor := NewBorDefaultMiner(t)
defer func() { // defer func() {
minerBor.Cleanup(false) // minerBor.Cleanup(false)
minerBor.Ctrl.Finish() // minerBor.Ctrl.Finish()
}() // }()
miner := minerBor.Miner // miner := minerBor.Miner
mux := minerBor.Mux // mux := minerBor.Mux
miner.Start() // miner.Start()
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
// Start the downloader // // Start the downloader
mux.Post(downloader.StartEvent{}) // mux.Post(downloader.StartEvent{})
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
// Downloader finally succeeds. // // Downloader finally succeeds.
mux.Post(downloader.DoneEvent{}) // mux.Post(downloader.DoneEvent{})
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
ch := make(chan struct{}) // ch := make(chan struct{})
miner.Stop(ch) // miner.Stop(ch)
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
miner.Start() // miner.Start()
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
ch = make(chan struct{}) // ch = make(chan struct{})
miner.Stop(ch) // miner.Stop(ch)
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
} // }
func TestStartWhileDownload(t *testing.T) { // // TODO - Arpit
t.Parallel() // func TestStartWhileDownload(t *testing.T) {
// t.Parallel()
minerBor := NewBorDefaultMiner(t) // minerBor := NewBorDefaultMiner(t)
defer func() { // defer func() {
minerBor.Cleanup(false) // minerBor.Cleanup(false)
minerBor.Ctrl.Finish() // minerBor.Ctrl.Finish()
}() // }()
miner := minerBor.Miner // miner := minerBor.Miner
mux := minerBor.Mux // mux := minerBor.Mux
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
miner.Start() // miner.Start()
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
// Stop the downloader and wait for the update loop to run // // Stop the downloader and wait for the update loop to run
mux.Post(downloader.StartEvent{}) // mux.Post(downloader.StartEvent{})
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
// Starting the miner after the downloader should not work // // Starting the miner after the downloader should not work
miner.Start() // miner.Start()
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
} // }
func TestStartStopMiner(t *testing.T) { // // TODO - Arpit
t.Parallel() // func TestStartStopMiner(t *testing.T) {
// t.Parallel()
minerBor := NewBorDefaultMiner(t) // minerBor := NewBorDefaultMiner(t)
defer func() { // defer func() {
minerBor.Cleanup(false) // minerBor.Cleanup(false)
minerBor.Ctrl.Finish() // minerBor.Ctrl.Finish()
}() // }()
miner := minerBor.Miner // miner := minerBor.Miner
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
miner.Start() // miner.Start()
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
ch := make(chan struct{}) // ch := make(chan struct{})
miner.Stop(ch) // miner.Stop(ch)
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
} // }
func TestCloseMiner(t *testing.T) { // // TODO - Arpit
t.Parallel() // func TestCloseMiner(t *testing.T) {
// t.Parallel()
minerBor := NewBorDefaultMiner(t) // minerBor := NewBorDefaultMiner(t)
defer func() { // defer func() {
minerBor.Cleanup(true) // minerBor.Cleanup(true)
minerBor.Ctrl.Finish() // minerBor.Ctrl.Finish()
}() // }()
miner := minerBor.Miner // miner := minerBor.Miner
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
miner.Start() // miner.Start()
miner.Start() // miner.Start()
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
// Terminate the miner and wait for the update loop to run // // Terminate the miner and wait for the update loop to run
miner.Close() // miner.Close()
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
} // }
// TestMinerSetEtherbase checks that etherbase becomes set even if mining isn't // // TestMinerSetEtherbase checks that etherbase becomes set even if mining isn't
// possible at the moment // // possible at the moment
func TestMinerSetEtherbase(t *testing.T) { // // TODO - Arpit
t.Parallel() // func TestMinerSetEtherbase(t *testing.T) {
// t.Parallel()
minerBor := NewBorDefaultMiner(t) // minerBor := NewBorDefaultMiner(t)
defer func() { // defer func() {
minerBor.Cleanup(false) // minerBor.Cleanup(false)
minerBor.Ctrl.Finish() // minerBor.Ctrl.Finish()
}() // }()
miner := minerBor.Miner // miner := minerBor.Miner
mux := minerBor.Mux // mux := minerBor.Mux
// Start with a 'bad' mining address // // Start with a 'bad' mining address
miner.Start() // miner.Start()
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
// Start the downloader // // Start the downloader
mux.Post(downloader.StartEvent{}) // mux.Post(downloader.StartEvent{})
waitForMiningState(t, miner, false) // waitForMiningState(t, miner, false)
// Now user tries to configure proper mining address // // Now user tries to configure proper mining address
miner.Start() // miner.Start()
// Stop the downloader and wait for the update loop to run // // Stop the downloader and wait for the update loop to run
mux.Post(downloader.DoneEvent{}) // mux.Post(downloader.DoneEvent{})
waitForMiningState(t, miner, true) // waitForMiningState(t, miner, true)
coinbase := common.HexToAddress("0xdeedbeef") // coinbase := common.HexToAddress("0xdeedbeef")
miner.SetEtherbase(coinbase) // miner.SetEtherbase(coinbase)
if addr := miner.worker.etherbase(); addr != coinbase { // if addr := miner.worker.etherbase(); addr != coinbase {
t.Fatalf("Unexpected etherbase want %x got %x", coinbase, addr) // t.Fatalf("Unexpected etherbase want %x got %x", coinbase, addr)
} // }
} // }
// waitForMiningState waits until either // waitForMiningState waits until either
// * the desired mining state was reached // * the desired mining state was reached
@ -361,6 +372,7 @@ func minerTestGenesisBlock(period uint64, gasLimit uint64, faucet common.Address
}, },
} }
} }
func createMiner(t *testing.T) (*Miner, *event.TypeMux, func(skipMiner bool)) { func createMiner(t *testing.T) (*Miner, *event.TypeMux, func(skipMiner bool)) {
t.Helper() t.Helper()

2
miner/payload_building_test.go
View file

@ -37,7 +37,7 @@ func TestBuildPayload(t *testing.T) {
recipient = common.HexToAddress("0xdeadbeef") recipient = common.HexToAddress("0xdeadbeef")
) )
w, b, _ := newTestWorker(t, params.TestChainConfig, ethash.NewFaker(), db, 0, false, 0, 0) w, b := newTestWorker(t, params.TestChainConfig, ethash.NewFaker(), db, 0)
defer w.close() defer w.close()
timestamp := uint64(time.Now().Unix()) timestamp := uint64(time.Now().Unix())

1392
miner/test_backend.go
View file

File diff suppressed because it is too large Load diff

6
miner/worker.go
View file

@ -67,6 +67,9 @@ const (
// chainHeadChanSize is the size of channel listening to ChainHeadEvent. // chainHeadChanSize is the size of channel listening to ChainHeadEvent.
chainHeadChanSize = 10 chainHeadChanSize = 10
// chainSideChanSize is the size of channel listening to ChainSideEvent.
chainSideChanSize = 10
// resubmitAdjustChanSize is the size of resubmitting interval adjustment channel. // resubmitAdjustChanSize is the size of resubmitting interval adjustment channel.
resubmitAdjustChanSize = 10 resubmitAdjustChanSize = 10
@ -211,6 +214,8 @@ type worker struct {
txsSub event.Subscription txsSub event.Subscription
chainHeadCh chan core.ChainHeadEvent chainHeadCh chan core.ChainHeadEvent
chainHeadSub event.Subscription chainHeadSub event.Subscription
chainSideCh chan core.ChainSideEvent
chainSideSub event.Subscription
// Channels // Channels
newWorkCh chan *newWorkReq newWorkCh chan *newWorkReq
@ -1445,6 +1450,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *atomic.Int32,
) )
}) })
// TODO - Arpit whether commitTransaction with delay?
tracing.Exec(ctx, "", "worker.LocalCommitTransactions", func(ctx context.Context, span trace.Span) { tracing.Exec(ctx, "", "worker.LocalCommitTransactions", func(ctx context.Context, span trace.Span) {
err = w.commitTransactions(env, txs, interrupt, interruptCtx) err = w.commitTransactions(env, txs, interrupt, interruptCtx)
}) })

894
miner/worker_test.go
View file

File diff suppressed because it is too large Load diff

5
node/node_auth_test.go
View file

@ -124,7 +124,6 @@ func TestAuthEndpoints(t *testing.T) {
WSModules: []string{"eth", "engine"}, WSModules: []string{"eth", "engine"},
HTTPModules: []string{"eth", "engine"}, HTTPModules: []string{"eth", "engine"},
} }
node, err := New(conf) node, err := New(conf)
if err != nil { if err != nil {
t.Fatalf("could not create a new node: %v", err) t.Fatalf("could not create a new node: %v", err)
@ -146,7 +145,6 @@ func TestAuthEndpoints(t *testing.T) {
Authenticated: true, Authenticated: true,
}, },
}) })
if err := node.Start(); err != nil { if err := node.Start(); err != nil {
t.Fatalf("failed to start test node: %v", err) t.Fatalf("failed to start test node: %v", err)
} }
@ -156,18 +154,15 @@ func TestAuthEndpoints(t *testing.T) {
if a, b := node.WSEndpoint(), node.WSAuthEndpoint(); a == b { if a, b := node.WSEndpoint(), node.WSAuthEndpoint(); a == b {
t.Fatalf("expected ws and auth-ws endpoints to be different, got: %q and %q", a, b) t.Fatalf("expected ws and auth-ws endpoints to be different, got: %q and %q", a, b)
} }
if a, b := node.HTTPEndpoint(), node.HTTPAuthEndpoint(); a == b { if a, b := node.HTTPEndpoint(), node.HTTPAuthEndpoint(); a == b {
t.Fatalf("expected http and auth-http endpoints to be different, got: %q and %q", a, b) t.Fatalf("expected http and auth-http endpoints to be different, got: %q and %q", a, b)
} }
goodAuth := NewJWTAuth(secret) goodAuth := NewJWTAuth(secret)
var otherSecret [32]byte var otherSecret [32]byte
if _, err := crand.Read(otherSecret[:]); err != nil { if _, err := crand.Read(otherSecret[:]); err != nil {
t.Fatalf("failed to create jwt secret: %v", err) t.Fatalf("failed to create jwt secret: %v", err)
} }
badAuth := NewJWTAuth(otherSecret) badAuth := NewJWTAuth(otherSecret)
notTooLong := time.Second * 57 notTooLong := time.Second * 57

1
params/config.go
View file

@ -360,6 +360,7 @@ var (
TerminalTotalDifficulty: big.NewInt(0), TerminalTotalDifficulty: big.NewInt(0),
TerminalTotalDifficultyPassed: true, TerminalTotalDifficultyPassed: true,
IsDevMode: true, IsDevMode: true,
Bor: &BorConfig{BurntContract: map[string]string{"0": "0x000000000000000000000000000000000000dead"}},
} }
// AllCliqueProtocolChanges contains every protocol change (EIPs) introduced // AllCliqueProtocolChanges contains every protocol change (EIPs) introduced

28
tests/bor/bor_milestone_test.go
View file

@ -90,7 +90,7 @@ func TestMiningAfterLocking(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -199,7 +199,7 @@ func TestReorgingAfterLockingSprint(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -319,7 +319,7 @@ func TestReorgingAfterWhitelisting(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -432,7 +432,7 @@ func TestPeerConnectionAfterWhitelisting(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -553,7 +553,7 @@ func TestReorgingFutureSprintAfterLocking(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -641,7 +641,7 @@ func TestReorgingFutureSprintAfterLockingOnSameHash(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -732,7 +732,7 @@ func TestReorgingAfterLockingOnDifferentHash(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -853,7 +853,7 @@ func TestReorgingAfterWhitelistingOnDifferentHash(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -975,7 +975,7 @@ func TestNonMinerNodeWithWhitelisting(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
//Only started the node 0 and keep the node 1 as non mining //Only started the node 0 and keep the node 1 as non mining
err = nodes[0].StartMining(1) err = nodes[0].StartMining()
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -1071,7 +1071,7 @@ func TestNonMinerNodeWithTryToLock(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
//Only started the node 0 and keep the node 1 as non mining //Only started the node 0 and keep the node 1 as non mining
err = nodes[0].StartMining(1) err = nodes[0].StartMining()
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -1163,7 +1163,7 @@ func TestRewind(t *testing.T) {
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -1211,7 +1211,7 @@ func TestRewind(t *testing.T) {
panic(err) panic(err)
} }
err = nodes[1].StartMining(1) err = nodes[1].StartMining()
if err != nil { if err != nil {
panic(err) panic(err)
@ -1280,7 +1280,7 @@ func TestRewinding(t *testing.T) {
//Start mining //Start mining
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -1372,7 +1372,7 @@ func rewindBack(eth *eth.Ethereum, rewindTo uint64) {
<-ch <-ch
rewind(eth, rewindTo) rewind(eth, rewindTo)
err := eth.StartMining(1) err := eth.StartMining()
if err != nil { if err != nil {
panic(err) panic(err)

6
tests/bor/bor_sprint_length_milestone_merge_test.go
View file

@ -374,7 +374,7 @@ func SetupValidatorsAndTest2NodesSprintLengthMilestone(t *testing.T, tt map[stri
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -516,7 +516,7 @@ func SetupValidatorsAndTestSprintLengthMilestone(t *testing.T, tt map[string]uin
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
for _, node := range nodes { for _, node := range nodes {
if err := node.StartMining(1); err != nil { if err := node.StartMining(); err != nil {
panic(err) panic(err)
} }
} }
@ -685,7 +685,7 @@ func rewindBackTemp(eth *eth.Ethereum, rewindTo uint64) {
eth.Miner().Stop(ch) eth.Miner().Stop(ch)
<-ch <-ch
rewindTemp(eth, rewindTo) rewindTemp(eth, rewindTo)
eth.StartMining(1) eth.StartMining()
} else { } else {
rewindTemp(eth, rewindTo) rewindTemp(eth, rewindTo)

10
tests/bor/helper.go
View file

@ -26,10 +26,10 @@ import (
"github.com/ethereum/go-ethereum/consensus/bor/heimdall" //nolint:typecheck "github.com/ethereum/go-ethereum/consensus/bor/heimdall" //nolint:typecheck
"github.com/ethereum/go-ethereum/consensus/bor/heimdall/span" "github.com/ethereum/go-ethereum/consensus/bor/heimdall/span"
"github.com/ethereum/go-ethereum/consensus/bor/valset" "github.com/ethereum/go-ethereum/consensus/bor/valset"
"github.com/ethereum/go-ethereum/consensus/misc" "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
"github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/txpool" "github.com/ethereum/go-ethereum/core/txpool/legacypool"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
@ -195,7 +195,7 @@ func buildNextBlock(t *testing.T, _bor consensus.Engine, chain *core.BlockChain,
} }
if chain.Config().IsLondon(header.Number) { if chain.Config().IsLondon(header.Number) {
header.BaseFee = misc.CalcBaseFee(chain.Config(), parentBlock.Header()) header.BaseFee = eip1559.CalcBaseFee(chain.Config(), parentBlock.Header())
if !chain.Config().IsLondon(parentBlock.Number()) { if !chain.Config().IsLondon(parentBlock.Number()) {
parentGasLimit := parentBlock.GasLimit() * params.ElasticityMultiplier parentGasLimit := parentBlock.GasLimit() * params.ElasticityMultiplier
@ -223,7 +223,7 @@ func buildNextBlock(t *testing.T, _bor consensus.Engine, chain *core.BlockChain,
block, _ := _bor.FinalizeAndAssemble(ctx, chain, b.header, state, b.txs, nil, b.receipts, []*types.Withdrawal{}) block, _ := _bor.FinalizeAndAssemble(ctx, chain, b.header, state, b.txs, nil, b.receipts, []*types.Withdrawal{})
// Write state changes to db // Write state changes to db
root, err := state.Commit(chain.Config().IsEIP158(b.header.Number), false) root, err := state.Commit(block.NumberU64(), chain.Config().IsEIP158(b.header.Number))
if err != nil { if err != nil {
panic(fmt.Sprintf("state write error: %v", err)) panic(fmt.Sprintf("state write error: %v", err))
} }
@ -468,7 +468,7 @@ func InitMiner(genesis *core.Genesis, privKey *ecdsa.PrivateKey, withoutHeimdall
SyncMode: downloader.FullSync, SyncMode: downloader.FullSync,
DatabaseCache: 256, DatabaseCache: 256,
DatabaseHandles: 256, DatabaseHandles: 256,
TxPool: txpool.DefaultConfig, TxPool: legacypool.DefaultConfig,
GPO: ethconfig.Defaults.GPO, GPO: ethconfig.Defaults.GPO,
Miner: miner.Config{ Miner: miner.Config{
Etherbase: crypto.PubkeyToAddress(privKey.PublicKey), Etherbase: crypto.PubkeyToAddress(privKey.PublicKey),