vm

package
v1.10.61 Latest Latest
Warning

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

 Go to latest Published: Nov 22, 2024 License: GPL-3.0, GPL-3.0 Imports: 29 Imported by: 10

Documentation

Overview

Package vm implements the Cortex Virtual Machine.

The vm package implements one CVM, a byte code VM. The BC (Byte Code) VM loops over a set of bytes and executes them according to the set of rules defined in the Cortex yellow paper.

Index

Constants

View Source 
const (
	GasQuickStep   uint64 = 2
	GasFastestStep uint64 = 3
	GasFastStep    uint64 = 5
	GasMidStep     uint64 = 8
	GasSlowStep    uint64 = 10
	GasExtStep     uint64 = 20
)

Gas costs

Variables

View Source 
var (
	PrecompiledAddressesPrague    []common.Address
	PrecompiledAddressesCancun    []common.Address
	PrecompiledAddressesBerlin    []common.Address
	PrecompiledAddressesIstanbul  []common.Address
	PrecompiledAddressesByzantium []common.Address
	PrecompiledAddressesHomestead []common.Address
)
View Source 
var (
	// ErrInvalidSubroutineEntry means that a BEGINSUB was reached via iteration,
	// as opposed to from a JUMPSUB instruction
	ErrInvalidSubroutineEntry   = errors.New("invalid subroutine entry")
	ErrOutOfGas                 = errors.New("out of gas")
	ErrCodeStoreOutOfGas        = errors.New("contract creation code storage out of gas")
	ErrDepth                    = errors.New("max call depth exceeded")
	ErrTraceLimitReached        = errors.New("the number of logs reached the specified limit")
	ErrInsufficientBalance      = errors.New("insufficient balance for transfer")
	ErrContractAddressCollision = errors.New("contract address collision")

	ErrInvalidMetaRawSize      = errors.New("invalid meta raw size")
	ErrNoCompatibleInterpreter = errors.New("no compatible interpreter")
	ErrInvalidMetaAuthor       = errors.New("invalid meta author")

	ErrMaxCodeSizeExceeded     = errors.New("max code size exceeded")
	ErrMaxInitCodeSizeExceeded = errors.New("max initcode size exceeded")
	ErrGasUintOverflow         = errors.New("gas uint64 overflow")
	ErrInvalidJump             = errors.New("invalid jump destination")
	ErrWriteProtection         = errors.New("write protection")
	ErrInvalidRetsub           = errors.New("invalid retsub")
	ErrReturnStackExceeded     = errors.New("return stack limit reached")

	ErrDownloading    = errors.New("downloading")
	ErrFileNotExist   = errors.New("file not exist")
	ErrInvalidTorrent = errors.New("invalid torrent")
	ErrInfer          = errors.New("infer error")

	ErrRuntime               = synapse.KERNEL_RUNTIME_ERROR
	ErrLogic                 = synapse.KERNEL_LOGIC_ERROR
	ErrReturnDataOutOfBounds = errors.New("return data out of bounds")
	ErrExecutionReverted     = errors.New("execution reverted")

	ErrNonceUintOverflow = errors.New("nonce uint64 overflow")
)

List execution errors

View Source 
var (
	ErrMetaInfoNotMature = errors.New("cvm: errMetaInfoNotMature")
)
View Source 
var PrecompiledContractsBLS = PrecompiledContractsPrague
View Source 
var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
	common.BytesToAddress([]byte{0x5}): &bigModExp{eip2565: true},
	common.BytesToAddress([]byte{0x6}): &bn256AddIstanbul{},
	common.BytesToAddress([]byte{0x7}): &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{0x8}): &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{0x9}): &blake2F{},
}

PrecompiledContractsBerlin contains the default set of pre-compiled Cortex contracts used in the Berlin release.

View Source 
var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
	common.BytesToAddress([]byte{0x5}): &bigModExp{eip2565: false},
	common.BytesToAddress([]byte{0x6}): &bn256AddByzantium{},
	common.BytesToAddress([]byte{0x7}): &bn256ScalarMulByzantium{},
	common.BytesToAddress([]byte{0x8}): &bn256PairingByzantium{},
}

PrecompiledContractsByzantium contains the default set of pre-compiled CortexTheseus contracts used in the Byzantium release.

