miner: add malicious miner feature for test

Author: NathanBSC

consensus/parlia/parlia.go

@@ -1704,6 +1704,23 @@ func (p *Parlia) Delay(chain consensus.ChainReader, header *types.Header, leftOv
 	return &delay
 }
 
+// AssembleSignature assemble the signature for block header
+func (p *Parlia) AssembleSignature(block *types.Block) (*types.Block, error) {
+	header := block.Header()
+	// Don't hold the val fields for the entire sealing procedure
+	p.lock.RLock()
+	val, signFn := p.val, p.signFn
+	p.lock.RUnlock()
+	sig, err := signFn(accounts.Account{Address: val}, accounts.MimetypeParlia, ParliaRLP(header, p.chainConfig.ChainID))
+	if err != nil {
+		log.Error("Sign for the block header failed when sealing", "err", err)
+		return nil, err
+	}
+	copy(header.Extra[len(header.Extra)-extraSeal:], sig)
+	block = block.WithSeal(header)
+	return block, nil
+}
+
 // Seal implements consensus.Engine, attempting to create a sealed block using
 // the local signing credentials.
 func (p *Parlia) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {

core/blockchain.go

@@ -2066,18 +2066,18 @@ func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.
 
 // WriteBlockAndSetHead writes the given block and all associated state to the database,
 // and applies the block as the new chain head.
-func (bc *BlockChain) WriteBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, sealedBlockSender *event.TypeMux) (status WriteStatus, err error) {
+func (bc *BlockChain) WriteBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, sealedBlockSender *event.TypeMux, delayBroadcast bool) (status WriteStatus, err error) {
 	if !bc.chainmu.TryLock() {
 		return NonStatTy, errChainStopped
 	}
 	defer bc.chainmu.Unlock()
 
-	return bc.writeBlockAndSetHead(block, receipts, logs, state, sealedBlockSender)
+	return bc.writeBlockAndSetHead(block, receipts, logs, state, sealedBlockSender, delayBroadcast)
 }
 
 // writeBlockAndSetHead is the internal implementation of WriteBlockAndSetHead.
 // This function expects the chain mutex to be held.
