early mint

Author: envestcc

blockchain/blockchain.go

@@ -94,6 +94,9 @@ type (
 		// MintNewBlock creates a new block with given actions
 		// Note: the coinbase transfer will be added to the given transfers when minting a new block
 		MintNewBlock(timestamp time.Time) (*block.Block, error)
+		// PrepareBlock start to prepares a new block with given previous hash asynchrously
+		// it can speed up the MintNewBlock
+		PrepareBlock(height uint64, prevHash []byte, timestamp time.Time) error
 		// CommitBlock validates and appends a block to the chain
 		CommitBlock(blk *block.Block) error
 		// ValidateBlock validates a new block before adding it to the blockchain
@@ -110,6 +113,7 @@ type (
 	BlockBuilderFactory interface {
 		// NewBlockBuilder creates block builder
 		NewBlockBuilder(context.Context, func(action.Envelope) (*action.SealedEnvelope, error)) (*block.Builder, error)
+		NewBlockBuilderAt(context.Context, func(action.Envelope) (*action.SealedEnvelope, error), []byte) (*block.Builder, error)
 	}
 
 	// blockchain implements the Blockchain interface
@@ -125,7 +129,8 @@ type (
 		timerFactory   *prometheustimer.TimerFactory
 
 		// used by account-based model
-		bbf BlockBuilderFactory
+		bbf     BlockBuilderFactory
+		prepare *Prepare
 	}
 )
 
@@ -187,6 +192,7 @@ func NewBlockchain(cfg Config, g genesis.Genesis, dao blockdao.BlockDAO, bbf Blo
 		bbf:           bbf,
 		clk:           clock.New(),
 		pubSubManager: NewPubSub(cfg.StreamingBlockBufferSize),
+		prepare:       newPrepare(),
 	}
 	for _, opt := range opts {
 		if err := opt(chain); err != nil {
@@ -208,7 +214,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.prepare)
 	return chain
 }
 
@@ -407,6 +413,41 @@ func (bc *blockchain) context(ctx context.Context, height uint64) (context.Conte
 	return protocol.WithFeatureWithHeightCtx(ctx), nil
 }
 
+func (bc *blockchain) PrepareBlock(height uint64, prevHash []byte, timestamp time.Time) error {
+	ctx, err := bc.context(context.Background(), height-1)
+	if err != nil {
+		return err
+	}
+	tip := protocol.MustGetBlockchainCtx(ctx).Tip
+	ctx = bc.contextWithBlock(ctx, bc.config.ProducerAddress(), height, 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()
+
+	go bc.prepare.PrepareBlock(prevHash, func() (*block.Block, error) {
+		blockBuilder, err := bc.bbf.NewBlockBuilderAt(
+			ctx,
+			func(elp action.Envelope) (*action.SealedEnvelope, error) {
+				return action.Sign(elp, minterPrivateKey)
+			},
+			prevHash,
+		)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to create block builder at height %d", height)
+		}
+		blk, err := blockBuilder.SignAndBuild(minterPrivateKey)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to create block at height %d", height)
+		}
+
+		_blockMtc.WithLabelValues("MintGas").Set(float64(blk.GasUsed()))
+		_blockMtc.WithLabelValues("MintActions").Set(float64(len(blk.Actions)))
+		return &blk, nil
+	})
+
+	return nil
+}
+
 func (bc *blockchain) MintNewBlock(timestamp time.Time) (*block.Block, error) {
 	bc.mu.RLock()
 	defer bc.mu.RUnlock()
@@ -422,6 +463,17 @@ func (bc *blockchain) MintNewBlock(timestamp time.Time) (*block.Block, error) {
 		return nil, err
 	}
 	tip := protocol.MustGetBlockchainCtx(ctx).Tip
+
+	// retrieve the draft block if it's prepared
+	pblk, err := bc.prepare.WaitBlock(tip.Hash[:])
+	if pblk != nil {
+		return pblk, nil
+	}
+	if err != nil {
+		log.L().Error("Failed to prepare new block", zap.Error(err))
+	}
+
+	// create a new block
 	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

blockchain/prepare.go

@@ -0,0 +1,73 @@
+package blockchain
+
+import (
+	"sync"
+
+	"github.com/iotexproject/go-pkgs/hash"
+
+	"github.com/iotexproject/iotex-core/v2/blockchain/block"
+)
+
+type (
+	Prepare struct {
+		draftBlocks map[hash.Hash256]chan *mintResult
+		mu          sync.Mutex
+	}
+	mintResult struct {
+		blk *block.Block
+		err error
+	}
+)
+
+func newPrepare() *Prepare {
+	return &Prepare{
+		draftBlocks: make(map[hash.Hash256]chan *mintResult),
+	}
+}
+
+func (d *Prepare) PrepareBlock(prevHash []byte, mintFn func() (*block.Block, error)) {
+	d.mu.Lock()
+	res := make(chan *mintResult, 1)
+	d.draftBlocks[hash.BytesToHash256(prevHash)] = res
+	d.mu.Unlock()
+
+	blk, err := mintFn()
+	res <- &mintResult{blk: blk, err: err}
+}
+
+func (d *Prepare) WaitBlock(prevHash []byte) (*block.Block, error) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	hash := hash.Hash256(prevHash)
+	if ch, ok := d.draftBlocks[hash]; ok {
+		// wait for the draft block
+		res := <-ch
+		delete(d.draftBlocks, hash)
+		if res.err == nil {
+			return res.blk, nil
+		}
+		return nil, res.err
+	}
+	return nil, nil
+}
+
+func (d *Prepare) ReceiveBlock(blk *block.Block) error {
+	d.mu.Lock()
+	keys := make([]hash.Hash256, 0, len(d.draftBlocks))
+	for hash, ch := range d.draftBlocks {
+		select {
+		case res := <-ch:
+			if res.err != nil {
+				keys = append(keys, hash)
+			} else if res.blk.Height() <= blk.Height() {
+				keys = append(keys, hash)
+			}
+		default:
+		}
+	}
+	for _, key := range keys {
+		delete(d.draftBlocks, key)
+	}
+	d.mu.Unlock()
+	return nil
+}

