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,14 @@ type (
 		timerFactory   *prometheustimer.TimerFactory
 
 		// used by account-based model
-		bbf BlockBuilderFactory
+		bbf         BlockBuilderFactory
+		draftBlocks map[hash.Hash256]chan *mintResult
+		draftMutex  sync.Mutex
+	}
+
+	mintResult struct {
+		blk *block.Block
+		err error
 	}
 )
 
@@ -407,6 +418,54 @@ 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()
+
+	bc.draftMutex.Lock()
+	bc.draftBlocks[hash.BytesToHash256(prevHash)] = make(chan *mintResult, 1)
+	bc.draftMutex.Unlock()
+	go func() {
+		blockBuilder, err := bc.bbf.NewBlockBuilderAt(
+			ctx,
+			func(elp action.Envelope) (*action.SealedEnvelope, error) {
+				return action.Sign(elp, minterPrivateKey)
+			},
+			prevHash,
+		)
+		res := &mintResult{}
+		defer func() {
+			bc.draftMutex.Lock()
+			if _, ok := bc.draftBlocks[hash.Hash256(prevHash)]; ok {
+				bc.draftBlocks[hash.Hash256(prevHash)] <- res
+			}
+			bc.draftMutex.Unlock()
+		}()
+		if err != nil {
+			res.err = errors.Wrapf(err, "failed to create block builder at height %d", height)
+			return
+		}
+		blk, err := blockBuilder.SignAndBuild(minterPrivateKey)
+		if err != nil {
+			res.err = errors.Wrapf(err, "failed to create block at height %d", height)
+			return
+		}
+		res.blk = &blk
+
+		_blockMtc.WithLabelValues("MintGas").Set(float64(blk.GasUsed()))
+		_blockMtc.WithLabelValues("MintActions").Set(float64(len(blk.Actions)))
+	}()
+
+	return nil
+}
+
 func (bc *blockchain) MintNewBlock(timestamp time.Time) (*block.Block, error) {
 	bc.mu.RLock()
 	defer bc.mu.RUnlock()
@@ -422,6 +481,33 @@ 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 := func() (*block.Block, error) {
+		bc.draftMutex.Lock()
+		defer bc.draftMutex.Unlock()
+		if ch, ok := bc.draftBlocks[tip.Hash]; ok {
+			// wait for the draft block
+			res := <-ch
+			delete(bc.draftBlocks, tip.Hash)
+			if res.err == nil {
+				if res.blk.Timestamp() == timestamp {
+					return res.blk, nil
+				}
+				return nil, errors.Errorf("block timestamp mismatch, expected %v, actual %v height %d", res.blk.Timestamp(), timestamp, newblockHeight)
+			}
+			return nil, res.err
+		}
+		return nil, nil
+	}()
+	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
@@ -539,6 +625,10 @@ func (bc *blockchain) commitBlock(blk *block.Block) error {
 	_blockMtc.WithLabelValues("blobGasUsed").Set(float64(blk.BlobGasUsed()))
 	// emit block to all block subscribers
 	bc.emitToSubscribers(blk)
+
+	bc.draftMutex.Lock()
+	delete(bc.draftBlocks, blk.HashBlock())
+	bc.draftMutex.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

@@ -12,6 +12,7 @@ import (
 	"github.com/facebookgo/clock"
 	"github.com/iotexproject/go-fsm"
 	"github.com/iotexproject/go-pkgs/crypto"
+	"github.com/iotexproject/go-pkgs/hash"
 	"github.com/iotexproject/iotex-proto/golang/iotextypes"
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
@@ -54,6 +55,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
@@ -65,7 +68,8 @@ type (
 	}
 
 	chainManager struct {
-		bc blockchain.Blockchain
+		bc          blockchain.Blockchain
+		draftBlocks map[hash.Hash256]*block.Block
 	}
 )
 
@@ -124,6 +128,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")
+}