core,eth,tests,trie: abstract node scheme, and contruct database (#578)

* core,eth,tests,trie: abstract node scheme, and contruct database
interface instead of keyvalue for supporting storing diff reverse data
in ancient

* stacktrie,core,eth: port the changes in stacktries, track the path prefix of nodes when commits,  use ethdb.Database for constructing trie.Database, it's not necessary right now, but it's required for path-based used to open reverse diff freezer

* core,trie: add scheme and resolvepath logic

cmd/ronin/chaincmd.go

@@ -38,6 +38,7 @@ import (
  "github.com/ethereum/go-ethereum/log"
  "github.com/ethereum/go-ethereum/metrics"
  "github.com/ethereum/go-ethereum/node"
+ "github.com/ethereum/go-ethereum/trie"
  "github.com/urfave/cli/v2"
 )
 
@@ -224,7 +225,11 @@ func initGenesis(ctx *cli.Context) error {
  if err != nil {
  utils.Fatalf("Failed to open database: %v", err)
  }
- _, hash, err := core.SetupGenesisBlock(chaindb, genesis, overrideChainConfig)
+ // Create triedb firstly
+ triedb := trie.NewDatabaseWithConfig(chaindb, &trie.Config{
+ Preimages: ctx.Bool(utils.CachePreimagesFlag.Name),
+ })
+ _, hash, err := core.SetupGenesisBlock(chaindb, triedb, genesis, overrideChainConfig)
  if err != nil {
  utils.Fatalf("Failed to write genesis block: %v", err)
  }
@@ -466,7 +471,10 @@ func dump(ctx *cli.Context) error {
  if err != nil {
  return err
  }
- state, err := state.New(root, state.NewDatabase(db), nil)
+ config := &trie.Config{
+ Preimages: true, // always enable preimage lookup
+ }
+ state, err := state.New(root, state.NewDatabaseWithConfig(db, config), nil)
  if err != nil {
  return err
  }

core/blockchain.go

@@ -175,6 +175,7 @@ type BlockChain struct {
  snaps *snapshot.Tree // Snapshot tree for fast trie leaf access
  triegc *prque.Prque // Priority queue mapping block numbers to tries to gc
  gcproc time.Duration // Accumulates canonical block processing for trie dumping
+ triedb *trie.Database // The database handler for maintaining trie nodes.
 
  // txLookupLimit is the maximum number of blocks from head whose tx indices
  // are reserved:
@@ -257,7 +258,19 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
  internalTxsCache, _ := lru.New[common.Hash, []*types.InternalTransaction](internalTxsCacheLimit)
 
  blobSidecarsCache, _ := lru.New[common.Hash, types.BlobSidecars](blobSidecarsCacheLimit)
- chainConfig, genesisHash, genesisErr := SetupGenesisBlockWithOverride(db, genesis, overrideArrowGlacier, false)
+
+ // Open trie database with provided config
+ triedb := trie.NewDatabaseWithConfig(
+ db,
+ &trie.Config{
+ Cache: cacheConfig.TrieCleanLimit,
+ Journal: cacheConfig.TrieCleanJournal,
+ Preimages: cacheConfig.Preimages,
+ })
+ // Setup the genesis block, commit the provided genesis specification
+ // to database if the genesis block is not present yet, or load the
+ // stored one from database.
+ chainConfig, genesisHash, genesisErr := SetupGenesisBlockWithOverride(db, triedb, genesis, overrideArrowGlacier, false)
  if _, ok := genesisErr.(*params.ConfigCompatError); genesisErr != nil && !ok {
  return nil, genesisErr
  }
@@ -267,6 +280,7 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
  chainConfig: chainConfig,
  cacheConfig: cacheConfig,
  db: db,
+ triedb: triedb,
  triegc: prque.New(nil),
  stateCache: state.NewDatabaseWithConfig(db, &trie.Config{
  Cache: cacheConfig.TrieCleanLimit,
@@ -290,6 +304,7 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 
  blobSidecarsCache: blobSidecarsCache,
  }
+ bc.stateCache = state.NewDatabaseWithNodeDB(bc.db, bc.triedb)
  bc.validator = NewBlockValidator(chainConfig, bc, engine)
  bc.prefetcher = newStatePrefetcher(chainConfig, bc, engine)
  bc.processor = NewStateProcessor(chainConfig, bc, engine)
@@ -326,7 +341,7 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 
  // Make sure the state associated with the block is available
  head := bc.CurrentBlock()
- if _, err := state.New(head.Root(), bc.stateCache, bc.snaps); err != nil {
+ if !bc.HasState(head.Root()) {
  // Head state is missing, before the state recovery, find out the
  // disk layer point of snapshot(if it's enabled). Make sure the
  // rewound point is lower than disk layer.
@@ -410,11 +425,12 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
  var recover bool
 
  head := bc.CurrentBlock()
- if layer := rawdb.ReadSnapshotRecoveryNumber(bc.db); layer != nil && *layer > head.NumberU64() {
+ // If we rewind the chain state to disk layer, then in this case recovery mode should be enabled.
+ if layer := rawdb.ReadSnapshotRecoveryNumber(bc.db); layer != nil && *layer >= head.NumberU64() {
  log.Warn("Enabling snapshot recovery", "chainhead", head.NumberU64(), "diskbase", *layer)
  recover = true
  }
- bc.snaps, _ = snapshot.New(bc.db, bc.stateCache.TrieDB(), bc.cacheConfig.SnapshotLimit, head.Root(), !bc.cacheConfig.SnapshotWait, true, recover)
+ bc.snaps, _ = snapshot.New(bc.db, bc.triedb, bc.cacheConfig.SnapshotLimit, head.Root(), !bc.cacheConfig.SnapshotWait, true, recover)
  }
 
  // Start future block processor.
@@ -435,11 +451,10 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
  log.Warn("Sanitizing invalid trie cache journal time", "provided", bc.cacheConfig.TrieCleanRejournal, "updated", time.Minute)
  bc.cacheConfig.TrieCleanRejournal = time.Minute
  }
- triedb := bc.stateCache.TrieDB()
  bc.wg.Add(1)
  go func() {
  defer bc.wg.Done()
- triedb.SaveCachePeriodically(bc.cacheConfig.TrieCleanJournal, bc.cacheConfig.TrieCleanRejournal, bc.quit)
+ bc.triedb.SaveCachePeriodically(bc.cacheConfig.TrieCleanJournal, bc.cacheConfig.TrieCleanRejournal, bc.quit)
  }()
  }
 
@@ -692,7 +707,7 @@ func (bc *BlockChain) setHeadBeyondRoot(head uint64, root common.Hash, repair bo
  // if the historical chain pruning is enabled. In that case the logic
  // needs to be improved here.
  if !bc.HasState(bc.genesisBlock.Root()) {
- if err := CommitGenesisState(bc.db, bc.genesisBlock.Hash()); err != nil {
+ if err := CommitGenesisState(bc.db, bc.triedb, bc.genesisBlock.Hash()); err != nil {
  log.Crit("Failed to commit genesis state", "err", err)
  }
  log.Debug("Recommitted genesis state to disk")
@@ -793,7 +808,7 @@ func (bc *BlockChain) FastSyncCommitHead(hash common.Hash) error {
  if block == nil {
  return fmt.Errorf("non existent block [%x..]", hash[:4])
  }
- if _, err := trie.NewSecure(common.Hash{}, block.Root(), bc.stateCache.TrieDB()); err != nil {
+ if _, err := trie.NewSecure(common.Hash{}, block.Root(), bc.triedb); err != nil {
  return err
  }
 
@@ -980,7 +995,7 @@ func (bc *BlockChain) Stop() {
  // - HEAD-1: So we don't do large reorgs if our HEAD becomes an uncle
  // - HEAD-127: So we have a hard limit on the number of blocks reexecuted
  if !bc.cacheConfig.TrieDirtyDisabled {
- triedb := bc.stateCache.TrieDB()
+ triedb := bc.triedb
 
  for _, offset := range []uint64{0, 1, uint64(bc.cacheConfig.TriesInMemory) - 1} {
  if number := bc.CurrentBlock().NumberU64(); number > offset {
@@ -1008,8 +1023,7 @@ func (bc *BlockChain) Stop() {
  // Ensure all live cached entries be saved into disk, so that we can skip
  // cache warmup when node restarts.
  if bc.cacheConfig.TrieCleanJournal != "" {
- triedb := bc.stateCache.TrieDB()
- triedb.SaveCache(bc.cacheConfig.TrieCleanJournal)
+ bc.triedb.SaveCache(bc.cacheConfig.TrieCleanJournal)
  }
  log.Info("Blockchain stopped")
 }
@@ -1549,27 +1563,26 @@ func (bc *BlockChain) writeBlockWithState(
  if err != nil {
  return NonStatTy, err
  }
- triedb := bc.stateCache.TrieDB()
 
  // If we're running an archive node, always flush
  if bc.cacheConfig.TrieDirtyDisabled {
- if err := triedb.Commit(root, false, nil); err != nil {
+ if err := bc.triedb.Commit(root, false, nil); err != nil {
  return NonStatTy, err
  }
  } else {
  // Full but not archive node, do proper garbage collection
- triedb.Reference(root, common.Hash{}) // metadata reference to keep trie alive
+ bc.triedb.Reference(root, common.Hash{}) // metadata reference to keep trie alive
  bc.triegc.Push(root, -int64(block.NumberU64()))
 
  triesInMemory := uint64(bc.cacheConfig.TriesInMemory)
  if current := block.NumberU64(); current > triesInMemory {
  // If we exceeded our memory allowance, flush matured singleton nodes to disk
  var (
- nodes, imgs = triedb.Size()
+ nodes, imgs = bc.triedb.Size()
  limit = common.StorageSize(bc.cacheConfig.TrieDirtyLimit) * 1024 * 1024
  )
  if nodes > limit || imgs > 4*1024*1024 {
- triedb.Cap(limit - ethdb.IdealBatchSize)
+ bc.triedb.Cap(limit - ethdb.IdealBatchSize)
  }
  // Find the next state trie we need to commit
  chosen := current - triesInMemory
@@ -1593,7 +1606,7 @@ func (bc *BlockChain) writeBlockWithState(
  )
  }
  // Flush an entire trie and restart the counters
- triedb.Commit(header.Root, true, nil)
+ bc.triedb.Commit(header.Root, true, nil)
  lastWrite = chosen
  bc.gcproc = 0
  }
@@ -1605,7 +1618,7 @@ func (bc *BlockChain) writeBlockWithState(
  bc.triegc.Push(root, number)
  break
  }
- triedb.Dereference(root.(common.Hash))
+ bc.triedb.Dereference(root.(common.Hash))
  }
  }
  }
@@ -2041,7 +2054,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool, sidecars
  stats.processed++
  stats.usedGas += usedGas
 
- dirty, _ := bc.stateCache.TrieDB().Size()
+ dirty, _ := bc.triedb.Size()
  stats.report(chain, it.index, dirty)
  }
 

core/blockchain_reader.go

@@ -29,6 +29,7 @@ import (
  "github.com/ethereum/go-ethereum/event"
  "github.com/ethereum/go-ethereum/params"
  "github.com/ethereum/go-ethereum/rlp"
+ "github.com/ethereum/go-ethereum/trie"
 )
 
 // CurrentHeader retrieves the current head header of the canonical chain. The
@@ -325,6 +326,11 @@ func (bc *BlockChain) TrieNode(hash common.Hash) ([]byte, error) {
  return bc.stateCache.TrieDB().Node(hash)
 }
 
+// TrieDB retrieves the low level trie database used for data storage.
+func (bc *BlockChain) TrieDB() *trie.Database {
+ return bc.triedb
+}
+
 // ContractCode retrieves a blob of data associated with a contract hash
 // either from ephemeral in-memory cache, or from persistent storage.
 func (bc *BlockChain) ContractCode(hash common.Hash) ([]byte, error) {

core/chain_makers.go

@@ -362,10 +362,7 @@ func generateChain(
 // then generate chain on top.
 func GenerateChainWithGenesis(genesis *Genesis, engine consensus.Engine, n int, gen func(int, *BlockGen)) (ethdb.Database, []*types.Block, []types.Receipts) {
  db := rawdb.NewMemoryDatabase()
- _, err := genesis.Commit(db)
- if err != nil {
- panic(err)
- }
+ genesis.MustCommit(db)
  blocks, receipts := GenerateChain(genesis.Config, genesis.ToBlock(), engine, db, n, gen, true)
  return db, blocks, receipts
 }

core/genesis.go

@@ -103,8 +103,8 @@ func (ga *GenesisAlloc) deriveHash() (common.Hash, error) {
 // flush is very similar with deriveHash, but the main difference is
 // all the generated states will be persisted into the given database.
 // Also, the genesis state specification will be flushed as well.
-func (ga *GenesisAlloc) flush(db ethdb.Database) error {
- statedb, err := state.New(common.Hash{}, state.NewDatabase(db), nil)
+func (ga *GenesisAlloc) flush(db ethdb.Database, triedb *trie.Database) error {
+ statedb, err := state.New(common.Hash{}, state.NewDatabaseWithNodeDB(db, triedb), nil)
  if err != nil {
  return err
  }
@@ -116,14 +116,18 @@ func (ga *GenesisAlloc) flush(db ethdb.Database) error {
  statedb.SetState(addr, key, value)
  }
  }
+ // Commit current state, return the root hash.
  root, err := statedb.Commit(false)
  if err != nil {
  return err
  }
- err = statedb.Database().TrieDB().Commit(root, true, nil)
- if err != nil {
- return err
+ // Commit newly generated states into disk if it's not empty.
+ if root != types.EmptyRootHash {
+ if err := triedb.Commit(root, true, nil); err != nil {
+ return err
+ }
  }
+
  // Marshal the genesis state specification and persist.
  blob, err := json.Marshal(ga)
  if err != nil {
@@ -134,8 +138,8 @@ func (ga *GenesisAlloc) flush(db ethdb.Database) error {
 }
 
 // CommitGenesisState loads the stored genesis state with the given block
-// hash and commits them into the given database handler.
-func CommitGenesisState(db ethdb.Database, hash common.Hash) error {
+// hash and commits it into the provided database handler.
+func CommitGenesisState(db ethdb.Database, triedb *trie.Database, hash common.Hash) error {
  var alloc GenesisAlloc
  blob := rawdb.ReadGenesisStateSpec(db, hash)
  if len(blob) != 0 {
@@ -167,7 +171,7 @@ func CommitGenesisState(db ethdb.Database, hash common.Hash) error {
  return errors.New("not found")
  }
  }
- return alloc.flush(db)
+ return alloc.flush(db, triedb)
 }
 
 // GenesisAccount is an account in the state of the genesis block.
@@ -244,14 +248,15 @@ func (e *GenesisMismatchError) Error() string {
 // error is a *params.ConfigCompatError and the new, unwritten config is returned.
 //
 // The returned chain configuration is never nil.
-func SetupGenesisBlock(db ethdb.Database, genesis *Genesis, overrideGenesis bool) (*params.ChainConfig, common.Hash, error) {
- return SetupGenesisBlockWithOverride(db, genesis, nil, overrideGenesis)
+func SetupGenesisBlock(db ethdb.Database, triedb *trie.Database, genesis *Genesis, overrideGenesis bool) (*params.ChainConfig, common.Hash, error) {
+ return SetupGenesisBlockWithOverride(db, triedb, genesis, nil, overrideGenesis)
 }
 
-func SetupGenesisBlockWithOverride(db ethdb.Database, genesis *Genesis, overrideArrowGlacier *big.Int, forceOverrideChainConfig bool) (*params.ChainConfig, common.Hash, error) {
+func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *trie.Database, genesis *Genesis, overrideArrowGlacier *big.Int, forceOverrideChainConfig bool) (*params.ChainConfig, common.Hash, error) {
  if genesis != nil && genesis.Config == nil {
  return params.AllEthashProtocolChanges, common.Hash{}, errGenesisNoConfig
  }
+
  // Just commit the new block if there is no stored genesis block.
  stored := rawdb.ReadCanonicalHash(db, 0)
  if (stored == common.Hash{}) {
@@ -261,7 +266,7 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, genesis *Genesis, override
  } else {
  log.Info("Writing custom genesis block")
  }
- block, err := genesis.Commit(db)
+ block, err := genesis.Commit(db, triedb)
  if err != nil {
  return genesis.Config, common.Hash{}, err
  }
@@ -270,7 +275,7 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, genesis *Genesis, override
  // We have the genesis block in database(perhaps in ancient database)
  // but the corresponding state is missing.
  header := rawdb.ReadHeader(db, stored, 0)
- if _, err := state.New(header.Root, state.NewDatabaseWithConfig(db, nil), nil); err != nil {
+ if _, err := state.New(header.Root, state.NewDatabaseWithNodeDB(db, triedb), nil); err != nil {
  if genesis == nil {
  genesis = DefaultGenesisBlock()
  }
@@ -279,7 +284,7 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, genesis *Genesis, override
  if hash != stored {
  return genesis.Config, hash, &GenesisMismatchError{stored, hash}
  }
- block, err := genesis.Commit(db)
+ block, err := genesis.Commit(db, triedb)
  if err != nil {
  return genesis.Config, hash, err
  }
@@ -410,7 +415,7 @@ func (g *Genesis) ToBlock() *types.Block {
 
 // Commit writes the block and state of a genesis specification to the database.
 // The block is committed as the canonical head block.
-func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error) {
+func (g *Genesis) Commit(db ethdb.Database, triedb *trie.Database) (*types.Block, error) {
  block := g.ToBlock()
  if block.Number().Sign() != 0 {
  return nil, errors.New("can't commit genesis block with number > 0")
@@ -428,7 +433,7 @@ func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error) {
  // All the checks has passed, flush the states derived from the genesis
  // specification as well as the specification itself into the provided
  // database.
- if err := g.Alloc.flush(db); err != nil {
+ if err := g.Alloc.flush(db, triedb); err != nil {
  return nil, err
  }
  rawdb.WriteTd(db, block.Hash(), block.NumberU64(), block.Difficulty())
@@ -445,7 +450,7 @@ func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error) {
 // MustCommit writes the genesis block and state to db, panicking on error.
 // The block is committed as the canonical head block.
 func (g *Genesis) MustCommit(db ethdb.Database) *types.Block {
- block, err := g.Commit(db)
+ block, err := g.Commit(db, trie.NewDatabase(db))
  if err != nil {
  panic(err)
  }