runtime

Documentation

Index

• type Output
• type ResolvedTransaction
  • func ResolveTransaction(tx *tx.Transaction) (*ResolvedTransaction, error)
  • func (r *ResolvedTransaction) BuyGas(state *state.State, blockTime uint64) (baseGasPrice *big.Int, gasPrice *big.Int, payer thor.Address, ...)
  • func (r *ResolvedTransaction) CommonTo() *thor.Address
  • func (r *ResolvedTransaction) ToContext(gasPrice *big.Int, gasPayer thor.Address, blockNumber uint32, ...) (*xenv.TransactionContext, error)
• type Runtime
  • func New(chain *chain.Chain, state *state.State, ctx *xenv.BlockContext, ...) *Runtime
  • func (rt *Runtime) Chain() *chain.Chain
  • func (rt *Runtime) Context() *xenv.BlockContext
  • func (rt *Runtime) ExecuteTransaction(tx *tx.Transaction) (receipt *tx.Receipt, err error)
  • func (rt *Runtime) PrepareClause(clause *tx.Clause, clauseIndex uint32, gas uint64, ...) (exec func() (output *Output, interrupted bool, err error), interrupt func())
  • func (rt *Runtime) PrepareTransaction(tx *tx.Transaction) (*TransactionExecutor, error)
  • func (rt *Runtime) SetVMConfig(config vm.Config) *Runtime
  • func (rt *Runtime) State() *state.State
• type TransactionExecutor

Types

type Output

type Output struct {
	Data            []byte
	Events          tx.Events
	Transfers       tx.Transfers
	LeftOverGas     uint64
	RefundGas       uint64
	VMErr           error         // VMErr identify the execution result of the contract function, not evm function's err.
	ContractAddress *thor.Address // if create a new contract, or is nil.
}

Output output of clause execution.

type ResolvedTransaction

type ResolvedTransaction struct {
	Origin       thor.Address
	Delegator    *thor.Address
	IntrinsicGas uint64
	Clauses      []*tx.Clause
	// contains filtered or unexported fields
}

ResolvedTransaction resolve the transaction according to given state.

func ResolveTransaction

func ResolveTransaction(tx *tx.Transaction) (*ResolvedTransaction, error)

ResolveTransaction resolves the transaction and performs basic validation.

func (*ResolvedTransaction) BuyGas

func (r *ResolvedTransaction) BuyGas(state *state.State, blockTime uint64) (
	baseGasPrice *big.Int,
	gasPrice *big.Int,
	payer thor.Address,
	returnGas func(uint64) error,
	err error,
)

BuyGas consumes energy to buy gas, to prepare for execution.

func (*ResolvedTransaction) CommonTo

func (r *ResolvedTransaction) CommonTo() *thor.Address

CommonTo returns common 'To' field of clauses if any. Nil returned if no common 'To'.

func (*ResolvedTransaction) ToContext

func (r *ResolvedTransaction) ToContext(
	gasPrice *big.Int,
	gasPayer thor.Address,
	blockNumber uint32,
	getBlockID func(uint32) (thor.Bytes32, error),
) (*xenv.TransactionContext, error)

ToContext create a tx context object.

type Runtime

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

Runtime bases on EVM and VeChain Thor builtins.

func New

func New(
	chain *chain.Chain,
	state *state.State,
	ctx *xenv.BlockContext,
	forkConfig thor.ForkConfig,
) *Runtime

New create a Runtime object.

func (*Runtime) Chain

func (rt *Runtime) Chain() *chain.Chain

func (*Runtime) Context

func (rt *Runtime) Context() *xenv.BlockContext

func (*Runtime) ExecuteTransaction

func (rt *Runtime) ExecuteTransaction(tx *tx.Transaction) (receipt *tx.Receipt, err error)

ExecuteTransaction executes a transaction. If some clause failed, receipt.Outputs will be nil and vmOutputs may shorter than clause count.

func (*Runtime) PrepareClause

func (rt *Runtime) PrepareClause(
	clause *tx.Clause,
	clauseIndex uint32,
	gas uint64,
	txCtx *xenv.TransactionContext,
) (exec func() (output *Output, interrupted bool, err error), interrupt func())

PrepareClause prepare to execute clause. It allows to interrupt execution.

func (*Runtime) PrepareTransaction

func (rt *Runtime) PrepareTransaction(tx *tx.Transaction) (*TransactionExecutor, error)

PrepareTransaction prepare to execute tx.

func (*Runtime) SetVMConfig

func (rt *Runtime) SetVMConfig(config vm.Config) *Runtime

SetVMConfig config VM. Returns this runtime.

func (*Runtime) State

func (rt *Runtime) State() *state.State

type TransactionExecutor

type TransactionExecutor struct {
	HasNextClause func() bool
	NextClause    func() (gasUsed uint64, output *Output, err error)
	Finalize      func() (*tx.Receipt, error)
}