prepare next proposal

Author: envestcc

consensus/consensusfsm/context.go

@@ -34,6 +34,7 @@ type Context interface {
 	Prepare() error
 	HasDelegate() bool
 	Proposal() (interface{}, error)
+	PrepareNextProposal(any) error
 	WaitUntilRoundStart() time.Duration
 	PreCommitEndorsement() interface{}
 	NewProposalEndorsement(interface{}) (interface{}, error)

consensus/consensusfsm/fsm.go

@@ -466,7 +466,9 @@ func (m *ConsensusFSM) onReceiveBlock(evt fsm.Event) (fsm.State, error) {
 		m.ctx.Logger().Debug("Failed to generate proposal endorsement", zap.Error(err))
 		return sAcceptBlockProposal, nil
 	}
-
+	if err := m.ctx.PrepareNextProposal(cEvt.Data()); err != nil {
+		m.ctx.Logger().Warn("Failed to prepare next proposal", zap.Error(err))
+	}
 	return sAcceptProposalEndorsement, nil
 }
 

consensus/consensusfsm/fsm_test.go

@@ -240,6 +240,7 @@ func TestStateTransitionFunctions(t *testing.T) {
 		t.Run("success", func(t *testing.T) {
 			mockCtx.EXPECT().NewProposalEndorsement(gomock.Any()).Return(NewMockEndorsement(ctrl), nil).Times(1)
 			mockCtx.EXPECT().Broadcast(gomock.Any()).Return().Times(1)
+			mockCtx.EXPECT().PrepareNextProposal(gomock.Any()).Return(nil).Times(1)
 			state, err := cfsm.onReceiveBlock(&ConsensusEvent{data: NewMockEndorsement(ctrl)})
 			require.NoError(err)
 			require.Equal(sAcceptProposalEndorsement, state)

consensus/consensusfsm/mock_context_test.go

@@ -403,6 +403,52 @@ func (ctx *rollDPoSCtx) Proposal() (interface{}, error) {
 	return ctx.mintNewBlock(privateKey)
 }
 
+func (ctx *rollDPoSCtx) PrepareNextProposal(msg any) error {
+	// retrieve the block from the message
+	ecm, ok := msg.(*EndorsedConsensusMessage)
+	if !ok {
+		return errors.New("invalid endorsed block")
+	}
+	proposal, ok := ecm.Document().(*blockProposal)
+	if !ok {
+		return errors.New("invalid endorsed block")
+	}
+	var (
+		blk       = proposal.block
+		height    = blk.Height() + 1
+		interval  = ctx.BlockInterval(height)
+		startTime = blk.Timestamp().Add(interval)
+		prevHash  = blk.HashBlock()
+		err       error
+	)
+	fork, err := ctx.chain.Fork(prevHash)
+	if err != nil {
+		return errors.Wrapf(err, "failed to check fork at block %d, hash %x", blk.Height(), prevHash[:])
+	}
+	roundCalc, err := ctx.roundCalc.Fork(prevHash)
+	if err != nil {
+		return errors.Wrapf(err, "failed to fork at block %d, hash %x", blk.Height(), prevHash[:])
+	}
+	// check if the current node is the next proposer
+	nextProposer := roundCalc.Proposer(height, interval, startTime)
+	var privateKey crypto.PrivateKey = nil
+	if idx := slices.Index(ctx.encodedAddrs, nextProposer); idx < 0 {
+		return nil
+	} else {
+		privateKey = ctx.priKeys[idx]
+	}
+	ctx.logger().Debug("prepare next proposal", log.Hex("prevHash", prevHash[:]), zap.Uint64("height", ctx.round.height+1), zap.Time("timestamp", startTime), zap.String("nextproposer", nextProposer))
+	go func() {
+		blk, err := fork.MintNewBlock(startTime, privateKey, prevHash)
+		if err != nil {
+			ctx.logger().Error("failed to mint new block", zap.Error(err))
+			return
+		}
+		ctx.logger().Debug("prepared a new block", zap.Uint64("height", blk.Height()), zap.Time("timestamp", blk.Timestamp()))
+	}()
+	return nil
+}
+
 func (ctx *rollDPoSCtx) WaitUntilRoundStart() time.Duration {
 	ctx.mutex.RLock()
 	defer ctx.mutex.RUnlock()