evm

README

Obscuro 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

• Variables
• func ExecuteObsCall(msg *types.Message, s *state.StateDB, header *common.BatchHeader, ...) (*gethcore.ExecutionResult, error)
• func ExecuteTransactions(txs []*common.L2Tx, s *state.StateDB, header *common.BatchHeader, ...) map[common.TxHash]interface{}
• type ObscuroChainContext
  • func NewObscuroChainContext(storage storage.Storage, logger gethlog.Logger) *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, _ bool) error
  • func (e *ObscuroNoOpConsensusEngine) VerifyHeaders(_ consensus.ChainHeaderReader, _ []*types.Header, _ []bool) (chan<- struct{}, <-chan error)
  • func (e *ObscuroNoOpConsensusEngine) VerifyUncles(_ consensus.ChainReader, _ *types.Block) error

Variables

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(
	msg *types.Message,
	s *state.StateDB,
	header *common.BatchHeader,
	storage storage.Storage,
	chainConfig *params.ChainConfig,
	logger gethlog.Logger,
) (*gethcore.ExecutionResult, error)

ExecuteObsCall - executes the eth_call call

func ExecuteTransactions

func ExecuteTransactions(
	txs []*common.L2Tx,
	s *state.StateDB,
	header *common.BatchHeader,
	storage storage.Storage,
	chainConfig *params.ChainConfig,
	fromTxIndex int,
	logger gethlog.Logger,
) map[common.TxHash]interface{}

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, 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.Transaction, _ []*types.Header)

func (*ObscuroNoOpConsensusEngine) FinalizeAndAssemble

func (e *ObscuroNoOpConsensusEngine) FinalizeAndAssemble(_ consensus.ChainHeaderReader, _ *types.Header, _ *state.StateDB, _ []*types.Transaction,
	_ []*types.Header, _ []*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, _ bool) error

func (*ObscuroNoOpConsensusEngine) VerifyHeaders

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

func (*ObscuroNoOpConsensusEngine) VerifyUncles

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