github.com/insight-chain/inb-go@v1.1.3-0.20191221022159-da049980ae38/core/dao_test.go (about) 1 // Copyright 2016 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 core 18 19 import ( 20 "math/big" 21 "testing" 22 23 "github.com/insight-chain/inb-go/consensus/ethash" 24 "github.com/insight-chain/inb-go/core/vm" 25 "github.com/insight-chain/inb-go/ethdb" 26 "github.com/insight-chain/inb-go/params" 27 ) 28 29 // Tests that DAO-fork enabled clients can properly filter out fork-commencing 30 // blocks based on their extradata fields. 31 func TestDAOForkRangeExtradata(t *testing.T) { 32 forkBlock := big.NewInt(32) 33 34 // Generate a common prefix for both pro-forkers and non-forkers 35 db := ethdb.NewMemDatabase() 36 gspec := new(Genesis) 37 genesis := gspec.MustCommit(db) 38 prefix, _ := GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, int(forkBlock.Int64()-1), func(i int, gen *BlockGen) {}) 39 40 // Create the concurrent, conflicting two nodes 41 proDb := ethdb.NewMemDatabase() 42 gspec.MustCommit(proDb) 43 44 proConf := *params.TestChainConfig 45 //proConf.DAOForkBlock = forkBlock 46 //proConf.DAOForkSupport = true 47 48 proBc, _ := NewBlockChain(proDb, nil, &proConf, ethash.NewFaker(), vm.Config{}, nil) 49 defer proBc.Stop() 50 51 conDb := ethdb.NewMemDatabase() 52 gspec.MustCommit(conDb) 53 54 conConf := *params.TestChainConfig 55 //conConf.DAOForkBlock = forkBlock 56 //conConf.DAOForkSupport = false 57 58 conBc, _ := NewBlockChain(conDb, nil, &conConf, ethash.NewFaker(), vm.Config{}, nil) 59 defer conBc.Stop() 60 61 if _, err := proBc.InsertChain(prefix); err != nil { 62 t.Fatalf("pro-fork: failed to import chain prefix: %v", err) 63 } 64 if _, err := conBc.InsertChain(prefix); err != nil { 65 t.Fatalf("con-fork: failed to import chain prefix: %v", err) 66 } 67 // Try to expand both pro-fork and non-fork chains iteratively with other camp's blocks 68 //for i := int64(0); i < params.DAOForkExtraRange.Int64(); i++ { 69 // // Create a pro-fork block, and try to feed into the no-fork chain 70 // db = ethdb.NewMemDatabase() 71 // gspec.MustCommit(db) 72 // bc, _ := NewBlockChain(db, nil, &conConf, ethash.NewFaker(), vm.Config{}, nil) 73 // defer bc.Stop() 74 // 75 // blocks := conBc.GetBlocksFromHash(conBc.CurrentBlock().Hash(), int(conBc.CurrentBlock().NumberU64())) 76 // for j := 0; j < len(blocks)/2; j++ { 77 // blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j] 78 // } 79 // if _, err := bc.InsertChain(blocks); err != nil { 80 // t.Fatalf("failed to import contra-fork chain for expansion: %v", err) 81 // } 82 // if err := bc.stateCache.TrieDB().Commit(bc.CurrentHeader().Root, true); err != nil { 83 // t.Fatalf("failed to commit contra-fork head for expansion: %v", err) 84 // } 85 // blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) 86 // if _, err := conBc.InsertChain(blocks); err == nil { 87 // t.Fatalf("contra-fork chain accepted pro-fork block: %v", blocks[0]) 88 // } 89 // // Create a proper no-fork block for the contra-forker 90 // blocks, _ = GenerateChain(&conConf, conBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) 91 // if _, err := conBc.InsertChain(blocks); err != nil { 92 // t.Fatalf("contra-fork chain didn't accepted no-fork block: %v", err) 93 // } 94 // // Create a no-fork block, and try to feed into the pro-fork chain 95 // db = ethdb.NewMemDatabase() 96 // gspec.MustCommit(db) 97 // bc, _ = NewBlockChain(db, nil, &proConf, ethash.NewFaker(), vm.Config{}, nil) 98 // defer bc.Stop() 99 // 100 // blocks = proBc.GetBlocksFromHash(proBc.CurrentBlock().Hash(), int(proBc.CurrentBlock().NumberU64())) 101 // for j := 0; j < len(blocks)/2; j++ { 102 // blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j] 103 // } 104 // if _, err := bc.InsertChain(blocks); err != nil { 105 // t.Fatalf("failed to import pro-fork chain for expansion: %v", err) 106 // } 107 // if err := bc.stateCache.TrieDB().Commit(bc.CurrentHeader().Root, true); err != nil { 108 // t.Fatalf("failed to commit pro-fork head for expansion: %v", err) 109 // } 110 // blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) 111 // if _, err := proBc.InsertChain(blocks); err == nil { 112 // t.Fatalf("pro-fork chain accepted contra-fork block: %v", blocks[0]) 113 // } 114 // // Create a proper pro-fork block for the pro-forker 115 // blocks, _ = GenerateChain(&proConf, proBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) 116 // if _, err := proBc.InsertChain(blocks); err != nil { 117 // t.Fatalf("pro-fork chain didn't accepted pro-fork block: %v", err) 118 // } 119 //} 120 // Verify that contra-forkers accept pro-fork extra-datas after forking finishes 121 db = ethdb.NewMemDatabase() 122 gspec.MustCommit(db) 123 bc, _ := NewBlockChain(db, nil, &conConf, ethash.NewFaker(), vm.Config{}, nil) 124 defer bc.Stop() 125 126 blocks := conBc.GetBlocksFromHash(conBc.CurrentBlock().Hash(), int(conBc.CurrentBlock().NumberU64())) 127 for j := 0; j < len(blocks)/2; j++ { 128 blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j] 129 } 130 if _, err := bc.InsertChain(blocks); err != nil { 131 t.Fatalf("failed to import contra-fork chain for expansion: %v", err) 132 } 133 if err := bc.stateCache.TrieDB().Commit(bc.CurrentHeader().Root, true); err != nil { 134 t.Fatalf("failed to commit contra-fork head for expansion: %v", err) 135 } 136 blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) 137 if _, err := conBc.InsertChain(blocks); err != nil { 138 t.Fatalf("contra-fork chain didn't accept pro-fork block post-fork: %v", err) 139 } 140 // Verify that pro-forkers accept contra-fork extra-datas after forking finishes 141 db = ethdb.NewMemDatabase() 142 gspec.MustCommit(db) 143 bc, _ = NewBlockChain(db, nil, &proConf, ethash.NewFaker(), vm.Config{}, nil) 144 defer bc.Stop() 145 146 blocks = proBc.GetBlocksFromHash(proBc.CurrentBlock().Hash(), int(proBc.CurrentBlock().NumberU64())) 147 for j := 0; j < len(blocks)/2; j++ { 148 blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j] 149 } 150 if _, err := bc.InsertChain(blocks); err != nil { 151 t.Fatalf("failed to import pro-fork chain for expansion: %v", err) 152 } 153 if err := bc.stateCache.TrieDB().Commit(bc.CurrentHeader().Root, true); err != nil { 154 t.Fatalf("failed to commit pro-fork head for expansion: %v", err) 155 } 156 blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) 157 if _, err := proBc.InsertChain(blocks); err != nil { 158 t.Fatalf("pro-fork chain didn't accept contra-fork block post-fork: %v", err) 159 } 160 }