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 := &params.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 := &ethconfig.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  }