evm

README

Ten executes EVM compatible transactions on top of a database that implements the Go-Ethereum interfaces.

The entry point is the evm_facade.

The approach we took was to depend on Go-Ethereum, mock out all consensus related dependencies, and just use the transaction execution functionality.

Documentation

Index

• Constants
• Variables
• func ExecuteObsCall(ctx context.Context, msg *gethcore.Message, s *state.StateDB, ...) (*gethcore.ExecutionResult, error)
• func ExecuteTransactions(ctx context.Context, txs common.L2PricedTransactions, s *state.StateDB, ...) (map[common.TxHash]*TxExecResult, error)
• type ObscuroChainContext
  • func NewObscuroChainContext(storage storage.Storage, gethEncodingService gethencoding.EncodingService, ...) *ObscuroChainContext
  • func (occ *ObscuroChainContext) Engine() consensus.Engine
  • func (occ *ObscuroChainContext) GetHeader(hash common.Hash, _ uint64) *types.Header
• type ObscuroNoOpConsensusEngine
  • func (e *ObscuroNoOpConsensusEngine) APIs(_ consensus.ChainHeaderReader) []rpc.API
  • func (e *ObscuroNoOpConsensusEngine) Author(_ *types.Header) (common.Address, error)
  • func (e *ObscuroNoOpConsensusEngine) CalcDifficulty(_ consensus.ChainHeaderReader, _ uint64, _ *types.Header) *big.Int
  • func (e *ObscuroNoOpConsensusEngine) Close() error
  • func (e *ObscuroNoOpConsensusEngine) Finalize(_ consensus.ChainHeaderReader, _ *types.Header, _ *state.StateDB, ...)
  • func (e *ObscuroNoOpConsensusEngine) FinalizeAndAssemble(_ consensus.ChainHeaderReader, _ *types.Header, _ *state.StateDB, ...) (*types.Block, error)
  • func (e *ObscuroNoOpConsensusEngine) Prepare(_ consensus.ChainHeaderReader, _ *types.Header) error
  • func (e *ObscuroNoOpConsensusEngine) Seal(_ consensus.ChainHeaderReader, _ *types.Block, _ chan<- *types.Block, ...) error
  • func (e *ObscuroNoOpConsensusEngine) SealHash(_ *types.Header) common.Hash
  • func (e *ObscuroNoOpConsensusEngine) VerifyHeader(_ consensus.ChainHeaderReader, _ *types.Header) error
  • func (e *ObscuroNoOpConsensusEngine) VerifyHeaders(_ consensus.ChainHeaderReader, _ []*types.Header) (chan<- struct{}, <-chan error)
  • func (e *ObscuroNoOpConsensusEngine) VerifyUncles(_ consensus.ChainReader, _ *types.Block) error
• type TxExecResult

Constants

const (
	BalanceDecreaseL1Payment       tracing.BalanceChangeReason = 100
	BalanceIncreaseL1Payment       tracing.BalanceChangeReason = 101
	BalanceRevertDecreaseL1Payment tracing.BalanceChangeReason = 102
	BalanceRevertIncreaseL1Payment tracing.BalanceChangeReason = 103
)

Variables

var ErrGasNotEnoughForL1 = errors.New("gas limit too low to pay for execution and l1 fees")

var PoolAddress = common.HexToAddress("0x0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A")

