@jinn-network/sdk 0.1.0

package/dist/payloads/prediction-v1.d.ts

@@ -0,0 +1,223 @@
+import { z } from 'zod';
+export declare const PredictionV1RestorationPayloadSchema: z.ZodObject<{
+    probabilityYes: z.ZodString;
+    submittedAt: z.ZodString;
+    format: z.ZodLiteral<"decimal">;
+    modelId: z.ZodString;
+    confidence: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    methodology: z.ZodOptional<z.ZodString>;
+    evidenceCids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    reasoningCid: z.ZodOptional<z.ZodString>;
+    sourceRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        title: string;
+    }, {
+        url: string;
+        title: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    probabilityYes: string;
+    submittedAt: string;
+    format: "decimal";
+    modelId: string;
+    confidence?: "low" | "medium" | "high" | undefined;
+    methodology?: string | undefined;
+    evidenceCids?: string[] | undefined;
+    reasoningCid?: string | undefined;
+    sourceRefs?: {
+        url: string;
+        title: string;
+    }[] | undefined;
+}, {
+    probabilityYes: string;
+    submittedAt: string;
+    format: "decimal";
+    modelId: string;
+    confidence?: "low" | "medium" | "high" | undefined;
+    methodology?: string | undefined;
+    evidenceCids?: string[] | undefined;
+    reasoningCid?: string | undefined;
+    sourceRefs?: {
+        url: string;
+        title: string;
+    }[] | undefined;
+}>;
+export type PredictionV1RestorationPayload = z.infer<typeof PredictionV1RestorationPayloadSchema>;
+export declare const PredictionV1VerdictPayloadSchema: z.ZodObject<{
+    verdict: z.ZodEnum<["SCORED", "REJECTED", "INVALID", "INDETERMINATE"]>;
+    outcome: z.ZodOptional<z.ZodEnum<["YES", "NO", "INVALID"]>>;
+    resolvedAt: z.ZodOptional<z.ZodString>;
+    resolutionSource: z.ZodObject<{
+        venue: z.ZodLiteral<"polymarket">;
+        url: z.ZodString;
+        marketId: z.ZodString;
+        conditionId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        venue: "polymarket";
+        url: string;
+        marketId: string;
+        conditionId: string;
+    }, {
+        venue: "polymarket";
+        url: string;
+        marketId: string;
+        conditionId: string;
+    }>;
+    task: z.ZodObject<{
+        cid: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        cid: string;
+        id: string;
+    }, {
+        cid: string;
+        id: string;
+    }>;
+    solutionEnvelope: z.ZodObject<{
+        cid: z.ZodString;
+        sha256: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        cid: string;
+        sha256: string;
+    }, {
+        cid: string;
+        sha256: string;
+    }>;
+    claimed: z.ZodOptional<z.ZodObject<{
+        probabilityYes: z.ZodString;
+        submittedAt: z.ZodString;
+        modelId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        probabilityYes: string;
+        submittedAt: string;
+        modelId: string;
+    }, {
+        probabilityYes: string;
+        submittedAt: string;
+        modelId: string;
+    }>>;
+    benchmark: z.ZodObject<{
+        probabilityYes: z.ZodString;
+        sampledAt: z.ZodString;
+        method: z.ZodLiteral<"best-bid-ask-midpoint">;
+    }, "strip", z.ZodTypeAny, {
+        sampledAt: string;
+        probabilityYes: string;
+        method: "best-bid-ask-midpoint";
+    }, {
+        sampledAt: string;
+        probabilityYes: string;
+        method: "best-bid-ask-midpoint";
+    }>;
+    scores: z.ZodOptional<z.ZodObject<{
+        scoreBasis: z.ZodLiteral<"brier-loss.v1">;
+        solverBrier: z.ZodString;
+        consensusBrier: z.ZodString;
+        brierSpread: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        scoreBasis: "brier-loss.v1";
+        solverBrier: string;
+        consensusBrier: string;
+        brierSpread: string;
+    }, {
+        scoreBasis: "brier-loss.v1";
+        solverBrier: string;
+        consensusBrier: string;
+        brierSpread: string;
+    }>>;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<["PASS", "FAIL", "SKIP", "INDETERMINATE"]>;
+        detail: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "PASS" | "FAIL" | "SKIP" | "INDETERMINATE";
+        name: string;
+        detail?: string | Record<string, unknown> | undefined;
+    }, {
+        status: "PASS" | "FAIL" | "SKIP" | "INDETERMINATE";
+        name: string;
+        detail?: string | Record<string, unknown> | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    verdict: "INDETERMINATE" | "SCORED" | "REJECTED" | "INVALID";
+    resolutionSource: {
+        venue: "polymarket";
+        url: string;
+        marketId: string;
+        conditionId: string;
+    };
+    task: {
+        cid: string;
+        id: string;
+    };
+    solutionEnvelope: {
+        cid: string;
+        sha256: string;
+    };
+    benchmark: {
+        sampledAt: string;
+        probabilityYes: string;
+        method: "best-bid-ask-midpoint";
+    };
+    checks: {
+        status: "PASS" | "FAIL" | "SKIP" | "INDETERMINATE";
+        name: string;
+        detail?: string | Record<string, unknown> | undefined;
+    }[];
+    outcome?: "YES" | "NO" | "INVALID" | undefined;
+    resolvedAt?: string | undefined;
+    claimed?: {
+        probabilityYes: string;
+        submittedAt: string;
+        modelId: string;
+    } | undefined;
+    scores?: {
+        scoreBasis: "brier-loss.v1";
+        solverBrier: string;
+        consensusBrier: string;
+        brierSpread: string;
+    } | undefined;
+}, {
+    verdict: "INDETERMINATE" | "SCORED" | "REJECTED" | "INVALID";
+    resolutionSource: {
+        venue: "polymarket";
+        url: string;
+        marketId: string;
+        conditionId: string;
+    };
+    task: {
+        cid: string;
+        id: string;
+    };
+    solutionEnvelope: {
+        cid: string;
+        sha256: string;
+    };
+    benchmark: {
+        sampledAt: string;
+        probabilityYes: string;
+        method: "best-bid-ask-midpoint";
+    };
+    checks: {
+        status: "PASS" | "FAIL" | "SKIP" | "INDETERMINATE";
+        name: string;
+        detail?: string | Record<string, unknown> | undefined;
+    }[];
+    outcome?: "YES" | "NO" | "INVALID" | undefined;
+    resolvedAt?: string | undefined;
+    claimed?: {
+        probabilityYes: string;
+        submittedAt: string;
+        modelId: string;
+    } | undefined;
+    scores?: {
+        scoreBasis: "brier-loss.v1";
+        solverBrier: string;
+        consensusBrier: string;
+        brierSpread: string;
+    } | undefined;
+}>;
+export type PredictionV1VerdictPayload = z.infer<typeof PredictionV1VerdictPayloadSchema>;

