Merge pull request #93 from wcatz/audit/cleanup-dead-code-and-docs

refactor: audit cleanup — remove dead code, fix stake bug, consolidate helpers

Author: wcatz

README.md

@@ -308,7 +308,7 @@ CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o goduckbot .
 docker pull wcatz/goduckbot:latest
 ```
 
-Multi-arch images (amd64/arm64) are published to [Docker Hub](https://hub.docker.com/r/wcatz/goduckbot) via GitHub Actions on every merge to master and tagged release.
+ARM64 images are published to [Docker Hub](https://hub.docker.com/r/wcatz/goduckbot) built locally and pushed on every release.
 
 ## Helm Chart
 

cli.go

@@ -373,7 +373,7 @@ func cmdCLIHistory(args []string) int {
 	if fromEpoch > 0 {
 		startEpoch = fromEpoch
 	} else {
-		regEpoch, regErr := fetchPoolRegistrationEpoch(ctx, cc.bech32PoolId)
+		regEpoch, regErr := fetchPoolRegistrationEpoch(ctx, koiosRESTBase(cc.networkMagic), cc.bech32PoolId)
 		if regErr != nil {
 			fmt.Fprintf(os.Stderr, "Error fetching pool registration: %v\n", regErr)
 			return 1
@@ -474,7 +474,7 @@ func cmdCLIHistory(args []string) int {
 		}
 
 		// Get OUR pool's forged slots from Koios
-		forgedSet, fErr := fetchPoolForgedSlots(ctx, cc.bech32PoolId, epoch)
+		forgedSet, fErr := fetchPoolForgedSlots(ctx, koiosRESTBase(cc.networkMagic), cc.bech32PoolId, epoch)
 		if fErr != nil {
 			log.Printf("[history] epoch %d: pool forged slots failed: %v", epoch, fErr)
 			forgedSet = make(map[uint64]bool)

commands.go

@@ -389,6 +389,7 @@ func (i *Indexer) cmdEpoch(m *telebot.Message) {
 	i.bot.Send(m.Chat, msg)
 }
 
+
 func (i *Indexer) cmdLeaderlog(m *telebot.Message) {
 	if !i.isAllowed(m) {
 		return
@@ -417,14 +418,11 @@ func (i *Indexer) cmdLeaderlog(m *telebot.Message) {
 
 	// Parse argument: "next", "current", or epoch number
 	var targetEpoch int
-	var snapType SnapshotType
 	switch {
 	case args == "next":
 		targetEpoch = i.getCurrentEpoch() + 1
-		snapType = SnapshotMark
 	case args == "current":
 		targetEpoch = i.getCurrentEpoch()
-		snapType = SnapshotSet
 	default:
 		parsed, err := strconv.Atoi(args)
 		if err != nil {
@@ -460,69 +458,9 @@ func (i *Indexer) cmdLeaderlog(m *telebot.Message) {
 			return
 		}
 
-		// Try NtC first if epoch is within snapshot range (mark/set/go)
-		var poolStake, totalStake uint64
-		curEpoch := i.getCurrentEpoch()
-		if i.nodeQuery != nil {
-			var snap SnapshotType
-			ntcAvailable := true
-			switch targetEpoch {
-			case curEpoch + 1:
-				snap = SnapshotMark
-			case curEpoch:
-				snap = SnapshotSet
-			case curEpoch - 1:
-				snap = SnapshotGo
-			default:
-				ntcAvailable = false
-			}
-			if ntcAvailable {
-				ntcCtx, ntcCancel := context.WithTimeout(ctx, 5*time.Minute)
-				snapshots, snapErr := i.nodeQuery.QueryPoolStakeSnapshots(ntcCtx, i.bech32PoolId)
-				ntcCancel()
-				if snapErr != nil {
-					log.Printf("NtC stake query for epoch %d failed: %v", targetEpoch, snapErr)
-				} else {
-					switch snap {
-					case SnapshotMark:
-						poolStake = snapshots.PoolStakeMark
-						totalStake = snapshots.TotalStakeMark
-					case SnapshotSet:
-						poolStake = snapshots.PoolStakeSet
-						totalStake = snapshots.TotalStakeSet
-					case SnapshotGo:
-						poolStake = snapshots.PoolStakeGo
-						totalStake = snapshots.TotalStakeGo
-					}
-				}
-			}
-		}
-
-		// Koios fallback for epochs outside NtC range or NtC failure
-		if poolStake == 0 && i.koios != nil {
-			curEpoch := i.getCurrentEpoch()
-			for _, tryEpoch := range []int{targetEpoch, curEpoch, curEpoch - 1, curEpoch - 2} {
-				epochNo := koios.EpochNo(tryEpoch)
-				poolHist, histErr := i.koios.GetPoolHistory(ctx, koios.PoolID(i.bech32PoolId), &epochNo, nil)
-				if histErr != nil || len(poolHist.Data) == 0 {
-					continue
-				}
-				poolStake = uint64(poolHist.Data[0].ActiveStake.IntPart())
-				epochInfo, infoErr := i.koios.GetEpochInfo(ctx, &epochNo, nil)
-				if infoErr != nil || len(epochInfo.Data) == 0 {
-					poolStake = 0
-					continue
-				}
-				totalStake = uint64(epochInfo.Data[0].ActiveStake.IntPart())
-				if tryEpoch != targetEpoch {
-					log.Printf("Using Koios stake fallback for /leaderlog %d (from epoch %d)", targetEpoch, tryEpoch)
-				}
-				break
-			}
-		}
-
-		if poolStake == 0 || totalStake == 0 {
-			replyEpoch(fmt.Sprintf("Failed to get stake for epoch %d from NtC or Koios", targetEpoch))
+		poolStake, totalStake, stakeErr := i.queryStakeForLeaderlog(ctx, targetEpoch)
+		if stakeErr != nil {
+			replyEpoch(fmt.Sprintf("Failed to get stake for epoch %d: %v", targetEpoch, stakeErr))
 			return
 		}
 
@@ -576,51 +514,9 @@ func (i *Indexer) cmdLeaderlog(m *telebot.Message) {
 		return
 	}
 
-	// Try NtC first for stake data
-	var poolStake, totalStake uint64
-	if i.nodeQuery != nil {
-		ntcCtx, ntcCancel := context.WithTimeout(ctx, 5*time.Minute)
-		snapshots, snapErr := i.nodeQuery.QueryPoolStakeSnapshots(ntcCtx, i.bech32PoolId)
-		ntcCancel()
-		if snapErr != nil {
-			log.Printf("NtC stake query for epoch %d failed: %v", targetEpoch, snapErr)
-		} else {
-			switch snapType {
-			case SnapshotSet:
-				poolStake = snapshots.PoolStakeSet
-				totalStake = snapshots.TotalStakeSet
-			default:
-				poolStake = snapshots.PoolStakeMark
-				totalStake = snapshots.TotalStakeMark
-			}
-		}
-	}
-
-	// Koios fallback if NtC unavailable or failed (try recent epochs since Koios may lag)
-	if poolStake == 0 && i.koios != nil {
-		curEpoch := i.getCurrentEpoch()
-		for _, tryEpoch := range []int{curEpoch, curEpoch - 1, curEpoch - 2} {
-			epochNo := koios.EpochNo(tryEpoch)
-			poolHist, histErr := i.koios.GetPoolHistory(ctx, koios.PoolID(i.bech32PoolId), &epochNo, nil)
-			if histErr != nil || len(poolHist.Data) == 0 {
-				continue
-			}
-			poolStake = uint64(poolHist.Data[0].ActiveStake.IntPart())
-			epochInfo, infoErr := i.koios.GetEpochInfo(ctx, &epochNo, nil)
-			if infoErr != nil || len(epochInfo.Data) == 0 {
-				poolStake = 0
-				continue
-			}
-			totalStake = uint64(epochInfo.Data[0].ActiveStake.IntPart())
-			if tryEpoch != targetEpoch {
-				log.Printf("Using Koios stake fallback for /leaderlog (from epoch %d)", tryEpoch)
-			}
-			break
-		}
-	}
-
-	if poolStake == 0 || totalStake == 0 {
-		reply(fmt.Sprintf("Failed to get stake for epoch %d from NtC or Koios", targetEpoch))
+	poolStake, totalStake, stakeErr := i.queryStakeForLeaderlog(ctx, targetEpoch)
+	if stakeErr != nil {
+		reply(fmt.Sprintf("Failed to get stake for epoch %d: %v", targetEpoch, stakeErr))
 		return
 	}
 
@@ -994,41 +890,9 @@ func (i *Indexer) cmdNextBlock(m *telebot.Message) {
 			return
 		}
 
-		var poolStake, totalStake uint64
-		if i.nodeQuery != nil {
-			ntcCtx, ntcCancel := context.WithTimeout(ctx, 5*time.Minute)
-			snapshots, snapErr := i.nodeQuery.QueryPoolStakeSnapshots(ntcCtx, i.bech32PoolId)
-			ntcCancel()
-			if snapErr != nil {
-				log.Printf("NtC stake query failed, trying Koios fallback: %v", snapErr)
-			} else {
-				poolStake = snapshots.PoolStakeSet
-				totalStake = snapshots.TotalStakeSet
-			}
-		}
-		if poolStake == 0 && i.koios != nil {
-			// Try recent epochs (Koios may lag 1-2 epochs behind)
-			for _, tryEpoch := range []int{currentEpoch, currentEpoch - 1, currentEpoch - 2} {
-				epochNo := koios.EpochNo(tryEpoch)
-				poolHist, histErr := i.koios.GetPoolHistory(ctx, koios.PoolID(i.bech32PoolId), &epochNo, nil)
-				if histErr != nil || len(poolHist.Data) == 0 {
-					log.Printf("Koios GetPoolHistory(%d) empty or error: %v", tryEpoch, histErr)
-					continue
-				}
-				poolStake = uint64(poolHist.Data[0].ActiveStake.IntPart())
-				epochInfo, infoErr := i.koios.GetEpochInfo(ctx, &epochNo, nil)
-				if infoErr != nil || len(epochInfo.Data) == 0 {
-					log.Printf("Koios GetEpochInfo(%d) failed: %v", tryEpoch, infoErr)
-					poolStake = 0
-					continue
-				}
-				totalStake = uint64(epochInfo.Data[0].ActiveStake.IntPart())
-				log.Printf("Using Koios stake fallback for /nextblock (from epoch %d)", tryEpoch)
-				break
-			}
-		}
-		if poolStake == 0 || totalStake == 0 {
-			reply("No stake data available from NtC or Koios")
+		poolStake, totalStake, stakeErr := i.queryStakeForLeaderlog(ctx, currentEpoch)
+		if stakeErr != nil {
+			reply(fmt.Sprintf("No stake data available: %v", stakeErr))
 			return
 		}
 

comprehensive_test.go

@@ -819,40 +819,6 @@ func TestStoreForgedSlots(t *testing.T) {
 	}
 }
 
-func TestStoreStreamBlockNonces(t *testing.T) {
-	store := newTestStore(t)
-	ctx := context.Background()
-
-	_, _ = store.InsertBlock(ctx, 300, 2, "h3", []byte{3}, []byte{33})
-	_, _ = store.InsertBlock(ctx, 100, 1, "h1", []byte{1}, []byte{11})
-	_, _ = store.InsertBlock(ctx, 200, 1, "h2", []byte{2}, []byte{22})
-
-	rows, err := store.StreamBlockNonces(ctx)
-	if err != nil {
-		t.Fatalf("StreamBlockNonces: %v", err)
-	}
-	defer rows.Close()
-
-	var slots []uint64
-	for rows.Next() {
-		_, slot, _, _, err := rows.Scan()
-		if err != nil {
-			t.Fatalf("Scan: %v", err)
-		}
-		slots = append(slots, slot)
-	}
-	if err := rows.Err(); err != nil {
-		t.Fatalf("Err: %v", err)
-	}
-
-	// Should be ordered by slot ASC
-	if len(slots) != 3 {
-		t.Fatalf("expected 3, got %d", len(slots))
-	}
-	if slots[0] != 100 || slots[1] != 200 || slots[2] != 300 {
-		t.Fatalf("slots not in order: %v", slots)
-	}
-}
 
 func TestStoreStreamBlockVrfOutputs(t *testing.T) {
 	store := newTestStore(t)

config.yaml.example

@@ -48,6 +48,12 @@ leaderlog:
   timezone: "America/New_York"
   timeFormat: "12h"           # "12h" or "24h"
 
+  # Advanced (full mode only):
+  # nonceIntegrityCheck: false  # After nonce backfill, verify computed nonces against Koios
+  #                              # and log any mismatches. Safe to enable; adds ~1 API call/epoch.
+  # backfillSchedules: false    # After nonce backfill, calculate and store leader schedules
+  #                              # for all historical epochs where nonce data is available.
+
 # Database configuration (only used when leaderlog.enabled is true)
 database:
   driver: "sqlite"              # "sqlite" (default) or "postgres"

db.go

@@ -311,15 +311,6 @@ func (s *PgStore) InsertBlockBatch(ctx context.Context, blocks []BlockData) erro
 	return tx.Commit(ctx)
 }
 
-func (s *PgStore) StreamBlockNonces(ctx context.Context) (BlockNonceRows, error) {
-	rows, err := s.pool.Query(ctx,
-		`SELECT epoch, slot, nonce_value, block_hash FROM blocks ORDER BY slot`,
-	)
-	if err != nil {
-		return nil, err
-	}
-	return &pgBlockNonceRows{rows: rows}, nil
-}
 
 func (s *PgStore) GetBlockByHash(ctx context.Context, hashPrefix string) ([]BlockRecord, error) {
 	rows, err := s.pool.Query(ctx,
@@ -382,46 +373,6 @@ func (s *PgStore) GetLeaderSchedule(ctx context.Context, epoch int) (*LeaderSche
 	}, nil
 }
 
-// pgBlockNonceRows wraps pgx.Rows to implement BlockNonceRows.
-type pgBlockNonceRows struct {
-	rows      pgx.Rows
-	epoch     int
-	slot      uint64
-	nonce     []byte
-	blockHash string
-	err       error
-	closed    bool
-}
-
-func (r *pgBlockNonceRows) Next() bool {
-	if r.closed {
-		return false
-	}
-	if !r.rows.Next() {
-		r.err = r.rows.Err()
-		r.closed = true
-		return false
-	}
-	var slotInt64 int64
-	r.err = r.rows.Scan(&r.epoch, &slotInt64, &r.nonce, &r.blockHash)
-	r.slot = uint64(slotInt64)
-	return r.err == nil
-}
-
-func (r *pgBlockNonceRows) Scan() (epoch int, slot uint64, nonceValue []byte, blockHash string, err error) {
-	return r.epoch, r.slot, r.nonce, r.blockHash, r.err
-}
-
-func (r *pgBlockNonceRows) Close() {
-	if !r.closed {
-		r.rows.Close()
-		r.closed = true
-	}
-}
-
-func (r *pgBlockNonceRows) Err() error {
-	return r.err
-}
 
 func (s *PgStore) StreamBlockVrfOutputs(ctx context.Context) (BlockVrfRows, error) {
 	rows, err := s.pool.Query(ctx,
@@ -500,24 +451,6 @@ func (s *PgStore) GetBlockCountForEpoch(ctx context.Context, epoch int) (int, er
 	return count, err
 }
 
-func (s *PgStore) GetNonceValuesForEpoch(ctx context.Context, epoch int) ([][]byte, error) {
-	rows, err := s.pool.Query(ctx,
-		`SELECT nonce_value FROM blocks WHERE epoch = $1 ORDER BY slot`, epoch)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var values [][]byte
-	for rows.Next() {
-		var nonce []byte
-		if err := rows.Scan(&nonce); err != nil {
-			return nil, err
-		}
-		values = append(values, nonce)
-	}
-	return values, rows.Err()
-}
 
 func (s *PgStore) GetVrfOutputsForEpoch(ctx context.Context, epoch int) ([]VrfBlock, error) {
 	rows, err := s.pool.Query(ctx,
@@ -548,15 +481,6 @@ func (s *PgStore) GetCandidateNonce(ctx context.Context, epoch int) ([]byte, err
 	return nonce, nil
 }
 
-func (s *PgStore) GetLastBlockHashForEpoch(ctx context.Context, epoch int) (string, error) {
-	var hash string
-	err := s.pool.QueryRow(ctx,
-		`SELECT block_hash FROM blocks WHERE epoch = $1 ORDER BY slot DESC LIMIT 1`, epoch).Scan(&hash)
-	if err != nil {
-		return "", err
-	}
-	return hash, nil
-}
 
 // GetPrevHashOfLastBlock returns the block hash of the second-to-last block
 // in the given epoch. This is the prevHash of the last block, which is what