core

Jul 4, 2021

Changes in this version

+ var ErrAlreadyKnown = errors.New("already known")

+ var ErrGasUintOverflow = errors.New("gas uint64 overflow")

+ var ErrInsufficientFundsForTransfer = errors.New("insufficient funds for transfer")

+ var ErrTxPoolOverflow = errors.New("txpool is full")

+ var ErrTxTypeNotSupported = types.ErrTxTypeNotSupported

+ func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common.Address) vm.BlockContext

+ func NewEVMTxContext(msg Message) vm.TxContext

type BlockChain

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

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

+ func (bc *BlockChain) InsertChainWithoutSealVerification(block *types.Block) (int, error)

+ func (bc *BlockChain) SetHeadBeyondRoot(head uint64, root common.Hash) (uint64, error)

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

+ func (bc *BlockChain) Snapshots() *snapshot.Tree

+ func (bc *BlockChain) StopInsert()

+ func (bc *BlockChain) TxLookupLimit() uint64

type BlockGen

+ func (b *BlockGen) GetBalance(addr common.Address) *big.Int

+ type BloomIndexer struct

+ func (b *BloomIndexer) Commit() error

+ func (b *BloomIndexer) Process(ctx context.Context, header *types.Header) error

+ func (b *BloomIndexer) Prune(threshold uint64) error

+ func (b *BloomIndexer) Reset(ctx context.Context, section uint64, lastSectionHead common.Hash) error

type CacheConfig

+ Preimages bool

+ SnapshotLimit int

+ SnapshotWait bool

+ TrieCleanJournal string

+ TrieCleanRejournal time.Duration

type ChainIndexer

+ func NewBloomIndexer(db ethdb.Database, size, confirms uint64) *ChainIndexer

+ func (c *ChainIndexer) Prune(threshold uint64) error

type ChainIndexerBackend

+ Prune func(threshold uint64) error

+ type ExecutionResult struct

+ Err error

+ ReturnData []byte

+ UsedGas uint64

+ func (result *ExecutionResult) Failed() bool

+ func (result *ExecutionResult) Return() []byte

+ func (result *ExecutionResult) Revert() []byte

+ func (result *ExecutionResult) Unwrap() error

type Genesis

+ func DefaultRebirthGenesisBlock() *Genesis

+ func DefaultRopstenGenesisBlock() *Genesis

+ func DefaultYoloV3GenesisBlock() *Genesis

type Message

+ AccessList func() types.AccessList

type TxPool

+ func (pool *TxPool) Has(hash common.Hash) bool

Feb 4, 2020

Changes in this version

+ const TriesInMemory

+ var ErrPenaltyInChain = errors.New("penalty in chain")

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

type BlockChain

+ func (bc *BlockChain) GetAncestor(hash common.Hash, number, ancestor uint64, maxNonCanonical *uint64) (common.Hash, uint64)

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

+ func (bc *BlockChain) GetReceiptsByHash(hash common.Hash) types.Receipts

+ func (bc *BlockChain) GetTransactionLookup(hash common.Hash) *rawdb.LegacyTxLookupEntry

+ func (bc *BlockChain) GetVMConfig() *vm.Config

+ func (bc *BlockChain) HasFastBlock(hash common.Hash, number uint64) bool

+ func (bc *BlockChain) HasState(hash common.Hash) bool

+ func (bc *BlockChain) StateCache() state.Database

+ func (bc *BlockChain) SubscribeBlockProcessingEvent(ch chan<- bool) event.Subscription

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

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

type BlockGen

+ func (b *BlockGen) AddTxWithChain(bc *BlockChain, tx *types.Transaction)

+ func (b *BlockGen) AddUncheckedTx(tx *types.Transaction)

+ func (b *BlockGen) SetDifficulty(diff *big.Int)

+ func (b *BlockGen) SetNonce(nonce types.BlockNonce)

+ type CacheConfig struct

+ TrieCleanLimit int

+ TrieCleanNoPrefetch bool

+ TrieDirtyDisabled bool

+ TrieDirtyLimit int

+ TrieTimeLimit time.Duration

type ChainIndexer

+ func (c *ChainIndexer) AddCheckpoint(section uint64, shead common.Hash)

+ func (c *ChainIndexer) SectionHead(section uint64) common.Hash

+ type ChainIndexerChain interface

+ CurrentHeader func() *types.Header

+ SubscribeChainHeadEvent func(ch chan<- ChainHeadEvent) event.Subscription

+ type DeleteBlockContentCallback func(ethdb.KeyValueWriter, common.Hash, uint64)

type GasPool

+ func (gp *GasPool) Gas() uint64

type Genesis

+ func DefaultGoerliGenesisBlock() *Genesis

+ func DeveloperGenesisBlock(period uint64, faucet common.Address) *Genesis

type HeaderChain

+ func (hc *HeaderChain) GetAncestor(hash common.Hash, number, ancestor uint64, maxNonCanonical *uint64) (common.Hash, uint64)

+ func (hc *HeaderChain) GetCanonicalHash(number uint64) common.Hash

+ type NewTxsEvent struct

+ Txs []*types.Transaction

+ type Pair struct

+ Key uint64

+ Value int64

+ type PairList []Pair

