Fix windowing when no validator is available

vms/proposervm/block.go

@@ -380,19 +380,21 @@ func (p *postForkCommonComponents) verifyPostDurangoBlockDelay(
 		parentPChainHeight,
 		proposer.TimeToSlot(parentTimestamp, blkTimestamp),
 	)
-	if err != nil {
+	switch {
+	case errors.Is(err, proposer.ErrAnyoneCanPropose):
+		return nil
+	case err != nil:
 		p.vm.ctx.Log.Error("unexpected block verification failure",
 			zap.String("reason", "failed to calculate expected proposer"),
 			zap.Stringer("blkID", blk.ID()),
 			zap.Error(err),
 		)
 		return err
-	}
-	if expectedProposerID != proposerID {
+	case expectedProposerID == proposerID:
+		return nil
+	default:
 		return errUnexpectedProposer
 	}
-
-	return nil
 }
 
 func (p *postForkCommonComponents) shouldBuildBlockPostDurango(
@@ -410,15 +412,17 @@ func (p *postForkCommonComponents) shouldBuildBlockPostDurango(
 		parentPChainHeight,
 		currentSlot,
 	)
-	if err != nil {
+	switch {
+	case errors.Is(err, proposer.ErrAnyoneCanPropose):
+		return nil
+	case err != nil:
 		p.vm.ctx.Log.Error("unexpected build block failure",
 			zap.String("reason", "failed to calculate expected proposer"),
 			zap.Stringer("parentID", parentID),
 			zap.Error(err),
 		)
 		return err
-	}
-	if expectedProposerID == p.vm.ctx.NodeID {
+	case expectedProposerID == p.vm.ctx.NodeID:
 		return nil
 	}
 

vms/proposervm/proposer/windower.go

@@ -37,7 +37,7 @@ const (
 var (
 	_ Windower = (*windower)(nil)
 
-	ErrNoProposersAvailable = errors.New("no proposers available")
+	ErrAnyoneCanPropose = errors.New("anyone can propose")
 )
 
 type Windower interface {
@@ -68,6 +68,7 @@ type Windower interface {
 	// able to propose from a given time on as it happens Pre-Durango).
 	// [ExpectedProposer] calculates which nodeID is scheduled to propose a
 	// block of height [blockHeight] at [slot].
+	// If no validators are currently available, [ErrAnyoneCanPropose] is returned
 	ExpectedProposer(
 		ctx context.Context,
 		blockHeight,
@@ -171,6 +172,9 @@ func (w *windower) ExpectedProposer(
 	if err != nil {
 		return ids.EmptyNodeID, err
 	}
+	if len(validators) == 0 {
+		return ids.EmptyNodeID, ErrAnyoneCanPropose
+	}
 
 	return w.expectedProposer(
 		validators,
@@ -193,6 +197,9 @@ func (w *windower) MinDelayForProposer(
 	if err != nil {
 		return 0, err
 	}
+	if len(validators) == 0 {
+		return 0, ErrAnyoneCanPropose
+	}
 
 	maxSlot := startSlot + MaxLookAheadSlots
 	for slot := startSlot; slot < maxSlot; slot++ {
@@ -263,7 +270,7 @@ func (w *windower) expectedProposer(
 	source.Seed(w.chainSource ^ blockHeight ^ bits.Reverse64(slot))
 	indices, err := sampler.Sample(1)
 	if err != nil {
-		return ids.EmptyNodeID, fmt.Errorf("%w, %w", err, ErrNoProposersAvailable)
+		return ids.EmptyNodeID, fmt.Errorf("failed sampling proposers, %w", err)
 	}
 	return validators[indices[0]].id, nil
 }

vms/proposervm/proposer/windower_test.go

@@ -41,8 +41,12 @@ func TestWindowerNoValidators(t *testing.T) {
 	require.Zero(delay)
 
 	expectedProposer, err := w.ExpectedProposer(context.Background(), chainHeight, pChainHeight, slot)
-	require.ErrorIs(err, ErrNoProposersAvailable)
+	require.ErrorIs(err, ErrAnyoneCanPropose)
 	require.Equal(ids.EmptyNodeID, expectedProposer)
+
+	delay, err = w.MinDelayForProposer(context.Background(), chainHeight, pChainHeight, nodeID, slot)
+	require.ErrorIs(err, ErrAnyoneCanPropose)
+	require.Zero(delay)
 }
 
 func TestWindowerRepeatedValidator(t *testing.T) {

vms/proposervm/vm.go

@@ -411,18 +411,22 @@ func (vm *VM) getPostDurangoSlotTime(
 		vm.ctx.NodeID,
 		slot,
 	)
-	if err != nil {
+	switch {
+	case err == nil:
+		// Note: The P-chain does not currently try to target any block time. It
+		// notifies the consensus engine as soon as a new block may be built. To
+		// avoid fast runs of blocks there is an additional minimum delay that
+		// validators can specify. This delay may be an issue for high performance,
+		// custom VMs. Until the P-chain is modified to target a specific block
+		// time, ProposerMinBlockDelay can be configured in the subnet config.
+		delay = math.Max(delay, vm.MinBlkDelay)
+		return parentTimestamp.Add(delay), err
+	case errors.Is(err, proposer.ErrAnyoneCanPropose):
+		delay = math.Max(time.Duration(0), vm.MinBlkDelay)
+		return parentTimestamp.Add(delay), err
+	default:
 		return time.Time{}, err
 	}
-
-	// Note: The P-chain does not currently try to target any block time. It
-	// notifies the consensus engine as soon as a new block may be built. To
-	// avoid fast runs of blocks there is an additional minimum delay that
-	// validators can specify. This delay may be an issue for high performance,
-	// custom VMs. Until the P-chain is modified to target a specific block
-	// time, ProposerMinBlockDelay can be configured in the subnet config.
-	delay = math.Max(delay, vm.MinBlkDelay)
-	return parentTimestamp.Add(delay), err
 }
 
 func (vm *VM) LastAccepted(ctx context.Context) (ids.ID, error) {