251 lines
8.1 KiB
Go
251 lines
8.1 KiB
Go
// Copyright 2020 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package catalyst
|
|
|
|
import (
|
|
"math/big"
|
|
"testing"
|
|
|
|
"github.com/ethereum/go-ethereum/consensus/ethash"
|
|
"github.com/ethereum/go-ethereum/core"
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/eth"
|
|
"github.com/ethereum/go-ethereum/eth/ethconfig"
|
|
"github.com/ethereum/go-ethereum/node"
|
|
"github.com/ethereum/go-ethereum/params"
|
|
)
|
|
|
|
var (
|
|
// testKey is a private key to use for funding a tester account.
|
|
testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
|
|
|
|
// testAddr is the Ethereum address of the tester account.
|
|
testAddr = crypto.PubkeyToAddress(testKey.PublicKey)
|
|
|
|
testBalance = big.NewInt(2e15)
|
|
)
|
|
|
|
func generateTestChain() (*core.Genesis, []*types.Block) {
|
|
db := rawdb.NewMemoryDatabase()
|
|
config := params.AllEthashProtocolChanges
|
|
genesis := &core.Genesis{
|
|
Config: config,
|
|
Alloc: core.GenesisAlloc{testAddr: {Balance: testBalance}},
|
|
ExtraData: []byte("test genesis"),
|
|
Timestamp: 9000,
|
|
BaseFee: big.NewInt(params.InitialBaseFee),
|
|
}
|
|
generate := func(i int, g *core.BlockGen) {
|
|
g.OffsetTime(5)
|
|
g.SetExtra([]byte("test"))
|
|
}
|
|
gblock := genesis.ToBlock(db)
|
|
engine := ethash.NewFaker()
|
|
blocks, _ := core.GenerateChain(config, gblock, engine, db, 10, generate)
|
|
blocks = append([]*types.Block{gblock}, blocks...)
|
|
return genesis, blocks
|
|
}
|
|
|
|
// TODO (MariusVanDerWijden) reenable once engine api is updated to the latest spec
|
|
/*
|
|
func generateTestChainWithFork(n int, fork int) (*core.Genesis, []*types.Block, []*types.Block) {
|
|
if fork >= n {
|
|
fork = n - 1
|
|
}
|
|
db := rawdb.NewMemoryDatabase()
|
|
config := ¶ms.ChainConfig{
|
|
ChainID: big.NewInt(1337),
|
|
HomesteadBlock: big.NewInt(0),
|
|
EIP150Block: big.NewInt(0),
|
|
EIP155Block: big.NewInt(0),
|
|
EIP158Block: big.NewInt(0),
|
|
ByzantiumBlock: big.NewInt(0),
|
|
ConstantinopleBlock: big.NewInt(0),
|
|
PetersburgBlock: big.NewInt(0),
|
|
IstanbulBlock: big.NewInt(0),
|
|
MuirGlacierBlock: big.NewInt(0),
|
|
BerlinBlock: big.NewInt(0),
|
|
LondonBlock: big.NewInt(0),
|
|
TerminalTotalDifficulty: big.NewInt(0),
|
|
Ethash: new(params.EthashConfig),
|
|
}
|
|
genesis := &core.Genesis{
|
|
Config: config,
|
|
Alloc: core.GenesisAlloc{testAddr: {Balance: testBalance}},
|
|
ExtraData: []byte("test genesis"),
|
|
Timestamp: 9000,
|
|
BaseFee: big.NewInt(params.InitialBaseFee),
|
|
}
|
|
generate := func(i int, g *core.BlockGen) {
|
|
g.OffsetTime(5)
|
|
g.SetExtra([]byte("test"))
|
|
}
|
|
generateFork := func(i int, g *core.BlockGen) {
|
|
g.OffsetTime(5)
|
|
g.SetExtra([]byte("testF"))
|
|
}
|
|
gblock := genesis.ToBlock(db)
|
|
engine := ethash.NewFaker()
|
|
blocks, _ := core.GenerateChain(config, gblock, engine, db, n, generate)
|
|
blocks = append([]*types.Block{gblock}, blocks...)
|
|
forkedBlocks, _ := core.GenerateChain(config, blocks[fork], engine, db, n-fork, generateFork)
|
|
return genesis, blocks, forkedBlocks
|
|
}
|
|
*/
|
|
|
|
func TestEth2AssembleBlock(t *testing.T) {
|
|
genesis, blocks := generateTestChain()
|
|
n, ethservice := startEthService(t, genesis, blocks[1:9])
|
|
defer n.Close()
|
|
|
|
api := newConsensusAPI(ethservice)
|
|
signer := types.NewEIP155Signer(ethservice.BlockChain().Config().ChainID)
|
|
tx, err := types.SignTx(types.NewTransaction(0, blocks[8].Coinbase(), big.NewInt(1000), params.TxGas, big.NewInt(params.InitialBaseFee), nil), signer, testKey)
|
|
if err != nil {
|
|
t.Fatalf("error signing transaction, err=%v", err)
|
|
}
|
|
ethservice.TxPool().AddLocal(tx)
|
|
blockParams := assembleBlockParams{
|
|
ParentHash: blocks[8].ParentHash(),
|
|
Timestamp: blocks[8].Time(),
|
|
}
|
|
execData, err := api.AssembleBlock(blockParams)
|
|
|
|
if err != nil {
|
|
t.Fatalf("error producing block, err=%v", err)
|
|
}
|
|
|
|
if len(execData.Transactions) != 1 {
|
|
t.Fatalf("invalid number of transactions %d != 1", len(execData.Transactions))
|
|
}
|
|
}
|
|
|
|
func TestEth2AssembleBlockWithAnotherBlocksTxs(t *testing.T) {
|
|
genesis, blocks := generateTestChain()
|
|
n, ethservice := startEthService(t, genesis, blocks[1:9])
|
|
defer n.Close()
|
|
|
|
api := newConsensusAPI(ethservice)
|
|
|
|
// Put the 10th block's tx in the pool and produce a new block
|
|
api.addBlockTxs(blocks[9])
|
|
blockParams := assembleBlockParams{
|
|
ParentHash: blocks[9].ParentHash(),
|
|
Timestamp: blocks[9].Time(),
|
|
}
|
|
execData, err := api.AssembleBlock(blockParams)
|
|
if err != nil {
|
|
t.Fatalf("error producing block, err=%v", err)
|
|
}
|
|
|
|
if len(execData.Transactions) != blocks[9].Transactions().Len() {
|
|
t.Fatalf("invalid number of transactions %d != 1", len(execData.Transactions))
|
|
}
|
|
}
|
|
|
|
// TODO (MariusVanDerWijden) reenable once engine api is updated to the latest spec
|
|
/*
|
|
func TestEth2NewBlock(t *testing.T) {
|
|
genesis, blocks, forkedBlocks := generateTestChainWithFork(10, 4)
|
|
n, ethservice := startEthService(t, genesis, blocks[1:5])
|
|
defer n.Close()
|
|
|
|
api := newConsensusAPI(ethservice)
|
|
for i := 5; i < 10; i++ {
|
|
p := executableData{
|
|
ParentHash: ethservice.BlockChain().CurrentBlock().Hash(),
|
|
Miner: blocks[i].Coinbase(),
|
|
StateRoot: blocks[i].Root(),
|
|
GasLimit: blocks[i].GasLimit(),
|
|
GasUsed: blocks[i].GasUsed(),
|
|
Transactions: encodeTransactions(blocks[i].Transactions()),
|
|
ReceiptRoot: blocks[i].ReceiptHash(),
|
|
LogsBloom: blocks[i].Bloom().Bytes(),
|
|
BlockHash: blocks[i].Hash(),
|
|
Timestamp: blocks[i].Time(),
|
|
Number: uint64(i),
|
|
}
|
|
success, err := api.NewBlock(p)
|
|
if err != nil || !success.Valid {
|
|
t.Fatalf("Failed to insert block: %v", err)
|
|
}
|
|
}
|
|
|
|
exp := ethservice.BlockChain().CurrentBlock().Hash()
|
|
|
|
// Introduce the fork point.
|
|
lastBlockNum := blocks[4].Number()
|
|
lastBlock := blocks[4]
|
|
for i := 0; i < 4; i++ {
|
|
lastBlockNum.Add(lastBlockNum, big.NewInt(1))
|
|
p := executableData{
|
|
ParentHash: lastBlock.Hash(),
|
|
Miner: forkedBlocks[i].Coinbase(),
|
|
StateRoot: forkedBlocks[i].Root(),
|
|
Number: lastBlockNum.Uint64(),
|
|
GasLimit: forkedBlocks[i].GasLimit(),
|
|
GasUsed: forkedBlocks[i].GasUsed(),
|
|
Transactions: encodeTransactions(blocks[i].Transactions()),
|
|
ReceiptRoot: forkedBlocks[i].ReceiptHash(),
|
|
LogsBloom: forkedBlocks[i].Bloom().Bytes(),
|
|
BlockHash: forkedBlocks[i].Hash(),
|
|
Timestamp: forkedBlocks[i].Time(),
|
|
}
|
|
success, err := api.NewBlock(p)
|
|
if err != nil || !success.Valid {
|
|
t.Fatalf("Failed to insert forked block #%d: %v", i, err)
|
|
}
|
|
lastBlock, err = insertBlockParamsToBlock(ethservice.BlockChain().Config(), lastBlock.Header(), p)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
if ethservice.BlockChain().CurrentBlock().Hash() != exp {
|
|
t.Fatalf("Wrong head after inserting fork %x != %x", exp, ethservice.BlockChain().CurrentBlock().Hash())
|
|
}
|
|
}
|
|
*/
|
|
|
|
// startEthService creates a full node instance for testing.
|
|
func startEthService(t *testing.T, genesis *core.Genesis, blocks []*types.Block) (*node.Node, *eth.Ethereum) {
|
|
t.Helper()
|
|
|
|
n, err := node.New(&node.Config{})
|
|
if err != nil {
|
|
t.Fatal("can't create node:", err)
|
|
}
|
|
|
|
ethcfg := ðconfig.Config{Genesis: genesis, Ethash: ethash.Config{PowMode: ethash.ModeFake}}
|
|
ethservice, err := eth.New(n, ethcfg)
|
|
if err != nil {
|
|
t.Fatal("can't create eth service:", err)
|
|
}
|
|
if err := n.Start(); err != nil {
|
|
t.Fatal("can't start node:", err)
|
|
}
|
|
if _, err := ethservice.BlockChain().InsertChain(blocks); err != nil {
|
|
n.Close()
|
|
t.Fatal("can't import test blocks:", err)
|
|
}
|
|
ethservice.SetEtherbase(testAddr)
|
|
|
|
return n, ethservice
|
|
}
|