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") } }
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() } } }
func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) { // Create the database in memory or in a temporary directory. var db common.Database if !disk { db, _ = ethdb.NewMemDatabase() } else { dir, err := ioutil.TempDir("", "eth-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, 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, _ := NewChainManager(db, FakePow{}, evmux) chainman.SetProcessor(NewBlockProcessor(db, FakePow{}, chainman, 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 runOneBlockTest(ctx *cli.Context, test *tests.BlockTest) (*eth.Ethereum, error) { cfg := utils.MakeEthConfig(ClientIdentifier, Version, ctx) cfg.NewDB = func(path string) (common.Database, error) { return ethdb.NewMemDatabase() } cfg.MaxPeers = 0 // disable network cfg.Shh = false // disable whisper cfg.NAT = nil // disable port mapping ethereum, err := eth.New(cfg) if err != nil { return nil, err } // if err := ethereum.Start(); err != nil { // return nil, err // } // import the genesis block ethereum.ResetWithGenesisBlock(test.Genesis) // import pre accounts statedb, err := test.InsertPreState(ethereum) if err != nil { return ethereum, fmt.Errorf("InsertPreState: %v", err) } if err := test.TryBlocksInsert(ethereum.ChainManager()); err != nil { return ethereum, fmt.Errorf("Block Test load error: %v", err) } if err := test.ValidatePostState(statedb); err != nil { return ethereum, fmt.Errorf("post state validation failed: %v", err) } return ethereum, nil }
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.SetLogs(state.Logs{&state.Log{ Address: addr, Topics: []common.Hash{hash}, Data: []byte("hi"), Number: 42, TxHash: hash, TxIndex: 0, BlockHash: hash, Index: 0, }}) PutReceipts(db, types.Receipts{receipt}) receipt = GetReceipt(db, common.Hash{}) if receipt == nil { t.Error("expected to get 1 receipt, got none.") } }
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 { return statedb } pool.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, false); err != nil { t.Error("didn't expect error", err) } if err := pool.add(tx2, false); 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 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 }
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 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()] }
// 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.balance = big.NewInt(42) so0.nonce = 43 so0.gasPool = big.NewInt(44) so0.code = []byte{'c', 'a', 'f', 'e'} so0.codeHash = so0.CodeHash() so0.remove = true so0.deleted = false so0.dirty = false state.SetStateObject(so0) // and one with deleted == true so1 := state.GetStateObject(stateobjaddr1) so1.balance = big.NewInt(52) so1.nonce = 53 so1.gasPool = big.NewInt(54) so1.code = []byte{'c', 'a', 'f', 'e', '2'} so1.codeHash = so1.CodeHash() so1.remove = true so1.deleted = true so1.dirty = true state.SetStateObject(so1) so1 = state.GetStateObject(stateobjaddr1) if so1 != nil { t.Fatalf("deleted object not nil when getting") } snapshot := state.Copy() state.Set(snapshot) so0Restored := state.GetStateObject(stateobjaddr0) so1Restored := state.GetStateObject(stateobjaddr1) // non-deleted is equal (restored) compareStateObjects(so0Restored, so0, t) // deleted should be nil, both before and after restore of state copy if so1Restored != nil { t.Fatalf("deleted object not nil after restoring snapshot") } }
func proc() (*BlockProcessor, *ChainManager) { db, _ := ethdb.NewMemDatabase() var mux event.TypeMux WriteTestNetGenesisBlock(db, 0) chainMan, err := NewChainManager(db, thePow(), &mux) if err != nil { fmt.Println(err) } return NewBlockProcessor(db, ezp.New(), chainMan, &mux), chainMan }
func (test *BlockTest) makeEthConfig() *eth.Config { ks := crypto.NewKeyStorePassphrase(filepath.Join(common.DefaultDataDir(), "keystore")) return ð.Config{ DataDir: common.DefaultDataDir(), Verbosity: 5, Etherbase: common.Address{}, AccountManager: accounts.NewManager(ks), NewDB: func(path string) (common.Database, error) { return ethdb.NewMemDatabase() }, } }
func newProtocolManagerForTesting(txAdded chan<- []*types.Transaction) *ProtocolManager { db, _ := ethdb.NewMemDatabase() core.WriteTestNetGenesisBlock(db, 0) var ( em = new(event.TypeMux) chain, _ = core.NewChainManager(db, core.FakePow{}, em) txpool = &fakeTxPool{added: txAdded} pm = NewProtocolManager(NetworkId, em, txpool, core.FakePow{}, chain) ) pm.Start() return pm }
func testREPL(t *testing.T, config func(*eth.Config)) (string, *testjethre, *eth.Ethereum) { tmp, err := ioutil.TempDir("", "geth-test") if err != nil { t.Fatal(err) } db, _ := ethdb.NewMemDatabase() core.WriteGenesisBlockForTesting(db, common.HexToAddress(testAddress), common.String2Big(testBalance)) ks := crypto.NewKeyStorePlain(filepath.Join(tmp, "keystore")) am := accounts.NewManager(ks) conf := ð.Config{ NodeKey: testNodeKey, DataDir: tmp, AccountManager: am, MaxPeers: 0, Name: "test", SolcPath: testSolcPath, PowTest: true, NewDB: func(path string) (common.Database, error) { return db, nil }, } if config != nil { config(conf) } ethereum, err := eth.New(conf) if err != nil { t.Fatal("%v", err) } keyb, err := crypto.HexToECDSA(testKey) if err != nil { t.Fatal(err) } key := crypto.NewKeyFromECDSA(keyb) err = ks.StoreKey(key, "") if err != nil { t.Fatal(err) } err = am.Unlock(key.Address, "") if err != nil { t.Fatal(err) } assetPath := filepath.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist", "assets", "ext") client := comms.NewInProcClient(codec.JSON) ds := docserver.New("/") tf := &testjethre{ds: ds} repl := newJSRE(ethereum, assetPath, "", client, false, tf) tf.jsre = repl return tmp, tf, ethereum }
func run(ctx *cli.Context) { vm.Debug = ctx.GlobalBool(DebugFlag.Name) vm.ForceJit = ctx.GlobalBool(ForceJitFlag.Name) vm.EnableJit = !ctx.GlobalBool(DisableJitFlag.Name) glog.SetToStderr(true) db, _ := ethdb.NewMemDatabase() statedb := state.New(common.Hash{}, db) sender := statedb.CreateAccount(common.StringToAddress("sender")) receiver := statedb.CreateAccount(common.StringToAddress("receiver")) receiver.SetCode(common.Hex2Bytes(ctx.GlobalString(CodeFlag.Name))) vmenv := NewEnv(statedb, common.StringToAddress("evmuser"), common.Big(ctx.GlobalString(ValueFlag.Name))) tstart := time.Now() ret, e := vmenv.Call( sender, receiver.Address(), common.Hex2Bytes(ctx.GlobalString(InputFlag.Name)), common.Big(ctx.GlobalString(GasFlag.Name)), common.Big(ctx.GlobalString(PriceFlag.Name)), common.Big(ctx.GlobalString(ValueFlag.Name)), ) vmdone := time.Since(tstart) if ctx.GlobalBool(DumpFlag.Name) { fmt.Println(string(statedb.Dump())) } vm.StdErrFormat(vmenv.StructLogs()) if ctx.GlobalBool(SysStatFlag.Name) { var mem runtime.MemStats runtime.ReadMemStats(&mem) fmt.Printf("vm took %v\n", vmdone) fmt.Printf(`alloc: %d tot alloc: %d no. malloc: %d heap alloc: %d heap objs: %d num gc: %d `, mem.Alloc, mem.TotalAlloc, mem.Mallocs, mem.HeapAlloc, mem.HeapObjects, mem.NumGC) } fmt.Printf("OUT: 0x%x", ret) if e != nil { fmt.Printf(" error: %v", e) } fmt.Println() }
func benchVmTest(test VmTest, env map[string]string, b *testing.B) { b.StopTimer() db, _ := ethdb.NewMemDatabase() statedb := state.New(common.Hash{}, db) for addr, account := range test.Pre { obj := StateObjectFromAccount(db, addr, account) statedb.SetStateObject(obj) for a, v := range account.Storage { obj.SetState(common.HexToHash(a), common.HexToHash(v)) } } b.StartTimer() RunVm(statedb, env, test.Exec) }
func TestNull(t *testing.T) { db, _ := ethdb.NewMemDatabase() state := New(common.Hash{}, db) address := common.HexToAddress("0x823140710bf13990e4500136726d8b55") state.CreateAccount(address) //value := common.FromHex("0x823140710bf13990e4500136726d8b55") var value common.Hash state.SetState(address, common.Hash{}, value) state.SyncIntermediate() state.Sync() value = state.GetState(address, common.Hash{}) if !common.EmptyHash(value) { t.Errorf("expected empty hash. got %x", value) } }
func NewTestManager() *TestManager { db, err := ethdb.NewMemDatabase() if err != nil { fmt.Println("Could not create mem-db, failing") return nil } testManager := &TestManager{} testManager.eventMux = new(event.TypeMux) testManager.db = db // testManager.txPool = NewTxPool(testManager) // testManager.blockChain = NewChainManager(testManager) // testManager.stateManager = NewStateManager(testManager) return testManager }
func TestChainMultipleInsertions(t *testing.T) { t.Skip("Skipped: outdated test files") db, _ := ethdb.NewMemDatabase() const max = 4 chains := make([]types.Blocks, max) var longest int for i := 0; i < max; i++ { var err error name := "valid" + strconv.Itoa(i+1) chains[i], err = loadChain(name, t) if len(chains[i]) >= len(chains[longest]) { longest = i } fmt.Println("loaded", name, "with a length of", len(chains[i])) if err != nil { fmt.Println(err) t.FailNow() } } chainMan := theChainManager(db, t) done := make(chan bool, max) for i, chain := range chains { // XXX the go routine would otherwise reference the same (chain[3]) variable and fail i := i chain := chain go func() { insertChain(done, chainMan, chain, t) fmt.Println(i, "done") }() } for i := 0; i < max; i++ { <-done } if chains[longest][len(chains[longest])-1].Hash() != chainMan.CurrentBlock().Hash() { t.Error("Invalid canonical chain") } }
func TestInsertNonceError(t *testing.T) { for i := 1; i < 25 && !t.Failed(); i++ { db, _ := ethdb.NewMemDatabase() genesis, err := WriteTestNetGenesisBlock(db, 0) if err != nil { t.Error(err) t.FailNow() } bc := chm(genesis, db) bc.processor = NewBlockProcessor(db, bc.pow, bc, bc.eventMux) blocks := makeChain(bc.currentBlock, i, db, 0) fail := rand.Int() % len(blocks) failblock := blocks[fail] bc.pow = failpow{failblock.NumberU64()} n, err := bc.InsertChain(blocks) // Check that the returned error indicates the nonce failure. if n != fail { t.Errorf("(i=%d) wrong failed block index: got %d, want %d", i, n, fail) } if !IsBlockNonceErr(err) { t.Fatalf("(i=%d) got %q, want a nonce error", i, err) } nerr := err.(*BlockNonceErr) if nerr.Number.Cmp(failblock.Number()) != 0 { t.Errorf("(i=%d) wrong block number in error, got %v, want %v", i, nerr.Number, failblock.Number()) } if nerr.Hash != failblock.Hash() { t.Errorf("(i=%d) wrong block hash in error, got %v, want %v", i, nerr.Hash, failblock.Hash()) } // Check that all no blocks after the failing block have been inserted. for _, block := range blocks[fail:] { if bc.HasBlock(block.Hash()) { t.Errorf("(i=%d) invalid block %d present in chain", i, block.NumberU64()) } } } }
func testEth(t *testing.T) (ethereum *eth.Ethereum, err error) { os.RemoveAll("/tmp/eth-natspec/") err = os.MkdirAll("/tmp/eth-natspec/keystore", os.ModePerm) if err != nil { panic(err) } // create a testAddress ks := crypto.NewKeyStorePassphrase("/tmp/eth-natspec/keystore") am := accounts.NewManager(ks) testAccount, err := am.NewAccount("password") if err != nil { panic(err) } testAddress := strings.TrimPrefix(testAccount.Address.Hex(), "0x") db, _ := ethdb.NewMemDatabase() // set up mock genesis with balance on the testAddress core.WriteGenesisBlockForTesting(db, common.HexToAddress(testAddress), common.String2Big(testBalance)) // only use minimalistic stack with no networking ethereum, err = eth.New(ð.Config{ DataDir: "/tmp/eth-natspec", AccountManager: am, MaxPeers: 0, PowTest: true, Etherbase: common.HexToAddress(testAddress), NewDB: func(path string) (common.Database, error) { return db, nil }, }) if err != nil { panic(err) } return }
func TestExtendCanonical(t *testing.T) { CanonicalLength := 5 db, err := ethdb.NewMemDatabase() if err != nil { t.Fatal("Failed to create db:", err) } // make first chain starting from genesis bman, err := newCanonical(CanonicalLength, db) if err != nil { t.Fatal("Could not make new canonical chain:", err) } f := func(td1, td2 *big.Int) { if td2.Cmp(td1) <= 0 { t.Error("expected chainB to have higher difficulty. Got", td2, "expected more than", td1) } } // Start fork from current height (CanonicalLength) testFork(t, bman, CanonicalLength, 1, f) testFork(t, bman, CanonicalLength, 2, f) testFork(t, bman, CanonicalLength, 5, f) testFork(t, bman, CanonicalLength, 10, f) }
func TestReorgShortest(t *testing.T) { db, _ := ethdb.NewMemDatabase() genesis, err := WriteTestNetGenesisBlock(db, 0) if err != nil { t.Error(err) t.FailNow() } bc := chm(genesis, db) chain1 := makeChainWithDiff(genesis, []int{1, 2, 3, 4}, 10) chain2 := makeChainWithDiff(genesis, []int{1, 10}, 11) bc.InsertChain(chain1) bc.InsertChain(chain2) prev := bc.CurrentBlock() for block := bc.GetBlockByNumber(bc.CurrentBlock().NumberU64() - 1); block.NumberU64() != 0; prev, block = block, bc.GetBlockByNumber(block.NumberU64()-1) { if prev.ParentHash() != block.Hash() { t.Errorf("parent hash mismatch %x - %x", prev.ParentHash(), block.Hash()) } } }
// Test fork of length N starting from block i func testFork(t *testing.T, bman *BlockProcessor, i, N int, f func(td1, td2 *big.Int)) { // switch databases to process the new chain db, err := ethdb.NewMemDatabase() if err != nil { t.Fatal("Failed to create db:", err) } // copy old chain up to i into new db with deterministic canonical bman2, err := newCanonical(i, db) if err != nil { t.Fatal("could not make new canonical in testFork", err) } // asert the bmans have the same block at i bi1 := bman.bc.GetBlockByNumber(uint64(i)).Hash() bi2 := bman2.bc.GetBlockByNumber(uint64(i)).Hash() if bi1 != bi2 { t.Fatal("chains do not have the same hash at height", i) } bman2.bc.SetProcessor(bman2) // extend the fork parent := bman2.bc.CurrentBlock() chainB := makeChain(parent, N, db, forkSeed) _, err = bman2.bc.InsertChain(chainB) if err != nil { t.Fatal("Insert chain error for fork:", err) } tdpre := bman.bc.Td() // Test the fork's blocks on the original chain td, err := testChain(chainB, bman) if err != nil { t.Fatal("expected chainB not to give errors:", err) } // Compare difficulties f(tdpre, td) // Loop over parents making sure reconstruction is done properly }
func TestEqualFork(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) } f := func(td1, td2 *big.Int) { if td2.Cmp(td1) != 0 { t.Error("expected chainB to have equal difficulty. Got", td2, "expected ", td1) } } // Sum of numbers must be equal to 10 // for this to be an equal fork testFork(t, bman, 0, 10, f) testFork(t, bman, 1, 9, f) testFork(t, bman, 2, 8, f) testFork(t, bman, 5, 5, f) testFork(t, bman, 6, 4, f) testFork(t, bman, 9, 1, f) }
func TestChainInsertions(t *testing.T) { t.Skip("Skipped: outdated test files") db, _ := ethdb.NewMemDatabase() chain1, err := loadChain("valid1", t) if err != nil { fmt.Println(err) t.FailNow() } chain2, err := loadChain("valid2", t) if err != nil { fmt.Println(err) t.FailNow() } chainMan := theChainManager(db, t) const max = 2 done := make(chan bool, max) go insertChain(done, chainMan, chain1, t) go insertChain(done, chainMan, chain2, t) for i := 0; i < max; i++ { <-done } if chain2[len(chain2)-1].Hash() != chainMan.CurrentBlock().Hash() { t.Error("chain2 is canonical and shouldn't be") } if chain1[len(chain1)-1].Hash() != chainMan.CurrentBlock().Hash() { t.Error("chain1 isn't canonical and should be") } }
func TestShorterFork(t *testing.T) { db, err := ethdb.NewMemDatabase() if err != nil { t.Fatal("Failed to create db:", err) } // make first chain starting from genesis bman, err := newCanonical(10, db) if err != nil { t.Fatal("Could not make new canonical chain:", err) } f := func(td1, td2 *big.Int) { if td2.Cmp(td1) >= 0 { t.Error("expected chainB to have lower difficulty. Got", td2, "expected less than", td1) } } // Sum of numbers must be less than 10 // for this to be a shorter fork testFork(t, bman, 0, 3, f) testFork(t, bman, 0, 7, f) testFork(t, bman, 1, 1, f) testFork(t, bman, 1, 7, f) testFork(t, bman, 5, 3, f) testFork(t, bman, 5, 4, f) }
func TestLongerFork(t *testing.T) { db, err := ethdb.NewMemDatabase() if err != nil { t.Fatal("Failed to create db:", err) } // make first chain starting from genesis bman, err := newCanonical(10, db) if err != nil { t.Fatal("Could not make new canonical chain:", err) } f := func(td1, td2 *big.Int) { if td2.Cmp(td1) <= 0 { t.Error("expected chainB to have higher difficulty. Got", td2, "expected more than", td1) } } // Sum of numbers must be greater than 10 // for this to be a longer fork testFork(t, bman, 0, 11, f) testFork(t, bman, 0, 15, f) testFork(t, bman, 1, 10, f) testFork(t, bman, 1, 12, f) testFork(t, bman, 5, 6, f) testFork(t, bman, 5, 8, f) }
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 { return statedb } pool.currentState().AddBalance(addr, big.NewInt(100000000000000)) pool.resetState() } resetState() tx := transaction(0, big.NewInt(100000), key) if err := pool.add(tx, false); 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, false); err != nil { t.Error("didn't expect error", err) } }
"errors" "fmt" "math/big" "sync/atomic" "testing" "time" "github.com/shiftcurrency/shift/common" "github.com/shiftcurrency/shift/core" "github.com/shiftcurrency/shift/core/types" "github.com/shiftcurrency/shift/ethdb" "github.com/shiftcurrency/shift/event" ) var ( testdb, _ = ethdb.NewMemDatabase() genesis = core.GenesisBlockForTesting(testdb, common.Address{}, big.NewInt(0)) ) // makeChain creates a chain of n blocks starting at but not including // parent. the returned hash chain is ordered head->parent. func makeChain(n int, seed byte, parent *types.Block) ([]common.Hash, map[common.Hash]*types.Block) { blocks := core.GenerateChain(parent, testdb, n, func(i int, gen *core.BlockGen) { gen.SetCoinbase(common.Address{seed}) }) hashes := make([]common.Hash, n+1) hashes[len(hashes)-1] = parent.Hash() blockm := make(map[common.Hash]*types.Block, n+1) blockm[parent.Hash()] = parent for i, b := range blocks { hashes[len(hashes)-i-2] = b.Hash()