+ func (p PairList) Len() int

+ func (p PairList) Less(i, j int) bool

+ func (p PairList) Swap(i, j int)

+ type Prefetcher interface

+ Prefetch func(block *types.Block, statedb *state.StateDB, cfg vm.Config, interrupt *uint32)

type TxPool

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

+ func (pool *TxPool) Locals() []common.Address

+ func (pool *TxPool) Nonce(addr common.Address) uint64

+ func (pool *TxPool) Status(hashes []common.Hash) []TxStatus

+ func (pool *TxPool) SubscribeNewTxsEvent(ch chan<- NewTxsEvent) event.Subscription

type TxPoolConfig

+ Locals []common.Address

+ type TxStatus uint

+ const TxStatusIncluded

+ const TxStatusPending

+ const TxStatusQueued

+ const TxStatusUnknown

+ type UpdateHeadBlocksCallback func(ethdb.KeyValueWriter, *types.Header)

Oct 17, 2017

Changes in this version

+ var BloomBitsIndexPrefix = []byte("iB")

+ var ErrNonceTooHigh = errors.New("nonce too high")

+ var ErrNonceTooLow = errors.New("nonce too low")

+ var ErrOversizedData = errors.New("oversized data")

+ func DeleteTxLookupEntry(db DatabaseDeleter, hash common.Hash)

+ func GetBloomBits(db DatabaseReader, bit uint, section uint64, head common.Hash) []byte

+ func GetTxLookupEntry(db DatabaseReader, hash common.Hash) (common.Hash, uint64, uint64)

+ func WriteBloomBits(db ethdb.Putter, bit uint, section uint64, head common.Hash, bits []byte)

+ func WriteTxLookupEntries(db ethdb.Putter, block *types.Block) error

type BlockChain

+ func (bc *BlockChain) PostChainEvents(events []interface{}, logs []*types.Log)

+ func (bc *BlockChain) SubscribeChainEvent(ch chan<- ChainEvent) event.Subscription

+ func (bc *BlockChain) SubscribeChainHeadEvent(ch chan<- ChainHeadEvent) event.Subscription

+ func (bc *BlockChain) SubscribeChainSideEvent(ch chan<- ChainSideEvent) event.Subscription

+ func (bc *BlockChain) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription

+ func (bc *BlockChain) SubscribeRemovedLogsEvent(ch chan<- RemovedLogsEvent) event.Subscription

+ func (bc *BlockChain) WriteBlockAndState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error)

+ type ChainIndexer struct

+ func NewChainIndexer(chainDb, indexDb ethdb.Database, backend ChainIndexerBackend, ...) *ChainIndexer

+ func (c *ChainIndexer) AddChildIndexer(indexer *ChainIndexer)

+ func (c *ChainIndexer) Close() error

+ func (c *ChainIndexer) Sections() (uint64, uint64, common.Hash)

+ func (c *ChainIndexer) Start(currentHeader *types.Header, ...)

+ type ChainIndexerBackend interface

+ Commit func() error

+ Process func(header *types.Header)

+ Reset func(section uint64)

+ type DatabaseDeleter interface

+ Delete func(key []byte) error

+ type DatabaseReader interface

+ Get func(key []byte) (value []byte, err error)

type Genesis

+ GasUsed uint64

+ Number uint64

type GenesisAccount

+ PrivateKey []byte

type GenesisAlloc

+ func (ga *GenesisAlloc) UnmarshalJSON(data []byte) error

type TxPool

+ func (pool *TxPool) AddLocal(tx *types.Transaction) error

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

+ func (pool *TxPool) AddRemote(tx *types.Transaction) error

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

+ func (pool *TxPool) SubscribeTxPreEvent(ch chan<- TxPreEvent) event.Subscription

type TxPoolConfig

+ Journal string

+ NoLocals bool

+ Rejournal time.Duration

Jun 4, 2017

Changes in this version

+ var DefaultTxPoolConfig = TxPoolConfig

+ var ErrBlacklistedHash = errors.New("blacklisted hash")

+ var ErrChainConfigNotFound = errors.New("ChainConfig not found")

+ var ErrGasLimitReached = errors.New("gas limit reached")

+ var ErrKnownBlock = errors.New("block already known")

+ var ErrReplaceUnderpriced = errors.New("replacement transaction underpriced")

+ var ErrUnderpriced = errors.New("transaction underpriced")

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

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

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

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

+ func PreimageTable(db ethdb.Database) ethdb.Database

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

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

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

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

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

+ type BadBlockArgs struct

+ Hash common.Hash

+ Header *types.Header

type BlockChain

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

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

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

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

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

type BlockValidator

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

+ type ChainContext interface

+ Engine func() consensus.Engine

+ GetHeader func(common.Hash, uint64) *types.Header

type Genesis

+ Alloc GenesisAlloc

+ Coinbase common.Address

+ Config *params.ChainConfig

+ Difficulty *big.Int

+ ExtraData []byte

+ GasLimit uint64

+ Mixhash common.Hash

+ Nonce uint64

+ ParentHash common.Hash

+ Timestamp uint64

+ func DefaultRinkebyGenesisBlock() *Genesis

+ func DefaultTestnetGenesisBlock() *Genesis

