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

package/dist/vendor/@jinn-network/sdk/dist/prediction-v1.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+const WindowSchema = z.object({
+    startTs: z.number().int().nonnegative(),
+    endTs: z.number().int().nonnegative(),
+});
+export const DecimalProbabilitySchema = z
+    .string()
+    .regex(/^(0(\.\d+)?|1(\.0+)?)$/, 'must be a decimal string in [0,1]');
+export const IsoDateTimeSchema = z.string().datetime({ offset: true });
+export const PredictionV1ClaimPolicySchema = z.object({
+    mode: z.enum(['exclusive', 'parallel']).default('exclusive'),
+    maxClaims: z.number().int().positive(),
+    maxClaimsPerOperator: z.number().int().positive().default(1),
+    claimWindowStartTs: z.number().int().optional(),
+    claimWindowEndTs: z.number().int().optional(),
+    submissionDeadlineTs: z.number().int().optional(),
+    claimLeaseTtlSeconds: z.number().int().positive().default(30 * 60),
+    policyHook: z.string().regex(/^0x[0-9a-fA-F]*$/).optional(),
+}).passthrough();
+export const PredictionV1SpecSchema = z.object({
+    question: z.object({
+        kind: z.literal('binary'),
+        text: z.string().min(1),
+        yesLabel: z.literal('YES'),
+        noLabel: z.literal('NO'),
+    }),
+    source: z.object({
+        type: z.literal('prediction-market'),
+        venue: z.literal('polymarket'),
+        url: z.string().url(),
+        identifiers: z.object({
+            marketId: z.string().min(1),
+            conditionId: z.string().min(1),
+            yesTokenId: z.string().min(1),
+            noTokenId: z.string().min(1),
+        }),
+    }),
+    resolution: z.object({
+        expectedResolutionTime: IsoDateTimeSchema,
+        rulesText: z.string().min(1),
+        rulesUrl: z.string().url(),
+        timezone: z.string().optional(),
+    }),
+    consensusSnapshot: z.object({
+        sampledAt: IsoDateTimeSchema,
+        probabilityYes: DecimalProbabilitySchema,
+        method: z.literal('best-bid-ask-midpoint'),
+        bestBidYes: DecimalProbabilitySchema,
+        bestAskYes: DecimalProbabilitySchema,
+        spread: DecimalProbabilitySchema,
+        source: z.literal('polymarket-clob'),
+    }),
+    eligibilitySnapshot: z.object({
+        sampledAt: IsoDateTimeSchema,
+        timeToResolutionHours: z.number(),
+        liquidityUsd: z.string().min(1),
+        volume24hUsd: z.string().min(1),
+        orderbookAgeSeconds: z.number().nonnegative(),
+        selectionReason: z.string().min(1),
+    }),
+});
+export const PredictionV1TaskSchema = z
+    .object({
+    id: z.string().min(1),
+    description: z.string().min(1),
+    solverType: z.literal('prediction.v1'),
+    role: z.enum(['restoration', 'evaluation']).optional(),
+    window: WindowSchema,
+    claimPolicy: PredictionV1ClaimPolicySchema,
+    spec: PredictionV1SpecSchema,
+    eligibility: z.record(z.unknown()).default({}),
+})
+    .refine((d) => d.window.endTs > d.window.startTs, {
+    message: 'window.endTs must be > window.startTs',
+    path: ['window'],
+})
+    .refine((d) => Date.parse(d.spec.resolution.expectedResolutionTime) > d.window.startTs, {
+    message: 'expectedResolutionTime must be after window.startTs',
+    path: ['spec', 'resolution', 'expectedResolutionTime'],
+});

package/dist/vendor/@jinn-network/sdk/dist/session-derived/distill-prompt-v1.d.ts

