b4dcff5772
resubmit intervalAdjust is for PoW only, to remove it to make worker simpler. With PoW, there will be a periodic timer to check if it is the time to stop packing transaction and start calculating the desired hash value, since other miner could succeed in hash compute if it spends too much time packing transactions. It will commit the current fruit to calculate root at a reasonable time. And it will schedule a new work to get a big block if new transaction was received. When there are too many transactions in the TxPool, the interval of the resubmit timer would be increased and vice versa. But it is not needed with PoS related consensus, since the block interval is determined in PoS, and there is already a timer to stop too long packing.
412 lines
13 KiB
Go
412 lines
13 KiB
Go
// Copyright 2018 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 miner
|
|
|
|
import (
|
|
"errors"
|
|
"math/big"
|
|
"math/rand"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/consensus"
|
|
"github.com/ethereum/go-ethereum/consensus/clique"
|
|
"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/state"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
"github.com/ethereum/go-ethereum/event"
|
|
"github.com/ethereum/go-ethereum/params"
|
|
)
|
|
|
|
const (
|
|
// testCode is the testing contract binary code which will initialises some
|
|
// variables in constructor
|
|
testCode = "0x60806040527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0060005534801561003457600080fd5b5060fc806100436000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c80630c4dae8814603757806398a213cf146053575b600080fd5b603d607e565b6040518082815260200191505060405180910390f35b607c60048036036020811015606757600080fd5b81019080803590602001909291905050506084565b005b60005481565b806000819055507fe9e44f9f7da8c559de847a3232b57364adc0354f15a2cd8dc636d54396f9587a6000546040518082815260200191505060405180910390a15056fea265627a7a723058208ae31d9424f2d0bc2a3da1a5dd659db2d71ec322a17db8f87e19e209e3a1ff4a64736f6c634300050a0032"
|
|
|
|
// testGas is the gas required for contract deployment.
|
|
testGas = 144109
|
|
)
|
|
|
|
var (
|
|
// Test chain configurations
|
|
testTxPoolConfig core.TxPoolConfig
|
|
ethashChainConfig *params.ChainConfig
|
|
cliqueChainConfig *params.ChainConfig
|
|
|
|
// Test accounts
|
|
testBankKey, _ = crypto.GenerateKey()
|
|
testBankAddress = crypto.PubkeyToAddress(testBankKey.PublicKey)
|
|
testBankFunds = big.NewInt(1000000000000000000)
|
|
|
|
testUserKey, _ = crypto.GenerateKey()
|
|
testUserAddress = crypto.PubkeyToAddress(testUserKey.PublicKey)
|
|
|
|
// Test transactions
|
|
pendingTxs []*types.Transaction
|
|
newTxs []*types.Transaction
|
|
|
|
testConfig = &Config{
|
|
Recommit: time.Second,
|
|
GasCeil: params.GenesisGasLimit,
|
|
}
|
|
)
|
|
|
|
func init() {
|
|
testTxPoolConfig = core.DefaultTxPoolConfig
|
|
testTxPoolConfig.Journal = ""
|
|
ethashChainConfig = new(params.ChainConfig)
|
|
*ethashChainConfig = *params.TestChainConfig
|
|
cliqueChainConfig = new(params.ChainConfig)
|
|
*cliqueChainConfig = *params.TestChainConfig
|
|
cliqueChainConfig.Clique = ¶ms.CliqueConfig{
|
|
Period: 10,
|
|
Epoch: 30000,
|
|
}
|
|
|
|
signer := types.LatestSigner(params.TestChainConfig)
|
|
tx1 := types.MustSignNewTx(testBankKey, signer, &types.AccessListTx{
|
|
ChainID: params.TestChainConfig.ChainID,
|
|
Nonce: 0,
|
|
To: &testUserAddress,
|
|
Value: big.NewInt(1000),
|
|
Gas: params.TxGas,
|
|
GasPrice: big.NewInt(params.InitialBaseFee),
|
|
})
|
|
pendingTxs = append(pendingTxs, tx1)
|
|
|
|
tx2 := types.MustSignNewTx(testBankKey, signer, &types.LegacyTx{
|
|
Nonce: 1,
|
|
To: &testUserAddress,
|
|
Value: big.NewInt(1000),
|
|
Gas: params.TxGas,
|
|
GasPrice: big.NewInt(params.InitialBaseFee),
|
|
})
|
|
newTxs = append(newTxs, tx2)
|
|
|
|
rand.Seed(time.Now().UnixNano())
|
|
}
|
|
|
|
// testWorkerBackend implements worker.Backend interfaces and wraps all information needed during the testing.
|
|
type testWorkerBackend struct {
|
|
db ethdb.Database
|
|
txPool *core.TxPool
|
|
chain *core.BlockChain
|
|
testTxFeed event.Feed
|
|
genesis *core.Genesis
|
|
uncleBlock *types.Block
|
|
}
|
|
|
|
func newTestWorkerBackend(t *testing.T, chainConfig *params.ChainConfig, engine consensus.Engine, db ethdb.Database, n int) *testWorkerBackend {
|
|
var gspec = core.Genesis{
|
|
Config: chainConfig,
|
|
Alloc: core.GenesisAlloc{testBankAddress: {Balance: testBankFunds}},
|
|
}
|
|
|
|
switch e := engine.(type) {
|
|
case *clique.Clique:
|
|
gspec.ExtraData = make([]byte, 32+common.AddressLength+crypto.SignatureLength)
|
|
copy(gspec.ExtraData[32:32+common.AddressLength], testBankAddress.Bytes())
|
|
e.Authorize(testBankAddress, func(account accounts.Account, s string, data []byte) ([]byte, error) {
|
|
return crypto.Sign(crypto.Keccak256(data), testBankKey)
|
|
})
|
|
case *ethash.Ethash:
|
|
default:
|
|
t.Fatalf("unexpected consensus engine type: %T", engine)
|
|
}
|
|
genesis := gspec.MustCommit(db)
|
|
|
|
chain, _ := core.NewBlockChain(db, &core.CacheConfig{TrieDirtyDisabled: true}, gspec.Config, engine, vm.Config{}, nil, nil)
|
|
txpool := core.NewTxPool(testTxPoolConfig, chainConfig, chain)
|
|
|
|
// Generate a small n-block chain and an uncle block for it
|
|
if n > 0 {
|
|
blocks, _ := core.GenerateChain(chainConfig, genesis, engine, db, n, func(i int, gen *core.BlockGen) {
|
|
gen.SetCoinbase(testBankAddress)
|
|
})
|
|
if _, err := chain.InsertChain(blocks); err != nil {
|
|
t.Fatalf("failed to insert origin chain: %v", err)
|
|
}
|
|
}
|
|
parent := genesis
|
|
if n > 0 {
|
|
parent = chain.GetBlockByHash(chain.CurrentBlock().ParentHash())
|
|
}
|
|
blocks, _ := core.GenerateChain(chainConfig, parent, engine, db, 1, func(i int, gen *core.BlockGen) {
|
|
gen.SetCoinbase(testUserAddress)
|
|
})
|
|
|
|
return &testWorkerBackend{
|
|
db: db,
|
|
chain: chain,
|
|
txPool: txpool,
|
|
genesis: &gspec,
|
|
uncleBlock: blocks[0],
|
|
}
|
|
}
|
|
|
|
func (b *testWorkerBackend) BlockChain() *core.BlockChain { return b.chain }
|
|
func (b *testWorkerBackend) TxPool() *core.TxPool { return b.txPool }
|
|
func (b *testWorkerBackend) StateAtBlock(block *types.Block, reexec uint64, base *state.StateDB, checkLive bool, preferDisk bool) (statedb *state.StateDB, err error) {
|
|
return nil, errors.New("not supported")
|
|
}
|
|
|
|
func (b *testWorkerBackend) newRandomUncle() *types.Block {
|
|
var parent *types.Block
|
|
cur := b.chain.CurrentBlock()
|
|
if cur.NumberU64() == 0 {
|
|
parent = b.chain.Genesis()
|
|
} else {
|
|
parent = b.chain.GetBlockByHash(b.chain.CurrentBlock().ParentHash())
|
|
}
|
|
blocks, _ := core.GenerateChain(b.chain.Config(), parent, b.chain.Engine(), b.db, 1, func(i int, gen *core.BlockGen) {
|
|
var addr = make([]byte, common.AddressLength)
|
|
rand.Read(addr)
|
|
gen.SetCoinbase(common.BytesToAddress(addr))
|
|
})
|
|
return blocks[0]
|
|
}
|
|
|
|
func (b *testWorkerBackend) newRandomTx(creation bool) *types.Transaction {
|
|
var tx *types.Transaction
|
|
gasPrice := big.NewInt(10 * params.InitialBaseFee)
|
|
if creation {
|
|
tx, _ = types.SignTx(types.NewContractCreation(b.txPool.Nonce(testBankAddress), big.NewInt(0), testGas, gasPrice, common.FromHex(testCode)), types.HomesteadSigner{}, testBankKey)
|
|
} else {
|
|
tx, _ = types.SignTx(types.NewTransaction(b.txPool.Nonce(testBankAddress), testUserAddress, big.NewInt(1000), params.TxGas, gasPrice, nil), types.HomesteadSigner{}, testBankKey)
|
|
}
|
|
return tx
|
|
}
|
|
|
|
func newTestWorker(t *testing.T, chainConfig *params.ChainConfig, engine consensus.Engine, db ethdb.Database, blocks int) (*worker, *testWorkerBackend) {
|
|
backend := newTestWorkerBackend(t, chainConfig, engine, db, blocks)
|
|
backend.txPool.AddLocals(pendingTxs)
|
|
w := newWorker(testConfig, chainConfig, engine, backend, new(event.TypeMux), nil, false)
|
|
w.setEtherbase(testBankAddress)
|
|
return w, backend
|
|
}
|
|
|
|
func TestGenerateBlockAndImportEthash(t *testing.T) {
|
|
testGenerateBlockAndImport(t, false)
|
|
}
|
|
|
|
func TestGenerateBlockAndImportClique(t *testing.T) {
|
|
testGenerateBlockAndImport(t, true)
|
|
}
|
|
|
|
func testGenerateBlockAndImport(t *testing.T, isClique bool) {
|
|
var (
|
|
engine consensus.Engine
|
|
chainConfig *params.ChainConfig
|
|
db = rawdb.NewMemoryDatabase()
|
|
)
|
|
if isClique {
|
|
chainConfig = params.AllCliqueProtocolChanges
|
|
chainConfig.Clique = ¶ms.CliqueConfig{Period: 1, Epoch: 30000}
|
|
engine = clique.New(chainConfig.Clique, db)
|
|
} else {
|
|
chainConfig = params.AllEthashProtocolChanges
|
|
engine = ethash.NewFaker()
|
|
}
|
|
|
|
chainConfig.LondonBlock = big.NewInt(0)
|
|
w, b := newTestWorker(t, chainConfig, engine, db, 0)
|
|
defer w.close()
|
|
|
|
// This test chain imports the mined blocks.
|
|
db2 := rawdb.NewMemoryDatabase()
|
|
b.genesis.MustCommit(db2)
|
|
chain, _ := core.NewBlockChain(db2, nil, b.chain.Config(), engine, vm.Config{}, nil, nil)
|
|
defer chain.Stop()
|
|
|
|
// Ignore empty commit here for less noise.
|
|
w.skipSealHook = func(task *task) bool {
|
|
return len(task.receipts) == 0
|
|
}
|
|
|
|
// Wait for mined blocks.
|
|
sub := w.mux.Subscribe(core.NewMinedBlockEvent{})
|
|
defer sub.Unsubscribe()
|
|
|
|
// Start mining!
|
|
w.start()
|
|
|
|
for i := 0; i < 5; i++ {
|
|
b.txPool.AddLocal(b.newRandomTx(true))
|
|
b.txPool.AddLocal(b.newRandomTx(false))
|
|
w.postSideBlock(core.ChainSideEvent{Block: b.newRandomUncle()})
|
|
w.postSideBlock(core.ChainSideEvent{Block: b.newRandomUncle()})
|
|
|
|
select {
|
|
case ev := <-sub.Chan():
|
|
block := ev.Data.(core.NewMinedBlockEvent).Block
|
|
if _, err := chain.InsertChain([]*types.Block{block}); err != nil {
|
|
t.Fatalf("failed to insert new mined block %d: %v", block.NumberU64(), err)
|
|
}
|
|
case <-time.After(3 * time.Second): // Worker needs 1s to include new changes.
|
|
t.Fatalf("timeout")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGetSealingWorkEthash(t *testing.T) {
|
|
testGetSealingWork(t, ethashChainConfig, ethash.NewFaker(), false)
|
|
}
|
|
|
|
func TestGetSealingWorkClique(t *testing.T) {
|
|
testGetSealingWork(t, cliqueChainConfig, clique.New(cliqueChainConfig.Clique, rawdb.NewMemoryDatabase()), false)
|
|
}
|
|
|
|
func TestGetSealingWorkPostMerge(t *testing.T) {
|
|
local := new(params.ChainConfig)
|
|
*local = *ethashChainConfig
|
|
local.TerminalTotalDifficulty = big.NewInt(0)
|
|
testGetSealingWork(t, local, ethash.NewFaker(), true)
|
|
}
|
|
|
|
func testGetSealingWork(t *testing.T, chainConfig *params.ChainConfig, engine consensus.Engine, postMerge bool) {
|
|
defer engine.Close()
|
|
|
|
w, b := newTestWorker(t, chainConfig, engine, rawdb.NewMemoryDatabase(), 0)
|
|
defer w.close()
|
|
|
|
w.setExtra([]byte{0x01, 0x02})
|
|
w.postSideBlock(core.ChainSideEvent{Block: b.uncleBlock})
|
|
|
|
w.skipSealHook = func(task *task) bool {
|
|
return true
|
|
}
|
|
w.fullTaskHook = func() {
|
|
time.Sleep(100 * time.Millisecond)
|
|
}
|
|
timestamp := uint64(time.Now().Unix())
|
|
assertBlock := func(block *types.Block, number uint64, coinbase common.Address, random common.Hash) {
|
|
if block.Time() != timestamp {
|
|
// Sometime the timestamp will be mutated if the timestamp
|
|
// is even smaller than parent block's. It's OK.
|
|
t.Logf("Invalid timestamp, want %d, get %d", timestamp, block.Time())
|
|
}
|
|
if len(block.Uncles()) != 0 {
|
|
t.Error("Unexpected uncle block")
|
|
}
|
|
_, isClique := engine.(*clique.Clique)
|
|
if !isClique {
|
|
if len(block.Extra()) != 0 {
|
|
t.Error("Unexpected extra field")
|
|
}
|
|
if block.Coinbase() != coinbase {
|
|
t.Errorf("Unexpected coinbase got %x want %x", block.Coinbase(), coinbase)
|
|
}
|
|
} else {
|
|
if block.Coinbase() != (common.Address{}) {
|
|
t.Error("Unexpected coinbase")
|
|
}
|
|
}
|
|
if !isClique {
|
|
if block.MixDigest() != random {
|
|
t.Error("Unexpected mix digest")
|
|
}
|
|
}
|
|
if block.Nonce() != 0 {
|
|
t.Error("Unexpected block nonce")
|
|
}
|
|
if block.NumberU64() != number {
|
|
t.Errorf("Mismatched block number, want %d got %d", number, block.NumberU64())
|
|
}
|
|
}
|
|
var cases = []struct {
|
|
parent common.Hash
|
|
coinbase common.Address
|
|
random common.Hash
|
|
expectNumber uint64
|
|
expectErr bool
|
|
}{
|
|
{
|
|
b.chain.Genesis().Hash(),
|
|
common.HexToAddress("0xdeadbeef"),
|
|
common.HexToHash("0xcafebabe"),
|
|
uint64(1),
|
|
false,
|
|
},
|
|
{
|
|
b.chain.CurrentBlock().Hash(),
|
|
common.HexToAddress("0xdeadbeef"),
|
|
common.HexToHash("0xcafebabe"),
|
|
b.chain.CurrentBlock().NumberU64() + 1,
|
|
false,
|
|
},
|
|
{
|
|
b.chain.CurrentBlock().Hash(),
|
|
common.Address{},
|
|
common.HexToHash("0xcafebabe"),
|
|
b.chain.CurrentBlock().NumberU64() + 1,
|
|
false,
|
|
},
|
|
{
|
|
b.chain.CurrentBlock().Hash(),
|
|
common.Address{},
|
|
common.Hash{},
|
|
b.chain.CurrentBlock().NumberU64() + 1,
|
|
false,
|
|
},
|
|
{
|
|
common.HexToHash("0xdeadbeef"),
|
|
common.HexToAddress("0xdeadbeef"),
|
|
common.HexToHash("0xcafebabe"),
|
|
0,
|
|
true,
|
|
},
|
|
}
|
|
|
|
// This API should work even when the automatic sealing is not enabled
|
|
for _, c := range cases {
|
|
block, err := w.getSealingBlock(c.parent, timestamp, c.coinbase, c.random)
|
|
if c.expectErr {
|
|
if err == nil {
|
|
t.Error("Expect error but get nil")
|
|
}
|
|
} else {
|
|
if err != nil {
|
|
t.Errorf("Unexpected error %v", err)
|
|
}
|
|
assertBlock(block, c.expectNumber, c.coinbase, c.random)
|
|
}
|
|
}
|
|
|
|
// This API should work even when the automatic sealing is enabled
|
|
w.start()
|
|
for _, c := range cases {
|
|
block, err := w.getSealingBlock(c.parent, timestamp, c.coinbase, c.random)
|
|
if c.expectErr {
|
|
if err == nil {
|
|
t.Error("Expect error but get nil")
|
|
}
|
|
} else {
|
|
if err != nil {
|
|
t.Errorf("Unexpected error %v", err)
|
|
}
|
|
assertBlock(block, c.expectNumber, c.coinbase, c.random)
|
|
}
|
|
}
|
|
}
|