Documentation

Overview

    Package core implements the Ethereum consensus protocol.

    Index

    Examples

    Constants

    View Source
    const (
    
    	// BlockChainVersion ensures that an incompatible database forces a resync from scratch.
    	BlockChainVersion = 3
    )

    Variables

    View Source
    var (
    	MIPMapLevels = []uint64{1000000, 500000, 100000, 50000, 1000}
    
    	ErrChainConfigNotFound = errors.New("ChainConfig not found") // general config not found error
    
    )
    View Source
    var (
    	// ErrKnownBlock is returned when a block to import is already known locally.
    	ErrKnownBlock = errors.New("block already known")
    
    	// ErrGasLimitReached is returned by the gas pool if the amount of gas required
    	// by a transaction is higher than what's left in the block.
    	ErrGasLimitReached = errors.New("gas limit reached")
    
    	// ErrBlacklistedHash is returned if a block to import is on the blacklist.
    	ErrBlacklistedHash = errors.New("blacklisted hash")
    )
    View Source
    var (
    	// Transaction Pool Errors
    	ErrInvalidSender      = errors.New("invalid sender")
    	ErrNonce              = errors.New("nonce too low")
    	ErrUnderpriced        = errors.New("transaction underpriced")
    	ErrReplaceUnderpriced = errors.New("replacement transaction underpriced")
    	ErrBalance            = errors.New("insufficient balance")
    	ErrInsufficientFunds  = errors.New("insufficient funds for fee")
    	ErrIntrinsicGas       = errors.New("intrinsic gas too low")
    	ErrGasLimit           = errors.New("exceeds block gas limit")
    	ErrNegativeValue      = errors.New("negative value")
    )
    View Source
    var BadHashes = map[common.Hash]bool{
    	common.HexToHash("05bef30ef572270f654746da22639a7a0c97dd97a7050b9e252391996aaeb689"): true,
    	common.HexToHash("7d05d08cbc596a2e5e4f13b80a743e53e09221b5323c3a61946b20873e58583f"): true,
    }

      BadHashes represent a set of manually tracked bad hashes (usually hard forks)

      View Source
      var (
      	Big0 = big.NewInt(0)
      )
      View Source
      var BlockReward = big.NewInt(5e+18)
      View Source
      var DefaultTxPoolConfig = TxPoolConfig{
      	PriceLimit: 1,
      	PriceBump:  10,
      
      	AccountSlots: 16,
      	GlobalSlots:  4096,
      	AccountQueue: 64,
      	GlobalQueue:  1024,
      
      	Lifetime: 3 * time.Hour,
      
      	MaxCodeSize: 24,
      }

        DefaultTxPoolConfig contains the default configurations for the transaction pool.

        View Source
        var (
        	ErrNoGenesis = errors.New("Genesis not found in chain")
        )

        Functions

        func ApplyDAOHardFork

        func ApplyDAOHardFork(statedb *state.StateDB)

          ApplyDAOHardFork modifies the state database according to the DAO hard-fork rules, transferring all balances of a set of DAO accounts to a single refund contract.

          func ApplyMessage

          func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) ([]byte, *big.Int, bool, error)

            ApplyMessage computes the new state by applying the given message against the old state within the environment.

            ApplyMessage returns the bytes returned by any EVM execution (if it took place), the gas used (which includes gas refunds) and an error if it failed. An error always indicates a core error meaning that the message would always fail for that particular state and would never be accepted within a block.

            func ApplyTransaction

            func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, *big.Int, error)

              ApplyTransaction attempts to apply a transaction to the given state database and uses the input parameters for its environment. It returns the receipt for the transaction, gas used and an error if the transaction failed, indicating the block was invalid.

              func CalcGasLimit

              func CalcGasLimit(parent *types.Block) *big.Int

                CalcGasLimit computes the gas limit of the next block after parent. The result may be modified by the caller. This is miner strategy, not consensus protocol.

                func CanTransfer

                func CanTransfer(db vm.StateDB, addr common.Address, amount *big.Int) bool

                  CanTransfer checks wether there are enough funds in the address' account to make a transfer. This does not take the necessary gas in to account to make the transfer valid.

                  func DeleteBlock

                  func DeleteBlock(db ethdb.Database, hash common.Hash, number uint64)

                    DeleteBlock removes all block data associated with a hash.

                    func DeleteBlockReceipts

                    func DeleteBlockReceipts(db ethdb.Database, hash common.Hash, number uint64)

                      DeleteBlockReceipts removes all receipt data associated with a block hash.

                      func DeleteBody

                      func DeleteBody(db ethdb.Database, hash common.Hash, number uint64)

                        DeleteBody removes all block body data associated with a hash.

                        func DeleteCanonicalHash

                        func DeleteCanonicalHash(db ethdb.Database, number uint64)

                          DeleteCanonicalHash removes the number to hash canonical mapping.

                          func DeleteHeader

                          func DeleteHeader(db ethdb.Database, hash common.Hash, number uint64)

                            DeleteHeader removes all block header data associated with a hash.

                            func DeleteReceipt

                            func DeleteReceipt(db ethdb.Database, hash common.Hash)

                              DeleteReceipt removes all receipt data associated with a transaction hash.

                              func DeleteTd

                              func DeleteTd(db ethdb.Database, hash common.Hash, number uint64)

                                DeleteTd removes all block total difficulty data associated with a hash.

                                func DeleteTransaction

                                func DeleteTransaction(db ethdb.Database, hash common.Hash)

                                  DeleteTransaction removes all transaction data associated with a hash.

                                  func FindCommonAncestor

                                  func FindCommonAncestor(db ethdb.Database, a, b *types.Header) *types.Header

                                    FindCommonAncestor returns the last common ancestor of two block headers

                                    func GenerateChain

                                    func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Database, n int, gen func(int, *BlockGen)) ([]*types.Block, []types.Receipts)

                                      GenerateChain creates a chain of n blocks. The first block's parent will be the provided parent. db is used to store intermediate states and should contain the parent's state trie.

                                      The generator function is called with a new block generator for every block. Any transactions and uncles added to the generator become part of the block. If gen is nil, the blocks will be empty and their coinbase will be the zero address.

                                      Blocks created by GenerateChain do not contain valid proof of work values. Inserting them into BlockChain requires use of FakePow or a similar non-validating proof of work implementation.

                                      Example
                                      Output:
                                      
                                      last block: #5
                                      balance of addr1: 989000
                                      balance of addr2: 10000
                                      balance of addr3: 19687500000000001000
                                      

                                      func GenesisBlockForTesting

                                      func GenesisBlockForTesting(db ethdb.Database, addr common.Address, balance *big.Int) *types.Block

                                        GenesisBlockForTesting creates and writes a block in which addr has the given wei balance.

                                        func GetBlock

                                        func GetBlock(db ethdb.Database, hash common.Hash, number uint64) *types.Block

                                          GetBlock retrieves an entire block corresponding to the hash, assembling it back from the stored header and body. If either the header or body could not be retrieved nil is returned.

                                          Note, due to concurrent download of header and block body the header and thus canonical hash can be stored in the database but the body data not (yet).

                                          func GetBlockChainVersion

                                          func GetBlockChainVersion(db ethdb.Database) int

                                            GetBlockChainVersion reads the version number from db.

                                            func GetBlockNumber

                                            func GetBlockNumber(db ethdb.Database, hash common.Hash) uint64

                                              GetBlockNumber returns the block number assigned to a block hash if the corresponding header is present in the database

                                              func GetBlockReceipts

                                              func GetBlockReceipts(db ethdb.Database, hash common.Hash, number uint64) types.Receipts

                                                GetBlockReceipts retrieves the receipts generated by the transactions included in a block given by its hash.

                                                func GetBody

                                                func GetBody(db ethdb.Database, hash common.Hash, number uint64) *types.Body

                                                  GetBody retrieves the block body (transactons, uncles) corresponding to the hash, nil if none found.

                                                  func GetBodyRLP

                                                  func GetBodyRLP(db ethdb.Database, hash common.Hash, number uint64) rlp.RawValue

                                                    GetBodyRLP retrieves the block body (transactions and uncles) in RLP encoding.

                                                    func GetCanonicalHash

                                                    func GetCanonicalHash(db ethdb.Database, number uint64) common.Hash

                                                      GetCanonicalHash retrieves a hash assigned to a canonical block number.

                                                      func GetChainConfig

                                                      func GetChainConfig(db ethdb.Database, hash common.Hash) (*params.ChainConfig, error)

                                                        GetChainConfig will fetch the network settings based on the given hash.

                                                        func GetHashFn

                                                        func GetHashFn(ref *types.Header, chain ChainContext) func(n uint64) common.Hash

                                                          GetHashFn returns a GetHashFunc which retrieves header hashes by number

                                                          func GetHeadBlockHash

                                                          func GetHeadBlockHash(db ethdb.Database) common.Hash

                                                            GetHeadBlockHash retrieves the hash of the current canonical head block.

                                                            func GetHeadFastBlockHash

                                                            func GetHeadFastBlockHash(db ethdb.Database) common.Hash

                                                              GetHeadFastBlockHash retrieves the hash of the current canonical head block during fast synchronization. The difference between this and GetHeadBlockHash is that whereas the last block hash is only updated upon a full block import, the last fast hash is updated when importing pre-processed blocks.

                                                              func GetHeadHeaderHash

                                                              func GetHeadHeaderHash(db ethdb.Database) common.Hash

                                                                GetHeadHeaderHash retrieves the hash of the current canonical head block's header. The difference between this and GetHeadBlockHash is that whereas the last block hash is only updated upon a full block import, the last header hash is updated already at header import, allowing head tracking for the light synchronization mechanism.

                                                                func GetHeader

                                                                func GetHeader(db ethdb.Database, hash common.Hash, number uint64) *types.Header

                                                                  GetHeader retrieves the block header corresponding to the hash, nil if none found.

                                                                  func GetHeaderRLP

                                                                  func GetHeaderRLP(db ethdb.Database, hash common.Hash, number uint64) rlp.RawValue

                                                                    GetHeaderRLP retrieves a block header in its raw RLP database encoding, or nil if the header's not found.

                                                                    func GetMipmapBloom

                                                                    func GetMipmapBloom(db ethdb.Database, number, level uint64) types.Bloom

                                                                      GetMipmapBloom returns a bloom filter using the number and level as input parameters. For available levels see MIPMapLevels.

                                                                      func GetReceipt

                                                                      func GetReceipt(db ethdb.Database, hash common.Hash) *types.Receipt

                                                                        GetReceipt returns a receipt by hash

                                                                        func GetTd

                                                                        func GetTd(db ethdb.Database, hash common.Hash, number uint64) *big.Int

                                                                          GetTd retrieves a block's total difficulty corresponding to the hash, nil if none found.

                                                                          func GetTransaction

                                                                          func GetTransaction(db ethdb.Database, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64)

                                                                            GetTransaction retrieves a specific transaction from the database, along with its added positional metadata.

                                                                            func IntrinsicGas

                                                                            func IntrinsicGas(data []byte, contractCreation, homestead bool) *big.Int

                                                                              IntrinsicGas computes the 'intrinsic gas' for a message with the given data.

                                                                              TODO convert to uint64

                                                                              func NewEVMContext

                                                                              func NewEVMContext(msg Message, header *types.Header, chain ChainContext, author *common.Address) vm.Context

                                                                                NewEVMContext creates a new context for use in the EVM.

                                                                                func PreimageTable

                                                                                func PreimageTable(db ethdb.Database) ethdb.Database

                                                                                  PreimageTable returns a Database instance with the key prefix for preimage entries.

                                                                                  func SetReceiptsData

                                                                                  func SetReceiptsData(config *params.ChainConfig, block *types.Block, receipts types.Receipts)

                                                                                    SetReceiptsData computes all the non-consensus fields of the receipts

                                                                                    func SetupGenesisBlock

                                                                                    func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig, common.Hash, error)

                                                                                      SetupGenesisBlock writes or updates the genesis block in db. The block that will be used is:

                                                                                                           genesis == nil       genesis != nil
                                                                                                        +------------------------------------------
                                                                                      db has no genesis |  main-net default  |  genesis
                                                                                      db has genesis    |  from DB           |  genesis (if compatible)
                                                                                      

                                                                                      The stored chain configuration will be updated if it is compatible (i.e. does not specify a fork block below the local head block). In case of a conflict, the error is a *params.ConfigCompatError and the new, unwritten config is returned.

                                                                                      The returned chain configuration is never nil.

                                                                                      func Transfer

                                                                                      func Transfer(db vm.StateDB, sender, recipient common.Address, amount *big.Int)

                                                                                        Transfer subtracts amount from sender and adds amount to recipient using the given Db

                                                                                        func ValidateDAOHeaderExtraData

                                                                                        func ValidateDAOHeaderExtraData(config *params.ChainConfig, header *types.Header) error

                                                                                          ValidateDAOHeaderExtraData validates the extra-data field of a block header to ensure it conforms to DAO hard-fork rules.

                                                                                          DAO hard-fork extension to the header validity:

                                                                                          a) if the node is no-fork, do not accept blocks in the [fork, fork+10) range
                                                                                             with the fork specific extra-data set
                                                                                          b) if the node is pro-fork, require blocks in the specific range to have the
                                                                                             unique extra-data set.
                                                                                          

                                                                                          func WriteBlock

                                                                                          func WriteBlock(db ethdb.Database, block *types.Block) error

                                                                                            WriteBlock serializes a block into the database, header and body separately.

                                                                                            func WriteBlockChainVersion

                                                                                            func WriteBlockChainVersion(db ethdb.Database, vsn int)

                                                                                              WriteBlockChainVersion writes vsn as the version number to db.

                                                                                              func WriteBlockReceipts

                                                                                              func WriteBlockReceipts(db ethdb.Database, hash common.Hash, number uint64, receipts types.Receipts) error

                                                                                                WriteBlockReceipts stores all the transaction receipts belonging to a block as a single receipt slice. This is used during chain reorganisations for rescheduling dropped transactions.

                                                                                                func WriteBody

                                                                                                func WriteBody(db ethdb.Database, hash common.Hash, number uint64, body *types.Body) error

                                                                                                  WriteBody serializes the body of a block into the database.

                                                                                                  func WriteBodyRLP

                                                                                                  func WriteBodyRLP(db ethdb.Database, hash common.Hash, number uint64, rlp rlp.RawValue) error

                                                                                                    WriteBodyRLP writes a serialized body of a block into the database.

                                                                                                    func WriteCanonicalHash

                                                                                                    func WriteCanonicalHash(db ethdb.Database, hash common.Hash, number uint64) error

                                                                                                      WriteCanonicalHash stores the canonical hash for the given block number.

                                                                                                      func WriteChainConfig

                                                                                                      func WriteChainConfig(db ethdb.Database, hash common.Hash, cfg *params.ChainConfig) error

                                                                                                        WriteChainConfig writes the chain config settings to the database.

                                                                                                        func WriteHeadBlockHash

                                                                                                        func WriteHeadBlockHash(db ethdb.Database, hash common.Hash) error

                                                                                                          WriteHeadBlockHash stores the head block's hash.

                                                                                                          func WriteHeadFastBlockHash

                                                                                                          func WriteHeadFastBlockHash(db ethdb.Database, hash common.Hash) error

                                                                                                            WriteHeadFastBlockHash stores the fast head block's hash.

                                                                                                            func WriteHeadHeaderHash

                                                                                                            func WriteHeadHeaderHash(db ethdb.Database, hash common.Hash) error

                                                                                                              WriteHeadHeaderHash stores the head header's hash.

                                                                                                              func WriteHeader

                                                                                                              func WriteHeader(db ethdb.Database, header *types.Header) error

                                                                                                                WriteHeader serializes a block header into the database.

                                                                                                                func WriteMipmapBloom

                                                                                                                func WriteMipmapBloom(db ethdb.Database, number uint64, receipts types.Receipts) error

                                                                                                                  WriteMipmapBloom writes each address included in the receipts' logs to the MIP bloom bin.

                                                                                                                  func WritePreimages

                                                                                                                  func WritePreimages(db ethdb.Database, number uint64, preimages map[common.Hash][]byte) error

                                                                                                                    WritePreimages writes the provided set of preimages to the database. `number` is the current block number, and is used for debug messages only.

                                                                                                                    func WriteReceipt

                                                                                                                    func WriteReceipt(db ethdb.Database, receipt *types.Receipt) error

                                                                                                                      WriteReceipt stores a single transaction receipt into the database.

                                                                                                                      func WriteReceipts

                                                                                                                      func WriteReceipts(db ethdb.Database, receipts types.Receipts) error

                                                                                                                        WriteReceipts stores a batch of transaction receipts into the database.

                                                                                                                        func WriteTd

                                                                                                                        func WriteTd(db ethdb.Database, hash common.Hash, number uint64, td *big.Int) error

                                                                                                                          WriteTd serializes the total difficulty of a block into the database.

                                                                                                                          func WriteTransactions

                                                                                                                          func WriteTransactions(db ethdb.Database, block *types.Block) error

                                                                                                                            WriteTransactions stores the transactions associated with a specific block into the given database. Beside writing the transaction, the function also stores a metadata entry along with the transaction, detailing the position of this within the blockchain.

                                                                                                                            Types

                                                                                                                            type BadBlockArgs

                                                                                                                            type BadBlockArgs struct {
                                                                                                                            	Hash   common.Hash   `json:"hash"`
                                                                                                                            	Header *types.Header `json:"header"`
                                                                                                                            }

                                                                                                                              BadBlockArgs represents the entries in the list returned when bad blocks are queried.

                                                                                                                              type BlockChain

                                                                                                                              type BlockChain struct {
                                                                                                                              	// contains filtered or unexported fields
                                                                                                                              }

                                                                                                                                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.

                                                                                                                                func NewBlockChain

                                                                                                                                func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, engine consensus.Engine, mux *event.TypeMux, vmConfig vm.Config) (*BlockChain, error)

                                                                                                                                  NewBlockChain returns a fully initialised block chain using information available in the database. It initialises the default Ethereum Validator and Processor.

                                                                                                                                  func (*BlockChain) BadBlocks

                                                                                                                                  func (bc *BlockChain) BadBlocks() ([]BadBlockArgs, error)

                                                                                                                                    BadBlocks returns a list of the last 'bad blocks' that the client has seen on the network

                                                                                                                                    func (*BlockChain) Config

                                                                                                                                    func (bc *BlockChain) Config() *params.ChainConfig

                                                                                                                                      Config retrieves the blockchain's chain configuration.

                                                                                                                                      func (*BlockChain) CurrentBlock

                                                                                                                                      func (bc *BlockChain) CurrentBlock() *types.Block

                                                                                                                                        CurrentBlock retrieves the current head block of the canonical chain. The block is retrieved from the blockchain's internal cache.

                                                                                                                                        func (*BlockChain) CurrentFastBlock

                                                                                                                                        func (bc *BlockChain) CurrentFastBlock() *types.Block

                                                                                                                                          CurrentFastBlock retrieves the current fast-sync head block of the canonical chain. The block is retrieved from the blockchain's internal cache.

                                                                                                                                          func (*BlockChain) CurrentHeader

                                                                                                                                          func (bc *BlockChain) CurrentHeader() *types.Header

                                                                                                                                            CurrentHeader retrieves the current head header of the canonical chain. The header is retrieved from the HeaderChain's internal cache.

                                                                                                                                            func (*BlockChain) Engine

                                                                                                                                            func (bc *BlockChain) Engine() consensus.Engine

                                                                                                                                              Engine retrieves the blockchain's consensus engine.

                                                                                                                                              func (*BlockChain) Export

                                                                                                                                              func (bc *BlockChain) Export(w io.Writer) error

                                                                                                                                                Export writes the active chain to the given writer.

                                                                                                                                                func (*BlockChain) ExportN

                                                                                                                                                func (bc *BlockChain) ExportN(w io.Writer, first uint64, last uint64) error

                                                                                                                                                  ExportN writes a subset of the active chain to the given writer.

                                                                                                                                                  func (*BlockChain) FastSyncCommitHead

                                                                                                                                                  func (bc *BlockChain) FastSyncCommitHead(hash common.Hash) error

                                                                                                                                                    FastSyncCommitHead sets the current head block to the one defined by the hash irrelevant what the chain contents were prior.

                                                                                                                                                    func (*BlockChain) GasLimit

                                                                                                                                                    func (bc *BlockChain) GasLimit() *big.Int

                                                                                                                                                      GasLimit returns the gas limit of the current HEAD block.

                                                                                                                                                      func (*BlockChain) Genesis

                                                                                                                                                      func (bc *BlockChain) Genesis() *types.Block

                                                                                                                                                        Genesis retrieves the chain's genesis block.

                                                                                                                                                        func (*BlockChain) GetBlock

                                                                                                                                                        func (bc *BlockChain) GetBlock(hash common.Hash, number uint64) *types.Block

                                                                                                                                                          GetBlock retrieves a block from the database by hash and number, caching it if found.

                                                                                                                                                          func (*BlockChain) GetBlockByHash

                                                                                                                                                          func (bc *BlockChain) GetBlockByHash(hash common.Hash) *types.Block

                                                                                                                                                            GetBlockByHash retrieves a block from the database by hash, caching it if found.

                                                                                                                                                            func (*BlockChain) GetBlockByNumber

                                                                                                                                                            func (bc *BlockChain) GetBlockByNumber(number uint64) *types.Block

                                                                                                                                                              GetBlockByNumber retrieves a block from the database by number, caching it (associated with its hash) if found.

                                                                                                                                                              func (*BlockChain) GetBlockHashesFromHash

                                                                                                                                                              func (bc *BlockChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash

                                                                                                                                                                GetBlockHashesFromHash retrieves a number of block hashes starting at a given hash, fetching towards the genesis block.

                                                                                                                                                                func (*BlockChain) GetBlocksFromHash

                                                                                                                                                                func (bc *BlockChain) GetBlocksFromHash(hash common.Hash, n int) (blocks []*types.Block)

                                                                                                                                                                  GetBlocksFromHash returns the block corresponding to hash and up to n-1 ancestors. [deprecated by eth/62]

                                                                                                                                                                  func (*BlockChain) GetBody

                                                                                                                                                                  func (bc *BlockChain) GetBody(hash common.Hash) *types.Body

                                                                                                                                                                    GetBody retrieves a block body (transactions and uncles) from the database by hash, caching it if found.

                                                                                                                                                                    func (*BlockChain) GetBodyRLP

                                                                                                                                                                    func (bc *BlockChain) GetBodyRLP(hash common.Hash) rlp.RawValue

                                                                                                                                                                      GetBodyRLP retrieves a block body in RLP encoding from the database by hash, caching it if found.

                                                                                                                                                                      func (*BlockChain) GetHeader

                                                                                                                                                                      func (bc *BlockChain) GetHeader(hash common.Hash, number uint64) *types.Header

                                                                                                                                                                        GetHeader retrieves a block header from the database by hash and number, caching it if found.

                                                                                                                                                                        func (*BlockChain) GetHeaderByHash

                                                                                                                                                                        func (bc *BlockChain) GetHeaderByHash(hash common.Hash) *types.Header

                                                                                                                                                                          GetHeaderByHash retrieves a block header from the database by hash, caching it if found.

                                                                                                                                                                          func (*BlockChain) GetHeaderByNumber

                                                                                                                                                                          func (bc *BlockChain) GetHeaderByNumber(number uint64) *types.Header

                                                                                                                                                                            GetHeaderByNumber retrieves a block header from the database by number, caching it (associated with its hash) if found.

                                                                                                                                                                            func (*BlockChain) GetTd

                                                                                                                                                                            func (bc *BlockChain) GetTd(hash common.Hash, number uint64) *big.Int

                                                                                                                                                                              GetTd retrieves a block's total difficulty in the canonical chain from the database by hash and number, caching it if found.

                                                                                                                                                                              func (*BlockChain) GetTdByHash

                                                                                                                                                                              func (bc *BlockChain) GetTdByHash(hash common.Hash) *big.Int

                                                                                                                                                                                GetTdByHash retrieves a block's total difficulty in the canonical chain from the database by hash, caching it if found.

                                                                                                                                                                                func (*BlockChain) GetUnclesInChain

                                                                                                                                                                                func (bc *BlockChain) GetUnclesInChain(block *types.Block, length int) []*types.Header

                                                                                                                                                                                  GetUnclesInChain retrieves all the uncles from a given block backwards until a specific distance is reached.

                                                                                                                                                                                  func (*BlockChain) HasBlock

                                                                                                                                                                                  func (bc *BlockChain) HasBlock(hash common.Hash) bool

                                                                                                                                                                                    HasBlock checks if a block is fully present in the database or not, caching it if present.

                                                                                                                                                                                    func (*BlockChain) HasBlockAndState

                                                                                                                                                                                    func (bc *BlockChain) HasBlockAndState(hash common.Hash) bool

                                                                                                                                                                                      HasBlockAndState checks if a block and associated state trie is fully present in the database or not, caching it if present.

                                                                                                                                                                                      func (*BlockChain) HasHeader

                                                                                                                                                                                      func (bc *BlockChain) HasHeader(hash common.Hash) bool

                                                                                                                                                                                        HasHeader checks if a block header is present in the database or not, caching it if present.

                                                                                                                                                                                        func (*BlockChain) InsertChain

                                                                                                                                                                                        func (bc *BlockChain) InsertChain(chain types.Blocks) (int, error)

                                                                                                                                                                                          InsertChain will attempt to insert the given chain 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 (for possible errors see core/errors.go).

                                                                                                                                                                                          func (*BlockChain) InsertHeaderChain

                                                                                                                                                                                          func (bc *BlockChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error)

                                                                                                                                                                                            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 (*BlockChain) InsertReceiptChain

                                                                                                                                                                                            func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain []types.Receipts) (int, error)

                                                                                                                                                                                              InsertReceiptChain attempts to complete an already existing header chain with transaction and receipt data. XXX should this be moved to the test?

                                                                                                                                                                                              func (*BlockChain) LastBlockHash

                                                                                                                                                                                              func (bc *BlockChain) LastBlockHash() common.Hash

                                                                                                                                                                                                LastBlockHash return the hash of the HEAD block.

                                                                                                                                                                                                func (*BlockChain) Processor

                                                                                                                                                                                                func (bc *BlockChain) Processor() Processor

                                                                                                                                                                                                  Processor returns the current processor.

                                                                                                                                                                                                  func (*BlockChain) Reset

                                                                                                                                                                                                  func (bc *BlockChain) Reset() error

                                                                                                                                                                                                    Reset purges the entire blockchain, restoring it to its genesis state.

                                                                                                                                                                                                    func (*BlockChain) ResetWithGenesisBlock

                                                                                                                                                                                                    func (bc *BlockChain) ResetWithGenesisBlock(genesis *types.Block) error

                                                                                                                                                                                                      ResetWithGenesisBlock purges the entire blockchain, restoring it to the specified genesis state.

                                                                                                                                                                                                      func (*BlockChain) Rollback

                                                                                                                                                                                                      func (bc *BlockChain) Rollback(chain []common.Hash)

                                                                                                                                                                                                        Rollback is designed to remove a chain of links from the database that aren't certain enough to be valid.

                                                                                                                                                                                                        func (*BlockChain) SetHead

                                                                                                                                                                                                        func (bc *BlockChain) SetHead(head uint64) error

                                                                                                                                                                                                          SetHead rewinds the local chain to a new head. In the case of headers, everything above the new head will be deleted and the new one set. In the case of blocks though, the head may be further rewound if block bodies are missing (non-archive nodes after a fast sync).

                                                                                                                                                                                                          func (*BlockChain) SetProcessor

                                                                                                                                                                                                          func (bc *BlockChain) SetProcessor(processor Processor)

                                                                                                                                                                                                            SetProcessor sets the processor required for making state modifications.

                                                                                                                                                                                                            func (*BlockChain) SetValidator

                                                                                                                                                                                                            func (bc *BlockChain) SetValidator(validator Validator)

                                                                                                                                                                                                              SetValidator sets the validator which is used to validate incoming blocks.

                                                                                                                                                                                                              func (*BlockChain) State

                                                                                                                                                                                                              func (bc *BlockChain) State() (*state.StateDB, error)

                                                                                                                                                                                                                State returns a new mutable state based on the current HEAD block.

                                                                                                                                                                                                                func (*BlockChain) StateAt

                                                                                                                                                                                                                func (bc *BlockChain) StateAt(root common.Hash) (*state.StateDB, error)

                                                                                                                                                                                                                  StateAt returns a new mutable state based on a particular point in time.

                                                                                                                                                                                                                  func (*BlockChain) Status

                                                                                                                                                                                                                  func (bc *BlockChain) Status() (td *big.Int, currentBlock common.Hash, genesisBlock common.Hash)

                                                                                                                                                                                                                    Status returns status information about the current chain such as the HEAD Td, the HEAD hash and the hash of the genesis block.

                                                                                                                                                                                                                    func (*BlockChain) Stop

                                                                                                                                                                                                                    func (bc *BlockChain) Stop()

                                                                                                                                                                                                                      Stop stops the blockchain service. If any imports are currently in progress it will abort them using the procInterrupt.

                                                                                                                                                                                                                      func (*BlockChain) Validator

                                                                                                                                                                                                                      func (bc *BlockChain) Validator() Validator

                                                                                                                                                                                                                        Validator returns the current validator.

                                                                                                                                                                                                                        func (*BlockChain) WriteBlock

                                                                                                                                                                                                                        func (bc *BlockChain) WriteBlock(block *types.Block) (status WriteStatus, err error)

                                                                                                                                                                                                                          WriteBlock writes the block to the chain.

                                                                                                                                                                                                                          type BlockGen

                                                                                                                                                                                                                          type BlockGen struct {
                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            BlockGen creates blocks for testing. See GenerateChain for a detailed explanation.

                                                                                                                                                                                                                            func (*BlockGen) AddTx

                                                                                                                                                                                                                            func (b *BlockGen) AddTx(tx *types.Transaction)

                                                                                                                                                                                                                              AddTx adds a transaction to the generated block. If no coinbase has been set, the block's coinbase is set to the zero address.

                                                                                                                                                                                                                              AddTx panics if the transaction cannot be executed. In addition to the protocol-imposed limitations (gas limit, etc.), there are some further limitations on the content of transactions that can be added. Notably, contract code relying on the BLOCKHASH instruction will panic during execution.

                                                                                                                                                                                                                              func (*BlockGen) AddUncheckedReceipt

                                                                                                                                                                                                                              func (b *BlockGen) AddUncheckedReceipt(receipt *types.Receipt)

                                                                                                                                                                                                                                AddUncheckedReceipt forcefully adds a receipts to the block without a backing transaction.

                                                                                                                                                                                                                                AddUncheckedReceipt will cause consensus failures when used during real chain processing. This is best used in conjunction with raw block insertion.

                                                                                                                                                                                                                                func (*BlockGen) AddUncle

                                                                                                                                                                                                                                func (b *BlockGen) AddUncle(h *types.Header)

                                                                                                                                                                                                                                  AddUncle adds an uncle header to the generated block.

                                                                                                                                                                                                                                  func (*BlockGen) Number

                                                                                                                                                                                                                                  func (b *BlockGen) Number() *big.Int

                                                                                                                                                                                                                                    Number returns the block number of the block being generated.

                                                                                                                                                                                                                                    func (*BlockGen) OffsetTime

                                                                                                                                                                                                                                    func (b *BlockGen) OffsetTime(seconds int64)

                                                                                                                                                                                                                                      OffsetTime modifies the time instance of a block, implicitly changing its associated difficulty. It's useful to test scenarios where forking is not tied to chain length directly.

                                                                                                                                                                                                                                      func (*BlockGen) PrevBlock

                                                                                                                                                                                                                                      func (b *BlockGen) PrevBlock(index int) *types.Block

                                                                                                                                                                                                                                        PrevBlock returns a previously generated block by number. It panics if num is greater or equal to the number of the block being generated. For index -1, PrevBlock returns the parent block given to GenerateChain.

                                                                                                                                                                                                                                        func (*BlockGen) SetCoinbase

                                                                                                                                                                                                                                        func (b *BlockGen) SetCoinbase(addr common.Address)

                                                                                                                                                                                                                                          SetCoinbase sets the coinbase of the generated block. It can be called at most once.

                                                                                                                                                                                                                                          func (*BlockGen) SetExtra

                                                                                                                                                                                                                                          func (b *BlockGen) SetExtra(data []byte)

                                                                                                                                                                                                                                            SetExtra sets the extra data field of the generated block.

                                                                                                                                                                                                                                            func (*BlockGen) TxNonce

                                                                                                                                                                                                                                            func (b *BlockGen) TxNonce(addr common.Address) uint64

                                                                                                                                                                                                                                              TxNonce returns the next valid transaction nonce for the account at addr. It panics if the account does not exist.

                                                                                                                                                                                                                                              type BlockValidator

                                                                                                                                                                                                                                              type BlockValidator struct {
                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                BlockValidator is responsible for validating block headers, uncles and processed state.

                                                                                                                                                                                                                                                BlockValidator implements Validator.

                                                                                                                                                                                                                                                func NewBlockValidator

                                                                                                                                                                                                                                                func NewBlockValidator(config *params.ChainConfig, blockchain *BlockChain, engine consensus.Engine) *BlockValidator

                                                                                                                                                                                                                                                  NewBlockValidator returns a new block validator which is safe for re-use

                                                                                                                                                                                                                                                  func (*BlockValidator) ValidateBody

                                                                                                                                                                                                                                                  func (v *BlockValidator) ValidateBody(block *types.Block) error

                                                                                                                                                                                                                                                    ValidateBody validates the given block's uncles and verifies the the block header's transaction and uncle roots. The headers are assumed to be already validated at this point.

                                                                                                                                                                                                                                                    func (*BlockValidator) ValidateState

                                                                                                                                                                                                                                                    func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas *big.Int) error

                                                                                                                                                                                                                                                      ValidateState validates the various changes that happen after a state transition, such as amount of used gas, the receipt roots and the state root itself. ValidateState returns a database batch if the validation was a success otherwise nil and an error is returned.

                                                                                                                                                                                                                                                      type ChainContext

                                                                                                                                                                                                                                                      type ChainContext interface {
                                                                                                                                                                                                                                                      	// Engine retrieves the chain's consensus engine.
                                                                                                                                                                                                                                                      	Engine() consensus.Engine
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// GetHeader returns the hash corresponding to their hash.
                                                                                                                                                                                                                                                      	GetHeader(common.Hash, uint64) *types.Header
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        ChainContext supports retrieving headers and consensus parameters from the current blockchain to be used during transaction processing.

                                                                                                                                                                                                                                                        type ChainEvent

                                                                                                                                                                                                                                                        type ChainEvent struct {
                                                                                                                                                                                                                                                        	Block *types.Block
                                                                                                                                                                                                                                                        	Hash  common.Hash
                                                                                                                                                                                                                                                        	Logs  []*types.Log
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                        type ChainHeadEvent

                                                                                                                                                                                                                                                        type ChainHeadEvent struct{ Block *types.Block }

                                                                                                                                                                                                                                                        type ChainSideEvent

                                                                                                                                                                                                                                                        type ChainSideEvent struct {
                                                                                                                                                                                                                                                        	Block *types.Block
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                        type ChainUncleEvent

                                                                                                                                                                                                                                                        type ChainUncleEvent struct {
                                                                                                                                                                                                                                                        	Block *types.Block
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                        type DeleteCallback

                                                                                                                                                                                                                                                        type DeleteCallback func(common.Hash, uint64)

                                                                                                                                                                                                                                                          DeleteCallback is a callback function that is called by SetHead before each header is deleted.

                                                                                                                                                                                                                                                          type GasPool

                                                                                                                                                                                                                                                          type GasPool big.Int

                                                                                                                                                                                                                                                            GasPool tracks the amount of gas available during execution of the transactions in a block. The zero value is a pool with zero gas available.

                                                                                                                                                                                                                                                            func (*GasPool) AddGas

                                                                                                                                                                                                                                                            func (gp *GasPool) AddGas(amount *big.Int) *GasPool

                                                                                                                                                                                                                                                              AddGas makes gas available for execution.

                                                                                                                                                                                                                                                              func (*GasPool) String

                                                                                                                                                                                                                                                              func (gp *GasPool) String() string

                                                                                                                                                                                                                                                              func (*GasPool) SubGas

                                                                                                                                                                                                                                                              func (gp *GasPool) SubGas(amount *big.Int) error

                                                                                                                                                                                                                                                                SubGas deducts the given amount from the pool if enough gas is available and returns an error otherwise.

                                                                                                                                                                                                                                                                type Genesis

                                                                                                                                                                                                                                                                type Genesis struct {
                                                                                                                                                                                                                                                                	Config     *params.ChainConfig `json:"config"`
                                                                                                                                                                                                                                                                	Nonce      uint64              `json:"nonce"`
                                                                                                                                                                                                                                                                	Timestamp  uint64              `json:"timestamp"`
                                                                                                                                                                                                                                                                	ParentHash common.Hash         `json:"parentHash"`
                                                                                                                                                                                                                                                                	ExtraData  []byte              `json:"extraData"`
                                                                                                                                                                                                                                                                	GasLimit   uint64              `json:"gasLimit"   gencodec:"required"`
                                                                                                                                                                                                                                                                	Difficulty *big.Int            `json:"difficulty" gencodec:"required"`
                                                                                                                                                                                                                                                                	Mixhash    common.Hash         `json:"mixHash"`
                                                                                                                                                                                                                                                                	Coinbase   common.Address      `json:"coinbase"`
                                                                                                                                                                                                                                                                	Alloc      GenesisAlloc        `json:"alloc"      gencodec:"required"`
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  Genesis specifies the header fields, state of a genesis block. It also defines hard fork switch-over blocks through the chain configuration.

                                                                                                                                                                                                                                                                  func DefaultGenesisBlock

                                                                                                                                                                                                                                                                  func DefaultGenesisBlock() *Genesis

                                                                                                                                                                                                                                                                    DefaultGenesisBlock returns the Ethereum main net genesis block.

                                                                                                                                                                                                                                                                    func DefaultOttomanGenesisBlock

                                                                                                                                                                                                                                                                    func DefaultOttomanGenesisBlock() *Genesis

                                                                                                                                                                                                                                                                    func DefaultReapChainGenesisBlock

                                                                                                                                                                                                                                                                    func DefaultReapChainGenesisBlock() *Genesis

                                                                                                                                                                                                                                                                      DefaultOttomanGenesisBlock returns the Ottoman network genesis block.

                                                                                                                                                                                                                                                                      func DefaultRinkebyGenesisBlock

                                                                                                                                                                                                                                                                      func DefaultRinkebyGenesisBlock() *Genesis

                                                                                                                                                                                                                                                                        DefaultRinkebyGenesisBlock returns the Rinkeby network genesis block.

                                                                                                                                                                                                                                                                        func DefaultTestnetGenesisBlock

                                                                                                                                                                                                                                                                        func DefaultTestnetGenesisBlock() *Genesis

                                                                                                                                                                                                                                                                          DefaultTestnetGenesisBlock returns the Ropsten network genesis block.

                                                                                                                                                                                                                                                                          func DevGenesisBlock

                                                                                                                                                                                                                                                                          func DevGenesisBlock() *Genesis

                                                                                                                                                                                                                                                                            DevGenesisBlock returns the 'geth --dev' genesis block.

                                                                                                                                                                                                                                                                            func (*Genesis) Commit

                                                                                                                                                                                                                                                                            func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error)

                                                                                                                                                                                                                                                                              Commit writes the block and state of a genesis specification to the database. The block is committed as the canonical head block.

                                                                                                                                                                                                                                                                              func (Genesis) MarshalJSON

                                                                                                                                                                                                                                                                              func (g Genesis) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                MarshalJSON marshals as JSON.

                                                                                                                                                                                                                                                                                func (*Genesis) MustCommit

                                                                                                                                                                                                                                                                                func (g *Genesis) MustCommit(db ethdb.Database) *types.Block

                                                                                                                                                                                                                                                                                  MustCommit writes the genesis block and state to db, panicking on error. The block is committed as the canonical head block.

                                                                                                                                                                                                                                                                                  func (*Genesis) ToBlock

                                                                                                                                                                                                                                                                                  func (g *Genesis) ToBlock() (*types.Block, *state.StateDB)

                                                                                                                                                                                                                                                                                    ToBlock creates the block and state of a genesis specification.

                                                                                                                                                                                                                                                                                    func (*Genesis) UnmarshalJSON

                                                                                                                                                                                                                                                                                    func (g *Genesis) UnmarshalJSON(input []byte) error

                                                                                                                                                                                                                                                                                      UnmarshalJSON unmarshals from JSON.

                                                                                                                                                                                                                                                                                      type GenesisAccount

                                                                                                                                                                                                                                                                                      type GenesisAccount struct {
                                                                                                                                                                                                                                                                                      	Code    []byte                      `json:"code,omitempty"`
                                                                                                                                                                                                                                                                                      	Storage map[common.Hash]common.Hash `json:"storage,omitempty"`
                                                                                                                                                                                                                                                                                      	Balance *big.Int                    `json:"balance" gencodec:"required"`
                                                                                                                                                                                                                                                                                      	Nonce   uint64                      `json:"nonce,omitempty"`
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        GenesisAccount is an account in the state of the genesis block.

                                                                                                                                                                                                                                                                                        func (GenesisAccount) MarshalJSON

                                                                                                                                                                                                                                                                                        func (g GenesisAccount) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                          MarshalJSON marshals as JSON.

                                                                                                                                                                                                                                                                                          func (*GenesisAccount) UnmarshalJSON

                                                                                                                                                                                                                                                                                          func (g *GenesisAccount) UnmarshalJSON(input []byte) error

                                                                                                                                                                                                                                                                                            UnmarshalJSON unmarshals from JSON.

                                                                                                                                                                                                                                                                                            type GenesisAlloc

                                                                                                                                                                                                                                                                                            type GenesisAlloc map[common.Address]GenesisAccount

                                                                                                                                                                                                                                                                                              GenesisAlloc specifies the initial state that is part of the genesis block.

                                                                                                                                                                                                                                                                                              type GenesisMismatchError

                                                                                                                                                                                                                                                                                              type GenesisMismatchError struct {
                                                                                                                                                                                                                                                                                              	Stored, New common.Hash
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                GenesisMismatchError is raised when trying to overwrite an existing genesis block with an incompatible one.

                                                                                                                                                                                                                                                                                                func (*GenesisMismatchError) Error

                                                                                                                                                                                                                                                                                                func (e *GenesisMismatchError) Error() string

                                                                                                                                                                                                                                                                                                type HeaderChain

                                                                                                                                                                                                                                                                                                type HeaderChain struct {
                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  HeaderChain implements the basic block header chain logic that is shared by core.BlockChain and light.LightChain. It is not usable in itself, only as a part of either structure. It is not thread safe either, the encapsulating chain structures should do the necessary mutex locking/unlocking.

                                                                                                                                                                                                                                                                                                  func NewHeaderChain

                                                                                                                                                                                                                                                                                                  func NewHeaderChain(chainDb ethdb.Database, config *params.ChainConfig, engine consensus.Engine, procInterrupt func() bool) (*HeaderChain, error)

                                                                                                                                                                                                                                                                                                    NewHeaderChain creates a new HeaderChain structure.

                                                                                                                                                                                                                                                                                                    getValidator should return the parent's validator
                                                                                                                                                                                                                                                                                                    procInterrupt points to the parent's interrupt semaphore
                                                                                                                                                                                                                                                                                                    wg points to the parent's shutdown wait group
                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                    func (*HeaderChain) Config

                                                                                                                                                                                                                                                                                                    func (hc *HeaderChain) Config() *params.ChainConfig

                                                                                                                                                                                                                                                                                                      Config retrieves the header chain's chain configuration.

                                                                                                                                                                                                                                                                                                      func (*HeaderChain) CurrentHeader

                                                                                                                                                                                                                                                                                                      func (hc *HeaderChain) CurrentHeader() *types.Header

                                                                                                                                                                                                                                                                                                        CurrentHeader retrieves the current head header of the canonical chain. The header is retrieved from the HeaderChain's internal cache.

                                                                                                                                                                                                                                                                                                        func (*HeaderChain) Engine

                                                                                                                                                                                                                                                                                                        func (hc *HeaderChain) Engine() consensus.Engine

                                                                                                                                                                                                                                                                                                          Engine retrieves the header chain's consensus engine.

                                                                                                                                                                                                                                                                                                          func (*HeaderChain) GetBlock

                                                                                                                                                                                                                                                                                                          func (hc *HeaderChain) GetBlock(hash common.Hash, number uint64) *types.Block

                                                                                                                                                                                                                                                                                                            GetBlock implements consensus.ChainReader, and returns nil for every input as a header chain does not have blocks available for retrieval.

                                                                                                                                                                                                                                                                                                            func (*HeaderChain) GetBlockHashesFromHash

                                                                                                                                                                                                                                                                                                            func (hc *HeaderChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash

                                                                                                                                                                                                                                                                                                              GetBlockHashesFromHash retrieves a number of block hashes starting at a given hash, fetching towards the genesis block.

                                                                                                                                                                                                                                                                                                              func (*HeaderChain) GetBlockNumber

                                                                                                                                                                                                                                                                                                              func (hc *HeaderChain) GetBlockNumber(hash common.Hash) uint64

                                                                                                                                                                                                                                                                                                                GetBlockNumber retrieves the block number belonging to the given hash from the cache or database

                                                                                                                                                                                                                                                                                                                func (*HeaderChain) GetHeader

                                                                                                                                                                                                                                                                                                                func (hc *HeaderChain) GetHeader(hash common.Hash, number uint64) *types.Header

                                                                                                                                                                                                                                                                                                                  GetHeader retrieves a block header from the database by hash and number, caching it if found.

                                                                                                                                                                                                                                                                                                                  func (*HeaderChain) GetHeaderByHash

                                                                                                                                                                                                                                                                                                                  func (hc *HeaderChain) GetHeaderByHash(hash common.Hash) *types.Header

                                                                                                                                                                                                                                                                                                                    GetHeaderByHash retrieves a block header from the database by hash, caching it if found.

                                                                                                                                                                                                                                                                                                                    func (*HeaderChain) GetHeaderByNumber

                                                                                                                                                                                                                                                                                                                    func (hc *HeaderChain) GetHeaderByNumber(number uint64) *types.Header

                                                                                                                                                                                                                                                                                                                      GetHeaderByNumber retrieves a block header from the database by number, caching it (associated with its hash) if found.

                                                                                                                                                                                                                                                                                                                      func (*HeaderChain) GetTd

                                                                                                                                                                                                                                                                                                                      func (hc *HeaderChain) GetTd(hash common.Hash, number uint64) *big.Int

                                                                                                                                                                                                                                                                                                                        GetTd retrieves a block's total difficulty in the canonical chain from the database by hash and number, caching it if found.

                                                                                                                                                                                                                                                                                                                        func (*HeaderChain) GetTdByHash

                                                                                                                                                                                                                                                                                                                        func (hc *HeaderChain) GetTdByHash(hash common.Hash) *big.Int

                                                                                                                                                                                                                                                                                                                          GetTdByHash retrieves a block's total difficulty in the canonical chain from the database by hash, caching it if found.

                                                                                                                                                                                                                                                                                                                          func (*HeaderChain) HasHeader

                                                                                                                                                                                                                                                                                                                          func (hc *HeaderChain) HasHeader(hash common.Hash) bool

                                                                                                                                                                                                                                                                                                                            HasHeader checks if a block header is present in the database or not, caching it if present.

                                                                                                                                                                                                                                                                                                                            func (*HeaderChain) InsertHeaderChain

                                                                                                                                                                                                                                                                                                                            func (hc *HeaderChain) InsertHeaderChain(chain []*types.Header, writeHeader WhCallback, start time.Time) (int, error)

                                                                                                                                                                                                                                                                                                                              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 verfy nonces, as well as because nonces can be verified sparsely, not needing to check each.

                                                                                                                                                                                                                                                                                                                              func (*HeaderChain) SetCurrentHeader

                                                                                                                                                                                                                                                                                                                              func (hc *HeaderChain) SetCurrentHeader(head *types.Header)

                                                                                                                                                                                                                                                                                                                                SetCurrentHeader sets the current head header of the canonical chain.

                                                                                                                                                                                                                                                                                                                                func (*HeaderChain) SetGenesis

                                                                                                                                                                                                                                                                                                                                func (hc *HeaderChain) SetGenesis(head *types.Header)

                                                                                                                                                                                                                                                                                                                                  SetGenesis sets a new genesis block header for the chain

                                                                                                                                                                                                                                                                                                                                  func (*HeaderChain) SetHead

                                                                                                                                                                                                                                                                                                                                  func (hc *HeaderChain) SetHead(head uint64, delFn DeleteCallback)

                                                                                                                                                                                                                                                                                                                                    SetHead rewinds the local chain to a new head. Everything above the new head will be deleted and the new one set.

                                                                                                                                                                                                                                                                                                                                    func (*HeaderChain) ValidateHeaderChain

                                                                                                                                                                                                                                                                                                                                    func (hc *HeaderChain) ValidateHeaderChain(chain []*types.Header, checkFreq int) (int, error)

                                                                                                                                                                                                                                                                                                                                    func (*HeaderChain) WriteHeader

                                                                                                                                                                                                                                                                                                                                    func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, err error)

                                                                                                                                                                                                                                                                                                                                      WriteHeader writes a header into the local chain, given that its parent is already known. If the total difficulty of the newly inserted header becomes greater than the current known TD, the canonical chain is re-routed.

                                                                                                                                                                                                                                                                                                                                      Note: This method is not concurrent-safe with inserting blocks simultaneously into the chain, as side effects caused by reorganisations cannot be emulated without the real blocks. Hence, writing headers directly should only be done in two scenarios: pure-header mode of operation (light clients), or properly separated header/block phases (non-archive clients).

                                                                                                                                                                                                                                                                                                                                      func (*HeaderChain) WriteTd

                                                                                                                                                                                                                                                                                                                                      func (hc *HeaderChain) WriteTd(hash common.Hash, number uint64, td *big.Int) error

                                                                                                                                                                                                                                                                                                                                        WriteTd stores a block's total difficulty into the database, also caching it along the way.

                                                                                                                                                                                                                                                                                                                                        type Message

                                                                                                                                                                                                                                                                                                                                        type Message interface {
                                                                                                                                                                                                                                                                                                                                        	From() common.Address
                                                                                                                                                                                                                                                                                                                                        	//FromFrontier() (common.Address, error)
                                                                                                                                                                                                                                                                                                                                        	To() *common.Address
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	GasPrice() *big.Int
                                                                                                                                                                                                                                                                                                                                        	Gas() *big.Int
                                                                                                                                                                                                                                                                                                                                        	Value() *big.Int
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	Nonce() uint64
                                                                                                                                                                                                                                                                                                                                        	CheckNonce() bool
                                                                                                                                                                                                                                                                                                                                        	Data() []byte
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	Governance() bool
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          Message represents a message sent to a contract.

                                                                                                                                                                                                                                                                                                                                          type NewMinedBlockEvent

                                                                                                                                                                                                                                                                                                                                          type NewMinedBlockEvent struct{ Block *types.Block }

                                                                                                                                                                                                                                                                                                                                            NewMinedBlockEvent is posted when a block has been imported.

                                                                                                                                                                                                                                                                                                                                            type PendingBlockEvent

                                                                                                                                                                                                                                                                                                                                            type PendingBlockEvent struct {
                                                                                                                                                                                                                                                                                                                                            	Block *types.Block
                                                                                                                                                                                                                                                                                                                                            	Logs  []*types.Log
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                            type PendingLogsEvent

                                                                                                                                                                                                                                                                                                                                            type PendingLogsEvent struct {
                                                                                                                                                                                                                                                                                                                                            	Logs []*types.Log
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              PendingLogsEvent is posted pre mining and notifies of pending logs.

                                                                                                                                                                                                                                                                                                                                              type PendingStateEvent

                                                                                                                                                                                                                                                                                                                                              type PendingStateEvent struct{}

                                                                                                                                                                                                                                                                                                                                                PendingStateEvent is posted pre mining and notifies of pending state changes.

                                                                                                                                                                                                                                                                                                                                                type Processor

                                                                                                                                                                                                                                                                                                                                                type Processor interface {
                                                                                                                                                                                                                                                                                                                                                	Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error)
                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                  Processor is an interface for processing blocks using a given initial state.

                                                                                                                                                                                                                                                                                                                                                  Process takes the block to be processed and the statedb upon which the initial state is based. It should return the receipts generated, amount of gas used in the process and return an error if any of the internal rules failed.

                                                                                                                                                                                                                                                                                                                                                  type RemovedLogsEvent

                                                                                                                                                                                                                                                                                                                                                  type RemovedLogsEvent struct{ Logs []*types.Log }

                                                                                                                                                                                                                                                                                                                                                    RemovedLogsEvent is posted when a reorg happens

                                                                                                                                                                                                                                                                                                                                                    type RemovedTransactionEvent

                                                                                                                                                                                                                                                                                                                                                    type RemovedTransactionEvent struct{ Txs types.Transactions }

                                                                                                                                                                                                                                                                                                                                                      RemovedTransactionEvent is posted when a reorg happens

                                                                                                                                                                                                                                                                                                                                                      type StartMining

                                                                                                                                                                                                                                                                                                                                                      type StartMining struct{}

                                                                                                                                                                                                                                                                                                                                                        Mining operation events

                                                                                                                                                                                                                                                                                                                                                        type StateProcessor

                                                                                                                                                                                                                                                                                                                                                        type StateProcessor struct {
                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          StateProcessor is a basic Processor, which takes care of transitioning state from one point to another.

                                                                                                                                                                                                                                                                                                                                                          StateProcessor implements Processor.

                                                                                                                                                                                                                                                                                                                                                          func NewStateProcessor

                                                                                                                                                                                                                                                                                                                                                          func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consensus.Engine) *StateProcessor

                                                                                                                                                                                                                                                                                                                                                            NewStateProcessor initialises a new StateProcessor.

                                                                                                                                                                                                                                                                                                                                                            func (*StateProcessor) Process

                                                                                                                                                                                                                                                                                                                                                            func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error)

                                                                                                                                                                                                                                                                                                                                                              Process processes the state changes according to the Ethereum rules by running the transaction messages using the statedb and applying any rewards to both the processor (coinbase) and any included uncles.

                                                                                                                                                                                                                                                                                                                                                              Process returns the receipts and logs accumulated during the process and returns the amount of gas that was used in the process. If any of the transactions failed to execute due to insufficient gas it will return an error.

                                                                                                                                                                                                                                                                                                                                                              type StateTransition

                                                                                                                                                                                                                                                                                                                                                              type StateTransition struct {
                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                The State Transitioning Model

                                                                                                                                                                                                                                                                                                                                                                A state transition is a change made when a transaction is applied to the current world state The state transitioning model does all all the necessary work to work out a valid new state root.

                                                                                                                                                                                                                                                                                                                                                                1) Nonce handling 2) Pre pay gas 3) Create a new state object if the recipient is \0*32 4) Value transfer == If contract creation ==

                                                                                                                                                                                                                                                                                                                                                                4a) Attempt to run transaction data
                                                                                                                                                                                                                                                                                                                                                                4b) If valid, use result as code for the new state object
                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                == end == 5) Run Script section 6) Derive new state root

                                                                                                                                                                                                                                                                                                                                                                func NewStateTransition

                                                                                                                                                                                                                                                                                                                                                                func NewStateTransition(evm *vm.EVM, msg Message, gp *GasPool) *StateTransition

                                                                                                                                                                                                                                                                                                                                                                  NewStateTransition initialises and returns a new state transition object.

                                                                                                                                                                                                                                                                                                                                                                  func (*StateTransition) TransitionDb

                                                                                                                                                                                                                                                                                                                                                                  func (st *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big.Int, failed bool, err error)

                                                                                                                                                                                                                                                                                                                                                                    TransitionDb will transition the state by applying the current message and returning the result including the required gas for the operation as well as the used gas. It returns an error if it failed. An error indicates a consensus issue.

                                                                                                                                                                                                                                                                                                                                                                    type TopMining

                                                                                                                                                                                                                                                                                                                                                                    type TopMining struct{}

                                                                                                                                                                                                                                                                                                                                                                    type TxPool

                                                                                                                                                                                                                                                                                                                                                                    type TxPool struct {
                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      TxPool contains all currently known transactions. Transactions enter the pool when they are received from the network or submitted locally. They exit the pool when they are included in the blockchain.

                                                                                                                                                                                                                                                                                                                                                                      The pool separates processable transactions (which can be applied to the current state) and future transactions. Transactions move between those two states over time as they are received and processed.

                                                                                                                                                                                                                                                                                                                                                                      func NewTxPool

                                                                                                                                                                                                                                                                                                                                                                      func NewTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, eventMux *event.TypeMux, currentStateFn stateFn, gasLimitFn func() *big.Int) *TxPool

                                                                                                                                                                                                                                                                                                                                                                        NewTxPool creates a new transaction pool to gather, sort and filter inbound trnsactions from the network.

                                                                                                                                                                                                                                                                                                                                                                        func (*TxPool) Add

                                                                                                                                                                                                                                                                                                                                                                        func (pool *TxPool) Add(tx *types.Transaction) error

                                                                                                                                                                                                                                                                                                                                                                          Add queues a single transaction in the pool if it is valid.

                                                                                                                                                                                                                                                                                                                                                                          func (*TxPool) AddBatch

                                                                                                                                                                                                                                                                                                                                                                          func (pool *TxPool) AddBatch(txs []*types.Transaction) error

                                                                                                                                                                                                                                                                                                                                                                            AddBatch attempts to queue a batch of transactions.

                                                                                                                                                                                                                                                                                                                                                                            func (*TxPool) Content

                                                                                                                                                                                                                                                                                                                                                                            func (pool *TxPool) Content() (map[common.Address]types.Transactions, map[common.Address]types.Transactions)

                                                                                                                                                                                                                                                                                                                                                                              Content retrieves the data content of the transaction pool, returning all the pending as well as queued transactions, grouped by account and sorted by nonce.

                                                                                                                                                                                                                                                                                                                                                                              func (*TxPool) GasPrice

                                                                                                                                                                                                                                                                                                                                                                              func (pool *TxPool) GasPrice() *big.Int

                                                                                                                                                                                                                                                                                                                                                                                GasPrice returns the current gas price enforced by the transaction pool.

                                                                                                                                                                                                                                                                                                                                                                                func (*TxPool) Get

                                                                                                                                                                                                                                                                                                                                                                                func (pool *TxPool) Get(hash common.Hash) *types.Transaction

                                                                                                                                                                                                                                                                                                                                                                                  Get returns a transaction if it is contained in the pool and nil otherwise.

                                                                                                                                                                                                                                                                                                                                                                                  func (*TxPool) Pending

                                                                                                                                                                                                                                                                                                                                                                                  func (pool *TxPool) Pending() (map[common.Address]types.Transactions, error)

                                                                                                                                                                                                                                                                                                                                                                                    Pending retrieves all currently processable transactions, groupped by origin account and sorted by nonce. The returned transaction set is a copy and can be freely modified by calling code.

                                                                                                                                                                                                                                                                                                                                                                                    func (*TxPool) Remove

                                                                                                                                                                                                                                                                                                                                                                                    func (pool *TxPool) Remove(hash common.Hash)

                                                                                                                                                                                                                                                                                                                                                                                      Remove removes the transaction with the given hash from the pool.

                                                                                                                                                                                                                                                                                                                                                                                      func (*TxPool) RemoveBatch

                                                                                                                                                                                                                                                                                                                                                                                      func (pool *TxPool) RemoveBatch(txs types.Transactions)

                                                                                                                                                                                                                                                                                                                                                                                        RemoveBatch removes all given transactions from the pool.

                                                                                                                                                                                                                                                                                                                                                                                        func (*TxPool) SetGasPrice

                                                                                                                                                                                                                                                                                                                                                                                        func (pool *TxPool) SetGasPrice(price *big.Int)

                                                                                                                                                                                                                                                                                                                                                                                          SetGasPrice updates the minimum price required by the transaction pool for a new transaction, and drops all transactions below this threshold.

                                                                                                                                                                                                                                                                                                                                                                                          func (*TxPool) SetLocal

                                                                                                                                                                                                                                                                                                                                                                                          func (pool *TxPool) SetLocal(tx *types.Transaction)

                                                                                                                                                                                                                                                                                                                                                                                            SetLocal marks a transaction as local, skipping gas price

                                                                                                                                                                                                                                                                                                                                                                                            check against local miner minimum in the future
                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                            func (*TxPool) State

                                                                                                                                                                                                                                                                                                                                                                                            func (pool *TxPool) State() *state.ManagedState

                                                                                                                                                                                                                                                                                                                                                                                              State returns the virtual managed state of the transaction pool.

                                                                                                                                                                                                                                                                                                                                                                                              func (*TxPool) Stats

                                                                                                                                                                                                                                                                                                                                                                                              func (pool *TxPool) Stats() (int, int)

                                                                                                                                                                                                                                                                                                                                                                                                Stats retrieves the current pool stats, namely the number of pending and the number of queued (non-executable) transactions.

                                                                                                                                                                                                                                                                                                                                                                                                func (*TxPool) Stop

                                                                                                                                                                                                                                                                                                                                                                                                func (pool *TxPool) Stop()

                                                                                                                                                                                                                                                                                                                                                                                                  Stop terminates the transaction pool.

                                                                                                                                                                                                                                                                                                                                                                                                  type TxPoolConfig

                                                                                                                                                                                                                                                                                                                                                                                                  type TxPoolConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                  	PriceLimit uint64 // Minimum gas price to enforce for acceptance into the pool
                                                                                                                                                                                                                                                                                                                                                                                                  	PriceBump  uint64 // Minimum price bump percentage to replace an already existing transaction (nonce)
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	AccountSlots uint64 // Minimum number of executable transaction slots guaranteed per account
                                                                                                                                                                                                                                                                                                                                                                                                  	GlobalSlots  uint64 // Maximum number of executable transaction slots for all accounts
                                                                                                                                                                                                                                                                                                                                                                                                  	AccountQueue uint64 // Maximum number of non-executable transaction slots permitted per account
                                                                                                                                                                                                                                                                                                                                                                                                  	GlobalQueue  uint64 // Maximum number of non-executable transaction slots for all accounts
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	Lifetime time.Duration // Maximum amount of time non-executable transaction are queued
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	MaxCodeSize uint64 // Maximum size allowed of contract code that can be deployed (in KB)
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    TxPoolConfig are the configuration parameters of the transaction pool.

                                                                                                                                                                                                                                                                                                                                                                                                    type TxPostEvent

                                                                                                                                                                                                                                                                                                                                                                                                    type TxPostEvent struct{ Tx *types.Transaction }

                                                                                                                                                                                                                                                                                                                                                                                                      TxPostEvent is posted when a transaction has been processed.

                                                                                                                                                                                                                                                                                                                                                                                                      type TxPreEvent

                                                                                                                                                                                                                                                                                                                                                                                                      type TxPreEvent struct{ Tx *types.Transaction }

                                                                                                                                                                                                                                                                                                                                                                                                        TxPreEvent is posted when a transaction enters the transaction pool.

                                                                                                                                                                                                                                                                                                                                                                                                        type Validator

                                                                                                                                                                                                                                                                                                                                                                                                        type Validator interface {
                                                                                                                                                                                                                                                                                                                                                                                                        	// ValidateBody validates the given block's content.
                                                                                                                                                                                                                                                                                                                                                                                                        	ValidateBody(block *types.Block) error
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        	// ValidateState validates the given statedb and optionally the receipts and
                                                                                                                                                                                                                                                                                                                                                                                                        	// gas used.
                                                                                                                                                                                                                                                                                                                                                                                                        	ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas *big.Int) error
                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                          Validator is an interface which defines the standard for block validation. It is only responsible for validating block contents, as the header validation is done by the specific consensus engines.

                                                                                                                                                                                                                                                                                                                                                                                                          type WhCallback

                                                                                                                                                                                                                                                                                                                                                                                                          type WhCallback func(*types.Header) error

                                                                                                                                                                                                                                                                                                                                                                                                            WhCallback is a callback function for inserting individual headers. A callback is used for two reasons: first, in a LightChain, status should be processed and light chain events sent, while in a BlockChain this is not necessary since chain events are sent after inserting blocks. Second, the header writes should be protected by the parent chain mutex individually.

                                                                                                                                                                                                                                                                                                                                                                                                            type WriteStatus

                                                                                                                                                                                                                                                                                                                                                                                                            type WriteStatus byte

                                                                                                                                                                                                                                                                                                                                                                                                              WriteStatus status of write

                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                              	NonStatTy   WriteStatus = iota
                                                                                                                                                                                                                                                                                                                                                                                                              	CanonStatTy             //?
                                                                                                                                                                                                                                                                                                                                                                                                              	SideStatTy
                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                              Directories

                                                                                                                                                                                                                                                                                                                                                                                                              Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                              Provides support for dealing with EVM assembly instructions (e.g., disassembling them).
                                                                                                                                                                                                                                                                                                                                                                                                              Provides support for dealing with EVM assembly instructions (e.g., disassembling them).
                                                                                                                                                                                                                                                                                                                                                                                                              Package state provides a caching layer atop the Ethereum state trie.
                                                                                                                                                                                                                                                                                                                                                                                                              Package state provides a caching layer atop the Ethereum state trie.
                                                                                                                                                                                                                                                                                                                                                                                                              Package types contains data types related to Ethereum consensus.
                                                                                                                                                                                                                                                                                                                                                                                                              Package types contains data types related to Ethereum consensus.
                                                                                                                                                                                                                                                                                                                                                                                                              vm
                                                                                                                                                                                                                                                                                                                                                                                                              Package vm implements the Ethereum Virtual Machine.
                                                                                                                                                                                                                                                                                                                                                                                                              Package vm implements the Ethereum Virtual Machine.
                                                                                                                                                                                                                                                                                                                                                                                                              runtime
                                                                                                                                                                                                                                                                                                                                                                                                              Package runtime provides a basic execution model for executing EVM code.
                                                                                                                                                                                                                                                                                                                                                                                                              Package runtime provides a basic execution model for executing EVM code.