From 7cbdded64da35027b584cd77aa06fcfab3c68d6e Mon Sep 17 00:00:00 2001 From: ledgerwatch Date: Wed, 27 Apr 2022 16:19:03 +0100 Subject: [PATCH 01/14] Update stageloop.go --- turbo/stages/stageloop.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index a2664a0f8c8..65d6a84ec81 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -309,7 +309,7 @@ func NewStagedSync( nil, controlServer.ChainConfig, controlServer.Engine, - &vm.Config{EnableTEMV: cfg.Prune.Experiments.TEVM}, + &vm.Config{EnableTEMV: cfg.Prune.Experiments.TEVM, TraceJumpDest: true}, notifications.Accumulator, cfg.StateStream, tmpdir, From 9fe44f3c34b8107f17dc3f071e69c5bdf0bea971 Mon Sep 17 00:00:00 2001 From: Alex Sharp Date: Wed, 27 Apr 2022 21:39:11 +0100 Subject: [PATCH 02/14] Print --- consensus/parlia/parlia.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index 89052cdf821..33a77c7fcae 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -557,11 +557,12 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash for i := 0; i < len(headers)/2; i++ { headers[i], headers[len(headers)-1-i] = headers[len(headers)-1-i], headers[i] } - + log.Info("Apply headers to snapshots", "headers", len(headers), "parents", len(parents)) snap, err := snap.apply(headers, chain, parents, p.chainConfig.ChainID) if err != nil { return nil, err } + log.Info("Finished apply") p.recentSnaps.Add(snap.Hash, snap) // If we've generated a new checkpoint snapshot, save to disk From 50c8b5b3000561737c03eb7f3e166d7a26392c25 Mon Sep 17 00:00:00 2001 From: Alexey Sharp Date: Thu, 28 Apr 2022 15:43:59 +0100 Subject: [PATCH 03/14] Consider snapshot headers as parlia checkpoints --- consensus/parlia/parlia.go | 50 ++++++++++++------------ eth/backend.go | 79 +++++++++++++++++++------------------- eth/ethconfig/config.go | 4 +- 3 files changed, 68 insertions(+), 65 deletions(-) diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index 33a77c7fcae..ff7c125b1a9 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -232,14 +232,16 @@ type Parlia struct { slashABI abi.ABI // The fields below are for testing only - fakeDiff bool // Skip difficulty verifications - forks []uint64 // Forks extracted from the chainConfig + fakeDiff bool // Skip difficulty verifications + forks []uint64 // Forks extracted from the chainConfig + snapshotBlocks uint64 // Number of blocks available via snapshots } // New creates a Parlia consensus engine. func New( chainConfig *params.ChainConfig, db kv.RwDB, + snapshotBlocks uint64, ) *Parlia { // get parlia config parliaConfig := chainConfig.Parlia @@ -276,6 +278,7 @@ func New( slashABI: sABI, signer: types.LatestSigner(chainConfig), forks: forkid.GatherForks(chainConfig), + snapshotBlocks: snapshotBlocks, } return c @@ -502,29 +505,28 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash snap = s break } - } - - // If we're at the genesis, snapshot the initial state. - if number == 0 { - checkpoint := chain.GetHeaderByNumber(number) - if checkpoint != nil { - // get checkpoint data - hash := checkpoint.Hash() - - validatorBytes := checkpoint.Extra[extraVanity : len(checkpoint.Extra)-extraSeal] - // get validators from headers - validators, err := ParseValidators(validatorBytes) - if err != nil { - return nil, err + if number <= p.snapshotBlocks || number == 0 { + // Headers included into the snapshots have to be trusted as checkpoints + checkpoint := chain.GetHeaderByNumber(number) + if checkpoint != nil { + // get checkpoint data + hash := checkpoint.Hash() + + validatorBytes := checkpoint.Extra[extraVanity : len(checkpoint.Extra)-extraSeal] + // get validators from headers + validators, err := ParseValidators(validatorBytes) + if err != nil { + return nil, err + } + + // new snapshot + snap = newSnapshot(p.config, p.signatures, number, hash, validators) + if err := snap.store(p.db); err != nil { + return nil, err + } + log.Info("Stored checkpoint snapshot to disk", "number", number, "hash", hash) + break } - - // new snapshot - snap = newSnapshot(p.config, p.signatures, number, hash, validators) - if err := snap.store(p.db); err != nil { - return nil, err - } - log.Info("Stored checkpoint snapshot to disk", "number", number, "hash", hash) - break } } diff --git a/eth/backend.go b/eth/backend.go index 7e946ce153a..62b1798d062 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -21,7 +21,6 @@ import ( "context" "errors" "fmt" - "google.golang.org/protobuf/types/known/emptypb" "math/big" "os" "path/filepath" @@ -30,6 +29,8 @@ import ( "sync" "time" + "google.golang.org/protobuf/types/known/emptypb" + "github.com/holiman/uint256" libcommon "github.com/ledgerwatch/erigon-lib/common" "github.com/ledgerwatch/erigon-lib/direct" @@ -216,44 +217,6 @@ func New(stack *node.Node, config *ethconfig.Config, txpoolCfg txpool2.Config, l } backend.gasPrice, _ = uint256.FromBig(config.Miner.GasPrice) - var consensusConfig interface{} - - if chainConfig.Clique != nil { - consensusConfig = &config.Clique - } else if chainConfig.Aura != nil { - config.Aura.Etherbase = config.Miner.Etherbase - consensusConfig = &config.Aura - } else if chainConfig.Parlia != nil { - consensusConfig = &config.Parlia - } else if chainConfig.Bor != nil { - consensusConfig = &config.Bor - } else { - consensusConfig = &config.Ethash - } - - backend.engine = ethconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, config.HeimdallURL, config.WithoutHeimdall, stack.DataDir()) - - log.Info("Initialising Ethereum protocol", "network", config.NetworkID) - - if err := chainKv.Update(context.Background(), func(tx kv.RwTx) error { - if err = stagedsync.UpdateMetrics(tx); err != nil { - return err - } - - config.Prune, err = prune.EnsureNotChanged(tx, config.Prune) - if err != nil { - return err - } - if err := snapshotsynccli.EnsureNotChanged(tx, config.Snapshot); err != nil { - return err - } - log.Info("Effective", "prune_flags", config.Prune.String(), "snapshot_flags", config.Snapshot.String()) - - return nil - }); err != nil { - return nil, err - } - if config.TxPool.Journal != "" { config.TxPool.Journal = stack.ResolvePath(config.TxPool.Journal) } @@ -341,6 +304,44 @@ func New(stack *node.Node, config *ethconfig.Config, txpoolCfg txpool2.Config, l blockReader = snapshotsync.NewBlockReader() } + var consensusConfig interface{} + + if chainConfig.Clique != nil { + consensusConfig = &config.Clique + } else if chainConfig.Aura != nil { + config.Aura.Etherbase = config.Miner.Etherbase + consensusConfig = &config.Aura + } else if chainConfig.Parlia != nil { + consensusConfig = &config.Parlia + } else if chainConfig.Bor != nil { + consensusConfig = &config.Bor + } else { + consensusConfig = &config.Ethash + } + + backend.engine = ethconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, config.HeimdallURL, config.WithoutHeimdall, stack.DataDir(), allSnapshots.BlocksAvailable()) + + log.Info("Initialising Ethereum protocol", "network", config.NetworkID) + + if err := chainKv.Update(context.Background(), func(tx kv.RwTx) error { + if err = stagedsync.UpdateMetrics(tx); err != nil { + return err + } + + config.Prune, err = prune.EnsureNotChanged(tx, config.Prune) + if err != nil { + return err + } + if err := snapshotsynccli.EnsureNotChanged(tx, config.Snapshot); err != nil { + return err + } + log.Info("Effective", "prune_flags", config.Prune.String(), "snapshot_flags", config.Snapshot.String()) + + return nil + }); err != nil { + return nil, err + } + backend.sentryControlServer, err = sentry.NewControlServer(chainKv, stack.Config().NodeName(), chainConfig, genesis.Hash(), backend.engine, backend.config.NetworkID, backend.sentries, config.BlockDownloaderWindow, blockReader) if err != nil { return nil, err diff --git a/eth/ethconfig/config.go b/eth/ethconfig/config.go index 7885e9e9da3..ed2822e102f 100644 --- a/eth/ethconfig/config.go +++ b/eth/ethconfig/config.go @@ -228,7 +228,7 @@ type Config struct { Ethstats string } -func CreateConsensusEngine(chainConfig *params.ChainConfig, logger log.Logger, config interface{}, notify []string, noverify bool, HeimdallURL string, WithoutHeimdall bool, datadir string) consensus.Engine { +func CreateConsensusEngine(chainConfig *params.ChainConfig, logger log.Logger, config interface{}, notify []string, noverify bool, HeimdallURL string, WithoutHeimdall bool, datadir string, snapshotBlocks uint64) consensus.Engine { var eng consensus.Engine switch consensusCfg := config.(type) { @@ -267,7 +267,7 @@ func CreateConsensusEngine(chainConfig *params.ChainConfig, logger log.Logger, c } case *params.ParliaConfig: if chainConfig.Parlia != nil { - eng = parlia.New(chainConfig, db.OpenDatabase(consensusCfg.DBPath, logger, consensusCfg.InMemory)) + eng = parlia.New(chainConfig, db.OpenDatabase(consensusCfg.DBPath, logger, consensusCfg.InMemory), snapshotBlocks) } case *params.BorConfig: if chainConfig.Bor != nil { From ebfc8665df4223a7bbbdf5ee29523912dfaf1289 Mon Sep 17 00:00:00 2001 From: Alexey Sharp Date: Thu, 28 Apr 2022 16:27:54 +0100 Subject: [PATCH 04/14] Not fail after not loading snapshot --- consensus/parlia/parlia.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index ff7c125b1a9..c076d49ad5d 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -503,7 +503,9 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash if s, err := loadSnapshot(p.config, p.signatures, p.db, number, hash); err == nil { log.Trace("Loaded snapshot from disk", "number", number, "hash", hash) snap = s - break + if snap != nil { + break + } } if number <= p.snapshotBlocks || number == 0 { // Headers included into the snapshots have to be trusted as checkpoints From f6be1f0bdb2231dbcfa2ff17c58fdd6fd45d85c1 Mon Sep 17 00:00:00 2001 From: Alexey Sharp Date: Thu, 28 Apr 2022 16:41:04 +0100 Subject: [PATCH 05/14] Lazy snapshots --- consensus/parlia/parlia.go | 13 +++++++------ eth/backend.go | 2 +- eth/ethconsensusconfig/config.go | 5 +++-- 3 files changed, 11 insertions(+), 9 deletions(-) diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index c076d49ad5d..a2a04a7ef94 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -36,6 +36,7 @@ import ( "github.com/ledgerwatch/erigon/params" "github.com/ledgerwatch/erigon/rlp" "github.com/ledgerwatch/erigon/rpc" + "github.com/ledgerwatch/erigon/turbo/snapshotsync" ) const ( @@ -232,16 +233,16 @@ type Parlia struct { slashABI abi.ABI // The fields below are for testing only - fakeDiff bool // Skip difficulty verifications - forks []uint64 // Forks extracted from the chainConfig - snapshotBlocks uint64 // Number of blocks available via snapshots + fakeDiff bool // Skip difficulty verifications + forks []uint64 // Forks extracted from the chainConfig + snapshots *snapshotsync.RoSnapshots } // New creates a Parlia consensus engine. func New( chainConfig *params.ChainConfig, db kv.RwDB, - snapshotBlocks uint64, + snapshots *snapshotsync.RoSnapshots, ) *Parlia { // get parlia config parliaConfig := chainConfig.Parlia @@ -278,7 +279,7 @@ func New( slashABI: sABI, signer: types.LatestSigner(chainConfig), forks: forkid.GatherForks(chainConfig), - snapshotBlocks: snapshotBlocks, + snapshots: snapshots, } return c @@ -507,7 +508,7 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash break } } - if number <= p.snapshotBlocks || number == 0 { + if (p.snapshots != nil && number <= p.snapshots.BlocksAvailable()) || number == 0 { // Headers included into the snapshots have to be trusted as checkpoints checkpoint := chain.GetHeaderByNumber(number) if checkpoint != nil { diff --git a/eth/backend.go b/eth/backend.go index ce1dbba385e..3de4032cf5a 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -321,7 +321,7 @@ func New(stack *node.Node, config *ethconfig.Config, txpoolCfg txpool2.Config, l consensusConfig = &config.Ethash } - backend.engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, config.HeimdallURL, config.WithoutHeimdall, stack.DataDir(), allSnapshots.BlocksAvailable()) + backend.engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, config.HeimdallURL, config.WithoutHeimdall, stack.DataDir(), allSnapshots) log.Info("Initialising Ethereum protocol", "network", config.NetworkID) diff --git a/eth/ethconsensusconfig/config.go b/eth/ethconsensusconfig/config.go index 09eab9f5eb1..fadd2ab887a 100644 --- a/eth/ethconsensusconfig/config.go +++ b/eth/ethconsensusconfig/config.go @@ -14,10 +14,11 @@ import ( "github.com/ledgerwatch/erigon/consensus/parlia" "github.com/ledgerwatch/erigon/consensus/serenity" "github.com/ledgerwatch/erigon/params" + "github.com/ledgerwatch/erigon/turbo/snapshotsync" "github.com/ledgerwatch/log/v3" ) -func CreateConsensusEngine(chainConfig *params.ChainConfig, logger log.Logger, config interface{}, notify []string, noverify bool, HeimdallURL string, WithoutHeimdall bool, datadir string, snapshotBlocks uint64) consensus.Engine { +func CreateConsensusEngine(chainConfig *params.ChainConfig, logger log.Logger, config interface{}, notify []string, noverify bool, HeimdallURL string, WithoutHeimdall bool, datadir string, snapshots *snapshotsync.RoSnapshots) consensus.Engine { var eng consensus.Engine switch consensusCfg := config.(type) { @@ -56,7 +57,7 @@ func CreateConsensusEngine(chainConfig *params.ChainConfig, logger log.Logger, c } case *params.ParliaConfig: if chainConfig.Parlia != nil { - eng = parlia.New(chainConfig, db.OpenDatabase(consensusCfg.DBPath, logger, consensusCfg.InMemory), snapshotBlocks) + eng = parlia.New(chainConfig, db.OpenDatabase(consensusCfg.DBPath, logger, consensusCfg.InMemory), snapshots) } case *params.BorConfig: if chainConfig.Bor != nil { From da369df4ef6b2984eae26cd5046236440f885688 Mon Sep 17 00:00:00 2001 From: Alexey Sharp Date: Thu, 28 Apr 2022 16:56:11 +0100 Subject: [PATCH 06/14] Print number of validators --- consensus/parlia/parlia.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index a2a04a7ef94..b0816a5ec9a 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -527,7 +527,7 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash if err := snap.store(p.db); err != nil { return nil, err } - log.Info("Stored checkpoint snapshot to disk", "number", number, "hash", hash) + log.Info("Stored checkpoint snapshot to disk", "number", number, "hash", hash, "validators", len(validators)) break } } From d97c69d0a161280b16082857bfbf1855f0433743 Mon Sep 17 00:00:00 2001 From: Alex Sharp Date: Thu, 28 Apr 2022 19:00:50 +0100 Subject: [PATCH 07/14] More printing --- consensus/parlia/parlia.go | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index b0816a5ec9a..68fbf7abbb6 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -509,12 +509,10 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash } } if (p.snapshots != nil && number <= p.snapshots.BlocksAvailable()) || number == 0 { + log.Info("Constructing checkpoint", "number", number, "checkpointInterval", checkpointInterval, "blocksAvailble", p.snapshots.BlocksAvailable()) // Headers included into the snapshots have to be trusted as checkpoints - checkpoint := chain.GetHeaderByNumber(number) + checkpoint := chain.GetHeader(hash, number) if checkpoint != nil { - // get checkpoint data - hash := checkpoint.Hash() - validatorBytes := checkpoint.Extra[extraVanity : len(checkpoint.Extra)-extraSeal] // get validators from headers validators, err := ParseValidators(validatorBytes) From d7b32e541d246618fc70d07f2ee340e21d8d495f Mon Sep 17 00:00:00 2001 From: Alex Sharp Date: Thu, 28 Apr 2022 19:18:12 +0100 Subject: [PATCH 08/14] Use epoch instead of checkpoint interval --- consensus/parlia/parlia.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index 68fbf7abbb6..8fa63dc6390 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -508,8 +508,10 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash break } } + } + if number%p.config.Epoch == 0 { if (p.snapshots != nil && number <= p.snapshots.BlocksAvailable()) || number == 0 { - log.Info("Constructing checkpoint", "number", number, "checkpointInterval", checkpointInterval, "blocksAvailble", p.snapshots.BlocksAvailable()) + log.Info("Constructing checkpoint", "number", number, "epoch", p.config.Epoch, "blocksAvailble", p.snapshots.BlocksAvailable()) // Headers included into the snapshots have to be trusted as checkpoints checkpoint := chain.GetHeader(hash, number) if checkpoint != nil { From 67b3b5df68cbb0930347fce43706a215260ebd26 Mon Sep 17 00:00:00 2001 From: Alex Sharp Date: Thu, 28 Apr 2022 19:23:49 +0100 Subject: [PATCH 09/14] Reduce logging --- consensus/parlia/parlia.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index 8fa63dc6390..c2c94fabeb1 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -511,7 +511,6 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash } if number%p.config.Epoch == 0 { if (p.snapshots != nil && number <= p.snapshots.BlocksAvailable()) || number == 0 { - log.Info("Constructing checkpoint", "number", number, "epoch", p.config.Epoch, "blocksAvailble", p.snapshots.BlocksAvailable()) // Headers included into the snapshots have to be trusted as checkpoints checkpoint := chain.GetHeader(hash, number) if checkpoint != nil { @@ -562,12 +561,10 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash for i := 0; i < len(headers)/2; i++ { headers[i], headers[len(headers)-1-i] = headers[len(headers)-1-i], headers[i] } - log.Info("Apply headers to snapshots", "headers", len(headers), "parents", len(parents)) snap, err := snap.apply(headers, chain, parents, p.chainConfig.ChainID) if err != nil { return nil, err } - log.Info("Finished apply") p.recentSnaps.Add(snap.Hash, snap) // If we've generated a new checkpoint snapshot, save to disk From 88eeb0d032f86162f4230c91303d03e4c28a8960 Mon Sep 17 00:00:00 2001 From: Alex Sharp Date: Thu, 28 Apr 2022 19:29:34 +0100 Subject: [PATCH 10/14] Fix compilation --- cmd/integration/commands/stages.go | 8 ++++---- cmd/state/commands/erigon2.go | 17 ++++++++--------- 2 files changed, 12 insertions(+), 13 deletions(-) diff --git a/cmd/integration/commands/stages.go b/cmd/integration/commands/stages.go index 2193121bfc0..967e7b790ba 100644 --- a/cmd/integration/commands/stages.go +++ b/cmd/integration/commands/stages.go @@ -1187,15 +1187,15 @@ func newSync(ctx context.Context, db kv.RwDB, miningConfig *params.MiningConfig) if chainConfig.Clique != nil { c := params.CliqueSnapshot c.DBPath = filepath.Join(datadir, "clique", "db") - engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, c, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, allSn.BlocksAvailable()) + engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, c, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, allSn) } else if chainConfig.Aura != nil { - engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, ¶ms.AuRaConfig{DBPath: filepath.Join(datadir, "aura")}, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, allSn.BlocksAvailable()) + engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, ¶ms.AuRaConfig{DBPath: filepath.Join(datadir, "aura")}, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, allSn) } else if chainConfig.Parlia != nil { consensusConfig := ¶ms.ParliaConfig{DBPath: filepath.Join(datadir, "parlia")} - engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, allSn.BlocksAvailable()) + engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, allSn) } else if chainConfig.Bor != nil { consensusConfig := &config.Bor - engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, HeimdallURL, false, datadir, allSn.BlocksAvailable()) + engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, HeimdallURL, false, datadir, allSn) } else { //ethash engine = ethash.NewFaker() } diff --git a/cmd/state/commands/erigon2.go b/cmd/state/commands/erigon2.go index 3778f8ec56f..6526c342776 100644 --- a/cmd/state/commands/erigon2.go +++ b/cmd/state/commands/erigon2.go @@ -206,17 +206,16 @@ func Erigon2(genesis *core.Genesis, chainConfig *params.ChainConfig, logger log. }() var blockReader interfaces.FullBlockReader - var snapshotBlocks uint64 + var allSnapshots *snapshotsync.RoSnapshots syncMode := ethconfig.SyncModeByChainName(chainConfig.ChainName, syncmodeCli) if syncMode == ethconfig.SnapSync { - allSnapshots := snapshotsync.NewRoSnapshots(ethconfig.NewSnapshotCfg(true, false), path.Join(datadir, "snapshots")) - snapshotBlocks = allSnapshots.BlocksAvailable() + allSnapshots = snapshotsync.NewRoSnapshots(ethconfig.NewSnapshotCfg(true, false), path.Join(datadir, "snapshots")) defer allSnapshots.Close() blockReader = snapshotsync.NewBlockReaderWithSnapshots(allSnapshots) } else { blockReader = snapshotsync.NewBlockReader() } - engine := initConsensusEngine(chainConfig, logger, snapshotBlocks) + engine := initConsensusEngine(chainConfig, logger, allSnapshots) for !interrupt { blockNum++ @@ -600,23 +599,23 @@ func (ww *WriterWrapper) CreateContract(address common.Address) error { return nil } -func initConsensusEngine(chainConfig *params.ChainConfig, logger log.Logger, snapshotBlocks uint64) (engine consensus.Engine) { +func initConsensusEngine(chainConfig *params.ChainConfig, logger log.Logger, snapshots *snapshotsync.RoSnapshots) (engine consensus.Engine) { config := ethconfig.Defaults switch { case chainConfig.Clique != nil: c := params.CliqueSnapshot c.DBPath = filepath.Join(datadir, "clique", "db") - engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, c, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, snapshotBlocks) + engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, c, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, snapshots) case chainConfig.Aura != nil: consensusConfig := ¶ms.AuRaConfig{DBPath: filepath.Join(datadir, "aura")} - engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, snapshotBlocks) + engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, snapshots) case chainConfig.Parlia != nil: consensusConfig := ¶ms.ParliaConfig{DBPath: filepath.Join(datadir, "parlia")} - engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, snapshotBlocks) + engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, "", true, datadir, snapshots) case chainConfig.Bor != nil: consensusConfig := &config.Bor - engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, "http://localhost:1317", false, datadir, snapshotBlocks) + engine = ethconsensusconfig.CreateConsensusEngine(chainConfig, logger, consensusConfig, config.Miner.Notify, config.Miner.Noverify, "http://localhost:1317", false, datadir, snapshots) default: //ethash engine = ethash.NewFaker() } From 50f8c92f2e415b0766b73902a9d7df90d2f94795 Mon Sep 17 00:00:00 2001 From: Alex Sharp Date: Thu, 28 Apr 2022 19:37:54 +0100 Subject: [PATCH 11/14] Remove trace jump dest --- turbo/stages/stageloop.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index 65d6a84ec81..a2664a0f8c8 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -309,7 +309,7 @@ func NewStagedSync( nil, controlServer.ChainConfig, controlServer.Engine, - &vm.Config{EnableTEMV: cfg.Prune.Experiments.TEVM, TraceJumpDest: true}, + &vm.Config{EnableTEMV: cfg.Prune.Experiments.TEVM}, notifications.Accumulator, cfg.StateStream, tmpdir, From bf79b68936900bf0a1bb8d3429dafb4f5b0e7b69 Mon Sep 17 00:00:00 2001 From: Alex Sharp Date: Thu, 28 Apr 2022 20:12:58 +0100 Subject: [PATCH 12/14] Fix lint --- cmd/integration/commands/stages.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/integration/commands/stages.go b/cmd/integration/commands/stages.go index 967e7b790ba..5b7fb5e9081 100644 --- a/cmd/integration/commands/stages.go +++ b/cmd/integration/commands/stages.go @@ -1149,7 +1149,7 @@ func newSync(ctx context.Context, db kv.RwDB, miningConfig *params.MiningConfig) } vmConfig := &vm.Config{} - genesis, chainConfig := byChain(chain) + genesis, _ := byChain(chain) events := privateapi.NewEvents() From b995f826ef3dc07f7a45b76ba01cf01d1bb6eca9 Mon Sep 17 00:00:00 2001 From: Alex Sharp Date: Thu, 28 Apr 2022 20:41:09 +0100 Subject: [PATCH 13/14] Not store snapshots every epoch --- consensus/parlia/parlia.go | 5 ----- 1 file changed, 5 deletions(-) diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index c2c94fabeb1..969fb719675 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -520,13 +520,8 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash if err != nil { return nil, err } - // new snapshot snap = newSnapshot(p.config, p.signatures, number, hash, validators) - if err := snap.store(p.db); err != nil { - return nil, err - } - log.Info("Stored checkpoint snapshot to disk", "number", number, "hash", hash, "validators", len(validators)) break } } From f70cb7d680f4dfbc8eea804977b53433009943a2 Mon Sep 17 00:00:00 2001 From: Alex Sharp Date: Thu, 28 Apr 2022 22:29:53 +0100 Subject: [PATCH 14/14] Separate snapshot for verification and finalisation --- consensus/parlia/api.go | 8 ++++---- consensus/parlia/parlia.go | 22 +++++++++++----------- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/consensus/parlia/api.go b/consensus/parlia/api.go index 05aaeefed70..fbcec09e6e6 100644 --- a/consensus/parlia/api.go +++ b/consensus/parlia/api.go @@ -42,7 +42,7 @@ func (api *API) GetSnapshot(number *rpc.BlockNumber) (*Snapshot, error) { if header == nil { return nil, errUnknownBlock } - return api.parlia.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil) + return api.parlia.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil, false /* verify */) } // GetSnapshotAtHash retrieves the state snapshot at a given block. @@ -51,7 +51,7 @@ func (api *API) GetSnapshotAtHash(hash common.Hash) (*Snapshot, error) { if header == nil { return nil, errUnknownBlock } - return api.parlia.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil) + return api.parlia.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil, false /* verify */) } // GetValidators retrieves the list of validators at the specified block. @@ -67,7 +67,7 @@ func (api *API) GetValidators(number *rpc.BlockNumber) ([]common.Address, error) if header == nil { return nil, errUnknownBlock } - snap, err := api.parlia.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil) + snap, err := api.parlia.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil, false /* verify */) if err != nil { return nil, err } @@ -80,7 +80,7 @@ func (api *API) GetValidatorsAtHash(hash common.Hash) ([]common.Address, error) if header == nil { return nil, errUnknownBlock } - snap, err := api.parlia.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil) + snap, err := api.parlia.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil, false /* verify */) if err != nil { return nil, err } diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go index 969fb719675..d1ca6701cca 100644 --- a/consensus/parlia/parlia.go +++ b/consensus/parlia/parlia.go @@ -396,7 +396,7 @@ func (p *Parlia) verifyCascadingFields(chain consensus.ChainHeaderReader, header return consensus.ErrUnknownAncestor } - snap, err := p.snapshot(chain, number-1, header.ParentHash, parents) + snap, err := p.snapshot(chain, number-1, header.ParentHash, parents, true /* verify */) if err != nil { return err } @@ -442,7 +442,7 @@ func (p *Parlia) verifySeal(chain consensus.ChainHeaderReader, header *types.Hea return errUnknownBlock } // Retrieve the snapshot needed to verify this header and cache it - snap, err := p.snapshot(chain, number-1, header.ParentHash, parents) + snap, err := p.snapshot(chain, number-1, header.ParentHash, parents, true /* verify */) if err != nil { return err } @@ -485,7 +485,7 @@ func (p *Parlia) verifySeal(chain consensus.ChainHeaderReader, header *types.Hea } // snapshot retrieves the authorization snapshot at a given point in time. -func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash common.Hash, parents []*types.Header) (*Snapshot, error) { +func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash common.Hash, parents []*types.Header, verify bool) (*Snapshot, error) { // Search for a snapshot in memory or on disk for checkpoints var ( headers []*types.Header @@ -504,12 +504,12 @@ func (p *Parlia) snapshot(chain consensus.ChainHeaderReader, number uint64, hash if s, err := loadSnapshot(p.config, p.signatures, p.db, number, hash); err == nil { log.Trace("Loaded snapshot from disk", "number", number, "hash", hash) snap = s - if snap != nil { + if !verify || snap != nil { break } } } - if number%p.config.Epoch == 0 { + if (verify && number%p.config.Epoch == 0) || number == 0 { if (p.snapshots != nil && number <= p.snapshots.BlocksAvailable()) || number == 0 { // Headers included into the snapshots have to be trusted as checkpoints checkpoint := chain.GetHeader(hash, number) @@ -588,7 +588,7 @@ func (p *Parlia) Prepare(chain consensus.ChainHeaderReader, header *types.Header header.Nonce = types.BlockNonce{} number := header.Number.Uint64() - snap, err := p.snapshot(chain, number-1, header.ParentHash, nil) + snap, err := p.snapshot(chain, number-1, header.ParentHash, nil, false /* verify */) if err != nil { return err } @@ -683,7 +683,7 @@ func (p *Parlia) finalize(header *types.Header, state *state.IntraBlockState, tx txs = userTxs // warn if not in majority fork number := header.Number.Uint64() - snap, err := p.snapshot(chain, number-1, header.ParentHash, nil) + snap, err := p.snapshot(chain, number-1, header.ParentHash, nil, false /* verify */) if err != nil { return nil, nil, err } @@ -803,7 +803,7 @@ func (p *Parlia) Seal(chain consensus.ChainHeaderReader, block *types.Block, res val, signFn := p.val, p.signFn p.lock.RUnlock() - snap, err := p.snapshot(chain, number-1, header.ParentHash, nil) + snap, err := p.snapshot(chain, number-1, header.ParentHash, nil, false /* verify */) if err != nil { return err } @@ -873,7 +873,7 @@ func (p *Parlia) SealHash(header *types.Header) common.Hash { // CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty // that a new block should have. func (p *Parlia) CalcDifficulty(chain consensus.ChainHeaderReader, time, parentTime uint64, parentDifficulty *big.Int, parentNumber uint64, parentHash, parentUncleHash common.Hash, parentSeal []rlp.RawValue) *big.Int { - snap, err := p.snapshot(chain, parentNumber, parentHash, nil) + snap, err := p.snapshot(chain, parentNumber, parentHash, nil, false /* verify */) if err != nil { return nil } @@ -948,7 +948,7 @@ func (p *Parlia) shouldWaitForCurrentBlockProcess(chain consensus.ChainHeaderRea } func (p *Parlia) EnoughDistance(chain consensus.ChainReader, header *types.Header) bool { - snap, err := p.snapshot(chain, header.Number.Uint64()-1, header.ParentHash, nil) + snap, err := p.snapshot(chain, header.Number.Uint64()-1, header.ParentHash, nil, false /* verify */) if err != nil { return true } @@ -960,7 +960,7 @@ func (p *Parlia) IsLocalBlock(header *types.Header) bool { } func (p *Parlia) AllowLightProcess(chain consensus.ChainReader, currentHeader *types.Header) bool { - snap, err := p.snapshot(chain, currentHeader.Number.Uint64()-1, currentHeader.ParentHash, nil) + snap, err := p.snapshot(chain, currentHeader.Number.Uint64()-1, currentHeader.ParentHash, nil, false /* verify */) if err != nil { return true }