@jinn-network/client 0.1.2 → 0.1.3-canary.24b69ea4

package/dist/solvernets/registry-client.d.ts

@@ -0,0 +1,121 @@
+/**
+ * SolverNet registry client interface.
+ *
+ * Abstract surface for publishing and reading SolverNet launched-instance
+ * authority documents (manifests) and their lifecycle status. Per
+ * `spec/2026-05-05-solvernet-creation-and-launch.md` §13: the operator app
+ * depends on this interface so the day-1 IdentityRegistry+subgraph backing can
+ * be replaced later (alternative IPFS gateway, future on-chain SolverNet
+ * registry contract, etc.) without touching the manifest schema or operator
+ * flow.
+ *
+ * INTERFACE ONLY. The day-1 concrete implementation
+ * (`IdentityRegistryBackedSolverNetRegistryClient`) lands in Task 4 and wires:
+ *   - publishManifest / publishLifecycleTransition → IdentityRegistry.setMetadata
+ *   - listLaunched / getLifecycleStatus            → subgraph (most-recent-wins)
+ *   - getManifest                                  → IPFS via `client/src/adapters/mech/ipfs.ts`
+ */
+import type { SolverNetManifestV1 } from '../vendor/@jinn-network/sdk/dist/solvernets/index.js';
+/**
+ * Minimal "ready to sign" handle for the launcher's agent EOA. Held by the
+ * registry client implementation to (a) sign manifests via `signManifest` and
+ * (b) send the on-chain `setMetadata` tx that anchors the manifest CID.
+ *
+ * Kept data-only on purpose: no viem `Account`, no signer abstraction. This
+ * makes test doubles trivial and avoids leaking viem types into the interface.
+ * The Task 4 implementation derives the viem account from `agentEoaPrivateKey`
+ * at the call site.
+ *
+ * `agentId` is included for convenience so the implementation does not have to
+ * round-trip the IdentityRegistry to look it up before publishing.
+ */
+export interface SignerWithAgentEoa {
+    agentEoaAddress: `0x${string}`;
+    agentEoaPrivateKey: `0x${string}`;
+    agentId: string;
+}
+/**
+ * Catalog-row projection of a launched SolverNet — the minimum useful shape
+ * for the operator catalog UI and join flow. `listLaunched` returns these;
+ * the full manifest is fetched on demand via `getManifest`.
+ *
+ * `status` and `statusUpdatedAt` reflect the most-recent-wins resolution of
+ * the launcher's lifecycle transitions (§13 day-1 implementation note).
+ *
+ * Lives next to the interface (not in the SDK) until a second consumer
+ * appears; promotable later without breaking callers.
+ */
+export interface SolverNetManifestSummary {
+    manifestCid: string;
+    solverNetId: string;
+    name: string;
+    network: string;
+    launcherAgentId: string;
+    launcherSafeAddress: `0x${string}`;
+    status: 'launched' | 'paused' | 'retired';
+    statusUpdatedAt: string;
+    contractId: string;
+    contractVersion: string;
+    solutionPriceWei: string;
+    verdictPriceWei: string;
+    openRoles: Array<'solver' | 'evaluator'>;
+    anchorBlock: number;
+}
+/**
+ * Abstract registry client. Five methods, mirroring spec §13 exactly.
+ *
+ * Publish-side (`publishManifest`, `publishLifecycleTransition`) require a
+ * `SignerWithAgentEoa` — they sign and broadcast on the launcher's behalf.
+ * Read-side (`listLaunched`, `getManifest`, `getLifecycleStatus`) are
+ * permissionless lookups that do not need a signer.
+ */
+export interface SolverNetRegistryClient {
+    publishManifest(args: {
+        manifest: SolverNetManifestV1;
+        signer: SignerWithAgentEoa;
+    }): Promise<{
+        manifestCid: string;
+        metadataTxHash: `0x${string}`;
+        metadataBlockNumber: number;
+    }>;
+    publishLifecycleTransition(args: {
+        manifestCid: string;
+        launcherAgentId: string;
+        target: 'launched' | 'paused' | 'retired';
+        signer: SignerWithAgentEoa;
+    }): Promise<{
+        metadataTxHash: `0x${string}`;
+        metadataBlockNumber: number;
+    }>;
+    listLaunched(args: {
+        network: string;
+        statusFilter?: Array<'launched' | 'paused' | 'retired'>;
+        sinceBlock?: number;
+    }): Promise<SolverNetManifestSummary[]>;
+    getManifest(args: {
+        manifestCid: string;
+    }): Promise<SolverNetManifestV1>;
+    /**
+     * Cache-only manifest lookup. Returns the cached manifest body if the
+     * client has previously seen this cid (via publish or read), or `null`
+     * otherwise. Never falls through to IPFS — the goal is server-side hot-
+     * path enrichment (e.g. embedding manifest summaries in list responses)
+     * where an IPFS round-trip per row would be unacceptable. Callers that
+     * need the full IPFS-validated body should use `getManifest`.
+     *
+     * Synchronous in spirit (the day-1 implementation reads a Map), but typed
+     * as `Promise` to keep the interface symmetric with the rest of the API
+     * and to allow future implementations to back the cache with async
+     * storage (e.g. SQLite) without a breaking change.
+     */
+    getManifestFromCache(args: {
+        manifestCid: string;
+    }): Promise<SolverNetManifestV1 | null>;
+    getLifecycleStatus(args: {
+        manifestCid: string;
+    }): Promise<{
+        status: 'launched' | 'paused' | 'retired';
+        statusUpdatedAt: string;
+        sourceBlock: number;
+    }>;
+}

