+ "sort"

+ "github.com/ava-labs/coreth/core/state/snapshot"

+ "github.com/ethereum/go-ethereum/common"

+ "github.com/ethereum/go-ethereum/common/mclock"

+ "github.com/ethereum/go-ethereum/common/prque"

+ "github.com/ethereum/go-ethereum/ethdb"

+ "github.com/ethereum/go-ethereum/event"

+ "github.com/ethereum/go-ethereum/log"

+ "github.com/ethereum/go-ethereum/metrics"

+ "github.com/ethereum/go-ethereum/rlp"

+ "github.com/ethereum/go-ethereum/trie"

+ lru "github.com/hashicorp/golang-lru"

+ snapshotAccountReadTimer = metrics.NewRegisteredTimer("chain/snapshot/account/reads", nil)

+ snapshotStorageReadTimer = metrics.NewRegisteredTimer("chain/snapshot/storage/reads", nil)

+ snapshotCommitTimer = metrics.NewRegisteredTimer("chain/snapshot/commits", nil)

+

+

+ blockReorgMeter = metrics.NewRegisteredMeter("chain/reorg/executes", nil)

+ blockReorgAddMeter = metrics.NewRegisteredMeter("chain/reorg/add", nil)

+ blockReorgDropMeter = metrics.NewRegisteredMeter("chain/reorg/drop", nil)

+ blockReorgInvalidatedTx = metrics.NewRegisteredMeter("chain/reorg/invalidTx", nil)

+ // - Version 8

+ // The following incompatible database changes were added:

+ // * New scheme for contract code in order to separate the codes and trie nodes

+ BlockChainVersion uint64 = 8

+ TrieCleanJournal string // Disk journal for saving clean cache entries.

+ TrieCleanRejournal time.Duration // Time interval to dump clean cache to disk periodically

+ SnapshotLimit int // Memory allowance (MB) to use for caching snapshot entries in memory

+

+ 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

+// user (also used during testing).

+var defaultCacheConfig = &CacheConfig{

+ TrieCleanLimit: 256,

+ TrieDirtyLimit: 256,

+ TrieTimeLimit: 5 * time.Minute,

+ SnapshotLimit: 256,

+ SnapshotWait: true,

+ snaps *snapshot.Tree // Snapshot tree for fast trie leaf access

+ // txLookupLimit is the maximum number of blocks from head whose tx indices

+ // are reserved:

+ // * 0: means no limit and regenerate any missing indexes

+ // * N: means N block limit [HEAD-N+1, HEAD] and delete extra indexes

+ // * nil: disable tx reindexer/deleter, but still index new blocks

+ txLookupLimit uint64

+

+ quit chan struct{} // blockchain quit channel

+ running int32 // 0 if chain is running, 1 when stopped

+ procInterrupt int32 // interrupt signaler for block processing

+func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, chainConfig *params.ChainConfig, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(block *types.Block) bool, txLookupLimit *uint64, manualCanonical bool) (*BlockChain, error) {

+ cacheConfig = defaultCacheConfig

+ stateCache: state.NewDatabaseWithCache(db, cacheConfig.TrieCleanLimit, cacheConfig.TrieCleanJournal),

+ bc.hc, err = NewHeaderChain(db, chainConfig, engine, bc.insertStopped)

+

+ var nilBlock *types.Block

+ bc.currentBlock.Store(nilBlock)

+ bc.currentFastBlock.Store(nilBlock)

+

+ var txIndexBlock uint64

+

+ // If ancient database is not empty, reconstruct all missing

+ // indices in the background.

+ frozen, _ := bc.db.Ancients()

+ if frozen > 0 {

+ txIndexBlock = frozen

+ }

+ // 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 {

+ log.Warn("Head state missing, repairing", "number", head.Number(), "hash", head.Hash())

+ if err := bc.SetHead(head.NumberU64()); err != nil {

+ return nil, err

+ }

+ }

+ // Ensure that a previous crash in SetHead doesn't leave extra ancients

