bft_mock.go

// Copyright 2021 The PlatON Network Authors
// This file is part of the PlatON-Go library.
//
// The PlatON-Go 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 PlatON-Go 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 PlatON-Go library. If not, see <http://www.gnu.org/licenses/>.

package consensus

import (
	"bytes"
	"errors"
	"fmt"
	"math/big"
	"time"

	"github.com/PlatONnetwork/PlatON-Go/core/rawdb"
	"github.com/PlatONnetwork/PlatON-Go/core/snapshotdb"
	"github.com/PlatONnetwork/PlatON-Go/params"

	"github.com/PlatONnetwork/PlatON-Go/p2p/enode"

	"github.com/PlatONnetwork/PlatON-Go/ethdb"
	"github.com/PlatONnetwork/PlatON-Go/event"
	"github.com/PlatONnetwork/PlatON-Go/trie"

	"github.com/PlatONnetwork/PlatON-Go/common/consensus"
	"github.com/PlatONnetwork/PlatON-Go/crypto"

	"github.com/PlatONnetwork/PlatON-Go/common"
	"github.com/PlatONnetwork/PlatON-Go/core/cbfttypes"
	"github.com/PlatONnetwork/PlatON-Go/core/state"
	"github.com/PlatONnetwork/PlatON-Go/core/types"
	"github.com/PlatONnetwork/PlatON-Go/p2p"
	"github.com/PlatONnetwork/PlatON-Go/rpc"

	ctypes "github.com/PlatONnetwork/PlatON-Go/consensus/cbft/types"
	"github.com/PlatONnetwork/PlatON-Go/x/gov"
)

type Chain interface {
	StateAt(root common.Hash) (*state.StateDB, error)

	ProcessDirectly(block *types.Block, state *state.StateDB, parent *types.Block) (types.Receipts, error)

	WriteBlockWithState(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool, cbftBridgeUpdateChainState func()) error

	GetHeaderByNumber(number uint64) *types.Header
}

func NewFaker() *BftMock {
	c := new(BftMock)
	c.Blocks = make([]*types.Block, 0)
	c.blockIndexs = make(map[common.Hash]int, 0)
	return c
}

func NewFakerWithDataBase(database ethdb.Database, genesis *types.Block) *BftMock {
	c := new(BftMock)
	c.Blocks = make([]*types.Block, 0)
	c.blockIndexs = make(map[common.Hash]int, 0)
	c.database = database
	c.genesis = genesis
	return c
}

func NewFailFaker(number uint64) *BftMock {
	c := NewFaker()
	c.fakeFail = number
	return c
}

// BftMock represents a simulated consensus structure.
type BftMock struct {
	EventMux    *event.TypeMux
	Blocks      []*types.Block
	blockIndexs map[common.Hash]int
	Next        uint32
	Current     *types.Block
	Base        *types.Block
	fakeFail    uint64         // Block number which fails BFT check even in fake mode
	database    ethdb.Database // In memory database to store our testing data
	chain       Chain
	genesis     *types.Block
}

func (bm *BftMock) Reset() {
	bm.Blocks = make([]*types.Block, 0)
	bm.blockIndexs = make(map[common.Hash]int, 0)
}

func (bm *BftMock) SetChain(c Chain) {
	bm.chain = c
}

// InsertChain is a fake interface, no need to implement.
func (bm *BftMock) InsertChain(block *types.Block) error {
	if _, ok := bm.blockIndexs[block.Hash()]; ok {
		return nil
	}

	if len(bm.Blocks) != 0 && bm.Blocks[len(bm.Blocks)-1].Hash() != block.ParentHash() {
		return errors.New("insertChain fail,block not compare")
	}

	if bm.chain != nil {
		var root common.Hash
		if block.ParentHash() == bm.genesis.Hash() {
			root = bm.genesis.Root()
		} else if len(bm.Blocks) == 0 {
			root = bm.chain.GetHeaderByNumber(block.NumberU64() - 1).Root
		} else {
			root = bm.Blocks[len(bm.Blocks)-1].Root()
		}

		statedb, err := bm.chain.StateAt(root)
		gov.NewGovDB(snapshotdb.Instance()).AddActiveVersion(params.FORKVERSION_1_6_0, 1, statedb)
		if err != nil {
			return err
		}
		receipts, err := bm.chain.ProcessDirectly(block, statedb, nil)
		if err != nil {
			return err
		}
		if err := statedb.UpdateSnaps(); err != nil {
			return err
		}
		if err := bm.chain.WriteBlockWithState(block, receipts, nil, statedb, false, nil); err != nil {
			return err
		}
	}

	bm.Blocks = append(bm.Blocks, block)
	bm.blockIndexs[block.Hash()] = len(bm.Blocks) - 1
	bm.Current = block
	bm.Base = block
	if bm.database != nil {
		rawdb.WriteBlock(bm.database, block)
		rawdb.WriteHeadBlockHash(bm.database, block.Hash())
		rawdb.WriteCanonicalHash(bm.database, block.Hash(), block.NumberU64())
		rawdb.WriteHeadHeaderHash(bm.database, block.Hash())
	}
	return nil
}

