lightnode-sdk 0.3.2 → 0.4.0

package/README.md

@@ -81,8 +81,12 @@ npx lightnode fee llama3-8b               # on-chain job fee
 npx lightnode analytics --csv             # per-model performance (CSV)
 npx lightnode reliability --csv           # per-worker reliability (CSV)
 
-# Scaffold inference into an existing project (auto-detects Next.js, Hono, or Node):
-npx lightnode add inference [--template auto|nextjs-api|hono|node] [--net testnet|mainnet] [--force]
+# Patch an existing project (auto-detects Next.js, Hono, or Node):
+npx lightnode add inference                    # encrypted inference route/script
+npx lightnode add chat                         # chat-style UI with conversation history
+npx lightnode add analytics-dashboard          # read-only network + worker analytics page
+npx lightnode add nft-mint-with-inference      # AI-generated NFT metadata with on-chain provenance
+# All `add` commands accept [--template auto|nextjs-api|hono|node] [--net testnet|mainnet] [--force]
 
 # Or scaffold a brand-new project:
 npm create lightnode-app my-app
@@ -90,6 +94,34 @@ npm create lightnode-app my-app
 
 ## Submitting inference
 
+**Easy mode (`runInference` — v0.4+):** one async call drives the whole protocol —
+SIWE → prepareSession → on-chain createSession → relay WS → encrypt + upload prompt
+→ on-chain submitJob → decrypt streamed chunks → wait for `JobCompleted` →
+return the assembled answer + three tx hashes. Built-in retry on `StalledWorkerError`.
+
+```ts
+import { LightNode, GatewayClient, runInference } from "lightnode-sdk";
+import WS from "ws"; // omit in the browser
+
+const ln = new LightNode("testnet");
+const gateway = new GatewayClient({ network: "testnet", bearer: await getJwt() });
+const { answer, txs } = await runInference({
+  prompt: "Reply with a one-sentence fun fact about the ocean.",
+  gateway, wallet, publicClient, network: ln.network,
+  WebSocket: WS,
+  onChunk: (chunk) => process.stdout.write(chunk), // live streaming
+  maxRetries: 2,                                    // auto-retry on stall
+});
+console.log("\n", txs); // { createSession, submitJob, jobCompleted }
+```
+
+The lower-level helpers (`prepareSession`, `submitPrompt`, `decryptResponse`,
+the typed errors `StalledWorkerError` / `OnChainRevertError` / `GatewayAuthError`
+/ `RelayTokenTimeoutError`) stay exported for builders who want a different
+retry policy or to reuse a session across prompts.
+
+### Manual mode (the full surface)
+
 `v0.3+` ships the encrypted inference-submit flow end to end. Wire-compatible with
 the reference client [`lcai-chat-v2`](https://github.com/lightchain-protocol/lcai-chat-v2)
 (same ECDH-P256 + AES-256-GCM, same gateway endpoints, same `JobRegistry` calls).

package/dist/add.d.ts

@@ -30,4 +30,22 @@ export declare function addInference(opts?: AddOpts): {
     template: Template;
     network: Network;
 };
+export declare function addAnalyticsDashboard(opts?: AddOpts): {
+    written: WrittenFile[];
+    install: string;
+    template: Template;
+    network: Network;
+};
+export declare function addChat(opts?: AddOpts): {
+    written: WrittenFile[];
+    install: string;
+    template: Template;
+    network: Network;
+};
+export declare function addNftMint(opts?: AddOpts): {
+    written: WrittenFile[];
+    install: string;
+    template: Template;
+    network: Network;
+};
 export {};

package/dist/add.js

@@ -370,3 +370,566 @@ export function addInference(opts = {}) {
         network,
     };
 }