consensus/consensusfsm/context.go

@@ -41,4 +41,5 @@ type Context interface {
 	NewPreCommitEndorsement(interface{}) (interface{}, error)
 	Commit(interface{}) (bool, error)
 	ConsensusConfig
+	PrepareNextProposal(any) error
 }

consensus/consensusfsm/fsm.go

@@ -504,7 +504,7 @@ func (m *ConsensusFSM) onReceiveProposalEndorsement(evt fsm.Event, currentState
 	}
 	m.ProduceReceiveLockEndorsementEvent(lockEndorsement)
 	m.ctx.Broadcast(lockEndorsement)
-
+	m.ctx.PrepareNextProposal(lockEndorsement)
 	return sAcceptLockEndorsement, err
 }
 

consensus/scheme/rolldpos/rolldpos.go

@@ -54,6 +54,8 @@ type (
 		// MintNewBlock creates a new block with given actions
 		// Note: the coinbase transfer will be added to the given transfers when minting a new block
 		MintNewBlock(timestamp time.Time) (*block.Block, error)
+		// PrepareBlock prepares a new block with given parent hash
+		PrepareBlock(height uint64, prevHash []byte, timestamp time.Time) error
 		// CommitBlock validates and appends a block to the chain
 		CommitBlock(blk *block.Block) error
 		// ValidateBlock validates a new block before adding it to the blockchain
@@ -124,6 +126,11 @@ func (cm *chainManager) MintNewBlock(timestamp time.Time) (*block.Block, error)
 	return cm.bc.MintNewBlock(timestamp)
 }
 