func (bm *BftMock) GetPrepareQC(number uint64) *ctypes.QuorumCert {
	panic("implement me")
}

// FastSyncCommitHead is a fake interface, no need to implement.
func (bm *BftMock) FastSyncCommitHead(block *types.Block) error {
	return nil
}

// Start is a fake interface, no need to implement.
func (bm *BftMock) Start(chain ChainReader, blockCacheWriter BlockCacheWriter, pool TxPoolReset, agency Agency) error {
	return nil
}

// CalcBlockDeadline is a fake interface, no need to implement.
func (bm *BftMock) CalcBlockDeadline(timePoint time.Time) time.Time {
	now := time.Now()

	if timePoint.Equal(now) || timePoint.Before(now) {
		return now.Add(now.Sub(timePoint)).Add(10 * time.Millisecond)
	}
	return timePoint.Add(10 * time.Millisecond)
}

// CalcNextBlockTime is a fake interface, no need to implement.
func (bm *BftMock) CalcNextBlockTime(timePoint time.Time) time.Time {
	return time.Now()
}

// GetBlockWithoutLock is a fake interface, no need to implement.
func (bm *BftMock) GetBlockWithoutLock(hash common.Hash, number uint64) *types.Block {
	return nil
}

// IsSignedBySelf is a fake interface, no need to implement.
func (bm *BftMock) IsSignedBySelf(sealHash common.Hash, header *types.Header) bool {
	return true
}

// Evidences is a fake interface, no need to implement.
func (bm *BftMock) Evidences() string {
	return ""
}

// UnmarshalEvidence is a fake interface, no need to implement.
func (bm *BftMock) UnmarshalEvidence(data []byte) (consensus.Evidences, error) {
	return nil, nil
}

func (bm *BftMock) Node() *enode.Node {
	privateKey, err := crypto.GenerateKey()
	if nil != err {
		panic(fmt.Sprintf("Failed to generate random NodeId private key: %v", err))
	}
	return enode.NewV4(&privateKey.PublicKey, nil, 0, 0)
}

// Author retrieves the Ethereum address of the account that minted the given
// block, which may be different from the header's coinbase if a consensus
// engine is based on signatures.
func (bm *BftMock) Author(header *types.Header) (common.Address, error) {
	return common.Address{}, nil
}

// VerifyHeader checks whether a header conforms to the consensus rules of a
// given engine. Verifying the seal may be done optionally here, or explicitly
// via the VerifySeal method.
func (bm *BftMock) VerifyHeader(chain ChainReader, header *types.Header, async bool) error {
	if bm.fakeFail == header.Number.Uint64() {
		return fmt.Errorf("failed verifyHeader on bftMock")
	}
	return nil
}

// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers
// concurrently. The method returns a quit channel to abort the operations and
// a results channel to retrieve the async verifications (the order is that of
// the input slice).
func (bm *BftMock) VerifyHeaders(chain ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) {
	results := make(chan error, len(headers))
	c := make(chan<- struct{})

	//time.Sleep(bm.fakeDelay)
	go func() {
		for i := range headers {
			if bm.fakeFail == headers[i].Number.Uint64() {
				results <- fmt.Errorf("failed verifyHeader on bftMock")
			} else {
				results <- nil
			}
		}
	}()
	return c, results
}

// VerifySeal checks whether the crypto seal on a header is valid according to
// the consensus rules of the given engine.
func (bm *BftMock) VerifySeal(chain ChainReader, header *types.Header) error {
	return nil
}

// Prepare initializes the consensus fields of a block header according to the
// rules of a particular engine. The changes are executed inline.
func (bm *BftMock) Prepare(chain ChainReader, header *types.Header) error {
	//header.Extra[0:31] to store block's version info etc. and right pad with 0x00;
	//header.Extra[32:] to store block's sign of producer, the length of sign is 65.
	if len(header.Extra) < 32 {
		header.Extra = append(header.Extra, bytes.Repeat([]byte{0x00}, 32-len(header.Extra))...)
	}
	header.Extra = header.Extra[:32]
	//init header.Extra[32: 32+65]
	header.Extra = append(header.Extra, make([]byte, ExtraSeal)...)
	return nil
}

