@jinn-network/client 0.1.6 → 0.1.7-canary.17a8ecb8

package/dist/api/gather-status.js

@@ -1,21 +1,24 @@
 /**
  * Best-effort status collection for GET /v1/status (RPC + earning store + SQLite).
  */
-import { createPublicClient, http } from 'viem';
+import { createPublicClient, getAddress, http, parseAbiItem } from 'viem';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { base, baseSepolia } from 'viem/chains';
+import { isOverSpendCap } from '../daemon/spend-cap-gate.js';
 import { FleetStateStore } from '../earning/store.js';
-import { getChainConfig } from '../earning/contracts.js';
+import { DEFAULT_TESTNET_ARTIFACTS, getChainConfig, loadJinnMviConfig, } from '../earning/contracts.js';
+import { createJinnL1PublicClient } from '../earning/viem-clients.js';
 import { stage1MinMasterEth } from '../earning/bootstrap.js';
 import { JINN_STAKING_ABI } from '../earning/jinn-rewards.js';
 import { displayFleetServiceIndex } from '../earning/fleet-display-index.js';
-import { assembleStatusV1, resolveMasterDailyEstimateWei, } from './status-build.js';
+import { assembleStatusV1, pendingTjinnStatus, TJINN_PUBLIC_INVALID_SAFE_ERROR, TJINN_PUBLIC_PARTIAL_ERROR, TJINN_PUBLIC_READ_ERROR, resolveMasterDailyEstimateWei, } from './status-build.js';
 import { listStolasClaimTargets } from '../earning/stolas-claim.js';
 import { gatherPortfolioV0Status, DEFAULT_ENGINE_WORKING_DIR_ROOT, } from './portfolio-v0-build.js';
 import { gatherPredictionV1Status, } from './prediction-v1-build.js';
 import { gatherTaskRunsStatus } from './task-runs-build.js';
 import { buildPredictionOperatorStatus, } from '../solver-nets/prediction-operator-ux.js';