package/dist/solvernets/registry-client.js

@@ -0,0 +1,19 @@
+/**
+ * SolverNet registry client interface.
+ *
+ * Abstract surface for publishing and reading SolverNet launched-instance
+ * authority documents (manifests) and their lifecycle status. Per
+ * `spec/2026-05-05-solvernet-creation-and-launch.md` §13: the operator app
+ * depends on this interface so the day-1 IdentityRegistry+subgraph backing can
+ * be replaced later (alternative IPFS gateway, future on-chain SolverNet
+ * registry contract, etc.) without touching the manifest schema or operator
+ * flow.
+ *
+ * INTERFACE ONLY. The day-1 concrete implementation
+ * (`IdentityRegistryBackedSolverNetRegistryClient`) lands in Task 4 and wires:
+ *   - publishManifest / publishLifecycleTransition → IdentityRegistry.setMetadata
+ *   - listLaunched / getLifecycleStatus            → subgraph (most-recent-wins)
+ *   - getManifest                                  → IPFS via `client/src/adapters/mech/ipfs.ts`
+ */
+export {};
+//# sourceMappingURL=registry-client.js.map

package/dist/solvernets/registry-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-client.js","sourceRoot":"","sources":["../../src/solvernets/registry-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG"}

package/dist/solvernets/store.d.ts