View Source 
var PrecompiledContractsCancun = map[common.Address]PrecompiledContract{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
	common.BytesToAddress([]byte{0x5}): &bigModExp{eip2565: true},
	common.BytesToAddress([]byte{0x6}): &bn256AddIstanbul{},
	common.BytesToAddress([]byte{0x7}): &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{0x8}): &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{0x9}): &blake2F{},
	common.BytesToAddress([]byte{0xa}): &kzgPointEvaluation{},
}

PrecompiledContractsCancun contains the default set of pre-compiled Ethereum contracts used in the Cancun release.

View Source 
var PrecompiledContractsHomestead = map[common.Address]PrecompiledContract{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
}

PrecompiledContractsHomestead contains the default set of pre-compiled CortexTheseus contracts used in the Frontier and Homestead releases.

View Source 
var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract{
	common.BytesToAddress([]byte{0x1}): &ecrecover{},
	common.BytesToAddress([]byte{0x2}): &sha256hash{},
	common.BytesToAddress([]byte{0x3}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x4}): &dataCopy{},
	common.BytesToAddress([]byte{0x5}): &bigModExp{eip2565: false},
	common.BytesToAddress([]byte{0x6}): &bn256AddIstanbul{},
	common.BytesToAddress([]byte{0x7}): &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{0x8}): &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{0x9}): &blake2F{},
}

PrecompiledContractsIstanbul contains the default set of pre-compiled CortexTheseus contracts used in the Istanbul release.

View Source 
var PrecompiledContractsNeo = PrecompiledContractsIstanbul
View Source 
var PrecompiledContractsPrague = map[common.Address]PrecompiledContract{
	common.BytesToAddress([]byte{0x01}): &ecrecover{},
	common.BytesToAddress([]byte{0x02}): &sha256hash{},
	common.BytesToAddress([]byte{0x03}): &ripemd160hash{},
	common.BytesToAddress([]byte{0x04}): &dataCopy{},
	common.BytesToAddress([]byte{0x05}): &bigModExp{eip2565: true},
	common.BytesToAddress([]byte{0x06}): &bn256AddIstanbul{},
	common.BytesToAddress([]byte{0x07}): &bn256ScalarMulIstanbul{},
	common.BytesToAddress([]byte{0x08}): &bn256PairingIstanbul{},
	common.BytesToAddress([]byte{0x09}): &blake2F{},
	common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{},
	common.BytesToAddress([]byte{0x0b}): &bls12381G1Add{},
	common.BytesToAddress([]byte{0x0c}): &bls12381G1Mul{},
	common.BytesToAddress([]byte{0x0d}): &bls12381G1MultiExp{},
	common.BytesToAddress([]byte{0x0e}): &bls12381G2Add{},
	common.BytesToAddress([]byte{0x0f}): &bls12381G2Mul{},
	common.BytesToAddress([]byte{0x10}): &bls12381G2MultiExp{},
	common.BytesToAddress([]byte{0x11}): &bls12381Pairing{},
	common.BytesToAddress([]byte{0x12}): &bls12381MapG1{},
	common.BytesToAddress([]byte{0x13}): &bls12381MapG2{},
}

PrecompiledContractsPrague contains the set of pre-compiled Ethereum contracts used in the Prague release.

Functions

func ActivePrecompiles added in v1.10.34 

func ActivePrecompiles(rules params.Rules) []common.Address

ActivePrecompiles returns the precompiles enabled with the current configuration.

func EnableEIP added in v1.9.52 

func EnableEIP(eipNum int, jt *JumpTable) error

EnableEIP enables the given EIP on the config. This operation writes in-place, and callers need to ensure that the globally defined jump tables are not polluted.

func NoopCanTransfer 

func NoopCanTransfer(db StateDB, from common.Address, balance *big.Int) bool

func NoopTransfer 

func NoopTransfer(db StateDB, from, to common.Address, amount *big.Int)

func RunPrecompiledContract 

func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error)

RunPrecompiledContract runs and evaluates the output of a precompiled contract. It returns - the returned bytes, - the _remaining_ gas, - any error that occurred

Types

type AccountRef 

type AccountRef common.Address

AccountRef implements ContractRef.

Account references are used during CVM initialisation and it's primary use is to fetch addresses. Removing this object proves difficult because of the cached jump destinations which are fetched from the parent contract (i.e. the caller), which is a ContractRef.

