Documentation
¶
Overview ¶
Package core implements the Ethereum consensus protocol.
Index ¶
- Constants
- Variables
- func AccumulateRewards(statedb *state.StateDB, header *types.Header, uncles []*types.Header)
- func ApplyMessage(env vm.Environment, msg Message, gp GasPool) ([]byte, *big.Int, error)
- func CalcDifficulty(time, parentTime uint64, parentNumber, parentDiff *big.Int) *big.Int
- func CalcGasLimit(parent *types.Block) *big.Int
- func CalcTD(block, parent *types.Block) *big.Int
- func Canary(statedb *state.StateDB) bool
- func Disassemble(script []byte) (asm []string)
- func GenerateChain(parent *types.Block, db common.Database, n int, gen func(int, *BlockGen)) []*types.Block
- func GenesisBlockForTesting(db common.Database, addr common.Address, balance *big.Int) *types.Block
- func GetBlockByHash(db common.Database, hash common.Hash) *types.Block
- func GetBlockByNumber(db common.Database, number uint64) *types.Block
- func GetBlockReceipts(db common.Database, hash common.Hash) types.Receipts
- func GetReceipt(db common.Database, txHash common.Hash) *types.Receipt
- func IntrinsicGas(data []byte) *big.Int
- func IsBlockNonceErr(err error) bool
- func IsInvalidTxErr(err error) bool
- func IsKnownBlockErr(e error) bool
- func IsNonceErr(err error) bool
- func IsParentErr(err error) bool
- func IsTDError(e error) bool
- func IsUncleErr(err error) bool
- func IsValidationErr(err error) bool
- func IsValueTransferErr(e error) bool
- func MessageCreatesContract(msg Message) bool
- func NewDefaultGenesisReader() (io.Reader, error)
- func ParentError(hash common.Hash) error
- func PutBlockReceipts(db common.Database, block *types.Block, receipts types.Receipts) error
- func PutReceipts(db common.Database, receipts types.Receipts) error
- func PutTransactions(db common.Database, block *types.Block, txs types.Transactions)
- func ReportBlock(block *types.Block, err error)
- func UncleError(format string, v ...interface{}) error
- func ValidateHeader(pow pow.PoW, block *types.Header, parent *types.Block, checkPow, uncle bool) error
- func WriteBlock(db common.Database, block *types.Block) error
- func WriteCanonNumber(db common.Database, block *types.Block) error
- func WriteGenesisBlock(chainDb common.Database, reader io.Reader) (*types.Block, error)
- func WriteGenesisBlockForTesting(db common.Database, addr common.Address, balance *big.Int) *types.Block
- func WriteHead(db common.Database, block *types.Block) error
- func WriteTestNetGenesisBlock(chainDb common.Database, nonce uint64) (*types.Block, error)
- type AccountChange
- type Backend
- type BlockCache
- type BlockGen
- type BlockNonceErr
- type BlockProcessor
- func (self *BlockProcessor) ApplyTransaction(gp GasPool, statedb *state.StateDB, header *types.Header, ...) (*types.Receipt, *big.Int, error)
- func (self *BlockProcessor) ApplyTransactions(gp GasPool, statedb *state.StateDB, block *types.Block, txs types.Transactions, ...) (types.Receipts, error)
- func (self *BlockProcessor) ChainManager() *ChainManager
- func (sm *BlockProcessor) GetBlockReceipts(bhash common.Hash) types.Receipts
- func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err error)
- func (sm *BlockProcessor) Process(block *types.Block) (logs state.Logs, receipts types.Receipts, err error)
- func (sm *BlockProcessor) RetryProcess(block *types.Block) (logs state.Logs, err error)
- func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block *types.Block, transientProcess bool) (receipts types.Receipts, err error)
- func (sm *BlockProcessor) VerifyUncles(statedb *state.StateDB, block, parent *types.Block) error
- type ChainEvent
- type ChainHeadEvent
- type ChainManager
- func (self *ChainManager) CurrentBlock() *types.Block
- func (self *ChainManager) Export(w io.Writer) error
- func (self *ChainManager) ExportN(w io.Writer, first uint64, last uint64) error
- func (self *ChainManager) GasLimit() *big.Int
- func (bc *ChainManager) Genesis() *types.Block
- func (self *ChainManager) GetBlock(hash common.Hash) *types.Block
- func (self *ChainManager) GetBlockByNumber(num uint64) *types.Block
- func (self *ChainManager) GetBlockHashesFromHash(hash common.Hash, max uint64) (chain []common.Hash)
- func (self *ChainManager) GetBlocksFromHash(hash common.Hash, n int) (blocks []*types.Block)
- func (self *ChainManager) GetUnclesInChain(block *types.Block, length int) (uncles []*types.Header)
- func (bc *ChainManager) HasBlock(hash common.Hash) bool
- func (self *ChainManager) InsertChain(chain types.Blocks) (int, error)
- func (self *ChainManager) LastBlockHash() common.Hash
- func (bc *ChainManager) Reset()
- func (bc *ChainManager) ResetWithGenesisBlock(gb *types.Block)
- func (bc *ChainManager) SetHead(head *types.Block)
- func (self *ChainManager) SetProcessor(proc types.BlockProcessor)
- func (self *ChainManager) State() *state.StateDB
- func (self *ChainManager) Status() (td *big.Int, currentBlock common.Hash, genesisBlock common.Hash)
- func (bc *ChainManager) Stop()
- func (self *ChainManager) Td() *big.Int
- func (self *ChainManager) WriteBlock(block *types.Block, queued bool) (status writeStatus, err error)
- type ChainSideEvent
- type ChainSplitEvent
- type ChainUncleEvent
- type Execution
- type FakePow
- type Filter
- func (self *Filter) FilterLogs(logs state.Logs) state.Logs
- func (self *Filter) Find() state.Logs
- func (self *Filter) SetAddress(addr []common.Address)
- func (self *Filter) SetEarliestBlock(earliest int64)
- func (self *Filter) SetLatestBlock(latest int64)
- func (self *Filter) SetMax(max int)
- func (self *Filter) SetSkip(skip int)
- func (self *Filter) SetTopics(topics [][]common.Hash)
- type GasPool
- type GasPriceChanged
- type InvalidTxErr
- type KnownBlockError
- type Message
- type NewBlockEvent
- type NewMinedBlockEvent
- type NonceErr
- type ParentErr
- type PendingBlockEvent
- type StartMining
- type StateTransition
- type TDError
- type TopMining
- type TxPool
- func (self *TxPool) Add(tx *types.Transaction) (err error)
- func (self *TxPool) AddTransactions(txs []*types.Transaction)
- func (self *TxPool) GetQueuedTransactions() types.Transactions
- func (tp *TxPool) GetTransaction(hash common.Hash) *types.Transaction
- func (self *TxPool) GetTransactions() (txs types.Transactions)
- func (self *TxPool) RemoveTransactions(txs types.Transactions)
- func (pool *TxPool) RemoveTx(hash common.Hash)
- func (pool *TxPool) State() *state.ManagedState
- func (pool *TxPool) Stats() (pending int, queued int)
- func (pool *TxPool) Stop()
- type TxPostEvent
- type TxPreEvent
- type UncleErr
- type VMEnv
- func (self *VMEnv) AddLog(log *state.Log)
- func (self *VMEnv) AddStructLog(log vm.StructLog)
- func (self *VMEnv) BlockNumber() *big.Int
- func (self *VMEnv) Call(me vm.ContextRef, addr common.Address, data []byte, gas, price, value *big.Int) ([]byte, error)
- func (self *VMEnv) CallCode(me vm.ContextRef, addr common.Address, data []byte, gas, price, value *big.Int) ([]byte, error)
- func (self *VMEnv) CanTransfer(from vm.Account, balance *big.Int) bool
- func (self *VMEnv) Coinbase() common.Address
- func (self *VMEnv) Create(me vm.ContextRef, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ContextRef)
- func (self *VMEnv) Depth() int
- func (self *VMEnv) Difficulty() *big.Int
- func (self *VMEnv) GasLimit() *big.Int
- func (self *VMEnv) GetHash(n uint64) common.Hash
- func (self *VMEnv) Origin() common.Address
- func (self *VMEnv) SetDepth(i int)
- func (self *VMEnv) SetVmType(t vm.Type)
- func (self *VMEnv) State() *state.StateDB
- func (self *VMEnv) StructLogs() []vm.StructLog
- func (self *VMEnv) Time() *big.Int
- func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error
- func (self *VMEnv) Value() *big.Int
- func (self *VMEnv) VmType() vm.Type
- type ValidationErr
- type ValueTransferError
Examples ¶
Constants ¶
const ( NonStatTy writeStatus = iota CanonStatTy SplitStatTy SideStatTy )
const ( // must be bumped when consensus algorithm is changed, this forces the upgradedb // command to be run (forces the blocks to be imported again using the new algorithm) BlockChainVersion = 3 )
Variables ¶
var ( BlockNumberErr = errors.New("block number invalid") BlockFutureErr = errors.New("block time is in the future") BlockTSTooBigErr = errors.New("block time too big") BlockEqualTSErr = errors.New("block time stamp equal to previous") )
var ( // Transaction Pool Errors ErrInvalidSender = errors.New("Invalid sender") ErrNonce = errors.New("Nonce too low") ErrCheap = errors.New("Gas price too low for acceptance") ErrBalance = errors.New("Insufficient balance") ErrNonExistentAccount = errors.New("Account does not exist or account balance too low") ErrInsufficientFunds = errors.New("Insufficient funds for gas * price + value") ErrIntrinsicGas = errors.New("Intrinsic gas too low") ErrGasLimit = errors.New("Exceeds block gas limit") ErrNegativeValue = errors.New("Negative value") )
var BadHashes = map[common.Hash]bool{ common.HexToHash("05bef30ef572270f654746da22639a7a0c97dd97a7050b9e252391996aaeb689"): true, }
Set of manually tracked bad hashes (usually hard forks)
var BlockReward *big.Int = big.NewInt(5e+18)
var DisableBadBlockReporting = true
DisabledBadBlockReporting can be set to prevent blocks being reported.
var (
ErrNoGenesis = errors.New("Genesis not found in chain")
)
var (
ExpDiffPeriod = big.NewInt(100000)
)
Functions ¶
func AccumulateRewards ¶
AccumulateRewards credits the coinbase of the given block with the mining reward. The total reward consists of the static block reward and rewards for included uncles. The coinbase of each uncle block is also rewarded.
func ApplyMessage ¶
func CalcDifficulty ¶
CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty that a new block b should have when created at time given the parent block's time and difficulty.
func CalcGasLimit ¶
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 Canary ¶
Canary will check the 0'd address of the 4 contracts above. If two or more are set to anything other than a 0 the canary dies a horrible death.
func Disassemble ¶
func GenerateChain ¶
func GenerateChain(parent *types.Block, db common.Database, n int, gen func(int, *BlockGen)) []*types.Block
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 ChainManager requires use of FakePow or a similar non-validating proof of work implementation.
Example ¶
params.MinGasLimit = big.NewInt(125000) // Minimum the gas limit may ever be. params.GenesisGasLimit = big.NewInt(3141592) // Gas limit of the Genesis block. var ( key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") key2, _ = crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a") key3, _ = crypto.HexToECDSA("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee") addr1 = crypto.PubkeyToAddress(key1.PublicKey) addr2 = crypto.PubkeyToAddress(key2.PublicKey) addr3 = crypto.PubkeyToAddress(key3.PublicKey) db, _ = ethdb.NewMemDatabase() ) // Ensure that key1 has some funds in the genesis block. genesis := WriteGenesisBlockForTesting(db, addr1, big.NewInt(1000000)) // This call generates a chain of 5 blocks. The function runs for // each block and adds different features to gen based on the // block index. chain := GenerateChain(genesis, db, 5, func(i int, gen *BlockGen) { switch i { case 0: // In block 1, addr1 sends addr2 some ether. tx, _ := types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(10000), params.TxGas, nil, nil).SignECDSA(key1) gen.AddTx(tx) case 1: // In block 2, addr1 sends some more ether to addr2. // addr2 passes it on to addr3. tx1, _ := types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(key1) tx2, _ := types.NewTransaction(gen.TxNonce(addr2), addr3, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(key2) gen.AddTx(tx1) gen.AddTx(tx2) case 2: // Block 3 is empty but was mined by addr3. gen.SetCoinbase(addr3) gen.SetExtra([]byte("yeehaw")) case 3: // Block 4 includes blocks 2 and 3 as uncle headers (with modified extra data). b2 := gen.PrevBlock(1).Header() b2.Extra = []byte("foo") gen.AddUncle(b2) b3 := gen.PrevBlock(2).Header() b3.Extra = []byte("foo") gen.AddUncle(b3) } }) // Import the chain. This runs all block validation rules. evmux := &event.TypeMux{} chainman, _ := NewChainManager(db, FakePow{}, evmux) chainman.SetProcessor(NewBlockProcessor(db, FakePow{}, chainman, evmux)) if i, err := chainman.InsertChain(chain); err != nil { fmt.Printf("insert error (block %d): %v\n", i, err) return } state := chainman.State() fmt.Printf("last block: #%d\n", chainman.CurrentBlock().Number()) fmt.Println("balance of addr1:", state.GetBalance(addr1)) fmt.Println("balance of addr2:", state.GetBalance(addr2)) fmt.Println("balance of addr3:", state.GetBalance(addr3))
Output: last block: #5 balance of addr1: 989000 balance of addr2: 10000 balance of addr3: 19687500000000001000
func GenesisBlockForTesting ¶
GenesisBlockForTesting creates a block in which addr has the given wei balance. The state trie of the block is written to db.
func GetBlockByHash ¶
GetBlockByHash returns the block corresponding to the hash or nil if not found
func GetBlockByNumber ¶
GetBlockByHash returns the canonical block by number or nil if not found
func GetBlockReceipts ¶ added in v0.9.39
GetBlockReceipts returns the receipts generated by the transactions included in block's given hash.
func GetReceipt ¶
GetReceipt returns a receipt by hash
func IntrinsicGas ¶
IntrinsicGas computes the 'intrisic gas' for a message with the given data.
func IsBlockNonceErr ¶
IsBlockNonceErr returns true for invalid block nonce errors.
func IsInvalidTxErr ¶
func IsKnownBlockErr ¶
func IsNonceErr ¶
func IsParentErr ¶
func IsUncleErr ¶
func IsValidationErr ¶
func IsValueTransferErr ¶
func MessageCreatesContract ¶
func NewDefaultGenesisReader ¶ added in v1.0.1
func ParentError ¶
func PutBlockReceipts ¶ added in v0.9.39
PutBlockReceipts stores the block's transactions associated receipts and stores them by block hash in a single slice. This is required for forks and chain reorgs
func PutReceipts ¶
PutReceipts stores the receipts in the current database
func PutTransactions ¶
PutTransactions stores the transactions in the given database
func ReportBlock ¶
ReportBlock reports the block to the block reporting tool found at badblocks.ethdev.com
func UncleError ¶
func ValidateHeader ¶
func ValidateHeader(pow pow.PoW, block *types.Header, parent *types.Block, checkPow, uncle bool) error
See YP section 4.3.4. "Block Header Validity" Validates a block. Returns an error if the block is invalid.
func WriteBlock ¶ added in v0.9.39
WriteBlock writes a block to the database
func WriteCanonNumber ¶ added in v1.0.0
WriteCanonNumber writes the canonical hash for the given block
func WriteGenesisBlock ¶ added in v0.9.39
WriteGenesisBlock writes the genesis block to the database as block number 0
func WriteGenesisBlockForTesting ¶ added in v0.9.39
Types ¶
type AccountChange ¶
type AccountChange struct {
Address, StateAddress []byte
}
type Backend ¶
type Backend interface { AccountManager() *accounts.Manager BlockProcessor() *BlockProcessor ChainManager() *ChainManager TxPool() *TxPool ChainDb() common.Database DappDb() common.Database EventMux() *event.TypeMux }
TODO move this to types?
type BlockCache ¶
type BlockCache struct {
// contains filtered or unexported fields
}
BlockCache implements a caching mechanism specifically for blocks and uses FILO to pop
func NewBlockCache ¶
func NewBlockCache(size int) *BlockCache
Creates and returns a `BlockCache` with `size`. If `size` is smaller than 1 it will panic
func (*BlockCache) Clear ¶
func (bc *BlockCache) Clear()
func (*BlockCache) Delete ¶
func (bc *BlockCache) Delete(hash common.Hash)
func (*BlockCache) Push ¶
func (bc *BlockCache) Push(block *types.Block)
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) PrevBlock ¶
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 ¶
SetCoinbase sets the coinbase of the generated block. It can be called at most once.
type BlockNonceErr ¶
BlockNonceErr indicates that a block's nonce is invalid.
func (*BlockNonceErr) Error ¶
func (err *BlockNonceErr) Error() string
type BlockProcessor ¶
type BlockProcessor struct { // Proof of work used for validating Pow pow.PoW // contains filtered or unexported fields }
func NewBlockProcessor ¶
func NewBlockProcessor(db common.Database, pow pow.PoW, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor
func (*BlockProcessor) ApplyTransaction ¶
func (*BlockProcessor) ApplyTransactions ¶
func (*BlockProcessor) ChainManager ¶
func (self *BlockProcessor) ChainManager() *ChainManager
func (*BlockProcessor) GetBlockReceipts ¶
func (sm *BlockProcessor) GetBlockReceipts(bhash common.Hash) types.Receipts
GetBlockReceipts returns the receipts beloniging to the block hash
func (*BlockProcessor) GetLogs ¶
GetLogs returns the logs of the given block. This method is using a two step approach where it tries to get it from the (updated) method which gets them from the receipts or the depricated way by re-processing the block.
func (*BlockProcessor) Process ¶
func (sm *BlockProcessor) Process(block *types.Block) (logs state.Logs, receipts types.Receipts, err error)
Process block will attempt to process the given block's transactions and applies them on top of the block's parent state (given it exists) and will return wether it was successful or not.
func (*BlockProcessor) RetryProcess ¶
func (*BlockProcessor) TransitionState ¶
func (*BlockProcessor) VerifyUncles ¶
type ChainHeadEvent ¶
type ChainManager ¶
type ChainManager struct {
// contains filtered or unexported fields
}
func NewChainManager ¶
func (*ChainManager) CurrentBlock ¶
func (self *ChainManager) CurrentBlock() *types.Block
func (*ChainManager) Export ¶
func (self *ChainManager) Export(w io.Writer) error
Export writes the active chain to the given writer.
func (*ChainManager) GasLimit ¶
func (self *ChainManager) GasLimit() *big.Int
func (*ChainManager) GetBlockByNumber ¶
func (self *ChainManager) GetBlockByNumber(num uint64) *types.Block
func (*ChainManager) GetBlockHashesFromHash ¶
func (*ChainManager) GetBlocksFromHash ¶
GetBlocksFromHash returns the block corresponding to hash and up to n-1 ancestors.
func (*ChainManager) GetUnclesInChain ¶
func (*ChainManager) HasBlock ¶
func (bc *ChainManager) HasBlock(hash common.Hash) bool
Block fetching methods
func (*ChainManager) InsertChain ¶
func (self *ChainManager) InsertChain(chain types.Blocks) (int, error)
InsertChain will attempt to insert the given chain in to the canonical chain or, otherwise, create a fork. It 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 (*ChainManager) LastBlockHash ¶
func (self *ChainManager) LastBlockHash() common.Hash
func (*ChainManager) Reset ¶
func (bc *ChainManager) Reset()
func (*ChainManager) ResetWithGenesisBlock ¶
func (bc *ChainManager) ResetWithGenesisBlock(gb *types.Block)
func (*ChainManager) SetHead ¶
func (bc *ChainManager) SetHead(head *types.Block)
func (*ChainManager) SetProcessor ¶
func (self *ChainManager) SetProcessor(proc types.BlockProcessor)
func (*ChainManager) State ¶
func (self *ChainManager) State() *state.StateDB
func (*ChainManager) Stop ¶
func (bc *ChainManager) Stop()
func (*ChainManager) Td ¶
func (self *ChainManager) Td() *big.Int
func (*ChainManager) WriteBlock ¶
func (self *ChainManager) WriteBlock(block *types.Block, queued bool) (status writeStatus, err error)
WriteBlock writes the block to the chain (or pending queue)
type ChainSplitEvent ¶
ChainSplit is posted when a new head is detected
type ChainUncleEvent ¶
type Execution ¶
Execution is the execution environment for the given call or create action.
func NewExecution ¶
func NewExecution(env vm.Environment, address *common.Address, input []byte, gas, gasPrice, value *big.Int) *Execution
NewExecution returns a new execution environment that handles all calling and creation logic defined by the YP.
func (*Execution) Create ¶
func (self *Execution) Create(caller vm.ContextRef) (ret []byte, err error, account *state.StateObject)
Create creates a new contract and runs the initialisation procedure of the contract. This returns the returned code for the contract and is stored elsewhere.
type FakePow ¶
type FakePow struct{}
FakePow is a non-validating proof of work implementation. It returns true from Verify for any block.
func (FakePow) GetHashrate ¶
type Filter ¶
type Filter struct { BlockCallback func(*types.Block, state.Logs) TransactionCallback func(*types.Transaction) LogsCallback func(state.Logs) // contains filtered or unexported fields }
Filtering interface
func NewFilter ¶
Create a new filter which uses a bloom filter on blocks to figure out whether a particular block is interesting or not.
func (*Filter) SetAddress ¶
func (*Filter) SetEarliestBlock ¶
Set the earliest and latest block for filtering. -1 = latest block (i.e., the current block) hash = particular hash from-to
func (*Filter) SetLatestBlock ¶
type GasPool ¶ added in v1.0.3
GasPool tracks the amount of gas available during execution of the transactions in a block.
type GasPriceChanged ¶
type InvalidTxErr ¶
type InvalidTxErr struct {
Message string
}
func InvalidTxError ¶
func InvalidTxError(err error) *InvalidTxErr
func (*InvalidTxErr) Error ¶
func (err *InvalidTxErr) Error() string
type KnownBlockError ¶
type KnownBlockError struct {
// contains filtered or unexported fields
}
func (*KnownBlockError) Error ¶
func (self *KnownBlockError) Error() string
type Message ¶
type Message interface { From() (common.Address, error) To() *common.Address GasPrice() *big.Int Gas() *big.Int Value() *big.Int Nonce() uint64 Data() []byte }
Message represents a message sent to a contract.
type NewBlockEvent ¶
NewBlockEvent is posted when a block has been imported.
type NewMinedBlockEvent ¶
NewMinedBlockEvent is posted when a block has been imported.
type NonceErr ¶
func NonceError ¶
type ParentErr ¶
type ParentErr struct {
Message string
}
Parent error. In case a parent is unknown this error will be thrown by the block manager
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 / buy gas of the coinbase (miner) * 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(env vm.Environment, msg Message, gp GasPool) *StateTransition
func (*StateTransition) AddGas ¶
func (self *StateTransition) AddGas(amount *big.Int)
func (*StateTransition) BuyGas ¶
func (self *StateTransition) BuyGas() error
func (*StateTransition) From ¶
func (self *StateTransition) From() (*state.StateObject, error)
func (*StateTransition) To ¶
func (self *StateTransition) To() *state.StateObject
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 (*TxPool) Add ¶
func (self *TxPool) Add(tx *types.Transaction) (err error)
Add queues a single transaction in the pool if it is valid.
func (*TxPool) AddTransactions ¶
func (self *TxPool) AddTransactions(txs []*types.Transaction)
AddTransactions attempts to queue all valid transactions in txs.
func (*TxPool) GetQueuedTransactions ¶
func (self *TxPool) GetQueuedTransactions() types.Transactions
GetQueuedTransactions returns all non-processable transactions.
func (*TxPool) GetTransaction ¶
func (tp *TxPool) GetTransaction(hash common.Hash) *types.Transaction
GetTransaction returns a transaction if it is contained in the pool and nil otherwise.
func (*TxPool) GetTransactions ¶
func (self *TxPool) GetTransactions() (txs types.Transactions)
GetTransactions returns all currently processable transactions. The returned slice may be modified by the caller.
func (*TxPool) RemoveTransactions ¶
func (self *TxPool) RemoveTransactions(txs types.Transactions)
RemoveTransactions removes all given transactions from the pool.
func (*TxPool) RemoveTx ¶ added in v1.0.1
RemoveTx removes the transaction with the given hash from the pool.
func (*TxPool) State ¶
func (pool *TxPool) State() *state.ManagedState
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 VMEnv ¶
type VMEnv struct {
// contains filtered or unexported fields
}
func (*VMEnv) AddStructLog ¶
func (*VMEnv) BlockNumber ¶
func (*VMEnv) CanTransfer ¶ added in v1.1.0
func (*VMEnv) Create ¶
func (self *VMEnv) Create(me vm.ContextRef, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ContextRef)
func (*VMEnv) Difficulty ¶
func (*VMEnv) StructLogs ¶
type ValidationErr ¶
type ValidationErr struct {
Message string
}
Block validation error. If any validation fails, this error will be thrown
func ValidationError ¶
func ValidationError(format string, v ...interface{}) *ValidationErr
func (*ValidationErr) Error ¶
func (err *ValidationErr) Error() string
type ValueTransferError ¶
type ValueTransferError struct {
// contains filtered or unexported fields
}
func ValueTransferErr ¶
func ValueTransferErr(str string, v ...interface{}) *ValueTransferError
func (*ValueTransferError) Error ¶
func (self *ValueTransferError) Error() string
Source Files
¶
Directories
¶
Path | Synopsis |
---|---|
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. |
Package vm implements the Ethereum Virtual Machine.
|
Package vm implements the Ethereum Virtual Machine. |