+ func DevGenesisBlock() *Genesis

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

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

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

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

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

type GenesisAccount

+ Code []byte

+ Nonce uint64

+ Storage map[common.Hash]common.Hash

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

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

+ type GenesisAlloc map[common.Address]GenesisAccount

+ type GenesisMismatchError struct

+ New common.Hash

+ Stored common.Hash

+ func (e *GenesisMismatchError) Error() string

type HeaderChain

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

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

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

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

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

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

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

type Message

+ CheckNonce func() bool

type TxPool

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

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

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

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

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

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

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

+ type TxPoolConfig struct

+ AccountQueue uint64

+ AccountSlots uint64

+ GlobalQueue uint64

+ GlobalSlots uint64

+ Lifetime time.Duration

+ PriceBump uint64

+ PriceLimit uint64

type Validator

+ ValidateBody func(block *types.Block) error

Oct 8, 2016

Changes in this version

+ func ApplyDAOHardFork(statedb *state.StateDB)

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

type BlockChain

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

type ChainConfig

+ DAOForkBlock *big.Int

+ DAOForkSupport bool

type VMEnv

+ func (self *VMEnv) RevertToSnapshot(snapshot int)

+ func (self *VMEnv) SnapshotDatabase() int

May 22, 2016

Changes in this version

+ var ChainConfigNotFoundErr = errors.New("ChainConfig not found")

+ func DefaultGenesisBlock() string

+ func GetBlockChainVersion(db ethdb.Database) int

+ func GetHashFn(ref common.Hash, chain *BlockChain) func(n uint64) common.Hash

+ func OlympicGenesisBlock() string

+ func TestNetGenesisBlock() string

+ func WriteBlockChainVersion(db ethdb.Database, vsn int)

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

+ func WriteDefaultGenesisBlock(chainDb ethdb.Database) (*types.Block, error)

type BlockChain

+ func (self *BlockChain) Config() *ChainConfig

type BlockGen

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

+ type ChainConfig struct

+ HomesteadBlock *big.Int

+ VmConfig vm.Config

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

+ func MakeChainConfig() *ChainConfig

+ func (c *ChainConfig) IsHomestead(num *big.Int) bool

+ type DeleteCallback func(common.Hash)

+ type HeaderChain struct

+ func NewHeaderChain(chainDb ethdb.Database, config *ChainConfig, getValidator getHeaderValidatorFn, ...) (*HeaderChain, error)

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

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

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

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

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

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

+ func (hc *HeaderChain) InsertHeaderChain(chain []*types.Header, checkFreq int, writeHeader WhCallback) (int, error)

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

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

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

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

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

+ type HeaderValidator interface

+ ValidateHeader func(header, parent *types.Header, checkPow bool) error

+ func NewHeaderValidator(config *ChainConfig, chain *HeaderChain, pow pow.PoW) HeaderValidator

+ type PendingLogsEvent struct

+ Logs vm.Logs

+ type PendingStateEvent struct

+ type RemovedLogsEvent struct

+ Logs vm.Logs

type StateTransition

+ func (self *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big.Int, err error)

type TxPool

+ func (pool *TxPool) Content() (map[common.Address]map[uint64][]*types.Transaction, ...)

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

type VMEnv

+ func (self *VMEnv) RuleSet() vm.RuleSet

+ func (self *VMEnv) Vm() vm.Vm

+ type WhCallback func(*types.Header) error

+ type WriteStatus byte

Mar 3, 2016

Changes in this version

+ var Big0 = big.NewInt(0)

+ var BlockTSTooBigErr = errors.New("block time too big")

+ var ExpDiffPeriod = big.NewInt(100000)

+ var MIPMapLevels = []uint64

+ func ApplyTransaction(bc *BlockChain, gp *GasPool, statedb *state.StateDB, header *types.Header, ...) (*types.Receipt, vm.Logs, *big.Int, error)

+ func Call(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, ...) (ret []byte, err error)

+ func CallCode(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, ...) (ret []byte, err error)

+ func Create(env vm.Environment, caller vm.ContractRef, code []byte, ...) (ret []byte, address common.Address, err error)

+ func DelegateCall(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, ...) (ret []byte, err error)

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

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

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

+ func DeleteCanonicalHash(db ethdb.Database, number uint64)

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

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

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

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

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

+ func GetBlockByHashOld(db ethdb.Database, hash common.Hash) *types.Block

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

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

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

+ func GetHeadBlockHash(db ethdb.Database) common.Hash

+ func GetHeadFastBlockHash(db ethdb.Database) common.Hash

+ func GetHeadHeaderHash(db ethdb.Database) common.Hash

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

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

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

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

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

+ func IsBadHashError(err error) bool

+ func Transfer(from, to vm.Account, amount *big.Int)

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

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

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

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

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

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

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

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

+ func WriteOlympicGenesisBlock(chainDb ethdb.Database, nonce uint64) (*types.Block, error)

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

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

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

type Backend

+ BlockChain func() *BlockChain

+ ChainDb func() ethdb.Database

+ DappDb func() ethdb.Database

+ type BadHashError common.Hash

+ func (h BadHashError) Error() string

+ type BlockChain struct