-func (bc *BlockChain) writeBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, sealedBlockSender *event.TypeMux) (status WriteStatus, err error) {
+func (bc *BlockChain) writeBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, sealedBlockSender *event.TypeMux, delayBroadcast bool) (status WriteStatus, err error) {
 	currentBlock := bc.CurrentBlock()
 	reorg, err := bc.forker.ReorgNeededWithFastFinality(currentBlock, block.Header())
 	if err != nil {
@@ -2086,7 +2086,7 @@ func (bc *BlockChain) writeBlockAndSetHead(block *types.Block, receipts []*types
 	if reorg {
 		bc.highestVerifiedBlock.Store(types.CopyHeader(block.Header()))
 		bc.highestVerifiedBlockFeed.Send(HighestVerifiedBlockEvent{Header: block.Header()})
-		if sealedBlockSender != nil {
+		if sealedBlockSender != nil && !delayBroadcast {
 			// If the local DB is corrupted, writeBlockWithState may fail.
 			// It's fine — other nodes will persist the block.
 			//
@@ -2708,7 +2708,7 @@ func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, s
 		// Don't set the head, only insert the block
 		err = bc.writeBlockWithState(block, res.Receipts, statedb)
 	} else {
-		status, err = bc.writeBlockAndSetHead(block, res.Receipts, res.Logs, statedb, nil)
+		status, err = bc.writeBlockAndSetHead(block, res.Receipts, res.Logs, statedb, nil, false)
 	}
 	if err != nil {
 		return nil, err

core/types/block.go

@@ -20,6 +20,7 @@ package types
 import (
 	"crypto/sha256"
 	"encoding/binary"
+	"encoding/json"
 	"fmt"
 	"io"
 	"math/big"
@@ -785,6 +786,14 @@ func (b *Block) WithWitness(witness *ExecutionWitness) *Block {
 	}
 }
 
+func (b *Block) DeepCopySidecars(sidecars BlobSidecars) {
+	b.sidecars = make(BlobSidecars, len(sidecars))
+	if len(sidecars) != 0 {
+		buffer, _ := json.Marshal(sidecars)
+		json.Unmarshal(buffer, &b.sidecars)
+	}
+}
+
 // Hash returns the keccak256 hash of b's header.
 // The hash is computed on the first call and cached thereafter.
 func (b *Block) Hash() common.Hash {

core/vote/vote_manager.go

@@ -35,6 +35,7 @@ var notContinuousJustified = metrics.NewRegisteredCounter("votesManager/notConti
 // Backend wraps all methods required for voting.
 type Backend interface {
 	IsMining() bool
+	VoteEnabled() bool
 	EventMux() *event.TypeMux
 }
 
@@ -140,6 +141,11 @@ func (voteManager *VoteManager) loop() {
 				log.Debug("skip voting because mining is disabled, continue")
 				continue
 			}
+			if !voteManager.eth.VoteEnabled() {
+				log.Debug("skip voting because voting is disabled, continue")
+				continue
+			}
+
 			blockCountSinceMining++
 			if blockCountSinceMining <= blocksNumberSinceMining {
 				log.Debug("skip voting", "blockCountSinceMining", blockCountSinceMining, "blocksNumberSinceMining", blocksNumberSinceMining)

core/vote/vote_pool_test.go

@@ -76,6 +76,7 @@ func newTestBackend() *testBackend {
 	return &testBackend{eventMux: new(event.TypeMux)}
 }
 func (b *testBackend) IsMining() bool           { return true }
+func (b *testBackend) VoteEnabled() bool        { return true }
 func (b *testBackend) EventMux() *event.TypeMux { return b.eventMux }
 
 func (mp *mockPOSA) GetJustifiedNumberAndHash(chain consensus.ChainHeaderReader, headers []*types.Header) (uint64, common.Hash, error) {

eth/api_miner.go

@@ -20,6 +20,7 @@ import (
 	"math/big"
 	"time"
 
+	"github.com/ethereum/go-ethereum/miner/minerconfig"
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -117,3 +118,37 @@ func (api *MinerAPI) AddBuilder(builder common.Address, url string) error {
 func (api *MinerAPI) RemoveBuilder(builder common.Address) error {
 	return api.e.APIBackend.RemoveBuilder(builder)
 }
+
+func (api *MinerAPI) MBConfig() minerconfig.MBConfig {
+	return api.e.Miner().MBConfig()
+}
+
+func (api *MinerAPI) ResetMaliciousBehavior() minerconfig.MBConfig {
+	api.e.Miner().ResetMaliciousBehavior()
+	return api.e.Miner().MBConfig()
+}
+
+func (api *MinerAPI) SetDoubleSign(on bool) minerconfig.MBConfig {
+	api.e.Miner().SetDoubleSign(on)
+	return api.e.Miner().MBConfig()
+}
+
+func (api *MinerAPI) SetVoteDisable(on bool) minerconfig.MBConfig {
+	api.e.Miner().SetVoteDisable(on)
+	return api.e.Miner().MBConfig()
+}
+
+func (api *MinerAPI) SetSkipOffsetInturn(offset uint64) minerconfig.MBConfig {
+	api.e.Miner().SetSkipOffsetInturn(offset)
+	return api.e.Miner().MBConfig()
+}
+
+func (api *MinerAPI) SetBroadcastDelayBlocks(num uint64) minerconfig.MBConfig {
+	api.e.Miner().SetBroadcastDelayBlocks(num)
+	return api.e.Miner().MBConfig()
+}
+
+func (api *MinerAPI) SetLastBlockMiningTime(time uint64) minerconfig.MBConfig {
+	api.e.Miner().SetLastBlockMiningTime(time)
+	return api.e.Miner().MBConfig()
+}

eth/backend.go

@@ -826,6 +826,7 @@ func (s *Ethereum) StopMining() {
 }
 
 func (s *Ethereum) IsMining() bool      { return s.miner.Mining() }
+func (s *Ethereum) VoteEnabled() bool   { return s.miner.VoteEnabled() }
 func (s *Ethereum) Miner() *miner.Miner { return s.miner }
 
 func (s *Ethereum) AccountManager() *accounts.Manager  { return s.accountManager }

miner/miner.go

@@ -170,6 +170,10 @@ func (miner *Miner) Mining() bool {
 	return miner.worker.isRunning()
 }
 
+func (miner *Miner) VoteEnabled() bool {
+	return miner.worker.config.VoteEnable && !miner.worker.config.MB.VoteDisable
+}
+
 func (miner *Miner) InTurn() bool {
 	return miner.worker.inTurn()
 }
@@ -227,6 +231,34 @@ func (miner *Miner) SetGasCeil(ceil uint64) {
 	miner.worker.setGasCeil(ceil)
 }
 
+func (miner *Miner) MBConfig() minerconfig.MBConfig {
+	return miner.worker.config.MB
+}
+
+func (miner *Miner) ResetMaliciousBehavior() {
+	miner.worker.config.MB = minerconfig.DefaultMBConfig
+}
+
+func (miner *Miner) SetDoubleSign(on bool) {
+	miner.worker.config.MB.DoubleSign = on
+}
+
+func (miner *Miner) SetVoteDisable(on bool) {
+	miner.worker.config.MB.VoteDisable = on
+}
+
+func (miner *Miner) SetSkipOffsetInturn(offset uint64) {
+	miner.worker.config.MB.SkipOffsetInturn = &offset
+}
+
+func (miner *Miner) SetBroadcastDelayBlocks(num uint64) {
+	miner.worker.config.MB.BroadcastDelayBlocks = num
+}
+
+func (miner *Miner) SetLastBlockMiningTime(time uint64) {
+	miner.worker.config.MB.LastBlockMiningTime = time
+}
+
 // BuildPayload builds the payload according to the provided parameters.
 func (miner *Miner) BuildPayload(args *BuildPayloadArgs, witness bool) (*Payload, error) {
 	return miner.worker.buildPayload(args, witness)

miner/minerconfig/config.go

@@ -71,6 +71,7 @@ type Config struct {
 	TxGasLimit             uint64         // Maximum gas for per transaction(will be removed after Mendel hardfork)
 
 	Mev MevConfig // Mev configuration
+	MB  MBConfig  // Malicious behavior configuration
 }
 
 // DefaultConfig contains default settings for miner.
@@ -89,6 +90,7 @@ var DefaultConfig = Config{
 	MaxWaitProposalInSecs: &defaultMaxWaitProposalInSecs,
 
 	Mev: DefaultMevConfig,
+	MB:  DefaultMBConfig,
 }
 
 type BuilderConfig struct {
@@ -170,3 +172,24 @@ func ApplyDefaultMinerConfig(cfg *Config) {
 		log.Info("ApplyDefaultMinerConfig", "Mev.MaxBidsPerBuilder", *cfg.Mev.MaxBidsPerBuilder)
 	}
 }
+
+//go:generate go run github.com/fjl/gencodec -type MBConfig -formats toml -out gen_mb_config.go
+type MBConfig struct {
+	// Generate two consecutive blocks for the same parent block
+	DoubleSign bool
+	// Disable voting for Fast Finality
+	VoteDisable bool
+	// Skip block production for in-turn validators at a specified offset
+	SkipOffsetInturn *uint64 `toml:",omitempty"`
+	// Delay broadcasting mined blocks by a specified number of blocks, only for in turn validators
+	BroadcastDelayBlocks uint64
+	// Mining time (milliseconds) for the last block in every turn
+	LastBlockMiningTime uint64
+}
+
+var DefaultMBConfig = MBConfig{
+	DoubleSign:           false,
+	VoteDisable:          false,
+	BroadcastDelayBlocks: 0,
+	LastBlockMiningTime:  0,
+}