epoch/finder: use GetEpochInfo instead of GetSlot for authoritative epoch

Replace the slot-based epoch approximation with GetEpochInfo which
returns the authoritative epoch directly from the RPC. This fixes an
issue where a stale GetSlot(finalized) response caused the epoch finder
to return the wrong epoch for ~51 minutes after an epoch boundary,
leading to Account Not Found alerts on all circuits.

For recent targets (within the current epoch), the authoritative epoch
from GetEpochInfo is returned directly. For targets in prior epochs,
slot math is used as before but with the authoritative slot from
GetEpochInfo.

Author: snormore

CHANGELOG.md

@@ -11,6 +11,8 @@ All notable changes to this project will be documented in this file.
 - E2E Tests
   - Add geoprobe E2E test (`TestE2E_GeoprobeDiscovery`) that exercises the full geolocation flow: deploy geolocation program, create probe onchain, start geoprobe-agent container, and verify the telemetry-agent discovers and measures the probe via TWAMP
   - Add geoprobe Docker image, geolocation program build/deploy support, and manager geolocation CLI configuration to the E2E devnet infrastructure
+- Tools
+  - Fix epoch finder returning wrong epoch for ~51 minutes after epoch boundaries by using `GetEpochInfo` (authoritative epoch) instead of approximating from `GetSlot` which was vulnerable to stale finalized slot responses ([#3227](https://github.com/malbeclabs/doublezero/pull/3227))
 
 ## [v0.11.0](https://github.com/malbeclabs/doublezero/compare/client/v0.10.0...client/v0.11.0) - 2026-03-12
 

tools/solana/pkg/epoch/finder.go

@@ -19,6 +19,7 @@ const (
 
 type SolanaRPCClient interface {
 	GetSlot(ctx context.Context, commitment solanarpc.CommitmentType) (out uint64, err error)
+	GetEpochInfo(ctx context.Context, commitment solanarpc.CommitmentType) (out *solanarpc.GetEpochInfoResult, err error)
 	GetEpochSchedule(ctx context.Context) (out *solanarpc.GetEpochScheduleResult, err error)
 	GetSignaturesForAddressWithOpts(ctx context.Context, account solana.PublicKey, opts *solanarpc.GetSignaturesForAddressOpts) ([]*solanarpc.TransactionSignature, error)
 }
@@ -73,34 +74,42 @@ func (e *epochFinder) ApproximateAtTime(ctx context.Context, target time.Time) (
 		return val.(uint64), nil
 	}
 
-	sched := e.sched.Load()
-	if sched == nil {
-		val, err := e.getEpochScheduleWithRetry(ctx)
-		if err != nil {
-			return 0, fmt.Errorf("failed to get epoch schedule: %w", err)
-		}
-		e.sched.Store(val)
-		sched = val
-	}
-
-	currentSlot, err := e.getSlotWithRetry(ctx)
+	// Use GetEpochInfo for the authoritative current epoch and slot. This avoids
+	// the failure mode where GetSlot returns a stale finalized slot from the previous
+	// epoch, causing all records to be assigned the wrong epoch.
+	epochInfo, err := e.getEpochInfoWithRetry(ctx)
 	if err != nil {
-		return 0, fmt.Errorf("failed to get current slot: %w", err)
+		return 0, fmt.Errorf("failed to get epoch info: %w", err)
 	}
 
-	slotsAgo := now.Sub(target) / ApproximateSlotDuration
-
-	if uint64(slotsAgo) > currentSlot {
-		return 0, fmt.Errorf("target time %v is too far in the past", target)
+	slotsAgo := uint64(now.Sub(target) / ApproximateSlotDuration)
+
+	var ep uint64
+	if slotsAgo <= epochInfo.SlotIndex {
+		// Target is within the current epoch — use the authoritative epoch directly.
+		ep = epochInfo.Epoch
+	} else {
+		// Target is before the current epoch — fall back to slot math.
+		sched := e.sched.Load()
+		if sched == nil {
+			val, err := e.getEpochScheduleWithRetry(ctx)
+			if err != nil {
+				return 0, fmt.Errorf("failed to get epoch schedule: %w", err)
+			}
+			e.sched.Store(val)
+			sched = val
+		}
+		if slotsAgo > epochInfo.AbsoluteSlot {
+			return 0, fmt.Errorf("target time %v is too far in the past", target)
+		}
+		approxSlot := epochInfo.AbsoluteSlot - slotsAgo
+		ep = e.getEpochForSlot(approxSlot, sched)
 	}
-	approxSlot := currentSlot - uint64(slotsAgo)
-
-	epoch := e.getEpochForSlot(approxSlot, sched)
 
-	e.cache.SetWithTTL(cacheKey, epoch, 0, 30*time.Minute)
+	e.cache.SetWithTTL(cacheKey, ep, 0, 30*time.Minute)
 	e.cache.Wait()
 
-	return epoch, nil
+	return ep, nil
 }
 
 func (e *epochFinder) getEpochForSlot(slot uint64, sched *solanarpc.GetEpochScheduleResult) uint64 {
@@ -128,23 +137,19 @@ func (e *epochFinder) getEpochForSlot(slot uint64, sched *solanarpc.GetEpochSche
 	return epoch
 }
 
-func (e *epochFinder) getSlotWithRetry(ctx context.Context) (uint64, error) {
+func (e *epochFinder) getEpochInfoWithRetry(ctx context.Context) (*solanarpc.GetEpochInfoResult, error) {
 	attempt := 0
-	slot, err := backoff.Retry(ctx, func() (uint64, error) {
+	info, err := backoff.Retry(ctx, func() (*solanarpc.GetEpochInfoResult, error) {
 		if attempt > 1 {
-			e.log.Warn("Failed to get current slot, retrying", "attempt", attempt)
+			e.log.Warn("Failed to get epoch info, retrying", "attempt", attempt)
 		}
 		attempt++
-		slot, err := e.client.GetSlot(ctx, solanarpc.CommitmentFinalized)
-		if err != nil {
-			return 0, err
-		}
-		return slot, nil
+		return e.client.GetEpochInfo(ctx, solanarpc.CommitmentFinalized)
 	}, backoff.WithBackOff(backoff.NewExponentialBackOff()))
 	if err != nil {
-		return 0, fmt.Errorf("failed to get current slot: %w", err)
+		return nil, fmt.Errorf("failed to get epoch info: %w", err)
 	}
-	return slot, nil
+	return info, nil
 }
 
 func (e *epochFinder) getEpochScheduleWithRetry(ctx context.Context) (*solanarpc.GetEpochScheduleResult, error) {