+ func NewBlockChain(chainDb ethdb.Database, pow pow.PoW, mux *event.TypeMux) (*BlockChain, error)

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

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

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

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

+ func (bc *BlockChain) Reset()

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

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

+ func (bc *BlockChain) Stop()

+ func (self *BlockChain) AuxValidator() pow.PoW

+ func (self *BlockChain) CurrentBlock() *types.Block

+ func (self *BlockChain) CurrentFastBlock() *types.Block

+ func (self *BlockChain) CurrentHeader() *types.Header

+ func (self *BlockChain) Export(w io.Writer) error

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

+ func (self *BlockChain) FastSyncCommitHead(hash common.Hash) error

+ func (self *BlockChain) GasLimit() *big.Int

+ func (self *BlockChain) GetBlock(hash common.Hash) *types.Block

+ func (self *BlockChain) GetBlockByNumber(number uint64) *types.Block

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

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

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

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

+ func (self *BlockChain) GetHeader(hash common.Hash) *types.Header

+ func (self *BlockChain) GetHeaderByNumber(number uint64) *types.Header

+ func (self *BlockChain) GetTd(hash common.Hash) *big.Int

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

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

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

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

+ func (self *BlockChain) LastBlockHash() common.Hash

+ func (self *BlockChain) Processor() Processor

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

+ func (self *BlockChain) SetProcessor(processor Processor)

+ func (self *BlockChain) SetValidator(validator Validator)

+ func (self *BlockChain) State() (*state.StateDB, error)

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

+ func (self *BlockChain) Validator() Validator

+ func (self *BlockChain) WriteBlock(block *types.Block) (status writeStatus, err error)

type BlockGen

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

+ func (b *BlockGen) OffsetTime(seconds int64)

+ type BlockValidator struct

+ Pow pow.PoW

+ func NewBlockValidator(blockchain *BlockChain, pow pow.PoW) *BlockValidator

+ func (v *BlockValidator) ValidateBlock(block *types.Block) error

+ func (v *BlockValidator) ValidateHeader(header, parent *types.Header, checkPow bool) error

+ func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, ...) (err error)

+ func (v *BlockValidator) VerifyUncles(block, parent *types.Block) error

type GasLimitErr

+ Have *big.Int

+ Want *big.Int

+ type GasPool big.Int

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

+ func (gp *GasPool) String() string

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

+ type GenesisAccount struct

+ Address common.Address

+ Balance *big.Int

type Message

+ FromFrontier func() (common.Address, error)

+ type Processor interface

+ Process func(block *types.Block, statedb *state.StateDB) (types.Receipts, vm.Logs, *big.Int, error)

+ type RemovedTransactionEvent struct

+ Txs types.Transactions

+ type StateProcessor struct

+ func NewStateProcessor(bc *BlockChain) *StateProcessor

+ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB) (types.Receipts, vm.Logs, *big.Int, error)

type VMEnv

+ func (self *VMEnv) CanTransfer(from common.Address, balance *big.Int) bool

+ func (self *VMEnv) Db() vm.Database

+ func (self *VMEnv) DelegateCall(me vm.ContractRef, addr common.Address, data []byte, gas, price *big.Int) ([]byte, error)

+ func (self *VMEnv) MakeSnapshot() vm.Database

+ func (self *VMEnv) SetSnapshot(copy vm.Database)

+ type Validator interface

+ ValidateBlock func(block *types.Block) error

+ ValidateHeader func(header, parent *types.Header, checkPow bool) error

+ ValidateState func(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, ...) error

Aug 5, 2015

Changes in this version

+ func NewDefaultGenesisReader() (io.Reader, error)

type TxPool

+ func (pool *TxPool) RemoveTx(hash common.Hash)

Jul 29, 2015

Changes in this version

+ func WriteCanonNumber(db common.Database, block *types.Block) error

Jul 25, 2015

Changes in this version

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

+ func GetBlockReceipts(db common.Database, hash common.Hash) types.Receipts

+ func PutBlockReceipts(db common.Database, block *types.Block, receipts types.Receipts) error

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

+ func WriteGenesisBlock(stateDb, blockDb common.Database, reader io.Reader) (*types.Block, error)

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

+ func WriteTestNetGenesisBlock(stateDb, blockDb common.Database, nonce uint64) (*types.Block, error)

Jul 7, 2015

Changes in this version

+ const CanonStatTy

+ const NonStatTy

+ const SideStatTy

+ const SplitStatTy

+ var DisableBadBlockReporting = true

+ func GetBlockByHash(db common.Database, hash common.Hash) *types.Block

+ func GetBlockByNumber(db common.Database, number uint64) *types.Block

+ func GetReceipt(db common.Database, txHash common.Hash) *types.Receipt

+ func GetReceiptsFromBlock(db common.Database, block *types.Block) types.Receipts

+ 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 WriteHead(db common.Database, block *types.Block) error

type Backend

+ ExtraDb func() common.Database

type TxPool

+ func (pool *TxPool) Stats() (pending int, queued int)

Jun 30, 2015

Changes in this version

+ func Canary(statedb *state.StateDB) bool

+ 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

+ type BlockGen struct

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

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

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

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

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

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

type ChainManager

