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 }