github.com/anthdm/go-ethereum@v1.8.4-0.20180412101906-60516c83b011/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/state" 26 "github.com/ethereum/go-ethereum/core/vm" 27 "github.com/ethereum/go-ethereum/crypto" 28 "github.com/ethereum/go-ethereum/ethdb" 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 EIP155Block: new(big.Int), 61 EIP158Block: new(big.Int), 62 } 63 } 64 65 if cfg.Difficulty == nil { 66 cfg.Difficulty = new(big.Int) 67 } 68 if cfg.Time == nil { 69 cfg.Time = big.NewInt(time.Now().Unix()) 70 } 71 if cfg.GasLimit == 0 { 72 cfg.GasLimit = math.MaxUint64 73 } 74 if cfg.GasPrice == nil { 75 cfg.GasPrice = new(big.Int) 76 } 77 if cfg.Value == nil { 78 cfg.Value = new(big.Int) 79 } 80 if cfg.BlockNumber == nil { 81 cfg.BlockNumber = new(big.Int) 82 } 83 if cfg.GetHashFn == nil { 84 cfg.GetHashFn = func(n uint64) common.Hash { 85 return common.BytesToHash(crypto.Keccak256([]byte(new(big.Int).SetUint64(n).String()))) 86 } 87 } 88 } 89 90 // Execute executes the code using the input as call data during the execution. 91 // It returns the EVM's return value, the new state and an error if it failed. 92 // 93 // Executes sets up a in memory, temporarily, environment for the execution of 94 // the given code. It makes sure that it's restored to it's original state afterwards. 95 func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) { 96 if cfg == nil { 97 cfg = new(Config) 98 } 99 setDefaults(cfg) 100 101 if cfg.State == nil { 102 db, _ := ethdb.NewMemDatabase() 103 cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(db)) 104 } 105 var ( 106 address = common.BytesToAddress([]byte("contract")) 107 vmenv = NewEnv(cfg) 108 sender = vm.AccountRef(cfg.Origin) 109 ) 110 cfg.State.CreateAccount(address) 111 // set the receiver's (the executing contract) code for execution. 112 cfg.State.SetCode(address, code) 113 // Call the code with the given configuration. 114 ret, _, err := vmenv.Call( 115 sender, 116 common.BytesToAddress([]byte("contract")), 117 input, 118 cfg.GasLimit, 119 cfg.Value, 120 ) 121 122 return ret, cfg.State, err 123 } 124 125 // Create executes the code using the EVM create method 126 func Create(input []byte, cfg *Config) ([]byte, common.Address, uint64, error) { 127 if cfg == nil { 128 cfg = new(Config) 129 } 130 setDefaults(cfg) 131 132 if cfg.State == nil { 133 db, _ := ethdb.NewMemDatabase() 134 cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(db)) 135 } 136 var ( 137 vmenv = NewEnv(cfg) 138 sender = vm.AccountRef(cfg.Origin) 139 ) 140 141 // Call the code with the given configuration. 142 code, address, leftOverGas, err := vmenv.Create( 143 sender, 144 input, 145 cfg.GasLimit, 146 cfg.Value, 147 ) 148 return code, address, leftOverGas, err 149 } 150 151 // Call executes the code given by the contract's address. It will return the 152 // EVM's return value or an error if it failed. 153 // 154 // Call, unlike Execute, requires a config and also requires the State field to 155 // be set. 156 func Call(address common.Address, input []byte, cfg *Config) ([]byte, uint64, error) { 157 setDefaults(cfg) 158 159 vmenv := NewEnv(cfg) 160 161 sender := cfg.State.GetOrNewStateObject(cfg.Origin) 162 // Call the code with the given configuration. 163 ret, leftOverGas, err := vmenv.Call( 164 sender, 165 address, 166 input, 167 cfg.GasLimit, 168 cfg.Value, 169 ) 170 171 return ret, leftOverGas, err 172 }