+ func (self *ChainManager) GetBlocksFromHash(hash common.Hash, n int) (blocks []*types.Block)

+ func (self *ChainManager) WriteBlock(block *types.Block) (status writeStatus, err error)

Jun 23, 2015

Changes in this version

+ func ValidateHeader(pow pow.PoW, block, parent *types.Header, checkPow bool) error

Jun 15, 2015

Changes in this version

+ var ErrCheap = errors.New("Gas price too low for acceptance")

type VMEnv

+ func (self *VMEnv) AddStructLog(log vm.StructLog)

+ func (self *VMEnv) StructLogs() []vm.StructLog

Jun 9, 2015

Changes in this version

+ var GenesisAccounts = []byte(...)

+ func IsBlockNonceErr(err error) bool

+ type BlockNonceErr struct

+ Hash common.Hash

+ Nonce uint64

+ Number *big.Int

+ func (err *BlockNonceErr) Error() string

type ChainManager

+ func (self *ChainManager) ExportN(w io.Writer, first uint64, last uint64) error

type TxPool

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

May 28, 2015

Changes in this version

+ var BadHashes = map[common.Hash]bool

May 27, 2015

Changes in this version

+ var ErrNegativeValue = errors.New("Negative value")

May 21, 2015

Changes in this version

type BlockProcessor

+ func (self *BlockProcessor) GetBlockReceipts(bhash common.Hash) (receipts types.Receipts, err error)

May 15, 2015

Changes in this version

+ func CalcTD(block, parent *types.Block) *big.Int

type Backend

+ Downloader func() *downloader.Downloader

type ChainEvent

+ Hash common.Hash

May 12, 2015

Changes in this version

type Backend

+ AccountManager func() *accounts.Manager

+ type GasPriceChanged struct

+ Price *big.Int

May 8, 2015

Changes in this version

+ const BlockChainVersion

+ var BlockEqualTSErr = errors.New("block time stamp equal to previous")

+ var CanonicalSeed = 1

+ var ErrBalance = errors.New("Insufficient balance")

+ var ErrGasLimit = errors.New("Exceeds block gas limit")

+ var ErrInsufficientFunds = errors.New("Insufficient funds for gas * price + value")

+ var ErrIntrinsicGas = errors.New("Intrinsic gas too low")

+ var ErrNonExistentAccount = errors.New("Account does not exist")

+ var ErrNonce = errors.New("Nonce too low")

+ var ForkSeed = 2

+ var GenesisData = []byte(...)

+ func AccumulateRewards(statedb *state.StateDB, block *types.Block)

+ func ApplyMessage(env vm.Environment, msg Message, coinbase *state.StateObject) ([]byte, *big.Int, error)

+ func IntrinsicGas(msg Message) *big.Int

+ func IsInvalidTxErr(err error) bool

+ func IsValueTransferErr(e error) bool

+ func MakeBlock(bman *BlockProcessor, parent *types.Block, i int, db common.Database, seed int) *types.Block

+ func MakeChain(bman *BlockProcessor, parent *types.Block, max int, db common.Database, ...) types.Blocks

+ func NewBlockFromParent(addr common.Address, parent *types.Block) *types.Block

type Backend

+ BlockDb func() common.Database

+ StateDb func() common.Database

+ type BlockCache struct

+ func NewBlockCache(size int) *BlockCache

+ func (bc *BlockCache) Clear()

+ func (bc *BlockCache) Delete(hash common.Hash)

+ func (bc *BlockCache) Each(cb func(int, *types.Block))

+ func (bc *BlockCache) Get(hash common.Hash) *types.Block

+ func (bc *BlockCache) Has(hash common.Hash) bool

+ func (bc *BlockCache) Push(block *types.Block)

type BlockProcessor

+ func NewBlockProc(db common.Database, cman *ChainManager, eventMux *event.TypeMux) *BlockProcessor

+ func NewCanonical(n int, db common.Database) (*BlockProcessor, error)

+ func (self *BlockProcessor) ChainManager() *ChainManager

+ func (sm *BlockProcessor) RetryProcess(block *types.Block) (logs state.Logs, err error)

+ func (sm *BlockProcessor) ValidateHeader(block, parent *types.Header) error

+ func (sm *BlockProcessor) VerifyUncles(statedb *state.StateDB, block, parent *types.Block) error

type ChainEvent

+ Logs state.Logs

+ type ChainHeadEvent struct

+ Block *types.Block

type ChainManager

+ func NewChainMan(block *types.Block, eventMux *event.TypeMux, db common.Database) *ChainManager

+ func (bc *ChainManager) ResetWithGenesisBlock(gb *types.Block)

+ func (bc *ChainManager) SetHead(head *types.Block)

+ func (self *ChainManager) GasLimit() *big.Int

+ func (self *ChainManager) TxState() *state.ManagedState

+ type ChainSideEvent struct

+ Block *types.Block

+ Logs state.Logs

type ChainSplitEvent

+ Logs state.Logs

+ type ChainUncleEvent struct

+ Block *types.Block

+ type FakePow struct

+ func (f FakePow) GetHashrate() int64

+ func (f FakePow) Search(block pow.Block, stop <-chan struct{}) (uint64, []byte)