func (AccountRef) Address 

func (ar AccountRef) Address() common.Address

Address casts AccountRef to a Address

type BlockContext added in v1.10.13 

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

	// Block information
	Coinbase    common.Address // Provides information for COINBASE
	GasLimit    uint64         // Provides information for GASLIMIT
	Quota       uint64
	BlockNumber *big.Int     // Provides information for NUMBER
	Time        uint64       // Provides information for TIME
	Difficulty  *big.Int     // Provides information for DIFFICULTY
	Random      *common.Hash // Provides information for RANDOM
}

Context provides the CVM with auxiliary information. Once provided it shouldn't be modified.

type CVM added in v1.0.0 

type CVM struct {
	// Context provides auxiliary blockchain related information
	Context BlockContext
	TxContext
	// StateDB gives access to the underlying state
	StateDB StateDB
	// contains filtered or unexported fields
}

CVM is the Cortex Virtual Machine base object and provides the necessary tools to run a contract on the given state with the provided context. It should be noted that any error generated through any of the calls should be considered a revert-state-and-consume-all-gas operation, no checks on specific errors should ever be performed. The interpreter makes sure that any errors generated are to be considered faulty code.

The CVM should never be reused and is not thread safe.

func NewCVM added in v1.0.0 

func NewCVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, vmConfig Config) *CVM

NewCVM returns a new CVM. The returned CVM is not thread safe and should only ever be used *once*.

func (*CVM) Call added in v1.0.0 

func (cvm *CVM) Call(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, modelGas map[common.Address]uint64, err error)

Call executes the contract associated with the addr with the given input as parameters. It also handles any necessary value transfer required and takes the necessary steps to create accounts and reverses the state in case of an execution error or failed value transfer.

func (*CVM) CallCode added in v1.0.0 

func (cvm *CVM) CallCode(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, modelGas map[common.Address]uint64, err error)

CallCode executes the contract associated with the addr with the given input as parameters. It also handles any necessary value transfer required and takes the necessary steps to create accounts and reverses the state in case of an execution error or failed value transfer.

CallCode differs from Call in the sense that it executes the given address' code with the caller as context.

func (*CVM) Cancel added in v1.0.0 

func (cvm *CVM) Cancel()

Cancel cancels any running CVM operation. This may be called concurrently and it's safe to be called multiple times.

func (*CVM) Cancelled added in v1.0.0 

func (cvm *CVM) Cancelled() bool

func (*CVM) ChainConfig added in v1.0.0 

func (cvm *CVM) ChainConfig() *params.ChainConfig

ChainConfig returns the environment's chain configuration

func (*CVM) Config added in v1.0.0 

func (cvm *CVM) Config() Config

func (*CVM) Create added in v1.0.0 

func (cvm *CVM) Create(caller ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, modelGas map[common.Address]uint64, err error)

Create creates a new contract using code as deployment code.

func (*CVM) Create2 added in v1.0.0 

func (cvm *CVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, salt *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, modelGas map[common.Address]uint64, err error)

Create2 creates a new contract using code as deployment code.

The different between Create2 with Create is Create2 uses sha3(0xff ++ msg.sender ++ salt ++ sha3(init_code))[12:] instead of the usual sender-and-nonce-hash as the address where the contract is initialized at.

func (*CVM) DelegateCall added in v1.0.0 

func (cvm *CVM) DelegateCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, modelGas map[common.Address]uint64, err error)

DelegateCall executes the contract associated with the addr with the given input as parameters. It reverses the state in case of an execution error.

DelegateCall differs from CallCode in the sense that it executes the given address' code with the caller as context and the caller is set to the caller of the caller.

func (*CVM) GetInputMeta added in v1.0.0 

func (cvm *CVM) GetInputMeta(addr common.Address) (meta *torrentfs.InputMeta, err error)

func (*CVM) GetModelMeta added in v1.0.0 

func (cvm *CVM) GetModelMeta(addr common.Address) (meta *torrentfs.ModelMeta, err error)

func (*CVM) Infer added in v1.0.0 

func (cvm *CVM) Infer(modelInfoHash, inputInfoHash string, modelRawSize, inputRawSize uint64) ([]byte, error)

infer function that returns an int64 as output, can be used a categorical output