@@ -0,0 +1,2 @@
+export declare const SESSION_DERIVED_DISTILL_PROMPT_V1 = "You are decomposing a captured local agent session into atomic Tasks for a SolverNet.\n\nInput contains a redacted session trajectory, session provenance, repository metadata, executor identity, and optional final patch or test evidence.\n\nProduce one or more self-contained Tasks. Each Task must name the concrete problem, the repository commit it applies to when known, expected artifacts, and signal hints that help an evaluator grade future Solutions.\n\nPrefer narrow Tasks that can be solved and evaluated independently. Reject sessions that are mostly setup, secrets, policy-sensitive content, or vague exploration without a concrete outcome.\n\nThis prompt is a foundation reference implementation, not protocol canon. Launchers may substitute or extend it; they must publish the prompt hash they used so generated Tasks remain auditable.";
+export declare const SESSION_DERIVED_DISTILL_PROMPT_V1_SHA256 = "1f3ed97358b416d7ffac2e94d436d07e3e71a8e7b5327afa117ca5a09561f78c";

package/dist/vendor/@jinn-network/sdk/dist/session-derived/distill-prompt-v1.js

@@ -0,0 +1,10 @@
+export const SESSION_DERIVED_DISTILL_PROMPT_V1 = `You are decomposing a captured local agent session into atomic Tasks for a SolverNet.
+
+Input contains a redacted session trajectory, session provenance, repository metadata, executor identity, and optional final patch or test evidence.
+
+Produce one or more self-contained Tasks. Each Task must name the concrete problem, the repository commit it applies to when known, expected artifacts, and signal hints that help an evaluator grade future Solutions.
+
+Prefer narrow Tasks that can be solved and evaluated independently. Reject sessions that are mostly setup, secrets, policy-sensitive content, or vague exploration without a concrete outcome.
+
+This prompt is a foundation reference implementation, not protocol canon. Launchers may substitute or extend it; they must publish the prompt hash they used so generated Tasks remain auditable.`;
+export const SESSION_DERIVED_DISTILL_PROMPT_V1_SHA256 = '1f3ed97358b416d7ffac2e94d436d07e3e71a8e7b5327afa117ca5a09561f78c';

package/dist/vendor/@jinn-network/sdk/dist/solvernets/index.d.ts

@@ -0,0 +1,6 @@
+export { PREDICTION_V1_SOLVER_NET_CONTRACT, SOLVER_NET_CONTRACTS, PayloadValidationException, getSolverNetContract, validateTask, assertTask, validateSolutionPayload, assertSolutionPayload, validateVerdictPayload, assertVerdictPayload, buildSolutionOutput, buildVerdictOutput, } from '../contracts.js';
+export type { SolverNetContractRole, PayloadKind, SupportedSolverType, CredentialRequirement, SolverNetEvaluationFunction, SolverNetAggregationFunction, SolverNetClaimPolicyDefaults, SolverNetContract, SolverNetContractMap, SolverNetContractSchema, PayloadValidationIssue, PayloadValidationFailure, PayloadValidationSuccess, PayloadValidationResult, BuildSolutionOutputArgs, BuildVerdictOutputArgs, } from '../contracts.js';
+export { SolverNetManifestV1Schema, validateSolverNetManifest, } from './manifest-schema.js';
+export type { SolverNetManifestV1, SolverNetCredentialRequirement, ManifestValidationIssue, ManifestValidationResult, } from './manifest-schema.js';
+export { zodToJsonSchema, jsonSchemaToZod, } from '../json-schema.js';
+export type { JsonSchema } from '../json-schema.js';

package/dist/vendor/@jinn-network/sdk/dist/solvernets/index.js

@@ -0,0 +1,8 @@
+export { PREDICTION_V1_SOLVER_NET_CONTRACT, SOLVER_NET_CONTRACTS, PayloadValidationException, getSolverNetContract, validateTask, assertTask, validateSolutionPayload, assertSolutionPayload, validateVerdictPayload, assertVerdictPayload, buildSolutionOutput, buildVerdictOutput, } from '../contracts.js';
+// SolverNetManifestV1 — the launched-instance authority document.
+// See `spec/2026-05-05-solvernet-creation-and-launch.md` §7.
+export { SolverNetManifestV1Schema, validateSolverNetManifest, } from './manifest-schema.js';
+// JSON Schema serialization helpers — the canonical wire format for manifest
+// task/solution/verdict schemas, with a Zod recovery helper for daemon-side
+// validation.
+export { zodToJsonSchema, jsonSchemaToZod, } from '../json-schema.js';