+ func (f FakePow) Turbo(bool)

+ func (f FakePow) Verify(block pow.Block) bool

type Filter

+ TransactionCallback func(*types.Transaction)

+ type InvalidTxErr struct

+ Message string

+ func InvalidTxError(err error) *InvalidTxErr

+ func (err *InvalidTxErr) Error() string

type PendingBlockEvent

+ Logs state.Logs

+ type StartMining struct

+ type TopMining struct

type TxPool

+ func (self *TxPool) GetQueuedTransactions() types.Transactions

+ func (self *TxPool) RemoveTransactions(txs types.Transactions)

+ func (tp *TxPool) GetTransaction(hash common.Hash) *types.Transaction

+ type ValueTransferError struct

+ func ValueTransferErr(str string, v ...interface{}) *ValueTransferError

+ func (self *ValueTransferError) Error() string

Feb 20, 2015

Changes in this version

+ var BlockFutureErr = errors.New("block time is in the future")

+ var BlockNumberErr = errors.New("block number invalid")

+ var ErrInvalidSender = errors.New("Invalid sender")

+ func CalcGasLimit(parent, block *types.Block) *big.Int

+ func CalculateTD(block, parent *types.Block) *big.Int

+ func GenesisBlock(db ethutil.Database) *types.Block

+ type Backend interface

+ BlockProcessor func() *BlockProcessor

+ ChainManager func() *ChainManager

+ Db func() ethutil.Database

+ EventMux func() *event.TypeMux

+ IsListening func() bool

+ KeyManager func() *crypto.KeyManager

+ PeerCount func() int

+ Peers func() []*p2p.Peer

+ TxPool func() *TxPool

+ type BlockProcessor struct

+ Pow pow.PoW

+ func NewBlockProcessor(db ethutil.Database, txpool *TxPool, chainManager *ChainManager, ...) *BlockProcessor

+ func (self *BlockProcessor) ApplyTransaction(coinbase *state.StateObject, statedb *state.StateDB, block *types.Block, ...) (*types.Receipt, *big.Int, error)

+ func (self *BlockProcessor) ApplyTransactions(coinbase *state.StateObject, statedb *state.StateDB, block *types.Block, ...) (types.Receipts, types.Transactions, types.Transactions, types.Transactions, ...)

+ func (sm *BlockProcessor) AccumulateRewards(statedb *state.StateDB, block, parent *types.Block) error

+ func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err error)

+ func (sm *BlockProcessor) Process(block *types.Block) (td *big.Int, err error)

+ func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block *types.Block) (receipts types.Receipts, err error)

+ func (sm *BlockProcessor) ValidateBlock(block, parent *types.Block) error

+ type ChainEvent struct

+ Block *types.Block

+ Td *big.Int

type ChainManager

+ func (self *ChainManager) GetAccount(addr []byte) *state.StateObject

+ func (self *ChainManager) GetAncestors(block *types.Block, length int) (blocks []*types.Block)

+ func (self *ChainManager) GetBlockHashesFromHash(hash []byte, max uint64) (chain [][]byte)

+ func (self *ChainManager) GetUnclesInChain(block *types.Block, length int) (uncles []*types.Header)

+ func (self *ChainManager) Status() (td *big.Int, currentBlock []byte, genesisBlock []byte)

+ type ChainSplitEvent struct

+ Block *types.Block

type Filter

+ LogsCallback func(state.Logs)

+ PendingCallback func(*types.Block)

+ func (self *Filter) FilterLogs(logs state.Logs) state.Logs

+ func (self *Filter) SetAddress(addr [][]byte)

+ func (self *Filter) SetOptions(options FilterOptions)

+ func (self *Filter) SetTopics(topics [][]byte)

+ type FilterOptions struct

+ Address [][]byte

+ Earliest int64

+ Latest int64

+ Max int

+ Skip int

+ Topics [][]byte

+ type NewMinedBlockEvent struct

+ Block *types.Block

+ type PendingBlockEvent struct

+ Block *types.Block

+ type StateQuery interface

+ GetAccount func(addr []byte) *state.StateObject

type TxPool

+ func (self *TxPool) AddTransactions(txs []*types.Transaction)

+ func (self *TxPool) GetTransactions() (txs types.Transactions)

type VMEnv

+ func (self *VMEnv) GetHash(n uint64) []byte

+ func (self *VMEnv) SetVmType(t vm.Type)

+ func (self *VMEnv) VmType() vm.Type

Dec 21, 2014

Changes in this version

+ var BlockReward *big.Int = big.NewInt(1.5e+18)

+ var EmptyListRoot = crypto.Sha3(ethutil.Encode(""))

+ var EmptyShaList = crypto.Sha3(ethutil.Encode([]interface{}{}))

+ var Found bool

+ var Genesis = []interface

+ var GenesisHeader = []interface

+ var MinGasPrice = big.NewInt(10000000000000)

+ var ZeroHash160 = make([]byte, 20)

+ var ZeroHash256 = make([]byte, 32)

+ var ZeroHash512 = make([]byte, 64)

+ func AddTestNetFunds(block *types.Block)

+ func AddressFromMessage(msg Message) []byte

+ func CalcDifficulty(block, parent *types.Block) *big.Int