PoolAddress - address of the pool where the gas will go todo (#627) - this has to be reworked when the gas/fee work starts

Functions

func ExecuteObsCall

func ExecuteObsCall(
	ctx context.Context,
	msg *gethcore.Message,
	s *state.StateDB,
	header *common.BatchHeader,
	storage storage.Storage,
	gethEncodingService gethencoding.EncodingService,
	chainConfig *params.ChainConfig,
	gasEstimationCap uint64,
	config config.EnclaveConfig,
	logger gethlog.Logger,
) (*gethcore.ExecutionResult, error)

ExecuteObsCall - executes the eth_call call

func ExecuteTransactions

func ExecuteTransactions(
	ctx context.Context,
	txs common.L2PricedTransactions,
	s *state.StateDB,
	header *common.BatchHeader,
	storage storage.Storage,
	gethEncodingService gethencoding.EncodingService,
	chainConfig *params.ChainConfig,
	config config.EnclaveConfig,
	fromTxIndex int,
	noBaseFee bool,
	batchGasLimit uint64,
	logger gethlog.Logger,
) (map[common.TxHash]*TxExecResult, error)

ExecuteTransactions header - the header of the rollup where this transaction will be included fromTxIndex - for the receipts and events, the evm needs to know for each transaction the order in which it was executed in the block.

Types

type ObscuroChainContext

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

ObscuroChainContext - basic implementation of the ChainContext needed for the EVM integration

func NewObscuroChainContext

func NewObscuroChainContext(storage storage.Storage, gethEncodingService gethencoding.EncodingService, config config.EnclaveConfig, logger gethlog.Logger) *ObscuroChainContext

NewObscuroChainContext returns a new instance of the ObscuroChainContext given a storage ( and logger )

func (*ObscuroChainContext) Engine

func (occ *ObscuroChainContext) Engine() consensus.Engine

func (*ObscuroChainContext) GetHeader

func (occ *ObscuroChainContext) GetHeader(hash common.Hash, _ uint64) *types.Header

type ObscuroNoOpConsensusEngine

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

ObscuroNoOpConsensusEngine - implements the geth consensus.Engine, but doesn't do anything This is needed for running evm transactions

func (*ObscuroNoOpConsensusEngine) APIs

func (e *ObscuroNoOpConsensusEngine) APIs(_ consensus.ChainHeaderReader) []rpc.API

func (*ObscuroNoOpConsensusEngine) Author

func (e *ObscuroNoOpConsensusEngine) Author(_ *types.Header) (common.Address, error)

Author is used to determine where to send the gas collected from the fees.

func (*ObscuroNoOpConsensusEngine) CalcDifficulty

func (e *ObscuroNoOpConsensusEngine) CalcDifficulty(_ consensus.ChainHeaderReader, _ uint64, _ *types.Header) *big.Int

func (*ObscuroNoOpConsensusEngine) Close

func (e *ObscuroNoOpConsensusEngine) Close() error

func (*ObscuroNoOpConsensusEngine) Finalize

func (e *ObscuroNoOpConsensusEngine) Finalize(_ consensus.ChainHeaderReader, _ *types.Header, _ *state.StateDB, _ *types.Body)

func (*ObscuroNoOpConsensusEngine) FinalizeAndAssemble

func (e *ObscuroNoOpConsensusEngine) FinalizeAndAssemble(_ consensus.ChainHeaderReader, _ *types.Header, _ *state.StateDB, _ *types.Body, _ []*types.Receipt) (*types.Block, error)

func (*ObscuroNoOpConsensusEngine) Prepare

func (e *ObscuroNoOpConsensusEngine) Prepare(_ consensus.ChainHeaderReader, _ *types.Header) error

func (*ObscuroNoOpConsensusEngine) Seal

func (e *ObscuroNoOpConsensusEngine) Seal(_ consensus.ChainHeaderReader, _ *types.Block, _ chan<- *types.Block, _ <-chan struct{}) error

func (*ObscuroNoOpConsensusEngine) SealHash

func (e *ObscuroNoOpConsensusEngine) SealHash(_ *types.Header) common.Hash

func (*ObscuroNoOpConsensusEngine) VerifyHeader

func (e *ObscuroNoOpConsensusEngine) VerifyHeader(_ consensus.ChainHeaderReader, _ *types.Header) error

func (*ObscuroNoOpConsensusEngine) VerifyHeaders

func (e *ObscuroNoOpConsensusEngine) VerifyHeaders(_ consensus.ChainHeaderReader, _ []*types.Header) (chan<- struct{}, <-chan error)

func (*ObscuroNoOpConsensusEngine) VerifyUncles

func (e *ObscuroNoOpConsensusEngine) VerifyUncles(_ consensus.ChainReader, _ *types.Block) error

type TxExecResult

type TxExecResult struct {
	Receipt          *types.Receipt
	CreatedContracts []*gethcommon.Address
	Err              error
}