func (*CVM) InferArray added in v1.0.0 

func (cvm *CVM) InferArray(modelInfoHash string, inputArray []byte, modelRawSize uint64) ([]byte, error)

infer function that returns an int64 as output, can be used a categorical output

func (*CVM) Interpreter added in v1.0.0 

func (cvm *CVM) Interpreter() *CVMInterpreter

Interpreter returns the current interpreter

func (*CVM) IsCode added in v1.9.52 

func (cvm *CVM) IsCode(code []byte) bool

func (*CVM) IsInput added in v1.9.52 

func (cvm *CVM) IsInput(code []byte) bool

func (*CVM) IsModel added in v1.9.52 

func (cvm *CVM) IsModel(code []byte) bool

func (*CVM) OpsInfer added in v1.0.0 

func (cvm *CVM) OpsInfer(addr common.Address) (opsRes uint64, errRes error)

infer function that returns an int64 as output, can be used a categorical output

func (*CVM) Reset added in v1.10.13 

func (cvm *CVM) Reset(txCtx TxContext, statedb StateDB)

Reset resets the CVM with a new transaction context.Reset This is not threadsafe and should only be done very cautiously.

func (*CVM) SetBlockContext added in v1.10.39 

func (cvm *CVM) SetBlockContext(blockCtx BlockContext)

SetBlockContext updates the block context of the CVM.

func (*CVM) SetExtraEips added in v1.10.39 

func (cvm *CVM) SetExtraEips(extraEips []int)

func (*CVM) StaticCall added in v1.0.0 

func (cvm *CVM) StaticCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, modelGas map[common.Address]uint64, err error)

StaticCall executes the contract associated with the addr with the given input as parameters while disallowing any modifications to the state during the call. Opcodes that attempt to perform such modifications will result in exceptions instead of performing the modifications.

type CVMInterpreter added in v1.0.0 

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

CVMInterpreter represents an CVM interpreter

func NewCVMInterpreter added in v1.0.0 

func NewCVMInterpreter(cvm *CVM) *CVMInterpreter

NewCVMInterpreter returns a new instance of the Interpreter.

func (*CVMInterpreter) Run added in v1.0.0 

func (in *CVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (ret []byte, err error)

Run loops and evaluates the contract's code with the given input data and returns the return byte-slice and an error if one occurred.

It's important to note that any errors returned by the interpreter should be considered a revert-and-consume-all-gas operation except for errExecutionReverted which means revert-and-keep-gas-left.

type CVMLogger added in v1.10.34 

type CVMLogger interface {
	// Transaction level
	CaptureTxStart(gasLimit uint64)
	CaptureTxEnd(restGas uint64)
	// Top call frame
	CaptureStart(env *CVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int)
	CaptureEnd(output []byte, gasUsed uint64, err error)
	// Rest of call frames
	CaptureEnter(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int)
	CaptureExit(output []byte, gasUsed uint64, err error)
	// Opcode level
	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)
}

CVMLogger is used to collect execution traces from an CVM transaction execution. CaptureState is called for each step of the VM with the current VM state. Note that reference types are actual VM data structures; make copies if you need to retain them beyond the current call.

type CallContext 

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

CallContext provides a basic interface for the CVM calling conventions. The CVM depends on this context being implemented for doing subcalls and initialising new CVM contracts.

type CanTransferFunc 

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

CanTransferFunc is the signature of a transfer guard function

type Category added in v1.9.52 

type Category struct {
	IsCode, IsModel, IsInput bool
}

type Config 

type Config struct {
	// Tracer is the op code logger
	Tracer CVMLogger
	// NoRecursion disabled Interpreter call, callcode,
	// delegate call and create.
	//NoRecursion bool
	// Enable recording of SHA3/keccak preimages
	EnablePreimageRecording bool
	// uri for remote infer service
	// InferURI string
	// rpc getInternalTransaction flag
	RPC_GetInternalTransaction bool

	// opCall flag
	CallFakeVM   bool
	DebugInferVM bool
	StorageDir   string

	ExtraEips               []int // Additional EIPS that are to be enabled
	EnableWitnessCollection bool  // true if witness collection is enabled
}

Config are the configuration options for the Interpreter

type ConfigAux 

type ConfigAux struct {
	InferURI string
}