+import { findJoinedByName, rolesFromJoinedConfig, solverTypeFromJoinedContract, } from '../solver-nets/registry.js';
 const ERC20_BALANCE_OF_ABI = [
     {
         type: 'function',
@@ -25,6 +28,81 @@ const ERC20_BALANCE_OF_ABI = [
         outputs: [{ name: '', type: 'uint256' }],
     },
 ];
+const JINN_DISTRIBUTOR_CLAIMED_ABI = [
+    {
+        type: 'function',
+        name: 'totalClaimedOperator',
+        stateMutability: 'view',
+        inputs: [{ name: 'serviceId', type: 'uint256' }],
+        outputs: [{ name: '', type: 'uint256' }],
+    },
+];
+/**
+ * `Claimed` event item for `getLogs({ event, args })`. Matches the
+ * Solidity signature in
+ * `contracts/src/jinn/distribution/JinnDistributor.sol` so the operator
+ * 24h-minted sum can be computed without a separate indexer.
+ */
+const JINN_DISTRIBUTOR_CLAIMED_EVENT = parseAbiItem('event Claimed(uint256 indexed serviceId, address indexed multisig, uint256 operatorMinted, uint256 daoMinted, uint256 totalEntitledOperator, uint256 totalEntitledDao)');
+const TJINN_BALANCE_CACHE_TTL_MS = 30_000;
+const TJINN_BALANCE_TIMEOUT_MS = 6_000;
+/**
+ * Approximate Sepolia blocks per 24 hours. The chain produces a block every
+ * ~12s; 86_400 / 12 = 7_200. We pad to 7_500 to absorb the occasional
+ * slower block and keep the window comfortably within the common 10k-block
+ * `eth_getLogs` cap.
+ */
+const SEPOLIA_BLOCKS_PER_24H = 7500n;
+/**
+ * tJINN token address + chain id resolved from the bundled JINN MVI L1
+ * deployment artifact — the single source of truth. Used only when the caller
+ * (`main.ts`) does not thread explicit values through `StatusGatherConfig`
+ * (e.g. test callers, sqlite-only introspection without config). Lazy + cached
+ * so the artifact read happens at most once per process.
+ */
+let cachedTjinnArtifactIdentity;
+function defaultTjinnIdentity() {
+    if (!cachedTjinnArtifactIdentity) {
+        let tokenAddress;
+        let chainId;
+        try {
+            const mvi = loadJinnMviConfig({ l1ArtifactPath: DEFAULT_TESTNET_ARTIFACTS.jinnMviL1 });
+            tokenAddress = mvi.jinn;
+            chainId = mvi.l1ChainId;
+        }
+        catch {
+            // Fall through to the hard defaults below if the artifact is unreadable.
+        }
+        cachedTjinnArtifactIdentity = {
+            tokenAddress: tokenAddress ?? '0x0bc0B2f733bF4229FD58Baaac5ebFEf2AEc83C4A',
+            chainId: chainId ?? 11155111,
+        };
+    }
+    return cachedTjinnArtifactIdentity;
+}
+function resolveTjinnIdentity(status) {
+    const fallback = defaultTjinnIdentity();
+    return {
+        tokenAddress: status?.tjinnTokenAddress ?? fallback.tokenAddress,
+        chainId: status?.tjinnChainId ?? fallback.chainId,
+    };
+}
+/** Fill a fresh errors Map with `TJINN_PUBLIC_READ_ERROR` for every key. */
+function errorsForAllKeys(keys) {
+    const errors = new Map();
+    for (const key of keys) {
+        errors.set(key, TJINN_PUBLIC_READ_ERROR);
+    }
+    return errors;
+}
+function errorsForAllServiceIds(serviceIds) {
+    const errors = new Map();
+    for (const serviceId of serviceIds) {
+        errors.set(serviceId, TJINN_PUBLIC_READ_ERROR);
+    }
+    return errors;
+}
+const tjinnBalanceCache = new Map();
 function readDaemonRuntime(earningDir) {
     if (!earningDir)
         return undefined;
@@ -62,6 +140,24 @@ export function invalidatePredictionOperatorStatusCache(config) {
 function chainKey(network) {
     return network === 'testnet' ? 'base-sepolia' : 'base';
 }
+/**
+ * Derive the SolverNet name to use for the prediction operator diagnostic.
+ *
+ * Priority: (1) first joined entry's `name` field, (2) first joined entry's
+ * manifestCid, (3) fallback `'prediction'`.
+ *
+ * Post-issue-#421 the legacy `solverNets` config block has been retired; the
+ * operator's participation choices live in `joinedSolverNets` keyed by
+ * manifestCid.
+ */
+function derivePredictionSolverNetName(config) {
+    const joinedEntries = Object.entries(config.joinedSolverNets ?? {});
+    if (joinedEntries.length > 0) {
+        const [cid, entry] = joinedEntries[0];
+        return entry.name ?? cid;
+    }
+    return 'prediction';
+}
 function predictionOperatorCacheKey(configPath, name) {
     return `${configPath}\0${name}`;
 }
@@ -77,41 +173,42 @@ async function getCachedPredictionOperatorStatus(config, configPath, name) {
         // gather-status only runs inside a live daemon; the operator-status
         // surface should reflect that (Issue #86 §1: drop the vacuous
         // "start the daemon" copy when the daemon is already running).
-        cached = buildPredictionOperatorStatus({ config, configPath, name, daemonRunning: true })
+        cached = buildPredictionOperatorStatus({ config, configPath, daemonRunning: true })
             .catch((error) => predictionOperatorUnavailable(config, configPath, name, errorMessage(error)));
         byKey.set(key, cached);
     }
     return cached;
 }
 function predictionOperatorUnavailable(config, configPath, name, message) {
-    const net = config.solverNets[name];
+    // Resolve the matching joined entry by display name (or manifestCid) so
+    // the diagnostic can still surface the operator's configured roles when
+    // possible.
+    const joined = findJoinedByName(config.joinedSolverNets, name);
     const diagnostic = {
         code: 'prediction_operator_status_unavailable',
         severity: 'error',
         message,
         nextAction: {
-            description: 'Inspect Prediction SolverNet configuration and restart the daemon after fixing it.',
-            cli: `jinn solver-nets show ${name}`,
+            description: 'Inspect Prediction SolverNet configuration via Operator > SolverNets and restart the daemon after fixing it.',
+            url: '/operator#solvernets',
         },
     };
     // Roles are best-effort: an unavailable status path means the daemon
-    // could not load the SolverNet, so we surface whatever the operator has
-    // configured (post-migration) without trying to default further.
-    const rawRoles = net?.roles;
-    const netRoles = Array.isArray(rawRoles)
-        ? rawRoles.filter((r) => r === 'solving' || r === 'evaluating')
-        : [];
+    // could not load the SolverNet, so we surface whatever the operator
+    // joined.
+    const netRoles = joined ? rolesFromJoinedConfig(joined) : [];
+    const solverType = (joined && solverTypeFromJoinedContract(joined)) ?? 'prediction.v1';
     return {
         kind: 'prediction.v1.operatorStatus',
         ok: false,
         configPath,
         solverNet: {
             name,
-            enabled: net?.enabled ?? false,
-            solverType: net?.solverType ?? 'prediction.v1',
+            enabled: joined ? netRoles.length > 0 : false,
+            solverType,
             roles: netRoles,
-            harness: net?.harness,
-            taskGeneratorEnabled: net?.taskGenerator.enabled ?? false,
+            harness: joined?.harness,
+            taskGeneratorEnabled: false,
         },
         runtimePlugins: [],
         diagnostics: [diagnostic],
@@ -163,6 +260,8 @@ function predictionV1Unavailable(operator, operatorError) {
             solutions: 0,
             verdicts: 0,
             failed: 0,
+            settledFailed: 0,
+            localErrors: 0,
         },
         latest: {
             taskAt: null,
@@ -177,6 +276,158 @@ function predictionV1Unavailable(operator, operatorError) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function tJinnBalanceCacheKey(ethereumRpcUrl, distributorAddress, safeKeys, serviceIds) {
+    return [
+        ethereumRpcUrl,
+        distributorAddress ?? '',
+        [...safeKeys].sort().join(','),
+        [...serviceIds].sort((a, b) => a - b).join(','),
+    ].join('\0');
+}
+function timeoutError(message) {
+    const error = new Error(message);
+    error.name = 'TimeoutError';
+    return error;
+}
+function withTimeout(promise, timeoutMs, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(timeoutError(message)), timeoutMs);
+        promise
+            .then(resolve, reject)
+            .finally(() => clearTimeout(timer));
+    });
+}
+async function readTjinnBalances(ethereumRpcUrl, tokenAddress, distributorAddress, expectedChainId, safeToAddress, serviceIds) {
+    const safeEntries = [...safeToAddress.entries()];
+    const client = createJinnL1PublicClient(ethereumRpcUrl, 'sepolia');
+    const chainId = await client.getChainId();
+    const balances = new Map();
+    const operatorClaimedByService = new Map();
+    const operatorMintedLast24hByService = new Map();
+    if (chainId !== expectedChainId) {
+        return {
+            chainId,
+            balances,
+            operatorClaimedByService,
+            operatorMintedLast24hByService,
+            errors: errorsForAllKeys(safeToAddress.keys()),
+            claimedErrors: errorsForAllServiceIds(serviceIds),
+            claimedLast24hError: TJINN_PUBLIC_READ_ERROR,
+        };
+    }
+    const errors = new Map();
+    // Single multicall3 round-trip (Sepolia has multicall3). `allowFailure: true`
+    // preserves the per-Safe partial-failure handling — a failed entry yields a
+    // `{ status: 'failure' }` result rather than rejecting the whole batch.
+    const results = await client.multicall({
+        allowFailure: true,
+        contracts: safeEntries.map(([, safeAddress]) => ({
+            address: tokenAddress,
+            abi: ERC20_BALANCE_OF_ABI,
+            functionName: 'balanceOf',
+            args: [safeAddress],
+        })),
+    });
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const key = safeEntries[i]?.[0];
+        if (!key)
+            continue;
+        if (result.status === 'success') {
+            balances.set(key, result.result.toString());
+        }
+        else {
+            errors.set(key, TJINN_PUBLIC_READ_ERROR);
+        }
+    }
+    const claimedErrors = new Map();
+    if (distributorAddress && serviceIds.length > 0) {
+        const claimedResults = await client.multicall({
+            allowFailure: true,
+            contracts: serviceIds.map((serviceId) => ({
+                address: distributorAddress,
+                abi: JINN_DISTRIBUTOR_CLAIMED_ABI,
+                functionName: 'totalClaimedOperator',
+                args: [BigInt(serviceId)],
+            })),
+        });
+        for (let i = 0; i < claimedResults.length; i++) {
+            const serviceId = serviceIds[i];
+            if (serviceId === undefined)
+                continue;
+            const result = claimedResults[i];
+            if (result.status === 'success') {
+                operatorClaimedByService.set(serviceId, result.result.toString());
+            }
+            else {
+                claimedErrors.set(serviceId, TJINN_PUBLIC_READ_ERROR);
+            }
+        }
+    }
+    let claimedLast24hError = null;
+    if (distributorAddress && serviceIds.length > 0) {
+        try {
+            const latest = await client.getBlockNumber();
+            const fromBlock = latest > SEPOLIA_BLOCKS_PER_24H ? latest - SEPOLIA_BLOCKS_PER_24H : 0n;
+            const logs = await client.getLogs({
+                address: distributorAddress,
+                event: JINN_DISTRIBUTOR_CLAIMED_EVENT,
+                args: { serviceId: serviceIds.map((id) => BigInt(id)) },
+                fromBlock,
+                toBlock: latest,
+            });
+            const sums = new Map();
+            for (const log of logs) {
+                const args = log.args;
+                if (args.serviceId === undefined || args.operatorMinted === undefined)
+                    continue;
+                const id = Number(args.serviceId);
+                sums.set(id, (sums.get(id) ?? 0n) + args.operatorMinted);
+            }
+            for (const serviceId of serviceIds) {
+                operatorMintedLast24hByService.set(serviceId, (sums.get(serviceId) ?? 0n).toString());
+            }
+        }
+        catch {
+            claimedLast24hError = TJINN_PUBLIC_READ_ERROR;
+        }
+    }
+    return {
+        chainId,
+        balances,
+        operatorClaimedByService,
+        operatorMintedLast24hByService,
+        errors,
+        claimedErrors,
+        claimedLast24hError,
+    };
+}
+async function getCachedTjinnBalances(ethereumRpcUrl, tokenAddress, distributorAddress, expectedChainId, safeToAddress, serviceIds) {
+    const safeKeys = [...safeToAddress.keys()].sort();
+    const sortedServiceIds = [...serviceIds].sort((a, b) => a - b);
+    const cacheKey = tJinnBalanceCacheKey(ethereumRpcUrl, distributorAddress, safeKeys, sortedServiceIds);
+    const now = Date.now();
+    const cached = tjinnBalanceCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+        return cached.promise;
+    }
+    const promise = withTimeout(readTjinnBalances(ethereumRpcUrl, tokenAddress, distributorAddress, expectedChainId, safeToAddress, sortedServiceIds), TJINN_BALANCE_TIMEOUT_MS, 'tJINN balance collection timed out').catch(() => {
+        return {
+            chainId: expectedChainId,
+            balances: new Map(),
+            operatorClaimedByService: new Map(),
+            operatorMintedLast24hByService: new Map(),
+            errors: errorsForAllKeys(safeKeys),
+            claimedErrors: errorsForAllServiceIds(sortedServiceIds),
+            claimedLast24hError: TJINN_PUBLIC_READ_ERROR,
+        };
+    });
+    tjinnBalanceCache.set(cacheKey, {
+        expiresAt: now + TJINN_BALANCE_CACHE_TTL_MS,
+        promise,
+    });
+    return promise;
+}
 async function sumPendingStakingRewards(rpcUrl, network, fleet) {
     const targets = listStolasClaimTargets(fleet.services);
     if (targets.length === 0) {
@@ -228,6 +479,158 @@ async function sumPendingStakingRewards(rpcUrl, network, fleet) {
         return { error: e instanceof Error ? e.message : String(e) };
     }
 }
+/**
+ * Resolve the public error string for a tJINN status with at least one error.
+ *
+ * Flattened from a 3-deep nested ternary into guard clauses:
+ *  - partial success (some balances read) → PARTIAL
+ *  - only invalid-Safe errors             → INVALID_SAFE
+ *  - otherwise (RPC read failures)        → READ_ERROR
+ *
+ * Caller must only invoke this when `hasInvalidSafe || hasReadError` is true.
+ */
+function tjinnPublicError(opts) {
+    if (opts.hasAnyBalance)
+        return TJINN_PUBLIC_PARTIAL_ERROR;
+    if (opts.hasInvalidSafe && !opts.hasReadError)
+        return TJINN_PUBLIC_INVALID_SAFE_ERROR;
+    return TJINN_PUBLIC_READ_ERROR;
+}
+async function gatherTjinnStatus(ethereumRpcUrl, tokenAddress, distributorAddress, chainId, fleet) {
+    if (!fleet) {
+        return pendingTjinnStatus(tokenAddress, chainId);
+    }
+    const services = [];
+    const safeToAddress = new Map();
+    const serviceIds = new Set();
+    for (const svc of fleet.services) {
+        const index = displayFleetServiceIndex(svc);
+        const serviceId = svc.service_id ?? null;
+        if (serviceId !== null) {
+            serviceIds.add(serviceId);
+        }
+        const safeAddress = svc.safe_address;
+        if (!safeAddress) {
+            services.push({
+                index,
+                serviceId,
+                safeAddress: null,
+                balanceWei: null,
+                operatorClaimedWei: null,
+                state: 'pending',
+                error: null,
+            });
+            continue;
+        }
+        try {
+            const checksum = getAddress(safeAddress);
+            const key = checksum.toLowerCase();
+            services.push({
+                index,
+                serviceId,
+                safeAddress: checksum,
+                balanceWei: null,
+                operatorClaimedWei: null,
+                state: 'pending',
+                error: null,
+            });
+            safeToAddress.set(key, checksum);
+        }
+        catch {
+            services.push({
+                index,
+                serviceId,
+                safeAddress,
+                balanceWei: null,
+                operatorClaimedWei: null,
+                state: 'error',
+                error: TJINN_PUBLIC_INVALID_SAFE_ERROR,
+            });
+        }
+    }
+    const safeCount = safeToAddress.size;
+    if (safeCount === 0) {
+        const invalid = services.find((svc) => svc.state === 'error')?.error;
+        return pendingTjinnStatus(tokenAddress, chainId, {
+            state: invalid ? 'error' : 'pending',
+            safeCount,
+            services,
+            error: invalid ?? null,
+        });
+    }
+    if (!ethereumRpcUrl) {
+        return pendingTjinnStatus(tokenAddress, chainId, { safeCount, services });
+    }
+    const snapshot = await getCachedTjinnBalances(ethereumRpcUrl, tokenAddress, distributorAddress, chainId, safeToAddress, [...serviceIds]);
+    let total = 0n;
+    for (const balance of snapshot.balances.values()) {
+        total += BigInt(balance);
+    }
+    const allClaimedReadsAvailable = !!distributorAddress &&
+        serviceIds.size > 0 &&
+        snapshot.claimedErrors.size === 0 &&
+        [...serviceIds].every((serviceId) => snapshot.operatorClaimedByService.has(serviceId));
+    let operatorClaimedWei = null;
+    if (allClaimedReadsAvailable) {
+        let claimedTotal = 0n;
+        for (const serviceId of serviceIds) {
+            claimedTotal += BigInt(snapshot.operatorClaimedByService.get(serviceId) ?? '0');
+        }
+        operatorClaimedWei = claimedTotal.toString();
+    }
+    // 24h-window sum: null when the log query errored or there are no services.
+    let operatorMintedLast24hWei = null;
+    if (!!distributorAddress &&
+        serviceIds.size > 0 &&
+        snapshot.claimedLast24hError === null) {
+        let last24hTotal = 0n;
+        for (const serviceId of serviceIds) {
+            last24hTotal += BigInt(snapshot.operatorMintedLast24hByService.get(serviceId) ?? '0');
+        }
+        operatorMintedLast24hWei = last24hTotal.toString();
+    }
+    const hasInvalidSafe = services.some((svc) => svc.error === TJINN_PUBLIC_INVALID_SAFE_ERROR);
+    const hasReadError = snapshot.errors.size > 0;
+    const hasAnyError = hasInvalidSafe || hasReadError;
+    const hasAnyBalance = snapshot.balances.size > 0;
+    const publicError = hasAnyError
+        ? tjinnPublicError({ hasInvalidSafe, hasReadError, hasAnyBalance })
+        : null;
+    return pendingTjinnStatus(tokenAddress, snapshot.chainId, {
+        state: hasAnyError ? 'error' : 'ready',
+        safeBalanceWei: hasAnyBalance ? total.toString() : null,
+        operatorClaimedWei,
+        operatorMintedLast24hWei,
+        safeCount,
+        services: services.map((svc) => {
+            const operatorClaimedForService = svc.serviceId !== null
+                ? (snapshot.operatorClaimedByService.get(svc.serviceId) ?? null)
+                : null;
+            if (!svc.safeAddress)
+                return { ...svc, operatorClaimedWei: operatorClaimedForService };
+            if (svc.state === 'error')
+                return { ...svc, operatorClaimedWei: operatorClaimedForService };
+            const key = svc.safeAddress.toLowerCase();
+            const balance = snapshot.balances.get(key);
+            if (balance !== undefined) {
+                return {
+                    ...svc,
+                    state: 'ready',
+                    balanceWei: balance,
+                    operatorClaimedWei: operatorClaimedForService,
+                    error: null,
+                };
+            }
+            return {
+                ...svc,
+                state: 'error',
+                operatorClaimedWei: operatorClaimedForService,
+                error: snapshot.errors.get(key) ?? TJINN_PUBLIC_READ_ERROR,
+            };
+        }),
+        error: publicError,
+    });
+}
 function hasUsefulCacheValues(entry, isAgentRole) {
     if (isAgentRole)
         return entry.nativeWei != null;
@@ -350,6 +753,7 @@ export async function gatherGatheredStatusRaw(store, status) {
     }));
     const lastRewardClaimTickAt = store.getConfigValue('last_reward_claim_tick_at');
     const daily = resolveMasterDailyEstimateWei(status?.masterEthDailyEstimateWei, status?.pollIntervalMs ?? 5000);