package/dist/payloads/prediction-v1.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { DecimalProbabilitySchema, IsoDateTimeSchema } from '../prediction-v1.js';
+const Sha256Schema = z.string().regex(/^[0-9a-f]{64}$/);
+const CheckSchema = z.object({
+    name: z.string().min(1),
+    status: z.enum(['PASS', 'FAIL', 'SKIP', 'INDETERMINATE']),
+    detail: z.union([z.string(), z.record(z.unknown())]).optional(),
+});
+export const PredictionV1RestorationPayloadSchema = z.object({
+    probabilityYes: DecimalProbabilitySchema,
+    submittedAt: IsoDateTimeSchema,
+    format: z.literal('decimal'),
+    modelId: z.string().min(1),
+    confidence: z.enum(['low', 'medium', 'high']).optional(),
+    methodology: z.string().optional(),
+    evidenceCids: z.array(z.string().min(1)).optional(),
+    reasoningCid: z.string().min(1).optional(),
+    sourceRefs: z
+        .array(z.object({
+        title: z.string().min(1),
+        url: z.string().url(),
+    }))
+        .optional(),
+});
+export const PredictionV1VerdictPayloadSchema = z.object({
+    verdict: z.enum(['SCORED', 'REJECTED', 'INVALID', 'INDETERMINATE']),
+    outcome: z.enum(['YES', 'NO', 'INVALID']).optional(),
+    resolvedAt: IsoDateTimeSchema.optional(),
+    resolutionSource: z.object({
+        venue: z.literal('polymarket'),
+        url: z.string().url(),
+        marketId: z.string().min(1),
+        conditionId: z.string().min(1),
+    }),
+    task: z.object({
+        cid: z.string(),
+        id: z.string().min(1),
+    }),
+    solutionEnvelope: z.object({
+        cid: z.string(),
+        sha256: Sha256Schema,
+    }),
+    claimed: z
+        .object({
+        probabilityYes: DecimalProbabilitySchema,
+        submittedAt: IsoDateTimeSchema,
+        modelId: z.string().min(1),
+    })
+        .optional(),
+    benchmark: z.object({
+        probabilityYes: DecimalProbabilitySchema,
+        sampledAt: IsoDateTimeSchema,
+        method: z.literal('best-bid-ask-midpoint'),
+    }),
+    scores: z
+        .object({
+        scoreBasis: z.literal('brier-loss.v1'),
+        solverBrier: z.string(),
+        consensusBrier: z.string(),
+        brierSpread: z.string(),
+    })
+        .optional(),
+    checks: z.array(CheckSchema),
+});