only for the sake of debug info of NewPublicBlockChainAPI

type Contract 

type Contract struct {
	// CallerAddress 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 common.Address

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

	Gas uint64

	ModelGas map[common.Address]uint64
	// contains filtered or unexported fields
}

Contract represents an cortex contract in the state database. It contains the contract code, calling arguments. Contract implements ContractRef

func NewContract 

func NewContract(caller ContractRef, object ContractRef, value *big.Int, gas uint64) *Contract

NewContract returns a new contract environment for the execution of CVM.

func (*Contract) Address 

func (c *Contract) Address() common.Address

Address returns the contracts address

func (*Contract) AsDelegate 

func (c *Contract) AsDelegate() *Contract

AsDelegate sets the contract to be a delegate call and returns the current contract (for chaining calls)

func (*Contract) Caller 

func (c *Contract) Caller() common.Address

Caller returns the caller of the contract.

Caller will recursively call caller when the contract is a delegate call, including that of caller's caller.

func (*Contract) GetOp 

func (c *Contract) GetOp(n uint64) OpCode

GetOp returns the n'th element in the contract's byte array

func (*Contract) SetCallCode 

func (c *Contract) SetCallCode(addr *common.Address, hash common.Hash, code []byte)

SetCallCode sets the code of the contract and address of the backing data object

func (*Contract) SetCode 

func (c *Contract) SetCode(hash common.Hash, code []byte)

SetCode sets the code to the contract

func (*Contract) SetCodeOptionalHash added in v1.9.52 

func (c *Contract) SetCodeOptionalHash(addr *common.Address, codeAndHash *codeAndHash)

SetCodeOptionalHash can be used to provide code, but it's optional to provide hash. In case hash is not provided, the jumpdest analysis will not be saved to the parent context

func (*Contract) UseGas 

func (c *Contract) UseGas(gas uint64) (ok bool)

UseGas attempts the use gas and subtracts it and returns true on success

func (*Contract) Value 

func (c *Contract) Value() *big.Int

Value returns the contract's value (sent to it from it's caller)

type ContractRef 

type ContractRef interface {
	Address() common.Address
}

ContractRef is a reference to the contract's backing object

type ErrInvalidOpCode added in v1.10.30 

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

ErrInvalidOpCode wraps an evm error when an invalid opcode is encountered.

func (*ErrInvalidOpCode) Error added in v1.10.30 

func (e *ErrInvalidOpCode) Error() string

type ErrStackOverflow added in v1.10.30 

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

ErrStackOverflow wraps an evm error when the items on the stack exceeds the maximum allowance.

func (*ErrStackOverflow) Error added in v1.10.30 

func (e *ErrStackOverflow) Error() string

type ErrStackUnderflow added in v1.10.30 

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

ErrStackUnderflow wraps an evm error when the items on the stack less than the minimal requirement.

func (*ErrStackUnderflow) Error added in v1.10.30 

func (e *ErrStackUnderflow) Error() string

type GetHashFunc 

type GetHashFunc func(uint64) common.Hash

GetHashFunc returns the nth block hash in the blockchain and is used by the BLOCKHASH CVM op code.

type JumpTable added in v1.9.52 

type JumpTable [256]*operation

JumpTable contains the CVM opcodes supported at a given fork.

type Memory 

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

Memory implements a simple memory model for the cortex virtual machine.

func NewMemory 

func NewMemory() *Memory

NewMemory returns a new memory memory model.

func (*Memory) Copy added in v1.10.47 

func (m *Memory) Copy(dst, src, len uint64)

Copy copies data from the src position slice into the dst position. The source and destination may overlap. OBS: This operation assumes that any necessary memory expansion has already been performed, and this method may panic otherwise.

func (*Memory) Data 

func (m *Memory) Data() []byte

Data returns the backing slice

func (*Memory) Free added in v1.10.59 

func (m *Memory) Free()

Free returns the memory to the pool.

func (*Memory) GetCopy added in v1.10.0 

func (m *Memory) GetCopy(offset, size uint64) (cpy []byte)

GetCopy returns offset + size as a new slice

func (*Memory) GetPtr 

func (m *Memory) GetPtr(offset, size uint64) []byte

GetPtr returns the offset + size

func (*Memory) GetSolidityBytes added in v1.0.0 

