fork blockchain

Author: envestcc

action/protocol/execution/protocol_test.go

@@ -478,7 +478,7 @@ func (sct *SmartContractTest) prepareBlockchain(
 		cfg.Chain,
 		cfg.Genesis,
 		dao,
-		factory.NewMinter(sf, ap),
+		factory.NewMinter(sf, ap, factory.WithPrivateKeyOption(cfg.Chain.ProducerPrivateKey())),
 		blockchain.BlockValidatorOption(block.NewValidator(
 			sf,
 			protocol.NewGenericValidator(sf, accountutil.AccountState),
@@ -730,7 +730,7 @@ func TestProtocol_Handle(t *testing.T) {
 			cfg.Chain,
 			cfg.Genesis,
 			dao,
-			factory.NewMinter(sf, ap),
+			factory.NewMinter(sf, ap, factory.WithPrivateKeyOption(cfg.Chain.ProducerPrivateKey())),
 			blockchain.BlockValidatorOption(block.NewValidator(
 				sf,
 				protocol.NewGenericValidator(sf, accountutil.AccountState),

api/serverV2_integrity_test.go

@@ -325,7 +325,7 @@ func setupChain(cfg testConfig) (blockchain.Blockchain, blockdao.BlockDAO, block
 		cfg.chain,
 		cfg.genesis,
 		dao,
-		factory.NewMinter(sf, ap),
+		factory.NewMinter(sf, ap, factory.WithPrivateKeyOption(cfg.chain.ProducerPrivateKey())),
 		blockchain.BlockValidatorOption(block.NewValidator(
 			sf,
 			protocol.NewGenericValidator(sf, accountutil.AccountState),

blockchain/blockchain.go

@@ -20,12 +20,12 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"go.uber.org/zap"
 
-	"github.com/iotexproject/iotex-core/v2/action"
 	"github.com/iotexproject/iotex-core/v2/action/protocol"
 	"github.com/iotexproject/iotex-core/v2/blockchain/block"
 	"github.com/iotexproject/iotex-core/v2/blockchain/blockdao"
 	"github.com/iotexproject/iotex-core/v2/blockchain/filedao"
 	"github.com/iotexproject/iotex-core/v2/blockchain/genesis"
+	"github.com/iotexproject/iotex-core/v2/db"
 	"github.com/iotexproject/iotex-core/v2/pkg/lifecycle"
 	"github.com/iotexproject/iotex-core/v2/pkg/log"
 	"github.com/iotexproject/iotex-core/v2/pkg/prometheustimer"
@@ -98,6 +98,8 @@ type (
 		CommitBlock(blk *block.Block) error
 		// ValidateBlock validates a new block before adding it to the blockchain
 		ValidateBlock(*block.Block, ...BlockValidationOption) error
+		// Fork returns a new blockchain instance with the given tip hash
+		Fork(hash.Hash256) (Blockchain, error)
 
 		// AddSubscriber make you listen to every single produced block
 		AddSubscriber(BlockCreationSubscriber) error
@@ -108,8 +110,12 @@ type (
 
 	// BlockBuilderFactory is the factory interface of block builder
 	BlockBuilderFactory interface {
-		// NewBlockBuilder creates block builder
-		NewBlockBuilder(context.Context, func(action.Envelope) (*action.SealedEnvelope, error)) (*block.Builder, error)
+		Mint(ctx context.Context) (*block.Block, error)
+		ReceiveBlock(*block.Block) error
+		Init(hash.Hash256)
+		AddProposal(*block.Block) error
+		Block(hash.Hash256) *block.Block
+		BlockByHeight(uint64) *block.Block
 	}
 
 	// blockchain implements the Blockchain interface
@@ -123,6 +129,7 @@ type (
 		clk            clock.Clock
 		pubSubManager  PubSubManager
 		timerFactory   *prometheustimer.TimerFactory
+		head           *block.Header
 
 		// used by account-based model
 		bbf BlockBuilderFactory
@@ -208,7 +215,7 @@ func NewBlockchain(cfg Config, g genesis.Genesis, dao blockdao.BlockDAO, bbf Blo
 	}
 	chain.lifecycle.Add(chain.dao)
 	chain.lifecycle.Add(chain.pubSubManager)
-
+	chain.pubSubManager.AddBlockListener(chain.bbf)
 	return chain
 }
 
@@ -238,7 +245,20 @@ func (bc *blockchain) Start(ctx context.Context) error {
 				EvmNetworkID: bc.EvmNetworkID(),
 			},
 		), bc.genesis))
-	return bc.lifecycle.OnStart(ctx)
+	if err := bc.lifecycle.OnStart(ctx); err != nil {
+		return err
+	}
+	tip, err := bc.dao.Height()
+	if err != nil {
+		return err
+	}
+	header, err := bc.dao.HeaderByHeight(tip)
+	if err != nil {
+		return err
+	}
+	bc.head = header
+	bc.bbf.Init(header.HashBlock())
+	return nil
 }
 
 // Stop stops the blockchain.
@@ -249,7 +269,20 @@ func (bc *blockchain) Stop(ctx context.Context) error {
 }
 
 func (bc *blockchain) BlockHeaderByHeight(height uint64) (*block.Header, error) {
-	return bc.dao.HeaderByHeight(height)
+	header, err := bc.dao.HeaderByHeight(height)
+	switch errors.Cause(err) {
+	case nil:
+		return header, nil
+	case db.ErrNotExist:
+		bc.mu.RLock()
+		defer bc.mu.RUnlock()
+		if blk := bc.draftBlockByHeight(height); blk != nil {
+			return &blk.Header, nil
+		}
+		return nil, err
+	default:
+		return nil, err
+	}
 }
 
 func (bc *blockchain) BlockFooterByHeight(height uint64) (*block.Footer, error) {
@@ -258,24 +291,18 @@ func (bc *blockchain) BlockFooterByHeight(height uint64) (*block.Footer, error)
 
 // TipHash returns tip block's hash
 func (bc *blockchain) TipHash() hash.Hash256 {
-	tipHeight, err := bc.dao.Height()
-	if err != nil {
-		return hash.ZeroHash256
-	}
-	tipHash, err := bc.dao.GetBlockHash(tipHeight)
-	if err != nil {
-		return hash.ZeroHash256
-	}
-	return tipHash
+	bc.mu.RLock()
+	defer bc.mu.RUnlock()
+
+	return bc.head.HashBlock()
 }
 
 // TipHeight returns tip block's height
 func (bc *blockchain) TipHeight() uint64 {
-	tipHeight, err := bc.dao.Height()
-	if err != nil {
-		log.L().Panic("failed to get tip height", zap.Error(err))
-	}
-	return tipHeight
+	bc.mu.RLock()
+	defer bc.mu.RUnlock()
+
+	return bc.head.Height()
 }
 
 // ValidateBlock validates a new block before adding it to the blockchain
@@ -287,10 +314,7 @@ func (bc *blockchain) ValidateBlock(blk *block.Block, opts ...BlockValidationOpt
 	if blk == nil {
 		return ErrInvalidBlock
 	}
-	tipHeight, err := bc.dao.Height()
-	if err != nil {
-		return err
-	}
+	tipHeight := bc.head.Height()
 	tip, err := bc.tipInfo(tipHeight)
 	if err != nil {
 		return err
@@ -355,7 +379,14 @@ func (bc *blockchain) ValidateBlock(blk *block.Block, opts ...BlockValidationOpt
 	if bc.blockValidator == nil {
 		return nil
 	}
-	return bc.blockValidator.Validate(ctx, blk)
+	err = bc.blockValidator.Validate(ctx, blk)
+	if err != nil {
+		return err
+	}
+	if err = bc.bbf.AddProposal(blk); err != nil {
+		log.L().Warn("failed to add block to proposal pool", zap.Error(err), zap.Uint64("height", blk.Height()), zap.Time("timestamp", blk.Timestamp()))
+	}
+	return nil
 }
 
 func (bc *blockchain) Context(ctx context.Context) (context.Context, error) {
@@ -392,7 +423,10 @@ func (bc *blockchain) context(ctx context.Context, height uint64) (context.Conte
 	if err != nil {
 		return nil, err
 	}
+	return bc.contextWithTipInfo(ctx, tip), nil
+}
 
+func (bc *blockchain) contextWithTipInfo(ctx context.Context, tip *protocol.TipInfo) context.Context {
 	ctx = genesis.WithGenesisContext(
 		protocol.WithBlockchainCtx(
 			ctx,
@@ -404,7 +438,7 @@ func (bc *blockchain) context(ctx context.Context, height uint64) (context.Conte
 		),
 		bc.genesis,
 	)
-	return protocol.WithFeatureWithHeightCtx(ctx), nil
+	return protocol.WithFeatureWithHeightCtx(ctx)
 }
 
 func (bc *blockchain) MintNewBlock(timestamp time.Time) (*block.Block, error) {
@@ -422,30 +456,23 @@ func (bc *blockchain) MintNewBlock(timestamp time.Time) (*block.Block, error) {
 		return nil, err
 	}
 	tip := protocol.MustGetBlockchainCtx(ctx).Tip
+	// create a new block
+	log.L().Debug("Produce a new block.", zap.Uint64("height", newblockHeight), zap.Time("timestamp", timestamp))
 	ctx = bc.contextWithBlock(ctx, bc.config.ProducerAddress(), newblockHeight, timestamp, protocol.CalcBaseFee(genesis.MustExtractGenesisContext(ctx).Blockchain, &tip), protocol.CalcExcessBlobGas(tip.ExcessBlobGas, tip.BlobGasUsed))
 	ctx = protocol.WithFeatureCtx(ctx)
 	// run execution and update state trie root hash
-	minterPrivateKey := bc.config.ProducerPrivateKey()
-	blockBuilder, err := bc.bbf.NewBlockBuilder(
-		ctx,
-		func(elp action.Envelope) (*action.SealedEnvelope, error) {
-			return action.Sign(elp, minterPrivateKey)
-		},
-	)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to create block builder at new block height %d", newblockHeight)
-	}
-	blk, err := blockBuilder.SignAndBuild(minterPrivateKey)
+	blk, err := bc.bbf.Mint(ctx)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to create block")
 	}
 	_blockMtc.WithLabelValues("MintGas").Set(float64(blk.GasUsed()))
 	_blockMtc.WithLabelValues("MintActions").Set(float64(len(blk.Actions)))
-	return &blk, nil
+	return blk, nil
 }
 
 // CommitBlock validates and appends a block to the chain
 func (bc *blockchain) CommitBlock(blk *block.Block) error {
+	log.L().Debug("Commit a block.", zap.Uint64("height", blk.Height()), zap.String("ioAddr", bc.config.ProducerAddress().String()))
 	bc.mu.Lock()
 	defer bc.mu.Unlock()
 	timer := bc.timerFactory.NewTimer("CommitBlock")
@@ -466,6 +493,21 @@ func (bc *blockchain) RemoveSubscriber(s BlockCreationSubscriber) error {
 	return bc.pubSubManager.RemoveBlockListener(s)
 }
 
+func (bc *blockchain) Fork(hash hash.Hash256) (Blockchain, error) {
+	bc.mu.RLock()
+	defer bc.mu.RUnlock()
+	if bc.head.HashBlock() == hash {
+		return bc, nil
+	}
+	headBlk := bc.bbf.Block(hash)
+	if headBlk == nil {
+		return nil, errors.Errorf("block %x is not in the proposal pool, tip height %d", hash, bc.head.Height())
+	}
+	fork := *bc
+	fork.head = &headBlk.Header
+	return &fork, nil
+}
+
 //======================================
 // internal functions
 //=====================================
@@ -486,11 +528,10 @@ func (bc *blockchain) tipInfo(tipHeight uint64) (*protocol.TipInfo, error) {
 			Timestamp: time.Unix(bc.genesis.Timestamp, 0),
 		}, nil
 	}
-	header, err := bc.dao.HeaderByHeight(tipHeight)
+	header, err := bc.blockByHeight(tipHeight)
 	if err != nil {
 		return nil, err
 	}
-
 	return &protocol.TipInfo{
 		Height:        tipHeight,
 		GasUsed:       header.GasUsed(),
@@ -502,6 +543,38 @@ func (bc *blockchain) tipInfo(tipHeight uint64) (*protocol.TipInfo, error) {
 	}, nil
 }
 
+func (bc *blockchain) tipInfoByHash(tipHash []byte) (*protocol.TipInfo, error) {
+	if hash.Hash256(tipHash) == bc.genesis.Hash() {
+		return &protocol.TipInfo{
+			Height:    0,
+			Hash:      bc.genesis.Hash(),
+			Timestamp: time.Unix(bc.genesis.Timestamp, 0),
+		}, nil
+	}
+
+	header, err := bc.dao.Header(hash.Hash256(tipHash))
+	switch errors.Cause(err) {
+	case nil:
+	case db.ErrNotExist:
+		if blk := bc.bbf.Block(hash.Hash256(tipHash)); blk == nil {
+			return nil, err
+		} else {
+			header = &blk.Header
+		}
+	default:
+		return nil, err
+	}
+	return &protocol.TipInfo{
+		Height:        header.Height(),
+		GasUsed:       header.GasUsed(),
+		Hash:          header.HashBlock(),
+		Timestamp:     header.Timestamp(),
+		BaseFee:       header.BaseFee(),
+		BlobGasUsed:   header.BlobGasUsed(),
+		ExcessBlobGas: header.ExcessBlobGas(),
+	}, nil
+}
+
 // commitBlock commits a block to the chain
 func (bc *blockchain) commitBlock(blk *block.Block) error {
 	tipHeight, err := bc.dao.Height()
@@ -526,6 +599,7 @@ func (bc *blockchain) commitBlock(blk *block.Block) error {
 	default:
 		return err
 	}
+	bc.head = &blk.Header
 	blkHash := blk.HashBlock()
 	if blk.Height()%100 == 0 {
 		blk.HeaderLogger(log.L()).Info("Committed a block.", log.Hex("tipHash", blkHash[:]))
@@ -548,3 +622,26 @@ func (bc *blockchain) emitToSubscribers(blk *block.Block) {
 	}
 	bc.pubSubManager.SendBlockToSubscribers(blk)
 }
+
+func (bc *blockchain) draftBlockByHeight(height uint64) *block.Block {
+	for blk := bc.bbf.Block(bc.head.HashBlock()); blk != nil && blk.Height() > height; blk = bc.bbf.Block(blk.PrevHash()) {
+		if blk.Height() == height {
+			return blk
+		}
+	}
+	return nil
+}
+
+func (bc *blockchain) blockByHeight(height uint64) (*block.Block, error) {
+	daoHeight, err := bc.dao.Height()
+	if err != nil {
+		return nil, err
+	}
+	if height > daoHeight {
+		if blk := bc.draftBlockByHeight(height); blk != nil {
+			return blk, nil
+		}
+		return nil, errors.Wrapf(db.ErrNotExist, "block %d not found", height)
+	}
+	return bc.dao.GetBlockByHeight(height)
+}

blockchain/integrity/benchmark_test.go

@@ -273,7 +273,7 @@ func newChainInDB() (blockchain.Blockchain, actpool.ActPool, error) {
 		cfg.Chain,
 		cfg.Genesis,
 		dao,
-		factory.NewMinter(sf, ap),
+		factory.NewMinter(sf, ap, factory.WithPrivateKeyOption(cfg.Chain.ProducerPrivateKey())),
 		blockchain.BlockValidatorOption(block.NewValidator(
 			sf,
 			protocol.NewGenericValidator(sf, accountutil.AccountState),