+    const tjinnIdentity = resolveTjinnIdentity(status);
     // portfolio.v0 lifecycle data — best-effort, never throws
     let portfolioV0;
     try {
@@ -369,7 +773,8 @@ export async function gatherGatheredStatusRaw(store, status) {
     let predictionOperatorError;
     if (status?.config) {
         try {
-            const raw = await getCachedPredictionOperatorStatus(status.config, status.configPath ?? '<default>', 'prediction');
+            const solverNetName = derivePredictionSolverNetName(status.config);
+            const raw = await getCachedPredictionOperatorStatus(status.config, status.configPath ?? '<default>', solverNetName);
             predictionOperator = narrowOperatorStatusForApi(raw);
         }
         catch (error) {
@@ -410,6 +815,9 @@ export async function gatherGatheredStatusRaw(store, status) {
         serviceBalances: {},
         pendingByService: {},
         claimedByService: store.getClaimedRewardsByService(),
+        tjinnTokenAddress: tjinnIdentity.tokenAddress,
+        tjinnChainId: tjinnIdentity.chainId,
+        tjinnDistributorAddress: status?.tjinnDistributorAddress,
     };
     if (!status) {
         return { ...baseRaw, hintsScope: 'sqlite_only' };
@@ -424,6 +832,11 @@ export async function gatherGatheredStatusRaw(store, status) {
         testnetMechDeploymentPath: status.testnetMechDeploymentPath,
         testnetStolasDeploymentPath: status.testnetStolasDeploymentPath,
     });
+    // Start the Sepolia tJINN read up front so it overlaps the Base-RPC fan-out
+    // below for free. `gatherTjinnStatus` is internally error-safe (it catches
+    // and returns a snapshot), so the promise never rejects — it is awaited at
+    // the point its result is assigned to `raw.tJinn`.
+    const tJinnPromise = gatherTjinnStatus(status.network === 'testnet' ? status.config?.ethereumRpcUrl : undefined, tjinnIdentity.tokenAddress, status.tjinnDistributorAddress, tjinnIdentity.chainId, fleet);
     const raw = {
         ...baseRaw,
         fleet,
@@ -503,6 +916,51 @@ export async function gatherGatheredStatusRaw(store, status) {
         else {
             raw.pendingRewardsError = pr.error;
         }
+        // Eviction state + inactivity — best-effort; never blocks the rest of status assembly.
+        try {
+            const evictedByServiceIndex = {};
+            const inactivityByServiceIndex = {};
+            await Promise.all(fleet.services.map(async (svc) => {
+                const serviceId = svc.service_id;
+                const stakingProxy = svc.staking_address;
+                if (!serviceId || !stakingProxy)
+                    return;
+                const di = displayFleetServiceIndex(svc);
+                try {
+                    const [state, info] = await Promise.all([
+                        client.readContract({
+                            address: stakingProxy,
+                            abi: JINN_STAKING_ABI,
+                            functionName: 'getStakingState',
+                            args: [BigInt(serviceId)],
+                        }),
+                        client.readContract({
+                            address: stakingProxy,
+                            abi: JINN_STAKING_ABI,
+                            functionName: 'getServiceInfo',
+                            args: [BigInt(serviceId)],
+                        }).catch(() => null),
+                    ]);
+                    // getStakingState returns uint8; 2 = Evicted enum value
+                    evictedByServiceIndex[di] = Number(state) === 2;
+                    // getServiceInfo returns a struct — inactivity is seconds of accumulated inactivity
+                    if (info != null) {
+                        const inactivity = info.inactivity;
+                        if (typeof inactivity === 'bigint') {
+                            inactivityByServiceIndex[di] = Number(inactivity);
+                        }
+                    }
+                }
+                catch {
+                    // Transient RPC errors: skip silently; evicted defaults to false
+                }
+            }));
+            raw.evictedByServiceIndex = evictedByServiceIndex;
+            raw.inactivityByServiceIndex = inactivityByServiceIndex;
+        }
+        catch {
+            // Non-fatal: staking state reads should not prevent status from returning
+        }
     }
     if (fleet) {
         const per = {};
@@ -520,10 +978,27 @@ export async function gatherGatheredStatusRaw(store, status) {
             raw.serviceBalanceErrors = bal.errorsByDisplay;
         }
     }
+    // The tJINN read started up front (overlapping the Base-RPC fan-out). It is
+    // awaited here, as late as possible — after ALL other awaited Base-chain work
+    // — so the up-to-4s tJINN timeout never serializes the Base fan-out behind it.
+    // `gatherTjinnStatus` is internally error-safe, so a plain await is safe.
+    raw.tJinn = await tJinnPromise;
     return raw;
 }
 export async function gatherStatusForApi(store, status) {
     const raw = await gatherGatheredStatusRaw(store, status);
-    return assembleStatusV1(raw);
+    const body = assembleStatusV1(raw);
+    const caps = status?.spendCaps;
+    if (caps && Object.keys(caps).length > 0) {
+        const now = new Date();
+        const resetsAt = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1)).toISOString();
+        body.spend = {
+            credentials: Object.entries(caps).map(([credentialId, capUsd]) => {
+                const spentTodayUsd = store.spentTodayMicros(credentialId, now) / 1_000_000;
+                return { credentialId, capUsd, spentTodayUsd, paused: isOverSpendCap(spentTodayUsd, capUsd), resetsAt };
+            }),
+        };
+    }
+    return body;
 }
 //# sourceMappingURL=gather-status.js.map