func (m *Memory) GetSolidityBytes(slot int64) ([]byte, error)

func (*Memory) GetSolidityUint256 added in v1.0.0 

func (m *Memory) GetSolidityUint256(slot int64) ([]byte, error)

func (*Memory) Len 

func (m *Memory) Len() int

Len returns the length of the backing slice

func (*Memory) Print 

func (m *Memory) Print()

Print dumps the content of the memory.

func (*Memory) Resize 

func (m *Memory) Resize(size uint64)

Resize resizes the memory to size

func (*Memory) Set 

func (m *Memory) Set(offset, size uint64, value []byte)

Set sets offset + size to value

func (*Memory) Set32 

func (m *Memory) Set32(offset uint64, val *uint256.Int)

Set32 sets the 32 bytes starting at offset to the value of val, left-padded with zeroes to 32 bytes.

func (*Memory) WriteSolidityUint256Array added in v1.0.0 

func (m *Memory) WriteSolidityUint256Array(slot int64, data []byte) error

type NoopCVMCallContext added in v1.0.0 

type NoopCVMCallContext struct{}

func (NoopCVMCallContext) Call added in v1.0.0 

func (NoopCVMCallContext) Call(caller ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)

func (NoopCVMCallContext) CallCode added in v1.0.0 

func (NoopCVMCallContext) CallCode(caller ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)

func (NoopCVMCallContext) Create added in v1.0.0 

func (NoopCVMCallContext) Create(caller ContractRef, data []byte, gas, value *big.Int) ([]byte, common.Address, error)

func (NoopCVMCallContext) DelegateCall added in v1.0.0 

func (NoopCVMCallContext) DelegateCall(me ContractRef, addr common.Address, data []byte, gas *big.Int) ([]byte, error)

type NoopStateDB 

type NoopStateDB struct{}

func (NoopStateDB) AddBalance 

func (NoopStateDB) AddBalance(common.Address, *big.Int)

func (NoopStateDB) AddLog 

func (NoopStateDB) AddLog(*types.Log)

func (NoopStateDB) AddPreimage 

func (NoopStateDB) AddPreimage(common.Hash, []byte)

func (NoopStateDB) AddRefund 

func (NoopStateDB) AddRefund(uint64)

func (NoopStateDB) CreateAccount 

func (NoopStateDB) CreateAccount(common.Address)

func (NoopStateDB) Empty 

func (NoopStateDB) Empty(common.Address) bool

func (NoopStateDB) Exist 

func (NoopStateDB) Exist(common.Address) bool

func (NoopStateDB) ForEachStorage 

func (NoopStateDB) ForEachStorage(common.Address, func(common.Hash, common.Hash) bool)

func (NoopStateDB) GetBalance 

func (NoopStateDB) GetBalance(common.Address) *big.Int

func (NoopStateDB) GetCode 

func (NoopStateDB) GetCode(common.Address) []byte

func (NoopStateDB) GetCodeHash 

func (NoopStateDB) GetCodeHash(common.Address) common.Hash

func (NoopStateDB) GetCodeSize 

func (NoopStateDB) GetCodeSize(common.Address) int

func (NoopStateDB) GetNonce 

func (NoopStateDB) GetNonce(common.Address) uint64

func (NoopStateDB) GetRefund 

func (NoopStateDB) GetRefund() uint64

func (NoopStateDB) GetState 

func (NoopStateDB) GetState(common.Address, common.Hash) common.Hash

func (NoopStateDB) GetUpload 

func (NoopStateDB) GetUpload(common.Address) *big.Int

func (NoopStateDB) AddUpload(common.Address, *big.Int) {}

func (NoopStateDB) HasSuicided 

func (NoopStateDB) HasSuicided(common.Address) bool

func (NoopStateDB) RevertToSnapshot 

func (NoopStateDB) RevertToSnapshot(int)

func (NoopStateDB) SetCode 

func (NoopStateDB) SetCode(common.Address, []byte)

func (NoopStateDB) SetNonce 

func (NoopStateDB) SetNonce(common.Address, uint64)

func (NoopStateDB) SetState 

func (NoopStateDB) SetState(common.Address, common.Hash, common.Hash)

func (NoopStateDB) Snapshot 

func (NoopStateDB) Snapshot() int

