12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768 |
- // 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 (
- "context"
- "errors"
- "fmt"
- "io"
- "math/big"
- mrand "math/rand"
- "sort"
- "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/mps"
- "github.com/ethereum/go-ethereum/core/privatecache"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "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/qlight"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- lru "github.com/hashicorp/golang-lru"
- )
- var (
- headBlockGauge = metrics.NewRegisteredGauge("chain/head/block", nil)
- headHeaderGauge = metrics.NewRegisteredGauge("chain/head/header", nil)
- headFastBlockGauge = metrics.NewRegisteredGauge("chain/head/receipt", nil)
- 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)
- snapshotAccountReadTimer = metrics.NewRegisteredTimer("chain/snapshot/account/reads", nil)
- snapshotStorageReadTimer = metrics.NewRegisteredTimer("chain/snapshot/storage/reads", nil)
- snapshotCommitTimer = metrics.NewRegisteredTimer("chain/snapshot/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)
- 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)
- 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
- txLookupCacheLimit = 1024
- maxFutureBlocks = 256
- maxTimeFutureBlocks = 30
- 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
- // - 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
- )
- // 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
- TrieCleanJournal string // Disk journal for saving clean cache entries.
- TrieCleanRejournal time.Duration // Time interval to dump clean cache to disk periodically
- 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
- SnapshotLimit int // Memory allowance (MB) to use for caching snapshot entries in memory
- Preimages bool // Whether to store preimage of trie key to the disk
- 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,
- }
- // 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
- snaps *snapshot.Tree // Snapshot tree for fast trie leaf access
- triegc *prque.Prque // Priority queue mapping block numbers to tries to gc
- gcproc time.Duration // Accumulates canonical block processing for trie dumping
- // 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
- 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
- txLookupCache *lru.Cache // Cache for the most recent transaction lookup data.
- futureBlocks *lru.Cache // future blocks are blocks added for later processing
- quit chan struct{} // blockchain quit channel
- wg sync.WaitGroup // chain processing wait group for shutting down
- running int32 // 0 if chain is running, 1 when stopped
- procInterrupt int32 // interrupt signaler for block processing
- engine consensus.Engine
- validator Validator // Block and state validator interface
- prefetcher Prefetcher
- processor Processor // Block transaction processor interface
- vmConfig vm.Config
- 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.
- // Quorum
- quorumConfig *QuorumChainConfig // quorum chain config holds all the possible configuration fields for GoQuorum
- setPrivateState func([]*types.Log, *state.StateDB, types.PrivateStateIdentifier) // Function to check extension and set private state
- // privateStateManager manages private state(s) for this blockchain
- privateStateManager mps.PrivateStateManager
- privateStateRootHashValidator qlight.PrivateStateRootHashValidator
- // End Quorum
- }
- // 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, txLookupLimit *uint64, quorumChainConfig *QuorumChainConfig) (*BlockChain, error) {
- if cacheConfig == nil {
- cacheConfig = defaultCacheConfig
- }
- if quorumChainConfig == nil {
- quorumChainConfig = &QuorumChainConfig{}
- }
- bodyCache, _ := lru.New(bodyCacheLimit)
- bodyRLPCache, _ := lru.New(bodyCacheLimit)
- receiptsCache, _ := lru.New(receiptsCacheLimit)
- blockCache, _ := lru.New(blockCacheLimit)
- txLookupCache, _ := lru.New(txLookupCacheLimit)
- futureBlocks, _ := lru.New(maxFutureBlocks)
- bc := &BlockChain{
- chainConfig: chainConfig,
- cacheConfig: cacheConfig,
- db: db,
- triegc: prque.New(nil),
- stateCache: state.NewDatabaseWithConfig(db, &trie.Config{
- Cache: cacheConfig.TrieCleanLimit,
- Journal: cacheConfig.TrieCleanJournal,
- Preimages: cacheConfig.Preimages,
- }),
- quit: make(chan struct{}),
- shouldPreserve: shouldPreserve,
- bodyCache: bodyCache,
- bodyRLPCache: bodyRLPCache,
- receiptsCache: receiptsCache,
- blockCache: blockCache,
- txLookupCache: txLookupCache,
- futureBlocks: futureBlocks,
- engine: engine,
- vmConfig: vmConfig,
- // Quorum
- quorumConfig: quorumChainConfig,
- }
- bc.validator = NewBlockValidator(chainConfig, bc, engine)
- bc.prefetcher = newStatePrefetcher(chainConfig, bc, engine)
- bc.processor = NewStateProcessor(chainConfig, bc, engine)
- var err error
- privateStateCacheProvider := privatecache.NewPrivateCacheProvider(db, &trie.Config{Cache: cacheConfig.TrieCleanLimit,
- Preimages: cacheConfig.Preimages}, bc.stateCache, quorumChainConfig.privateTrieCacheEnabled)
- // Quorum: attempt to initialize PSM
- if bc.privateStateManager, err = newPrivateStateManager(bc.db, privateStateCacheProvider, chainConfig.IsMPS); err != nil {
- return nil, err
- }
- bc.hc, err = NewHeaderChain(db, chainConfig, engine, bc.insertStopped)
- if err != nil {
- return nil, err
- }
- bc.genesisBlock = bc.GetBlockByNumber(0)
- if bc.genesisBlock == nil {
- return nil, ErrNoGenesis
- }
- var nilBlock *types.Block
- bc.currentBlock.Store(nilBlock)
- bc.currentFastBlock.Store(nilBlock)
- // Initialize the chain with ancient data if it isn't empty.
- var txIndexBlock uint64
- if bc.empty() {
- rawdb.InitDatabaseFromFreezer(bc.db)
- // If ancient database is not empty, reconstruct all missing
- // indices in the background.
- frozen, _ := bc.db.Ancients()
- if frozen > 0 {
- txIndexBlock = frozen
- }
- }
- if err := bc.loadLastState(); err != nil {
- return nil, err
- }
- // 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 {
- // Head state is missing, before the state recovery, find out the
- // disk layer point of snapshot(if it's enabled). Make sure the
- // rewound point is lower than disk layer.
- var diskRoot common.Hash
- if bc.cacheConfig.SnapshotLimit > 0 {
- diskRoot = rawdb.ReadSnapshotRoot(bc.db)
- }
- if diskRoot != (common.Hash{}) {
- log.Warn("Head state missing, repairing", "number", head.Number(), "hash", head.Hash(), "snaproot", diskRoot)
- snapDisk, err := bc.SetHeadBeyondRoot(head.NumberU64(), diskRoot)
- if err != nil {
- return nil, err
- }
- // Chain rewound, persist old snapshot number to indicate recovery procedure
- if snapDisk != 0 {
- rawdb.WriteSnapshotRecoveryNumber(bc.db, snapDisk)
- }
- } else {
- log.Warn("Head state missing, repairing", "number", head.Number(), "hash", head.Hash())
- if err := bc.SetHead(head.NumberU64()); err != nil {
- return nil, err
- }
- }
- }
- // Quorum
- if err := bc.privateStateManager.CheckAt(head.Root()); err != nil {
- log.Warn("Head private state missing, resetting chain", "number", head.Number(), "hash", head.Hash())
- return nil, bc.Reset()
- }
- // End Quorum
- // Ensure that a previous crash in SetHead doesn't leave extra ancients
- 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.Hash() != bc.genesisBlock.Hash() && 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 {
- 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)
- // 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)
- if err := bc.SetHead(header.Number.Uint64() - 1); err != nil {
- return nil, err
- }
- log.Error("Chain rewind was successful, resuming normal operation")
- }
- }
- }
- // Load any existing snapshot, regenerating it if loading failed
- if bc.cacheConfig.SnapshotLimit > 0 {
- // If the chain was rewound past the snapshot persistent layer (causing
- // a recovery block number to be persisted to disk), check if we're still
- // in recovery mode and in that case, don't invalidate the snapshot on a
- // head mismatch.
- var recover bool
- head := bc.CurrentBlock()
- if layer := rawdb.ReadSnapshotRecoveryNumber(bc.db); layer != nil && *layer > head.NumberU64() {
- log.Warn("Enabling snapshot recovery", "chainhead", head.NumberU64(), "diskbase", *layer)
- recover = true
- }
- bc.snaps, err = snapshot.New(bc.db, bc.stateCache.TrieDB(), bc.cacheConfig.SnapshotLimit, head.Root(), !bc.cacheConfig.SnapshotWait, true, recover)
- if err != nil {
- log.Error("Error trying to load snapshot", "err", err)
- }
- }
- // Take ownership of this particular state
- go bc.update()
- if txLookupLimit != nil {
- bc.txLookupLimit = *txLookupLimit
- bc.wg.Add(1)
- 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)
- }()
- }
- return bc, nil
- }
- // Quorum
- // Decorates NewBlockChain with multitenancy flag
- func NewMultitenantBlockChain(db ethdb.Database, cacheConfig *CacheConfig, chainConfig *params.ChainConfig, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(block *types.Block) bool, txLookupLimit *uint64, quorumChainConfig *QuorumChainConfig) (*BlockChain, error) {
- if quorumChainConfig == nil {
- quorumChainConfig = &QuorumChainConfig{multiTenantEnabled: true}
- } else {
- quorumChainConfig.multiTenantEnabled = true
- }
- bc, err := NewBlockChain(db, cacheConfig, chainConfig, engine, vmConfig, shouldPreserve, txLookupLimit, quorumChainConfig)
- if err != nil {
- return nil, err
- }
- return bc, err
- }
- func (bc *BlockChain) PrivateStateManager() mps.PrivateStateManager {
- return bc.privateStateManager
- }
- func (bc *BlockChain) SetPrivateStateManager(psm mps.PrivateStateManager) {
- bc.privateStateManager = psm
- }
- // End Quorum
- // 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()
- }
- // Quorum
- if _, err := bc.privateStateManager.StateRepository(currentBlock.Root()); err != nil {
- log.Warn("Head private state missing, resetting chain", "number", currentBlock.Number(), "hash", currentBlock.Hash())
- bc.currentBlock.Store(currentBlock)
- return bc.Reset()
- }
- // /Quorum
- // Everything seems to be fine, set as the head block
- bc.currentBlock.Store(currentBlock)
- headBlockGauge.Update(int64(currentBlock.NumberU64()))
- // 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)
- headFastBlockGauge.Update(int64(currentBlock.NumberU64()))
- if head := rawdb.ReadHeadFastBlockHash(bc.db); head != (common.Hash{}) {
- if block := bc.GetBlockByHash(head); block != nil {
- bc.currentFastBlock.Store(block)
- headFastBlockGauge.Update(int64(block.NumberU64()))
- }
- }
- // 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)))
- if pivot := rawdb.ReadLastPivotNumber(bc.db); pivot != nil {
- log.Info("Loaded last fast-sync pivot marker", "number", *pivot)
- }
- return nil
- }
- // 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.
- func (bc *BlockChain) SetHead(head uint64) error {
- _, err := bc.SetHeadBeyondRoot(head, common.Hash{})
- return err
- }
- // SetHeadBeyondRoot rewinds the local chain to a new head with the extra condition
- // that the rewind must pass the specified state root. This method is meant to be
- // used when rewinding with snapshots enabled to ensure that we go back further than
- // persistent disk layer. Depending on whether the node was fast synced or full, and
- // in which state, the method will try to delete minimal data from disk whilst
- // retaining chain consistency.
- //
- // The method returns the block number where the requested root cap was found.
- func (bc *BlockChain) SetHeadBeyondRoot(head uint64, root common.Hash) (uint64, error) {
- bc.chainmu.Lock()
- defer bc.chainmu.Unlock()
- // Track the block number of the requested root hash
- var rootNumber uint64 // (no root == always 0)
- // 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() {
- newHeadBlock := bc.GetBlock(header.Hash(), header.Number.Uint64())
- if newHeadBlock == nil {
- log.Error("Gap in the chain, rewinding to genesis", "number", header.Number, "hash", header.Hash())
- newHeadBlock = bc.genesisBlock
- } else {
- // Block exists, keep rewinding until we find one with state,
- // keeping rewinding until we exceed the optional threshold
- // root hash
- beyondRoot := (root == common.Hash{}) // Flag whether we're beyond the requested root (no root, always true)
- for {
- // If a root threshold was requested but not yet crossed, check
- if root != (common.Hash{}) && !beyondRoot && newHeadBlock.Root() == root {
- beyondRoot, rootNumber = true, newHeadBlock.NumberU64()
- }
- 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 {
- parent := bc.GetBlock(newHeadBlock.ParentHash(), newHeadBlock.NumberU64()-1)
- if parent != nil {
- newHeadBlock = parent
- continue
- }
- log.Error("Missing block in the middle, aiming genesis", "number", newHeadBlock.NumberU64()-1, "hash", newHeadBlock.ParentHash())
- newHeadBlock = bc.genesisBlock
- } else {
- log.Trace("Rewind passed pivot, aiming genesis", "number", newHeadBlock.NumberU64(), "hash", newHeadBlock.Hash(), "pivot", *pivot)
- newHeadBlock = bc.genesisBlock
- }
- }
- if beyondRoot || newHeadBlock.NumberU64() == 0 {
- log.Debug("Rewound to block with state", "number", newHeadBlock.NumberU64(), "hash", newHeadBlock.Hash())
- break
- }
- log.Debug("Skipping block with threshold state", "number", newHeadBlock.NumberU64(), "hash", newHeadBlock.Hash(), "root", newHeadBlock.Root())
- newHeadBlock = bc.GetBlock(newHeadBlock.ParentHash(), newHeadBlock.NumberU64()-1) // Keep rewinding
- }
- }
- rawdb.WriteHeadBlockHash(db, newHeadBlock.Hash())
- // 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.
- bc.currentBlock.Store(newHeadBlock)
- headBlockGauge.Update(int64(newHeadBlock.NumberU64()))
- }
- // 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())
- // 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.
- bc.currentFastBlock.Store(newHeadFastBlock)
- headFastBlockGauge.Update(int64(newHeadFastBlock.NumberU64()))
- }
- localHead := head
- if bc.CurrentBlock() != nil {
- localHead = 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 localHead+1 < frozen {
- wipe = pivot == nil || localHead >= *pivot
- }
- return localHead, wipe // Only force wipe if full synced
- }
- // 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); 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
- }
- // 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 != nil && 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)
- }
- // Clear out any stale content from the caches
- bc.bodyCache.Purge()
- bc.bodyRLPCache.Purge()
- bc.receiptsCache.Purge()
- bc.blockCache.Purge()
- bc.txLookupCache.Purge()
- bc.futureBlocks.Purge()
- return rootNumber, 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)
- headBlockGauge.Update(int64(block.NumberU64()))
- bc.chainmu.Unlock()
- // Destroy any existing state snapshot and regenerate it in the background,
- // also resuming the normal maintenance of any previously paused snapshot.
- if bc.snaps != nil {
- bc.snaps.Rebuild(block.Root())
- }
- 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 {
- bc.chainmu.RLock()
- defer bc.chainmu.RUnlock()
- 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)
- }
- // Snapshots returns the blockchain snapshot tree.
- func (bc *BlockChain) Snapshots() *snapshot.Tree {
- return bc.snaps
- }
- // 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, mps.PrivateStateRepository, error) {
- return bc.StateAt(bc.CurrentBlock().Root())
- }
- // Quorum
- //
- // StatePSI returns a new mutable public state and a mutable private state for given PSI,
- // based on the current HEAD block.
- func (bc *BlockChain) StatePSI(psi types.PrivateStateIdentifier) (*state.StateDB, *state.StateDB, error) {
- return bc.StateAtPSI(bc.CurrentBlock().Root(), psi)
- }
- // Quorum
- //
- // SetPrivateStateRootHashValidator allows injecting a private state root hash validator
- func (bc *BlockChain) SetPrivateStateRootHashValidator(psrhv qlight.PrivateStateRootHashValidator) {
- bc.privateStateRootHashValidator = psrhv
- }
- // StatePSI returns a new mutable public state and a mutable private state for the given PSI,
- // based on a particular point in time.
- func (bc *BlockChain) StateAtPSI(root common.Hash, psi types.PrivateStateIdentifier) (*state.StateDB, *state.StateDB, error) {
- publicStateDb, privateStateRepo, err := bc.StateAt(root)
- if err != nil {
- return nil, nil, err
- }
- privateStateDb, privateStateDbErr := privateStateRepo.StatePSI(psi)
- if privateStateDbErr != nil {
- return nil, nil, privateStateDbErr
- }
- return publicStateDb, privateStateDb, nil
- }
- // StateAt returns a new mutable public state and a new mutable private state repo
- // based on a particular point in time. The returned private state repo can be used
- // to obtain a mutable private state for a given PSI
- func (bc *BlockChain) StateAt(root common.Hash) (*state.StateDB, mps.PrivateStateRepository, error) {
- publicStateDb, publicStateDbErr := state.New(root, bc.stateCache, bc.snaps)
- if publicStateDbErr != nil {
- return nil, nil, publicStateDbErr
- }
- privateStateRepo, privateStateRepoErr := bc.privateStateManager.StateRepository(root)
- if privateStateRepoErr != nil {
- return nil, nil, privateStateRepoErr
- }
- return publicStateDb, privateStateRepo, nil
- }
- // 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
- 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
- bc.genesisBlock = genesis
- bc.currentBlock.Store(bc.genesisBlock)
- headBlockGauge.Update(int64(bc.genesisBlock.NumberU64()))
- bc.hc.SetGenesis(bc.genesisBlock.Header())
- bc.hc.SetCurrentHeader(bc.genesisBlock.Header())
- bc.currentFastBlock.Store(bc.genesisBlock)
- headFastBlockGauge.Update(int64(bc.genesisBlock.NumberU64()))
- return nil
- }
- // 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
- }
- // writeHeadBlock 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) writeHeadBlock(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
- batch := bc.db.NewBatch()
- rawdb.WriteCanonicalHash(batch, block.Hash(), block.NumberU64())
- rawdb.WriteTxLookupEntriesByBlock(batch, block)
- rawdb.WriteHeadBlockHash(batch, block.Hash())
- // If the block is better than our head or is on a different chain, force update heads
- if updateHeads {
- 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.hc.SetCurrentHeader(block.Header())
- bc.currentFastBlock.Store(block)
- headFastBlockGauge.Update(int64(block.NumberU64()))
- }
- bc.currentBlock.Store(block)
- headBlockGauge.Update(int64(block.NumberU64()))
- }
- // 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
- }
- // (Quorum) GetPMTPrivateReceiptsByHash retrieves the receipts for all internal private transactions (i.e. the private
- // transaction for a privacy marker transaction) in a given block.
- func (bc *BlockChain) GetPMTPrivateReceiptsByHash(ctx context.Context, hash common.Hash) (types.Receipts, error) {
- psm, err := bc.privateStateManager.ResolveForUserContext(ctx)
- if err != nil {
- return nil, err
- }
- allReceipts := bc.GetReceiptsByHash(hash)
- block := bc.GetBlockByHash(hash)
- if block == nil {
- return types.Receipts{}, nil
- }
- privateReceipts := make([]*types.Receipt, 0)
- for i, tx := range block.Transactions() {
- if tx.IsPrivacyMarker() {
- receipt := allReceipts[i]
- if receipt.PSReceipts != nil && receipt.PSReceipts[psm.ID] != nil {
- privateReceipts = append(privateReceipts, receipt.PSReceipts[psm.ID])
- } else {
- return nil, errors.New("could not find receipt for private transaction")
- }
- }
- }
- return privateReceipts, nil
- }
- // 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
- // 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)
- }
- // 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)
- }
- // 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)
- bc.StopInsert()
- bc.wg.Wait()
- // 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)
- }
- }
- // 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, nil); err != nil {
- log.Error("Failed to commit recent state trie", "err", err)
- }
- }
- }
- 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)
- }
- }
- 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")
- }
- }
- // 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
- }
- 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 {
- sort.Slice(blocks, func(i, j int) bool {
- return blocks[i].NumberU64() < blocks[j].NumberU64()
- })
- // 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
- )
- // 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.txLookupCache.Purge()
- bc.futureBlocks.Purge()
- log.Info("Rewind ancient data", "number", head)
- return nil
- }
- // numberHash is just a container for a number and a hash, to represent a block
- type numberHash struct {
- number uint64
- hash common.Hash
- }
- // 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) {
- // We don't require the chainMu here since we want to maximize the
- // concurrency of header insertion and receipt insertion.
- 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 an indicator whether the inserted blocks are canonical.
- updateHead := func(head *types.Block) bool {
- bc.chainmu.Lock()
- // Rewind may have occurred, skip in that case.
- if bc.CurrentHeader().Number.Cmp(head.Number()) >= 0 {
- currentFastBlock, td := bc.CurrentFastBlock(), bc.GetTd(head.Hash(), head.NumberU64())
- if bc.GetTd(currentFastBlock.Hash(), currentFastBlock.NumberU64()).Cmp(td) < 0 {
- rawdb.WriteHeadFastBlockHash(bc.db, head.Hash())
- bc.currentFastBlock.Store(head)
- headFastBlockGauge.Update(int64(head.NumberU64()))
- bc.chainmu.Unlock()
- return true
- }
- }
- bc.chainmu.Unlock()
- return false
- }
- // 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 []*numberHash
- for i, block := range blockChain {
- // Short circuit insertion if shutting down or processing failed
- if bc.insertStopped() {
- 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])
- }
- if block.NumberU64() == 1 {
- // Make sure to write the genesis into the freezer
- if frozen, _ := bc.db.Ancients(); frozen == 0 {
- h := rawdb.ReadCanonicalHash(bc.db, 0)
- b := rawdb.ReadBlock(bc.db, h, 0)
- size += rawdb.WriteAncientBlock(bc.db, b, rawdb.ReadReceipts(bc.db, h, 0, bc.chainConfig), rawdb.ReadTd(bc.db, h, 0))
- log.Info("Wrote genesis to ancients")
- }
- }
- // Flush data into ancient database.
- size += rawdb.WriteAncientBlock(bc.db, block, receiptChain[i], bc.GetTd(block.Hash(), block.NumberU64()))
- // 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)
- }
- 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 _, nh := range deleted {
- rawdb.DeleteBlockWithoutNumber(batch, nh.hash, nh.number)
- rawdb.DeleteCanonicalHash(batch, nh.number)
- }
- for _, block := range 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 _, nh := range deleted {
- for _, hash := range rawdb.ReadAllHashes(bc.db, nh.number) {
- rawdb.DeleteBlock(batch, hash, nh.number)
- }
- }
- for _, block := range 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) {
- skipPresenceCheck := false
- batch := bc.db.NewBatch()
- for i, block := range blockChain {
- // Short circuit insertion if shutting down or processing failed
- if bc.insertStopped() {
- 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 !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
- }
- }
- // 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.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)
- if batch.ValueSize() >= ethdb.IdealBatchSize {
- if err := batch.Write(); err != nil {
- return 0, err
- }
- size += batch.ValueSize()
- batch.Reset()
- }
- 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)
- 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
- }
- }
- // 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)
- }
- }
- }
- 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
- }
- // 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
- }
- 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()
- 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)
- }
- 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
- }
- }
- bc.writeHeadBlock(block)
- return nil
- }
- // WriteBlockWithState writes the block and all associated state to the database.
- func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, psManager mps.PrivateStateRepository, emitHeadEvent bool) (status WriteStatus, err error) {
- bc.chainmu.Lock()
- defer bc.chainmu.Unlock()
- return bc.writeBlockWithState(block, receipts, logs, state, psManager, emitHeadEvent)
- }
- // QUORUM
- // checks if the consensus engine is Rfat
- func (bc *BlockChain) isRaft() bool {
- return bc.chainConfig.IsQuorum && bc.chainConfig.Istanbul == nil && bc.chainConfig.IBFT == nil && bc.chainConfig.QBFT == nil && bc.chainConfig.Clique == nil
- }
- // function specifically added for Raft consensus. This is called from mintNewBlock
- // to commit public and private state using bc.chainmu lock
- // added to avoid concurrent map errors in high stress conditions
- func (bc *BlockChain) CommitBlockWithState(deleteEmptyObjects bool, state, privateState *state.StateDB) error {
- // check if consensus is not Raft
- if !bc.isRaft() {
- return errors.New("error function can be called only for Raft consensus")
- }
- bc.chainmu.Lock()
- defer bc.chainmu.Unlock()
- if _, err := state.Commit(deleteEmptyObjects); err != nil {
- return fmt.Errorf("error committing public state: %v", err)
- }
- if _, err := privateState.Commit(deleteEmptyObjects); err != nil {
- return fmt.Errorf("error committing private state: %v", err)
- }
- return nil
- }
- // END QUORUM
- // 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, logs []*types.Log, state *state.StateDB, psManager mps.PrivateStateRepository, emitHeadEvent bool) (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
- }
- 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.
- //
- // 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.
- root, err := state.Commit(bc.chainConfig.IsEIP158(block.Number()))
- if err != nil {
- return NonStatTy, err
- }
- // quorum - private state commit must come after public state commit. If the private state is being cached then the
- // private state root will reference the public state root, hence the need for public state trie to have already
- // been committed.
- // Make sure no inconsistent state is leaked during insertion
- // Quorum
- // Write private state changes to database
- err = psManager.CommitAndWrite(bc.chainConfig.IsEIP158(block.Number()), block)
- if err != nil {
- return NonStatTy, err
- }
- if bc.privateStateRootHashValidator != nil {
- err = bc.privateStateRootHashValidator.ValidatePrivateStateRoot(block.Hash(), block.Root())
- if err != nil {
- return NonStatTy, err
- }
- }
- // /Quorum
- triedb := bc.stateCache.TrieDB()
- // If we're running an archive node, always flush
- if bc.cacheConfig.TrieDirtyDisabled {
- if err := triedb.Commit(root, false, nil); err != nil {
- 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, nil)
- 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))
- }
- }
- }
- // 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
- }
- }
- status = CanonStatTy
- } else {
- status = SideStatTy
- }
- // Set new head.
- if status == CanonStatTy {
- bc.writeHeadBlock(block)
- }
- bc.futureBlocks.Remove(block.Hash())
- 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})
- }
- 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, err := bc.insertChain(chain, true)
- bc.chainmu.Unlock()
- bc.wg.Done()
- return n, err
- }
- // InsertChainWithoutSealVerification works exactly the same
- // except for seal verification, seal verification is omitted
- func (bc *BlockChain) InsertChainWithoutSealVerification(block *types.Block) (int, error) {
- bc.blockProcFeed.Send(true)
- defer bc.blockProcFeed.Send(false)
- // Pre-checks passed, start the full block imports
- bc.wg.Add(1)
- bc.chainmu.Lock()
- n, err := bc.insertChain(types.Blocks([]*types.Block{block}), false)
- bc.chainmu.Unlock()
- bc.wg.Done()
- 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, error) {
- // If the chain is terminating, don't even bother starting up
- if atomic.LoadInt32(&bc.procInterrupt) == 1 {
- log.Debug("Premature abort during blocks processing")
- // QUORUM
- if bc.isRaft() {
- // Only returns an error for raft mode
- return 0, ErrAbortBlocksProcessing
- }
- return 0, 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)
- var (
- 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})
- }
- }()
- // 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, 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 errors.Is(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 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)) {
- log.Debug("Future block, postponing import", "number", block.Number(), "hash", block.Hash())
- if err := bc.addFutureBlock(block); err != nil {
- return it.index, 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, err
- // Some other error occurred, abort
- case err != nil:
- bc.futureBlocks.Remove(block.Hash())
- stats.ignored += len(it.chain)
- bc.reportBlock(block, nil, err)
- return it.index, err
- }
- // No validation errors for the first block (or chain prefix skipped)
- var activeState *state.StateDB
- defer func() {
- // The chain importer is starting and stopping trie prefetchers. If a bad
- // block or other error is hit however, an early return may not properly
- // terminate the background threads. This defer ensures that we clean up
- // and dangling prefetcher, without defering each and holding on live refs.
- if activeState != nil {
- activeState.StopPrefetcher()
- }
- }()
- for ; block != nil && err == nil || err == ErrKnownBlock; block, err = it.next() {
- // If the chain is terminating, stop processing blocks
- if bc.insertStopped() {
- log.Debug("Abort during block processing")
- // QUORUM
- if bc.isRaft() {
- // Only returns an error for raft mode
- return it.index, ErrAbortBlocksProcessing
- }
- // END QUORUM
- break
- }
- // If the header is a banned one, straight out abort
- if BadHashes[block.Hash()] {
- bc.reportBlock(block, nil, ErrBlacklistedHash)
- return it.index, 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())
- // 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())
- }
- if err := bc.writeKnownBlock(block); err != nil {
- return it.index, 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.
- 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, bc.snaps)
- if err != nil {
- return it.index, err
- }
- // Quorum
- privateStateRepo, err := bc.privateStateManager.StateRepository(parent.Root)
- if err != nil {
- return it.index, err
- }
- // End Quorum
- // Enable prefetching to pull in trie node paths while processing transactions
- statedb.StartPrefetcher("chain")
- activeState = statedb
- // 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 {
- throwaway, _ := state.New(parent.Root, bc.stateCache, bc.snaps)
- // Quorum
- privateStateRepo, stateRepoErr := bc.privateStateManager.StateRepository(parent.Root)
- if stateRepoErr == nil && privateStateRepo != nil {
- throwawayPrivateStateRepo := privateStateRepo.Copy()
- // Quorum: add privateStateThrowaway argument
- go func(start time.Time, followup *types.Block, throwaway *state.StateDB, privateStateThrowaway mps.PrivateStateRepository, interrupt *uint32) {
- bc.prefetcher.Prefetch(followup, throwaway, throwawayPrivateStateRepo, bc.vmConfig, &followupInterrupt)
- blockPrefetchExecuteTimer.Update(time.Since(start))
- if atomic.LoadUint32(interrupt) == 1 {
- blockPrefetchInterruptMeter.Mark(1)
- }
- }(time.Now(), followup, throwaway, throwawayPrivateStateRepo, &followupInterrupt)
- } else {
- log.Warn("Unable to load the private state repository for pre-fetching", "stateRepoErr", stateRepoErr)
- }
- // End Quorum
- }
- }
- // Process block using the parent state as reference point
- substart := time.Now()
- receipts, privateReceipts, logs, usedGas, err := bc.processor.Process(block, statedb, privateStateRepo, bc.vmConfig)
- if err != nil {
- bc.reportBlock(block, receipts, err)
- atomic.StoreUint32(&followupInterrupt, 1)
- return it.index, 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
- snapshotAccountReadTimer.Update(statedb.SnapshotAccountReads) // Account reads are complete, we can mark them
- snapshotStorageReadTimer.Update(statedb.SnapshotStorageReads) // Storage reads are complete, we can mark them
- triehash := statedb.AccountHashes + statedb.StorageHashes // Save to not double count in validation
- trieproc := statedb.SnapshotAccountReads + statedb.AccountReads + statedb.AccountUpdates
- trieproc += statedb.SnapshotStorageReads + 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, err
- }
- allReceipts := privateStateRepo.MergeReceipts(receipts, privateReceipts)
- 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, allReceipts, logs, statedb, privateStateRepo, false)
- atomic.StoreUint32(&followupInterrupt, 1)
- if err != nil {
- return it.index, err
- }
- // Quorum
- if err := rawdb.WritePrivateBlockBloom(bc.db, block.NumberU64(), privateReceipts); err != nil {
- return it.index, err
- }
- // End Quorum
- // 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
- snapshotCommitTimer.Update(statedb.SnapshotCommits) // Snapshot commits are complete, we can mark them
- blockWriteTimer.Update(time.Since(substart) - statedb.AccountCommits - statedb.StorageCommits - statedb.SnapshotCommits)
- 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())
- 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())
- 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 && errors.Is(err, consensus.ErrFutureBlock) {
- if err := bc.addFutureBlock(block); err != nil {
- return it.index, err
- }
- block, err = it.next()
- for ; block != nil && errors.Is(err, consensus.ErrUnknownAncestor); block, err = it.next() {
- if err := bc.addFutureBlock(block); err != nil {
- return it.index, err
- }
- stats.queued++
- }
- }
- stats.ignored += it.remaining()
- return it.index, 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, 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 && errors.Is(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
- // Collect the TD of the block. Since we know it's a canon one,
- // we can get it directly, and not (like further below) use
- // the parent and then add the block on top
- externTd = bc.GetTd(block.Hash(), block.NumberU64())
- 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, 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, 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, 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, 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, err
- }
- blocks, memory = blocks[:0], 0
- // If the chain is terminating, stop processing blocks
- if bc.insertStopped() {
- log.Debug("Abort during blocks processing")
- return 0, 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
- }
- // 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 or removed 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)
- var logs []*types.Log
- for _, receipt := range receipts {
- for _, log := range receipt.Logs {
- l := *log
- if removed {
- l.Removed = true
- }
- 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
- }
- )
- // 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.Info
- msg := "Chain reorg detected"
- if len(oldChain) > 63 {
- msg = "Large chain reorg detected"
- logFn = log.Warn
- }
- logFn(msg, "number", commonBlock.Number(), "hash", commonBlock.Hash(),
- "drop", len(oldChain), "dropfrom", oldChain[0].Hash(), "add", len(newChain), "addfrom", newChain[0].Hash())
- blockReorgAddMeter.Mark(int64(len(newChain)))
- blockReorgDropMeter.Mark(int64(len(oldChain)))
- blockReorgMeter.Mark(1)
- } 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.writeHeadBlock(newChain[i])
- // Collect reborn logs due to chain reorg
- collectLogs(newChain[i].Hash(), false)
- // Collect the new added transactions.
- addedTxs = append(addedTxs, newChain[i].Transactions()...)
- }
- // Delete useless indexes right now which includes the non-canonical
- // transaction indexes, canonical chain indexes which above the head.
- indexesBatch := bc.db.NewBatch()
- for _, tx := range types.TxDifference(deletedTxs, addedTxs) {
- rawdb.DeleteTxLookupEntry(indexesBatch, 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(indexesBatch, i)
- }
- if err := indexesBatch.Write(); err != nil {
- log.Crit("Failed to delete useless indexes", "err", err)
- }
- // 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.
- 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
- }
- func (bc *BlockChain) update() {
- futureTimer := time.NewTicker(5 * time.Second)
- defer futureTimer.Stop()
- for {
- select {
- case <-futureTimer.C:
- bc.procFutureBlocks()
- case <-bc.quit:
- return
- }
- }
- }
- // 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) {
- defer bc.wg.Done()
- // 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, bc.quit)
- }
- // 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, bc.quit)
- }
- 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, bc.quit)
- }
- 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, bc.quit)
- } else {
- // Unindex a part of stale indices and forward index tail to HEAD-limit
- rawdb.UnindexTransactions(bc.db, *tail, head-bc.txLookupLimit+1, bc.quit)
- }
- }
- // 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:
- if done != nil {
- log.Info("Waiting background transaction indexer to exit")
- <-done
- }
- return
- }
- }
- }
- // reportBlock logs a bad block error.
- func (bc *BlockChain) reportBlock(block *types.Block, receipts types.Receipts, err error) {
- rawdb.WriteBadBlock(bc.db, 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()
- _, err := bc.hc.InsertHeaderChain(chain, start)
- return 0, err
- }
- // 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)
- }
- // GetCanonicalHash returns the canonical hash for a given block number
- func (bc *BlockChain) GetCanonicalHash(number uint64) common.Hash {
- return bc.hc.GetCanonicalHash(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) {
- 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)
- }
- // GetTransactionLookup retrieves the lookup associate with the given transaction
- // hash from the cache or database.
- func (bc *BlockChain) GetTransactionLookup(hash common.Hash) *rawdb.LegacyTxLookupEntry {
- // Short circuit if the txlookup already in the cache, retrieve otherwise
- if lookup, exist := bc.txLookupCache.Get(hash); exist {
- return lookup.(*rawdb.LegacyTxLookupEntry)
- }
- tx, blockHash, blockNumber, txIndex := rawdb.ReadTransaction(bc.db, hash)
- if tx == nil {
- return nil
- }
- lookup := &rawdb.LegacyTxLookupEntry{BlockHash: blockHash, BlockIndex: blockNumber, Index: txIndex}
- bc.txLookupCache.Add(hash, lookup)
- return lookup
- }
- // Config retrieves the chain's fork configuration.
- func (bc *BlockChain) Config() *params.ChainConfig { return bc.chainConfig }
- // QuorumConfig retrieves the Quorum chain's configuration
- func (bc *BlockChain) QuorumConfig() *QuorumChainConfig { return bc.quorumConfig }
- // 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))
- }
- // Quorum
- func (bc *BlockChain) SupportsMultitenancy(context.Context) bool {
- return bc.quorumConfig.MultiTenantEnabled()
- }
- // PopulateSetPrivateState function pointer for updating private state
- // Quorum
- func (bc *BlockChain) PopulateSetPrivateState(ps func([]*types.Log, *state.StateDB, types.PrivateStateIdentifier)) {
- bc.setPrivateState = ps
- }
- // CheckAndSetPrivateState function to update the private state as a part contract state extension
- // Quorum
- func (bc *BlockChain) CheckAndSetPrivateState(txLogs []*types.Log, privateState *state.StateDB, psi types.PrivateStateIdentifier) {
- if bc.setPrivateState != nil {
- bc.setPrivateState(txLogs, privateState, psi)
- }
- }
|