@jinn-network/client 0.1.7 → 0.1.8-canary.09a3b2f6

package/dist/discovery/http.js

@@ -1,4 +1,4 @@
-import { DiscoveryUnavailableError } from './types.js';
+import { DiscoveryUnavailableError, TASK_POST_WINDOW_BLOCKS, bucketTaskPostCounts } from './types.js';
 import { manifestDigestForCid } from '../adapters/mech/digest.js';
 // ── GraphQL query strings ─────────────────────────────────────────────────────
 /**
@@ -68,6 +68,8 @@ const ATTEMPTS_PAGE_LIMIT = 1000;
  * the resulting count is a lower bound; see `getSolverNetOperatorCount`.
  */
 const MAX_OPERATOR_COUNT_TASK_PAGES = 50;
+/** Page cap for the task-post-rate scan (1000 rows/page → 50k recent tasks). */
+const MAX_TASK_POST_PAGES = 50;
 const ATTEMPTS_FOR_TASKS_QUERY = `
 query AttemptsForTasks($taskIds: [String!]!, $chainId: Int!, $limit: Int!, $after: String) {
   attempts(
@@ -97,6 +99,43 @@ query AttemptsForTasks($taskIds: [String!]!, $chainId: Int!, $limit: Int!, $afte
 // scalar variables into a literal `where: { ... }` block is a bug.
 const LIST_SOLVER_NETS_QUERY = `
 query ListSolverNets($where: solverNetManifestFilter, $limit: Int!) {
+  solverNetManifests(
+    where: $where,
+    limit: $limit,
+    orderBy: "anchorBlock",
+    orderDirection: "desc"
+  ) {
+    items {
+      id
+      launcherAgentId
+      status
+      statusUpdatedAt
+      manifestHash
+      anchorBlock
+      chainId
+      name
+      network
+      solutionPriceWei
+      verdictPriceWei
+      openRoles
+      launcherSafeAddress
+      contractId
+      contractVersion
+      solverNetId
+      manifestEnrichmentStatus
+    }
+  }
+}
+`;
+// Legacy selection for the backward-compat degrade path (issue #985): the
+// pre-enrichment field set, safe against an OLD indexer that lacks the
+// enriched columns. The projection fills sentinels for the missing fields and
+// leaves manifestEnrichmentStatus undefined → treated as not-ok → sentinels.
+// These rows surface unenriched on the LIST path (empty name, '0' prices, zero
+// address); they are not re-enriched anywhere — full fields require an indexer
+// that persists the enriched columns, or the hash-verified getManifest detail path.
+const LIST_SOLVER_NETS_QUERY_LEGACY = `
+query ListSolverNetsLegacy($where: solverNetManifestFilter, $limit: Int!) {
   solverNetManifests(
     where: $where,
     limit: $limit,
@@ -181,6 +220,126 @@ query OperatorCountAttempts($taskIds: [String!]!, $chainId: Int!, $limit: Int!,
   }
 }
 `;
+/**
+ * Paginated read of verdictEnvelopeMeta rows for swe-rebench-v2 successes,
+ * scoped to a single SolverNet via `solverNetManifestCid` so multi-SolverNet
+ * operators with overlapping instance_id pools don't cross-tenant over-count
+ * (#669 Finding 2).
+ *
+ * Ponder's auto-GraphQL does not expose GROUP BY / count aggregations, so
+ * getInstanceSuccessCounts pages this query with the `after` cursor and
+ * groups client-side. Capped at 1000 per page (Ponder's upper bound on
+ * plural-query `limit`).
+ */
+const INSTANCE_SUCCESS_COUNTS_QUERY = `
+query InstanceSuccessCounts($solverNetManifestCid: String!, $limit: Int!, $after: String) {
+  verdictEnvelopeMetas(
+    where: {
+      solverNetManifestCid: $solverNetManifestCid,
+      solverType_starts_with: "swe-rebench-v2",
+      actualPassed: true,
+      enrichmentStatus: "ok",
+      instanceId_not: ""
+    },
+    limit: $limit,
+    after: $after,
+    orderBy: "enrichedAtBlock",
+    orderDirection: "asc"
+  ) {
+    items {
+      requestId
+      chainId
+      instanceId
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}
+`;
+/**
+ * Leg 1 of getInstanceClaimCounts (#802): page every task id + maxClaims for a
+ * SolverNet's manifestDigest. Leg 2 reuses ATTEMPTS_FOR_TASKS_QUERY to count
+ * attempts (= consumed slots) per task. Same two-leg shape as
+ * getSolverNetOperatorCount; the only delta is selecting maxClaims here.
+ */
+const CLAIM_COUNT_TASKS_QUERY = `
+query ClaimCountTasks($manifestDigest: String!, $limit: Int!, $after: String) {
+  tasks(
+    where: { manifestDigest: $manifestDigest },
+    limit: $limit,
+    after: $after,
+    orderBy: "id",
+    orderDirection: "asc"
+  ) {
+    items {
+      id
+      maxClaims
+      chainId
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}
+`;
+/**
+ * Task-post-rate query (#918). Pages the most-recent tasks ordered by
+ * createdAtBlock desc; the daemon reads the top row's block as the window head
+ * and buckets the three windows (1h / 6h / 24h) AND the per-cid totals
+ * client-side from createdAtBlock + manifestDigest.
+ *
+ * We do NOT push a `manifestDigest_in` / `createdAtBlock_gte` filter into the
+ * query: `manifestDigest_in` is not a stable Ponder filter operator across all
+ * deploys, and the chain-wide total needs every recent task anyway. A
+ * client-side scan-then-bucket over the most-recent N pages is the portable
+ * shape. `windowEndBlock` for the HTTP backing is the indexer's latest indexed
+ * task block (the top row), not the chain head.
+ */
+const TASK_POST_COUNTS_QUERY = `
+query TaskPostCounts($limit: Int!, $after: String) {
+  tasks(
+    limit: $limit,
+    after: $after,
+    orderBy: "createdAtBlock",
+    orderDirection: "desc"
+  ) {
+    items {
+      id
+      manifestDigest
+      createdAtBlock
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}
+`;
+/**
+ * Most-recent task for a SolverNet (#957). Filters the `task` table by
+ * `manifestDigest = keccak256(manifestCid)` (the same digest join the other
+ * task queries use), orders newest-first by `createdAtBlock`, limit 1. Returns
+ * the row's `taskCidDigest` + `id` so the caller can reconstruct the IPFS task
+ * CID and read its eligibility ref.
+ */
+const MOST_RECENT_TASK_QUERY = `
+query MostRecentTask($manifestDigest: String!) {
+  tasks(
+    where: { manifestDigest: $manifestDigest },
+    limit: 1,
+    orderBy: "createdAtBlock",
+    orderDirection: "desc"
+  ) {
+    items {
+      id
+      taskCidDigest
+    }
+  }
+}
+`;
 const QUERY_ENVELOPES_QUERY = `
 query QueryEnvelopes($where: envelopeFilter, $limit: Int!) {
   envelopes(
@@ -199,6 +358,67 @@ query QueryEnvelopes($where: envelopeFilter, $limit: Int!) {
   }
 }
 `;
+/** Sentinel for an unenriched / unknown launcher safe address. */
+const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
+/** Coerce an indexer-supplied address to a typed hex, or fall back to the zero sentinel. */
+function safeAddr(a) {
+    return typeof a === 'string' && /^0x[0-9a-fA-F]{40}$/.test(a) ? a : ZERO_ADDR;
+}
+// ── Per-codeDigest reward aggregates (#764) ──────────────────────────────────
+const CODEDIGEST_ATTEMPTS_QUERY = `
+query CodeDigestAttempts($codeDigests: [String!]!, $limit: Int!, $after: String) {
+  attemptEnvelopeMetas(
+    where: { codeDigest_in: $codeDigests, mode: "train", enrichmentStatus: "ok" },
+    limit: $limit,
+    after: $after,
+    orderBy: "enrichedAtBlock",
+    orderDirection: "desc"
+  ) {
+    items { requestId chainId codeDigest }
+    pageInfo { hasNextPage endCursor }
+  }
+}
+`;
+// The verdict leg is the only place per-SolverNet scoping is queryable: of the
+// tables this method touches, only `verdictEnvelopeMeta` carries
+// `solverNetManifestCid` (ponder.schema.ts:657 — written by the same IPFS
+// task-body enrichment that resolves instanceId). `attemptEnvelopeMeta` has no
+// SolverNet column. Aggregation (step 4) only counts requests that HAVE a
+// verdict, so filtering the verdict leg correctly scopes the whole aggregate to
+// the given SolverNet. The filter is emitted only when scoping is requested —
+// Ponder treats a `null` `where` value as "IS NULL", not "skip the filter", so
+// an unscoped call must omit the field entirely (#764).
+function codeDigestVerdictsQuery(scopeBySolverNet) {
+    return `
+query CodeDigestVerdicts($requestIds: [String!]!, $limit: Int!, $after: String${scopeBySolverNet ? ', $solverNetManifestCid: String!' : ''}) {
+  verdictEnvelopeMetas(
+    where: { requestId_in: $requestIds${scopeBySolverNet ? ', solverNetManifestCid: $solverNetManifestCid' : ''} },
+    limit: $limit,
+    after: $after,
+    orderBy: "requestId",
+    orderDirection: "asc"
+  ) {
+    items { requestId chainId actualPassed actualScore passedCount totalCount }
+    pageInfo { hasNextPage endCursor }
+  }
+}
+`;
+}
+// Optional operator scoping: restrict attempts to those the operator claimed.
+const CODEDIGEST_OPERATOR_ATTEMPTS_QUERY = `
+query CodeDigestOperatorAttempts($requestIds: [String!]!, $operator: String!, $limit: Int!, $after: String) {
+  attempts(
+    where: { requestId_in: $requestIds, operator: $operator },
+    limit: $limit,
+    after: $after,
+    orderBy: "createdAtBlock",
+    orderDirection: "asc"
+  ) {
+    items { requestId chainId }
+    pageInfo { hasNextPage endCursor }
+  }
+}
+`;
 // ── Plug-in publication queries (attd) ───────────────────────────────────────
 const LIST_PLUGIN_PUBLICATIONS_QUERY = `
 query ListPluginPublications($where: pluginPublicationFilter, $limit: Int!) {
@@ -248,6 +468,17 @@ query GetPluginScores($pluginCid: String!, $limit: Int!) {
  * a sync stall low without hammering the endpoint.
  */
 const READY_PROBE_TTL_MS = 20_000;
+/**
+ * Per-request timeout for every indexer fetch (the `/ready` probe and all
+ * GraphQL POSTs). A healthy indexer answers in well under a second; 15s is
+ * generous headroom that still recovers quickly. Its purpose is to convert a
+ * never-settling fetch (half-open socket during an indexer redeploy) into a
+ * catchable `DiscoveryUnavailableError` so the discovery/generator/catalog
+ * loops skip the tick and retry on the next poll, rather than wedging forever
+ * with no self-recovery while the indexer-independent loops mask the outage
+ * (#1038).
+ */
+const FETCH_TIMEOUT_MS = 15_000;
 // ── Helpers ───────────────────────────────────────────────────────────────────
 function parseOptionalNumber(value) {
     if (typeof value === 'number')
@@ -306,10 +537,20 @@ export function createHttpDiscoveryAPI(opts) {
     // Ponder's `/ready` lives at the host root, not under `/graphql`.
     const readyUrl = `${opts.url.replace(/\/graphql\/?$/, '').replace(/\/$/, '')}/ready`;
     const readyTtlMs = opts.readyProbeTtlMs ?? READY_PROBE_TTL_MS;
-    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
-    if (!fetchImpl) {
+    const fetchTimeoutMs = opts.fetchTimeoutMs ?? FETCH_TIMEOUT_MS;
+    const baseFetch = opts.fetchImpl ?? globalThis.fetch;
+    if (!baseFetch) {
         throw new Error('No fetch implementation available; pass fetchImpl in options');
     }
+    // Bound every indexer fetch with an AbortSignal timeout. Without it, a single
+    // fetch against an indexer whose socket went half-open (e.g. mid-redeploy)
+    // never resolves or rejects — and since the fetch is unbounded, the awaiting
+    // discovery/generator/catalog loop wedges forever with no self-recovery,
+    // while the indexer-independent loops keep running and mask the outage
+    // on-chain (#1038). A timeout turns the hang into the same
+    // DiscoveryUnavailableError those loops already catch and retry. A caller
+    // that supplies its own signal keeps it.
+    const fetchImpl = (input, init) => baseFetch(input, { ...init, signal: init?.signal ?? AbortSignal.timeout(fetchTimeoutMs) });
     // ── /ready probe (memoized with a short TTL) ──────────────────────────────
     // Ponder serves GraphQL with 200 + stale/empty data while still catching up;
     // `/ready` returns non-200 until it is at realtime. The daemon's fallback
@@ -448,7 +689,10 @@ export function createHttpDiscoveryAPI(opts) {
             // by id ASC and pages are appended in page order), but sort defensively
             // so the round-robin always pulls the lowest unclaimed id from each CID
             // even if upstream ordering ever changes.
-            bucket.sort((a, b) => Number(BigInt(a.taskId) - BigInt(b.taskId)));
+            bucket.sort((a, b) => {
+                const diff = BigInt(a.taskId) - BigInt(b.taskId);
+                return diff < 0n ? -1 : diff > 0n ? 1 : 0;
+            });
             buckets.push(bucket);
         }
         // Round-robin interleave across CID buckets: pull index 0 from each CID
@@ -477,26 +721,51 @@ export function createHttpDiscoveryAPI(opts) {
             where['status_in'] = args.status;
         if (args?.launcherAgentId)
             where['launcherAgentId'] = args.launcherAgentId;
-        const data = await postGql(gqlUrl, fetchImpl, LIST_SOLVER_NETS_QUERY, { where, limit: 200 });
-        return (data.solverNetManifests?.items ?? []).map((row) => ({
-            manifestCid: row.id,
-            // The 8 fields below are IPFS-only: not stored in the indexer. Populate
-            // with the same sentinels used by OnchainDiscoveryAPI.listLaunchedSolverNets
-            // in client/src/discovery/onchain.ts. Consumers enrich via IPFS fetch.
-            solverNetId: row.id, // best-effort: cid as id
-            name: '', // requires IPFS fetch
-            network: '', // requires IPFS fetch
-            launcherSafeAddress: '0x0000000000000000000000000000000000000000', // requires IPFS fetch
-            contractId: '', // requires IPFS fetch
-            contractVersion: '', // requires IPFS fetch
-            solutionPriceWei: '0', // requires IPFS fetch
-            verdictPriceWei: '0', // requires IPFS fetch
-            openRoles: [], // requires IPFS fetch
-            launcherAgentId: row.launcherAgentId,
-            status: row.status ?? 'launched',
-            statusUpdatedAt: row.statusUpdatedAt,
-            anchorBlock: Number(row.anchorBlock),
-        }));
+        let data;
+        try {
+            data = await postGql(gqlUrl, fetchImpl, LIST_SOLVER_NETS_QUERY, { where, limit: 200 });
+        }
+        catch (err) {
+            // Backward-compat degrade (issue #985): an OLD indexer that predates the
+            // enriched columns rejects the extended selection set with a GraphQL
+            // validation error. Mirror the getPluginScores degrade pattern: re-run
+            // the minimal legacy query and project sentinels, so a daemon on a new
+            // build still lists against an old indexer (consumers re-enrich via IPFS).
+            if (err instanceof Error && /Unknown type|Cannot query|Cannot query field/.test(err.message)) {
+                data = await postGql(gqlUrl, fetchImpl, LIST_SOLVER_NETS_QUERY_LEGACY, { where, limit: 200 });
+            }
+            else {
+                throw err;
+            }
+        }
+        return (data.solverNetManifests?.items ?? []).map((row) => {
+            // Only trust enriched fields when the indexer marked the row 'ok'. A
+            // pending/failed row (or an old indexer that omits the field) keeps the
+            // sentinel rather than presenting an empty-string price as a real value.
+            // On the LIST hot path these rows pass through unenriched (degraded but
+            // present — empty name, '0' prices, zero address); full fields arrive once
+            // indexer enrichment lands, or via the hash-verified getManifest detail path.
+            const enriched = row.manifestEnrichmentStatus === 'ok';
+            return {
+                manifestCid: row.id,
+                solverNetId: enriched && row.solverNetId ? row.solverNetId : row.id,
+                name: enriched ? (row.name ?? '') : '',
+                network: enriched ? (row.network ?? '') : '',
+                launcherSafeAddress: enriched ? safeAddr(row.launcherSafeAddress) : ZERO_ADDR,
+                contractId: enriched ? (row.contractId ?? '') : '',
+                contractVersion: enriched ? (row.contractVersion ?? '') : '',
+                solutionPriceWei: enriched ? (row.solutionPriceWei ?? '0') : '0',
+                verdictPriceWei: enriched ? (row.verdictPriceWei ?? '0') : '0',
+                openRoles: enriched
+                    ? ((row.openRoles ?? []).filter((r) => r === 'solver' || r === 'evaluator'))
+                    : [],
+                launcherAgentId: row.launcherAgentId,
+                status: row.status ?? 'launched',
+                statusUpdatedAt: row.statusUpdatedAt,
+                anchorBlock: Number(row.anchorBlock),
+                chainId: row.chainId,
+            };
+        });
     }
     // ── getLifecycleStatus ────────────────────────────────────────────────────
     async function getLifecycleStatus(manifestCid) {
@@ -672,6 +941,275 @@ export function createHttpDiscoveryAPI(opts) {
         });
         return plugins;
     }
+    // ── getInstanceSuccessCounts (#669) ────────────────────────────────────────
+    // Scoped to a single SolverNet via `verdictEnvelopeMeta.solverNetManifestCid`
+    // — the indexer enrichment writes this column from the task body's top-level
+    // `solverNetManifestCid` (task.v1 schema). Prevents multi-SolverNet operators
+    // with overlapping instance_id pools from cross-tenant over-counting
+    // (#669 Finding 2).
+    async function getInstanceSuccessCounts(args) {
+        await ensureReady();
+        // Defensive cap: 10 × 1000 rows. Expected ~125 successes per SolverNet
+        // (25 candidates × N_target_successes), so two orders of magnitude head.
+        const MAX_PAGES = 10;
+        const PAGE_LIMIT = 1000;
+        const counts = new Map();
+        const seen = new Set(); // (requestId|chainId) dedupe across pages
+        let cursor = null;
+        for (let page = 0; page < MAX_PAGES; page++) {
+            const data = await postGql(gqlUrl, fetchImpl, INSTANCE_SUCCESS_COUNTS_QUERY, { solverNetManifestCid: args.manifestCid, limit: PAGE_LIMIT, after: cursor });
+            const rows = data.verdictEnvelopeMetas?.items ?? [];
+            for (const row of rows) {
+                const key = `${row.requestId}|${row.chainId}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const id = row.instanceId;
+                if (!id)
+                    continue;
+                counts.set(id, (counts.get(id) ?? 0) + 1);
+            }
+            const pageInfo = data.verdictEnvelopeMetas?.pageInfo;
+            if (!pageInfo?.hasNextPage || !pageInfo.endCursor)
+                break;
+            cursor = pageInfo.endCursor;
+        }
+        return counts;
+    }
+    async function getCodeDigestRewards(args) {
+        if (args.codeDigests.length === 0)
+            return [];
+        await ensureReady();
+        const MAX_PAGES = 20;
+        const PAGE_LIMIT = 1000;
+        // Per-digest recency cap (#764 C1). CODEDIGEST_ATTEMPTS_QUERY orders by
+        // enrichedAtBlock desc, so attempt rows arrive newest-first. Ponder's
+        // GraphQL `limit` is global across all requested codeDigests, so the window
+        // MUST be enforced client-side per-digest — we keep only the first `window`
+        // rows seen for each codeDigest (i.e. the most recent). When undefined, no
+        // cap is applied (behaviour identical to before this change).
+        const windowCap = typeof args.window === 'number' && Number.isFinite(args.window) && args.window > 0
+            ? Math.floor(args.window)
+            : undefined;
+        // 1) Pull train-mode attempt-meta rows for the requested codeDigests,
+        //    capped to the most-recent `window` per codeDigest when set.
+        const requestKeyToDigest = new Map(); // "requestId|chainId" -> codeDigest
+        const keptPerDigest = new Map(); // codeDigest -> rows kept
+        let cursor = null;
+        for (let page = 0; page < MAX_PAGES; page++) {
+            const data = await postGql(gqlUrl, fetchImpl, CODEDIGEST_ATTEMPTS_QUERY, { codeDigests: args.codeDigests, limit: PAGE_LIMIT, after: cursor });
+            for (const row of data.attemptEnvelopeMetas?.items ?? []) {
+                if (windowCap !== undefined) {
+                    const kept = keptPerDigest.get(row.codeDigest) ?? 0;
+                    if (kept >= windowCap)
+                        continue; // already have the window's worth for this digest
+                    keptPerDigest.set(row.codeDigest, kept + 1);
+                }
+                requestKeyToDigest.set(`${row.requestId}|${row.chainId}`, row.codeDigest);
+            }
+            const pi = data.attemptEnvelopeMetas?.pageInfo;
+            if (!pi?.hasNextPage || !pi.endCursor)
+                break;
+            // Short-circuit pagination once every requested digest has filled its
+            // window — no need to keep paging history we'll discard.
+            if (windowCap !== undefined &&
+                args.codeDigests.every((d) => (keptPerDigest.get(d) ?? 0) >= windowCap))
+                break;
+            cursor = pi.endCursor;
+        }
+        if (requestKeyToDigest.size === 0)
+            return [];
+        const requestIds = [...new Set([...requestKeyToDigest.keys()].map((k) => k.split('|')[0]))];
+        // 2) Optional operator scoping: keep only requests the operator claimed.
+        let allowedKeys = null;
+        if (args.operator) {
+            allowedKeys = new Set();
+            cursor = null;
+            for (let page = 0; page < MAX_PAGES; page++) {
+                const data = await postGql(gqlUrl, fetchImpl, CODEDIGEST_OPERATOR_ATTEMPTS_QUERY, { requestIds, operator: args.operator, limit: PAGE_LIMIT, after: cursor });
+                for (const row of data.attempts?.items ?? [])
+                    allowedKeys.add(`${row.requestId}|${row.chainId}`);
+                const pi = data.attempts?.pageInfo;
+                if (!pi?.hasNextPage || !pi.endCursor)
+                    break;
+                cursor = pi.endCursor;
+            }
+        }
+        // 3) Pull verdict-meta rows for those requestIds (actualPassed/actualScore).
+        // Optionally scope to a single SolverNet: verdictEnvelopeMeta is the only
+        // queryable table carrying solverNetManifestCid, and only requests with a
+        // verdict are aggregated (step 4), so filtering here scopes the aggregate.
+        const scopeBySolverNet = typeof args.solverNetManifestCid === 'string' && args.solverNetManifestCid.length > 0;
+        const verdictsQuery = codeDigestVerdictsQuery(scopeBySolverNet);
+        const verdictByKey = new Map();
+        cursor = null;
+        for (let page = 0; page < MAX_PAGES; page++) {
+            const variables = { requestIds, limit: PAGE_LIMIT, after: cursor };
+            if (scopeBySolverNet)
+                variables.solverNetManifestCid = args.solverNetManifestCid;
+            const data = await postGql(gqlUrl, fetchImpl, verdictsQuery, variables);
+            for (const row of data.verdictEnvelopeMetas?.items ?? []) {
+                const key = `${row.requestId}|${row.chainId}`;
+                const scoreNum = Number(row.actualScore);
+                const pc = Number(row.passedCount);
+                const tc = Number(row.totalCount);
+                const graded = Number.isFinite(tc) && tc > 0 ? pc / tc : null;
+                verdictByKey.set(key, {
+                    passed: Boolean(row.actualPassed),
+                    score: Number.isFinite(scoreNum) && row.actualScore !== '' ? scoreNum : null,
+                    graded,
+                });
+            }
+            const pi = data.verdictEnvelopeMetas?.pageInfo;
+            if (!pi?.hasNextPage || !pi.endCursor)
+                break;
+            cursor = pi.endCursor;
+        }
+        // 4) Aggregate per codeDigest (only requests that HAVE a verdict count).
+        const agg = new Map();
+        for (const [key, digest] of requestKeyToDigest) {
+            if (allowedKeys && !allowedKeys.has(key))
+                continue;
+            const v = verdictByKey.get(key);
+            if (!v)
+                continue; // no verdict yet — not a completed attempt
+            const cur = agg.get(digest) ?? { attempts: 0, passes: 0, scoreSum: 0, scoreN: 0, gradedScores: [] };
+            cur.attempts += 1;
+            if (v.passed)
+                cur.passes += 1;
+            if (v.score !== null) {
+                cur.scoreSum += v.score;
+                cur.scoreN += 1;
+            }
+            if (v.graded !== null)
+                cur.gradedScores.push(v.graded);
+            agg.set(digest, cur);
+        }
+        const rows = [];
+        for (const [codeDigest, a] of agg) {
+            rows.push({
+                codeDigest,
+                attempts: a.attempts,
+                passes: a.passes,
+                passRate: a.attempts > 0 ? a.passes / a.attempts : 0,
+                avgScore: a.scoreN > 0 ? a.scoreSum / a.scoreN : 0,
+                gradedScores: a.gradedScores,
+            });
+        }
+        return rows;
+    }
+    // ── getInstanceClaimCounts (#802) ──────────────────────────────────────────
+    // Per-task consumed-vs-maxClaims for a SolverNet. Two legs, mirroring
+    // getSolverNetOperatorCount: leg 1 pages tasks (+ maxClaims) for the
+    // manifestDigest; leg 2 pages attempts (consumed slots) batched by taskId_in.
+    async function getInstanceClaimCounts(args) {
+        await ensureReady();
+        const manifestDigest = manifestDigestForCid(args.manifestCid).toLowerCase();
+        // Leg 1: task ids + maxClaims for this SolverNet (single-chain → shared chainId).
+        const maxClaimsByTaskId = new Map();
+        const taskIds = [];
+        let chainId;
+        let taskCursor = null;
+        for (let page = 0; page < MAX_OPERATOR_COUNT_TASK_PAGES; page++) {
+            const data = await postGql(gqlUrl, fetchImpl, CLAIM_COUNT_TASKS_QUERY, { manifestDigest, limit: ATTEMPTS_PAGE_LIMIT, after: taskCursor });
+            for (const row of data.tasks?.items ?? []) {
+                taskIds.push(row.id);
+                maxClaimsByTaskId.set(row.id, row.maxClaims);
+                if (chainId === undefined)
+                    chainId = row.chainId;
+            }
+            const pageInfo = data.tasks?.pageInfo;
+            if (!pageInfo?.hasNextPage || !pageInfo.endCursor)
+                break;
+            taskCursor = pageInfo.endCursor;
+        }
+        if (taskIds.length === 0 || chainId === undefined) {
+            return new Map();
+        }
+        // Leg 2: count attempts per taskId (= consumed slots), batched by taskId_in.
+        const consumedByTaskId = new Map();
+        let attemptCursor = null;
+        for (;;) {
+            const data = await postGql(gqlUrl, fetchImpl, ATTEMPTS_FOR_TASKS_QUERY, { taskIds, chainId, limit: ATTEMPTS_PAGE_LIMIT, after: attemptCursor });
+            for (const a of data.attempts?.items ?? []) {
+                consumedByTaskId.set(a.taskId, (consumedByTaskId.get(a.taskId) ?? 0) + 1);
+            }
+            const pageInfo = data.attempts?.pageInfo;
+            if (!pageInfo?.hasNextPage || !pageInfo.endCursor)
+                break;
+            attemptCursor = pageInfo.endCursor;
+        }
+        const out = new Map();
+        for (const taskId of taskIds) {
+            out.set(taskId, {
+                taskId,
+                consumed: consumedByTaskId.get(taskId) ?? 0,
+                maxClaims: maxClaimsByTaskId.get(taskId) ?? 0,
+            });
+        }
+        return out;
+    }
+    // ── getTaskPostCounts (#918) ───────────────────────────────────────────────
+    // Page the most-recent tasks (createdAtBlock desc); the top row's block is the
+    // window head. Bucket the three windows AND the per-cid totals client-side.
+    // windowEndBlock here is the indexer's latest indexed task block, not the
+    // chain head (the indexer is the source of truth on the HTTP path).
+    async function getTaskPostCounts(args) {
+        await ensureReady();
+        const windowEndTs = Math.floor(Date.now() / 1000);
+        const cids = Array.from(new Set((args?.manifestCids ?? []).filter(Boolean)));
+        const cidByDigest = new Map();
+        for (const cid of cids) {
+            cidByDigest.set(manifestDigestForCid(cid).toLowerCase(), cid);
+        }
+        // Page createdAtBlock desc. The first row sets the window head; we stop
+        // paging once a page's oldest row falls before the 24h cut (everything
+        // beyond is outside every window).
+        const rows = [];
+        let head;
+        let cursor = null;
+        for (let page = 0; page < MAX_TASK_POST_PAGES; page++) {
+            const data = await postGql(gqlUrl, fetchImpl, TASK_POST_COUNTS_QUERY, { limit: 1000, after: cursor });
+            const items = data.tasks?.items ?? [];
+            for (const row of items) {
+                const block = Number(row.createdAtBlock);
+                if (!Number.isFinite(block))
+                    continue;
+                if (head === undefined)
+                    head = block;
+                rows.push({ digest: (row.manifestDigest ?? '').toLowerCase(), block });
+            }
+            const pageInfo = data.tasks?.pageInfo;
+            // Once the oldest row this page is past the 24h cut, no further page can
+            // contribute (desc order) — stop early.
+            if (head !== undefined && items.length > 0) {
+                const oldest = Number(items[items.length - 1].createdAtBlock);
+                if (Number.isFinite(oldest) && oldest < head - TASK_POST_WINDOW_BLOCKS.h24)
+                    break;
+            }
+            if (!pageInfo?.hasNextPage || !pageInfo.endCursor)
+                break;
+            cursor = pageInfo.endCursor;
+        }
+        const windowEndBlock = head ?? 0;
+        const { chain, byCid } = bucketTaskPostCounts(windowEndBlock, windowEndTs, rows, cidByDigest);
+        return { windowEndBlock, windowEndTs, chain, byCid };
+    }
+    // ── getMostRecentTaskCidDigest (#957) ──────────────────────────────────────
+    // Single newest task (createdAtBlock desc, limit 1) for the SolverNet's
+    // manifestDigest. Pure indexer read — no IPFS hop; the caller reconstructs the
+    // task CID from the returned digest.
+    async function getMostRecentTaskCidDigest(manifestCid) {
+        await ensureReady();
+        // The indexer keys tasks by `manifestDigest = keccak256(toBytes(cid))`, not
+        // by the cid string — same join the other task queries use.
+        const manifestDigest = manifestDigestForCid(manifestCid).toLowerCase();
+        const data = await postGql(gqlUrl, fetchImpl, MOST_RECENT_TASK_QUERY, { manifestDigest });
+        const row = data.tasks?.items?.[0];
+        if (!row || !isHex(row.taskCidDigest))
+            return undefined;
+        return { taskCidDigest: row.taskCidDigest, taskId: row.id };
+    }
     return {
         findClaimableTasks,
         listLaunchedSolverNets,
@@ -681,6 +1219,11 @@ export function createHttpDiscoveryAPI(opts) {
         listPluginPublications,
         getPluginScores,
         listBuilderArtifacts,
+        getInstanceSuccessCounts,
+        getCodeDigestRewards,
+        getInstanceClaimCounts,
+        getTaskPostCounts,
+        getMostRecentTaskCidDigest,
     };
 }
 //# sourceMappingURL=http.js.map