2120 lines
78 KiB
Go
2120 lines
78 KiB
Go
// Copyright 2014 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
// Package core implements the Ethereum consensus protocol.
|
|
package core
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"math/big"
|
|
mrand "math/rand"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"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/consensus"
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
|
"github.com/ethereum/go-ethereum/core/state"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
"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/params"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"github.com/ethereum/go-ethereum/trie"
|
|
"github.com/hashicorp/golang-lru"
|
|
)
|
|
|
|
var (
|
|
accountReadTimer = metrics.NewRegisteredTimer("chain/account/reads", nil)
|
|
accountHashTimer = metrics.NewRegisteredTimer("chain/account/hashes", nil)
|
|
accountUpdateTimer = metrics.NewRegisteredTimer("chain/account/updates", nil)
|
|
accountCommitTimer = metrics.NewRegisteredTimer("chain/account/commits", nil)
|
|
|
|
storageReadTimer = metrics.NewRegisteredTimer("chain/storage/reads", nil)
|
|
storageHashTimer = metrics.NewRegisteredTimer("chain/storage/hashes", nil)
|
|
storageUpdateTimer = metrics.NewRegisteredTimer("chain/storage/updates", nil)
|
|
storageCommitTimer = metrics.NewRegisteredTimer("chain/storage/commits", nil)
|
|
|
|
blockInsertTimer = metrics.NewRegisteredTimer("chain/inserts", nil)
|
|
blockValidationTimer = metrics.NewRegisteredTimer("chain/validation", nil)
|
|
blockExecutionTimer = metrics.NewRegisteredTimer("chain/execution", nil)
|
|
blockWriteTimer = metrics.NewRegisteredTimer("chain/write", nil)
|
|
|
|
blockPrefetchExecuteTimer = metrics.NewRegisteredTimer("chain/prefetch/executes", nil)
|
|
blockPrefetchInterruptMeter = metrics.NewRegisteredMeter("chain/prefetch/interrupts", nil)
|
|
|
|
errInsertionInterrupted = errors.New("insertion is interrupted")
|
|
)
|
|
|
|
const (
|
|
bodyCacheLimit = 256
|
|
blockCacheLimit = 256
|
|
receiptsCacheLimit = 32
|
|
maxFutureBlocks = 256
|
|
maxTimeFutureBlocks = 30
|
|
badBlockLimit = 10
|
|
TriesInMemory = 128
|
|
|
|
// BlockChainVersion ensures that an incompatible database forces a resync from scratch.
|
|
//
|
|
// Changelog:
|
|
//
|
|
// - Version 4
|
|
// The following incompatible database changes were added:
|
|
// * the `BlockNumber`, `TxHash`, `TxIndex`, `BlockHash` and `Index` fields of log are deleted
|
|
// * the `Bloom` field of receipt is deleted
|
|
// * the `BlockIndex` and `TxIndex` fields of txlookup are deleted
|
|
// - Version 5
|
|
// The following incompatible database changes were added:
|
|
// * the `TxHash`, `GasCost`, and `ContractAddress` fields are no longer stored for a receipt
|
|
// * the `TxHash`, `GasCost`, and `ContractAddress` fields are computed by looking up the
|
|
// receipts' corresponding block
|
|
// - Version 6
|
|
// The following incompatible database changes were added:
|
|
// * Transaction lookup information stores the corresponding block number instead of block hash
|
|
// - Version 7
|
|
// The following incompatible database changes were added:
|
|
// * Use freezer as the ancient database to maintain all ancient data
|
|
BlockChainVersion uint64 = 7
|
|
)
|
|
|
|
// CacheConfig contains the configuration values for the trie caching/pruning
|
|
// that's resident in a blockchain.
|
|
type CacheConfig struct {
|
|
TrieCleanLimit int // Memory allowance (MB) to use for caching trie nodes in memory
|
|
TrieCleanNoPrefetch bool // Whether to disable heuristic state prefetching for followup blocks
|
|
TrieDirtyLimit int // Memory limit (MB) at which to start flushing dirty trie nodes to disk
|
|
TrieDirtyDisabled bool // Whether to disable trie write caching and GC altogether (archive node)
|
|
TrieTimeLimit time.Duration // Time limit after which to flush the current in-memory trie to disk
|
|
}
|
|
|
|
// BlockChain represents the canonical chain given a database with a genesis
|
|
// block. The Blockchain manages chain imports, reverts, chain reorganisations.
|
|
//
|
|
// Importing blocks in to the block chain happens according to the set of rules
|
|
// defined by the two stage Validator. Processing of blocks is done using the
|
|
// Processor which processes the included transaction. The validation of the state
|
|
// is done in the second part of the Validator. Failing results in aborting of
|
|
// the import.
|
|
//
|
|
// The BlockChain also helps in returning blocks from **any** chain included
|
|
// in the database as well as blocks that represents the canonical chain. It's
|
|
// important to note that GetBlock can return any block and does not need to be
|
|
// included in the canonical one where as GetBlockByNumber always represents the
|
|
// canonical chain.
|
|
type BlockChain struct {
|
|
chainConfig *params.ChainConfig // Chain & network configuration
|
|
cacheConfig *CacheConfig // Cache configuration for pruning
|
|
|
|
db ethdb.Database // Low level persistent database to store final content in
|
|
triegc *prque.Prque // Priority queue mapping block numbers to tries to gc
|
|
gcproc time.Duration // Accumulates canonical block processing for trie dumping
|
|
|
|
hc *HeaderChain
|
|
rmLogsFeed event.Feed
|
|
chainFeed event.Feed
|
|
chainSideFeed event.Feed
|
|
chainHeadFeed event.Feed
|
|
logsFeed event.Feed
|
|
blockProcFeed event.Feed
|
|
scope event.SubscriptionScope
|
|
genesisBlock *types.Block
|
|
|
|
chainmu sync.RWMutex // blockchain insertion lock
|
|
|
|
currentBlock atomic.Value // Current head of the block chain
|
|
currentFastBlock atomic.Value // Current head of the fast-sync chain (may be above the block chain!)
|
|
|
|
stateCache state.Database // State database to reuse between imports (contains state cache)
|
|
bodyCache *lru.Cache // Cache for the most recent block bodies
|
|
bodyRLPCache *lru.Cache // Cache for the most recent block bodies in RLP encoded format
|
|
receiptsCache *lru.Cache // Cache for the most recent receipts per block
|
|
blockCache *lru.Cache // Cache for the most recent entire blocks
|
|
futureBlocks *lru.Cache // future blocks are blocks added for later processing
|
|
|
|
quit chan struct{} // blockchain quit channel
|
|
running int32 // running must be called atomically
|
|
// procInterrupt must be atomically called
|
|
procInterrupt int32 // interrupt signaler for block processing
|
|
wg sync.WaitGroup // chain processing wait group for shutting down
|
|
|
|
engine consensus.Engine
|
|
validator Validator // Block and state validator interface
|
|
prefetcher Prefetcher // Block state prefetcher interface
|
|
processor Processor // Block transaction processor interface
|
|
vmConfig vm.Config
|
|
|
|
badBlocks *lru.Cache // Bad block cache
|
|
shouldPreserve func(*types.Block) bool // Function used to determine whether should preserve the given block.
|
|
terminateInsert func(common.Hash, uint64) bool // Testing hook used to terminate ancient receipt chain insertion.
|
|
}
|
|
|
|
// NewBlockChain returns a fully initialised block chain using information
|
|
// available in the database. It initialises the default Ethereum Validator and
|
|
// Processor.
|
|
func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, chainConfig *params.ChainConfig, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(block *types.Block) bool) (*BlockChain, error) {
|
|
if cacheConfig == nil {
|
|
cacheConfig = &CacheConfig{
|
|
TrieCleanLimit: 256,
|
|
TrieDirtyLimit: 256,
|
|
TrieTimeLimit: 5 * time.Minute,
|
|
}
|
|
}
|
|
bodyCache, _ := lru.New(bodyCacheLimit)
|
|
bodyRLPCache, _ := lru.New(bodyCacheLimit)
|
|
receiptsCache, _ := lru.New(receiptsCacheLimit)
|
|
blockCache, _ := lru.New(blockCacheLimit)
|
|
futureBlocks, _ := lru.New(maxFutureBlocks)
|
|
badBlocks, _ := lru.New(badBlockLimit)
|
|
|
|
bc := &BlockChain{
|
|
chainConfig: chainConfig,
|
|
cacheConfig: cacheConfig,
|
|
db: db,
|
|
triegc: prque.New(nil),
|
|
stateCache: state.NewDatabaseWithCache(db, cacheConfig.TrieCleanLimit),
|
|
quit: make(chan struct{}),
|
|
shouldPreserve: shouldPreserve,
|
|
bodyCache: bodyCache,
|
|
bodyRLPCache: bodyRLPCache,
|
|
receiptsCache: receiptsCache,
|
|
blockCache: blockCache,
|
|
futureBlocks: futureBlocks,
|
|
engine: engine,
|
|
vmConfig: vmConfig,
|
|
badBlocks: badBlocks,
|
|
}
|
|
bc.validator = NewBlockValidator(chainConfig, bc, engine)
|
|
bc.prefetcher = newStatePrefetcher(chainConfig, bc, engine)
|
|
bc.processor = NewStateProcessor(chainConfig, bc, engine)
|
|
|
|
var err error
|
|
bc.hc, err = NewHeaderChain(db, chainConfig, engine, bc.getProcInterrupt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
bc.genesisBlock = bc.GetBlockByNumber(0)
|
|
if bc.genesisBlock == nil {
|
|
return nil, ErrNoGenesis
|
|
}
|
|
// Initialize the chain with ancient data if it isn't empty.
|
|
if bc.empty() {
|
|
rawdb.InitDatabaseFromFreezer(bc.db)
|
|
}
|
|
if err := bc.loadLastState(); 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 frozen, err := bc.db.Ancients(); err == nil && frozen > 0 {
|
|
var (
|
|
needRewind bool
|
|
low uint64
|
|
)
|
|
// The head full block may be rolled back to a very low height due to
|
|
// blockchain repair. If the head full block is even lower than the ancient
|
|
// chain, truncate the ancient store.
|
|
fullBlock := bc.CurrentBlock()
|
|
if fullBlock != nil && fullBlock != bc.genesisBlock && fullBlock.NumberU64() < frozen-1 {
|
|
needRewind = true
|
|
low = fullBlock.NumberU64()
|
|
}
|
|
// In fast sync, it may happen that ancient data has been written to the
|
|
// ancient store, but the LastFastBlock has not been updated, truncate the
|
|
// extra data here.
|
|
fastBlock := bc.CurrentFastBlock()
|
|
if fastBlock != nil && fastBlock.NumberU64() < frozen-1 {
|
|
needRewind = true
|
|
if fastBlock.NumberU64() < low || low == 0 {
|
|
low = fastBlock.NumberU64()
|
|
}
|
|
}
|
|
if needRewind {
|
|
var hashes []common.Hash
|
|
previous := bc.CurrentHeader().Number.Uint64()
|
|
for i := low + 1; i <= bc.CurrentHeader().Number.Uint64(); i++ {
|
|
hashes = append(hashes, rawdb.ReadCanonicalHash(bc.db, i))
|
|
}
|
|
bc.Rollback(hashes)
|
|
log.Warn("Truncate ancient chain", "from", previous, "to", low)
|
|
}
|
|
}
|
|
// Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain
|
|
for hash := range BadHashes {
|
|
if header := bc.GetHeaderByHash(hash); header != nil {
|
|
// get the canonical block corresponding to the offending header's number
|
|
headerByNumber := bc.GetHeaderByNumber(header.Number.Uint64())
|
|
// make sure the headerByNumber (if present) is in our current canonical chain
|
|
if headerByNumber != nil && headerByNumber.Hash() == header.Hash() {
|
|
log.Error("Found bad hash, rewinding chain", "number", header.Number, "hash", header.ParentHash)
|
|
bc.SetHead(header.Number.Uint64() - 1)
|
|
log.Error("Chain rewind was successful, resuming normal operation")
|
|
}
|
|
}
|
|
}
|
|
// Take ownership of this particular state
|
|
go bc.update()
|
|
return bc, nil
|
|
}
|
|
|
|
func (bc *BlockChain) getProcInterrupt() bool {
|
|
return atomic.LoadInt32(&bc.procInterrupt) == 1
|
|
}
|
|
|
|
// GetVMConfig returns the block chain VM config.
|
|
func (bc *BlockChain) GetVMConfig() *vm.Config {
|
|
return &bc.vmConfig
|
|
}
|
|
|
|
// empty returns an indicator whether the blockchain is empty.
|
|
// Note, it's a special case that we connect a non-empty ancient
|
|
// database with an empty node, so that we can plugin the ancient
|
|
// into node seamlessly.
|
|
func (bc *BlockChain) empty() bool {
|
|
genesis := bc.genesisBlock.Hash()
|
|
for _, hash := range []common.Hash{rawdb.ReadHeadBlockHash(bc.db), rawdb.ReadHeadHeaderHash(bc.db), rawdb.ReadHeadFastBlockHash(bc.db)} {
|
|
if hash != genesis {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// loadLastState loads the last known chain state from the database. This method
|
|
// assumes that the chain manager mutex is held.
|
|
func (bc *BlockChain) loadLastState() error {
|
|
// Restore the last known head block
|
|
head := rawdb.ReadHeadBlockHash(bc.db)
|
|
if head == (common.Hash{}) {
|
|
// Corrupt or empty database, init from scratch
|
|
log.Warn("Empty database, resetting chain")
|
|
return bc.Reset()
|
|
}
|
|
// Make sure the entire head block is available
|
|
currentBlock := bc.GetBlockByHash(head)
|
|
if currentBlock == nil {
|
|
// Corrupt or empty database, init from scratch
|
|
log.Warn("Head block missing, resetting chain", "hash", head)
|
|
return bc.Reset()
|
|
}
|
|
// Make sure the state associated with the block is available
|
|
if _, err := state.New(currentBlock.Root(), bc.stateCache); err != nil {
|
|
// Dangling block without a state associated, init from scratch
|
|
log.Warn("Head state missing, repairing chain", "number", currentBlock.Number(), "hash", currentBlock.Hash())
|
|
if err := bc.repair(¤tBlock); err != nil {
|
|
return err
|
|
}
|
|
rawdb.WriteHeadBlockHash(bc.db, currentBlock.Hash())
|
|
}
|
|
// Everything seems to be fine, set as the head block
|
|
bc.currentBlock.Store(currentBlock)
|
|
|
|
// Restore the last known head header
|
|
currentHeader := currentBlock.Header()
|
|
if head := rawdb.ReadHeadHeaderHash(bc.db); head != (common.Hash{}) {
|
|
if header := bc.GetHeaderByHash(head); header != nil {
|
|
currentHeader = header
|
|
}
|
|
}
|
|
bc.hc.SetCurrentHeader(currentHeader)
|
|
|
|
// Restore the last known head fast block
|
|
bc.currentFastBlock.Store(currentBlock)
|
|
if head := rawdb.ReadHeadFastBlockHash(bc.db); head != (common.Hash{}) {
|
|
if block := bc.GetBlockByHash(head); block != nil {
|
|
bc.currentFastBlock.Store(block)
|
|
}
|
|
}
|
|
|
|
// Issue a status log for the user
|
|
currentFastBlock := bc.CurrentFastBlock()
|
|
|
|
headerTd := bc.GetTd(currentHeader.Hash(), currentHeader.Number.Uint64())
|
|
blockTd := bc.GetTd(currentBlock.Hash(), currentBlock.NumberU64())
|
|
fastTd := bc.GetTd(currentFastBlock.Hash(), currentFastBlock.NumberU64())
|
|
|
|
log.Info("Loaded most recent local header", "number", currentHeader.Number, "hash", currentHeader.Hash(), "td", headerTd, "age", common.PrettyAge(time.Unix(int64(currentHeader.Time), 0)))
|
|
log.Info("Loaded most recent local full block", "number", currentBlock.Number(), "hash", currentBlock.Hash(), "td", blockTd, "age", common.PrettyAge(time.Unix(int64(currentBlock.Time()), 0)))
|
|
log.Info("Loaded most recent local fast block", "number", currentFastBlock.Number(), "hash", currentFastBlock.Hash(), "td", fastTd, "age", common.PrettyAge(time.Unix(int64(currentFastBlock.Time()), 0)))
|
|
|
|
return nil
|
|
}
|
|
|
|
// SetHead rewinds the local chain to a new head. In the case of headers, everything
|
|
// above the new head will be deleted and the new one set. In the case of blocks
|
|
// though, the head may be further rewound if block bodies are missing (non-archive
|
|
// nodes after a fast sync).
|
|
func (bc *BlockChain) SetHead(head uint64) error {
|
|
log.Warn("Rewinding blockchain", "target", head)
|
|
|
|
bc.chainmu.Lock()
|
|
defer bc.chainmu.Unlock()
|
|
|
|
updateFn := func(db ethdb.KeyValueWriter, header *types.Header) {
|
|
// Rewind the block chain, ensuring we don't end up with a stateless head block
|
|
if currentBlock := bc.CurrentBlock(); currentBlock != nil && header.Number.Uint64() < currentBlock.NumberU64() {
|
|
newHeadBlock := bc.GetBlock(header.Hash(), header.Number.Uint64())
|
|
if newHeadBlock == nil {
|
|
newHeadBlock = bc.genesisBlock
|
|
} else {
|
|
if _, err := state.New(newHeadBlock.Root(), bc.stateCache); err != nil {
|
|
// Rewound state missing, rolled back to before pivot, reset to genesis
|
|
newHeadBlock = bc.genesisBlock
|
|
}
|
|
}
|
|
rawdb.WriteHeadBlockHash(db, newHeadBlock.Hash())
|
|
bc.currentBlock.Store(newHeadBlock)
|
|
}
|
|
|
|
// Rewind the fast block in a simpleton way to the target head
|
|
if currentFastBlock := bc.CurrentFastBlock(); currentFastBlock != nil && header.Number.Uint64() < currentFastBlock.NumberU64() {
|
|
newHeadFastBlock := bc.GetBlock(header.Hash(), header.Number.Uint64())
|
|
// If either blocks reached nil, reset to the genesis state
|
|
if newHeadFastBlock == nil {
|
|
newHeadFastBlock = bc.genesisBlock
|
|
}
|
|
rawdb.WriteHeadFastBlockHash(db, newHeadFastBlock.Hash())
|
|
bc.currentFastBlock.Store(newHeadFastBlock)
|
|
}
|
|
}
|
|
|
|
// Rewind the header chain, deleting all block bodies until then
|
|
delFn := func(db ethdb.KeyValueWriter, hash common.Hash, num uint64) {
|
|
// Ignore the error here since light client won't hit this path
|
|
frozen, _ := bc.db.Ancients()
|
|
if num+1 <= frozen {
|
|
// Truncate all relative data(header, total difficulty, body, receipt
|
|
// and canonical hash) from ancient store.
|
|
if err := bc.db.TruncateAncients(num + 1); err != nil {
|
|
log.Crit("Failed to truncate ancient data", "number", num, "err", err)
|
|
}
|
|
|
|
// Remove the hash <-> number mapping from the active store.
|
|
rawdb.DeleteHeaderNumber(db, hash)
|
|
} else {
|
|
// Remove relative body and receipts from the active store.
|
|
// The header, total difficulty and canonical hash will be
|
|
// removed in the hc.SetHead function.
|
|
rawdb.DeleteBody(db, hash, num)
|
|
rawdb.DeleteReceipts(db, hash, num)
|
|
}
|
|
// Todo(rjl493456442) txlookup, bloombits, etc
|
|
}
|
|
bc.hc.SetHead(head, updateFn, delFn)
|
|
|
|
// Clear out any stale content from the caches
|
|
bc.bodyCache.Purge()
|
|
bc.bodyRLPCache.Purge()
|
|
bc.receiptsCache.Purge()
|
|
bc.blockCache.Purge()
|
|
bc.futureBlocks.Purge()
|
|
|
|
return bc.loadLastState()
|
|
}
|
|
|
|
// FastSyncCommitHead sets the current head block to the one defined by the hash
|
|
// irrelevant what the chain contents were prior.
|
|
func (bc *BlockChain) FastSyncCommitHead(hash common.Hash) error {
|
|
// Make sure that both the block as well at its state trie exists
|
|
block := bc.GetBlockByHash(hash)
|
|
if block == nil {
|
|
return fmt.Errorf("non existent block [%x…]", hash[:4])
|
|
}
|
|
if _, err := trie.NewSecure(block.Root(), bc.stateCache.TrieDB()); err != nil {
|
|
return err
|
|
}
|
|
// If all checks out, manually set the head block
|
|
bc.chainmu.Lock()
|
|
bc.currentBlock.Store(block)
|
|
bc.chainmu.Unlock()
|
|
|
|
log.Info("Committed new head block", "number", block.Number(), "hash", hash)
|
|
return nil
|
|
}
|
|
|
|
// GasLimit returns the gas limit of the current HEAD block.
|
|
func (bc *BlockChain) GasLimit() uint64 {
|
|
return bc.CurrentBlock().GasLimit()
|
|
}
|
|
|
|
// CurrentBlock retrieves the current head block of the canonical chain. The
|
|
// block is retrieved from the blockchain's internal cache.
|
|
func (bc *BlockChain) CurrentBlock() *types.Block {
|
|
return bc.currentBlock.Load().(*types.Block)
|
|
}
|
|
|
|
// CurrentFastBlock retrieves the current fast-sync head block of the canonical
|
|
// chain. The block is retrieved from the blockchain's internal cache.
|
|
func (bc *BlockChain) CurrentFastBlock() *types.Block {
|
|
return bc.currentFastBlock.Load().(*types.Block)
|
|
}
|
|
|
|
// Validator returns the current validator.
|
|
func (bc *BlockChain) Validator() Validator {
|
|
return bc.validator
|
|
}
|
|
|
|
// Processor returns the current processor.
|
|
func (bc *BlockChain) Processor() Processor {
|
|
return bc.processor
|
|
}
|
|
|
|
// State returns a new mutable state based on the current HEAD block.
|
|
func (bc *BlockChain) State() (*state.StateDB, error) {
|
|
return bc.StateAt(bc.CurrentBlock().Root())
|
|
}
|
|
|
|
// StateAt returns a new mutable state based on a particular point in time.
|
|
func (bc *BlockChain) StateAt(root common.Hash) (*state.StateDB, error) {
|
|
return state.New(root, bc.stateCache)
|
|
}
|
|
|
|
// StateCache returns the caching database underpinning the blockchain instance.
|
|
func (bc *BlockChain) StateCache() state.Database {
|
|
return bc.stateCache
|
|
}
|
|
|
|
// Reset purges the entire blockchain, restoring it to its genesis state.
|
|
func (bc *BlockChain) Reset() error {
|
|
return bc.ResetWithGenesisBlock(bc.genesisBlock)
|
|
}
|
|
|
|
// ResetWithGenesisBlock purges the entire blockchain, restoring it to the
|
|
// specified genesis state.
|
|
func (bc *BlockChain) ResetWithGenesisBlock(genesis *types.Block) error {
|
|
// Dump the entire block chain and purge the caches
|
|
if err := bc.SetHead(0); err != nil {
|
|
return err
|
|
}
|
|
bc.chainmu.Lock()
|
|
defer bc.chainmu.Unlock()
|
|
|
|
// Prepare the genesis block and reinitialise the chain
|
|
if err := bc.hc.WriteTd(genesis.Hash(), genesis.NumberU64(), genesis.Difficulty()); err != nil {
|
|
log.Crit("Failed to write genesis block TD", "err", err)
|
|
}
|
|
rawdb.WriteBlock(bc.db, genesis)
|
|
|
|
bc.genesisBlock = genesis
|
|
bc.insert(bc.genesisBlock)
|
|
bc.currentBlock.Store(bc.genesisBlock)
|
|
bc.hc.SetGenesis(bc.genesisBlock.Header())
|
|
bc.hc.SetCurrentHeader(bc.genesisBlock.Header())
|
|
bc.currentFastBlock.Store(bc.genesisBlock)
|
|
|
|
return nil
|
|
}
|
|
|
|
// repair tries to repair the current blockchain by rolling back the current block
|
|
// until one with associated state is found. This is needed to fix incomplete db
|
|
// writes caused either by crashes/power outages, or simply non-committed tries.
|
|
//
|
|
// This method only rolls back the current block. The current header and current
|
|
// fast block are left intact.
|
|
func (bc *BlockChain) repair(head **types.Block) error {
|
|
for {
|
|
// Abort if we've rewound to a head block that does have associated state
|
|
if _, err := state.New((*head).Root(), bc.stateCache); err == nil {
|
|
log.Info("Rewound blockchain to past state", "number", (*head).Number(), "hash", (*head).Hash())
|
|
return nil
|
|
}
|
|
// Otherwise rewind one block and recheck state availability there
|
|
block := bc.GetBlock((*head).ParentHash(), (*head).NumberU64()-1)
|
|
if block == nil {
|
|
return fmt.Errorf("missing block %d [%x]", (*head).NumberU64()-1, (*head).ParentHash())
|
|
}
|
|
*head = block
|
|
}
|
|
}
|
|
|
|
// Export writes the active chain to the given writer.
|
|
func (bc *BlockChain) Export(w io.Writer) error {
|
|
return bc.ExportN(w, uint64(0), bc.CurrentBlock().NumberU64())
|
|
}
|
|
|
|
// ExportN writes a subset of the active chain to the given writer.
|
|
func (bc *BlockChain) ExportN(w io.Writer, first uint64, last uint64) error {
|
|
bc.chainmu.RLock()
|
|
defer bc.chainmu.RUnlock()
|
|
|
|
if first > last {
|
|
return fmt.Errorf("export failed: first (%d) is greater than last (%d)", first, last)
|
|
}
|
|
log.Info("Exporting batch of blocks", "count", last-first+1)
|
|
|
|
start, reported := time.Now(), time.Now()
|
|
for nr := first; nr <= last; nr++ {
|
|
block := bc.GetBlockByNumber(nr)
|
|
if block == nil {
|
|
return fmt.Errorf("export failed on #%d: not found", nr)
|
|
}
|
|
if err := block.EncodeRLP(w); err != nil {
|
|
return err
|
|
}
|
|
if time.Since(reported) >= statsReportLimit {
|
|
log.Info("Exporting blocks", "exported", block.NumberU64()-first, "elapsed", common.PrettyDuration(time.Since(start)))
|
|
reported = time.Now()
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// insert injects a new head block into the current block chain. This method
|
|
// assumes that the block is indeed a true head. It will also reset the head
|
|
// header and the head fast sync block to this very same block if they are older
|
|
// or if they are on a different side chain.
|
|
//
|
|
// Note, this function assumes that the `mu` mutex is held!
|
|
func (bc *BlockChain) insert(block *types.Block) {
|
|
// If the block is on a side chain or an unknown one, force other heads onto it too
|
|
updateHeads := rawdb.ReadCanonicalHash(bc.db, block.NumberU64()) != block.Hash()
|
|
|
|
// Add the block to the canonical chain number scheme and mark as the head
|
|
rawdb.WriteCanonicalHash(bc.db, block.Hash(), block.NumberU64())
|
|
rawdb.WriteHeadBlockHash(bc.db, block.Hash())
|
|
|
|
bc.currentBlock.Store(block)
|
|
|
|
// If the block is better than our head or is on a different chain, force update heads
|
|
if updateHeads {
|
|
bc.hc.SetCurrentHeader(block.Header())
|
|
rawdb.WriteHeadFastBlockHash(bc.db, block.Hash())
|
|
|
|
bc.currentFastBlock.Store(block)
|
|
}
|
|
}
|
|
|
|
// Genesis retrieves the chain's genesis block.
|
|
func (bc *BlockChain) Genesis() *types.Block {
|
|
return bc.genesisBlock
|
|
}
|
|
|
|
// GetBody retrieves a block body (transactions and uncles) from the database by
|
|
// hash, caching it if found.
|
|
func (bc *BlockChain) GetBody(hash common.Hash) *types.Body {
|
|
// Short circuit if the body's already in the cache, retrieve otherwise
|
|
if cached, ok := bc.bodyCache.Get(hash); ok {
|
|
body := cached.(*types.Body)
|
|
return body
|
|
}
|
|
number := bc.hc.GetBlockNumber(hash)
|
|
if number == nil {
|
|
return nil
|
|
}
|
|
body := rawdb.ReadBody(bc.db, hash, *number)
|
|
if body == nil {
|
|
return nil
|
|
}
|
|
// Cache the found body for next time and return
|
|
bc.bodyCache.Add(hash, body)
|
|
return body
|
|
}
|
|
|
|
// GetBodyRLP retrieves a block body in RLP encoding from the database by hash,
|
|
// caching it if found.
|
|
func (bc *BlockChain) GetBodyRLP(hash common.Hash) rlp.RawValue {
|
|
// Short circuit if the body's already in the cache, retrieve otherwise
|
|
if cached, ok := bc.bodyRLPCache.Get(hash); ok {
|
|
return cached.(rlp.RawValue)
|
|
}
|
|
number := bc.hc.GetBlockNumber(hash)
|
|
if number == nil {
|
|
return nil
|
|
}
|
|
body := rawdb.ReadBodyRLP(bc.db, hash, *number)
|
|
if len(body) == 0 {
|
|
return nil
|
|
}
|
|
// Cache the found body for next time and return
|
|
bc.bodyRLPCache.Add(hash, body)
|
|
return body
|
|
}
|
|
|
|
// HasBlock checks if a block is fully present in the database or not.
|
|
func (bc *BlockChain) HasBlock(hash common.Hash, number uint64) bool {
|
|
if bc.blockCache.Contains(hash) {
|
|
return true
|
|
}
|
|
return rawdb.HasBody(bc.db, hash, number)
|
|
}
|
|
|
|
// HasFastBlock checks if a fast block is fully present in the database or not.
|
|
func (bc *BlockChain) HasFastBlock(hash common.Hash, number uint64) bool {
|
|
if !bc.HasBlock(hash, number) {
|
|
return false
|
|
}
|
|
if bc.receiptsCache.Contains(hash) {
|
|
return true
|
|
}
|
|
return rawdb.HasReceipts(bc.db, hash, number)
|
|
}
|
|
|
|
// HasState checks if state trie is fully present in the database or not.
|
|
func (bc *BlockChain) HasState(hash common.Hash) bool {
|
|
_, err := bc.stateCache.OpenTrie(hash)
|
|
return err == nil
|
|
}
|
|
|
|
// HasBlockAndState checks if a block and associated state trie is fully present
|
|
// in the database or not, caching it if present.
|
|
func (bc *BlockChain) HasBlockAndState(hash common.Hash, number uint64) bool {
|
|
// Check first that the block itself is known
|
|
block := bc.GetBlock(hash, number)
|
|
if block == nil {
|
|
return false
|
|
}
|
|
return bc.HasState(block.Root())
|
|
}
|
|
|
|
// GetBlock retrieves a block from the database by hash and number,
|
|
// caching it if found.
|
|
func (bc *BlockChain) GetBlock(hash common.Hash, number uint64) *types.Block {
|
|
// Short circuit if the block's already in the cache, retrieve otherwise
|
|
if block, ok := bc.blockCache.Get(hash); ok {
|
|
return block.(*types.Block)
|
|
}
|
|
block := rawdb.ReadBlock(bc.db, hash, number)
|
|
if block == nil {
|
|
return nil
|
|
}
|
|
// Cache the found block for next time and return
|
|
bc.blockCache.Add(block.Hash(), block)
|
|
return block
|
|
}
|
|
|
|
// GetBlockByHash retrieves a block from the database by hash, caching it if found.
|
|
func (bc *BlockChain) GetBlockByHash(hash common.Hash) *types.Block {
|
|
number := bc.hc.GetBlockNumber(hash)
|
|
if number == nil {
|
|
return nil
|
|
}
|
|
return bc.GetBlock(hash, *number)
|
|
}
|
|
|
|
// GetBlockByNumber retrieves a block from the database by number, caching it
|
|
// (associated with its hash) if found.
|
|
func (bc *BlockChain) GetBlockByNumber(number uint64) *types.Block {
|
|
hash := rawdb.ReadCanonicalHash(bc.db, number)
|
|
if hash == (common.Hash{}) {
|
|
return nil
|
|
}
|
|
return bc.GetBlock(hash, number)
|
|
}
|
|
|
|
// GetReceiptsByHash retrieves the receipts for all transactions in a given block.
|
|
func (bc *BlockChain) GetReceiptsByHash(hash common.Hash) types.Receipts {
|
|
if receipts, ok := bc.receiptsCache.Get(hash); ok {
|
|
return receipts.(types.Receipts)
|
|
}
|
|
number := rawdb.ReadHeaderNumber(bc.db, hash)
|
|
if number == nil {
|
|
return nil
|
|
}
|
|
receipts := rawdb.ReadReceipts(bc.db, hash, *number, bc.chainConfig)
|
|
if receipts == nil {
|
|
return nil
|
|
}
|
|
bc.receiptsCache.Add(hash, receipts)
|
|
return receipts
|
|
}
|
|
|
|
// GetBlocksFromHash returns the block corresponding to hash and up to n-1 ancestors.
|
|
// [deprecated by eth/62]
|
|
func (bc *BlockChain) GetBlocksFromHash(hash common.Hash, n int) (blocks []*types.Block) {
|
|
number := bc.hc.GetBlockNumber(hash)
|
|
if number == nil {
|
|
return nil
|
|
}
|
|
for i := 0; i < n; i++ {
|
|
block := bc.GetBlock(hash, *number)
|
|
if block == nil {
|
|
break
|
|
}
|
|
blocks = append(blocks, block)
|
|
hash = block.ParentHash()
|
|
*number--
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetUnclesInChain retrieves all the uncles from a given block backwards until
|
|
// a specific distance is reached.
|
|
func (bc *BlockChain) GetUnclesInChain(block *types.Block, length int) []*types.Header {
|
|
uncles := []*types.Header{}
|
|
for i := 0; block != nil && i < length; i++ {
|
|
uncles = append(uncles, block.Uncles()...)
|
|
block = bc.GetBlock(block.ParentHash(), block.NumberU64()-1)
|
|
}
|
|
return uncles
|
|
}
|
|
|
|
// TrieNode retrieves a blob of data associated with a trie node (or code hash)
|
|
// either from ephemeral in-memory cache, or from persistent storage.
|
|
func (bc *BlockChain) TrieNode(hash common.Hash) ([]byte, error) {
|
|
return bc.stateCache.TrieDB().Node(hash)
|
|
}
|
|
|
|
// Stop stops the blockchain service. If any imports are currently in progress
|
|
// it will abort them using the procInterrupt.
|
|
func (bc *BlockChain) Stop() {
|
|
if !atomic.CompareAndSwapInt32(&bc.running, 0, 1) {
|
|
return
|
|
}
|
|
// Unsubscribe all subscriptions registered from blockchain
|
|
bc.scope.Close()
|
|
close(bc.quit)
|
|
atomic.StoreInt32(&bc.procInterrupt, 1)
|
|
|
|
bc.wg.Wait()
|
|
|
|
// Ensure the state of a recent block is also stored to disk before exiting.
|
|
// We're writing three different states to catch different restart scenarios:
|
|
// - HEAD: So we don't need to reprocess any blocks in the general case
|
|
// - 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()
|
|
|
|
for _, offset := range []uint64{0, 1, TriesInMemory - 1} {
|
|
if number := bc.CurrentBlock().NumberU64(); number > offset {
|
|
recent := bc.GetBlockByNumber(number - offset)
|
|
|
|
log.Info("Writing cached state to disk", "block", recent.Number(), "hash", recent.Hash(), "root", recent.Root())
|
|
if err := triedb.Commit(recent.Root(), true); err != nil {
|
|
log.Error("Failed to commit recent state trie", "err", err)
|
|
}
|
|
}
|
|
}
|
|
for !bc.triegc.Empty() {
|
|
triedb.Dereference(bc.triegc.PopItem().(common.Hash))
|
|
}
|
|
if size, _ := triedb.Size(); size != 0 {
|
|
log.Error("Dangling trie nodes after full cleanup")
|
|
}
|
|
}
|
|
log.Info("Blockchain manager stopped")
|
|
}
|
|
|
|
func (bc *BlockChain) procFutureBlocks() {
|
|
blocks := make([]*types.Block, 0, bc.futureBlocks.Len())
|
|
for _, hash := range bc.futureBlocks.Keys() {
|
|
if block, exist := bc.futureBlocks.Peek(hash); exist {
|
|
blocks = append(blocks, block.(*types.Block))
|
|
}
|
|
}
|
|
if len(blocks) > 0 {
|
|
types.BlockBy(types.Number).Sort(blocks)
|
|
|
|
// Insert one by one as chain insertion needs contiguous ancestry between blocks
|
|
for i := range blocks {
|
|
bc.InsertChain(blocks[i : i+1])
|
|
}
|
|
}
|
|
}
|
|
|
|
// WriteStatus status of write
|
|
type WriteStatus byte
|
|
|
|
const (
|
|
NonStatTy WriteStatus = iota
|
|
CanonStatTy
|
|
SideStatTy
|
|
)
|
|
|
|
// Rollback is designed to remove a chain of links from the database that aren't
|
|
// certain enough to be valid.
|
|
func (bc *BlockChain) Rollback(chain []common.Hash) {
|
|
bc.chainmu.Lock()
|
|
defer bc.chainmu.Unlock()
|
|
|
|
for i := len(chain) - 1; i >= 0; i-- {
|
|
hash := chain[i]
|
|
|
|
currentHeader := bc.hc.CurrentHeader()
|
|
if currentHeader.Hash() == hash {
|
|
bc.hc.SetCurrentHeader(bc.GetHeader(currentHeader.ParentHash, currentHeader.Number.Uint64()-1))
|
|
}
|
|
if currentFastBlock := bc.CurrentFastBlock(); currentFastBlock.Hash() == hash {
|
|
newFastBlock := bc.GetBlock(currentFastBlock.ParentHash(), currentFastBlock.NumberU64()-1)
|
|
rawdb.WriteHeadFastBlockHash(bc.db, newFastBlock.Hash())
|
|
bc.currentFastBlock.Store(newFastBlock)
|
|
}
|
|
if currentBlock := bc.CurrentBlock(); currentBlock.Hash() == hash {
|
|
newBlock := bc.GetBlock(currentBlock.ParentHash(), currentBlock.NumberU64()-1)
|
|
rawdb.WriteHeadBlockHash(bc.db, newBlock.Hash())
|
|
bc.currentBlock.Store(newBlock)
|
|
}
|
|
}
|
|
// Truncate ancient data which exceeds the current header.
|
|
//
|
|
// Notably, it can happen that system crashes without truncating the ancient data
|
|
// but the head indicator has been updated in the active store. Regarding this issue,
|
|
// system will self recovery by truncating the extra data during the setup phase.
|
|
if err := bc.truncateAncient(bc.hc.CurrentHeader().Number.Uint64()); err != nil {
|
|
log.Crit("Truncate ancient store failed", "err", err)
|
|
}
|
|
}
|
|
|
|
// truncateAncient rewinds the blockchain to the specified header and deletes all
|
|
// data in the ancient store that exceeds the specified header.
|
|
func (bc *BlockChain) truncateAncient(head uint64) error {
|
|
frozen, err := bc.db.Ancients()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Short circuit if there is no data to truncate in ancient store.
|
|
if frozen <= head+1 {
|
|
return nil
|
|
}
|
|
// Truncate all the data in the freezer beyond the specified head
|
|
if err := bc.db.TruncateAncients(head + 1); err != nil {
|
|
return err
|
|
}
|
|
// Clear out any stale content from the caches
|
|
bc.hc.headerCache.Purge()
|
|
bc.hc.tdCache.Purge()
|
|
bc.hc.numberCache.Purge()
|
|
|
|
// Clear out any stale content from the caches
|
|
bc.bodyCache.Purge()
|
|
bc.bodyRLPCache.Purge()
|
|
bc.receiptsCache.Purge()
|
|
bc.blockCache.Purge()
|
|
bc.futureBlocks.Purge()
|
|
|
|
log.Info("Rewind ancient data", "number", head)
|
|
return nil
|
|
}
|
|
|
|
// InsertReceiptChain attempts to complete an already existing header chain with
|
|
// transaction and receipt data.
|
|
func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain []types.Receipts, ancientLimit uint64) (int, error) {
|
|
bc.wg.Add(1)
|
|
defer bc.wg.Done()
|
|
|
|
var (
|
|
ancientBlocks, liveBlocks types.Blocks
|
|
ancientReceipts, liveReceipts []types.Receipts
|
|
)
|
|
// Do a sanity check that the provided chain is actually ordered and linked
|
|
for i := 0; i < len(blockChain); i++ {
|
|
if i != 0 {
|
|
if blockChain[i].NumberU64() != blockChain[i-1].NumberU64()+1 || blockChain[i].ParentHash() != blockChain[i-1].Hash() {
|
|
log.Error("Non contiguous receipt insert", "number", blockChain[i].Number(), "hash", blockChain[i].Hash(), "parent", blockChain[i].ParentHash(),
|
|
"prevnumber", blockChain[i-1].Number(), "prevhash", blockChain[i-1].Hash())
|
|
return 0, fmt.Errorf("non contiguous insert: item %d is #%d [%x…], item %d is #%d [%x…] (parent [%x…])", i-1, blockChain[i-1].NumberU64(),
|
|
blockChain[i-1].Hash().Bytes()[:4], i, blockChain[i].NumberU64(), blockChain[i].Hash().Bytes()[:4], blockChain[i].ParentHash().Bytes()[:4])
|
|
}
|
|
}
|
|
if blockChain[i].NumberU64() <= ancientLimit {
|
|
ancientBlocks, ancientReceipts = append(ancientBlocks, blockChain[i]), append(ancientReceipts, receiptChain[i])
|
|
} else {
|
|
liveBlocks, liveReceipts = append(liveBlocks, blockChain[i]), append(liveReceipts, receiptChain[i])
|
|
}
|
|
}
|
|
|
|
var (
|
|
stats = struct{ processed, ignored int32 }{}
|
|
start = time.Now()
|
|
size = 0
|
|
)
|
|
// updateHead updates the head fast sync block if the inserted blocks are better
|
|
// and returns a indicator whether the inserted blocks are canonical.
|
|
updateHead := func(head *types.Block) bool {
|
|
var isCanonical bool
|
|
bc.chainmu.Lock()
|
|
if td := bc.GetTd(head.Hash(), head.NumberU64()); td != nil { // Rewind may have occurred, skip in that case
|
|
currentFastBlock := bc.CurrentFastBlock()
|
|
if bc.GetTd(currentFastBlock.Hash(), currentFastBlock.NumberU64()).Cmp(td) < 0 {
|
|
rawdb.WriteHeadFastBlockHash(bc.db, head.Hash())
|
|
bc.currentFastBlock.Store(head)
|
|
isCanonical = true
|
|
}
|
|
}
|
|
bc.chainmu.Unlock()
|
|
return isCanonical
|
|
}
|
|
// writeAncient writes blockchain and corresponding receipt chain into ancient store.
|
|
//
|
|
// this function only accepts canonical chain data. All side chain will be reverted
|
|
// eventually.
|
|
writeAncient := func(blockChain types.Blocks, receiptChain []types.Receipts) (int, error) {
|
|
var (
|
|
previous = bc.CurrentFastBlock()
|
|
batch = bc.db.NewBatch()
|
|
)
|
|
// If any error occurs before updating the head or we are inserting a side chain,
|
|
// all the data written this time wll be rolled back.
|
|
defer func() {
|
|
if previous != nil {
|
|
if err := bc.truncateAncient(previous.NumberU64()); err != nil {
|
|
log.Crit("Truncate ancient store failed", "err", err)
|
|
}
|
|
}
|
|
}()
|
|
var deleted types.Blocks
|
|
for i, block := range blockChain {
|
|
// Short circuit insertion if shutting down or processing failed
|
|
if atomic.LoadInt32(&bc.procInterrupt) == 1 {
|
|
return 0, errInsertionInterrupted
|
|
}
|
|
// Short circuit insertion if it is required(used in testing only)
|
|
if bc.terminateInsert != nil && bc.terminateInsert(block.Hash(), block.NumberU64()) {
|
|
return i, errors.New("insertion is terminated for testing purpose")
|
|
}
|
|
// Short circuit if the owner header is unknown
|
|
if !bc.HasHeader(block.Hash(), block.NumberU64()) {
|
|
return i, fmt.Errorf("containing header #%d [%x…] unknown", block.Number(), block.Hash().Bytes()[:4])
|
|
}
|
|
var (
|
|
start = time.Now()
|
|
logged = time.Now()
|
|
count int
|
|
)
|
|
// Migrate all ancient blocks. This can happen if someone upgrades from Geth
|
|
// 1.8.x to 1.9.x mid-fast-sync. Perhaps we can get rid of this path in the
|
|
// long term.
|
|
for {
|
|
// We can ignore the error here since light client won't hit this code path.
|
|
frozen, _ := bc.db.Ancients()
|
|
if frozen >= block.NumberU64() {
|
|
break
|
|
}
|
|
h := rawdb.ReadCanonicalHash(bc.db, frozen)
|
|
b := rawdb.ReadBlock(bc.db, h, frozen)
|
|
size += rawdb.WriteAncientBlock(bc.db, b, rawdb.ReadReceipts(bc.db, h, frozen, bc.chainConfig), rawdb.ReadTd(bc.db, h, frozen))
|
|
count += 1
|
|
|
|
// Always keep genesis block in active database.
|
|
if b.NumberU64() != 0 {
|
|
deleted = append(deleted, b)
|
|
}
|
|
if time.Since(logged) > 8*time.Second {
|
|
log.Info("Migrating ancient blocks", "count", count, "elapsed", common.PrettyDuration(time.Since(start)))
|
|
logged = time.Now()
|
|
}
|
|
}
|
|
if count > 0 {
|
|
log.Info("Migrated ancient blocks", "count", count, "elapsed", common.PrettyDuration(time.Since(start)))
|
|
}
|
|
// Flush data into ancient database.
|
|
size += rawdb.WriteAncientBlock(bc.db, block, receiptChain[i], bc.GetTd(block.Hash(), block.NumberU64()))
|
|
rawdb.WriteTxLookupEntries(batch, block)
|
|
|
|
stats.processed++
|
|
}
|
|
// Flush all tx-lookup index data.
|
|
size += batch.ValueSize()
|
|
if err := batch.Write(); err != nil {
|
|
return 0, err
|
|
}
|
|
batch.Reset()
|
|
|
|
// Sync the ancient store explicitly to ensure all data has been flushed to disk.
|
|
if err := bc.db.Sync(); err != nil {
|
|
return 0, err
|
|
}
|
|
if !updateHead(blockChain[len(blockChain)-1]) {
|
|
return 0, errors.New("side blocks can't be accepted as the ancient chain data")
|
|
}
|
|
previous = nil // disable rollback explicitly
|
|
|
|
// Wipe out canonical block data.
|
|
for _, block := range append(deleted, blockChain...) {
|
|
// Always keep genesis block in active database.
|
|
if block.NumberU64() != 0 {
|
|
rawdb.DeleteBlockWithoutNumber(batch, block.Hash(), block.NumberU64())
|
|
rawdb.DeleteCanonicalHash(batch, block.NumberU64())
|
|
}
|
|
}
|
|
if err := batch.Write(); err != nil {
|
|
return 0, err
|
|
}
|
|
batch.Reset()
|
|
|
|
// Wipe out side chain too.
|
|
for _, block := range append(deleted, blockChain...) {
|
|
// Always keep genesis block in active database.
|
|
if block.NumberU64() != 0 {
|
|
for _, hash := range rawdb.ReadAllHashes(bc.db, block.NumberU64()) {
|
|
rawdb.DeleteBlock(batch, hash, block.NumberU64())
|
|
}
|
|
}
|
|
}
|
|
if err := batch.Write(); err != nil {
|
|
return 0, err
|
|
}
|
|
return 0, nil
|
|
}
|
|
// writeLive writes blockchain and corresponding receipt chain into active store.
|
|
writeLive := func(blockChain types.Blocks, receiptChain []types.Receipts) (int, error) {
|
|
batch := bc.db.NewBatch()
|
|
for i, block := range blockChain {
|
|
// Short circuit insertion if shutting down or processing failed
|
|
if atomic.LoadInt32(&bc.procInterrupt) == 1 {
|
|
return 0, errInsertionInterrupted
|
|
}
|
|
// Short circuit if the owner header is unknown
|
|
if !bc.HasHeader(block.Hash(), block.NumberU64()) {
|
|
return i, fmt.Errorf("containing header #%d [%x…] unknown", block.Number(), block.Hash().Bytes()[:4])
|
|
}
|
|
if bc.HasBlock(block.Hash(), block.NumberU64()) {
|
|
stats.ignored++
|
|
continue
|
|
}
|
|
// Write all the data out into the database
|
|
rawdb.WriteBody(batch, block.Hash(), block.NumberU64(), block.Body())
|
|
rawdb.WriteReceipts(batch, block.Hash(), block.NumberU64(), receiptChain[i])
|
|
rawdb.WriteTxLookupEntries(batch, block)
|
|
|
|
stats.processed++
|
|
if batch.ValueSize() >= ethdb.IdealBatchSize {
|
|
if err := batch.Write(); err != nil {
|
|
return 0, err
|
|
}
|
|
size += batch.ValueSize()
|
|
batch.Reset()
|
|
}
|
|
}
|
|
if batch.ValueSize() > 0 {
|
|
size += batch.ValueSize()
|
|
if err := batch.Write(); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
updateHead(blockChain[len(blockChain)-1])
|
|
return 0, nil
|
|
}
|
|
// Write downloaded chain data and corresponding receipt chain data.
|
|
if len(ancientBlocks) > 0 {
|
|
if n, err := writeAncient(ancientBlocks, ancientReceipts); err != nil {
|
|
if err == errInsertionInterrupted {
|
|
return 0, nil
|
|
}
|
|
return n, err
|
|
}
|
|
}
|
|
if len(liveBlocks) > 0 {
|
|
if n, err := writeLive(liveBlocks, liveReceipts); err != nil {
|
|
if err == errInsertionInterrupted {
|
|
return 0, nil
|
|
}
|
|
return n, err
|
|
}
|
|
}
|
|
|
|
head := blockChain[len(blockChain)-1]
|
|
context := []interface{}{
|
|
"count", stats.processed, "elapsed", common.PrettyDuration(time.Since(start)),
|
|
"number", head.Number(), "hash", head.Hash(), "age", common.PrettyAge(time.Unix(int64(head.Time()), 0)),
|
|
"size", common.StorageSize(size),
|
|
}
|
|
if stats.ignored > 0 {
|
|
context = append(context, []interface{}{"ignored", stats.ignored}...)
|
|
}
|
|
log.Info("Imported new block receipts", context...)
|
|
|
|
return 0, nil
|
|
}
|
|
|
|
var lastWrite uint64
|
|
|
|
// writeBlockWithoutState writes only the block and its metadata to the database,
|
|
// but does not write any state. This is used to construct competing side forks
|
|
// up to the point where they exceed the canonical total difficulty.
|
|
func (bc *BlockChain) writeBlockWithoutState(block *types.Block, td *big.Int) (err error) {
|
|
bc.wg.Add(1)
|
|
defer bc.wg.Done()
|
|
|
|
if err := bc.hc.WriteTd(block.Hash(), block.NumberU64(), td); err != nil {
|
|
return err
|
|
}
|
|
rawdb.WriteBlock(bc.db, block)
|
|
|
|
return nil
|
|
}
|
|
|
|
// writeKnownBlock updates the head block flag with a known block
|
|
// and introduces chain reorg if necessary.
|
|
func (bc *BlockChain) writeKnownBlock(block *types.Block) error {
|
|
bc.wg.Add(1)
|
|
defer bc.wg.Done()
|
|
|
|
current := bc.CurrentBlock()
|
|
if block.ParentHash() != current.Hash() {
|
|
if err := bc.reorg(current, block); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
// Write the positional metadata for transaction/receipt lookups.
|
|
// Preimages here is empty, ignore it.
|
|
rawdb.WriteTxLookupEntries(bc.db, block)
|
|
|
|
bc.insert(block)
|
|
return nil
|
|
}
|
|
|
|
// WriteBlockWithState writes the block and all associated state to the database.
|
|
func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
|
|
bc.chainmu.Lock()
|
|
defer bc.chainmu.Unlock()
|
|
|
|
return bc.writeBlockWithState(block, receipts, state)
|
|
}
|
|
|
|
// writeBlockWithState writes the block and all associated state to the database,
|
|
// but is expects the chain mutex to be held.
|
|
func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
|
|
bc.wg.Add(1)
|
|
defer bc.wg.Done()
|
|
|
|
// Calculate the total difficulty of the block
|
|
ptd := bc.GetTd(block.ParentHash(), block.NumberU64()-1)
|
|
if ptd == nil {
|
|
return NonStatTy, consensus.ErrUnknownAncestor
|
|
}
|
|
// Make sure no inconsistent state is leaked during insertion
|
|
currentBlock := bc.CurrentBlock()
|
|
localTd := bc.GetTd(currentBlock.Hash(), currentBlock.NumberU64())
|
|
externTd := new(big.Int).Add(block.Difficulty(), ptd)
|
|
|
|
// Irrelevant of the canonical status, write the block itself to the database
|
|
if err := bc.hc.WriteTd(block.Hash(), block.NumberU64(), externTd); err != nil {
|
|
return NonStatTy, err
|
|
}
|
|
rawdb.WriteBlock(bc.db, block)
|
|
|
|
root, err := state.Commit(bc.chainConfig.IsEIP158(block.Number()))
|
|
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); 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.triegc.Push(root, -int64(block.NumberU64()))
|
|
|
|
if current := block.NumberU64(); current > TriesInMemory {
|
|
// If we exceeded our memory allowance, flush matured singleton nodes to disk
|
|
var (
|
|
nodes, imgs = triedb.Size()
|
|
limit = common.StorageSize(bc.cacheConfig.TrieDirtyLimit) * 1024 * 1024
|
|
)
|
|
if nodes > limit || imgs > 4*1024*1024 {
|
|
triedb.Cap(limit - ethdb.IdealBatchSize)
|
|
}
|
|
// Find the next state trie we need to commit
|
|
chosen := current - TriesInMemory
|
|
|
|
// If we exceeded out time allowance, flush an entire trie to disk
|
|
if bc.gcproc > bc.cacheConfig.TrieTimeLimit {
|
|
// If the header is missing (canonical chain behind), we're reorging a low
|
|
// diff sidechain. Suspend committing until this operation is completed.
|
|
header := bc.GetHeaderByNumber(chosen)
|
|
if header == nil {
|
|
log.Warn("Reorg in progress, trie commit postponed", "number", chosen)
|
|
} else {
|
|
// If we're exceeding limits but haven't reached a large enough memory gap,
|
|
// warn the user that the system is becoming unstable.
|
|
if chosen < lastWrite+TriesInMemory && bc.gcproc >= 2*bc.cacheConfig.TrieTimeLimit {
|
|
log.Info("State in memory for too long, committing", "time", bc.gcproc, "allowance", bc.cacheConfig.TrieTimeLimit, "optimum", float64(chosen-lastWrite)/TriesInMemory)
|
|
}
|
|
// Flush an entire trie and restart the counters
|
|
triedb.Commit(header.Root, true)
|
|
lastWrite = chosen
|
|
bc.gcproc = 0
|
|
}
|
|
}
|
|
// Garbage collect anything below our required write retention
|
|
for !bc.triegc.Empty() {
|
|
root, number := bc.triegc.Pop()
|
|
if uint64(-number) > chosen {
|
|
bc.triegc.Push(root, number)
|
|
break
|
|
}
|
|
triedb.Dereference(root.(common.Hash))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Write other block data using a batch.
|
|
batch := bc.db.NewBatch()
|
|
rawdb.WriteReceipts(batch, block.Hash(), block.NumberU64(), receipts)
|
|
|
|
// If the total difficulty is higher than our known, add it to the canonical chain
|
|
// Second clause in the if statement reduces the vulnerability to selfish mining.
|
|
// Please refer to http://www.cs.cornell.edu/~ie53/publications/btcProcFC.pdf
|
|
reorg := externTd.Cmp(localTd) > 0
|
|
currentBlock = bc.CurrentBlock()
|
|
if !reorg && externTd.Cmp(localTd) == 0 {
|
|
// Split same-difficulty blocks by number, then preferentially select
|
|
// the block generated by the local miner as the canonical block.
|
|
if block.NumberU64() < currentBlock.NumberU64() {
|
|
reorg = true
|
|
} else if block.NumberU64() == currentBlock.NumberU64() {
|
|
var currentPreserve, blockPreserve bool
|
|
if bc.shouldPreserve != nil {
|
|
currentPreserve, blockPreserve = bc.shouldPreserve(currentBlock), bc.shouldPreserve(block)
|
|
}
|
|
reorg = !currentPreserve && (blockPreserve || mrand.Float64() < 0.5)
|
|
}
|
|
}
|
|
if reorg {
|
|
// Reorganise the chain if the parent is not the head block
|
|
if block.ParentHash() != currentBlock.Hash() {
|
|
if err := bc.reorg(currentBlock, block); err != nil {
|
|
return NonStatTy, err
|
|
}
|
|
}
|
|
// Write the positional metadata for transaction/receipt lookups and preimages
|
|
rawdb.WriteTxLookupEntries(batch, block)
|
|
rawdb.WritePreimages(batch, state.Preimages())
|
|
|
|
status = CanonStatTy
|
|
} else {
|
|
status = SideStatTy
|
|
}
|
|
if err := batch.Write(); err != nil {
|
|
return NonStatTy, err
|
|
}
|
|
|
|
// Set new head.
|
|
if status == CanonStatTy {
|
|
bc.insert(block)
|
|
}
|
|
bc.futureBlocks.Remove(block.Hash())
|
|
return status, nil
|
|
}
|
|
|
|
// addFutureBlock checks if the block is within the max allowed window to get
|
|
// accepted for future processing, and returns an error if the block is too far
|
|
// ahead and was not added.
|
|
func (bc *BlockChain) addFutureBlock(block *types.Block) error {
|
|
max := uint64(time.Now().Unix() + maxTimeFutureBlocks)
|
|
if block.Time() > max {
|
|
return fmt.Errorf("future block timestamp %v > allowed %v", block.Time(), max)
|
|
}
|
|
bc.futureBlocks.Add(block.Hash(), block)
|
|
return nil
|
|
}
|
|
|
|
// InsertChain attempts to insert the given batch of blocks in to the canonical
|
|
// chain or, otherwise, create a fork. If an error is returned it will return
|
|
// the index number of the failing block as well an error describing what went
|
|
// wrong.
|
|
//
|
|
// After insertion is done, all accumulated events will be fired.
|
|
func (bc *BlockChain) InsertChain(chain types.Blocks) (int, error) {
|
|
// Sanity check that we have something meaningful to import
|
|
if len(chain) == 0 {
|
|
return 0, nil
|
|
}
|
|
|
|
bc.blockProcFeed.Send(true)
|
|
defer bc.blockProcFeed.Send(false)
|
|
|
|
// Remove already known canon-blocks
|
|
var (
|
|
block, prev *types.Block
|
|
)
|
|
// Do a sanity check that the provided chain is actually ordered and linked
|
|
for i := 1; i < len(chain); i++ {
|
|
block = chain[i]
|
|
prev = chain[i-1]
|
|
if block.NumberU64() != prev.NumberU64()+1 || block.ParentHash() != prev.Hash() {
|
|
// Chain broke ancestry, log a message (programming error) and skip insertion
|
|
log.Error("Non contiguous block insert", "number", block.Number(), "hash", block.Hash(),
|
|
"parent", block.ParentHash(), "prevnumber", prev.Number(), "prevhash", prev.Hash())
|
|
|
|
return 0, fmt.Errorf("non contiguous insert: item %d is #%d [%x…], item %d is #%d [%x…] (parent [%x…])", i-1, prev.NumberU64(),
|
|
prev.Hash().Bytes()[:4], i, block.NumberU64(), block.Hash().Bytes()[:4], block.ParentHash().Bytes()[:4])
|
|
}
|
|
}
|
|
// Pre-checks passed, start the full block imports
|
|
bc.wg.Add(1)
|
|
bc.chainmu.Lock()
|
|
n, events, logs, err := bc.insertChain(chain, true)
|
|
bc.chainmu.Unlock()
|
|
bc.wg.Done()
|
|
|
|
bc.PostChainEvents(events, logs)
|
|
return n, err
|
|
}
|
|
|
|
// insertChain is the internal implementation of InsertChain, which assumes that
|
|
// 1) chains are contiguous, and 2) The chain mutex is held.
|
|
//
|
|
// This method is split out so that import batches that require re-injecting
|
|
// historical blocks can do so without releasing the lock, which could lead to
|
|
// racey behaviour. If a sidechain import is in progress, and the historic state
|
|
// is imported, but then new canon-head is added before the actual sidechain
|
|
// completes, then the historic state could be pruned again
|
|
func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, []interface{}, []*types.Log, error) {
|
|
// If the chain is terminating, don't even bother starting up
|
|
if atomic.LoadInt32(&bc.procInterrupt) == 1 {
|
|
return 0, nil, nil, nil
|
|
}
|
|
// Start a parallel signature recovery (signer will fluke on fork transition, minimal perf loss)
|
|
senderCacher.recoverFromBlocks(types.MakeSigner(bc.chainConfig, chain[0].Number()), chain)
|
|
|
|
// A queued approach to delivering events. This is generally
|
|
// faster than direct delivery and requires much less mutex
|
|
// acquiring.
|
|
var (
|
|
stats = insertStats{startTime: mclock.Now()}
|
|
events = make([]interface{}, 0, len(chain))
|
|
lastCanon *types.Block
|
|
coalescedLogs []*types.Log
|
|
)
|
|
// Start the parallel header verifier
|
|
headers := make([]*types.Header, len(chain))
|
|
seals := make([]bool, len(chain))
|
|
|
|
for i, block := range chain {
|
|
headers[i] = block.Header()
|
|
seals[i] = verifySeals
|
|
}
|
|
abort, results := bc.engine.VerifyHeaders(bc, headers, seals)
|
|
defer close(abort)
|
|
|
|
// Peek the error for the first block to decide the directing import logic
|
|
it := newInsertIterator(chain, results, bc.validator)
|
|
|
|
block, err := it.next()
|
|
|
|
// Left-trim all the known blocks
|
|
if err == ErrKnownBlock {
|
|
// First block (and state) is known
|
|
// 1. We did a roll-back, and should now do a re-import
|
|
// 2. The block is stored as a sidechain, and is lying about it's stateroot, and passes a stateroot
|
|
// from the canonical chain, which has not been verified.
|
|
// Skip all known blocks that are behind us
|
|
var (
|
|
current = bc.CurrentBlock()
|
|
localTd = bc.GetTd(current.Hash(), current.NumberU64())
|
|
externTd = bc.GetTd(block.ParentHash(), block.NumberU64()-1) // The first block can't be nil
|
|
)
|
|
for block != nil && err == ErrKnownBlock {
|
|
externTd = new(big.Int).Add(externTd, block.Difficulty())
|
|
if localTd.Cmp(externTd) < 0 {
|
|
break
|
|
}
|
|
log.Debug("Ignoring already known block", "number", block.Number(), "hash", block.Hash())
|
|
stats.ignored++
|
|
|
|
block, err = it.next()
|
|
}
|
|
// The remaining blocks are still known blocks, the only scenario here is:
|
|
// During the fast sync, the pivot point is already submitted but rollback
|
|
// happens. Then node resets the head full block to a lower height via `rollback`
|
|
// and leaves a few known blocks in the database.
|
|
//
|
|
// When node runs a fast sync again, it can re-import a batch of known blocks via
|
|
// `insertChain` while a part of them have higher total difficulty than current
|
|
// head full block(new pivot point).
|
|
for block != nil && err == ErrKnownBlock {
|
|
log.Debug("Writing previously known block", "number", block.Number(), "hash", block.Hash())
|
|
if err := bc.writeKnownBlock(block); err != nil {
|
|
return it.index, nil, nil, err
|
|
}
|
|
lastCanon = block
|
|
|
|
block, err = it.next()
|
|
}
|
|
// Falls through to the block import
|
|
}
|
|
switch {
|
|
// First block is pruned, insert as sidechain and reorg only if TD grows enough
|
|
case err == consensus.ErrPrunedAncestor:
|
|
log.Debug("Pruned ancestor, inserting as sidechain", "number", block.Number(), "hash", block.Hash())
|
|
return bc.insertSideChain(block, it)
|
|
|
|
// First block is future, shove it (and all children) to the future queue (unknown ancestor)
|
|
case err == consensus.ErrFutureBlock || (err == consensus.ErrUnknownAncestor && bc.futureBlocks.Contains(it.first().ParentHash())):
|
|
for block != nil && (it.index == 0 || err == consensus.ErrUnknownAncestor) {
|
|
log.Debug("Future block, postponing import", "number", block.Number(), "hash", block.Hash())
|
|
if err := bc.addFutureBlock(block); err != nil {
|
|
return it.index, events, coalescedLogs, err
|
|
}
|
|
block, err = it.next()
|
|
}
|
|
stats.queued += it.processed()
|
|
stats.ignored += it.remaining()
|
|
|
|
// If there are any still remaining, mark as ignored
|
|
return it.index, events, coalescedLogs, err
|
|
|
|
// Some other error occurred, abort
|
|
case err != nil:
|
|
stats.ignored += len(it.chain)
|
|
bc.reportBlock(block, nil, err)
|
|
return it.index, events, coalescedLogs, err
|
|
}
|
|
// No validation errors for the first block (or chain prefix skipped)
|
|
for ; block != nil && err == nil || err == ErrKnownBlock; block, err = it.next() {
|
|
// If the chain is terminating, stop processing blocks
|
|
if atomic.LoadInt32(&bc.procInterrupt) == 1 {
|
|
log.Debug("Premature abort during blocks processing")
|
|
break
|
|
}
|
|
// If the header is a banned one, straight out abort
|
|
if BadHashes[block.Hash()] {
|
|
bc.reportBlock(block, nil, ErrBlacklistedHash)
|
|
return it.index, events, coalescedLogs, ErrBlacklistedHash
|
|
}
|
|
// If the block is known (in the middle of the chain), it's a special case for
|
|
// Clique blocks where they can share state among each other, so importing an
|
|
// older block might complete the state of the subsequent one. In this case,
|
|
// just skip the block (we already validated it once fully (and crashed), since
|
|
// its header and body was already in the database).
|
|
if err == ErrKnownBlock {
|
|
logger := log.Debug
|
|
if bc.chainConfig.Clique == nil {
|
|
logger = log.Warn
|
|
}
|
|
logger("Inserted known block", "number", block.Number(), "hash", block.Hash(),
|
|
"uncles", len(block.Uncles()), "txs", len(block.Transactions()), "gas", block.GasUsed(),
|
|
"root", block.Root())
|
|
|
|
if err := bc.writeKnownBlock(block); err != nil {
|
|
return it.index, nil, nil, err
|
|
}
|
|
stats.processed++
|
|
|
|
// We can assume that logs are empty here, since the only way for consecutive
|
|
// Clique blocks to have the same state is if there are no transactions.
|
|
events = append(events, ChainEvent{block, block.Hash(), nil})
|
|
lastCanon = block
|
|
|
|
continue
|
|
}
|
|
// Retrieve the parent block and it's state to execute on top
|
|
start := time.Now()
|
|
|
|
parent := it.previous()
|
|
if parent == nil {
|
|
parent = bc.GetHeader(block.ParentHash(), block.NumberU64()-1)
|
|
}
|
|
statedb, err := state.New(parent.Root, bc.stateCache)
|
|
if err != nil {
|
|
return it.index, events, coalescedLogs, err
|
|
}
|
|
// If we have a followup block, run that against the current state to pre-cache
|
|
// transactions and probabilistically some of the account/storage trie nodes.
|
|
var followupInterrupt uint32
|
|
|
|
if !bc.cacheConfig.TrieCleanNoPrefetch {
|
|
if followup, err := it.peek(); followup != nil && err == nil {
|
|
go func(start time.Time) {
|
|
throwaway, _ := state.New(parent.Root, bc.stateCache)
|
|
bc.prefetcher.Prefetch(followup, throwaway, bc.vmConfig, &followupInterrupt)
|
|
|
|
blockPrefetchExecuteTimer.Update(time.Since(start))
|
|
if atomic.LoadUint32(&followupInterrupt) == 1 {
|
|
blockPrefetchInterruptMeter.Mark(1)
|
|
}
|
|
}(time.Now())
|
|
}
|
|
}
|
|
// Process block using the parent state as reference point
|
|
substart := time.Now()
|
|
receipts, logs, usedGas, err := bc.processor.Process(block, statedb, bc.vmConfig)
|
|
if err != nil {
|
|
bc.reportBlock(block, receipts, err)
|
|
atomic.StoreUint32(&followupInterrupt, 1)
|
|
return it.index, events, coalescedLogs, err
|
|
}
|
|
// Update the metrics touched during block processing
|
|
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
|
|
|
|
triehash := statedb.AccountHashes + statedb.StorageHashes // Save to not double count in validation
|
|
trieproc := statedb.AccountReads + statedb.AccountUpdates
|
|
trieproc += statedb.StorageReads + statedb.StorageUpdates
|
|
|
|
blockExecutionTimer.Update(time.Since(substart) - trieproc - triehash)
|
|
|
|
// Validate the state using the default validator
|
|
substart = time.Now()
|
|
if err := bc.validator.ValidateState(block, statedb, receipts, usedGas); err != nil {
|
|
bc.reportBlock(block, receipts, err)
|
|
atomic.StoreUint32(&followupInterrupt, 1)
|
|
return it.index, events, coalescedLogs, err
|
|
}
|
|
proctime := time.Since(start)
|
|
|
|
// Update the metrics touched during block validation
|
|
accountHashTimer.Update(statedb.AccountHashes) // Account hashes are complete, we can mark them
|
|
storageHashTimer.Update(statedb.StorageHashes) // Storage hashes are complete, we can mark them
|
|
|
|
blockValidationTimer.Update(time.Since(substart) - (statedb.AccountHashes + statedb.StorageHashes - triehash))
|
|
|
|
// Write the block to the chain and get the status.
|
|
substart = time.Now()
|
|
status, err := bc.writeBlockWithState(block, receipts, statedb)
|
|
if err != nil {
|
|
atomic.StoreUint32(&followupInterrupt, 1)
|
|
return it.index, events, coalescedLogs, err
|
|
}
|
|
atomic.StoreUint32(&followupInterrupt, 1)
|
|
|
|
// Update the metrics touched during block commit
|
|
accountCommitTimer.Update(statedb.AccountCommits) // Account commits are complete, we can mark them
|
|
storageCommitTimer.Update(statedb.StorageCommits) // Storage commits are complete, we can mark them
|
|
|
|
blockWriteTimer.Update(time.Since(substart) - statedb.AccountCommits - statedb.StorageCommits)
|
|
blockInsertTimer.UpdateSince(start)
|
|
|
|
switch status {
|
|
case CanonStatTy:
|
|
log.Debug("Inserted new block", "number", block.Number(), "hash", block.Hash(),
|
|
"uncles", len(block.Uncles()), "txs", len(block.Transactions()), "gas", block.GasUsed(),
|
|
"elapsed", common.PrettyDuration(time.Since(start)),
|
|
"root", block.Root())
|
|
|
|
coalescedLogs = append(coalescedLogs, logs...)
|
|
events = append(events, ChainEvent{block, block.Hash(), logs})
|
|
lastCanon = block
|
|
|
|
// Only count canonical blocks for GC processing time
|
|
bc.gcproc += proctime
|
|
|
|
case SideStatTy:
|
|
log.Debug("Inserted forked block", "number", block.Number(), "hash", block.Hash(),
|
|
"diff", block.Difficulty(), "elapsed", common.PrettyDuration(time.Since(start)),
|
|
"txs", len(block.Transactions()), "gas", block.GasUsed(), "uncles", len(block.Uncles()),
|
|
"root", block.Root())
|
|
events = append(events, ChainSideEvent{block})
|
|
|
|
default:
|
|
// This in theory is impossible, but lets be nice to our future selves and leave
|
|
// a log, instead of trying to track down blocks imports that don't emit logs.
|
|
log.Warn("Inserted block with unknown status", "number", block.Number(), "hash", block.Hash(),
|
|
"diff", block.Difficulty(), "elapsed", common.PrettyDuration(time.Since(start)),
|
|
"txs", len(block.Transactions()), "gas", block.GasUsed(), "uncles", len(block.Uncles()),
|
|
"root", block.Root())
|
|
}
|
|
stats.processed++
|
|
stats.usedGas += usedGas
|
|
|
|
dirty, _ := bc.stateCache.TrieDB().Size()
|
|
stats.report(chain, it.index, dirty)
|
|
}
|
|
// Any blocks remaining here? The only ones we care about are the future ones
|
|
if block != nil && err == consensus.ErrFutureBlock {
|
|
if err := bc.addFutureBlock(block); err != nil {
|
|
return it.index, events, coalescedLogs, err
|
|
}
|
|
block, err = it.next()
|
|
|
|
for ; block != nil && err == consensus.ErrUnknownAncestor; block, err = it.next() {
|
|
if err := bc.addFutureBlock(block); err != nil {
|
|
return it.index, events, coalescedLogs, err
|
|
}
|
|
stats.queued++
|
|
}
|
|
}
|
|
stats.ignored += it.remaining()
|
|
|
|
// Append a single chain head event if we've progressed the chain
|
|
if lastCanon != nil && bc.CurrentBlock().Hash() == lastCanon.Hash() {
|
|
events = append(events, ChainHeadEvent{lastCanon})
|
|
}
|
|
return it.index, events, coalescedLogs, err
|
|
}
|
|
|
|
// insertSideChain is called when an import batch hits upon a pruned ancestor
|
|
// error, which happens when a sidechain with a sufficiently old fork-block is
|
|
// found.
|
|
//
|
|
// The method writes all (header-and-body-valid) blocks to disk, then tries to
|
|
// switch over to the new chain if the TD exceeded the current chain.
|
|
func (bc *BlockChain) insertSideChain(block *types.Block, it *insertIterator) (int, []interface{}, []*types.Log, error) {
|
|
var (
|
|
externTd *big.Int
|
|
current = bc.CurrentBlock()
|
|
)
|
|
// The first sidechain block error is already verified to be ErrPrunedAncestor.
|
|
// Since we don't import them here, we expect ErrUnknownAncestor for the remaining
|
|
// ones. Any other errors means that the block is invalid, and should not be written
|
|
// to disk.
|
|
err := consensus.ErrPrunedAncestor
|
|
for ; block != nil && (err == consensus.ErrPrunedAncestor); block, err = it.next() {
|
|
// Check the canonical state root for that number
|
|
if number := block.NumberU64(); current.NumberU64() >= number {
|
|
canonical := bc.GetBlockByNumber(number)
|
|
if canonical != nil && canonical.Hash() == block.Hash() {
|
|
// Not a sidechain block, this is a re-import of a canon block which has it's state pruned
|
|
continue
|
|
}
|
|
if canonical != nil && canonical.Root() == block.Root() {
|
|
// This is most likely a shadow-state attack. When a fork is imported into the
|
|
// database, and it eventually reaches a block height which is not pruned, we
|
|
// just found that the state already exist! This means that the sidechain block
|
|
// refers to a state which already exists in our canon chain.
|
|
//
|
|
// If left unchecked, we would now proceed importing the blocks, without actually
|
|
// having verified the state of the previous blocks.
|
|
log.Warn("Sidechain ghost-state attack detected", "number", block.NumberU64(), "sideroot", block.Root(), "canonroot", canonical.Root())
|
|
|
|
// If someone legitimately side-mines blocks, they would still be imported as usual. However,
|
|
// we cannot risk writing unverified blocks to disk when they obviously target the pruning
|
|
// mechanism.
|
|
return it.index, nil, nil, errors.New("sidechain ghost-state attack")
|
|
}
|
|
}
|
|
if externTd == nil {
|
|
externTd = bc.GetTd(block.ParentHash(), block.NumberU64()-1)
|
|
}
|
|
externTd = new(big.Int).Add(externTd, block.Difficulty())
|
|
|
|
if !bc.HasBlock(block.Hash(), block.NumberU64()) {
|
|
start := time.Now()
|
|
if err := bc.writeBlockWithoutState(block, externTd); err != nil {
|
|
return it.index, nil, nil, err
|
|
}
|
|
log.Debug("Injected sidechain block", "number", block.Number(), "hash", block.Hash(),
|
|
"diff", block.Difficulty(), "elapsed", common.PrettyDuration(time.Since(start)),
|
|
"txs", len(block.Transactions()), "gas", block.GasUsed(), "uncles", len(block.Uncles()),
|
|
"root", block.Root())
|
|
}
|
|
}
|
|
// At this point, we've written all sidechain blocks to database. Loop ended
|
|
// either on some other error or all were processed. If there was some other
|
|
// error, we can ignore the rest of those blocks.
|
|
//
|
|
// If the externTd was larger than our local TD, we now need to reimport the previous
|
|
// blocks to regenerate the required state
|
|
localTd := bc.GetTd(current.Hash(), current.NumberU64())
|
|
if localTd.Cmp(externTd) > 0 {
|
|
log.Info("Sidechain written to disk", "start", it.first().NumberU64(), "end", it.previous().Number, "sidetd", externTd, "localtd", localTd)
|
|
return it.index, nil, nil, err
|
|
}
|
|
// Gather all the sidechain hashes (full blocks may be memory heavy)
|
|
var (
|
|
hashes []common.Hash
|
|
numbers []uint64
|
|
)
|
|
parent := it.previous()
|
|
for parent != nil && !bc.HasState(parent.Root) {
|
|
hashes = append(hashes, parent.Hash())
|
|
numbers = append(numbers, parent.Number.Uint64())
|
|
|
|
parent = bc.GetHeader(parent.ParentHash, parent.Number.Uint64()-1)
|
|
}
|
|
if parent == nil {
|
|
return it.index, nil, nil, errors.New("missing parent")
|
|
}
|
|
// Import all the pruned blocks to make the state available
|
|
var (
|
|
blocks []*types.Block
|
|
memory common.StorageSize
|
|
)
|
|
for i := len(hashes) - 1; i >= 0; i-- {
|
|
// Append the next block to our batch
|
|
block := bc.GetBlock(hashes[i], numbers[i])
|
|
|
|
blocks = append(blocks, block)
|
|
memory += block.Size()
|
|
|
|
// If memory use grew too large, import and continue. Sadly we need to discard
|
|
// all raised events and logs from notifications since we're too heavy on the
|
|
// memory here.
|
|
if len(blocks) >= 2048 || memory > 64*1024*1024 {
|
|
log.Info("Importing heavy sidechain segment", "blocks", len(blocks), "start", blocks[0].NumberU64(), "end", block.NumberU64())
|
|
if _, _, _, err := bc.insertChain(blocks, false); err != nil {
|
|
return 0, nil, nil, err
|
|
}
|
|
blocks, memory = blocks[:0], 0
|
|
|
|
// If the chain is terminating, stop processing blocks
|
|
if atomic.LoadInt32(&bc.procInterrupt) == 1 {
|
|
log.Debug("Premature abort during blocks processing")
|
|
return 0, nil, nil, nil
|
|
}
|
|
}
|
|
}
|
|
if len(blocks) > 0 {
|
|
log.Info("Importing sidechain segment", "start", blocks[0].NumberU64(), "end", blocks[len(blocks)-1].NumberU64())
|
|
return bc.insertChain(blocks, false)
|
|
}
|
|
return 0, nil, nil, nil
|
|
}
|
|
|
|
// reorg takes two blocks, an old chain and a new chain and will reconstruct the
|
|
// blocks and inserts them to be part of the new canonical chain and accumulates
|
|
// potential missing transactions and post an event about them.
|
|
func (bc *BlockChain) reorg(oldBlock, newBlock *types.Block) error {
|
|
var (
|
|
newChain types.Blocks
|
|
oldChain types.Blocks
|
|
commonBlock *types.Block
|
|
|
|
deletedTxs types.Transactions
|
|
addedTxs types.Transactions
|
|
|
|
deletedLogs []*types.Log
|
|
rebirthLogs []*types.Log
|
|
|
|
// collectLogs collects the logs that were generated during the
|
|
// processing of the block that corresponds with the given hash.
|
|
// These logs are later announced as deleted or reborn
|
|
collectLogs = func(hash common.Hash, removed bool) {
|
|
number := bc.hc.GetBlockNumber(hash)
|
|
if number == nil {
|
|
return
|
|
}
|
|
receipts := rawdb.ReadReceipts(bc.db, hash, *number, bc.chainConfig)
|
|
for _, receipt := range receipts {
|
|
for _, log := range receipt.Logs {
|
|
l := *log
|
|
if removed {
|
|
l.Removed = true
|
|
deletedLogs = append(deletedLogs, &l)
|
|
} else {
|
|
rebirthLogs = append(rebirthLogs, &l)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
)
|
|
// Reduce the longer chain to the same number as the shorter one
|
|
if oldBlock.NumberU64() > newBlock.NumberU64() {
|
|
// Old chain is longer, gather all transactions and logs as deleted ones
|
|
for ; oldBlock != nil && oldBlock.NumberU64() != newBlock.NumberU64(); oldBlock = bc.GetBlock(oldBlock.ParentHash(), oldBlock.NumberU64()-1) {
|
|
oldChain = append(oldChain, oldBlock)
|
|
deletedTxs = append(deletedTxs, oldBlock.Transactions()...)
|
|
collectLogs(oldBlock.Hash(), true)
|
|
}
|
|
} else {
|
|
// New chain is longer, stash all blocks away for subsequent insertion
|
|
for ; newBlock != nil && newBlock.NumberU64() != oldBlock.NumberU64(); newBlock = bc.GetBlock(newBlock.ParentHash(), newBlock.NumberU64()-1) {
|
|
newChain = append(newChain, newBlock)
|
|
}
|
|
}
|
|
if oldBlock == nil {
|
|
return fmt.Errorf("invalid old chain")
|
|
}
|
|
if newBlock == nil {
|
|
return fmt.Errorf("invalid new chain")
|
|
}
|
|
// Both sides of the reorg are at the same number, reduce both until the common
|
|
// ancestor is found
|
|
for {
|
|
// If the common ancestor was found, bail out
|
|
if oldBlock.Hash() == newBlock.Hash() {
|
|
commonBlock = oldBlock
|
|
break
|
|
}
|
|
// Remove an old block as well as stash away a new block
|
|
oldChain = append(oldChain, oldBlock)
|
|
deletedTxs = append(deletedTxs, oldBlock.Transactions()...)
|
|
collectLogs(oldBlock.Hash(), true)
|
|
|
|
newChain = append(newChain, newBlock)
|
|
|
|
// Step back with both chains
|
|
oldBlock = bc.GetBlock(oldBlock.ParentHash(), oldBlock.NumberU64()-1)
|
|
if oldBlock == nil {
|
|
return fmt.Errorf("invalid old chain")
|
|
}
|
|
newBlock = bc.GetBlock(newBlock.ParentHash(), newBlock.NumberU64()-1)
|
|
if newBlock == nil {
|
|
return fmt.Errorf("invalid new chain")
|
|
}
|
|
}
|
|
// Ensure the user sees large reorgs
|
|
if len(oldChain) > 0 && len(newChain) > 0 {
|
|
logFn := log.Debug
|
|
if len(oldChain) > 63 {
|
|
logFn = log.Warn
|
|
}
|
|
logFn("Chain split detected", "number", commonBlock.Number(), "hash", commonBlock.Hash(),
|
|
"drop", len(oldChain), "dropfrom", oldChain[0].Hash(), "add", len(newChain), "addfrom", newChain[0].Hash())
|
|
} else {
|
|
log.Error("Impossible reorg, please file an issue", "oldnum", oldBlock.Number(), "oldhash", oldBlock.Hash(), "newnum", newBlock.Number(), "newhash", newBlock.Hash())
|
|
}
|
|
// Insert the new chain(except the head block(reverse order)),
|
|
// taking care of the proper incremental order.
|
|
for i := len(newChain) - 1; i >= 1; i-- {
|
|
// Insert the block in the canonical way, re-writing history
|
|
bc.insert(newChain[i])
|
|
|
|
// Collect reborn logs due to chain reorg
|
|
collectLogs(newChain[i].Hash(), false)
|
|
|
|
// Write lookup entries for hash based transaction/receipt searches
|
|
rawdb.WriteTxLookupEntries(bc.db, newChain[i])
|
|
addedTxs = append(addedTxs, newChain[i].Transactions()...)
|
|
}
|
|
// When transactions get deleted from the database, the receipts that were
|
|
// created in the fork must also be deleted
|
|
batch := bc.db.NewBatch()
|
|
for _, tx := range types.TxDifference(deletedTxs, addedTxs) {
|
|
rawdb.DeleteTxLookupEntry(batch, tx.Hash())
|
|
}
|
|
// Delete any canonical number assignments above the new head
|
|
number := bc.CurrentBlock().NumberU64()
|
|
for i := number + 1; ; i++ {
|
|
hash := rawdb.ReadCanonicalHash(bc.db, i)
|
|
if hash == (common.Hash{}) {
|
|
break
|
|
}
|
|
rawdb.DeleteCanonicalHash(batch, i)
|
|
}
|
|
batch.Write()
|
|
// If any logs need to be fired, do it now. In theory we could avoid creating
|
|
// this goroutine if there are no events to fire, but realistcally that only
|
|
// ever happens if we're reorging empty blocks, which will only happen on idle
|
|
// networks where performance is not an issue either way.
|
|
//
|
|
// TODO(karalabe): Can we get rid of the goroutine somehow to guarantee correct
|
|
// event ordering?
|
|
go func() {
|
|
if len(deletedLogs) > 0 {
|
|
bc.rmLogsFeed.Send(RemovedLogsEvent{deletedLogs})
|
|
}
|
|
if len(rebirthLogs) > 0 {
|
|
bc.logsFeed.Send(rebirthLogs)
|
|
}
|
|
if len(oldChain) > 0 {
|
|
for _, block := range oldChain {
|
|
bc.chainSideFeed.Send(ChainSideEvent{Block: block})
|
|
}
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
// PostChainEvents iterates over the events generated by a chain insertion and
|
|
// posts them into the event feed.
|
|
// TODO: Should not expose PostChainEvents. The chain events should be posted in WriteBlock.
|
|
func (bc *BlockChain) PostChainEvents(events []interface{}, logs []*types.Log) {
|
|
// post event logs for further processing
|
|
if logs != nil {
|
|
bc.logsFeed.Send(logs)
|
|
}
|
|
for _, event := range events {
|
|
switch ev := event.(type) {
|
|
case ChainEvent:
|
|
bc.chainFeed.Send(ev)
|
|
|
|
case ChainHeadEvent:
|
|
bc.chainHeadFeed.Send(ev)
|
|
|
|
case ChainSideEvent:
|
|
bc.chainSideFeed.Send(ev)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (bc *BlockChain) update() {
|
|
futureTimer := time.NewTicker(5 * time.Second)
|
|
defer futureTimer.Stop()
|
|
for {
|
|
select {
|
|
case <-futureTimer.C:
|
|
bc.procFutureBlocks()
|
|
case <-bc.quit:
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// BadBlocks returns a list of the last 'bad blocks' that the client has seen on the network
|
|
func (bc *BlockChain) BadBlocks() []*types.Block {
|
|
blocks := make([]*types.Block, 0, bc.badBlocks.Len())
|
|
for _, hash := range bc.badBlocks.Keys() {
|
|
if blk, exist := bc.badBlocks.Peek(hash); exist {
|
|
block := blk.(*types.Block)
|
|
blocks = append(blocks, block)
|
|
}
|
|
}
|
|
return blocks
|
|
}
|
|
|
|
// addBadBlock adds a bad block to the bad-block LRU cache
|
|
func (bc *BlockChain) addBadBlock(block *types.Block) {
|
|
bc.badBlocks.Add(block.Hash(), block)
|
|
}
|
|
|
|
// reportBlock logs a bad block error.
|
|
func (bc *BlockChain) reportBlock(block *types.Block, receipts types.Receipts, err error) {
|
|
bc.addBadBlock(block)
|
|
|
|
var receiptString string
|
|
for i, receipt := range receipts {
|
|
receiptString += fmt.Sprintf("\t %d: cumulative: %v gas: %v contract: %v status: %v tx: %v logs: %v bloom: %x state: %x\n",
|
|
i, receipt.CumulativeGasUsed, receipt.GasUsed, receipt.ContractAddress.Hex(),
|
|
receipt.Status, receipt.TxHash.Hex(), receipt.Logs, receipt.Bloom, receipt.PostState)
|
|
}
|
|
log.Error(fmt.Sprintf(`
|
|
########## BAD BLOCK #########
|
|
Chain config: %v
|
|
|
|
Number: %v
|
|
Hash: 0x%x
|
|
%v
|
|
|
|
Error: %v
|
|
##############################
|
|
`, bc.chainConfig, block.Number(), block.Hash(), receiptString, err))
|
|
}
|
|
|
|
// InsertHeaderChain attempts to insert the given header chain in to the local
|
|
// chain, possibly creating a reorg. If an error is returned, it will return the
|
|
// index number of the failing header as well an error describing what went wrong.
|
|
//
|
|
// The verify parameter can be used to fine tune whether nonce verification
|
|
// should be done or not. The reason behind the optional check is because some
|
|
// of the header retrieval mechanisms already need to verify nonces, as well as
|
|
// because nonces can be verified sparsely, not needing to check each.
|
|
func (bc *BlockChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error) {
|
|
start := time.Now()
|
|
if i, err := bc.hc.ValidateHeaderChain(chain, checkFreq); err != nil {
|
|
return i, err
|
|
}
|
|
|
|
// Make sure only one thread manipulates the chain at once
|
|
bc.chainmu.Lock()
|
|
defer bc.chainmu.Unlock()
|
|
|
|
bc.wg.Add(1)
|
|
defer bc.wg.Done()
|
|
|
|
whFunc := func(header *types.Header) error {
|
|
_, err := bc.hc.WriteHeader(header)
|
|
return err
|
|
}
|
|
return bc.hc.InsertHeaderChain(chain, whFunc, start)
|
|
}
|
|
|
|
// CurrentHeader retrieves the current head header of the canonical chain. The
|
|
// header is retrieved from the HeaderChain's internal cache.
|
|
func (bc *BlockChain) CurrentHeader() *types.Header {
|
|
return bc.hc.CurrentHeader()
|
|
}
|
|
|
|
// GetTd retrieves a block's total difficulty in the canonical chain from the
|
|
// database by hash and number, caching it if found.
|
|
func (bc *BlockChain) GetTd(hash common.Hash, number uint64) *big.Int {
|
|
return bc.hc.GetTd(hash, number)
|
|
}
|
|
|
|
// GetTdByHash retrieves a block's total difficulty in the canonical chain from the
|
|
// database by hash, caching it if found.
|
|
func (bc *BlockChain) GetTdByHash(hash common.Hash) *big.Int {
|
|
return bc.hc.GetTdByHash(hash)
|
|
}
|
|
|
|
// GetHeader retrieves a block header from the database by hash and number,
|
|
// caching it if found.
|
|
func (bc *BlockChain) GetHeader(hash common.Hash, number uint64) *types.Header {
|
|
return bc.hc.GetHeader(hash, number)
|
|
}
|
|
|
|
// GetHeaderByHash retrieves a block header from the database by hash, caching it if
|
|
// found.
|
|
func (bc *BlockChain) GetHeaderByHash(hash common.Hash) *types.Header {
|
|
return bc.hc.GetHeaderByHash(hash)
|
|
}
|
|
|
|
// HasHeader checks if a block header is present in the database or not, caching
|
|
// it if present.
|
|
func (bc *BlockChain) HasHeader(hash common.Hash, number uint64) bool {
|
|
return bc.hc.HasHeader(hash, number)
|
|
}
|
|
|
|
// GetBlockHashesFromHash retrieves a number of block hashes starting at a given
|
|
// hash, fetching towards the genesis block.
|
|
func (bc *BlockChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash {
|
|
return bc.hc.GetBlockHashesFromHash(hash, max)
|
|
}
|
|
|
|
// GetAncestor retrieves the Nth ancestor of a given block. It assumes that either the given block or
|
|
// a close ancestor of it is canonical. maxNonCanonical points to a downwards counter limiting the
|
|
// number of blocks to be individually checked before we reach the canonical chain.
|
|
//
|
|
// Note: ancestor == 0 returns the same block, 1 returns its parent and so on.
|
|
func (bc *BlockChain) GetAncestor(hash common.Hash, number, ancestor uint64, maxNonCanonical *uint64) (common.Hash, uint64) {
|
|
bc.chainmu.RLock()
|
|
defer bc.chainmu.RUnlock()
|
|
|
|
return bc.hc.GetAncestor(hash, number, ancestor, maxNonCanonical)
|
|
}
|
|
|
|
// GetHeaderByNumber retrieves a block header from the database by number,
|
|
// caching it (associated with its hash) if found.
|
|
func (bc *BlockChain) GetHeaderByNumber(number uint64) *types.Header {
|
|
return bc.hc.GetHeaderByNumber(number)
|
|
}
|
|
|
|
// Config retrieves the blockchain's chain configuration.
|
|
func (bc *BlockChain) Config() *params.ChainConfig { return bc.chainConfig }
|
|
|
|
// Engine retrieves the blockchain's consensus engine.
|
|
func (bc *BlockChain) Engine() consensus.Engine { return bc.engine }
|
|
|
|
// SubscribeRemovedLogsEvent registers a subscription of RemovedLogsEvent.
|
|
func (bc *BlockChain) SubscribeRemovedLogsEvent(ch chan<- RemovedLogsEvent) event.Subscription {
|
|
return bc.scope.Track(bc.rmLogsFeed.Subscribe(ch))
|
|
}
|
|
|
|
// SubscribeChainEvent registers a subscription of ChainEvent.
|
|
func (bc *BlockChain) SubscribeChainEvent(ch chan<- ChainEvent) event.Subscription {
|
|
return bc.scope.Track(bc.chainFeed.Subscribe(ch))
|
|
}
|
|
|
|
// SubscribeChainHeadEvent registers a subscription of ChainHeadEvent.
|
|
func (bc *BlockChain) SubscribeChainHeadEvent(ch chan<- ChainHeadEvent) event.Subscription {
|
|
return bc.scope.Track(bc.chainHeadFeed.Subscribe(ch))
|
|
}
|
|
|
|
// SubscribeChainSideEvent registers a subscription of ChainSideEvent.
|
|
func (bc *BlockChain) SubscribeChainSideEvent(ch chan<- ChainSideEvent) event.Subscription {
|
|
return bc.scope.Track(bc.chainSideFeed.Subscribe(ch))
|
|
}
|
|
|
|
// SubscribeLogsEvent registers a subscription of []*types.Log.
|
|
func (bc *BlockChain) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
|
|
return bc.scope.Track(bc.logsFeed.Subscribe(ch))
|
|
}
|
|
|
|
// SubscribeBlockProcessingEvent registers a subscription of bool where true means
|
|
// block processing has started while false means it has stopped.
|
|
func (bc *BlockChain) SubscribeBlockProcessingEvent(ch chan<- bool) event.Subscription {
|
|
return bc.scope.Track(bc.blockProcFeed.Subscribe(ch))
|
|
}
|