execution

package
v0.21.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 21, 2018 License: Apache-2.0 Imports: 29 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	BlockingTimeout     = 10 * time.Second
	SubscribeBufferSize = 10
)

Variables

This section is empty.

Functions

func CallCodeSim added in v0.20.0 

func CallCodeSim(reader state.Reader, tip bcm.BlockchainInfo, fromAddress, address crypto.Address, code, data []byte,
	logger *logging.Logger) (*exec.TxExecution, error)

Run the given code on an isolated and unpersisted state Cannot be used to create new contracts.

func CallSim added in v0.20.0 

func CallSim(reader state.Reader, tip bcm.BlockchainInfo, fromAddress, address crypto.Address, data []byte,
	logger *logging.Logger) (*exec.TxExecution, error)

Run a contract's code on an isolated and unpersisted state Cannot be used to create new contracts

func VMOptions 

func VMOptions(vmOptions ...func(*evm.VM)) func(*executor)

Types

type Accounts 

type Accounts struct {
	burrow_sync.RingMutex
	state.Reader
	// contains filtered or unexported fields
}

Accounts pairs an underlying state.Reader with a KeyClient to provide a signing variant of an account it also maintains a lock over addresses to provide a linearisation of signing events using SequentialSigningAccount

func NewAccounts 

func NewAccounts(reader state.Reader, keyClient keys.KeyClient, mutexCount int) *Accounts

func (*Accounts) SequentialSigningAccount 

func (accs *Accounts) SequentialSigningAccount(address crypto.Address) (*SequentialSigningAccount, error)

func (*Accounts) SigningAccount 

func (accs *Accounts) SigningAccount(address crypto.Address) (*SigningAccount, error)

type BatchCommitter 

type BatchCommitter interface {
	BatchExecutor
	// Commit execution results to underlying State and provide opportunity
	// to mutate state before it is saved
	Commit(blockHash []byte, blockTime time.Time, header *abciTypes.Header) (stateHash []byte, err error)
}

Executes transactions

func NewBatchCommitter 

func NewBatchCommitter(backend ExecutorState, blockchain *bcm.Blockchain, emitter event.Publisher,
	keyClient keys.KeyClient, logger *logging.Logger, options ...ExecutionOption) BatchCommitter

type BatchExecutor 

type BatchExecutor interface {
	// Provides access to write lock for a BatchExecutor so reads can be prevented for the duration of a commit
	sync.Locker
	state.Reader
	// Execute transaction against block cache (i.e. block buffer)
	Executor
	// Reset executor to underlying State
	Reset() error
}

func NewBatchChecker 

func NewBatchChecker(backend ExecutorState, blockchain *bcm.Blockchain, keyClient keys.KeyClient, logger *logging.Logger,
	options ...ExecutionOption) BatchExecutor

Wraps a cache of what is variously known as the 'check cache' and 'mempool'

type Context added in v0.20.0 

type Context interface {
	Execute(txe *exec.TxExecution) error
}

type ExecutionConfig 

type ExecutionConfig struct {
	VMOptions []VMOption `json:",omitempty" toml:",omitempty"`
}

func DefaultExecutionConfig 

func DefaultExecutionConfig() *ExecutionConfig

func (*ExecutionConfig) ExecutionOptions 

func (ec *ExecutionConfig) ExecutionOptions() ([]ExecutionOption, error)

type ExecutionOption 

type ExecutionOption func(*executor)

type Executor added in v0.19.0 

type Executor interface {
	Execute(txEnv *txs.Envelope) (*exec.TxExecution, error)
}

type ExecutorState added in v0.19.0 

type ExecutorState interface {
	Update(updater func(ws Updatable) error) (hash []byte, err error)
	names.Reader
	state.IterableReader
}

type SequentialSigningAccount 

type SequentialSigningAccount struct {
	Address crypto.Address
	// contains filtered or unexported fields
}

func (*SequentialSigningAccount) Lock 

func (ssa *SequentialSigningAccount) Lock() (*SigningAccount, UnlockFunc, error)

type SigningAccount 

type SigningAccount struct {
	acm.Account
	crypto.Signer
}

type State 

type State struct {
	// Values not reassigned
	sync.RWMutex
	// contains filtered or unexported fields
}

Writers to state are responsible for calling State.Lock() before calling

func LoadState 

func LoadState(db dbm.DB, hash []byte) (*State, error)

Tries to load the execution state from DB, returns nil with no error if no state found

func MakeGenesisState 

func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error)

Make genesis state from GenesisDoc and save to DB

func NewState 

func NewState(db dbm.DB) *State

Create a new State object

func (*State) Copy 

func (s *State) Copy(db dbm.DB) (*State, error)

Creates a copy of the database to the supplied db

func (*State) GetAccount 

func (s *State) GetAccount(address crypto.Address) (acm.Account, error)

Returns nil if account does not exist with given address.

func (*State) GetBlock added in v0.20.0 

func (s *State) GetBlock(height uint64) (*exec.BlockExecution, error)

func (*State) GetBlocks added in v0.20.0 

func (s *State) GetBlocks(startHeight, endHeight uint64, consumer func(*exec.BlockExecution) (stop bool)) (stopped bool, err error)