func (NoopStateDB) SubBalance 

func (NoopStateDB) SubBalance(common.Address, *big.Int)

func (NoopStateDB) SubUpload 

func (NoopStateDB) SubUpload(common.Address, *big.Int) *big.Int

func (NoopStateDB) Suicide 

func (NoopStateDB) Suicide(common.Address) bool

type OpCode 

type OpCode byte

OpCode is an CVM opcode 

const (
	STOP       OpCode = 0x0
	ADD        OpCode = 0x1
	MUL        OpCode = 0x2
	SUB        OpCode = 0x3
	DIV        OpCode = 0x4
	SDIV       OpCode = 0x5
	MOD        OpCode = 0x6
	SMOD       OpCode = 0x7
	ADDMOD     OpCode = 0x8
	MULMOD     OpCode = 0x9
	EXP        OpCode = 0xa
	SIGNEXTEND OpCode = 0xb
)
const (
	LT     OpCode = 0x10
	GT     OpCode = 0x11
	SLT    OpCode = 0x12
	SGT    OpCode = 0x13
	EQ     OpCode = 0x14
	ISZERO OpCode = 0x15
	AND    OpCode = 0x16
	OR     OpCode = 0x17
	XOR    OpCode = 0x18
	NOT    OpCode = 0x19
	BYTE   OpCode = 0x1a
	SHL    OpCode = 0x1b
	SHR    OpCode = 0x1c
	SAR    OpCode = 0x1d
)

0x10 range - comparison ops. 

const (
	ADDRESS        OpCode = 0x30
	BALANCE        OpCode = 0x31
	ORIGIN         OpCode = 0x32
	CALLER         OpCode = 0x33
	CALLVALUE      OpCode = 0x34
	CALLDATALOAD   OpCode = 0x35
	CALLDATASIZE   OpCode = 0x36
	CALLDATACOPY   OpCode = 0x37
	CODESIZE       OpCode = 0x38
	CODECOPY       OpCode = 0x39
	GASPRICE       OpCode = 0x3a
	EXTCODESIZE    OpCode = 0x3b
	EXTCODECOPY    OpCode = 0x3c
	RETURNDATASIZE OpCode = 0x3d
	RETURNDATACOPY OpCode = 0x3e
	EXTCODEHASH    OpCode = 0x3f
)

0x30 range - closure state. 

const (
	BLOCKHASH   OpCode = 0x40 + iota
	COINBASE    OpCode = 0x41
	TIMESTAMP   OpCode = 0x42
	NUMBER      OpCode = 0x43
	DIFFICULTY  OpCode = 0x44
	RANDOM      OpCode = 0x44 // Same as DIFFICULTY
	PREVRANDAO  OpCode = 0x44 // Same as DIFFICULTY
	GASLIMIT    OpCode = 0x45
	CHAINID     OpCode = 0x46
	SELFBALANCE OpCode = 0x47
)

0x40 range - block operations. 

const (
	POP      OpCode = 0x50
	MLOAD    OpCode = 0x51
	MSTORE   OpCode = 0x52
	MSTORE8  OpCode = 0x53
	SLOAD    OpCode = 0x54
	SSTORE   OpCode = 0x55
	JUMP     OpCode = 0x56
	JUMPI    OpCode = 0x57
	PC       OpCode = 0x58
	MSIZE    OpCode = 0x59
	GAS      OpCode = 0x5a
	JUMPDEST OpCode = 0x5b
	TLOAD    OpCode = 0x5c
	TSTORE   OpCode = 0x5d
	MCOPY    OpCode = 0x5e
	PUSH0    OpCode = 0x5f
)

0x50 range - 'storage' and execution. 

const (
	PUSH1 OpCode = 0x60 + iota
	PUSH2
	PUSH3
	PUSH4
	PUSH5
	PUSH6
	PUSH7
	PUSH8
	PUSH9
	PUSH10
	PUSH11
	PUSH12
	PUSH13
	PUSH14
	PUSH15
	PUSH16
	PUSH17
	PUSH18
	PUSH19
	PUSH20
	PUSH21
	PUSH22
	PUSH23
	PUSH24
	PUSH25
	PUSH26
	PUSH27
	PUSH28
	PUSH29
	PUSH30
	PUSH31
	PUSH32
	DUP1
	DUP2
	DUP3
	DUP4
	DUP5
	DUP6
	DUP7
	DUP8
	DUP9
	DUP10
	DUP11
	DUP12
	DUP13
	DUP14
	DUP15
	DUP16
	SWAP1
	SWAP2
	SWAP3
	SWAP4
	SWAP5
	SWAP6
	SWAP7
	SWAP8
	SWAP9
	SWAP10
	SWAP11
	SWAP12
	SWAP13
	SWAP14
	SWAP15
	SWAP16
)

