execution

package
v0.0.0-...-2935fa7 Latest Latest
Warning

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

 Go to latest Published: Apr 10, 2021 License: Apache-2.0 Imports: 36 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	SubscribeBufferSize = 10
)
View Source 
const VersionOffset = int64(1)

Since we have an initial save of our state forest we start one version ahead of the block height, but from then on we should track height by this offset.

Variables

This section is empty.

Functions

func CallCodeSim 

func CallCodeSim(reader acmstate.Reader, blockchain 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 

func CallSim(reader acmstate.Reader, blockchain 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 HeightAtVersion 

func HeightAtVersion(version int64) uint64

func VMOptions 

func VMOptions(vmOptions engine.Options) func(*executor)

func VersionAtHeight 

func VersionAtHeight(height uint64) int64

Types

type Accounts 

type Accounts struct {
	hsc_sync.RingMutex
	acmstate.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 acmstate.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(header *types.Header) (stateHash []byte, err error)
}

Executes transactions

func NewBatchCommitter 

func NewBatchCommitter(backend ExecutorState, params Params, blockchain engine.Blockchain, emitter *event.Emitter,
	logger *logging.Logger, options ...Option) (BatchCommitter, error)

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
	// Used by execution.Accounts to implement memory pool signing
	acmstate.Reader
	// Execute transaction against block cache (i.e. block buffer)
	Executor
	// Reset executor to underlying State
	Reset() error
}

func NewBatchChecker 

func NewBatchChecker(backend ExecutorState, params Params, blockchain engine.Blockchain, logger *logging.Logger,
	options ...Option) (BatchExecutor, error)

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

type ExecutionConfig 

type ExecutionConfig struct {
	// This parameter scales the default Tendermint timeouts. A value of 1 gives the Tendermint defaults designed to
	// work for 100 node + public network. Smaller networks should be able to sustain lower values.
	// When running in no-consensus mode (Tendermint.Enabled = false) this scales the block duration with 1.0 meaning 1 second
	// and 0 meaning commit immediately
	TimeoutFactor            float64
	CallStackMaxDepth        uint64
	DataStackInitialCapacity uint64
	DataStackMaxDepth        uint64
	VMOptions                []VMOption `json:",omitempty" toml:",omitempty"`
}

func DefaultExecutionConfig 

func DefaultExecutionConfig() *ExecutionConfig

func (*ExecutionConfig) ExecutionOptions 

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

type Executor 

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

type ExecutorFunc 

type ExecutorFunc func(txEnv *txs.Envelope) (*exec.TxExecution, error)

func (ExecutorFunc) Execute 

func (f ExecutorFunc) Execute(txEnv *txs.Envelope) (*exec.TxExecution, error)

type ExecutorState 

type ExecutorState interface {
	Update(updater func(ws state.Updatable) error) (hash []byte, version int64, err error)
	LastStoredHeight() (uint64, error)
	acmstate.IterableReader
	acmstate.MetadataReader
	names.Reader
	registry.Reader
	proposal.Reader
	validator.IterableReader
}

type Option 

type Option func(*executor)

type Params 

type Params struct {
	ChainID           string
	ProposalThreshold uint64
}

func ParamsFromGenesis 

func ParamsFromGenesis(genesisDoc *genesis.GenesisDoc) Params

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 Transactor 

type Transactor struct {
	BlockchainInfo  bcm.BlockchainInfo
	Emitter         *event.Emitter
	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 HiveSmartChain 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, emitter *event.Emitter, mempoolAccounts *Accounts,
	checkTxAsync txChecker, id p2p.ID, txEncoder txs.Encoder, logger *logging.Logger) *Transactor

func (*Transactor) BroadcastTxAsync 

func (trans *Transactor) BroadcastTxAsync(ctx context.Context, 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 

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

func (*Transactor) CheckTxAsync 

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

func (*Transactor) CheckTxAsyncRaw 

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

func (*Transactor) CheckTxSync 

func (trans *Transactor) CheckTxSync(ctx context.Context, 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 

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

func (*Transactor) MaybeSignTxMempool 

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 

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

type UnlockFunc 

type UnlockFunc func()

type VMOption 

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

Source Files

View all Source files

Directories

Path Synopsis
evm
abi
asm
asm/bc

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.