evm

type AccountRef Address

type Address [AddressLength]byte

type BlockContext struct {
	// CanTransfer returns whether the account contains
	// sufficient ether to transfer the value
	CanTransfer CanTransferFunc
	// Transfer transfers ether from one account to the other
	Transfer TransferFunc
	// GetHash returns the hash corresponding to n
	GetHash GetHashFunc

	// Block information
	Coinbase      Address  // Provides information for COINBASE
	GasLimit      uint64   // Provides information for GASLIMIT
	BlockNumber   *big.Int // Provides information for NUMBER
	Time          uint64   // Provides information for TIME
	Difficulty    *big.Int // Provides information for DIFFICULTY
	BaseFee       *big.Int // Provides information for BASEFEE
	Random        *Hash    // Provides information for PREVRANDAO
	ExcessBlobGas *uint64  // ExcessBlobGas field in the header, needed to compute the data
}

type CallContext interface {
	// Call calls another contract.
	Call(env *EVM, me ContractRef, addr Address, data []byte, gas, value *big.Int) ([]byte, error)
	// CallCode takes another contracts code and execute within our own context
	CallCode(env *EVM, me ContractRef, addr Address, data []byte, gas, value *big.Int) ([]byte, error)
	// DelegateCall is same as CallCode except sender and value is propagated from parent to child scope
	DelegateCall(env *EVM, me ContractRef, addr Address, data []byte, gas *big.Int) ([]byte, error)
	// Create creates a new contract
	Create(env *EVM, me ContractRef, data []byte, gas, value *big.Int) ([]byte, Address, error)
}

type CanTransferFunc func(StateDB, Address, *big.Int) bool

type Config struct {
	Tracer                  EVMLogger // Opcode logger
	NoBaseFee               bool      // Forces the EIP-1559 baseFee to 0 (needed for 0 price calls)
	EnablePreimageRecording bool      // Enables recording of SHA3/keccak preimages
	ExtraEips               []int     // Additional EIPS that are to be enabled
}

type Contract struct {
	// Callercommon.Address is the result of the caller which initialised this
	// contract. However when the "call method" is delegated this value
	// needs to be initialised to that of the caller's caller.
	CallerAddress Address

	Code     []byte
	CodeHash Hash
	CodeAddr *Address
	Input    []byte

	Gas uint64
	// contains filtered or unexported fields
}

type ContractRef interface {
	Address() Address
}

type EVM struct {
	// Context provides auxiliary blockchain related information
	Context BlockContext
	TxContext
	// StateDB gives access to the underlying state
	StateDB StateDB

	// virtual machine configuration options used to initialise the
	// evm.
	Config Config
	// contains filtered or unexported fields
}

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

type EVMLogger interface {
	CaptureTxStart(gasLimit uint64)
	CaptureTxEnd(restGas uint64)

	CaptureStart(env *EVM, from Address, to Address, create bool, input []byte, gas uint64, value *big.Int)
	CaptureEnd(output []byte, gasUsed uint64, err error)

	CaptureEnter(typ OpCode, from Address, to Address, input []byte, gas uint64, value *big.Int)
	CaptureExit(output []byte, gasUsed uint64, err error)

	CaptureState(pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, rData []byte, depth int, err error)
	CaptureFault(pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, depth int, err error)
}

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

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

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

type GetHashFunc func(uint64) Hash

type Hash [HashLength]byte

type JumpTable [256]*operation

type KeccakState interface {
	hash.Hash
	Read([]byte) (int, error)
}

type Log struct {
	// Consensus fields:
	// address of the contract that generated the event
	Address Address `json:"address"`
	// list of topics provided by the contract.
	Topics []Hash `json:"topics"`
	// supplied by the contract, usually ABI-encoded
	Data []byte `json:"data"`

	// Derived fields. These fields are filled in by the node
	// but not secured by consensus.
	// block in which the transaction was included
	BlockNumber uint64 `json:"blockNumber"`
	// hash of the transaction
	TxHash Hash `json:"transactionHash"`
	// index of the transaction in the block
	TxIndex uint `json:"transactionIndex"`
	// hash of the block in which the transaction was included
	BlockHash Hash `json:"blockHash"`
	// index of the log in the block
	Index uint `json:"logIndex"`

	// The Removed field is true if this log was reverted due to a chain reorganisation.
	// You must pay attention to this field if you receive logs through a filter query.
	Removed bool `json:"removed"`
}

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

type OpCode byte

type PrecompiledContract interface {
	RequiredGas(input []byte) uint64  // RequiredPrice calculates the contract gas use
	Run(input []byte) ([]byte, error) // Run runs the precompiled contract
}

type ScopeContext struct {
	Memory   *Memory
	Stack    *Stack
	Contract *Contract
}

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

type StateDB interface {
	CreateAccount(Address)

	SubBalance(Address, *big.Int)
	AddBalance(Address, *big.Int)
	GetBalance(Address) *big.Int

	GetNonce(Address) uint64
	SetNonce(Address, uint64)

	GetCodeHash(Address) Hash
	GetCode(Address) []byte
	SetCode(Address, []byte)
	GetCodeSize(Address) int

	// 添加退款金额
	AddRefund(uint64)
	// 减去退款金额
	SubRefund(uint64)
	GetRefund() uint64

	// 返回的是当前执行context提交到数据库的已提交状态(committed state)
	// 也就是上次日志记录点(journal checkpoint)时的状态
	GetCommittedState(Address, Hash) Hash
	// 返回的是当前VM执行过程中的当前状态(current state),包含未提交的变更
	// 反映了所有最近的写入,但未提交至底层数据库
	GetState(Address, Hash) Hash
	SetState(Address, Hash, Hash)

	GetTransientState(addr Address, key Hash) Hash
	SetTransientState(addr Address, key, val Hash)

	SelfDestruct(Address)
	HasSelfDestructed(Address) bool

	Selfdestruct6780(Address)

	// Exist reports whether the given account exists in state.
	// Notably this should also return true for self-destructed accounts.
	Exist(Address) bool
	// Empty returns whether the given account is empty. Empty
	// is defined according to EIP161 (balance = nonce = code = 0).
	Empty(Address) bool

	AddressInAccessList(addr Address) bool
	SlotInAccessList(addr Address, slot Hash) (addressOk bool, slotOk bool)
	// Addcommon.AddressToAccessList adds the given define.Address to the access list. This operation is safe to perform
	// even if the feature/fork is not active yet
	AddAddressToAccessList(addr Address)
	// AddSlotToAccessList adds the given (define.Address,slot) to the access list. This operation is safe to perform
	// even if the feature/fork is not active yet
	AddSlotToAccessList(addr Address, slot Hash)

	RevertToSnapshot(int)
	Snapshot() int

	AddLog(Log)
	AddPreimage(Hash, []byte)
}

type TransferFunc func(StateDB, Address, Address, *big.Int)

type TxContext struct {
	// Message information
	Origin     Address  // Provides information for ORIGIN
	GasPrice   *big.Int // Provides information for GASPRICE
	BlobHashes []Hash   // Provides information for BLOBHASH
}