fix: use stability window for slot threshold

- Replace hard-coded blockfetchBatchSlotThreshold with dynamic calculation
- Use correct security parameters based on current era:
  * Byron era: K parameter from ByronGenesis.ProtocolConsts.K
  * Shelley+ eras: SecurityParam from ShelleyGenesis.SecurityParam
- Update stability window calculation in both chainsync and validation logic
- Calculate stability window as 3k/f for Shelley+ eras, k for Byron era
- Ensures blockfetch operations respect protocol-defined stability window

Fixes the TODO to calculate slot threshold from protocol params

Signed-off-by: Chris Gianelloni <wolf31o2@blinklabs.io>

Author: wolf31o2

ledger/chainsync.go

@@ -36,9 +36,8 @@ const (
 	// This prevents us exceeding the configured recv queue size in the block-fetch protocol
 	blockfetchBatchSize = 500
 
-	// TODO: calculate from protocol params
-	// Number of slots from upstream tip to stop doing blockfetch batches
-	blockfetchBatchSlotThreshold = 2500 * 20
+	// Default/fallback slot threshold for blockfetch batches
+	blockfetchBatchSlotThresholdDefault = 2500 * 20
 
 	// Timeout for updates on a blockfetch operation. This is based on a 2s BatchStart
 	// and a 2s Block timeout for blockfetch
@@ -141,8 +140,10 @@ func (ls *LedgerState) handleEventChainsyncBlockHeader(e ChainsyncEvent) error {
 	}
 	// Wait for additional block headers before fetching block bodies if we're
 	// far enough out from upstream tip
+	// Use security window as slot threshold if available
+	slotThreshold := ls.calculateStabilityWindow()
 	if e.Point.Slot < e.Tip.Point.Slot &&
-		(e.Tip.Point.Slot-e.Point.Slot > blockfetchBatchSlotThreshold) &&
+		(e.Tip.Point.Slot-e.Point.Slot > slotThreshold) &&
 		(headerCount+1) < allowedHeaderCount {
 		return nil
 	}
@@ -267,18 +268,59 @@ func (ls *LedgerState) calculateEpochNonce(
 		return genesisHashBytes, nil
 	}
 	// Calculate stability window
-	byronGenesis := ls.config.CardanoNodeConfig.ByronGenesis()
 	shelleyGenesis := ls.config.CardanoNodeConfig.ShelleyGenesis()
-	if byronGenesis == nil || shelleyGenesis == nil {
-		return nil, errors.New("could not get genesis config")
+	if shelleyGenesis == nil {
+		return nil, errors.New("could not get Shelley genesis config")
+	}
+	var securityParam uint64
+	// Use K parameter from Byron Genesis during Byron era, SecurityParam from Shelley Genesis for later eras
+	if ls.currentEra.Id == 0 { // Byron era ID is 0
+		byronGenesis := ls.config.CardanoNodeConfig.ByronGenesis()
+		if byronGenesis == nil {
+			return nil, errors.New("cloud not get Byron genesis config")
+		}
+		k := byronGenesis.ProtocolConsts.K
+		if k < 0 {
+			return nil, fmt.Errorf("k parameter must be non-negative: %d", k)
+		}
+		// Safe conversion: K is non-negative
+		securityParam = uint64(k) // #nosec G115
+	} else {
+		secParam := shelleyGenesis.SecurityParam
+		if secParam < 0 {
+			return nil, fmt.Errorf("security param must be non-negative: %d", secParam)
+		}
+		// Safe conversion: SecurityParam is non-negative
+		securityParam = uint64(secParam) // #nosec G115
+	}
+	// Calculate stability window: 3k/f for Shelley+ eras, just k for Byron
+	var stabilityWindow uint64
+	if ls.currentEra.Id == 0 { // Byron era
+		stabilityWindow = securityParam
+	} else {
+		// Validate ActiveSlotsCoeff before using it
+		if shelleyGenesis.ActiveSlotsCoeff.Rat == nil {
+			return nil, errors.New("empty ActiveSlotsCoeff")
+		}
+		activeSlotsRat := shelleyGenesis.ActiveSlotsCoeff.Rat
+		// Check for division by zero
+		if activeSlotsRat.Num().Sign() == 0 {
+			return nil, errors.New("divide by zero")
+		}
+		// Compute stability window: floor((3 * securityParam) / f)
+		// Using integer arithmetic to avoid floating point precision issues
+		numerator := new(big.Int).SetUint64(3 * securityParam)
+		quotient := new(big.Int).Div(
+			new(big.Int).Mul(numerator, activeSlotsRat.Denom()),
+			activeSlotsRat.Num(),
+		)
+
+		// Check if result fits in uint64
+		if !quotient.IsUint64() {
+			return nil, errors.New("stability window calculation result too large")
+		}
+		stabilityWindow = quotient.Uint64()
 	}
-	stabilityWindow := new(big.Rat).Quo(
-		big.NewRat(
-			int64(3*byronGenesis.ProtocolConsts.K),
-			1,
-		),
-		shelleyGenesis.ActiveSlotsCoeff.Rat,
-	).Num().Uint64()
 	var stabilityWindowStartSlot uint64
 	if epochStartSlot > stabilityWindow {
 		stabilityWindowStartSlot = epochStartSlot - stabilityWindow

ledger/state.go

@@ -406,6 +406,43 @@ func (ls *LedgerState) consumeUtxo(
 	)
 }
 
+// calculateStabilityWindow returns the stability window based on the current era.
+// For Byron era, returns k. For Shelley+ eras, returns 3k/f.
+// Returns the default threshold if genesis data is unavailable or invalid.
+func (ls *LedgerState) calculateStabilityWindow() uint64 {
+	byronGenesis := ls.config.CardanoNodeConfig.ByronGenesis()
+	shelleyGenesis := ls.config.CardanoNodeConfig.ShelleyGenesis()
+	if byronGenesis == nil || shelleyGenesis == nil {
+		return blockfetchBatchSlotThresholdDefault
+	}
+
+	var securityParam uint64
+	if ls.currentEra.Id == 0 { // Byron era
+		securityParam = uint64(byronGenesis.ProtocolConsts.K) //nolint:gosec
+		return securityParam                                  // Byron uses k directly
+	}
+
+	// Shelley+ eras
+	k := shelleyGenesis.SecurityParam
+	if k < 0 {
+		ls.config.Logger.Warn("invalid negative security parameter", "k", k)
+		return blockfetchBatchSlotThresholdDefault
+	}
+	securityParam = uint64(k)
+
+	// Calculate 3k/f
+	if shelleyGenesis.ActiveSlotsCoeff.Rat == nil {
+		ls.config.Logger.Warn("ActiveSlotsCoeff.Rat is nil")
+		return blockfetchBatchSlotThresholdDefault
+	}
+
+	result := new(big.Rat).Quo(
+		big.NewRat(int64(3*securityParam), 1), //nolint:gosec
+		shelleyGenesis.ActiveSlotsCoeff.Rat,
+	)
+	return new(big.Int).Div(result.Num(), result.Denom()).Uint64()
+}
+
 type readChainResult struct {
 	rollbackPoint ocommon.Point
 	blocks        []ledger.Block
@@ -594,22 +631,42 @@ func (ls *LedgerState) ledgerProcessBlocks() {
 					// Enable validation using the k-slot window from ShelleyGenesis.
 					if !shouldValidate && i == 0 {
 						var cutoffSlot uint64
-						// Get parameters from Shelley Genesis
-						shelleyGenesis := ls.config.CardanoNodeConfig.ShelleyGenesis()
-						if shelleyGenesis == nil {
-							return errors.New(
-								"failed to get Shelley Genesis config",
-							)
-						}
-						// Get security parameter (k)
-						k := shelleyGenesis.SecurityParam
-						if k < 0 {
-							return fmt.Errorf(
-								"security param must be non-negative: %d",
-								k,
-							)
+						// Get security parameter based on era
+						var securityParam uint64
+						if ls.currentEra.Id == 0 { // Byron era
+							byronGenesis := ls.config.CardanoNodeConfig.ByronGenesis()
+							if byronGenesis == nil {
+								return errors.New(
+									"failed to get Byron Genesis config",
+								)
+							}
+							k := byronGenesis.ProtocolConsts.K
+							if k < 0 {
+								return fmt.Errorf(
+									"k parameter must be non-negative: %d",
+									k,
+								)
+							}
+							// Safe conversion: K is non-negative
+							securityParam = uint64(k) // #nosec G115
+						} else { // Shelley and later eras
+							shelleyGenesis := ls.config.CardanoNodeConfig.ShelleyGenesis()
+							if shelleyGenesis == nil {
+								return errors.New(
+									"failed to get Shelley Genesis config",
+								)
+							}
+							// Get security parameter (k)
+							k := shelleyGenesis.SecurityParam
+							if k < 0 {
+								return fmt.Errorf(
+									"security param must be non-negative: %d",
+									k,
+								)
+							}
+							// Safe conversion: SecurityParam is non-negative
+							securityParam = uint64(k) // #nosec G115
 						}
-						securityParam := uint64(k)
 						currentTipSlot := ls.currentTip.Point.Slot
 						blockSlot := next.SlotNumber()
 						if currentTipSlot >= securityParam {