fix(pr71): address CodeRabbit performance and context issues

1. Fix canceled context in /nextblock command:
   - Move cancelShort() after scheduleNonceMatches() call
   - Prevents passing canceled context to function

2. Add in-memory verified nonce cache:
   - Add verifiedNonces map[int][]byte to NonceTracker
   - Check cache before recomputing from genesis (10min operation)
   - Prevents blocking adder pipeline on hot paths
   - Cache guards with existing mutex

Resolves CodeRabbit findings from PR #71.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: wcatz

commands.go

@@ -921,10 +921,10 @@ func (i *Indexer) cmdNextBlock(m *telebot.Message) {
 	// Try DB first with short timeout
 	ctxShort, cancelShort := context.WithTimeout(context.Background(), 10*time.Second)
 	schedule, err := i.store.GetLeaderSchedule(ctxShort, currentEpoch)
-	cancelShort()
 	if err == nil && schedule != nil && !i.scheduleNonceMatches(ctxShort, schedule) {
 		schedule = nil
 	}
+	cancelShort()
 
 	// If no schedule, auto-compute it
 	if err != nil || schedule == nil {

nonce.go

@@ -35,19 +35,21 @@ type NonceTracker struct {
 	blockCount     int
 	candidateFroze bool // whether candidate nonce was frozen this epoch
 	networkMagic   int
-	fullMode       bool // true = genesis-seeded rolling nonce, false = lite (zero-seeded)
+	fullMode       bool           // true = genesis-seeded rolling nonce, false = lite (zero-seeded)
+	verifiedNonces map[int][]byte // in-memory cache of verified epoch nonces (full mode only)
 }
 
 // NewNonceTracker creates a NonceTracker and attempts to restore state from DB.
 // In full mode, the initial nonce is seeded with the Shelley genesis hash.
 // In lite mode, the initial nonce is zero (current behavior).
 func NewNonceTracker(store Store, koiosClient *koios.Client, epoch, networkMagic int, fullMode bool) *NonceTracker {
 	nt := &NonceTracker{
-		store:        store,
-		koiosClient:  koiosClient,
-		currentEpoch: epoch,
-		networkMagic: networkMagic,
-		fullMode:     fullMode,
+		store:          store,
+		koiosClient:    koiosClient,
+		currentEpoch:   epoch,
+		networkMagic:   networkMagic,
+		fullMode:       fullMode,
+		verifiedNonces: make(map[int][]byte),
 	}
 
 	// Try to restore evolving nonce from DB for current epoch
@@ -319,24 +321,39 @@ func (nt *NonceTracker) GetNonceForEpoch(epoch int) ([]byte, error) {
 // GetVerifiedNonceForEpoch returns a nonce that is verified against canonical
 // data for that epoch, repairing stale DB cache entries if needed.
 //
-// Full mode: always recompute from local chain data and upsert DB cache.
+// Full mode: check in-memory cache first, then recompute from local chain data
+// if not cached. Repairs stale DB entries on mismatch.
 // Lite mode: use existing lookup priority (DB -> Koios).
 func (nt *NonceTracker) GetVerifiedNonceForEpoch(epoch int) ([]byte, error) {
 	if !nt.fullMode {
 		return nt.GetNonceForEpoch(epoch)
 	}
 
+	// Check in-memory cache first (prevents repeated genesis recomputation)
+	nt.mu.Lock()
+	if cached, ok := nt.verifiedNonces[epoch]; ok {
+		nt.mu.Unlock()
+		return cached, nil
+	}
+	nt.mu.Unlock()
+
+	// Not in cache — recompute from local chain data
 	computeCtx, computeCancel := context.WithTimeout(context.Background(), 10*time.Minute)
 	defer computeCancel()
 	computed, err := nt.ComputeEpochNonce(computeCtx, epoch)
 	if err != nil {
 		return nil, fmt.Errorf("failed to verify nonce for epoch %d: %w", epoch, err)
 	}
 
+	// Check if DB cache needs repair
 	checkCtx, checkCancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer checkCancel()
 	cached, cacheErr := nt.store.GetFinalNonce(checkCtx, epoch)
 	if cacheErr == nil && cached != nil && bytes.Equal(cached, computed) {
+		// DB matches — store in memory cache and return
+		nt.mu.Lock()
+		nt.verifiedNonces[epoch] = computed
+		nt.mu.Unlock()
 		return cached, nil
 	}
 
@@ -352,6 +369,11 @@ func (nt *NonceTracker) GetVerifiedNonceForEpoch(epoch int) ([]byte, error) {
 		log.Printf("Failed to persist verified nonce for epoch %d: %v", epoch, err)
 	}
 
+	// Store in memory cache
+	nt.mu.Lock()
+	nt.verifiedNonces[epoch] = computed
+	nt.mu.Unlock()
+
 	return computed, nil
 }