github.com/fff-chain/go-fff@v0.0.0-20220726032732-1c84420b8a99/eth/catalyst/api_test.go (about) 1 // Copyright 2020 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 catalyst 18 19 import ( 20 "math/big" 21 "testing" 22 23 "github.com/fff-chain/go-fff/consensus/ethash" 24 "github.com/fff-chain/go-fff/core" 25 "github.com/fff-chain/go-fff/core/rawdb" 26 "github.com/fff-chain/go-fff/core/types" 27 "github.com/fff-chain/go-fff/crypto" 28 "github.com/fff-chain/go-fff/eth" 29 "github.com/fff-chain/go-fff/eth/ethconfig" 30 "github.com/fff-chain/go-fff/node" 31 "github.com/fff-chain/go-fff/params" 32 ) 33 34 var ( 35 // testKey is a private key to use for funding a tester account. 36 testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") 37 38 // testAddr is the Ethereum address of the tester account. 39 testAddr = crypto.PubkeyToAddress(testKey.PublicKey) 40 41 testBalance = big.NewInt(2e10) 42 ) 43 44 func generateTestChain() (*core.Genesis, []*types.Block) { 45 db := rawdb.NewMemoryDatabase() 46 config := params.AllEthashProtocolChanges 47 genesis := &core.Genesis{ 48 Config: config, 49 Alloc: core.GenesisAlloc{testAddr: {Balance: testBalance}}, 50 ExtraData: []byte("test genesis"), 51 Timestamp: 9000, 52 } 53 generate := func(i int, g *core.BlockGen) { 54 g.OffsetTime(5) 55 g.SetExtra([]byte("test")) 56 } 57 gblock := genesis.ToBlock(db) 58 engine := ethash.NewFaker() 59 blocks, _ := core.GenerateChain(config, gblock, engine, db, 10, generate) 60 blocks = append([]*types.Block{gblock}, blocks...) 61 return genesis, blocks 62 } 63 64 func generateTestChainWithFork(n int, fork int) (*core.Genesis, []*types.Block, []*types.Block) { 65 if fork >= n { 66 fork = n - 1 67 } 68 db := rawdb.NewMemoryDatabase() 69 config := ¶ms.ChainConfig{ 70 ChainID: big.NewInt(1337), 71 HomesteadBlock: big.NewInt(0), 72 EIP150Block: big.NewInt(0), 73 EIP155Block: big.NewInt(0), 74 EIP158Block: big.NewInt(0), 75 ByzantiumBlock: big.NewInt(0), 76 ConstantinopleBlock: big.NewInt(0), 77 PetersburgBlock: big.NewInt(0), 78 IstanbulBlock: big.NewInt(0), 79 MuirGlacierBlock: big.NewInt(0), 80 BerlinBlock: big.NewInt(0), 81 CatalystBlock: big.NewInt(0), 82 RamanujanBlock: big.NewInt(0), 83 NielsBlock: big.NewInt(0), 84 MirrorSyncBlock: big.NewInt(0), 85 BrunoBlock: big.NewInt(0), 86 87 Ethash: new(params.EthashConfig), 88 } 89 genesis := &core.Genesis{ 90 Config: config, 91 Alloc: core.GenesisAlloc{testAddr: {Balance: testBalance}}, 92 ExtraData: []byte("test genesis"), 93 Timestamp: 9000, 94 } 95 generate := func(i int, g *core.BlockGen) { 96 g.OffsetTime(5) 97 g.SetExtra([]byte("test")) 98 } 99 generateFork := func(i int, g *core.BlockGen) { 100 g.OffsetTime(5) 101 g.SetExtra([]byte("testF")) 102 } 103 gblock := genesis.ToBlock(db) 104 engine := ethash.NewFaker() 105 blocks, _ := core.GenerateChain(config, gblock, engine, db, n, generate) 106 blocks = append([]*types.Block{gblock}, blocks...) 107 forkedBlocks, _ := core.GenerateChain(config, blocks[fork], engine, db, n-fork, generateFork) 108 return genesis, blocks, forkedBlocks 109 } 110 111 func TestEth2AssembleBlock(t *testing.T) { 112 genesis, blocks := generateTestChain() 113 n, ethservice := startEthService(t, genesis, blocks[1:9]) 114 defer n.Close() 115 116 api := newConsensusAPI(ethservice) 117 signer := types.NewEIP155Signer(ethservice.BlockChain().Config().ChainID) 118 tx, err := types.SignTx(types.NewTransaction(0, blocks[8].Coinbase(), big.NewInt(1000), params.TxGas, nil, nil), signer, testKey) 119 if err != nil { 120 t.Fatalf("error signing transaction, err=%v", err) 121 } 122 ethservice.TxPool().AddLocal(tx) 123 blockParams := assembleBlockParams{ 124 ParentHash: blocks[8].ParentHash(), 125 Timestamp: blocks[8].Time(), 126 } 127 execData, err := api.AssembleBlock(blockParams) 128 129 if err != nil { 130 t.Fatalf("error producing block, err=%v", err) 131 } 132 133 if len(execData.Transactions) != 1 { 134 t.Fatalf("invalid number of transactions %d != 1", len(execData.Transactions)) 135 } 136 } 137 138 func TestEth2AssembleBlockWithAnotherBlocksTxs(t *testing.T) { 139 genesis, blocks := generateTestChain() 140 n, ethservice := startEthService(t, genesis, blocks[1:9]) 141 defer n.Close() 142 143 api := newConsensusAPI(ethservice) 144 145 // Put the 10th block's tx in the pool and produce a new block 146 api.addBlockTxs(blocks[9]) 147 blockParams := assembleBlockParams{ 148 ParentHash: blocks[9].ParentHash(), 149 Timestamp: blocks[9].Time(), 150 } 151 execData, err := api.AssembleBlock(blockParams) 152 if err != nil { 153 t.Fatalf("error producing block, err=%v", err) 154 } 155 156 if len(execData.Transactions) != blocks[9].Transactions().Len() { 157 t.Fatalf("invalid number of transactions %d != 1", len(execData.Transactions)) 158 } 159 } 160 161 func TestEth2NewBlock(t *testing.T) { 162 genesis, blocks, forkedBlocks := generateTestChainWithFork(10, 4) 163 n, ethservice := startEthService(t, genesis, blocks[1:5]) 164 defer n.Close() 165 166 api := newConsensusAPI(ethservice) 167 for i := 5; i < 10; i++ { 168 p := executableData{ 169 ParentHash: ethservice.BlockChain().CurrentBlock().Hash(), 170 Miner: blocks[i].Coinbase(), 171 StateRoot: blocks[i].Root(), 172 GasLimit: blocks[i].GasLimit(), 173 GasUsed: blocks[i].GasUsed(), 174 Transactions: encodeTransactions(blocks[i].Transactions()), 175 ReceiptRoot: blocks[i].ReceiptHash(), 176 LogsBloom: blocks[i].Bloom().Bytes(), 177 BlockHash: blocks[i].Hash(), 178 Timestamp: blocks[i].Time(), 179 Number: uint64(i), 180 } 181 success, err := api.NewBlock(p) 182 if err != nil || !success.Valid { 183 t.Fatalf("Failed to insert block: %v", err) 184 } 185 } 186 187 exp := ethservice.BlockChain().CurrentBlock().Hash() 188 189 // Introduce the fork point. 190 lastBlockNum := blocks[4].Number() 191 lastBlock := blocks[4] 192 for i := 0; i < 4; i++ { 193 lastBlockNum.Add(lastBlockNum, big.NewInt(1)) 194 p := executableData{ 195 ParentHash: lastBlock.Hash(), 196 Miner: forkedBlocks[i].Coinbase(), 197 StateRoot: forkedBlocks[i].Root(), 198 Number: lastBlockNum.Uint64(), 199 GasLimit: forkedBlocks[i].GasLimit(), 200 GasUsed: forkedBlocks[i].GasUsed(), 201 Transactions: encodeTransactions(blocks[i].Transactions()), 202 ReceiptRoot: forkedBlocks[i].ReceiptHash(), 203 LogsBloom: forkedBlocks[i].Bloom().Bytes(), 204 BlockHash: forkedBlocks[i].Hash(), 205 Timestamp: forkedBlocks[i].Time(), 206 } 207 success, err := api.NewBlock(p) 208 if err != nil || !success.Valid { 209 t.Fatalf("Failed to insert forked block #%d: %v", i, err) 210 } 211 lastBlock, err = insertBlockParamsToBlock(p) 212 if err != nil { 213 t.Fatal(err) 214 } 215 } 216 217 if ethservice.BlockChain().CurrentBlock().Hash() != exp { 218 t.Fatalf("Wrong head after inserting fork %x != %x", exp, ethservice.BlockChain().CurrentBlock().Hash()) 219 } 220 } 221 222 // startEthService creates a full node instance for testing. 223 func startEthService(t *testing.T, genesis *core.Genesis, blocks []*types.Block) (*node.Node, *eth.Ethereum) { 224 t.Helper() 225 226 n, err := node.New(&node.Config{}) 227 if err != nil { 228 t.Fatal("can't create node:", err) 229 } 230 231 ethcfg := ðconfig.Config{Genesis: genesis, Ethash: ethash.Config{PowMode: ethash.ModeFake}} 232 ethservice, err := eth.New(n, ethcfg) 233 if err != nil { 234 t.Fatal("can't create eth service:", err) 235 } 236 if err := n.Start(); err != nil { 237 t.Fatal("can't start node:", err) 238 } 239 if _, err := ethservice.BlockChain().InsertChain(blocks); err != nil { 240 n.Close() 241 t.Fatal("can't import test blocks:", err) 242 } 243 ethservice.SetEtherbase(testAddr) 244 245 return n, ethservice 246 }