package/dist/vendor/@jinn-network/sdk/dist/solvernets/manifest-schema.d.ts

@@ -0,0 +1,559 @@
+import { z } from 'zod';
+import type { JsonSchema } from '../json-schema.js';
+declare const ContractRoleZ: z.ZodEnum<["creator", "solver", "evaluator"]>;
+declare const CredentialRequirementZ: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    required: z.ZodBoolean;
+    description: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    kind: string;
+    id: string;
+    required: boolean;
+}, {
+    description: string;
+    kind: string;
+    id: string;
+    required: boolean;
+}>;
+declare const ClaimPolicyDefaultsZ: z.ZodObject<{
+    mode: z.ZodEnum<["parallel", "serial"]>;
+    maxClaims: z.ZodNumber;
+    maxClaimsPerOperator: z.ZodNumber;
+    claimLeaseTtlSeconds: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    mode: "parallel" | "serial";
+    maxClaims: number;
+    maxClaimsPerOperator: number;
+    claimLeaseTtlSeconds: number;
+}, {
+    mode: "parallel" | "serial";
+    maxClaims: number;
+    maxClaimsPerOperator: number;
+    claimLeaseTtlSeconds: number;
+}>;
+declare const EvaluationFunctionZ: z.ZodObject<{
+    id: z.ZodString;
+    deterministic: z.ZodBoolean;
+    inputs: z.ZodArray<z.ZodString, "many">;
+    output: z.ZodString;
+    implementation: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    deterministic: boolean;
+    inputs: string[];
+    output: string;
+    implementation: string;
+}, {
+    id: string;
+    deterministic: boolean;
+    inputs: string[];
+    output: string;
+    implementation: string;
+}>;
+declare const AggregationFunctionZ: z.ZodObject<{
+    id: z.ZodString;
+    deterministic: z.ZodBoolean;
+    inputs: z.ZodArray<z.ZodString, "many">;
+    output: z.ZodString;
+    windowDays: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    deterministic: boolean;
+    inputs: string[];
+    output: string;
+    windowDays?: number | undefined;
+}, {
+    id: string;
+    deterministic: boolean;
+    inputs: string[];
+    output: string;
+    windowDays?: number | undefined;
+}>;
+export declare const SolverNetManifestV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"solvernet.manifest.v1">;
+    solverNetId: z.ZodString;
+    network: z.ZodEnum<["base-sepolia", "base"]>;
+    name: z.ZodString;
+    description: z.ZodString;
+    launcher: z.ZodObject<{
+        safeAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        agentEoa: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        agentId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        agentId: string;
+        safeAddress: `0x${string}`;
+        agentEoa: `0x${string}`;
+    }, {
+        agentId: string;
+        safeAddress: `0x${string}`;
+        agentEoa: `0x${string}`;
+    }>;
+    contract: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        schemas: z.ZodObject<{
+            task: z.ZodType<JsonSchema, z.ZodTypeDef, JsonSchema>;
+            solution: z.ZodType<JsonSchema, z.ZodTypeDef, JsonSchema>;
+            verdict: z.ZodType<JsonSchema, z.ZodTypeDef, JsonSchema>;
+        }, "strict", z.ZodTypeAny, {
+            verdict: JsonSchema;
+            task: JsonSchema;
+            solution: JsonSchema;
+        }, {
+            verdict: JsonSchema;
+            task: JsonSchema;
+            solution: JsonSchema;
+        }>;
+        claimPolicyDefaults: z.ZodObject<{
+            mode: z.ZodEnum<["parallel", "serial"]>;
+            maxClaims: z.ZodNumber;
+            maxClaimsPerOperator: z.ZodNumber;
+            claimLeaseTtlSeconds: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            mode: "parallel" | "serial";
+            maxClaims: number;
+            maxClaimsPerOperator: number;
+            claimLeaseTtlSeconds: number;
+        }, {
+            mode: "parallel" | "serial";
+            maxClaims: number;
+            maxClaimsPerOperator: number;
+            claimLeaseTtlSeconds: number;
+        }>;
+        credentialRequirements: z.ZodObject<{
+            creator: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                required: z.ZodBoolean;
+                description: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }, {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }>, "many">;
+            solver: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                required: z.ZodBoolean;
+                description: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }, {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }>, "many">;
+            evaluator: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                required: z.ZodBoolean;
+                description: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }, {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            creator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            solver: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            evaluator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+        }, {
+            creator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            solver: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            evaluator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+        }>;
+        evaluationFunction: z.ZodObject<{
+            id: z.ZodString;
+            deterministic: z.ZodBoolean;
+            inputs: z.ZodArray<z.ZodString, "many">;
+            output: z.ZodString;
+            implementation: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            implementation: string;
+        }, {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            implementation: string;
+        }>;
+        aggregationFunction: z.ZodObject<{
+            id: z.ZodString;
+            deterministic: z.ZodBoolean;
+            inputs: z.ZodArray<z.ZodString, "many">;
+            output: z.ZodString;
+            windowDays: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            windowDays?: number | undefined;
+        }, {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            windowDays?: number | undefined;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        version: string;
+        id: string;
+        schemas: {
+            verdict: JsonSchema;
+            task: JsonSchema;
+            solution: JsonSchema;
+        };
+        claimPolicyDefaults: {
+            mode: "parallel" | "serial";
+            maxClaims: number;
+            maxClaimsPerOperator: number;
+            claimLeaseTtlSeconds: number;
+        };
+        credentialRequirements: {
+            creator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            solver: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            evaluator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+        };
+        evaluationFunction: {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            implementation: string;
+        };
+        aggregationFunction: {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            windowDays?: number | undefined;
+        };
+    }, {
+        version: string;
+        id: string;
+        schemas: {
+            verdict: JsonSchema;
+            task: JsonSchema;
+            solution: JsonSchema;
+        };
+        claimPolicyDefaults: {
+            mode: "parallel" | "serial";
+            maxClaims: number;
+            maxClaimsPerOperator: number;
+            claimLeaseTtlSeconds: number;
+        };
+        credentialRequirements: {
+            creator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            solver: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            evaluator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+        };
+        evaluationFunction: {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            implementation: string;
+        };
+        aggregationFunction: {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            windowDays?: number | undefined;
+        };
+    }>;
+    solutionPriceWei: z.ZodString;
+    verdictPriceWei: z.ZodString;
+    openRoles: z.ZodArray<z.ZodEnum<["solver", "evaluator"]>, "many">;
+    registry: z.ZodOptional<z.ZodObject<{
+        manifestCid: z.ZodOptional<z.ZodString>;
+        registryUrl: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        manifestCid?: string | undefined;
+        registryUrl?: string | undefined;
+    }, {
+        manifestCid?: string | undefined;
+        registryUrl?: string | undefined;
+    }>>;
+    createdAt: z.ZodString;
+    launchedAt: z.ZodString;
+    signature: z.ZodObject<{
+        alg: z.ZodLiteral<"eip-191">;
+        signer: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        value: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    }, "strict", z.ZodTypeAny, {
+        value: `0x${string}`;
+        alg: "eip-191";
+        signer: `0x${string}`;
+    }, {
+        value: `0x${string}`;
+        alg: "eip-191";
+        signer: `0x${string}`;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    schemaVersion: "solvernet.manifest.v1";
+    name: string;
+    signature: {
+        value: `0x${string}`;
+        alg: "eip-191";
+        signer: `0x${string}`;
+    };
+    solverNetId: string;
+    network: "base-sepolia" | "base";
+    launcher: {
+        agentId: string;
+        safeAddress: `0x${string}`;
+        agentEoa: `0x${string}`;
+    };
+    contract: {
+        version: string;
+        id: string;
+        schemas: {
+            verdict: JsonSchema;
+            task: JsonSchema;
+            solution: JsonSchema;
+        };
+        claimPolicyDefaults: {
+            mode: "parallel" | "serial";
+            maxClaims: number;
+            maxClaimsPerOperator: number;
+            claimLeaseTtlSeconds: number;
+        };
+        credentialRequirements: {
+            creator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            solver: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            evaluator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+        };
+        evaluationFunction: {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            implementation: string;
+        };
+        aggregationFunction: {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            windowDays?: number | undefined;
+        };
+    };
+    solutionPriceWei: string;
+    verdictPriceWei: string;
+    openRoles: ("solver" | "evaluator")[];
+    createdAt: string;
+    launchedAt: string;
+    registry?: {
+        manifestCid?: string | undefined;
+        registryUrl?: string | undefined;
+    } | undefined;
+}, {
+    description: string;
+    schemaVersion: "solvernet.manifest.v1";
+    name: string;
+    signature: {
+        value: `0x${string}`;
+        alg: "eip-191";
+        signer: `0x${string}`;
+    };
+    solverNetId: string;
+    network: "base-sepolia" | "base";
+    launcher: {
+        agentId: string;
+        safeAddress: `0x${string}`;
+        agentEoa: `0x${string}`;
+    };
+    contract: {
+        version: string;
+        id: string;
+        schemas: {
+            verdict: JsonSchema;
+            task: JsonSchema;
+            solution: JsonSchema;
+        };
+        claimPolicyDefaults: {
+            mode: "parallel" | "serial";
+            maxClaims: number;
+            maxClaimsPerOperator: number;
+            claimLeaseTtlSeconds: number;
+        };
+        credentialRequirements: {
+            creator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            solver: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+            evaluator: {
+                description: string;
+                kind: string;
+                id: string;
+                required: boolean;
+            }[];
+        };
+        evaluationFunction: {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            implementation: string;
+        };
+        aggregationFunction: {
+            id: string;
+            deterministic: boolean;
+            inputs: string[];
+            output: string;
+            windowDays?: number | undefined;
+        };
+    };
+    solutionPriceWei: string;
+    verdictPriceWei: string;
+    openRoles: ("solver" | "evaluator")[];
+    createdAt: string;
+    launchedAt: string;
+    registry?: {
+        manifestCid?: string | undefined;
+        registryUrl?: string | undefined;
+    } | undefined;
+}>;
+/**
+ * The canonical TypeScript shape of a SolverNetManifestV1, derived from the
+ * Zod schema. Mirrors the interface in §7 of the spec exactly.
+ *
+ * Note: derivation from Zod ensures the type and the validator can never
+ * drift apart. If you change the Zod schema, the type updates automatically.
+ */
+export type SolverNetManifestV1 = z.infer<typeof SolverNetManifestV1Schema>;
+/**
+ * Re-exports of the per-role helper types — useful for code that builds
+ * partial pieces of a manifest before the full document is assembled.
+ */
+export type SolverNetContractRole = z.infer<typeof ContractRoleZ>;
+export type SolverNetCredentialRequirement = z.infer<typeof CredentialRequirementZ>;
+export type SolverNetClaimPolicyDefaults = z.infer<typeof ClaimPolicyDefaultsZ>;
+export type SolverNetEvaluationFunction = z.infer<typeof EvaluationFunctionZ>;
+export type SolverNetAggregationFunction = z.infer<typeof AggregationFunctionZ>;
+export interface ManifestValidationIssue {
+    path: string;
+    message: string;
+}
+export type ManifestValidationResult = {
+    ok: true;
+    value: SolverNetManifestV1;
+} | {
+    ok: false;
+    issues: ManifestValidationIssue[];
+};
+/**
+ * Validate a value against the SolverNetManifestV1 schema. Returns a tagged
+ * union with either the typed manifest or a list of validation issues with
+ * dotted paths suitable for surfacing in launcher UI.
+ */
+export declare function validateSolverNetManifest(value: unknown): ManifestValidationResult;
+export {};