fix(treasury): honest subnet and auction figures for the KPI cards

Runtime verification caught both: splits pay through the warehouse, so
the split-address filter summed zero — subnet earnings now walk
warehouse→treasury USDC transfers and keep the ones the final split
emitted in, the ledger's own attribution rule. And the settled-auction
count saturated at one subgraph page (Gnars is past 2000 auctions) —
now cursor-paged by id.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: sktbrd

src/services/dao.ts

@@ -63,26 +63,41 @@ export const fetchTotalAuctionSalesWei = cache(async (): Promise<bigint> => {
 });
 
 const SETTLED_AUCTION_IDS_GQL = /* GraphQL */ `
-  query SettledAuctionIds($dao: String!) {
-    auctions(where: { dao: $dao, settled: true }, first: 1000) {
+  query SettledAuctionIds($dao: String!, $after: ID!) {
+    auctions(
+      where: { dao: $dao, settled: true, id_gt: $after }
+      first: 1000
+      orderBy: id
+      orderDirection: asc
+    ) {
       id
     }
   }
 `;
 
 /**
- * Count of settled auctions. The subgraph pages at 1000, so this saturates
- * there — at the DAO's ~1/day cadence that is years away, and the KPI note
- * degrades to "1000 auctions settled", not a wrong number. `0` = count
- * unavailable; callers omit the note rather than claiming zero history.
+ * Count of settled auctions. There is no aggregate on the DAO entity (and
+ * `tokensCount` counts founder mints too), so this cursors through id-only
+ * pages — ~8 requests for Gnars' ~7k auctions, refreshed at the page's ISR
+ * cadence. The 20-page guard is a runaway stop, not an expected ceiling.
+ * `0` = count unavailable; callers omit the note rather than claiming zero.
  */
 export const fetchSettledAuctionCount = cache(async (): Promise<number> => {
   try {
-    const data = await subgraphQuery<{ auctions?: Array<{ id: string }> }>(
-      SETTLED_AUCTION_IDS_GQL,
-      { dao: DAO_ADDRESSES.token.toLowerCase() },
-    );
-    return data.auctions?.length ?? 0;
+    const dao = DAO_ADDRESSES.token.toLowerCase();
+    let count = 0;
+    let after = "";
+    for (let page = 0; page < 20; page += 1) {
+      const data = await subgraphQuery<{ auctions?: Array<{ id: string }> }>(
+        SETTLED_AUCTION_IDS_GQL,
+        { dao, after },
+      );
+      const ids = data.auctions ?? [];
+      count += ids.length;
+      if (ids.length < 1000) return count;
+      after = ids[ids.length - 1].id;
+    }
+    return count;
   } catch {
     return 0;
   }

src/services/treasury-inflows.ts

@@ -291,17 +291,19 @@ export interface SubnetEarnings {
 }
 
 /**
- * All-time Morpheus subnet earnings: every USDC transfer from the final split
- * to the treasury. The paged inflows feed above is a window and cannot sum
- * honestly; this asks Alchemy for exactly the split→treasury lane and walks
- * every page (the claim history is tiny). `null` = could not determine —
- * the KPI card renders a dash, never a fabricated 0.
+ * All-time Morpheus subnet earnings. Splits pay through the warehouse (see the
+ * SPLITS_WAREHOUSE note above — the split address is never the `from`), so
+ * this walks every warehouse→treasury USDC transfer and keeps the ones whose
+ * transaction the subnet's final split emitted in, the same attribution rule
+ * the inflows ledger uses. The paged inflows feed above is a window and cannot
+ * sum honestly; this lane's full history is tiny, and the per-tx receipts are
+ * immutable and day-cached. `null` = could not determine — the KPI card
+ * renders a dash, never a fabricated 0.
  */
 export const loadSubnetEarnings = cache(async (): Promise<SubnetEarnings | null> => {
   if (!ALCHEMY_KEY) return null;
   try {
-    let totalUsdc = 0;
-    let claimCount = 0;
+    const transfers: Array<{ value: number; hash: string }> = [];
     let pageKey: string | undefined;
     do {
       const res = await fetch(`https://base-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}`, {
@@ -313,7 +315,7 @@ export const loadSubnetEarnings = cache(async (): Promise<SubnetEarnings | null>
           method: "alchemy_getAssetTransfers",
           params: [
             {
-              fromAddress: SUBNET_FINAL_SPLIT,
+              fromAddress: SPLITS_WAREHOUSE,
               toAddress: DAO_ADDRESSES.treasury,
               contractAddresses: [USDC],
               category: ["erc20"],
@@ -327,16 +329,27 @@ export const loadSubnetEarnings = cache(async (): Promise<SubnetEarnings | null>
       });
       if (!res.ok) throw new Error(`Alchemy ${res.status}`);
       const json = (await res.json()) as {
-        result?: { transfers?: Array<{ value: number | null }>; pageKey?: string };
+        result?: {
+          transfers?: Array<{ value: number | null; hash?: string }>;
+          pageKey?: string;
+        };
         error?: { message?: string };
       };
       if (json.error) throw new Error(json.error.message ?? "Alchemy error");
       for (const t of json.result?.transfers ?? []) {
-        totalUsdc += t.value ?? 0;
-        claimCount += 1;
+        if (t.hash) transfers.push({ value: t.value ?? 0, hash: t.hash });
       }
       pageKey = json.result?.pageKey;
     } while (pageKey);
+
+    const sources = await Promise.all(transfers.map((t) => splitSourceForTx(t.hash)));
+    let totalUsdc = 0;
+    let claimCount = 0;
+    for (let i = 0; i < transfers.length; i += 1) {
+      if (sources[i] !== "subnet") continue;
+      totalUsdc += transfers[i].value;
+      claimCount += 1;
+    }
     return { totalUsdc, claimCount };
   } catch {
     return null;