@@ -0,0 +1,298 @@
+/**
+ * Local launched + draft persistence store for SolverNets.
+ *
+ * Spec: `spec/2026-05-05-solvernet-creation-and-launch.md` §6.1, §6.2.
+ *
+ * Layout (under the user's `~/.jinn-client/`):
+ *   solvernets/
+ *     launched/<solverNetId>.json   → LaunchedSolverNetRecord
+ *     drafts/<draftId>.json         → DraftSolverNetRecord
+ *
+ * Mirrors the precedent set by `client/src/earning/store.ts` (atomic
+ * tmp-then-rename writes; corrupted files logged and skipped, never
+ * thrown). The store accepts a `baseDir` override so tests never touch
+ * the real `~/.jinn-client/` tree.
+ */
+import { z } from 'zod';
+/**
+ * Local persistent record for a SolverNet the launcher daemon owns. Mirrors
+ * the spec §6.2 shape exactly.
+ *
+ * `generatorConfig` is the per-record hot-applyable runtime config the
+ * launcher edits via `PATCH /v1/solvernets/launched/:id/generator-config`
+ * (Task 14). Stored as an opaque blob — the precise shape lives with the
+ * solver-type's runtime-config interface (e.g.
+ * `PredictionV1GeneratorRuntimeConfig`). The endpoint validates against
+ * that interface before persisting; the store treats it as JSON.
+ */
+export declare const LaunchedSolverNetRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"solvernet.launched.v1">;
+    solverNetId: z.ZodEffects<z.ZodString, string, string>;
+    manifestCid: z.ZodString;
+    manifestPath: z.ZodOptional<z.ZodString>;
+    manifestHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    launcherAgentId: z.ZodString;
+    launcherSafeAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    launchedAt: z.ZodString;
+    status: z.ZodEnum<["launching", "launched", "paused", "retired", "failed"]>;
+    statusUpdatedAt: z.ZodString;
+    generatorEnabled: z.ZodBoolean;
+    generatorState: z.ZodOptional<z.ZodObject<{
+        lastPollAt: z.ZodOptional<z.ZodString>;
+        lastError: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            at: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            at: string;
+            message: string;
+        }, {
+            at: string;
+            message: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        lastPollAt?: string | undefined;
+        lastError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    }, {
+        lastPollAt?: string | undefined;
+        lastError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    }>>;
+    generatorConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    launchProgress: z.ZodOptional<z.ZodObject<{
+        phase: z.ZodEnum<["pinning", "recording", "broadcasting", "confirming", "spawning"]>;
+        txHash: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+        txError: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            at: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            at: string;
+            message: string;
+        }, {
+            at: string;
+            message: string;
+        }>>;
+        attemptCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        phase: "pinning" | "recording" | "broadcasting" | "confirming" | "spawning";
+        attemptCount: number;
+        txHash?: `0x${string}` | undefined;
+        txError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    }, {
+        phase: "pinning" | "recording" | "broadcasting" | "confirming" | "spawning";
+        attemptCount: number;
+        txHash?: `0x${string}` | undefined;
+        txError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    }>>;
+    lifecycleProgress: z.ZodOptional<z.ZodObject<{
+        phase: z.ZodEnum<["broadcasting", "confirming"]>;
+        target: z.ZodEnum<["paused", "launched", "retired"]>;
+        txHash: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+        txError: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            at: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            at: string;
+            message: string;
+        }, {
+            at: string;
+            message: string;
+        }>>;
+        attemptCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        target: "paused" | "launched" | "retired";
+        phase: "broadcasting" | "confirming";
+        attemptCount: number;
+        txHash?: `0x${string}` | undefined;
+        txError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    }, {
+        target: "paused" | "launched" | "retired";
+        phase: "broadcasting" | "confirming";
+        attemptCount: number;
+        txHash?: `0x${string}` | undefined;
+        txError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    }>>;
+    registry: z.ZodObject<{
+        metadataTxHash: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+        metadataBlockNumber: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        metadataTxHash?: `0x${string}` | undefined;
+        metadataBlockNumber?: number | undefined;
+    }, {
+        metadataTxHash?: `0x${string}` | undefined;
+        metadataBlockNumber?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    status: "launching" | "failed" | "paused" | "launched" | "retired";
+    schemaVersion: "solvernet.launched.v1";
+    manifestCid: string;
+    solverNetId: string;
+    manifestHash: `0x${string}`;
+    launcherAgentId: string;
+    launcherSafeAddress: `0x${string}`;
+    launchedAt: string;
+    statusUpdatedAt: string;
+    generatorEnabled: boolean;
+    registry: {
+        metadataTxHash?: `0x${string}` | undefined;
+        metadataBlockNumber?: number | undefined;
+    };
+    manifestPath?: string | undefined;
+    generatorState?: {
+        lastPollAt?: string | undefined;
+        lastError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    } | undefined;
+    generatorConfig?: Record<string, unknown> | undefined;
+    launchProgress?: {
+        phase: "pinning" | "recording" | "broadcasting" | "confirming" | "spawning";
+        attemptCount: number;
+        txHash?: `0x${string}` | undefined;
+        txError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    } | undefined;
+    lifecycleProgress?: {
+        target: "paused" | "launched" | "retired";
+        phase: "broadcasting" | "confirming";
+        attemptCount: number;
+        txHash?: `0x${string}` | undefined;
+        txError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    } | undefined;
+}, {
+    status: "launching" | "failed" | "paused" | "launched" | "retired";
+    schemaVersion: "solvernet.launched.v1";
+    manifestCid: string;
+    solverNetId: string;
+    manifestHash: `0x${string}`;
+    launcherAgentId: string;
+    launcherSafeAddress: `0x${string}`;
+    launchedAt: string;
+    statusUpdatedAt: string;
+    generatorEnabled: boolean;
+    registry: {
+        metadataTxHash?: `0x${string}` | undefined;
+        metadataBlockNumber?: number | undefined;
+    };
+    manifestPath?: string | undefined;
+    generatorState?: {
+        lastPollAt?: string | undefined;
+        lastError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    } | undefined;
+    generatorConfig?: Record<string, unknown> | undefined;
+    launchProgress?: {
+        phase: "pinning" | "recording" | "broadcasting" | "confirming" | "spawning";
+        attemptCount: number;
+        txHash?: `0x${string}` | undefined;
+        txError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    } | undefined;
+    lifecycleProgress?: {
+        target: "paused" | "launched" | "retired";
+        phase: "broadcasting" | "confirming";
+        attemptCount: number;
+        txHash?: `0x${string}` | undefined;
+        txError?: {
+            at: string;
+            message: string;
+        } | undefined;
+    } | undefined;
+}>;
+export type LaunchedSolverNetRecord = z.infer<typeof LaunchedSolverNetRecordSchema>;
+/**
+ * Local persistent record for a Create-flow draft. Most fields are optional
+ * because drafts are partial-by-construction — `completedSteps` tracks which
+ * sections of the wizard have been filled in and is the source of truth for
+ * resumability.
+ */
+export declare const DraftSolverNetRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"solvernet.draft.v1">;
+    draftId: z.ZodEffects<z.ZodString, string, string>;
+    templateContractId: z.ZodOptional<z.ZodString>;
+    templateContractVersion: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    generatorConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    solutionPriceWei: z.ZodOptional<z.ZodString>;
+    verdictPriceWei: z.ZodOptional<z.ZodString>;
+    openRoles: z.ZodOptional<z.ZodArray<z.ZodEnum<["solver", "evaluator"]>, "many">>;
+    completedSteps: z.ZodArray<z.ZodEnum<["define", "reviewContract", "configureGenerator", "configurePricing"]>, "many">;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "solvernet.draft.v1";
+    createdAt: string;
+    updatedAt: string;
+    draftId: string;
+    completedSteps: ("define" | "reviewContract" | "configureGenerator" | "configurePricing")[];
+    name?: string | undefined;
+    description?: string | undefined;
+    generatorConfig?: Record<string, unknown> | undefined;
+    templateContractId?: string | undefined;
+    templateContractVersion?: string | undefined;
+    solutionPriceWei?: string | undefined;
+    verdictPriceWei?: string | undefined;
+    openRoles?: ("solver" | "evaluator")[] | undefined;
+}, {
+    schemaVersion: "solvernet.draft.v1";
+    createdAt: string;
+    updatedAt: string;
+    draftId: string;
+    completedSteps: ("define" | "reviewContract" | "configureGenerator" | "configurePricing")[];
+    name?: string | undefined;
+    description?: string | undefined;
+    generatorConfig?: Record<string, unknown> | undefined;
+    templateContractId?: string | undefined;
+    templateContractVersion?: string | undefined;
+    solutionPriceWei?: string | undefined;
+    verdictPriceWei?: string | undefined;
+    openRoles?: ("solver" | "evaluator")[] | undefined;
+}>;
+export type DraftSolverNetRecord = z.infer<typeof DraftSolverNetRecordSchema>;
+export declare const DEFAULT_JINN_CLIENT_DIR: string;
+export interface SolverNetStore {
+    loadOwnedRecords(): Promise<LaunchedSolverNetRecord[]>;
+    loadRecord(solverNetId: string): Promise<LaunchedSolverNetRecord | null>;
+    writeRecord(record: LaunchedSolverNetRecord): Promise<void>;
+    deleteRecord(solverNetId: string): Promise<void>;
+    loadDraft(draftId: string): Promise<DraftSolverNetRecord | null>;
+    writeDraft(record: DraftSolverNetRecord): Promise<void>;
+    listDrafts(): Promise<DraftSolverNetRecord[]>;
+    deleteDraft(draftId: string): Promise<void>;
+}
+export interface SolverNetStoreOptions {
+    /**
+     * Override the root directory under which `solvernets/launched/` and
+     * `solvernets/drafts/` live. Defaults to `~/.jinn-client`. Tests should
+     * always supply a tmpdir here to avoid touching the real home directory.
+     */
+    baseDir?: string;
+}
+export declare function createSolverNetStore(opts?: SolverNetStoreOptions): SolverNetStore;