func (*State) GetName added in v0.20.0 

func (s *State) GetName(name string) (*names.Entry, error)

func (*State) GetStorage 

func (s *State) GetStorage(address crypto.Address, key binary.Word256) (binary.Word256, error)

func (*State) GetTx added in v0.20.0 

func (s *State) GetTx(txHash []byte) (*exec.TxExecution, error)

func (*State) Hash 

func (s *State) Hash() []byte

func (*State) IterateAccounts 

func (s *State) IterateAccounts(consumer func(acm.Account) (stop bool)) (stopped bool, err error)

func (*State) IterateNames added in v0.20.0 

func (s *State) IterateNames(consumer func(*names.Entry) (stop bool)) (stopped bool, err error)

func (*State) IterateStorage 

func (s *State) IterateStorage(address crypto.Address,
	consumer func(key, value binary.Word256) (stop bool)) (stopped bool, err error)

func (*State) Update added in v0.19.0 

func (s *State) Update(updater func(up Updatable) error) ([]byte, error)

Perform updates to state whilst holding the write lock, allows a commit to hold the write lock across multiple operations while preventing interlaced reads and writes

type Transactor 

type Transactor struct {
	Tip             bcm.BlockchainInfo
	Subscribable    event.Subscribable
	MempoolAccounts *Accounts
	// contains filtered or unexported fields
}

Transactor is responsible for helping to formulate, sign, and broadcast transactions to tendermint

The BroadcastTx* methods are able to work against the mempool Accounts (pending) state rather than the committed (final) Accounts state and can assign a sequence number based on all of the txs seen since the last block - provided these transactions are successfully committed (via DeliverTx) then subsequent transactions will have valid sequence numbers. This allows Burrow to coordinate sequencing and signing for a key it holds or is provided - it is down to the key-holder to manage the mutual information between transactions concurrent within a new block window.

func NewTransactor 

func NewTransactor(tip bcm.BlockchainInfo, subscribable event.Subscribable, mempoolAccounts *Accounts,
	checkTxAsync func(tx tmTypes.Tx, cb func(*abciTypes.Response)) error, txEncoder txs.Encoder,
	logger *logging.Logger) *Transactor

func (*Transactor) BroadcastTxAsync 

func (trans *Transactor) BroadcastTxAsync(txEnv *txs.Envelope) (*txs.Receipt, error)

Broadcast a transaction without waiting for confirmation - will attempt to sign server-side and set sequence numbers if no signatures are provided

func (*Transactor) BroadcastTxSync added in v0.20.0 

func (trans *Transactor) BroadcastTxSync(ctx context.Context, txEnv *txs.Envelope) (*exec.TxExecution, error)

func (*Transactor) CallCodeSim added in v0.20.0 

func (trans *Transactor) CallCodeSim(fromAddress crypto.Address, code, data []byte) (*exec.TxExecution, error)

func (*Transactor) CallSim added in v0.20.0 

func (trans *Transactor) CallSim(fromAddress, address crypto.Address, data []byte) (*exec.TxExecution, error)

func (*Transactor) CheckTxAsync added in v0.20.0 

func (trans *Transactor) CheckTxAsync(txEnv *txs.Envelope, callback func(res *abciTypes.Response)) error

func (*Transactor) CheckTxAsyncRaw added in v0.20.0 

func (trans *Transactor) CheckTxAsyncRaw(txBytes []byte, callback func(res *abciTypes.Response)) error

func (*Transactor) CheckTxSync added in v0.20.0 

func (trans *Transactor) CheckTxSync(txEnv *txs.Envelope) (*txs.Receipt, error)

Broadcast a transaction and waits for a response from the mempool. Transactions to BroadcastTx will block during various mempool operations (managed by Tendermint) including mempool Reap, Commit, and recheckTx.

func (*Transactor) CheckTxSyncRaw added in v0.20.0 

func (trans *Transactor) CheckTxSyncRaw(txBytes []byte) (*txs.Receipt, error)

func (*Transactor) MaybeSignTxMempool added in v0.20.1 

func (trans *Transactor) MaybeSignTxMempool(txEnv *txs.Envelope) (UnlockFunc, error)

func (*Transactor) SignTx 

func (trans *Transactor) SignTx(txEnv *txs.Envelope) (*txs.Envelope, error)

func (*Transactor) SignTxMempool added in v0.20.0 

func (trans *Transactor) SignTxMempool(txEnv *txs.Envelope) (*txs.Envelope, UnlockFunc, error)

type UnlockFunc 

type UnlockFunc func()

type Updatable added in v0.19.0 

type Updatable interface {
	state.Writer
	names.Writer
	AddBlock(blockExecution *exec.BlockExecution) error
}

type VMOption 

type VMOption string
const (
	DebugOpcodes VMOption = "DebugOpcodes"
	DumpTokens   VMOption = "DumpTokens"
)

Source Files

View all Source files

Directories

Path Synopsis
Package errors is a generated protocol buffer package.
 Package errors is a generated protocol buffer package.
evm
abi
asm
asm/bc
sha3
Package exec is a generated protocol buffer package.
 Package exec is a generated protocol buffer package.
Package names is a generated protocol buffer package.
 Package names is a generated protocol buffer package.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.