package/dist/plugins.d.ts

@@ -0,0 +1,36 @@
+export type SolverPluginSourceKind = 'bundled' | 'local' | 'npm' | 'git' | 'github' | 'claude';
+export type SolverPluginEntry = string | {
+    name?: string;
+    source: string;
+    version?: string;
+};
+export interface SolverPluginManifest {
+    name: string;
+    version: string;
+    description?: string;
+    jinn?: {
+        supports?: string[];
+        capabilities?: Record<string, unknown>;
+        mcpServers?: Record<string, unknown>;
+        skills?: string[];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface LoadedSolverPlugin {
+    name: string;
+    version: string;
+    supports: string[];
+    source: string;
+    sourceKind: SolverPluginSourceKind;
+    root: string;
+    manifestPath: string;
+    manifest: SolverPluginManifest;
+    sha256: string;
+    cid?: string;
+}
+export interface ResolveSolverPluginOptions {
+    bundledRoot?: string;
+    vendorRoot?: string;
+}
+export declare function validateSolverPluginManifest(input: unknown): SolverPluginManifest;

package/dist/plugins.js

@@ -0,0 +1,54 @@
+function assertRecord(value, label) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+}
+export function validateSolverPluginManifest(input) {
+    assertRecord(input, 'manifest');
+    for (const key of Object.keys(input)) {
+        if (key.startsWith('jinn.')) {
+            throw new Error(`unknown top-level jinn extension key: ${key}; use manifest.jinn`);
+        }
+    }
+    if (typeof input['name'] !== 'string' || input['name'].length === 0) {
+        throw new Error('manifest.name is required');
+    }
+    if (typeof input['version'] !== 'string' || input['version'].length === 0) {
+        throw new Error('manifest.version is required');
+    }
+    const jinn = input['jinn'];
+    if (jinn !== undefined) {
+        assertRecord(jinn, 'manifest.jinn');
+        if ('solverType' in jinn) {
+            throw new Error('manifest.jinn.solverType is no longer supported; SolverNet contracts define solverType authority');
+        }
+        if ('schemas' in jinn) {
+            throw new Error('manifest.jinn.schemas is no longer supported; SolverNet contracts define canonical schemas');
+        }
+        const supports = jinn['supports'];
+        if (supports !== undefined) {
+            if (!Array.isArray(supports))
+                throw new Error('manifest.jinn.supports must be an array');
+            for (const [idx, value] of supports.entries()) {
+                if (typeof value !== 'string' || value.length === 0) {
+                    throw new Error(`manifest.jinn.supports[${idx}] must be a non-empty string`);
+                }
+            }
+        }
+        if (jinn['capabilities'] !== undefined)
+            assertRecord(jinn['capabilities'], 'manifest.jinn.capabilities');
+        if (jinn['mcpServers'] !== undefined)
+            assertRecord(jinn['mcpServers'], 'manifest.jinn.mcpServers');
+        const skills = jinn['skills'];
+        if (skills !== undefined) {
+            if (!Array.isArray(skills))
+                throw new Error('manifest.jinn.skills must be an array');
+            for (const [idx, value] of skills.entries()) {
+                if (typeof value !== 'string' || value.length === 0) {
+                    throw new Error(`manifest.jinn.skills[${idx}] must be a non-empty string`);
+                }
+            }
+        }
+    }
+    return input;
+}