func TestBrokenChain(t *testing.T) { db, err := ethdb.NewMemDatabase() if err != nil { t.Fatal("Failed to create db:", err) } bman, err := newCanonical(10, db) if err != nil { t.Fatal("Could not make new canonical chain:", err) } db2, err := ethdb.NewMemDatabase() if err != nil { t.Fatal("Failed to create db:", err) } bman2, err := newCanonical(10, db2) if err != nil { t.Fatal("Could not make new canonical chain:", err) } bman2.bc.SetProcessor(bman2) parent := bman2.bc.CurrentBlock() chainB := makeChain(parent, 5, db2, forkSeed) chainB = chainB[1:] _, err = testChain(chainB, bman) if err == nil { t.Error("expected broken chain to return error") } }
// Tests that no intermediate state of an object is stored into the database, // only the one right before the commit. func TestIntermediateLeaks(t *testing.T) { // Create two state databases, one transitioning to the final state, the other final from the beginning transDb, _ := ethdb.NewMemDatabase() finalDb, _ := ethdb.NewMemDatabase() transState, _ := New(common.Hash{}, transDb) finalState, _ := New(common.Hash{}, finalDb) modify := func(state *StateDB, addr common.Address, i, tweak byte) { state.SetBalance(addr, big.NewInt(int64(11*i)+int64(tweak))) state.SetNonce(addr, uint64(42*i+tweak)) if i%2 == 0 { state.SetState(addr, common.Hash{i, i, i, 0}, common.Hash{}) state.SetState(addr, common.Hash{i, i, i, tweak}, common.Hash{i, i, i, i, tweak}) } if i%3 == 0 { state.SetCode(addr, []byte{i, i, i, i, i, tweak}) } } // Modify the transient state. for i := byte(0); i < 255; i++ { modify(transState, common.Address{byte(i)}, i, 0) } // Write modifications to trie. transState.IntermediateRoot() // Overwrite all the data with new values in the transient database. for i := byte(0); i < 255; i++ { modify(transState, common.Address{byte(i)}, i, 99) modify(finalState, common.Address{byte(i)}, i, 99) } // Commit and cross check the databases. if _, err := transState.Commit(); err != nil { t.Fatalf("failed to commit transition state: %v", err) } if _, err := finalState.Commit(); err != nil { t.Fatalf("failed to commit final state: %v", err) } for _, key := range finalDb.Keys() { if _, err := transDb.Get(key); err != nil { val, _ := finalDb.Get(key) t.Errorf("entry missing from the transition database: %x -> %x", key, val) } } for _, key := range transDb.Keys() { if _, err := finalDb.Get(key); err != nil { val, _ := transDb.Get(key) t.Errorf("extra entry in the transition database: %x -> %x", key, val) } } }
func TestTransactionDoubleNonce(t *testing.T) { pool, key := setupTxPool() addr := crypto.PubkeyToAddress(key.PublicKey) resetState := func() { db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, db) pool.currentState = func() (*state.StateDB, error) { return statedb, nil } currentState, _ := pool.currentState() currentState.AddBalance(addr, big.NewInt(100000000000000)) pool.resetState() } resetState() tx := transaction(0, big.NewInt(100000), key) tx2 := transaction(0, big.NewInt(1000000), key) if err := pool.add(tx); err != nil { t.Error("didn't expect error", err) } if err := pool.add(tx2); err != nil { t.Error("didn't expect error", err) } pool.checkQueue() if len(pool.pending) != 2 { t.Error("expected 2 pending txs. Got", len(pool.pending)) } }
func runVmBench(test vmBench, b *testing.B) { db, _ := ethdb.NewMemDatabase() sender := state.NewStateObject(common.Address{}, db) if test.precompile && !test.forcejit { NewProgram(test.code) } env := NewEnv() EnableJit = !test.nojit ForceJit = test.forcejit b.ResetTimer() for i := 0; i < b.N; i++ { context := NewContext(sender, sender, big.NewInt(100), big.NewInt(10000), big.NewInt(0)) context.Code = test.code context.CodeAddr = &common.Address{} _, err := New(env).Run(context, test.input) if err != nil { b.Error(err) b.FailNow() } } }
// Tests that a trie sync will not request nodes multiple times, even if they // have such references. func TestDuplicateAvoidanceTrieSync(t *testing.T) { // Create a random trie to copy srcDb, srcTrie, srcData := makeTestTrie() // Create a destination trie and sync with the scheduler dstDb, _ := ethdb.NewMemDatabase() sched := NewTrieSync(common.BytesToHash(srcTrie.Root()), dstDb, nil) queue := append([]common.Hash{}, sched.Missing(0)...) requested := make(map[common.Hash]struct{}) for len(queue) > 0 { results := make([]SyncResult, len(queue)) for i, hash := range queue { data, err := srcDb.Get(hash.Bytes()) if err != nil { t.Fatalf("failed to retrieve node data for %x: %v", hash, err) } if _, ok := requested[hash]; ok { t.Errorf("hash %x already requested once", hash) } requested[hash] = struct{}{} results[i] = SyncResult{hash, data} } if index, err := sched.Process(results); err != nil { t.Fatalf("failed to process result #%d: %v", index, err) } queue = append(queue[:0], sched.Missing(0)...) } // Cross check that the two tries re in sync checkTrieContents(t, dstDb, srcTrie.Root(), srcData) }
// Execute executes the code using the input as call data during the execution. // It returns the EVM's return value, the new state and an error if it failed. // // Executes sets up a in memory, temporarily, environment for the execution of // the given code. It enabled the JIT by default and make sure that it's restored // to it's original state afterwards. func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) { if cfg == nil { cfg = new(Config) } setDefaults(cfg) if cfg.State == nil { db, _ := ethdb.NewMemDatabase() cfg.State, _ = state.New(common.Hash{}, db) } var ( vmenv = NewEnv(cfg, cfg.State) sender = cfg.State.CreateAccount(cfg.Origin) receiver = cfg.State.CreateAccount(common.StringToAddress("contract")) ) // set the receiver's (the executing contract) code for execution. receiver.SetCode(crypto.Keccak256Hash(code), code) // Call the code with the given configuration. ret, err := vmenv.Call( sender, receiver.Address(), input, cfg.GasLimit, cfg.GasPrice, cfg.Value, ) return ret, cfg.State, err }
// Tests that the trie scheduler can correctly reconstruct the state even if only // partial results are returned, and the others sent only later. func TestIterativeDelayedStateSync(t *testing.T) { // Create a random state to copy srcDb, srcRoot, srcAccounts := makeTestState() // Create a destination state and sync with the scheduler dstDb, _ := ethdb.NewMemDatabase() sched := NewStateSync(srcRoot, dstDb) queue := append([]common.Hash{}, sched.Missing(0)...) for len(queue) > 0 { // Sync only half of the scheduled nodes results := make([]trie.SyncResult, len(queue)/2+1) for i, hash := range queue[:len(results)] { data, err := srcDb.Get(hash.Bytes()) if err != nil { t.Fatalf("failed to retrieve node data for %x: %v", hash, err) } results[i] = trie.SyncResult{Hash: hash, Data: data} } if index, err := sched.Process(results); err != nil { t.Fatalf("failed to process result #%d: %v", index, err) } queue = append(queue[len(results):], sched.Missing(0)...) } // Cross check that the two states are in sync checkStateAccounts(t, dstDb, srcRoot, srcAccounts) }
func testIterativeRandomStateSync(t *testing.T, batch int) { // Create a random state to copy srcDb, srcRoot, srcAccounts := makeTestState() // Create a destination state and sync with the scheduler dstDb, _ := ethdb.NewMemDatabase() sched := NewStateSync(srcRoot, dstDb) queue := make(map[common.Hash]struct{}) for _, hash := range sched.Missing(batch) { queue[hash] = struct{}{} } for len(queue) > 0 { // Fetch all the queued nodes in a random order results := make([]trie.SyncResult, 0, len(queue)) for hash, _ := range queue { data, err := srcDb.Get(hash.Bytes()) if err != nil { t.Fatalf("failed to retrieve node data for %x: %v", hash, err) } results = append(results, trie.SyncResult{Hash: hash, Data: data}) } // Feed the retrieved results back and queue new tasks if index, err := sched.Process(results); err != nil { t.Fatalf("failed to process result #%d: %v", index, err) } queue = make(map[common.Hash]struct{}) for _, hash := range sched.Missing(batch) { queue[hash] = struct{}{} } } // Cross check that the two states are in sync checkStateAccounts(t, dstDb, srcRoot, srcAccounts) }
// Tests block header storage and retrieval operations. func TestHeaderStorage(t *testing.T) { db, _ := ethdb.NewMemDatabase() // Create a test header to move around the database and make sure it's really new header := &types.Header{Extra: []byte("test header")} if entry := GetHeader(db, header.Hash()); entry != nil { t.Fatalf("Non existent header returned: %v", entry) } // Write and verify the header in the database if err := WriteHeader(db, header); err != nil { t.Fatalf("Failed to write header into database: %v", err) } if entry := GetHeader(db, header.Hash()); entry == nil { t.Fatalf("Stored header not found") } else if entry.Hash() != header.Hash() { t.Fatalf("Retrieved header mismatch: have %v, want %v", entry, header) } if entry := GetHeaderRLP(db, header.Hash()); entry == nil { t.Fatalf("Stored header RLP not found") } else { hasher := sha3.NewKeccak256() hasher.Write(entry) if hash := common.BytesToHash(hasher.Sum(nil)); hash != header.Hash() { t.Fatalf("Retrieved RLP header mismatch: have %v, want %v", entry, header) } } // Delete the header and verify the execution DeleteHeader(db, header.Hash()) if entry := GetHeader(db, header.Hash()); entry != nil { t.Fatalf("Deleted header returned: %v", entry) } }
// Tests that an empty state is not scheduled for syncing. func TestEmptyStateSync(t *testing.T) { empty := common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421") db, _ := ethdb.NewMemDatabase() if req := NewStateSync(empty, db).Missing(1); len(req) != 0 { t.Errorf("content requested for empty state: %v", req) } }
func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) { // Create the database in memory or in a temporary directory. var db ethdb.Database if !disk { db, _ = ethdb.NewMemDatabase() } else { dir, err := ioutil.TempDir("", "exp-core-bench") if err != nil { b.Fatalf("cannot create temporary directory: %v", err) } defer os.RemoveAll(dir) db, err = ethdb.NewLDBDatabase(dir, 0) if err != nil { b.Fatalf("cannot create temporary database: %v", err) } defer db.Close() } // Generate a chain of b.N blocks using the supplied block // generator function. genesis := WriteGenesisBlockForTesting(db, GenesisAccount{benchRootAddr, benchRootFunds}) chain, _ := GenerateChain(genesis, db, b.N, gen) // Time the insertion of the new chain. // State and blocks are stored in the same DB. evmux := new(event.TypeMux) chainman, _ := NewBlockChain(db, FakePow{}, evmux) defer chainman.Stop() b.ReportAllocs() b.ResetTimer() if i, err := chainman.InsertChain(chain); err != nil { b.Fatalf("insert error (block %d): %v\n", i, err) } }
func TestLightStateDelete(t *testing.T) { root, sdb := makeTestState() ldb, _ := ethdb.NewMemDatabase() odr := &testOdr{sdb: sdb, ldb: ldb} ls := NewLightState(root, odr) ctx := context.Background() addr := common.Address{42} b, err := ls.HasAccount(ctx, addr) if err != nil { t.Fatalf("HasAccount error: %v", err) } if !b { t.Fatalf("HasAccount returned false, expected true") } b, err = ls.IsDeleted(ctx, addr) if err != nil { t.Fatalf("IsDeleted error: %v", err) } if b { t.Fatalf("IsDeleted returned true, expected false") } ls.Delete(ctx, addr) b, err = ls.IsDeleted(ctx, addr) if err != nil { t.Fatalf("IsDeleted error: %v", err) } if !b { t.Fatalf("IsDeleted returned false, expected true") } }
func TestTransactionChainFork(t *testing.T) { pool, key := setupTxPool() addr := crypto.PubkeyToAddress(key.PublicKey) resetState := func() { db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, db) pool.currentState = func() (*state.StateDB, error) { return statedb, nil } currentState, _ := pool.currentState() currentState.AddBalance(addr, big.NewInt(100000000000000)) pool.resetState() } resetState() tx := transaction(0, big.NewInt(100000), key) if err := pool.add(tx); err != nil { t.Error("didn't expect error", err) } pool.RemoveTransactions([]*types.Transaction{tx}) // reset the pool's internal state resetState() if err := pool.add(tx); err != nil { t.Error("didn't expect error", err) } }
func TestPutReceipt(t *testing.T) { db, _ := ethdb.NewMemDatabase() var addr common.Address addr[0] = 1 var hash common.Hash hash[0] = 2 receipt := new(types.Receipt) receipt.Logs = vm.Logs{&vm.Log{ Address: addr, Topics: []common.Hash{hash}, Data: []byte("hi"), BlockNumber: 42, TxHash: hash, TxIndex: 0, BlockHash: hash, Index: 0, }} WriteReceipts(db, types.Receipts{receipt}) receipt = GetReceipt(db, common.Hash{}) if receipt == nil { t.Error("expected to get 1 receipt, got none.") } }
// makeTestState create a sample test state to test node-wise reconstruction. func makeTestState() (ethdb.Database, common.Hash, []*testAccount) { // Create an empty state db, _ := ethdb.NewMemDatabase() state, _ := New(common.Hash{}, db) // Fill it with some arbitrary data accounts := []*testAccount{} for i := byte(0); i < 96; i++ { obj := state.GetOrNewStateObject(common.BytesToAddress([]byte{i})) acc := &testAccount{address: common.BytesToAddress([]byte{i})} obj.AddBalance(big.NewInt(int64(11 * i))) acc.balance = big.NewInt(int64(11 * i)) obj.SetNonce(uint64(42 * i)) acc.nonce = uint64(42 * i) if i%3 == 0 { obj.SetCode(crypto.Keccak256Hash([]byte{i, i, i, i, i}), []byte{i, i, i, i, i}) acc.code = []byte{i, i, i, i, i} } state.updateStateObject(obj) accounts = append(accounts, acc) } root, _ := state.Commit() // Return the generated state return db, root, accounts }
func testIterativeTrieSync(t *testing.T, batch int) { // Create a random trie to copy srcDb, srcTrie, srcData := makeTestTrie() // Create a destination trie and sync with the scheduler dstDb, _ := ethdb.NewMemDatabase() sched := NewTrieSync(common.BytesToHash(srcTrie.Root()), dstDb, nil) queue := append([]common.Hash{}, sched.Missing(batch)...) for len(queue) > 0 { results := make([]SyncResult, len(queue)) for i, hash := range queue { data, err := srcDb.Get(hash.Bytes()) if err != nil { t.Fatalf("failed to retrieve node data for %x: %v", hash, err) } results[i] = SyncResult{hash, data} } if index, err := sched.Process(results); err != nil { t.Fatalf("failed to process result #%d: %v", index, err) } queue = append(queue[:0], sched.Missing(batch)...) } // Cross check that the two tries re in sync checkTrieContents(t, dstDb, srcTrie.Root(), srcData) }
func testIterativeRandomTrieSync(t *testing.T, batch int) { // Create a random trie to copy srcDb, srcTrie, srcData := makeTestTrie() // Create a destination trie and sync with the scheduler dstDb, _ := ethdb.NewMemDatabase() sched := NewTrieSync(common.BytesToHash(srcTrie.Root()), dstDb, nil) queue := make(map[common.Hash]struct{}) for _, hash := range sched.Missing(batch) { queue[hash] = struct{}{} } for len(queue) > 0 { // Fetch all the queued nodes in a random order results := make([]SyncResult, 0, len(queue)) for hash, _ := range queue { data, err := srcDb.Get(hash.Bytes()) if err != nil { t.Fatalf("failed to retrieve node data for %x: %v", hash, err) } results = append(results, SyncResult{hash, data}) } // Feed the retrieved results back and queue new tasks if index, err := sched.Process(results); err != nil { t.Fatalf("failed to process result #%d: %v", index, err) } queue = make(map[common.Hash]struct{}) for _, hash := range sched.Missing(batch) { queue[hash] = struct{}{} } } // Cross check that the two tries re in sync checkTrieContents(t, dstDb, srcTrie.Root(), srcData) }
func (test *snapshotTest) run() bool { // Run all actions and create snapshots. var ( db, _ = ethdb.NewMemDatabase() state, _ = New(common.Hash{}, db) snapshotRevs = make([]int, len(test.snapshots)) sindex = 0 ) for i, action := range test.actions { if len(test.snapshots) > sindex && i == test.snapshots[sindex] { snapshotRevs[sindex] = state.Snapshot() sindex++ } action.fn(action, state) } // Revert all snapshots in reverse order. Each revert must yield a state // that is equivalent to fresh state with all actions up the snapshot applied. for sindex--; sindex >= 0; sindex-- { checkstate, _ := New(common.Hash{}, db) for _, action := range test.actions[:test.snapshots[sindex]] { action.fn(action, checkstate) } state.RevertToSnapshot(snapshotRevs[sindex]) if err := test.checkEqual(state, checkstate); err != nil { test.err = fmt.Errorf("state mismatch after revert to snapshot %d\n%v", sindex, err) return false } } return true }
// makeTestSecureTrie creates a large enough secure trie for testing. func makeTestSecureTrie() (ethdb.Database, *SecureTrie, map[string][]byte) { // Create an empty trie db, _ := ethdb.NewMemDatabase() trie, _ := NewSecure(common.Hash{}, db) // Fill it with some arbitrary data content := make(map[string][]byte) for i := byte(0); i < 255; i++ { // Map the same data under multiple keys key, val := common.LeftPadBytes([]byte{1, i}, 32), []byte{i} content[string(key)] = val trie.Update(key, val) key, val = common.LeftPadBytes([]byte{2, i}, 32), []byte{i} content[string(key)] = val trie.Update(key, val) // Add some other data to inflate th trie for j := byte(3); j < 13; j++ { key, val = common.LeftPadBytes([]byte{j, i}, 32), []byte{j, i} content[string(key)] = val trie.Update(key, val) } } trie.Commit() // Return the generated trie return db, trie, content }
// Tests that at any point in time during a sync, only complete sub-tries are in // the database. func TestIncompleteStateSync(t *testing.T) { // Create a random state to copy srcDb, srcRoot, srcAccounts := makeTestState() // Create a destination state and sync with the scheduler dstDb, _ := ethdb.NewMemDatabase() sched := NewStateSync(srcRoot, dstDb) added := []common.Hash{} queue := append([]common.Hash{}, sched.Missing(1)...) for len(queue) > 0 { // Fetch a batch of state nodes results := make([]trie.SyncResult, len(queue)) for i, hash := range queue { data, err := srcDb.Get(hash.Bytes()) if err != nil { t.Fatalf("failed to retrieve node data for %x: %v", hash, err) } results[i] = trie.SyncResult{Hash: hash, Data: data} } // Process each of the state nodes if index, err := sched.Process(results); err != nil { t.Fatalf("failed to process result #%d: %v", index, err) } for _, result := range results { added = append(added, result.Hash) } // Check that all known sub-tries in the synced state is complete for _, root := range added { // Skim through the accounts and make sure the root hash is not a code node codeHash := false for _, acc := range srcAccounts { if bytes.Compare(root.Bytes(), crypto.Sha3(acc.code)) == 0 { codeHash = true break } } // If the root is a real trie node, check consistency if !codeHash { if err := checkStateConsistency(dstDb, root); err != nil { t.Fatalf("state inconsistent: %v", err) } } } // Fetch the next batch to retrieve queue = append(queue[:0], sched.Missing(1)...) } // Sanity check that removing any node from the database is detected for _, node := range added[1:] { key := node.Bytes() value, _ := dstDb.Get(key) dstDb.Delete(key) if err := checkStateConsistency(dstDb, added[0]); err == nil { t.Fatalf("trie inconsistency not caught, missing: %x", key) } dstDb.Put(key, value) } }
func benchStateTest(ruleSet RuleSet, test VmTest, env map[string]string, b *testing.B) { b.StopTimer() db, _ := ethdb.NewMemDatabase() statedb := makePreState(db, test.Pre) b.StartTimer() RunState(ruleSet, statedb, env, test.Exec) }
func create() (*ManagedState, *account) { db, _ := ethdb.NewMemDatabase() statedb, _ := New(common.Hash{}, db) ms := ManageState(statedb) ms.StateDB.SetNonce(addr, 100) ms.accounts[addr] = newAccount(ms.StateDB.GetStateObject(addr)) return ms, ms.accounts[addr] }
func setupTxPool() (*TxPool, *ecdsa.PrivateKey) { db, _ := ethdb.NewMemDatabase() statedb := state.New(common.Hash{}, db) var m event.TypeMux key, _ := crypto.GenerateKey() return NewTxPool(&m, func() *state.StateDB { return statedb }, func() *big.Int { return big.NewInt(1000000) }), key }
// Tests that receipts can be stored and retrieved. func TestReceiptStorage(t *testing.T) { db, _ := ethdb.NewMemDatabase() receipt1 := &types.Receipt{ PostState: []byte{0x01}, CumulativeGasUsed: big.NewInt(1), Logs: vm.Logs{ &vm.Log{Address: common.BytesToAddress([]byte{0x11})}, &vm.Log{Address: common.BytesToAddress([]byte{0x01, 0x11})}, }, TxHash: common.BytesToHash([]byte{0x11, 0x11}), ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), GasUsed: big.NewInt(111111), } receipt2 := &types.Receipt{ PostState: []byte{0x02}, CumulativeGasUsed: big.NewInt(2), Logs: vm.Logs{ &vm.Log{Address: common.BytesToAddress([]byte{0x22})}, &vm.Log{Address: common.BytesToAddress([]byte{0x02, 0x22})}, }, TxHash: common.BytesToHash([]byte{0x22, 0x22}), ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}), GasUsed: big.NewInt(222222), } receipts := []*types.Receipt{receipt1, receipt2} // Check that no receipt entries are in a pristine database for i, receipt := range receipts { if r := GetReceipt(db, receipt.TxHash); r != nil { t.Fatalf("receipt #%d [%x]: non existent receipt returned: %v", i, receipt.TxHash, r) } } // Insert all the receipts into the database, and verify contents if err := WriteReceipts(db, receipts); err != nil { t.Fatalf("failed to write receipts: %v", err) } for i, receipt := range receipts { if r := GetReceipt(db, receipt.TxHash); r == nil { t.Fatalf("receipt #%d [%x]: receipt not found", i, receipt.TxHash) } else { rlpHave, _ := rlp.EncodeToBytes(r) rlpWant, _ := rlp.EncodeToBytes(receipt) if bytes.Compare(rlpHave, rlpWant) != 0 { t.Fatalf("receipt #%d [%x]: receipt mismatch: have %v, want %v", i, receipt.TxHash, r, receipt) } } } // Delete the receipts and check purge for i, receipt := range receipts { DeleteReceipt(db, receipt.TxHash) if r := GetReceipt(db, receipt.TxHash); r != nil { t.Fatalf("receipt #%d [%x]: deleted receipt returned: %v", i, receipt.TxHash, r) } } }
// use testing instead of checker because checker does not support // printing/logging in tests (-check.vv does not work) func TestSnapshot2(t *testing.T) { db, _ := ethdb.NewMemDatabase() state, _ := New(common.Hash{}, db) stateobjaddr0 := toAddr([]byte("so0")) stateobjaddr1 := toAddr([]byte("so1")) var storageaddr common.Hash data0 := common.BytesToHash([]byte{17}) data1 := common.BytesToHash([]byte{18}) state.SetState(stateobjaddr0, storageaddr, data0) state.SetState(stateobjaddr1, storageaddr, data1) // db, trie are already non-empty values so0 := state.GetStateObject(stateobjaddr0) so0.SetBalance(big.NewInt(42)) so0.SetNonce(43) so0.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e'}), []byte{'c', 'a', 'f', 'e'}) so0.suicided = false so0.deleted = false state.setStateObject(so0) root, _ := state.Commit() state.Reset(root) // and one with deleted == true so1 := state.GetStateObject(stateobjaddr1) so1.SetBalance(big.NewInt(52)) so1.SetNonce(53) so1.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e', '2'}), []byte{'c', 'a', 'f', 'e', '2'}) so1.suicided = true so1.deleted = true state.setStateObject(so1) so1 = state.GetStateObject(stateobjaddr1) if so1 != nil { t.Fatalf("deleted object not nil when getting") } snapshot := state.Snapshot() state.RevertToSnapshot(snapshot) so0Restored := state.GetStateObject(stateobjaddr0) // Update lazily-loaded values before comparing. so0Restored.GetState(db, storageaddr) so0Restored.Code(db) // non-deleted is equal (restored) compareStateObjects(so0Restored, so0, t) // deleted should be nil, both before and after restore of state copy so1Restored := state.GetStateObject(stateobjaddr1) if so1Restored != nil { t.Fatalf("deleted object not nil after restoring snapshot: %+v", so1Restored) } }
func setupTxPool() (*TxPool, *ecdsa.PrivateKey) { db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, db) var m event.TypeMux key, _ := crypto.GenerateKey() newPool := NewTxPool(&m, func() (*state.StateDB, error) { return statedb, nil }, func() *big.Int { return big.NewInt(1000000) }) newPool.resetState() return newPool, key }
func TestMissingRoot(t *testing.T) { db, _ := ethdb.NewMemDatabase() trie, err := New(common.HexToHash("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"), db) if trie != nil { t.Error("New returned non-nil trie for invalid root") } if err != ErrMissingRoot { t.Error("New returned wrong error: %v", err) } }
func create() (*ManagedState, *account) { db, _ := ethdb.NewMemDatabase() statedb := New(common.Hash{}, db) ms := ManageState(statedb) so := &StateObject{address: addr, nonce: 100} ms.StateDB.stateObjects[addr.Str()] = so ms.accounts[addr.Str()] = newAccount(so) return ms, ms.accounts[addr.Str()] }
func DeriveSha(list DerivableList) common.Hash { db, _ := ethdb.NewMemDatabase() trie := trie.New(nil, db) for i := 0; i < list.Len(); i++ { key, _ := rlp.EncodeToBytes(uint(i)) trie.Update(key, list.GetRlp(i)) } return common.BytesToHash(trie.Root()) }
func TestMipmapBloom(t *testing.T) { db, _ := ethdb.NewMemDatabase() receipt1 := new(types.Receipt) receipt1.Logs = vm.Logs{ &vm.Log{Address: common.BytesToAddress([]byte("test"))}, &vm.Log{Address: common.BytesToAddress([]byte("address"))}, } receipt2 := new(types.Receipt) receipt2.Logs = vm.Logs{ &vm.Log{Address: common.BytesToAddress([]byte("test"))}, &vm.Log{Address: common.BytesToAddress([]byte("address1"))}, } WriteMipmapBloom(db, 1, types.Receipts{receipt1}) WriteMipmapBloom(db, 2, types.Receipts{receipt2}) for _, level := range MIPMapLevels { bloom := GetMipmapBloom(db, 2, level) if !bloom.Test(new(big.Int).SetBytes([]byte("address1"))) { t.Error("expected test to be included on level:", level) } } // reset db, _ = ethdb.NewMemDatabase() receipt := new(types.Receipt) receipt.Logs = vm.Logs{ &vm.Log{Address: common.BytesToAddress([]byte("test"))}, } WriteMipmapBloom(db, 999, types.Receipts{receipt1}) receipt = new(types.Receipt) receipt.Logs = vm.Logs{ &vm.Log{Address: common.BytesToAddress([]byte("test 1"))}, } WriteMipmapBloom(db, 1000, types.Receipts{receipt}) bloom := GetMipmapBloom(db, 1000, 1000) if bloom.TestBytes([]byte("test")) { t.Error("test should not have been included") } }