0x60 range. 

const (
	LOG0 OpCode = 0xa0 + iota
	LOG1
	LOG2
	LOG3
	LOG4
)

0xa0 range - logging ops. 

const (
	CREATE OpCode = 0xf0 + iota
	CALL
	CALLCODE
	RETURN
	DELEGATECALL
	CREATE2
	STATICCALL OpCode = 0xfa

	REVERT       OpCode = 0xfd
	INVALID      OpCode = 0xfe
	SELFDESTRUCT OpCode = 0xff
)

0xf0 range - closures. 

const (
	INFER      OpCode = 0xc0
	INFERARRAY        = 0xc1
)
const (
	KECCAK256 OpCode = 0x20
)

0x20 range - crypto.

func StringToOp 

func StringToOp(str string) OpCode

StringToOp finds the opcode whose name is stored in `str`.

func (OpCode) IsInfer 

func (op OpCode) IsInfer() bool

func (OpCode) IsPush 

func (op OpCode) IsPush() bool

IsPush specifies if an opcode is a PUSH opcode.

func (OpCode) String 

func (op OpCode) String() string

type PrecompiledContract 

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

PrecompiledContract is the basic interface for native Go contracts. The implementation requires a deterministic gas count based on the input size of the Run method of the contract.

type ScopeContext added in v1.10.34 

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

ScopeContext contains the things that are per-call, such as stack and memory, but not transients like pc and gas

type Stack 

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

Stack is an object for basic stack operations. Items popped to the stack are expected to be changed and modified. stack does not take care of adding newly initialised objects.

func (*Stack) Back 

func (st *Stack) Back(n int) *uint256.Int

Back returns the n'th item in stack

func (*Stack) Data 

func (st *Stack) Data() []uint256.Int

Data returns the underlying uint256.Int array.

func (*Stack) Print 

func (st *Stack) Print()

Print dumps the content of the stack

type StateDB 

type StateDB interface {
	CreateAccount(common.Address)
	CreateContract(common.Address)

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

	SetUpload(common.Address, *big.Int)
	SubUpload(common.Address, *big.Int) *big.Int
	//AddUpload(common.Address, *big.Int)
	//GetUpload(common.Address) *big.Int
	Uploading(common.Address) bool
	Upload(common.Address) *big.Int

	GetNum(common.Address) *big.Int
	SetNum(common.Address, *big.Int)

	GetNonce(common.Address) uint64
	SetNonce(common.Address, uint64)

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

	AddRefund(uint64)
	SubRefund(uint64)
	GetRefund() uint64

	GetCommittedState(common.Address, common.Hash) common.Hash

	GetState(common.Address, common.Hash) common.Hash
	SetState(common.Address, common.Hash, common.Hash)
	GetStorageRoot(addr common.Address) common.Hash

	GetSolidityBytes(common.Address, common.Hash) ([]byte, error)

	SelfDestruct(common.Address)
	HasSelfDestructed(common.Address) bool

	Selfdestruct6780(common.Address)

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

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

	RevertToSnapshot(int)
	Snapshot() int

	AddLog(*types.Log)
	AddPreimage(common.Hash, []byte)

	ForEachStorage(common.Address, func(common.Hash, common.Hash) bool) error
}

StateDB is an CVM database for full state querying.

type TransferFunc 

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

TransferFunc is the signature of a transfer function

type TxContext added in v1.10.13 

type TxContext struct {
	// Message information
	Origin   common.Address // Provides information for ORIGIN
	GasPrice *big.Int       // Provides information for GASPRICE
}

TxContext provides the CVM with information about a transaction. All fields can change between transactions.

Source Files

View all Source files

Directories

Path Synopsis
Package runtime provides a basic execution model for executing CVM code.
 Package runtime provides a basic execution model for executing CVM code.

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.