github.com/aidoskuneen/adk-node@v0.0.0-20220315131952-2e32567cb7f4/core/vm/evm.go (about)

     1  // Copyright 2021 The adkgo Authors
     2  // This file is part of the adkgo library (adapted for adkgo from go--ethereum v1.10.8).
     3  //
     4  // the adkgo library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // the adkgo library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the adkgo library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package vm
    18  
    19  import (
    20  	"math/big"
    21  	"sync/atomic"
    22  	"time"
    23  
    24  	"github.com/aidoskuneen/adk-node/common"
    25  	"github.com/aidoskuneen/adk-node/crypto"
    26  	"github.com/aidoskuneen/adk-node/params"
    27  	"github.com/holiman/uint256"
    28  )
    29  
    30  // emptyCodeHash is used by create to ensure deployment is disallowed to already
    31  // deployed contract addresses (relevant after the account abstraction).
    32  var emptyCodeHash = crypto.Keccak256Hash(nil)
    33  
    34  type (
    35  	// CanTransferFunc is the signature of a transfer guard function
    36  	CanTransferFunc func(StateDB, common.Address, *big.Int) bool
    37  	// TransferFunc is the signature of a transfer function
    38  	TransferFunc func(StateDB, common.Address, common.Address, *big.Int)
    39  	// GetHashFunc returns the n'th block hash in the blockchain
    40  	// and is used by the BLOCKHASH EVM op code.
    41  	GetHashFunc func(uint64) common.Hash
    42  )
    43  
    44  func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) {
    45  	var precompiles map[common.Address]PrecompiledContract
    46  	switch {
    47  	case evm.chainRules.IsBerlin:
    48  		precompiles = PrecompiledContractsBerlin
    49  	case evm.chainRules.IsIstanbul:
    50  		precompiles = PrecompiledContractsIstanbul
    51  	case evm.chainRules.IsByzantium:
    52  		precompiles = PrecompiledContractsByzantium
    53  	default:
    54  		precompiles = PrecompiledContractsHomestead
    55  	}
    56  	p, ok := precompiles[addr]
    57  	return p, ok
    58  }
    59  
    60  // BlockContext provides the EVM with auxiliary information. Once provided
    61  // it shouldn't be modified.
    62  type BlockContext struct {
    63  	// CanTransfer returns whether the account contains
    64  	// sufficient ether to transfer the value
    65  	CanTransfer CanTransferFunc
    66  	// Transfer transfers ether from one account to the other
    67  	Transfer TransferFunc
    68  	// GetHash returns the hash corresponding to n
    69  	GetHash GetHashFunc
    70  
    71  	// Block information
    72  	Coinbase    common.Address // Provides information for COINBASE
    73  	GasLimit    uint64         // Provides information for GASLIMIT
    74  	BlockNumber *big.Int       // Provides information for NUMBER
    75  	Time        *big.Int       // Provides information for TIME
    76  	Difficulty  *big.Int       // Provides information for DIFFICULTY
    77  	BaseFee     *big.Int       // Provides information for BASEFEE
    78  }
    79  
    80  // TxContext provides the EVM with information about a transaction.
    81  // All fields can change between transactions.
    82  type TxContext struct {
    83  	// Message information
    84  	Origin   common.Address // Provides information for ORIGIN
    85  	GasPrice *big.Int       // Provides information for GASPRICE
    86  }
    87  
    88  // EVM is the Ethereum Virtual Machine base object and provides
    89  // the necessary tools to run a contract on the given state with
    90  // the provided context. It should be noted that any error
    91  // generated through any of the calls should be considered a
    92  // revert-state-and-consume-all-gas operation, no checks on
    93  // specific errors should ever be performed. The interpreter makes
    94  // sure that any errors generated are to be considered faulty code.
    95  //
    96  // The EVM should never be reused and is not thread safe.
    97  type EVM struct {
    98  	// Context provides auxiliary blockchain related information
    99  	Context BlockContext
   100  	TxContext
   101  	// StateDB gives access to the underlying state
   102  	StateDB StateDB
   103  	// Depth is the current call stack
   104  	depth int
   105  
   106  	// chainConfig contains information about the current chain
   107  	chainConfig *params.ChainConfig
   108  	// chain rules contains the chain rules for the current epoch
   109  	chainRules params.Rules
   110  	// virtual machine configuration options used to initialise the
   111  	// evm.
   112  	Config Config
   113  	// global (to this context) ethereum virtual machine
   114  	// used throughout the execution of the tx.
   115  	interpreter *EVMInterpreter
   116  	// abort is used to abort the EVM calling operations
   117  	// NOTE: must be set atomically
   118  	abort int32
   119  	// callGasTemp holds the gas available for the current call. This is needed because the
   120  	// available gas is calculated in gasCall* according to the 63/64 rule and later
   121  	// applied in opCall*.
   122  	callGasTemp uint64
   123  }
   124  
   125  // NewEVM returns a new EVM. The returned EVM is not thread safe and should
   126  // only ever be used *once*.
   127  func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config) *EVM {
   128  	evm := &EVM{
   129  		Context:     blockCtx,
   130  		TxContext:   txCtx,
   131  		StateDB:     statedb,
   132  		Config:      config,
   133  		chainConfig: chainConfig,
   134  		chainRules:  chainConfig.Rules(blockCtx.BlockNumber),
   135  	}
   136  	evm.interpreter = NewEVMInterpreter(evm, config)
   137  	return evm
   138  }
   139  
   140  // Reset resets the EVM with a new transaction context.Reset
   141  // This is not threadsafe and should only be done very cautiously.
   142  func (evm *EVM) Reset(txCtx TxContext, statedb StateDB) {
   143  	evm.TxContext = txCtx
   144  	evm.StateDB = statedb
   145  }
   146  
   147  // Cancel cancels any running EVM operation. This may be called concurrently and
   148  // it's safe to be called multiple times.
   149  func (evm *EVM) Cancel() {
   150  	atomic.StoreInt32(&evm.abort, 1)
   151  }
   152  
   153  // Cancelled returns true if Cancel has been called
   154  func (evm *EVM) Cancelled() bool {
   155  	return atomic.LoadInt32(&evm.abort) == 1
   156  }
   157  
   158  // Interpreter returns the current interpreter
   159  func (evm *EVM) Interpreter() *EVMInterpreter {
   160  	return evm.interpreter
   161  }
   162  
   163  // Call executes the contract associated with the addr with the given input as
   164  // parameters. It also handles any necessary value transfer required and takes
   165  // the necessary steps to create accounts and reverses the state in case of an
   166  // execution error or failed value transfer.
   167  func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {
   168  	if evm.Config.NoRecursion && evm.depth > 0 {
   169  		return nil, gas, nil
   170  	}
   171  	// Fail if we're trying to execute above the call depth limit
   172  	if evm.depth > int(params.CallCreateDepth) {
   173  		return nil, gas, ErrDepth
   174  	}
   175  	// Fail if we're trying to transfer more than the available balance
   176  	if value.Sign() != 0 && !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
   177  		return nil, gas, ErrInsufficientBalance
   178  	}
   179  	snapshot := evm.StateDB.Snapshot()
   180  	p, isPrecompile := evm.precompile(addr)
   181  
   182  	if !evm.StateDB.Exist(addr) {
   183  		if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {
   184  			// Calling a non existing account, don't do anything, but ping the tracer
   185  			if evm.Config.Debug && evm.depth == 0 {
   186  				evm.Config.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)
   187  				evm.Config.Tracer.CaptureEnd(ret, 0, 0, nil)
   188  			}
   189  			return nil, gas, nil
   190  		}
   191  		evm.StateDB.CreateAccount(addr)
   192  	}
   193  	evm.Context.Transfer(evm.StateDB, caller.Address(), addr, value)
   194  
   195  	// Capture the tracer start/end events in debug mode
   196  	if evm.Config.Debug && evm.depth == 0 {
   197  		evm.Config.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)
   198  		defer func(startGas uint64, startTime time.Time) { // Lazy evaluation of the parameters
   199  			evm.Config.Tracer.CaptureEnd(ret, startGas-gas, time.Since(startTime), err)
   200  		}(gas, time.Now())
   201  	}
   202  
   203  	if isPrecompile {
   204  		ret, gas, err = RunPrecompiledContract(p, input, gas)
   205  	} else {
   206  		// Initialise a new contract and set the code that is to be used by the EVM.
   207  		// The contract is a scoped environment for this execution context only.
   208  		code := evm.StateDB.GetCode(addr)
   209  		if len(code) == 0 {
   210  			ret, err = nil, nil // gas is unchanged
   211  		} else {
   212  			addrCopy := addr
   213  			// If the account has no code, we can abort here
   214  			// The depth-check is already done, and precompiles handled above
   215  			contract := NewContract(caller, AccountRef(addrCopy), value, gas)
   216  			contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), code)
   217  			ret, err = evm.interpreter.Run(contract, input, false)
   218  			gas = contract.Gas
   219  		}
   220  	}
   221  	// When an error was returned by the EVM or when setting the creation code
   222  	// above we revert to the snapshot and consume any gas remaining. Additionally
   223  	// when we're in homestead this also counts for code storage gas errors.
   224  	if err != nil {
   225  		evm.StateDB.RevertToSnapshot(snapshot)
   226  		if err != ErrExecutionReverted {
   227  			gas = 0
   228  		}
   229  		// TODO: consider clearing up unused snapshots:
   230  		//} else {
   231  		//	evm.StateDB.DiscardSnapshot(snapshot)
   232  	}
   233  	return ret, gas, err
   234  }
   235  
   236  // CallCode executes the contract associated with the addr with the given input
   237  // as parameters. It also handles any necessary value transfer required and takes
   238  // the necessary steps to create accounts and reverses the state in case of an
   239  // execution error or failed value transfer.
   240  //
   241  // CallCode differs from Call in the sense that it executes the given address'
   242  // code with the caller as context.
   243  func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {
   244  	if evm.Config.NoRecursion && evm.depth > 0 {
   245  		return nil, gas, nil
   246  	}
   247  	// Fail if we're trying to execute above the call depth limit
   248  	if evm.depth > int(params.CallCreateDepth) {
   249  		return nil, gas, ErrDepth
   250  	}
   251  	// Fail if we're trying to transfer more than the available balance
   252  	// Note although it's noop to transfer X ether to caller itself. But
   253  	// if caller doesn't have enough balance, it would be an error to allow
   254  	// over-charging itself. So the check here is necessary.
   255  	if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
   256  		return nil, gas, ErrInsufficientBalance
   257  	}
   258  	var snapshot = evm.StateDB.Snapshot()
   259  
   260  	// It is allowed to call precompiles, even via delegatecall
   261  	if p, isPrecompile := evm.precompile(addr); isPrecompile {
   262  		ret, gas, err = RunPrecompiledContract(p, input, gas)
   263  	} else {
   264  		addrCopy := addr
   265  		// Initialise a new contract and set the code that is to be used by the EVM.
   266  		// The contract is a scoped environment for this execution context only.
   267  		contract := NewContract(caller, AccountRef(caller.Address()), value, gas)
   268  		contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))
   269  		ret, err = evm.interpreter.Run(contract, input, false)
   270  		gas = contract.Gas
   271  	}
   272  	if err != nil {
   273  		evm.StateDB.RevertToSnapshot(snapshot)
   274  		if err != ErrExecutionReverted {
   275  			gas = 0
   276  		}
   277  	}
   278  	return ret, gas, err
   279  }
   280  
   281  // DelegateCall executes the contract associated with the addr with the given input
   282  // as parameters. It reverses the state in case of an execution error.
   283  //
   284  // DelegateCall differs from CallCode in the sense that it executes the given address'
   285  // code with the caller as context and the caller is set to the caller of the caller.
   286  func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error) {
   287  	if evm.Config.NoRecursion && evm.depth > 0 {
   288  		return nil, gas, nil
   289  	}
   290  	// Fail if we're trying to execute above the call depth limit
   291  	if evm.depth > int(params.CallCreateDepth) {
   292  		return nil, gas, ErrDepth
   293  	}
   294  	var snapshot = evm.StateDB.Snapshot()
   295  
   296  	// It is allowed to call precompiles, even via delegatecall
   297  	if p, isPrecompile := evm.precompile(addr); isPrecompile {
   298  		ret, gas, err = RunPrecompiledContract(p, input, gas)
   299  	} else {
   300  		addrCopy := addr
   301  		// Initialise a new contract and make initialise the delegate values
   302  		contract := NewContract(caller, AccountRef(caller.Address()), nil, gas).AsDelegate()
   303  		contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))
   304  		ret, err = evm.interpreter.Run(contract, input, false)
   305  		gas = contract.Gas
   306  	}
   307  	if err != nil {
   308  		evm.StateDB.RevertToSnapshot(snapshot)
   309  		if err != ErrExecutionReverted {
   310  			gas = 0
   311  		}
   312  	}
   313  	return ret, gas, err
   314  }
   315  
   316  // StaticCall executes the contract associated with the addr with the given input
   317  // as parameters while disallowing any modifications to the state during the call.
   318  // Opcodes that attempt to perform such modifications will result in exceptions
   319  // instead of performing the modifications.
   320  func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error) {
   321  	if evm.Config.NoRecursion && evm.depth > 0 {
   322  		return nil, gas, nil
   323  	}
   324  	// Fail if we're trying to execute above the call depth limit
   325  	if evm.depth > int(params.CallCreateDepth) {
   326  		return nil, gas, ErrDepth
   327  	}
   328  	// We take a snapshot here. This is a bit counter-intuitive, and could probably be skipped.
   329  	// However, even a staticcall is considered a 'touch'. On mainnet, static calls were introduced
   330  	// after all empty accounts were deleted, so this is not required. However, if we omit this,
   331  	// then certain tests start failing; stRevertTest/RevertPrecompiledTouchExactOOG.json.
   332  	// We could change this, but for now it's left for legacy reasons
   333  	var snapshot = evm.StateDB.Snapshot()
   334  
   335  	// We do an AddBalance of zero here, just in order to trigger a touch.
   336  	// This doesn't matter on Mainnet, where all empties are gone at the time of Byzantium,
   337  	// but is the correct thing to do and matters on other networks, in tests, and potential
   338  	// future scenarios
   339  	evm.StateDB.AddBalance(addr, big0)
   340  
   341  	if p, isPrecompile := evm.precompile(addr); isPrecompile {
   342  		ret, gas, err = RunPrecompiledContract(p, input, gas)
   343  	} else {
   344  		// At this point, we use a copy of address. If we don't, the go compiler will
   345  		// leak the 'contract' to the outer scope, and make allocation for 'contract'
   346  		// even if the actual execution ends on RunPrecompiled above.
   347  		addrCopy := addr
   348  		// Initialise a new contract and set the code that is to be used by the EVM.
   349  		// The contract is a scoped environment for this execution context only.
   350  		contract := NewContract(caller, AccountRef(addrCopy), new(big.Int), gas)
   351  		contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))
   352  		// When an error was returned by the EVM or when setting the creation code
   353  		// above we revert to the snapshot and consume any gas remaining. Additionally
   354  		// when we're in Homestead this also counts for code storage gas errors.
   355  		ret, err = evm.interpreter.Run(contract, input, true)
   356  		gas = contract.Gas
   357  	}
   358  	if err != nil {
   359  		evm.StateDB.RevertToSnapshot(snapshot)
   360  		if err != ErrExecutionReverted {
   361  			gas = 0
   362  		}
   363  	}
   364  	return ret, gas, err
   365  }
   366  
   367  type codeAndHash struct {
   368  	code []byte
   369  	hash common.Hash
   370  }
   371  
   372  func (c *codeAndHash) Hash() common.Hash {
   373  	if c.hash == (common.Hash{}) {
   374  		c.hash = crypto.Keccak256Hash(c.code)
   375  	}
   376  	return c.hash
   377  }
   378  
   379  // create creates a new contract using code as deployment code.
   380  func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64, value *big.Int, address common.Address) ([]byte, common.Address, uint64, error) {
   381  	// Depth check execution. Fail if we're trying to execute above the
   382  	// limit.
   383  	if evm.depth > int(params.CallCreateDepth) {
   384  		return nil, common.Address{}, gas, ErrDepth
   385  	}
   386  	if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
   387  		return nil, common.Address{}, gas, ErrInsufficientBalance
   388  	}
   389  	nonce := evm.StateDB.GetNonce(caller.Address())
   390  	evm.StateDB.SetNonce(caller.Address(), nonce+1)
   391  	// We add this to the access list _before_ taking a snapshot. Even if the creation fails,
   392  	// the access-list change should not be rolled back
   393  	if evm.chainRules.IsBerlin {
   394  		evm.StateDB.AddAddressToAccessList(address)
   395  	}
   396  	// Ensure there's no existing contract already at the designated address
   397  	contractHash := evm.StateDB.GetCodeHash(address)
   398  	if evm.StateDB.GetNonce(address) != 0 || (contractHash != (common.Hash{}) && contractHash != emptyCodeHash) {
   399  		return nil, common.Address{}, 0, ErrContractAddressCollision
   400  	}
   401  	// Create a new account on the state
   402  	snapshot := evm.StateDB.Snapshot()
   403  	evm.StateDB.CreateAccount(address)
   404  	if evm.chainRules.IsEIP158 {
   405  		evm.StateDB.SetNonce(address, 1)
   406  	}
   407  	evm.Context.Transfer(evm.StateDB, caller.Address(), address, value)
   408  
   409  	// Initialise a new contract and set the code that is to be used by the EVM.
   410  	// The contract is a scoped environment for this execution context only.
   411  	contract := NewContract(caller, AccountRef(address), value, gas)
   412  	contract.SetCodeOptionalHash(&address, codeAndHash)
   413  
   414  	if evm.Config.NoRecursion && evm.depth > 0 {
   415  		return nil, address, gas, nil
   416  	}
   417  
   418  	if evm.Config.Debug && evm.depth == 0 {
   419  		evm.Config.Tracer.CaptureStart(evm, caller.Address(), address, true, codeAndHash.code, gas, value)
   420  	}
   421  	start := time.Now()
   422  
   423  	ret, err := evm.interpreter.Run(contract, nil, false)
   424  
   425  	// Check whether the max code size has been exceeded, assign err if the case.
   426  	if err == nil && evm.chainRules.IsEIP158 && len(ret) > params.MaxCodeSize {
   427  		err = ErrMaxCodeSizeExceeded
   428  	}
   429  
   430  	// Reject code starting with 0xEF if EIP-3541 is enabled.
   431  	if err == nil && len(ret) >= 1 && ret[0] == 0xEF && evm.chainRules.IsLondon {
   432  		err = ErrInvalidCode
   433  	}
   434  
   435  	// if the contract creation ran successfully and no errors were returned
   436  	// calculate the gas required to store the code. If the code could not
   437  	// be stored due to not enough gas set an error and let it be handled
   438  	// by the error checking condition below.
   439  	if err == nil {
   440  		createDataGas := uint64(len(ret)) * params.CreateDataGas
   441  		if contract.UseGas(createDataGas) {
   442  			evm.StateDB.SetCode(address, ret)
   443  		} else {
   444  			err = ErrCodeStoreOutOfGas
   445  		}
   446  	}
   447  
   448  	// When an error was returned by the EVM or when setting the creation code
   449  	// above we revert to the snapshot and consume any gas remaining. Additionally
   450  	// when we're in homestead this also counts for code storage gas errors.
   451  	if err != nil && (evm.chainRules.IsHomestead || err != ErrCodeStoreOutOfGas) {
   452  		evm.StateDB.RevertToSnapshot(snapshot)
   453  		if err != ErrExecutionReverted {
   454  			contract.UseGas(contract.Gas)
   455  		}
   456  	}
   457  
   458  	if evm.Config.Debug && evm.depth == 0 {
   459  		evm.Config.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
   460  	}
   461  	return ret, address, contract.Gas, err
   462  }
   463  
   464  // Create creates a new contract using code as deployment code.
   465  func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
   466  	contractAddr = crypto.CreateAddress(caller.Address(), evm.StateDB.GetNonce(caller.Address()))
   467  	return evm.create(caller, &codeAndHash{code: code}, gas, value, contractAddr)
   468  }
   469  
   470  // Create2 creates a new contract using code as deployment code.
   471  //
   472  // The different between Create2 with Create is Create2 uses sha3(0xff ++ msg.sender ++ salt ++ sha3(init_code))[12:]
   473  // instead of the usual sender-and-nonce-hash as the address where the contract is initialized at.
   474  func (evm *EVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, salt *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
   475  	codeAndHash := &codeAndHash{code: code}
   476  	contractAddr = crypto.CreateAddress2(caller.Address(), salt.Bytes32(), codeAndHash.Hash().Bytes())
   477  	return evm.create(caller, codeAndHash, gas, endowment, contractAddr)
   478  }
   479  
   480  // ChainConfig returns the environment's chain configuration
   481  func (evm *EVM) ChainConfig() *params.ChainConfig { return evm.chainConfig }