122 lines
3.6 KiB
Go
122 lines
3.6 KiB
Go
package miner
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
"math/big"
|
|
"testing"
|
|
|
|
"github.com/ethereum/go-ethereum/beacon/engine"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/consensus"
|
|
"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/txpool"
|
|
"github.com/ethereum/go-ethereum/core/txpool/legacypool"
|
|
"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/params"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// testMinerBackend implements miner's Backend interface.
|
|
type testMinerBackend struct {
|
|
txPool *txpool.TxPool
|
|
chain *core.BlockChain
|
|
}
|
|
|
|
func (b *testMinerBackend) BlockChain() *core.BlockChain { return b.chain }
|
|
func (b *testMinerBackend) TxPool() *txpool.TxPool { return b.txPool }
|
|
|
|
func newTestMinerBackend(t *testing.T, genesis *core.Genesis, engine consensus.Engine) *testMinerBackend {
|
|
chain, err := core.NewBlockChain(rawdb.NewMemoryDatabase(), &core.CacheConfig{TrieDirtyDisabled: true}, genesis, nil, engine, vm.Config{}, nil)
|
|
if err != nil {
|
|
t.Fatalf("core.NewBlockChain failed: %v", err)
|
|
}
|
|
|
|
testTxPoolConfig := legacypool.DefaultConfig
|
|
pool := legacypool.New(testTxPoolConfig, chain)
|
|
txpool, err := txpool.New(testTxPoolConfig.PriceLimit, chain, []txpool.SubPool{pool})
|
|
if err != nil {
|
|
t.Fatalf("txpool.New failed: %v", err)
|
|
}
|
|
|
|
return &testMinerBackend{
|
|
chain: chain,
|
|
txPool: txpool,
|
|
}
|
|
}
|
|
|
|
func newTestMiner(eth *testMinerBackend) *Miner {
|
|
return New(eth, DefaultConfig, eth.chain.Engine())
|
|
}
|
|
|
|
func newPendingTransactions(fromPrivateKey *ecdsa.PrivateKey, toAddress common.Address) []*types.Transaction {
|
|
signer := types.LatestSigner(params.TestChainConfig)
|
|
|
|
tx1 := types.MustSignNewTx(fromPrivateKey, signer, &types.AccessListTx{
|
|
ChainID: params.TestChainConfig.ChainID,
|
|
Nonce: 0,
|
|
To: &toAddress,
|
|
Value: big.NewInt(1000),
|
|
Gas: params.TxGas,
|
|
GasPrice: big.NewInt(params.InitialBaseFee),
|
|
})
|
|
pendingTxs = append(pendingTxs, tx1)
|
|
|
|
tx2 := types.MustSignNewTx(fromPrivateKey, signer, &types.LegacyTx{
|
|
Nonce: 1,
|
|
To: &toAddress,
|
|
Value: big.NewInt(1000),
|
|
Gas: params.TxGas,
|
|
GasPrice: big.NewInt(params.InitialBaseFee),
|
|
})
|
|
pendingTxs = append(pendingTxs, tx2)
|
|
|
|
return pendingTxs
|
|
}
|
|
|
|
func TestBuildInclusionList(t *testing.T) {
|
|
var (
|
|
// Test accounts
|
|
testBankKey, _ = crypto.GenerateKey()
|
|
testBankAddress = crypto.PubkeyToAddress(testBankKey.PublicKey)
|
|
testBankFunds = big.NewInt(1000000000000000000)
|
|
|
|
testUserKey, _ = crypto.GenerateKey()
|
|
testUserAddress = crypto.PubkeyToAddress(testUserKey.PublicKey)
|
|
|
|
// Test genesis and consensus engine
|
|
testGenesis = &core.Genesis{
|
|
Config: params.TestChainConfig,
|
|
Alloc: types.GenesisAlloc{testBankAddress: {Balance: testBankFunds}},
|
|
}
|
|
testEngine = ethash.NewFaker()
|
|
)
|
|
|
|
// Initialize miner and backend.
|
|
eth := newTestMinerBackend(t, testGenesis, testEngine)
|
|
miner := newTestMiner(eth)
|
|
|
|
// Add pending transactions to the pool.
|
|
pendingTxs := newPendingTransactions(testBankKey, testUserAddress)
|
|
eth.txPool.Add(pendingTxs, true, true)
|
|
|
|
// Build inclusion list.
|
|
args := &BuildInclusionListArgs{
|
|
Parent: eth.chain.CurrentBlock().Hash(),
|
|
}
|
|
inclusionList, err := miner.BuildInclusionList(args)
|
|
if err != nil {
|
|
t.Fatalf("Failed to build inclusion list %v", err)
|
|
}
|
|
|
|
// Verify inclusion list size.
|
|
inclusionListSize := uint64(0)
|
|
for _, tx := range inclusionList {
|
|
inclusionListSize += uint64(len(tx))
|
|
}
|
|
require.LessOrEqual(t, inclusionListSize, engine.MaxBytesPerInclusionList)
|
|
}
|