lightnode-sdk 0.7.4 → 0.7.6

package/dist/cli.js

@@ -49,6 +49,7 @@ Worker operator (needs PRIVATE_KEY in env; signs as the worker key):
   worker preflight         run one real test inference, print verdict + timings
                            ([--key 0x...] [--model llama3-8b] [--deadline 60])
   worker status [addr]     registration, stake, claimable, live protocol config
+  worker models <addr>     models served, reconciled vs chain (servingNow truth)
   worker can-deregister    check what blocks the exit (in-flight jobs), no spend
   worker settle            release completed jobs past their window + withdraw
   worker clearstuck        claimTimeout acked, past-deadline jobs (unblocks exit)
@@ -313,10 +314,38 @@ async function main() {
                 }
                 break;
             }
-            // Default: one-shot worker summary by address.
-            const addr = sub ?? die("usage: lightnode worker <address|watch|preflight|status|can-deregister|settle|clearstuck|withdraw|deregister> [...]");
-            const [w, registered, jobs] = await Promise.all([ln.getWorker(addr), ln.isRegistered(addr), ln.getWorkerJobs(addr, 5)]);
-            console.log(JSON.stringify({ onchainRegistered: registered, worker: w, recentJobs: jobs.map((j) => ({ id: j.id, state: j.state })) }, null, 2));
+            if (sub === "models") {
+                // The models a worker serves, reconciled against the chain (read-only,
+                // no key). onchainEligible is the truth; indexedActive is the subgraph's
+                // (which goes stale after a deregister/re-register).
+                const addr = positionals[2] ?? die("usage: lightnode worker models <address> [--net testnet]");
+                const served = await ln.getServedModels(addr);
+                console.log(JSON.stringify(served.map((m) => ({
+                    model: m.name ?? m.modelId,
+                    servingNow: m.onchainEligible, // true | false | null (chain unavailable)
+                    indexedActive: m.indexedActive,
+                    feeLcai: m.feeWei ? Number(BigInt(m.feeWei)) / 1e18 : null,
+                    maxOutputTokens: m.maxOutputTokens ?? null,
+                })), null, 2));
+                break;
+            }
+            // Default: one-shot worker summary by address. Registration is read straight
+            // from the chain (isRegistered); served models are reconciled against the
+            // chain via getServedModels (onchainEligible), so a stale index row can't
+            // misreport what the worker actually serves.
+            const addr = sub ?? die("usage: lightnode worker <address|watch|preflight|status|models|can-deregister|settle|clearstuck|withdraw|deregister> [...]");
+            const [w, registered, jobs, served] = await Promise.all([
+                ln.getWorker(addr),
+                ln.isRegistered(addr),
+                ln.getWorkerJobs(addr, 5),
+                ln.getServedModels(addr).catch(() => []),
+            ]);
+            console.log(JSON.stringify({
+                onchainRegistered: registered,
+                servingModels: served.filter((m) => m.onchainEligible === true).map((m) => m.name ?? m.modelId),
+                worker: w,
+                recentJobs: jobs.map((j) => ({ id: j.id, state: j.state })),
+            }, null, 2));
             break;
         }
         case "job": {

package/dist/index.d.ts

@@ -13,7 +13,7 @@ import { OnchainModelRegistry, AIVM_MODEL_REGISTRY_ABI, BENCHMARK_REGISTRY_ABI,
 import { StalledWorkerError, OnChainRevertError, RelayTokenTimeoutError, GatewayAuthError, isStalledWorker } from "./errors.js";
 import { GatewayClient, GatewayHttpError } from "./gateway.js";
 import * as crypto from "./crypto.js";
-import type { NetworkId, NetworkConfig, Worker, Job, JobTransactions, ModelInfo, WorkerModel, NetworkStats, ModelStat, WorkerStat, NetworkAnalytics } from "./types.js";
+import type { NetworkId, NetworkConfig, Worker, Job, JobTransactions, ModelInfo, WorkerModel, ServedModel, NetworkStats, ModelStat, WorkerStat, NetworkAnalytics } from "./types.js";
 /**
  * Read-only client for a LightChain AI network. Pure reads from the public indexer
  * and the chain; no keys, no writes. Independent, community-built.
@@ -42,6 +42,17 @@ export declare class LightNode {
      * whether the worker is currently serving them.
      */
     getWorkerModels(address: string): Promise<WorkerModel[]>;
+    /**
+     * The models a worker is serving, RECONCILED against the chain. getWorkerModels
+     * returns the raw subgraph rows, which go stale after a deregister/re-register
+     * (the indexer never clears removals). This joins those rows to model names AND
+     * to the authoritative on-chain WorkerRegistry.isEligible(worker, modelId), so
+     * each `ServedModel` carries both `indexedActive` (subgraph) and
+     * `onchainEligible` (chain truth). Use `onchainEligible === true` to decide what
+     * the worker ACTUALLY serves right now; it falls back to null (rely on
+     * `indexedActive`) if the chain read is unavailable.
+     */
+    getServedModels(address: string): Promise<ServedModel[]>;
     /** The network's registered models (name, fee, output limit, whitelist flags). */
     getModels(): Promise<ModelInfo[]>;
     /** Registered workers (default top 200). */
@@ -122,7 +133,7 @@ export declare class LightNode {
  * (especially in registry-proxy environments like StackBlitz where lockfiles
  * may pin an older minor than the local install command suggests).
  */
-export declare const SDK_VERSION = "0.7.4";
+export declare const SDK_VERSION = "0.7.6";
 export { NETWORKS, WORKER_REGISTRY, REGISTRY_TOPICS, aggregateModelStats, aggregateWorkerStats, networkAnalytics, modelStatsCsv, workerStatsCsv, workerJobsCsv, fromWei, resolveJobTransactions, fetchWorkerModels, computeModelId as modelId, estimateJobFee, JOB_REGISTRY_CONSUMER_ABI, consumerGatewayUrl, consumerGatewayHost, GatewayClient, GatewayHttpError, prepareSession, submitPrompt, decryptResponse, generateEcdhKeyPair, crypto, runInference, runInferenceWithKey, runInferenceStream, Conversation, chat, runInferenceBatch, Agent, parseAgentOutput, workerPreflight, workerWatch, Bridge, BRIDGE_ROUTE, HYPERLANE_ROUTER_ABI, ERC20_ABI, addressToBytes32, quoteBridgeFee, bridgeableBalance, bridgeAllowance, approveBridge, bridgeTransfer, DAO, DAO_ADDRESSES, ProposalState, PROPOSAL_STATE_LABEL, VoteSupport, GOVERNOR_ABI, VOTES_ABI, OnchainModelRegistry, AIVM_MODEL_REGISTRY_ABI, BENCHMARK_REGISTRY_ABI, ModelStatus, MODEL_STATUS_LABEL, StalledWorkerError, OnChainRevertError, RelayTokenTimeoutError, GatewayAuthError, isStalledWorker, WorkerOperator, WORKER_REGISTRY_ABI, JOB_REGISTRY_OPERATOR_ABI, AI_CONFIG_ABI, JOB_STATE, decodeWorkerError, WorkerOpError, isWorkerOpError, };
 export type { BearerSource, GatewayClientOptions, SelectSessionResult, PrepareSessionResult, UploadBlobResult, SessionTokenResult } from "./gateway.js";
 export type { SessionPreparation, RunInferenceArgs, RunInferenceResult, RunInferenceWithKeyArgs, RunInferenceStreamResult } from "./inference.js";
@@ -134,4 +145,4 @@ export type { BridgeChain, BridgeEndpoints, BridgeTransferArgs } from "./bridge.
 export type { DaoChain, DaoAddresses, ProposalSummary, ProposalRow, DaoConfig } from "./dao.js";
 export type { BaseModel, ModelVariant, AccessTier, AccessPolicy, Benchmark, OnchainModelRegistryOptions } from "./onchain-models.js";
 export type { MinimalWalletClient, MinimalPublicClient, WorkerOperatorOpts, WorkerProtocolConfig, WorkerStatus, DeregisterReadiness, StuckJob, EarningsBreakdown, OnchainJob, JobState, DecodedWorkerError, } from "./worker-operator.js";
-export type { NetworkId, NetworkConfig, Worker, Job, JobTransactions, ModelInfo, WorkerModel, NetworkStats, ModelStat, WorkerStat, NetworkAnalytics };
+export type { NetworkId, NetworkConfig, Worker, Job, JobTransactions, ModelInfo, WorkerModel, ServedModel, NetworkStats, ModelStat, WorkerStat, NetworkAnalytics };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { NETWORKS, WORKER_REGISTRY, REGISTRY_TOPICS } from "./networks.js";
 import { fetchWorker, fetchWorkerJobs, fetchWorkerModels, fetchRecentJobs, fetchJob, fetchModels, fetchWorkers, summarize, fromWei, resolveJobTransactions, } from "./subgraph.js";
-import { isRegistered } from "./onchain.js";
+import { isRegistered, fetchOnchainEligibleModels } from "./onchain.js";
 import { aggregateModelStats, aggregateWorkerStats, networkAnalytics, modelStatsCsv, workerStatsCsv, workerJobsCsv, } from "./analytics.js";
 import { modelId as computeModelId, estimateJobFee, JOB_REGISTRY_CONSUMER_ABI, consumerGatewayUrl, consumerGatewayHost, prepareSession, submitPrompt, decryptResponse, generateEcdhKeyPair, runInference, runInferenceWithKey, runInferenceStream, } from "./inference.js";
 import { Conversation, chat } from "./chat.js";
@@ -51,6 +51,37 @@ export class LightNode {
     getWorkerModels(address) {
         return fetchWorkerModels(this.network, address);
     }
+    /**
+     * The models a worker is serving, RECONCILED against the chain. getWorkerModels
+     * returns the raw subgraph rows, which go stale after a deregister/re-register
+     * (the indexer never clears removals). This joins those rows to model names AND
+     * to the authoritative on-chain WorkerRegistry.isEligible(worker, modelId), so
+     * each `ServedModel` carries both `indexedActive` (subgraph) and
+     * `onchainEligible` (chain truth). Use `onchainEligible === true` to decide what
+     * the worker ACTUALLY serves right now; it falls back to null (rely on
+     * `indexedActive`) if the chain read is unavailable.
+     */
+    async getServedModels(address) {
+        const [rows, registry] = await Promise.all([
+            fetchWorkerModels(this.network, address),
+            fetchModels(this.network),
+        ]);
+        if (rows.length === 0)
+            return [];
+        const byId = new Map(registry.map((m) => [m.id.toLowerCase(), m]));
+        const eligible = await fetchOnchainEligibleModels(this.network, address, rows.map((r) => r.model_id)).catch(() => null);
+        return rows.map((r) => {
+            const info = byId.get(r.model_id.toLowerCase());
+            return {
+                modelId: r.model_id,
+                name: info?.name ?? null,
+                feeWei: info?.fee,
+                maxOutputTokens: info?.max_output_tokens,
+                indexedActive: r.is_active,
+                onchainEligible: eligible ? (eligible.get(r.model_id.toLowerCase()) ?? null) : null,
+            };
+        });
+    }
     /** The network's registered models (name, fee, output limit, whitelist flags). */
     getModels() {
         return fetchModels(this.network);
@@ -181,7 +212,7 @@ export class LightNode {
  * (especially in registry-proxy environments like StackBlitz where lockfiles
  * may pin an older minor than the local install command suggests).
  */
-export const SDK_VERSION = "0.7.4";
+export const SDK_VERSION = "0.7.6";
 export { NETWORKS, WORKER_REGISTRY, REGISTRY_TOPICS, aggregateModelStats, aggregateWorkerStats, networkAnalytics, modelStatsCsv, workerStatsCsv, workerJobsCsv, fromWei, 
 // v0.7.3 per-job transaction-hash resolver (lifts the upstream
 // subgraph's "block-only" Job entity to a deep-linkable Job + tx pair).

package/dist/onchain.d.ts

@@ -1,8 +1,25 @@
 import type { NetworkConfig } from "./types.js";
 /**
- * Authoritative worker registration, read straight from the chain's WorkerRegistry
- * events (works for ANY worker, independent of the public indexer, which can lag a
- * deregister -> re-register cycle). Returns true/false from the latest join/exit
- * event, or null when the chain can't answer (RPC error, or no events for it).
+ * Authoritative worker registration from the chain. Prefers a direct
+ * WorkerRegistry.isWorkerRegistered() eth_call (instant, current state); falls
+ * back to scanning the join/exit event log if that read is unavailable. Both are
+ * independent of the public indexer, which can lag a deregister -> re-register
+ * cycle. Returns true/false, or null when the chain can't answer.
  */
 export declare function isRegistered(cfg: NetworkConfig, address: string): Promise<boolean | null>;
+/**
+ * Registration from the WorkerRegistry join/exit event log - the fallback when
+ * the direct read is unavailable. Takes the latest of the worker's join/exit
+ * events; null when the chain can't answer or there are no events for it.
+ */
+export declare function isRegisteredFromEvents(cfg: NetworkConfig, address: string): Promise<boolean | null>;
+/**
+ * On-chain truth for which of `modelIds` a worker currently serves, via
+ * WorkerRegistry.isEligible(worker, modelId). Stronger than the subgraph's
+ * WorkerModel.is_active: the indexer lists a worker's models from its LAST
+ * registration and never indexes removals, so it goes stale after a
+ * deregister/re-register (it can show a model the worker no longer serves, or
+ * miss the current one). Returns a Map keyed by lowercased modelId; null on any
+ * RPC failure so callers can fall back to the index. One eth_call per model.
+ */
+export declare function fetchOnchainEligibleModels(cfg: NetworkConfig, address: string, modelIds: string[]): Promise<Map<string, boolean> | null>;

package/dist/onchain.js

@@ -2,13 +2,63 @@ import { REGISTRY_TOPICS } from "./networks.js";
 function addressTopic(address) {
     return "0x" + address.toLowerCase().replace(/^0x/, "").padStart(64, "0");
 }
+// WorkerRegistry.isWorkerRegistered(address) selector. Unlike most of the
+// predeploy's getters this view does NOT revert, and it reflects current state
+// instantly - so it never lags a register/deregister the way the event log can
+// when several happen in quick succession.
+const IS_WORKER_REGISTERED_SELECTOR = "0xe798a7da";
 /**
- * Authoritative worker registration, read straight from the chain's WorkerRegistry
- * events (works for ANY worker, independent of the public indexer, which can lag a
- * deregister -> re-register cycle). Returns true/false from the latest join/exit
- * event, or null when the chain can't answer (RPC error, or no events for it).
+ * Authoritative worker registration from the chain. Prefers a direct
+ * WorkerRegistry.isWorkerRegistered() eth_call (instant, current state); falls
+ * back to scanning the join/exit event log if that read is unavailable. Both are
+ * independent of the public indexer, which can lag a deregister -> re-register
+ * cycle. Returns true/false, or null when the chain can't answer.
  */
 export async function isRegistered(cfg, address) {
+    if (!/^0x[a-fA-F0-9]{40}$/.test(address))
+        return null;
+    const direct = await isRegisteredDirect(cfg, address);
+    if (direct !== null)
+        return direct;
+    return isRegisteredFromEvents(cfg, address);
+}
+/** Direct contract read - the preferred, lag-free path. null on any failure. */
+async function isRegisteredDirect(cfg, address) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 8000);
+    try {
+        const data = `${IS_WORKER_REGISTERED_SELECTOR}${address.toLowerCase().replace(/^0x/, "").padStart(64, "0")}`;
+        const res = await fetch(cfg.rpc, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "eth_call",
+                params: [{ to: cfg.workerRegistry, data }, "latest"],
+            }),
+            signal: ctrl.signal,
+        });
+        if (!res.ok)
+            return null;
+        const json = (await res.json());
+        if (json.error || typeof json.result !== "string")
+            return null;
+        return /0*1$/.test(json.result.replace(/^0x/, ""));
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Registration from the WorkerRegistry join/exit event log - the fallback when
+ * the direct read is unavailable. Takes the latest of the worker's join/exit
+ * events; null when the chain can't answer or there are no events for it.
+ */
+export async function isRegisteredFromEvents(cfg, address) {
     if (!/^0x[a-fA-F0-9]{40}$/.test(address))
         return null;
     const ctrl = new AbortController();
@@ -55,3 +105,54 @@ export async function isRegistered(cfg, address) {
         clearTimeout(timer);
     }
 }
+// WorkerRegistry.isEligible(address,bytes32) selector. This view does NOT revert
+// on the deployed predeploy (unlike most of its getters), so it's a reliable
+// on-chain read of whether a worker currently serves a given model.
+const IS_ELIGIBLE_SELECTOR = "0xdb3ebef1";
+/**
+ * On-chain truth for which of `modelIds` a worker currently serves, via
+ * WorkerRegistry.isEligible(worker, modelId). Stronger than the subgraph's
+ * WorkerModel.is_active: the indexer lists a worker's models from its LAST
+ * registration and never indexes removals, so it goes stale after a
+ * deregister/re-register (it can show a model the worker no longer serves, or
+ * miss the current one). Returns a Map keyed by lowercased modelId; null on any
+ * RPC failure so callers can fall back to the index. One eth_call per model.
+ */
+export async function fetchOnchainEligibleModels(cfg, address, modelIds) {
+    if (!/^0x[a-fA-F0-9]{40}$/.test(address) || modelIds.length === 0)
+        return null;
+    const addrArg = address.toLowerCase().replace(/^0x/, "").padStart(64, "0");
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 8000);
+    try {
+        const entries = await Promise.all(modelIds.map(async (id) => {
+            const idArg = id.toLowerCase().replace(/^0x/, "").padStart(64, "0");
+            const res = await fetch(cfg.rpc, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: 1,
+                    method: "eth_call",
+                    params: [{ to: cfg.workerRegistry, data: `${IS_ELIGIBLE_SELECTOR}${addrArg}${idArg}` }, "latest"],
+                }),
+                signal: ctrl.signal,
+            });
+            if (!res.ok)
+                throw new Error(`rpc ${res.status}`);
+            const json = (await res.json());
+            if (json.error || typeof json.result !== "string")
+                throw new Error("eth_call failed");
+            // bool return: true iff the 32-byte word ends in 1.
+            const eligible = /0*1$/.test(json.result.replace(/^0x/, ""));
+            return [id.toLowerCase(), eligible];
+        }));
+        return new Map(entries);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/types.d.ts

@@ -78,6 +78,25 @@ export interface WorkerModel {
     created_at?: number;
     updated_at?: number;
 }
+/**
+ * A worker's served model, reconciled against the chain. Combines the subgraph
+ * WorkerModel row (name, is_active) with the authoritative on-chain
+ * WorkerRegistry.isEligible read, so you can tell a model the worker ACTUALLY
+ * serves now from a stale index row left over after a deregister/re-register.
+ */
+export interface ServedModel {
+    modelId: string;
+    name: string | null;
+    feeWei?: string;
+    maxOutputTokens?: number;
+    /** Subgraph WorkerModel.is_active (can be stale after deregister/re-register). */
+    indexedActive: boolean;
+    /**
+     * On-chain WorkerRegistry.isEligible(worker, modelId) - the authoritative
+     * "is it serving this right now". null when the chain read was unavailable.
+     */
+    onchainEligible: boolean | null;
+}
 export interface NetworkStats {
     total: number;
     active: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lightnode-sdk",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Read-only TypeScript client for LightChain AI: workers, jobs, models, on-chain registration, and per-model network analytics. Independent, community-built (not an official LightChain package).",
   "type": "module",
   "main": "./dist/index.js",