// Finalize runs any post-transaction state modifications (e.g. block rewards)
// and assembles the final block.
// Note: The block header and state database might be updated to reflect any
// consensus rules that happen at finalization (e.g. block rewards).
func (bm *BftMock) Finalize(chain ChainReader, header *types.Header, state *state.StateDB,
	txs []*types.Transaction, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) {
	header.Root = state.IntermediateRoot(true)

	// Header seems complete, assemble into a block and return
	return types.NewBlock(header, txs, receipts, new(trie.Trie)), nil
}

// Seal generates a new sealing request for the given input block and pushes
// the result into the given channel.
//
// Note, the method returns immediately and will send the result async. More
// than one result may also be returned depending on the consensus algorithm.
func (bm *BftMock) Seal(chain ChainReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}, complete chan<- struct{}) error {
	header := block.Header()
	if block.NumberU64() == 0 {
		return fmt.Errorf("unknown block")
	}
	sign := header.SealHash().Bytes()
	copy(header.Extra[len(header.Extra)-ExtraSeal:], sign[:])
	sealBlock := block.WithSeal(header)
	complete <- struct{}{}
	results <- sealBlock
	bm.EventMux.Post(cbfttypes.CbftResult{
		Block: sealBlock,
		//ExtraData:          extra,
		//SyncState:          cbft.commitErrCh,
		ChainStateUpdateCB: func() {
		},
	})
	return nil
}

// SealHash returns the hash of a block prior to it being sealed.
func (bm *BftMock) SealHash(header *types.Header) common.Hash {
	return header.SealHash()
}

// CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty
// that a new block should have.
func (bm *BftMock) CalcDifficulty(chain ChainReader, time uint64, parent *types.Header) *big.Int {
	return nil
}

// APIs returns the RPC APIs this consensus engine provides.
func (bm *BftMock) APIs(chain ChainReader) []rpc.API {
	return nil
}

// Protocols is a fake interface, no need to implement.
func (bm *BftMock) Protocols() []p2p.Protocol {
	return []p2p.Protocol{}
}

// Close terminates any background threads maintained by the consensus engine.
func (bm *BftMock) Close() error {
	return nil
}

func (bm *BftMock) Stop() error {
	return nil
}

// ConsensusNodes returns the current consensus node address list.
func (bm *BftMock) ConsensusNodes() ([]enode.ID, error) {
	return nil, nil
}

func (bm *BftMock) ConsensusValidators() []*cbfttypes.ValidateNode {
	return nil
}

// ShouldSeal returns whether the current node is out of the block
func (bm *BftMock) ShouldSeal(curTime time.Time) (bool, error) {
	return true, nil
}

// IsConsensusNode is a fake interface, no need to implement.
func (bm *BftMock) IsConsensusNode() bool {
	return true
}

// GetBlock is a fake interface, no need to implement.
func (bm *BftMock) GetBlock(hash common.Hash, number uint64) *types.Block {
	return nil
}

// NextBaseBlock is a fake interface, no need to implement.
func (bm *BftMock) NextBaseBlock() *types.Block {
	return bm.Base
}

// HasBlock is a fake interface, no need to implement.
func (bm *BftMock) HasBlock(hash common.Hash, number uint64) bool {
	return true
}

// GetBlockByHash is a fake interface, no need to implement.
func (bm *BftMock) GetBlockByHash(hash common.Hash) *types.Block {
	if index, ok := bm.blockIndexs[hash]; ok {
		return bm.Blocks[index]
	}

	return nil
}

// GetBlockByHash get the specified block by hash and number.
func (bm *BftMock) GetBlockByHashAndNum(hash common.Hash, number uint64) *types.Block {
	return nil
}

// CurrentBlock is a fake interface, no need to implement.
func (bm *BftMock) CurrentBlock() *types.Block {
	return bm.Current
}

// TracingSwitch is a fake interface, no need to implement.
func (bm *BftMock) TracingSwitch(flag int8) {}

func (bm *BftMock) Pause() {}

func (bm *BftMock) Resume() {}

func (bm *BftMock) Syncing() bool {
	return false
}

func (bm *BftMock) DecodeExtra(extra []byte) (common.Hash, uint64, error) {
	return common.Hash{}, 0, nil
}