+ if fullBlock != nil && fullBlock.Hash() != bc.genesisBlock.Hash() && fullBlock.NumberU64() < frozen-1 {

+ log.Error("Truncating ancient chain", "from", bc.CurrentHeader().Number.Uint64(), "to", low)

+ if err := bc.SetHead(low); err != nil {

+ return nil, err

+ // The first thing the node will do is reconstruct the verification data for

+ // the head block (ethash cache or clique voting snapshot). Might as well do

+ // it in advance.

+ bc.engine.VerifyHeader(bc, bc.CurrentHeader(), true)

+

+ if err := bc.SetHead(header.Number.Uint64() - 1); err != nil {

+ return nil, err

+ }

+ // Load any existing snapshot, regenerating it if loading failed

+ if bc.cacheConfig.SnapshotLimit > 0 {

+ bc.snaps = snapshot.New(bc.db, bc.stateCache.TrieDB(), bc.cacheConfig.SnapshotLimit, bc.CurrentBlock().Root(), !bc.cacheConfig.SnapshotWait)

+ }

+ if txLookupLimit != nil {

+ bc.txLookupLimit = *txLookupLimit

+ go bc.maintainTxIndex(txIndexBlock)

+ }

+ // If periodic cache journal is required, spin it up.

+ if bc.cacheConfig.TrieCleanRejournal > 0 {

+ if bc.cacheConfig.TrieCleanRejournal < time.Minute {

+ 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)

+ }()

+ }

+ if pivot := rawdb.ReadLastPivotNumber(bc.db); pivot != nil {

+ log.Info("Loaded last fast-sync pivot marker", "number", *pivot)

+ }

+// SetHead rewinds the local chain to a new head. Depending on whether the node

+// was fast synced or full synced and in which state, the method will try to

+// delete minimal data from disk whilst retaining chain consistency.

+ // Retrieve the last pivot block to short circuit rollbacks beyond it and the

+ // current freezer limit to start nuking id underflown

+ pivot := rawdb.ReadLastPivotNumber(bc.db)

+ frozen, _ := bc.db.Ancients()

+

+ updateFn := func(db ethdb.KeyValueWriter, header *types.Header) (uint64, bool) {

+ // Rewind the block chain, ensuring we don't end up with a stateless head

+ // block. Note, depth equality is permitted to allow using SetHead as a

+ // chain reparation mechanism without deleting any data!

+ if currentBlock := bc.CurrentBlock(); currentBlock != nil && header.Number.Uint64() <= currentBlock.NumberU64() {

+ log.Error("Gap in the chain, rewinding to genesis", "number", header.Number, "hash", header.Hash())

+ // Block exists, keep rewinding until we find one with state

+ for {

+ if _, err := state.New(newHeadBlock.Root(), bc.stateCache, bc.snaps); err != nil {

+ log.Trace("Block state missing, rewinding further", "number", newHeadBlock.NumberU64(), "hash", newHeadBlock.Hash())

+ if pivot == nil || newHeadBlock.NumberU64() > *pivot {

+ newHeadBlock = bc.GetBlock(newHeadBlock.ParentHash(), newHeadBlock.NumberU64()-1)

+ continue

+ } else {

+ log.Trace("Rewind passed pivot, aiming genesis", "number", newHeadBlock.NumberU64(), "hash", newHeadBlock.Hash(), "pivot", *pivot)

+ newHeadBlock = bc.genesisBlock

+ }

+ }

+ log.Debug("Rewound to block with state", "number", newHeadBlock.NumberU64(), "hash", newHeadBlock.Hash())

+ break

+

+ // Degrade the chain markers if they are explicitly reverted.

+ // In theory we should update all in-memory markers in the

+ // last step, however the direction of SetHead is from high

+ // to low, so it's safe the update in-memory markers directly.

+

+ // Degrade the chain markers if they are explicitly reverted.

+ // In theory we should update all in-memory markers in the

+ // last step, however the direction of SetHead is from high

+ // to low, so it's safe the update in-memory markers directly.

+ head := bc.CurrentBlock().NumberU64()

+ // If setHead underflown the freezer threshold and the block processing

+ // intent afterwards is full block importing, delete the chain segment

+ // between the stateful-block and the sethead target.

+ var wipe bool

+ if head+1 < frozen {

+ wipe = pivot == nil || head >= *pivot

+ }

+ return head, wipe // Only force wipe if full synced

+ }

+ if err := bc.db.TruncateAncients(num); err != nil {

+ // If SetHead was only called as a chain reparation method, try to skip

+ // touching the header chain altogether, unless the freezer is broken

+ if block := bc.CurrentBlock(); block.NumberU64() == head {

+ if target, force := updateFn(bc.db, block.Header()); force {

+ bc.hc.SetHead(target, updateFn, delFn)

+ }

+ } else {

+ // Rewind the chain to the requested head and keep going backwards until a

+ // block with a state is found or fast sync pivot is passed

+ log.Warn("Rewinding blockchain", "target", head)

+ bc.hc.SetHead(head, updateFn, delFn)

+ }

+ // Destroy any existing state snapshot and regenerate it in the background

+ if bc.snaps != nil {

+ bc.snaps.Rebuild(block.Root())

+ }

+// Snapshot returns the blockchain snapshot tree. This method is mainly used for

+// testing, to make it possible to verify the snapshot after execution.

+//

+// Warning: There are no guarantees about the safety of using the returned 'snap' if the

+// blockchain is simultaneously importing blocks, so take care.

+func (bc *BlockChain) Snapshot() *snapshot.Tree {

+ return bc.snaps

+}

+

+ return state.New(root, bc.stateCache, bc.snaps)

+ batch := bc.db.NewBatch()

+ rawdb.WriteTd(batch, genesis.Hash(), genesis.NumberU64(), genesis.Difficulty())

+ rawdb.WriteBlock(batch, genesis)

+ if err := batch.Write(); err != nil {

+ log.Crit("Failed to write genesis block", "err", err)

+ bc.writeHeadBlock(genesis)

+ // Last update all in-memory chain markers

+// writeHeadBlock injects a new head block into the current block chain. This method

+func (bc *BlockChain) writeHeadBlock(block *types.Block) {

+ batch := bc.db.NewBatch()

+ rawdb.WriteCanonicalHash(batch, block.Hash(), block.NumberU64())

+ rawdb.WriteTxLookupEntriesByBlock(batch, block)

+ rawdb.WriteHeadBlockHash(batch, block.Hash())

+ rawdb.WriteHeadHeaderHash(batch, block.Hash())

+ rawdb.WriteHeadFastBlockHash(batch, block.Hash())

+ }

+ // Flush the whole batch into the disk, exit the node if failed

+ if err := batch.Write(); err != nil {

+ log.Crit("Failed to update chain indexes and markers", "err", err)

+ }

+ // Update all in-memory chain markers in the last step

+ if updateHeads {

+ bc.currentBlock.Store(block)

+ headBlockGauge.Update(int64(block.NumberU64()))

+// TrieNode retrieves a blob of data associated with a trie node

+// 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) {

+ return bc.stateCache.ContractCode(common.Hash{}, hash)

+}

+

+// ContractCodeWithPrefix retrieves a blob of data associated with a contract

+// hash either from ephemeral in-memory cache, or from persistent storage.

+//

+// If the code doesn't exist in the in-memory cache, check the storage with

+// new code scheme.

+func (bc *BlockChain) ContractCodeWithPrefix(hash common.Hash) ([]byte, error) {

+ type codeReader interface {

+ ContractCodeWithPrefix(addrHash, codeHash common.Hash) ([]byte, error)

+ }

+ return bc.stateCache.(codeReader).ContractCodeWithPrefix(common.Hash{}, hash)

+}

+

+ bc.StopInsert()

+ // Ensure that the entirety of the state snapshot is journalled to disk.

+ var snapBase common.Hash

+ if bc.snaps != nil {

+ var err error

+ if snapBase, err = bc.snaps.Journal(bc.CurrentBlock().Root()); err != nil {

+ log.Error("Failed to journal state snapshot", "err", err)

+ }

+ }

+ if err := triedb.Commit(recent.Root(), true, nil); err != nil {

+ if snapBase != (common.Hash{}) {

+ log.Info("Writing snapshot state to disk", "root", snapBase)

+ if err := triedb.Commit(snapBase, true, nil); err != nil {

+ log.Error("Failed to commit recent state trie", "err", err)

+ }

+ }

+ // 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)

+ }

+ log.Info("Blockchain stopped")

+}

+

+// StopInsert interrupts all insertion methods, causing them to return

+// errInsertionInterrupted as soon as possible. Insertion is permanently disabled after

+// calling this method.

+func (bc *BlockChain) StopInsert() {

+ atomic.StoreInt32(&bc.procInterrupt, 1)

+}

+

+// insertStopped returns true after StopInsert has been called.

+func (bc *BlockChain) insertStopped() bool {

+ return atomic.LoadInt32(&bc.procInterrupt) == 1

+ sort.Slice(blocks, func(i, j int) bool {

+ return blocks[i].NumberU64() < blocks[j].NumberU64()

+ })

+ // and returns an indicator whether the inserted blocks are canonical.

+ if bc.insertStopped() {

+ // Write tx indices if any condition is satisfied:

+ // * If user requires to reserve all tx indices(txlookuplimit=0)

+ // * If all ancient tx indices are required to be reserved(txlookuplimit is even higher than ancientlimit)

+ // * If block number is large enough to be regarded as a recent block

+ // It means blocks below the ancientLimit-txlookupLimit won't be indexed.

+ //

+ // But if the `TxIndexTail` is not nil, e.g. Geth is initialized with

+ // an external ancient database, during the setup, blockchain will start

+ // a background routine to re-indexed all indices in [ancients - txlookupLimit, ancients)

+ // range. In this case, all tx indices of newly imported blocks should be

+ // generated.

+ if bc.txLookupLimit == 0 || ancientLimit <= bc.txLookupLimit || block.NumberU64() >= ancientLimit-bc.txLookupLimit {

+ rawdb.WriteTxLookupEntriesByBlock(batch, block)

+ } else if rawdb.ReadTxIndexTail(bc.db) != nil {

+ rawdb.WriteTxLookupEntriesByBlock(batch, block)

+ }

+ skipPresenceCheck := false

+ if bc.insertStopped() {

+ if !skipPresenceCheck {

+ // Ignore if the entire data is already known

+ if bc.HasBlock(block.Hash(), block.NumberU64()) {

+ stats.ignored++

+ continue

+ } else {

+ // If block N is not present, neither are the later blocks.

+ // This should be true, but if we are mistaken, the shortcut

+ // here will only cause overwriting of some existing data

+ skipPresenceCheck = true

+ }

+ rawdb.WriteTxLookupEntriesByBlock(batch, block) // Always write tx indices for live blocks, we assume they are needed

+ // Write everything belongs to the blocks into the database. So that

+ // we can ensure all components of body is completed(body, receipts,

+ // tx indexes)

+ stats.processed++

+ // Write everything belongs to the blocks into the database. So that

+ // we can ensure all components of body is completed(body, receipts,

+ // tx indexes)

+ // Write downloaded chain data and corresponding receipt chain data

+ // Write the tx index tail (block number from where we index) before write any live blocks

+ if len(liveBlocks) > 0 && liveBlocks[0].NumberU64() == ancientLimit+1 {

+ // The tx index tail can only be one of the following two options:

+ // * 0: all ancient blocks have been indexed

+ // * ancient-limit: the indices of blocks before ancient-limit are ignored

+ if tail := rawdb.ReadTxIndexTail(bc.db); tail == nil {

+ if bc.txLookupLimit == 0 || ancientLimit <= bc.txLookupLimit {

+ rawdb.WriteTxIndexTail(bc.db, 0)

+ } else {

+ rawdb.WriteTxIndexTail(bc.db, ancientLimit-bc.txLookupLimit)

+ }

+ }

+ }

+// SetTxLookupLimit is responsible for updating the txlookup limit to the

+// original one stored in db if the new mismatches with the old one.

+func (bc *BlockChain) SetTxLookupLimit(limit uint64) {

+ bc.txLookupLimit = limit

+}

+

+// TxLookupLimit retrieves the txlookup limit used by blockchain to prune

+// stale transaction indices.

+func (bc *BlockChain) TxLookupLimit() uint64 {

+ return bc.txLookupLimit

+}

+

+ batch := bc.db.NewBatch()

+ rawdb.WriteTd(batch, block.Hash(), block.NumberU64(), td)

+ rawdb.WriteBlock(batch, block)

+ if err := batch.Write(); err != nil {

+ log.Crit("Failed to write block into disk", "err", err)

+ if !bc.manualCanonical && block.ParentHash() != current.Hash() {

+ bc.writeHeadBlock(block)

+func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) {

+ return bc.writeBlockWithState(block, receipts, logs, state, emitHeadEvent)

+func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) {

+ // Irrelevant of the canonical status, write the block itself to the database.

+ //

+ // Note all the components of block(td, hash->number map, header, body, receipts)

+ // should be written atomically. BlockBatch is used for containing all components.

+ blockBatch := bc.db.NewBatch()

+ rawdb.WriteTd(blockBatch, block.Hash(), block.NumberU64(), externTd)

+ rawdb.WriteBlock(blockBatch, block)

+ rawdb.WriteReceipts(blockBatch, block.Hash(), block.NumberU64(), receipts)

+ rawdb.WritePreimages(blockBatch, state.Preimages())

+ if err := blockBatch.Write(); err != nil {

+ log.Crit("Failed to write block into disk", "err", err)

+ }

+ // Commit all cached state changes into underlying memory database.

+ if err := triedb.Commit(root, false, nil); err != nil {

+ triedb.Commit(header.Root, true, nil)

+ bc.writeHeadBlock(block)

+

+ if status == CanonStatTy {

+ bc.chainFeed.Send(ChainEvent{Block: block, Hash: block.Hash(), Logs: logs})

+ if len(logs) > 0 {

+ bc.logsFeed.Send(logs)

+ }

+ // In theory we should fire a ChainHeadEvent when we inject

+ // a canonical block, but sometimes we can insert a batch of

+ // canonicial blocks. Avoid firing too much ChainHeadEvents,

+ // we will fire an accumulated ChainHeadEvent and disable fire

+ // event here.

+ if emitHeadEvent {

+ bc.chainHeadFeed.Send(ChainHeadEvent{Block: block})

+ }

+ } else {

+ bc.chainSideFeed.Send(ChainSideEvent{Block: block})

+ }

+ n, err := bc.insertChain(chain, true)

+func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, error) {

+ return 0, nil

+ stats = insertStats{startTime: mclock.Now()}

+ lastCanon *types.Block

+ // Fire a single chain head event if we've progressed the chain

+ defer func() {

+ if lastCanon != nil && bc.CurrentBlock().Hash() == lastCanon.Hash() {

+ bc.chainHeadFeed.Send(ChainHeadEvent{lastCanon})

+ }

+ }()

+ return it.index, err

+ case errors.Is(err, consensus.ErrPrunedAncestor):

+ case errors.Is(err, consensus.ErrFutureBlock) || (errors.Is(err, consensus.ErrUnknownAncestor) && bc.futureBlocks.Contains(it.first().ParentHash())):

+ for block != nil && (it.index == 0 || errors.Is(err, consensus.ErrUnknownAncestor)) {

+ return it.index, err

+ return it.index, err

+ bc.futureBlocks.Remove(block.Hash())

+ return it.index, err

+ if bc.insertStopped() {

+ log.Debug("Abort during block processing")

+ return it.index, ErrBlacklistedHash

+ // Special case. Commit the empty receipt slice if we meet the known

+ // block in the middle. It can only happen in the clique chain. Whenever

+ // we insert blocks via `insertSideChain`, we only commit `td`, `header`

+ // and `body` if it's non-existent. Since we don't have receipts without

+ // reexecution, so nothing to commit. But if the sidechain will be adpoted

+ // as the canonical chain eventually, it needs to be reexecuted for missing

+ // state, but if it's this special case here(skip reexecution) we will lose

+ // the empty receipt entry.

+ if len(block.Transactions()) == 0 {

+ rawdb.WriteReceipts(bc.db, block.Hash(), block.NumberU64(), nil)

+ } else {

+ log.Error("Please file an issue, skip known block execution without receipt",

+ "hash", block.Hash(), "number", block.NumberU64())

+ }

+ return it.index, err

+ statedb, err := state.New(parent.Root, bc.stateCache, bc.snaps)

+ return it.index, err

+ throwaway, _ := state.New(parent.Root, bc.stateCache, bc.snaps)

+ go func(start time.Time, followup *types.Block, throwaway *state.StateDB, interrupt *uint32) {

+ if atomic.LoadUint32(interrupt) == 1 {

+ }(time.Now(), followup, throwaway, &followupInterrupt)

+ return it.index, err

+ accountReadTimer.Update(statedb.AccountReads) // Account reads are complete, we can mark them

+ storageReadTimer.Update(statedb.StorageReads) // Storage reads are complete, we can mark them

+ accountUpdateTimer.Update(statedb.AccountUpdates) // Account updates are complete, we can mark them

+ storageUpdateTimer.Update(statedb.StorageUpdates) // Storage updates are complete, we can mark them

+ snapshotAccountReadTimer.Update(statedb.SnapshotAccountReads) // Account reads are complete, we can mark them

+ snapshotStorageReadTimer.Update(statedb.SnapshotStorageReads) // Storage reads are complete, we can mark them

+ trieproc := statedb.SnapshotAccountReads + statedb.AccountReads + statedb.AccountUpdates

+ trieproc += statedb.SnapshotStorageReads + statedb.StorageReads + statedb.StorageUpdates

+ return it.index, err

+ status, err := bc.writeBlockWithState(block, receipts, logs, statedb, false)

+ atomic.StoreUint32(&followupInterrupt, 1)

+ return it.index, err

+ accountCommitTimer.Update(statedb.AccountCommits) // Account commits are complete, we can mark them

+ storageCommitTimer.Update(statedb.StorageCommits) // Storage commits are complete, we can mark them

+ snapshotCommitTimer.Update(statedb.SnapshotCommits) // Snapshot commits are complete, we can mark them

+ blockWriteTimer.Update(time.Since(substart) - statedb.AccountCommits - statedb.StorageCommits - statedb.SnapshotCommits)

+ if block != nil && errors.Is(err, consensus.ErrFutureBlock) {

+ return it.index, err

+ for ; block != nil && errors.Is(err, consensus.ErrUnknownAncestor); block, err = it.next() {

+ return it.index, err

+ return it.index, err

+func (bc *BlockChain) insertSideChain(block *types.Block, it *insertIterator) (int, error) {

+ for ; block != nil && errors.Is(err, consensus.ErrPrunedAncestor); block, err = it.next() {

+ return it.index, errors.New("sidechain ghost-state attack")

+ return it.index, err

+ return it.index, err

+ return it.index, errors.New("missing parent")

+ if _, err := bc.insertChain(blocks, false); err != nil {

+ return 0, err

+ if bc.insertStopped() {

+ log.Debug("Abort during blocks processing")

+ return 0, nil

+ return 0, nil

+ log.Error("reorg shouldn't happen!!!")

+ deletedLogs [][]*types.Log

+ rebirthLogs [][]*types.Log

+ // collectLogs collects the logs that were generated or removed during

+ // the processing of the block that corresponds with the given hash.

+

+ var logs []*types.Log

+ logs = append(logs, &l)

+ }

+ }

+ if len(logs) > 0 {

+ if removed {

+ deletedLogs = append(deletedLogs, logs)

+ } else {

+ rebirthLogs = append(rebirthLogs, logs)

+ // mergeLogs returns a merged log slice with specified sort order.

+ mergeLogs = func(logs [][]*types.Log, reverse bool) []*types.Log {

+ var ret []*types.Log

+ if reverse {

+ for i := len(logs) - 1; i >= 0; i-- {

+ ret = append(ret, logs[i]...)

+ }

+ } else {

+ for i := 0; i < len(logs); i++ {

+ ret = append(ret, logs[i]...)

+ }

+ }

+ return ret

+ }

+ blockReorgMeter.Mark(1)

+ bc.writeHeadBlock(newChain[i])

+ // Collect the new added transactions.

+ // Delete useless indexes right now which includes the non-canonical

+ // transaction indexes, canonical chain indexes which above the head.

+ indexesBatch := bc.db.NewBatch()

+ rawdb.DeleteTxLookupEntry(indexesBatch, tx.Hash())

+ rawdb.DeleteCanonicalHash(indexesBatch, i)

+ }

+ if err := indexesBatch.Write(); err != nil {

+ log.Crit("Failed to delete useless indexes", "err", err)

+ if len(deletedLogs) > 0 {

+ bc.rmLogsFeed.Send(RemovedLogsEvent{mergeLogs(deletedLogs, true)})

+ if len(rebirthLogs) > 0 {

+ bc.logsFeed.Send(mergeLogs(rebirthLogs, false))

+ }

+ if len(oldChain) > 0 {

+ for i := len(oldChain) - 1; i >= 0; i-- {

+ bc.chainSideFeed.Send(ChainSideEvent{Block: oldChain[i]})

+ return nil

+// maintainTxIndex is responsible for the construction and deletion of the

+// transaction index.

+//

+// User can use flag `txlookuplimit` to specify a "recentness" block, below

+// which ancient tx indices get deleted. If `txlookuplimit` is 0, it means

+// all tx indices will be reserved.

+//

+// The user can adjust the txlookuplimit value for each launch after fast

+// sync, Geth will automatically construct the missing indices and delete

+// the extra indices.

+func (bc *BlockChain) maintainTxIndex(ancients uint64) {

+ // Before starting the actual maintenance, we need to handle a special case,

+ // where user might init Geth with an external ancient database. If so, we

+ // need to reindex all necessary transactions before starting to process any

+ // pruning requests.

+ if ancients > 0 {

+ var from = uint64(0)

+ if bc.txLookupLimit != 0 && ancients > bc.txLookupLimit {

+ from = ancients - bc.txLookupLimit

+ }

+ rawdb.IndexTransactions(bc.db, from, ancients)

+ }

+ // indexBlocks reindexes or unindexes transactions depending on user configuration

+ indexBlocks := func(tail *uint64, head uint64, done chan struct{}) {

+ defer func() { done <- struct{}{} }()

+

+ // If the user just upgraded Geth to a new version which supports transaction

+ // index pruning, write the new tail and remove anything older.

+ if tail == nil {

+ if bc.txLookupLimit == 0 || head < bc.txLookupLimit {

+ // Nothing to delete, write the tail and return

+ rawdb.WriteTxIndexTail(bc.db, 0)

+ } else {

+ // Prune all stale tx indices and record the tx index tail

+ rawdb.UnindexTransactions(bc.db, 0, head-bc.txLookupLimit+1)

+ }

+ return

+ }

+ // If a previous indexing existed, make sure that we fill in any missing entries

+ if bc.txLookupLimit == 0 || head < bc.txLookupLimit {

+ if *tail > 0 {

+ rawdb.IndexTransactions(bc.db, 0, *tail)

+ }

+ return

+ }

+ // Update the transaction index to the new chain state

+ if head-bc.txLookupLimit+1 < *tail {

+ // Reindex a part of missing indices and rewind index tail to HEAD-limit

+ rawdb.IndexTransactions(bc.db, head-bc.txLookupLimit+1, *tail)

+ } else {

+ // Unindex a part of stale indices and forward index tail to HEAD-limit

+ rawdb.UnindexTransactions(bc.db, *tail, head-bc.txLookupLimit+1)

+ }

+ }

+ // Any reindexing done, start listening to chain events and moving the index window

+ var (

+ done chan struct{} // Non-nil if background unindexing or reindexing routine is active.

+ headCh = make(chan ChainHeadEvent, 1) // Buffered to avoid locking up the event feed

+ )

+ sub := bc.SubscribeChainHeadEvent(headCh)

+ if sub == nil {

+ return

+ }

+ defer sub.Unsubscribe()

+

+ for {

+ select {

+ case head := <-headCh:

+ if done == nil {

+ done = make(chan struct{})

+ go indexBlocks(rawdb.ReadTxIndexTail(bc.db), head.Block.NumberU64(), done)

+ }

+ case <-done:

+ done = nil

+ case <-bc.quit:

+ return

+ }

+ }

+}

+

+// GetCanonicalHash returns the canonical hash for a given block number

+func (bc *BlockChain) GetCanonicalHash(number uint64) common.Hash {

+ return bc.hc.GetCanonicalHash(number)

+}

+

+ bc.writeHeadBlock(block)