github.com/tenderly/bsc@v1.0.7/core/vm/runtime/runtime_test.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/big" 21 "strings" 22 "testing" 23 24 "github.com/tenderly/bsc/accounts/abi" 25 "github.com/tenderly/bsc/common" 26 "github.com/tenderly/bsc/consensus" 27 "github.com/tenderly/bsc/core" 28 "github.com/tenderly/bsc/core/rawdb" 29 "github.com/tenderly/bsc/core/state" 30 "github.com/tenderly/bsc/core/types" 31 "github.com/tenderly/bsc/core/vm" 32 "github.com/tenderly/bsc/params" 33 ) 34 35 func TestDefaults(t *testing.T) { 36 cfg := new(Config) 37 setDefaults(cfg) 38 39 if cfg.Difficulty == nil { 40 t.Error("expected difficulty to be non nil") 41 } 42 43 if cfg.Time == nil { 44 t.Error("expected time to be non nil") 45 } 46 if cfg.GasLimit == 0 { 47 t.Error("didn't expect gaslimit to be zero") 48 } 49 if cfg.GasPrice == nil { 50 t.Error("expected time to be non nil") 51 } 52 if cfg.Value == nil { 53 t.Error("expected time to be non nil") 54 } 55 if cfg.GetHashFn == nil { 56 t.Error("expected time to be non nil") 57 } 58 if cfg.BlockNumber == nil { 59 t.Error("expected block number to be non nil") 60 } 61 } 62 63 func TestEVM(t *testing.T) { 64 defer func() { 65 if r := recover(); r != nil { 66 t.Fatalf("crashed with: %v", r) 67 } 68 }() 69 70 Execute([]byte{ 71 byte(vm.DIFFICULTY), 72 byte(vm.TIMESTAMP), 73 byte(vm.GASLIMIT), 74 byte(vm.PUSH1), 75 byte(vm.ORIGIN), 76 byte(vm.BLOCKHASH), 77 byte(vm.COINBASE), 78 }, nil, nil) 79 } 80 81 func TestExecute(t *testing.T) { 82 ret, _, err := Execute([]byte{ 83 byte(vm.PUSH1), 10, 84 byte(vm.PUSH1), 0, 85 byte(vm.MSTORE), 86 byte(vm.PUSH1), 32, 87 byte(vm.PUSH1), 0, 88 byte(vm.RETURN), 89 }, nil, nil) 90 if err != nil { 91 t.Fatal("didn't expect error", err) 92 } 93 94 num := new(big.Int).SetBytes(ret) 95 if num.Cmp(big.NewInt(10)) != 0 { 96 t.Error("Expected 10, got", num) 97 } 98 } 99 100 func TestCall(t *testing.T) { 101 state, _ := state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil) 102 address := common.HexToAddress("0x0a") 103 state.SetCode(address, []byte{ 104 byte(vm.PUSH1), 10, 105 byte(vm.PUSH1), 0, 106 byte(vm.MSTORE), 107 byte(vm.PUSH1), 32, 108 byte(vm.PUSH1), 0, 109 byte(vm.RETURN), 110 }) 111 112 ret, _, err := Call(address, nil, &Config{State: state}) 113 if err != nil { 114 t.Fatal("didn't expect error", err) 115 } 116 117 num := new(big.Int).SetBytes(ret) 118 if num.Cmp(big.NewInt(10)) != 0 { 119 t.Error("Expected 10, got", num) 120 } 121 } 122 123 func BenchmarkCall(b *testing.B) { 124 var definition = `[{"constant":true,"inputs":[],"name":"seller","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":false,"inputs":[],"name":"abort","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"value","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[],"name":"refund","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"buyer","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":false,"inputs":[],"name":"confirmReceived","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"state","outputs":[{"name":"","type":"uint8"}],"type":"function"},{"constant":false,"inputs":[],"name":"confirmPurchase","outputs":[],"type":"function"},{"inputs":[],"type":"constructor"},{"anonymous":false,"inputs":[],"name":"Aborted","type":"event"},{"anonymous":false,"inputs":[],"name":"PurchaseConfirmed","type":"event"},{"anonymous":false,"inputs":[],"name":"ItemReceived","type":"event"},{"anonymous":false,"inputs":[],"name":"Refunded","type":"event"}]` 125 126 var code = common.Hex2Bytes("6060604052361561006c5760e060020a600035046308551a53811461007457806335a063b4146100865780633fa4f245146100a6578063590e1ae3146100af5780637150d8ae146100cf57806373fac6f0146100e1578063c19d93fb146100fe578063d696069714610112575b610131610002565b610133600154600160a060020a031681565b610131600154600160a060020a0390811633919091161461015057610002565b61014660005481565b610131600154600160a060020a039081163391909116146102d557610002565b610133600254600160a060020a031681565b610131600254600160a060020a0333811691161461023757610002565b61014660025460ff60a060020a9091041681565b61013160025460009060ff60a060020a9091041681146101cc57610002565b005b600160a060020a03166060908152602090f35b6060908152602090f35b60025460009060a060020a900460ff16811461016b57610002565b600154600160a060020a03908116908290301631606082818181858883f150506002805460a060020a60ff02191660a160020a179055506040517f72c874aeff0b183a56e2b79c71b46e1aed4dee5e09862134b8821ba2fddbf8bf9250a150565b80546002023414806101dd57610002565b6002805460a060020a60ff021973ffffffffffffffffffffffffffffffffffffffff1990911633171660a060020a1790557fd5d55c8a68912e9a110618df8d5e2e83b8d83211c57a8ddd1203df92885dc881826060a15050565b60025460019060a060020a900460ff16811461025257610002565b60025460008054600160a060020a0390921691606082818181858883f150508354604051600160a060020a0391821694503090911631915082818181858883f150506002805460a060020a60ff02191660a160020a179055506040517fe89152acd703c9d8c7d28829d443260b411454d45394e7995815140c8cbcbcf79250a150565b60025460019060a060020a900460ff1681146102f057610002565b6002805460008054600160a060020a0390921692909102606082818181858883f150508354604051600160a060020a0391821694503090911631915082818181858883f150506002805460a060020a60ff02191660a160020a179055506040517f8616bbbbad963e4e65b1366f1d75dfb63f9e9704bbbf91fb01bec70849906cf79250a15056") 127 128 abi, err := abi.JSON(strings.NewReader(definition)) 129 if err != nil { 130 b.Fatal(err) 131 } 132 133 cpurchase, err := abi.Pack("confirmPurchase") 134 if err != nil { 135 b.Fatal(err) 136 } 137 creceived, err := abi.Pack("confirmReceived") 138 if err != nil { 139 b.Fatal(err) 140 } 141 refund, err := abi.Pack("refund") 142 if err != nil { 143 b.Fatal(err) 144 } 145 146 b.ResetTimer() 147 for i := 0; i < b.N; i++ { 148 for j := 0; j < 400; j++ { 149 Execute(code, cpurchase, nil) 150 Execute(code, creceived, nil) 151 Execute(code, refund, nil) 152 } 153 } 154 } 155 func benchmarkEVM_Create(bench *testing.B, code string) { 156 var ( 157 statedb, _ = state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil) 158 sender = common.BytesToAddress([]byte("sender")) 159 receiver = common.BytesToAddress([]byte("receiver")) 160 ) 161 162 statedb.CreateAccount(sender) 163 statedb.SetCode(receiver, common.FromHex(code)) 164 runtimeConfig := Config{ 165 Origin: sender, 166 State: statedb, 167 GasLimit: 10000000, 168 Difficulty: big.NewInt(0x200000), 169 Time: new(big.Int).SetUint64(0), 170 Coinbase: common.Address{}, 171 BlockNumber: new(big.Int).SetUint64(1), 172 ChainConfig: ¶ms.ChainConfig{ 173 ChainID: big.NewInt(1), 174 HomesteadBlock: new(big.Int), 175 ByzantiumBlock: new(big.Int), 176 ConstantinopleBlock: new(big.Int), 177 DAOForkBlock: new(big.Int), 178 DAOForkSupport: false, 179 EIP150Block: new(big.Int), 180 EIP155Block: new(big.Int), 181 EIP158Block: new(big.Int), 182 }, 183 EVMConfig: vm.Config{}, 184 } 185 // Warm up the intpools and stuff 186 bench.ResetTimer() 187 for i := 0; i < bench.N; i++ { 188 Call(receiver, []byte{}, &runtimeConfig) 189 } 190 bench.StopTimer() 191 } 192 193 func BenchmarkEVM_CREATE_500(bench *testing.B) { 194 // initcode size 500K, repeatedly calls CREATE and then modifies the mem contents 195 benchmarkEVM_Create(bench, "5b6207a120600080f0600152600056") 196 } 197 func BenchmarkEVM_CREATE2_500(bench *testing.B) { 198 // initcode size 500K, repeatedly calls CREATE2 and then modifies the mem contents 199 benchmarkEVM_Create(bench, "5b586207a120600080f5600152600056") 200 } 201 func BenchmarkEVM_CREATE_1200(bench *testing.B) { 202 // initcode size 1200K, repeatedly calls CREATE and then modifies the mem contents 203 benchmarkEVM_Create(bench, "5b62124f80600080f0600152600056") 204 } 205 func BenchmarkEVM_CREATE2_1200(bench *testing.B) { 206 // initcode size 1200K, repeatedly calls CREATE2 and then modifies the mem contents 207 benchmarkEVM_Create(bench, "5b5862124f80600080f5600152600056") 208 } 209 210 func fakeHeader(n uint64, parentHash common.Hash) *types.Header { 211 header := types.Header{ 212 Coinbase: common.HexToAddress("0x00000000000000000000000000000000deadbeef"), 213 Number: big.NewInt(int64(n)), 214 ParentHash: parentHash, 215 Time: 1000, 216 Nonce: types.BlockNonce{0x1}, 217 Extra: []byte{}, 218 Difficulty: big.NewInt(0), 219 GasLimit: 100000, 220 } 221 return &header 222 } 223 224 type dummyChain struct { 225 counter int 226 } 227 228 // Engine retrieves the chain's consensus engine. 229 func (d *dummyChain) Engine() consensus.Engine { 230 return nil 231 } 232 233 // GetHeader returns the hash corresponding to their hash. 234 func (d *dummyChain) GetHeader(h common.Hash, n uint64) *types.Header { 235 d.counter++ 236 parentHash := common.Hash{} 237 s := common.LeftPadBytes(big.NewInt(int64(n-1)).Bytes(), 32) 238 copy(parentHash[:], s) 239 240 //parentHash := common.Hash{byte(n - 1)} 241 //fmt.Printf("GetHeader(%x, %d) => header with parent %x\n", h, n, parentHash) 242 return fakeHeader(n, parentHash) 243 } 244 245 // TestBlockhash tests the blockhash operation. It's a bit special, since it internally 246 // requires access to a chain reader. 247 func TestBlockhash(t *testing.T) { 248 // Current head 249 n := uint64(1000) 250 parentHash := common.Hash{} 251 s := common.LeftPadBytes(big.NewInt(int64(n-1)).Bytes(), 32) 252 copy(parentHash[:], s) 253 header := fakeHeader(n, parentHash) 254 255 // This is the contract we're using. It requests the blockhash for current num (should be all zeroes), 256 // then iteratively fetches all blockhashes back to n-260. 257 // It returns 258 // 1. the first (should be zero) 259 // 2. the second (should be the parent hash) 260 // 3. the last non-zero hash 261 // By making the chain reader return hashes which correlate to the number, we can 262 // verify that it obtained the right hashes where it should 263 264 /* 265 266 pragma solidity ^0.5.3; 267 contract Hasher{ 268 269 function test() public view returns (bytes32, bytes32, bytes32){ 270 uint256 x = block.number; 271 bytes32 first; 272 bytes32 last; 273 bytes32 zero; 274 zero = blockhash(x); // Should be zeroes 275 first = blockhash(x-1); 276 for(uint256 i = 2 ; i < 260; i++){ 277 bytes32 hash = blockhash(x - i); 278 if (uint256(hash) != 0){ 279 last = hash; 280 } 281 } 282 return (zero, first, last); 283 } 284 } 285 286 */ 287 // The contract above 288 data := common.Hex2Bytes("6080604052348015600f57600080fd5b50600436106045576000357c010000000000000000000000000000000000000000000000000000000090048063f8a8fd6d14604a575b600080fd5b60506074565b60405180848152602001838152602001828152602001935050505060405180910390f35b600080600080439050600080600083409050600184034092506000600290505b61010481101560c35760008186034090506000816001900414151560b6578093505b5080806001019150506094565b508083839650965096505050505090919256fea165627a7a72305820462d71b510c1725ff35946c20b415b0d50b468ea157c8c77dff9466c9cb85f560029") 289 // The method call to 'test()' 290 input := common.Hex2Bytes("f8a8fd6d") 291 chain := &dummyChain{} 292 ret, _, err := Execute(data, input, &Config{ 293 GetHashFn: core.GetHashFn(header, chain), 294 BlockNumber: new(big.Int).Set(header.Number), 295 }) 296 if err != nil { 297 t.Fatalf("expected no error, got %v", err) 298 } 299 if len(ret) != 96 { 300 t.Fatalf("expected returndata to be 96 bytes, got %d", len(ret)) 301 } 302 303 zero := new(big.Int).SetBytes(ret[0:32]) 304 first := new(big.Int).SetBytes(ret[32:64]) 305 last := new(big.Int).SetBytes(ret[64:96]) 306 if zero.BitLen() != 0 { 307 t.Fatalf("expected zeroes, got %x", ret[0:32]) 308 } 309 if first.Uint64() != 999 { 310 t.Fatalf("second block should be 999, got %d (%x)", first, ret[32:64]) 311 } 312 if last.Uint64() != 744 { 313 t.Fatalf("last block should be 744, got %d (%x)", last, ret[64:96]) 314 } 315 if exp, got := 255, chain.counter; exp != got { 316 t.Errorf("suboptimal; too much chain iteration, expected %d, got %d", exp, got) 317 } 318 } 319 320 // BenchmarkSimpleLoop test a pretty simple loop which loops 321 // 1M (1 048 575) times. 322 // Takes about 200 ms 323 func BenchmarkSimpleLoop(b *testing.B) { 324 // 0xfffff = 1048575 loops 325 code := []byte{ 326 byte(vm.PUSH3), 0x0f, 0xff, 0xff, 327 byte(vm.JUMPDEST), // [ count ] 328 byte(vm.PUSH1), 1, // [count, 1] 329 byte(vm.SWAP1), // [1, count] 330 byte(vm.SUB), // [ count -1 ] 331 byte(vm.DUP1), // [ count -1 , count-1] 332 byte(vm.PUSH1), 4, // [count-1, count -1, label] 333 byte(vm.JUMPI), // [ 0 ] 334 byte(vm.STOP), 335 } 336 //tracer := vm.NewJSONLogger(nil, os.Stdout) 337 //Execute(code, nil, &Config{ 338 // EVMConfig: vm.Config{ 339 // Debug: true, 340 // Tracer: tracer, 341 // }}) 342 343 for i := 0; i < b.N; i++ { 344 Execute(code, nil, nil) 345 } 346 }