+// ---------------------------------------------------------------------------
+// `lightnode add analytics-dashboard` - drop in a read-only network/worker
+// analytics page that uses the SDK's getNetworkAnalytics + getModelStats +
+// getWorkerStats. All reads, no wallet needed, no fees - so it composes onto
+// any existing dApp.
+// ---------------------------------------------------------------------------
+const NEXTJS_DASHBOARD_PAGE = `// app/lightnode-analytics/page.tsx
+// Generated by 'lightnode add analytics-dashboard'. See https://lightnode.app/build
+import { LightNode, type NetworkId } from "lightnode-sdk";
+
+export const revalidate = 30; // cache the SSR render for 30s
+
+const NETWORK = (process.env.NEXT_PUBLIC_LIGHTCHAIN_NETWORK ?? "mainnet") as NetworkId;
+
+export default async function LightNodeAnalyticsPage() {
+  const ln = new LightNode(NETWORK);
+  const [network, models, workers] = await Promise.all([
+    ln.getNetworkAnalytics(),
+    ln.getModelStats(),
+    ln.getWorkerStats(1000, 12),
+  ]);
+
+  return (
+    <main style={{ maxWidth: 1080, margin: "40px auto", padding: 24, fontFamily: "system-ui, sans-serif", color: "#111" }}>
+      <header style={{ marginBottom: 24 }}>
+        <h1 style={{ fontSize: 28, fontWeight: 600 }}>LightChain {NETWORK} - network analytics</h1>
+        <p style={{ color: "#555", marginTop: 6 }}>
+          Live read from the public worker subgraph + on-chain registration. Auto-refreshes every 30 seconds.
+        </p>
+      </header>
+
+      <section style={{ display: "grid", gap: 12, gridTemplateColumns: "repeat(auto-fit, minmax(180px, 1fr))", marginBottom: 28 }}>
+        <Stat label="Completion" value={pct(network.completionRate)} />
+        <Stat label="Jobs" value={fmt(network.jobs)} />
+        <Stat label="Incomplete" value={fmt(network.incomplete)} />
+        <Stat label="Earnings (LCAI)" value={network.earnings.toFixed(2)} />
+      </section>
+
+      <section style={{ marginBottom: 32 }}>
+        <h2 style={{ fontSize: 18, fontWeight: 600, marginBottom: 12 }}>Per-model performance</h2>
+        <table style={{ width: "100%", borderCollapse: "collapse", fontSize: 14 }}>
+          <thead>
+            <tr style={{ textAlign: "left", borderBottom: "1px solid #ddd", color: "#666" }}>
+              <th style={{ padding: 8 }}>Model</th>
+              <th style={{ padding: 8 }}>Jobs</th>
+              <th style={{ padding: 8 }}>Completion</th>
+              <th style={{ padding: 8 }}>p50</th>
+              <th style={{ padding: 8 }}>p95</th>
+              <th style={{ padding: 8 }}>Earnings</th>
+            </tr>
+          </thead>
+          <tbody>
+            {models.map((m) => (
+              <tr key={m.modelId} style={{ borderBottom: "1px solid #f0f0f0" }}>
+                <td style={{ padding: 8, fontWeight: 500 }}>{m.name}</td>
+                <td style={{ padding: 8 }}>{fmt(m.total)}</td>
+                <td style={{ padding: 8 }}>{pct(m.completionRate)}</td>
+                <td style={{ padding: 8 }}>{m.p50 ?? "-"}s</td>
+                <td style={{ padding: 8 }}>{m.p95 ?? "-"}s</td>
+                <td style={{ padding: 8 }}>{m.earnings.toFixed(2)} LCAI</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </section>
+
+      <section>
+        <h2 style={{ fontSize: 18, fontWeight: 600, marginBottom: 12 }}>Busiest workers (top 12)</h2>
+        <table style={{ width: "100%", borderCollapse: "collapse", fontSize: 14 }}>
+          <thead>
+            <tr style={{ textAlign: "left", borderBottom: "1px solid #ddd", color: "#666" }}>
+              <th style={{ padding: 8 }}>Worker</th>
+              <th style={{ padding: 8 }}>Jobs</th>
+              <th style={{ padding: 8 }}>Completion</th>
+              <th style={{ padding: 8 }}>Earnings</th>
+            </tr>
+          </thead>
+          <tbody>
+            {workers.map((w) => (
+              <tr key={w.address} style={{ borderBottom: "1px solid #f0f0f0" }}>
+                <td style={{ padding: 8, fontFamily: "monospace" }}>{short(w.address)}</td>
+                <td style={{ padding: 8 }}>{fmt(w.total)}</td>
+                <td style={{ padding: 8 }}>{pct(w.completionRate)}</td>
+                <td style={{ padding: 8 }}>{w.earnings.toFixed(3)} LCAI</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </section>
+
+      <p style={{ marginTop: 28, color: "#888", fontSize: 12 }}>
+        Powered by the open-source <a href="https://www.npmjs.com/package/lightnode-sdk">lightnode-sdk</a>.
+        Same data the dashboard at lightnode.app uses; you can re-style or filter freely.
+      </p>
+    </main>
+  );
+}
+
+function Stat({ label, value }: { label: string; value: string }) {
+  return (
+    <div style={{ background: "#fafafa", border: "1px solid #eee", borderRadius: 12, padding: 16 }}>
+      <div style={{ fontSize: 11, color: "#888", textTransform: "uppercase", letterSpacing: 0.5 }}>{label}</div>
+      <div style={{ fontSize: 24, fontWeight: 600, marginTop: 4, fontVariantNumeric: "tabular-nums" }}>{value}</div>
+    </div>
+  );
+}
+
+function pct(r: number | null): string { return r == null ? "-" : \`\${Math.round(r * 100)}%\`; }
+function fmt(n: number): string { return n.toLocaleString(); }
+function short(a: string): string { return \`\${a.slice(0, 6)}…\${a.slice(-4)}\`; }
+`;
+const NODE_DASHBOARD_SCRIPT = `// lightnode-analytics.ts
+// Generated by 'lightnode add analytics-dashboard'. Run with: tsx lightnode-analytics.ts
+import { LightNode, type NetworkId } from "lightnode-sdk";
+
+const NETWORK = (process.env.NETWORK ?? "mainnet") as NetworkId;
+const ln = new LightNode(NETWORK);
+
+const [network, models, workers] = await Promise.all([
+  ln.getNetworkAnalytics(),
+  ln.getModelStats(),
+  ln.getWorkerStats(1000, 10),
+]);
+
+console.log(\`LightChain \${NETWORK} - network analytics\\n\`);
+console.log(\`Completion : \${pct(network.completionRate)}\`);
+console.log(\`Jobs       : \${network.jobs.toLocaleString()}\`);
+console.log(\`Incomplete : \${network.incomplete.toLocaleString()}\`);
+console.log(\`Earnings   : \${network.earnings.toFixed(2)} LCAI\\n\`);
+
+console.log("Per-model performance:");
+for (const m of models) {
+  console.log(\`  \${m.name.padEnd(14)} jobs=\${String(m.total).padStart(5)} completion=\${pct(m.completionRate)} p50=\${m.p50 ?? "-"}s earnings=\${m.earnings.toFixed(3)} LCAI\`);
+}
+
+console.log("\\nTop 10 workers:");
+for (const w of workers) {
+  console.log(\`  \${short(w.address)} jobs=\${String(w.total).padStart(4)} completion=\${pct(w.completionRate)} earnings=\${w.earnings.toFixed(3)} LCAI\`);
+}
+
+function pct(r: number | null): string { return r == null ? "-" : \`\${Math.round(r * 100)}%\`; }
+function short(a: string): string { return \`\${a.slice(0, 6)}…\${a.slice(-4)}\`; }
+`;
+export function addAnalyticsDashboard(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const network = opts.network ?? "mainnet";
+    const template = opts.template && opts.template !== "auto" ? opts.template : detectTemplate(cwd);
+    const force = !!opts.force;
+    const written = [];
+    if (template === "nextjs-api") {
+        written.push(writeFile(path.join(cwd, "app/lightnode-analytics/page.tsx"), NEXTJS_DASHBOARD_PAGE, force));
+    }
+    else {
+        // Hono and Node both get the CLI-style script; the SDK calls are pure
+        // server-side reads anyway and a custom Hono route is trivial to wrap.
+        written.push(writeFile(path.join(cwd, "lightnode-analytics.ts"), NODE_DASHBOARD_SCRIPT, force));
+    }
+    return { written, install: `npm install lightnode-sdk`, template, network };
+}
+// ---------------------------------------------------------------------------
+// `lightnode add nft-mint-with-inference` - drop in a function that uses
+// LightChain AI to generate NFT metadata from a prompt. The caller wires it
+// into their existing mint flow; we don't pick a specific ERC-721 contract.
+// ---------------------------------------------------------------------------
+const NEXTJS_NFT_METADATA_ROUTE = `// app/api/nft-metadata/route.ts
+// Generated by 'lightnode add nft-mint-with-inference'.
+// Calls /api/inference (also added by 'lightnode add inference') to generate
+// an NFT description from a short prompt, returns ERC-721-style metadata.
+import { NextResponse } from "next/server";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface MintInput {
+  name?: string;
+  prompt?: string;
+  image?: string;
+  attributes?: Array<{ trait_type: string; value: string | number }>;
+}
+
+export async function POST(req: Request) {
+  const body = (await req.json().catch(() => ({}))) as MintInput;
+  const name = body.name?.trim();
+  const prompt = body.prompt?.trim();
+  if (!name || !prompt) return NextResponse.json({ error: "name and prompt are required" }, { status: 400 });
+
+  // Reuse the inference route added by 'lightnode add inference'. If you mounted
+  // it elsewhere, update this path. If you'd rather call the SDK directly here,
+  // copy the contents of app/api/inference/route.ts into this file.
+  const origin = new URL(req.url).origin;
+  const inference = await fetch(\`\${origin}/api/inference\`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ prompt: \`Write a short, evocative 1-2 sentence description of an NFT titled "\${name}" with this concept: \${prompt}\` }),
+  }).then((r) => r.json()) as { answer?: string; txs?: Record<string, string>; error?: string };
+
+  if (!inference?.answer) {
+    return NextResponse.json({ error: inference?.error ?? "inference failed" }, { status: 502 });
+  }
+
+  return NextResponse.json({
+    name,
+    description: inference.answer.trim(),
+    image: body.image ?? null,
+    attributes: body.attributes ?? [],
+    // Provenance: the on-chain LightChain AI transactions that generated this metadata.
+    // Pin this whole object to IPFS and use the IPFS hash as your tokenURI.
+    lightchain_inference: inference.txs,
+  });
+}
+`;
+const NEXTJS_NFT_MINT_CLIENT = `// app/nft-mint/page.tsx
+// Generated by 'lightnode add nft-mint-with-inference'.
+// Minimal client that takes a name + concept, generates AI metadata via the
+// /api/nft-metadata route, and shows the result. Bring your own mint() call.
+"use client";
+import { useState } from "react";
+
+interface Metadata { name: string; description: string; image: string | null; attributes: unknown[]; lightchain_inference?: Record<string, string> }
+
+export default function NftMint() {
+  const [name, setName] = useState("Cosmic Wanderer");
+  const [prompt, setPrompt] = useState("an astronaut surfing on the edge of a black hole");
+  const [meta, setMeta] = useState<Metadata | null>(null);
+  const [busy, setBusy] = useState(false);
+
+  return (
+    <main style={{ maxWidth: 640, margin: "40px auto", padding: 20, fontFamily: "system-ui" }}>
+      <h1>Mint an NFT with AI metadata</h1>
+      <p style={{ color: "#666", fontSize: 14 }}>
+        The description is generated by LightChain AI inference. The transaction hashes are returned in the
+        metadata as on-chain provenance you can pin alongside the JSON.
+      </p>
+      <label style={{ display: "block", marginTop: 16, fontSize: 13 }}>NFT name</label>
+      <input value={name} onChange={(e) => setName(e.target.value)} style={{ width: "100%", padding: 10, fontSize: 14 }} />
+      <label style={{ display: "block", marginTop: 12, fontSize: 13 }}>Concept</label>
+      <textarea value={prompt} onChange={(e) => setPrompt(e.target.value)} rows={2} style={{ width: "100%", padding: 10, fontSize: 14 }} />
+      <button
+        disabled={busy || !name || !prompt}
+        onClick={async () => {
+          setBusy(true); setMeta(null);
+          try {
+            const r = await fetch("/api/nft-metadata", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name, prompt }) }).then((r) => r.json());
+            setMeta(r);
+          } finally { setBusy(false); }
+        }}
+        style={{ marginTop: 12, padding: "10px 20px", fontSize: 14 }}
+      >
+        {busy ? "Generating..." : "Generate metadata"}
+      </button>
+      {meta && (
+        <pre style={{ marginTop: 20, padding: 16, background: "#eee", whiteSpace: "pre-wrap", fontSize: 13 }}>
+          {JSON.stringify(meta, null, 2)}
+        </pre>
+      )}
+      {/* Wire your own mint(uri) call here. tokenURI = ipfs://<hash of meta> after pinning. */}
+    </main>
+  );
+}
+`;
+const NODE_NFT_METADATA_SCRIPT = `// nft-metadata.ts
+// Generated by 'lightnode add nft-mint-with-inference'.
+// Use:  tsx nft-metadata.ts "Cosmic Wanderer" "an astronaut surfing on the edge of a black hole"
+//
+// Calls LightChain AI inference directly, prints ERC-721-style metadata to stdout.
+// Pipe to a file + pin to IPFS for the tokenURI in your mint contract.
+import WS from "ws";
+import { createPublicClient, createWalletClient, http, parseAbi, parseAbiItem, parseEther, type Log } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  LightNode, prepareSession, submitPrompt, decryptResponse,
+  estimateJobFee, consumerGatewayUrl, JOB_REGISTRY_CONSUMER_ABI,
+  GatewayClient, type NetworkId,
+} from "lightnode-sdk";
+
+const NETWORK = (process.env.NETWORK ?? "testnet") as NetworkId;
+const MODEL = process.env.MODEL ?? "llama3-8b";
+const [, , NAME, ...promptArgs] = process.argv;
+const CONCEPT = promptArgs.join(" ").trim();
+if (!NAME || !CONCEPT) { console.error('usage: tsx nft-metadata.ts "NFT Name" "concept"'); process.exit(1); }
+const PRIVATE_KEY = process.env.PRIVATE_KEY as \`0x\${string}\` | undefined;
+if (!PRIVATE_KEY?.startsWith("0x") || PRIVATE_KEY.length !== 66) { console.error("set PRIVATE_KEY in .env"); process.exit(1); }
+
+const ln = new LightNode(NETWORK);
+const cfg = ln.network;
+const acct = privateKeyToAccount(PRIVATE_KEY);
+const chain = { id: cfg.chainId, name: cfg.label, nativeCurrency: { name: "LCAI", symbol: "LCAI", decimals: 18 }, rpcUrls: { default: { http: [cfg.rpc] } } };
+const pub = createPublicClient({ transport: http(cfg.rpc), chain });
+const wal = createWalletClient({ account: acct, transport: http(cfg.rpc), chain });
+const abi = parseAbi(JOB_REGISTRY_CONSUMER_ABI);
+
+const ch = await (await fetch(\`\${consumerGatewayUrl(NETWORK)}/api/auth/challenge?address=\${acct.address}\`)).json() as { message?: string };
+if (!ch.message) throw new Error("auth challenge failed");
+const sig = await wal.signMessage({ message: ch.message });
+const verify = await (await fetch(\`\${consumerGatewayUrl(NETWORK)}/api/auth/verify\`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ message: ch.message, signature: sig }) })).json() as { token?: string };
+if (!verify.token) throw new Error("auth verify failed");
+const gateway = new GatewayClient({ network: NETWORK, bearer: verify.token });
+
+const { sessionKey, createSessionArgs } = await prepareSession(gateway, MODEL);
+const fee = await estimateJobFee(cfg, MODEL);
+const createTx = await wal.writeContract({
+  address: cfg.jobRegistry as \`0x\${string}\`, abi, functionName: "createSession",
+  args: [createSessionArgs.paramsHash, createSessionArgs.worker, createSessionArgs.encWorkerKey, createSessionArgs.ephemeralPubKey, createSessionArgs.initState, createSessionArgs.expiry],
+  gas: 1_000_000n,
+});
+const createReceipt = await pub.waitForTransactionReceipt({ hash: createTx });
+const sessionCreated = parseAbiItem("event SessionCreated(uint256 indexed sessionId, address indexed user, bytes32 indexed paramsHash, address worker, bytes encWorkerKey, bytes ephemeralPubKey)");
+const sessionLog = (await pub.getLogs({ address: cfg.jobRegistry as \`0x\${string}\`, event: sessionCreated, blockHash: createReceipt.blockHash })).find((l) => l.transactionHash === createTx);
+const sessionId = sessionLog?.args.sessionId;
+if (!sessionId) throw new Error("SessionCreated missing");
+
+let relayToken: string | undefined;
+for (let i = 0; i < 30 && !relayToken; i++) {
+  const r = await gateway.getSessionToken(Number(sessionId));
+  if ("token" in r && r.token) relayToken = r.token; else await new Promise((res) => setTimeout(res, 1000));
+}
+if (!relayToken) throw new Error("relay token never became ready");
+const ws = new WS(\`wss://relay.\${NETWORK}.lightchain.ai/ws?token=\${encodeURIComponent(relayToken)}\`);
+const chunks: string[] = [];
+await new Promise<void>((res, rej) => { ws.once("open", () => res()); ws.once("error", rej); });
+ws.on("message", async (data: Buffer) => {
+  let f: { type?: string; payload?: string };
+  try { f = JSON.parse(data.toString("utf8")); } catch { return; }
+  if (!f.payload) return;
+  if (f.type === "chunk") { try { chunks.push(await decryptResponse(sessionKey, f.payload)); } catch {} }
+  else if (f.type === "complete" && chunks.length === 0) { try { chunks.push(await decryptResponse(sessionKey, f.payload)); } catch {} }
+});
+
+const PROMPT = \`Write a short, evocative 1-2 sentence description of an NFT titled "\${NAME}" with this concept: \${CONCEPT}\`;
+const promptHash = await submitPrompt(gateway, sessionKey, PROMPT);
+const submitTx = await wal.writeContract({
+  address: cfg.jobRegistry as \`0x\${string}\`, abi, functionName: "submitJob",
+  args: [sessionId, promptHash], value: parseEther(String(fee)), gas: 500_000n,
+});
+const submitReceipt = await pub.waitForTransactionReceipt({ hash: submitTx });
+const jobSubmitted = parseAbiItem("event JobSubmitted(uint256 indexed jobId, uint256 indexed sessionId, address worker)");
+const jobLog = (await pub.getLogs({ address: cfg.jobRegistry as \`0x\${string}\`, event: jobSubmitted, blockHash: submitReceipt.blockHash })).find((l) => l.transactionHash === submitTx);
+const jobId = jobLog?.args.jobId;
+if (!jobId) throw new Error("JobSubmitted missing");
+
+const jobCompleted = parseAbiItem("event JobCompleted(uint256 indexed jobId, address indexed worker, bytes32 responseHash, bytes32 ciphertextHash)");
+const deadline = Date.now() + 90_000;
+let completed: Log | null = null;
+while (!completed && Date.now() < deadline) {
+  await new Promise((res) => setTimeout(res, 3000));
+  const logs = await pub.getLogs({ address: cfg.jobRegistry as \`0x\${string}\`, event: jobCompleted, args: { jobId }, fromBlock: submitReceipt.blockNumber });
+  if (logs.length) completed = logs[0] as Log;
+}
+if (!completed) { console.error("worker stalled - re-run for a different worker"); process.exit(1); }
+await new Promise((res) => setTimeout(res, 4000));
+ws.close();
+
+const description = chunks.join("").trim();
+const metadata = {
+  name: NAME,
+  description,
+  image: null,
+  attributes: [] as unknown[],
+  lightchain_inference: {
+    createSession: createTx,
+    submitJob: submitTx,
+    jobCompleted: completed.transactionHash,
+    sessionId: sessionId.toString(),
+    jobId: jobId.toString(),
+    worker: createSessionArgs.worker,
+  },
+};
+console.log(JSON.stringify(metadata, null, 2));
+process.exit(0);
+`;
+// ---------------------------------------------------------------------------
+// `lightnode add chat` - drop in a chat-style UI that uses the SDK's high-
+// level runInference() helper. Keeps conversation history client-side and
+// formats every prior turn into the next prompt so the model has context.
+// ---------------------------------------------------------------------------
+const NEXTJS_CHAT_PAGE = `// app/chat/page.tsx
+// Generated by 'lightnode add chat'.
+"use client";
+import { useState } from "react";
+
+type Turn = { role: "user" | "assistant"; text: string; txs?: Record<string, string> };
+
+export default function Chat() {
+  const [turns, setTurns] = useState<Turn[]>([]);
+  const [draft, setDraft] = useState("");
+  const [busy, setBusy] = useState(false);
+
+  async function send() {
+    if (!draft.trim()) return;
+    const next: Turn[] = [...turns, { role: "user", text: draft.trim() }];
+    setTurns(next);
+    setDraft("");
+    setBusy(true);
+    try {
+      // Concatenate prior turns so the model has the conversation context.
+      const prompt =
+        next.map((t) => (t.role === "user" ? \`User: \${t.text}\` : \`Assistant: \${t.text}\`)).join("\\n") +
+        "\\nAssistant:";
+      const r = await fetch("/api/inference", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ prompt }),
+      }).then((r) => r.json()) as { answer?: string; txs?: Record<string, string>; error?: string };
+      if (!r.answer) throw new Error(r.error ?? "no answer");
+      setTurns([...next, { role: "assistant", text: r.answer, txs: r.txs }]);
+    } catch (e) {
+      setTurns([...next, { role: "assistant", text: \`(error: \${(e as Error).message})\` }]);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <main style={{ maxWidth: 760, margin: "30px auto", padding: 20, fontFamily: "system-ui, sans-serif" }}>
+      <h1>LightChain AI - chat</h1>
+      <p style={{ color: "#666", fontSize: 13 }}>
+        Each turn pays ~0.02 LCAI on mainnet (free on testnet). Conversation history is sent with each turn so the
+        model has context.
+      </p>
+      <div style={{ marginTop: 20, display: "flex", flexDirection: "column", gap: 10 }}>
+        {turns.map((t, i) => (
+          <div
+            key={i}
+            style={{
+              padding: 14,
+              borderRadius: 12,
+              background: t.role === "user" ? "#e8f0ff" : "#f4f4f4",
+              alignSelf: t.role === "user" ? "flex-end" : "flex-start",
+              maxWidth: "85%",
+              whiteSpace: "pre-wrap",
+              lineHeight: 1.5,
+            }}
+          >
+            <div style={{ fontSize: 11, color: "#888", marginBottom: 4, textTransform: "uppercase", letterSpacing: 0.5 }}>
+              {t.role}
+            </div>
+            {t.text}
+            {t.txs && (
+              <div style={{ marginTop: 8, fontSize: 11, color: "#888", fontFamily: "monospace" }}>
+                jobCompleted: {t.txs.jobCompleted?.slice(0, 18)}…
+              </div>
+            )}
+          </div>
+        ))}
+        {busy && (
+          <div style={{ padding: 14, color: "#888", fontStyle: "italic" }}>
+            running encrypted inference…
+          </div>
+        )}
+      </div>
+      <div style={{ marginTop: 20, display: "flex", gap: 8 }}>
+        <input
+          value={draft}
+          onChange={(e) => setDraft(e.target.value)}
+          onKeyDown={(e) => e.key === "Enter" && !busy && send()}
+          placeholder="Type a message…"
+          style={{ flex: 1, padding: 12, fontSize: 14, borderRadius: 8, border: "1px solid #ccc" }}
+        />
+        <button
+          onClick={send}
+          disabled={busy || !draft.trim()}
+          style={{ padding: "10px 20px", fontSize: 14, borderRadius: 8 }}
+        >
+          Send
+        </button>
+      </div>
+      <p style={{ marginTop: 16, fontSize: 12, color: "#888" }}>
+        Make sure <code>/api/inference</code> is mounted - run <code>npx lightnode add inference</code> if you have
+        not. The route signs every call server-side with the PRIVATE_KEY in your .env.
+      </p>
+    </main>
+  );
+}
+`;
+const NODE_CHAT_REPL = `// chat-repl.ts
+// Generated by 'lightnode add chat'. Interactive chat REPL in your terminal.
+//   npm install lightnode-sdk viem ws
+//   tsx chat-repl.ts
+import * as readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import WS from "ws";
+import { createPublicClient, createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { LightNode, runInference, GatewayClient, consumerGatewayUrl, type NetworkId } from "lightnode-sdk";
+
+const NETWORK = (process.env.NETWORK ?? "testnet") as NetworkId;
+const MODEL = process.env.MODEL ?? "llama3-8b";
+const PRIVATE_KEY = process.env.PRIVATE_KEY as \`0x\${string}\` | undefined;
+if (!PRIVATE_KEY?.startsWith("0x") || PRIVATE_KEY.length !== 66) { console.error("set PRIVATE_KEY in .env"); process.exit(1); }
+
+const ln = new LightNode(NETWORK);
+const acct = privateKeyToAccount(PRIVATE_KEY);
+const chain = { id: ln.network.chainId, name: ln.network.label, nativeCurrency: { name: "LCAI", symbol: "LCAI", decimals: 18 }, rpcUrls: { default: { http: [ln.network.rpc] } } };
+const pub = createPublicClient({ transport: http(ln.network.rpc), chain });
+const wal = createWalletClient({ account: acct, transport: http(ln.network.rpc), chain });
+
+// One SIWE handshake per process; the JWT is reused across all turns.
+const ch = await (await fetch(\`\${consumerGatewayUrl(NETWORK)}/api/auth/challenge?address=\${acct.address}\`)).json() as { message?: string };
+if (!ch.message) throw new Error("auth challenge failed");
+const sig = await wal.signMessage({ message: ch.message });
+const verify = await (await fetch(\`\${consumerGatewayUrl(NETWORK)}/api/auth/verify\`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ message: ch.message, signature: sig }) })).json() as { token?: string };
+if (!verify.token) throw new Error("auth verify failed");
+const gateway = new GatewayClient({ network: NETWORK, bearer: verify.token });
+
+const rl = readline.createInterface({ input, output });
+const turns: { role: "user" | "assistant"; text: string }[] = [];
+console.log(\`▶ chat on \${NETWORK}, model=\${MODEL}. Ctrl+C to exit.\\n\`);
+
+while (true) {
+  const user = (await rl.question("> ")).trim();
+  if (!user) continue;
+  turns.push({ role: "user", text: user });
+  const prompt = turns.map((t) => (t.role === "user" ? \`User: \${t.text}\` : \`Assistant: \${t.text}\`)).join("\\n") + "\\nAssistant:";
+  try {
+    process.stdout.write("  ");
+    const { answer } = await runInference({
+      prompt, gateway, wallet: wal, publicClient: pub, network: ln.network,
+      model: MODEL, WebSocket: WS,
+      onChunk: (chunk) => process.stdout.write(chunk),
+    });
+    process.stdout.write("\\n\\n");
+    turns.push({ role: "assistant", text: answer });
+  } catch (e) {
+    console.log(\`  (error: \${(e as Error).message})\`);
+  }
+}
+`;
+export function addChat(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const network = opts.network ?? "testnet";
+    const template = opts.template && opts.template !== "auto" ? opts.template : detectTemplate(cwd);
+    const force = !!opts.force;
+    const written = [];
+    if (template === "nextjs-api") {
+        written.push(writeFile(path.join(cwd, "app/chat/page.tsx"), NEXTJS_CHAT_PAGE, force));
+    }
+    else {
+        written.push(writeFile(path.join(cwd, "chat-repl.ts"), NODE_CHAT_REPL, force));
+    }
+    written.push(writeFile(path.join(cwd, ".env.example"), ENV_EXAMPLE(network), force));
+    return { written, install: `npm install ${depsNeeded(template).join(" ")}`, template, network };
+}
+export function addNftMint(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const network = opts.network ?? "testnet";
+    const template = opts.template && opts.template !== "auto" ? opts.template : detectTemplate(cwd);
+    const force = !!opts.force;
+    const written = [];
+    if (template === "nextjs-api") {
+        written.push(writeFile(path.join(cwd, "app/api/nft-metadata/route.ts"), NEXTJS_NFT_METADATA_ROUTE, force));
+        written.push(writeFile(path.join(cwd, "app/nft-mint/page.tsx"), NEXTJS_NFT_MINT_CLIENT, force));
+    }
+    else {
+        written.push(writeFile(path.join(cwd, "nft-metadata.ts"), NODE_NFT_METADATA_SCRIPT, force));
+    }
+    written.push(writeFile(path.join(cwd, ".env.example"), ENV_EXAMPLE(network), force));
+    return {
+        written,
+        install: `npm install ${depsNeeded(template).join(" ")}`,
+        template,
+        network,
+    };
+}