github.com/baptiste-b-pegasys/quorum/v22@v22.4.2/core/vm/runtime/runtime.go (about) 1 // Copyright 2015 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package runtime 18 19 import ( 20 "math" 21 "math/big" 22 "time" 23 24 "github.com/ethereum/go-ethereum/common" 25 "github.com/ethereum/go-ethereum/core/rawdb" 26 "github.com/ethereum/go-ethereum/core/state" 27 "github.com/ethereum/go-ethereum/core/vm" 28 "github.com/ethereum/go-ethereum/crypto" 29 "github.com/ethereum/go-ethereum/params" 30 ) 31 32 // Config is a basic type specifying certain configuration flags for running 33 // the EVM. 34 type Config struct { 35 ChainConfig *params.ChainConfig 36 Difficulty *big.Int 37 Origin common.Address 38 Coinbase common.Address 39 BlockNumber *big.Int 40 Time *big.Int 41 GasLimit uint64 42 GasPrice *big.Int 43 Value *big.Int 44 Debug bool 45 EVMConfig vm.Config 46 47 State *state.StateDB 48 GetHashFn func(n uint64) common.Hash 49 } 50 51 // sets defaults on the config 52 func setDefaults(cfg *Config) { 53 if cfg.ChainConfig == nil { 54 cfg.ChainConfig = ¶ms.ChainConfig{ 55 ChainID: big.NewInt(1), 56 HomesteadBlock: new(big.Int), 57 DAOForkBlock: new(big.Int), 58 DAOForkSupport: false, 59 EIP150Block: new(big.Int), 60 EIP150Hash: common.Hash{}, 61 EIP155Block: new(big.Int), 62 EIP158Block: new(big.Int), 63 ByzantiumBlock: new(big.Int), 64 ConstantinopleBlock: new(big.Int), 65 PetersburgBlock: new(big.Int), 66 IstanbulBlock: new(big.Int), 67 MuirGlacierBlock: new(big.Int), 68 BerlinBlock: new(big.Int), 69 YoloV3Block: nil, 70 } 71 } 72 73 if cfg.Difficulty == nil { 74 cfg.Difficulty = new(big.Int) 75 } 76 if cfg.Time == nil { 77 cfg.Time = big.NewInt(time.Now().Unix()) 78 } 79 if cfg.GasLimit == 0 { 80 cfg.GasLimit = math.MaxUint64 81 } 82 if cfg.GasPrice == nil { 83 cfg.GasPrice = new(big.Int) 84 } 85 if cfg.Value == nil { 86 cfg.Value = new(big.Int) 87 } 88 if cfg.BlockNumber == nil { 89 cfg.BlockNumber = new(big.Int) 90 } 91 if cfg.GetHashFn == nil { 92 cfg.GetHashFn = func(n uint64) common.Hash { 93 return common.BytesToHash(crypto.Keccak256([]byte(new(big.Int).SetUint64(n).String()))) 94 } 95 } 96 } 97 98 // Execute executes the code using the input as call data during the execution. 99 // It returns the EVM's return value, the new state and an error if it failed. 100 // 101 // Execute sets up an in-memory, temporary, environment for the execution of 102 // the given code. It makes sure that it's restored to its original state afterwards. 103 func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) { 104 if cfg == nil { 105 cfg = new(Config) 106 } 107 setDefaults(cfg) 108 109 if cfg.State == nil { 110 cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil) 111 } 112 var ( 113 address = common.BytesToAddress([]byte("contract")) 114 vmenv = NewEnv(cfg) 115 sender = vm.AccountRef(cfg.Origin) 116 ) 117 if cfg.ChainConfig.IsBerlin(vmenv.Context.BlockNumber) { 118 cfg.State.PrepareAccessList(cfg.Origin, &address, vmenv.ActivePrecompiles(), nil) 119 } 120 cfg.State.CreateAccount(address) 121 // set the receiver's (the executing contract) code for execution. 122 cfg.State.SetCode(address, code) 123 // Call the code with the given configuration. 124 ret, _, err := vmenv.Call( 125 sender, 126 common.BytesToAddress([]byte("contract")), 127 input, 128 cfg.GasLimit, 129 cfg.Value, 130 ) 131 132 return ret, cfg.State, err 133 } 134 135 // Create executes the code using the EVM create method 136 func Create(input []byte, cfg *Config) ([]byte, common.Address, uint64, error) { 137 if cfg == nil { 138 cfg = new(Config) 139 } 140 setDefaults(cfg) 141 142 if cfg.State == nil { 143 cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil) 144 } 145 var ( 146 vmenv = NewEnv(cfg) 147 sender = vm.AccountRef(cfg.Origin) 148 ) 149 if cfg.ChainConfig.IsBerlin(vmenv.Context.BlockNumber) { 150 cfg.State.PrepareAccessList(cfg.Origin, nil, vmenv.ActivePrecompiles(), nil) 151 } 152 153 // Call the code with the given configuration. 154 code, address, leftOverGas, err := vmenv.Create( 155 sender, 156 input, 157 cfg.GasLimit, 158 cfg.Value, 159 ) 160 return code, address, leftOverGas, err 161 } 162 163 // Call executes the code given by the contract's address. It will return the 164 // EVM's return value or an error if it failed. 165 // 166 // Call, unlike Execute, requires a config and also requires the State field to 167 // be set. 168 func Call(address common.Address, input []byte, cfg *Config) ([]byte, uint64, error) { 169 setDefaults(cfg) 170 171 vmenv := NewEnv(cfg) 172 173 sender := cfg.State.GetOrNewStateObject(cfg.Origin) 174 statedb := cfg.State 175 if cfg.ChainConfig.IsBerlin(vmenv.Context.BlockNumber) { 176 statedb.PrepareAccessList(cfg.Origin, &address, vmenv.ActivePrecompiles(), nil) 177 } 178 179 // Call the code with the given configuration. 180 ret, leftOverGas, err := vmenv.Call( 181 sender, 182 address, 183 input, 184 cfg.GasLimit, 185 cfg.Value, 186 ) 187 188 return ret, leftOverGas, err 189 }