+// PrepareBlock prepares a new block with given parent hash
+func (cm *chainManager) PrepareBlock(height uint64, prevHash []byte, timestamp time.Time) error {
+	return cm.bc.PrepareBlock(height, prevHash, timestamp)
+}
+
 // CommitBlock validates and appends a block to the chain
 func (cm *chainManager) CommitBlock(blk *block.Block) error {
 	return cm.bc.CommitBlock(blk)

consensus/scheme/rolldpos/rolldposctx.go

@@ -370,6 +370,14 @@ func (ctx *rollDPoSCtx) Proposal() (interface{}, error) {
 	return ctx.mintNewBlock()
 }
 
+func (ctx *rollDPoSCtx) PrepareNextProposal(endorse any) error {
+	if ctx.encodedAddr != ctx.round.nextRoundProposer {
+		return nil
+	}
+	prevHash := endorse.(*EndorsedConsensusMessage).Document().(*ConsensusVote).blkHash
+	return ctx.chain.PrepareBlock(ctx.round.height+1, prevHash, ctx.round.nextRoundStartTime)
+}
+
 func (ctx *rollDPoSCtx) WaitUntilRoundStart() time.Duration {
 	ctx.mutex.RLock()
 	defer ctx.mutex.RUnlock()

consensus/scheme/rolldpos/roundcalculator.go

@@ -60,6 +60,14 @@ func (c *roundCalculator) UpdateRound(round *roundCtx, height uint64, blockInter
 	if err != nil {
 		return nil, err
 	}
+	nextProposers, err := c.Proposers(height + 1)
+	if err != nil {
+		return nil, err
+	}
+	nextProposer, err := c.calculateProposer(height+1, 0, nextProposers)
+	if err != nil {
+		return nil, err
+	}
 	var status status
 	var blockInLock []byte
 	var proofOfLock []*endorsement.Endorsement
@@ -89,6 +97,7 @@ func (c *roundCalculator) UpdateRound(round *roundCtx, height uint64, blockInter
 		proposer:           proposer,
 		roundStartTime:     roundStartTime,
 		nextRoundStartTime: roundStartTime.Add(blockInterval),
+		nextRoundProposer:  nextProposer,
 		eManager:           round.eManager,
 		status:             status,
 		blockInLock:        blockInLock,
@@ -219,9 +228,9 @@ func (c *roundCalculator) newRound(
 ) (round *roundCtx, err error) {
 	epochNum := uint64(0)
 	epochStartHeight := uint64(0)
-	var delegates, proposers []string
+	var delegates, proposers, nextProposers []string
 	var roundNum uint32
-	var proposer string
+	var proposer, nextProposer string
 	var roundStartTime time.Time
 	if height != 0 {
 		epochNum = c.rp.GetEpochNum(height)
@@ -239,6 +248,12 @@ func (c *roundCalculator) newRound(
 			return
 		}
 	}
+	if nextProposers, err = c.Proposers(height + 1); err != nil {
+		return
+	}
+	if nextProposer, err = c.calculateProposer(height+1, 0, nextProposers); err != nil {
+		return
+	}
 	if eManager == nil {
 		if eManager, err = newEndorsementManager(nil, nil); err != nil {
 			return nil, err
@@ -257,6 +272,7 @@ func (c *roundCalculator) newRound(
 		eManager:           eManager,
 		roundStartTime:     roundStartTime,
 		nextRoundStartTime: roundStartTime.Add(blockInterval),
+		nextRoundProposer:  nextProposer,
 		status:             _open,
 	}
 	eManager.SetIsMarjorityFunc(round.EndorsedByMajority)

consensus/scheme/rolldpos/roundctx.go

@@ -38,6 +38,7 @@ type roundCtx struct {
 	roundNum           uint32
 	proposer           string
 	roundStartTime     time.Time
+	nextRoundProposer  string
 	nextRoundStartTime time.Time
 
 	blockInLock []byte

state/factory/minter.go

@@ -7,6 +7,7 @@ package factory
 
 import (
 	"context"
+	"errors"
 	"time"
 
 	"github.com/iotexproject/iotex-core/v2/action"
@@ -49,3 +50,8 @@ func (m *minter) NewBlockBuilder(ctx context.Context, sign func(action.Envelope)
 	}
 	return m.f.NewBlockBuilder(ctx, m.ap, sign)
 }
+
+func (m *minter) NewBlockBuilderAt(ctx context.Context, sign func(action.Envelope) (*action.SealedEnvelope, error), prevHash []byte) (*block.Builder, error) {
+	// TODO: implement this
+	return nil, errors.New("not implemented")
+}