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>
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

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("could 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