+ func DaggerVerify(hash, diff, nonce *big.Int) bool

+ func Disassemble(script []byte) (asm []string)

+ func EachTx(pool *list.List, it func(*types.Transaction, *list.Element) bool)

+ func FindTx(pool *list.List, finder func(*types.Transaction, *list.Element) bool) *types.Transaction

+ func IsGasLimitErr(err error) bool

+ func IsKnownBlockErr(e error) bool

+ func IsNonceErr(err error) bool

+ func IsOutOfGasErr(err error) bool

+ func IsParentErr(err error) bool

+ func IsTDError(e error) bool

+ func IsUncleErr(err error) bool

+ func IsValidationErr(err error) bool

+ func MakeContract(msg Message, state *state.StateDB) *state.StateObject

+ func MessageCreatesContract(msg Message) bool

+ func MessageGasValue(msg Message) *big.Int

+ func ParentError(hash []byte) error

+ func Sum(sha hash.Hash) []byte

+ func UncleError(str string) error

+ type AccountChange struct

+ Address []byte

+ StateAddress []byte

+ type BlockManager struct

+ Pow pow.PoW

+ func NewBlockManager(txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockManager

+ func (self *BlockManager) ApplyTransactions(coinbase *state.StateObject, state *state.StateDB, block *types.Block, ...) (types.Receipts, types.Transactions, types.Transactions, types.Transactions, ...)

+ func (sm *BlockManager) AccumelateRewards(statedb *state.StateDB, block, parent *types.Block) error

+ func (sm *BlockManager) CalculateTD(block *types.Block) (*big.Int, bool)

+ func (sm *BlockManager) GetMessages(block *types.Block) (messages []*state.Message, err error)

+ func (sm *BlockManager) Process(block *types.Block) (td *big.Int, msgs state.Messages, err error)

+ func (sm *BlockManager) ProcessWithParent(block, parent *types.Block) (td *big.Int, messages state.Messages, err error)

+ func (sm *BlockManager) TransitionState(statedb *state.StateDB, parent, block *types.Block) (receipts types.Receipts, err error)

+ func (sm *BlockManager) ValidateBlock(block, parent *types.Block) error

+ type ChainManager struct

+ func NewChainManager(mux *event.TypeMux) *ChainManager

+ func (bc *ChainManager) BlockInfo(block *types.Block) types.BlockInfo

+ func (bc *ChainManager) Genesis() *types.Block

+ func (bc *ChainManager) HasBlock(hash []byte) bool

+ func (bc *ChainManager) NewBlock(coinbase []byte) *types.Block

+ func (bc *ChainManager) Reset()

+ func (bc *ChainManager) Stop()

+ func (self *ChainManager) CalcTotalDiff(block *types.Block) (*big.Int, error)

+ func (self *ChainManager) CurrentBlock() *types.Block

+ func (self *ChainManager) Export() []byte

+ func (self *ChainManager) GetBlock(hash []byte) *types.Block

+ func (self *ChainManager) GetBlockByNumber(num uint64) *types.Block

+ func (self *ChainManager) GetChainHashesFromHash(hash []byte, max uint64) (chain [][]byte)

+ func (self *ChainManager) InsertChain(chain types.Blocks) error

+ func (self *ChainManager) LastBlockHash() []byte

+ func (self *ChainManager) LastBlockNumber() uint64

+ func (self *ChainManager) SetProcessor(proc types.BlockProcessor)

+ func (self *ChainManager) State() *state.StateDB

+ func (self *ChainManager) Td() *big.Int

+ func (self *ChainManager) TransState() *state.StateDB

+ type Dagger struct

+ func (dag *Dagger) Eval(N *big.Int) *big.Int

+ func (dag *Dagger) Find(obj *big.Int, resChan chan int64)

+ func (dag *Dagger) Node(L uint64, i uint64) *big.Int

+ func (dag *Dagger) Search(hash, diff *big.Int) *big.Int

+ func (dag *Dagger) Verify(hash, diff, nonce *big.Int) bool

+ type EthManager interface

+ BlockManager func() *BlockManager

+ Broadcast func(msgType wire.MsgType, data []interface{})

+ ChainManager func() *ChainManager

+ ClientIdentity func() wire.ClientIdentity

+ Db func() ethutil.Database

+ EventMux func() *event.TypeMux

+ IsListening func() bool

+ IsMining func() bool

+ KeyManager func() *crypto.KeyManager

+ PeerCount func() int

+ Peers func() *list.List

+ TxPool func() *TxPool

+ type Execution struct

+ Gas *big.Int

+ SkipTransfer bool

+ func NewExecution(env vm.Environment, address, input []byte, gas, gasPrice, value *big.Int) *Execution

+ func (self *Execution) Addr() []byte

+ func (self *Execution) Call(codeAddr []byte, caller vm.ClosureRef) ([]byte, error)

+ func (self *Execution) Create(caller vm.ClosureRef) (ret []byte, err error, account *state.StateObject)

+ type Filter struct

+ Altered []AccountChange

+ BlockCallback func(*types.Block)

+ MessageCallback func(state.Messages)

+ func NewFilter(eth EthManager) *Filter

+ func (self *Filter) AddAltered(address, stateAddress []byte)

+ func (self *Filter) AddFrom(addr []byte)

+ func (self *Filter) AddTo(addr []byte)

+ func (self *Filter) FilterMessages(msgs []*state.Message) []*state.Message

+ func (self *Filter) Find() []*state.Message

+ func (self *Filter) SetEarliestBlock(earliest int64)

+ func (self *Filter) SetFrom(addr [][]byte)

+ func (self *Filter) SetLatestBlock(latest int64)

+ func (self *Filter) SetMax(max int)

+ func (self *Filter) SetSkip(skip int)

+ func (self *Filter) SetTo(addr [][]byte)

+ type GasLimitErr struct

+ Is *big.Int

+ Max *big.Int

+ Message string

+ func GasLimitError(is, max *big.Int) *GasLimitErr

+ func (err *GasLimitErr) Error() string

+ type KnownBlockError struct

+ func (self *KnownBlockError) Error() string

+ type Message interface

+ Data func() []byte

+ From func() []byte

+ Gas func() *big.Int

+ GasPrice func() *big.Int

+ Hash func() []byte

+ Nonce func() uint64

+ To func() []byte

+ Value func() *big.Int

+ type NewBlockEvent struct

+ Block *types.Block

+ type NonceErr struct

+ Exp uint64

+ Is uint64

+ Message string

+ func NonceError(is, exp uint64) *NonceErr

+ func (err *NonceErr) Error() string

+ type OutOfGasErr struct

+ Message string

+ func OutOfGasError() *OutOfGasErr

+ func (self *OutOfGasErr) Error() string

+ type ParentErr struct

+ Message string

+ func (err *ParentErr) Error() string

+ type Peer interface

+ Caps func() *ethutil.Value

+ Connected func() *int32

+ Host func() []byte

+ Inbound func() bool

+ LastPong func() int64

+ LastSend func() time.Time

+ PingTime func() string

+ Port func() uint16

+ Version func() string

+ type StateTransition struct

+ Env vm.Environment

+ func NewStateTransition(coinbase *state.StateObject, msg Message, state *state.StateDB, ...) *StateTransition

+ func (self *StateTransition) AddGas(amount *big.Int)

+ func (self *StateTransition) BuyGas() error

+ func (self *StateTransition) Coinbase() *state.StateObject

+ func (self *StateTransition) From() *state.StateObject

+ func (self *StateTransition) GasUsed() *big.Int

+ func (self *StateTransition) RefundGas()

+ func (self *StateTransition) To() *state.StateObject

+ func (self *StateTransition) TransitionState() (ret []byte, err error)

+ func (self *StateTransition) UseGas(amount *big.Int) error

+ func (self *StateTransition) VmEnv() vm.Environment

+ type TDError struct

+ func (self *TDError) Error() string

+ type TxMsg struct

+ Tx *types.Transaction

+ Type TxMsgTy

+ type TxMsgTy byte

+ type TxPool struct

+ SecondaryProcessor TxProcessor

+ func NewTxPool(chainManager *ChainManager, broadcaster types.Broadcaster, ...) *TxPool

+ func (pool *TxPool) CurrentTransactions() []*types.Transaction

+ func (pool *TxPool) Flush() []*types.Transaction

+ func (pool *TxPool) RemoveInvalid(state *state.StateDB)

+ func (pool *TxPool) Start()

+ func (pool *TxPool) Stop()

+ func (pool *TxPool) ValidateTransaction(tx *types.Transaction) error

+ func (self *TxPool) Add(tx *types.Transaction) error

+ func (self *TxPool) RemoveSet(txs types.Transactions)

+ func (self *TxPool) Size() int

+ type TxPoolHook chan *types.Transaction

+ type TxPostEvent struct

+ Tx *types.Transaction

+ type TxPreEvent struct

+ Tx *types.Transaction

+ type TxProcessor interface

+ ProcessTransaction func(tx *types.Transaction)

+ type UncleErr struct

+ Message string

+ func (err *UncleErr) Error() string

+ type VMEnv struct

+ func NewEnv(state *state.StateDB, msg Message, block *types.Block) *VMEnv

+ func (self *VMEnv) AddLog(log state.Log)

+ func (self *VMEnv) BlockHash() []byte

+ func (self *VMEnv) BlockNumber() *big.Int

+ func (self *VMEnv) Call(me vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error)

+ func (self *VMEnv) CallCode(me vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error)

+ func (self *VMEnv) Coinbase() []byte

+ func (self *VMEnv) Create(me vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ClosureRef)

+ func (self *VMEnv) Depth() int

+ func (self *VMEnv) Difficulty() *big.Int

+ func (self *VMEnv) GasLimit() *big.Int

+ func (self *VMEnv) Origin() []byte

+ func (self *VMEnv) PrevHash() []byte

+ func (self *VMEnv) SetDepth(i int)

+ func (self *VMEnv) State() *state.StateDB

+ func (self *VMEnv) Time() int64

+ func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error

+ func (self *VMEnv) Value() *big.Int

+ type ValidationErr struct

+ Message string

+ func ValidationError(format string, v ...interface{}) *ValidationErr

+ func (err *ValidationErr) Error() string