@sip-protocol/sdk 0.7.3 → 0.7.4

package/dist/proofs/halo2.js

@@ -0,0 +1,350 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/proofs/halo2.ts
+var halo2_exports = {};
+__export(halo2_exports, {
+  Halo2Provider: () => Halo2Provider,
+  createHalo2Provider: () => createHalo2Provider,
+  createOrchardProvider: () => createOrchardProvider
+});
+module.exports = __toCommonJS(halo2_exports);
+
+// src/proofs/providers/halo2.ts
+var import_utils = require("@noble/hashes/utils");
+var import_types = require("@sip-protocol/types");
+var DEFAULT_HALO2_CONFIG = {
+  artifactsPath: "",
+  circuits: [],
+  verbose: false,
+  numThreads: 4,
+  enableRecursion: false,
+  backend: "wasm"
+};
+var Halo2Provider = class {
+  system = "halo2";
+  _config;
+  _status;
+  _capabilities;
+  _metrics;
+  _circuits = /* @__PURE__ */ new Map();
+  _provingKeys = /* @__PURE__ */ new Map();
+  _initPromise = null;
+  _initError = null;
+  constructor(config = {}) {
+    this._config = { ...DEFAULT_HALO2_CONFIG, ...config };
+    this._metrics = {
+      proofsGenerated: 0,
+      proofsVerified: 0,
+      avgGenerationTimeMs: 0,
+      avgVerificationTimeMs: 0,
+      successRate: 1,
+      memoryUsageBytes: 0
+    };
+    this._status = {
+      isReady: false,
+      isBusy: false,
+      queueLength: 0,
+      metrics: this._metrics
+    };
+    this._capabilities = {
+      system: "halo2",
+      supportsRecursion: this._config.enableRecursion,
+      supportsBatchVerification: true,
+      supportsBrowser: this._config.backend === "wasm",
+      supportsNode: true,
+      maxProofSize: 10 * 1024 * 1024,
+      // 10MB
+      supportedStrategies: [
+        import_types.ProofAggregationStrategy.SEQUENTIAL,
+        import_types.ProofAggregationStrategy.PARALLEL,
+        import_types.ProofAggregationStrategy.BATCH,
+        ...this._config.enableRecursion ? [import_types.ProofAggregationStrategy.RECURSIVE] : []
+      ],
+      availableCircuits: []
+    };
+    for (const circuit of this._config.circuits) {
+      this._circuits.set(circuit.id, circuit);
+    }
+  }
+  // ─── Properties ───────────────────────────────────────────────────────────
+  get capabilities() {
+    return {
+      ...this._capabilities,
+      availableCircuits: Array.from(this._circuits.keys())
+    };
+  }
+  get status() {
+    return { ...this._status };
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  async initialize() {
+    if (this._status.isReady) return;
+    if (this._initPromise) {
+      return this._initPromise;
+    }
+    this._initPromise = this.doInitialize();
+    return this._initPromise;
+  }
+  async doInitialize() {
+    try {
+      if (this._config.verbose) {
+        console.log("[Halo2Provider] Initializing...");
+      }
+      await this.simulateAsyncLoad();
+      if (this._config.artifactsPath) {
+        await this.loadCircuitArtifacts();
+      }
+      this._status.isReady = true;
+      if (this._config.verbose) {
+        console.log("[Halo2Provider] Initialization complete");
+        console.log(`[Halo2Provider] Available circuits: ${Array.from(this._circuits.keys()).join(", ")}`);
+      }
+    } catch (error) {
+      this._initError = error instanceof Error ? error : new Error(String(error));
+      this._status.lastError = this._initError.message;
+      throw this._initError;
+    }
+  }
+  async waitUntilReady(timeoutMs = 3e4) {
+    if (this._status.isReady) return;
+    if (this._initError) {
+      throw this._initError;
+    }
+    if (!this._initPromise) {
+      this._initPromise = this.doInitialize();
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Halo2Provider initialization timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    await Promise.race([this._initPromise, timeoutPromise]);
+  }
+  async dispose() {
+    this._provingKeys.clear();
+    this._status.isReady = false;
+    this._initPromise = null;
+    this._initError = null;
+    if (this._config.verbose) {
+      console.log("[Halo2Provider] Disposed");
+    }
+  }
+  // ─── Circuit Management ───────────────────────────────────────────────────
+  getAvailableCircuits() {
+    return Array.from(this._circuits.keys());
+  }
+  hasCircuit(circuitId) {
+    return this._circuits.has(circuitId);
+  }
+  /**
+   * Register a circuit configuration
+   */
+  registerCircuit(config) {
+    this._circuits.set(config.id, config);
+    if (this._config.verbose) {
+      console.log(`[Halo2Provider] Registered circuit: ${config.id} (k=${config.k})`);
+    }
+  }
+  /**
+   * Load proving/verifying keys for a circuit
+   */
+  async loadCircuitKeys(circuitId) {
+    const circuit = this._circuits.get(circuitId);
+    if (!circuit) {
+      throw new Error(`Circuit not found: ${circuitId}`);
+    }
+    const provingKey = {
+      circuitId,
+      k: circuit.k,
+      pkBytes: void 0,
+      // Lazy-loaded
+      vkBytes: new Uint8Array(64)
+      // Placeholder VK
+    };
+    this._provingKeys.set(circuitId, provingKey);
+    if (this._config.verbose) {
+      console.log(`[Halo2Provider] Loaded keys for circuit: ${circuitId}`);
+    }
+  }
+  // ─── Proof Generation ─────────────────────────────────────────────────────
+  async generateProof(request) {
+    const startTime = Date.now();
+    if (!this._status.isReady) {
+      return {
+        success: false,
+        error: "Provider not initialized",
+        timeMs: Date.now() - startTime,
+        providerId: `halo2-${this.generateProviderId()}`
+      };
+    }
+    const circuit = this._circuits.get(request.circuitId);
+    if (!circuit) {
+      return {
+        success: false,
+        error: `Circuit not found: ${request.circuitId}`,
+        timeMs: Date.now() - startTime,
+        providerId: `halo2-${this.generateProviderId()}`
+      };
+    }
+    try {
+      this._status.isBusy = true;
+      const proof = await this.generateMockProof(request, circuit);
+      const timeMs = Date.now() - startTime;
+      this._metrics.proofsGenerated++;
+      this._metrics.avgGenerationTimeMs = (this._metrics.avgGenerationTimeMs * (this._metrics.proofsGenerated - 1) + timeMs) / this._metrics.proofsGenerated;
+      return {
+        success: true,
+        proof,
+        timeMs,
+        providerId: `halo2-${this.generateProviderId()}`
+      };
+    } catch (error) {
+      this._metrics.successRate = this._metrics.proofsGenerated > 0 ? (this._metrics.proofsGenerated - 1) / this._metrics.proofsGenerated : 0;
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error during proof generation",
+        timeMs: Date.now() - startTime,
+        providerId: `halo2-${this.generateProviderId()}`
+      };
+    } finally {
+      this._status.isBusy = false;
+    }
+  }
+  async generateMockProof(request, circuit) {
+    const simulatedTimeMs = Math.min(100 + circuit.k * 10, 2e3);
+    await this.delay(simulatedTimeMs);
+    const proofBytes = (0, import_utils.randomBytes)(256);
+    const proofHex = `0x${(0, import_utils.bytesToHex)(proofBytes)}`;
+    const publicInputs = Object.values(request.publicInputs).map((v) => {
+      if (typeof v === "string" && v.startsWith("0x")) {
+        return v;
+      }
+      if (typeof v === "bigint" || typeof v === "number") {
+        return `0x${v.toString(16).padStart(64, "0")}`;
+      }
+      return `0x${Buffer.from(String(v)).toString("hex")}`;
+    });
+    return {
+      id: `halo2-proof-${Date.now()}-${(0, import_utils.randomBytes)(4).reduce((a, b) => a + b.toString(16), "")}`,
+      proof: proofHex,
+      publicInputs,
+      metadata: {
+        system: "halo2",
+        systemVersion: "0.3.0",
+        circuitId: circuit.id,
+        circuitVersion: "1.0.0",
+        generatedAt: Date.now(),
+        proofSizeBytes: proofBytes.length,
+        verificationCost: BigInt(circuit.k * 1e4)
+      }
+    };
+  }
+  // ─── Verification ─────────────────────────────────────────────────────────
+  async verifyProof(proof) {
+    if (!this._status.isReady) {
+      throw new Error("Provider not initialized");
+    }
+    const startTime = Date.now();
+    try {
+      const isValid = this.validateProofFormat(proof);
+      const timeMs = Date.now() - startTime;
+      this._metrics.proofsVerified++;
+      this._metrics.avgVerificationTimeMs = (this._metrics.avgVerificationTimeMs * (this._metrics.proofsVerified - 1) + timeMs) / this._metrics.proofsVerified;
+      return isValid;
+    } catch {
+      return false;
+    }
+  }
+  async verifyBatch(proofs) {
+    if (!this._status.isReady) {
+      throw new Error("Provider not initialized");
+    }
+    const results = [];
+    for (const proof of proofs) {
+      results.push(await this.verifyProof(proof));
+    }
+    return results;
+  }
+  validateProofFormat(proof) {
+    if (!proof.id || !proof.proof || !proof.metadata) {
+      return false;
+    }
+    if (proof.metadata.system !== "halo2") {
+      return false;
+    }
+    if (!proof.proof.startsWith("0x")) {
+      return false;
+    }
+    if (proof.metadata.expiresAt && proof.metadata.expiresAt < Date.now()) {
+      return false;
+    }
+    return true;
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────────────
+  async simulateAsyncLoad() {
+    await this.delay(50);
+  }
+  async loadCircuitArtifacts() {
+    if (this._config.verbose) {
+      console.log(`[Halo2Provider] Loading artifacts from: ${this._config.artifactsPath}`);
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  generateProviderId() {
+    return (0, import_utils.bytesToHex)((0, import_utils.randomBytes)(4));
+  }
+};
+function createHalo2Provider(config) {
+  return new Halo2Provider(config);
+}
+function createOrchardProvider() {
+  return new Halo2Provider({
+    enableRecursion: true,
+    circuits: [
+      {
+        id: "orchard_action",
+        name: "Orchard Action Circuit",
+        k: 11,
+        numColumns: 10,
+        numPublicInputs: 5,
+        supportsRecursion: true
+      },
+      {
+        id: "orchard_bundle",
+        name: "Orchard Bundle Circuit",
+        k: 12,
+        numColumns: 12,
+        numPublicInputs: 8,
+        supportsRecursion: true
+      }
+    ]
+  });
+}
+
+// src/proofs/providers/kimchi.ts
+var import_utils2 = require("@noble/hashes/utils");
+var import_types2 = require("@sip-protocol/types");
+var KIMCHI_PROOF_SIZE = 22 * 1024;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Halo2Provider,
+  createHalo2Provider,
+  createOrchardProvider
+});

package/dist/proofs/halo2.mjs

@@ -0,0 +1,11 @@
+import {
+  Halo2Provider,
+  createHalo2Provider,
+  createOrchardProvider
+} from "../chunk-5D7A3L3W.mjs";
+import "../chunk-XGB3TDIC.mjs";
+export {
+  Halo2Provider,
+  createHalo2Provider,
+  createOrchardProvider
+};

package/dist/proofs/kimchi.d.mts

@@ -0,0 +1,160 @@
+import { b as ComposableProofProvider, g as ProofGenerationRequest, h as ProofGenerationResult } from '../interface-Bf7w1PLW.mjs';
+import { ProofSystem, ProofProviderCapabilities, ProofProviderStatus, SingleProof } from '@sip-protocol/types';
+export { ProofMetadata, ProofProviderCapabilities, ProofProviderStatus, ProofSystem, SingleProof } from '@sip-protocol/types';
+
+/**
+ * Kimchi Proof Provider
+ *
+ * Implements ComposableProofProvider interface for Mina's Kimchi proof system.
+ * Kimchi is the proving system behind Mina Protocol, providing succinct proofs
+ * and efficient recursive composition via Pickles.
+ *
+ * Key features:
+ * - Constant-size proofs (~22KB)
+ * - Recursive proof composition (Pickles wrapper)
+ * - Efficient verification
+ * - Browser WASM support via o1js
+ *
+ * @see https://docs.minaprotocol.com/ for Kimchi documentation
+ * @packageDocumentation
+ */
+
+/**
+ * Kimchi circuit configuration
+ */
+interface KimchiCircuitConfig {
+    /** Circuit identifier */
+    id: string;
+    /** Circuit name */
+    name: string;
+    /** Number of gates in the circuit */
+    gateCount: number;
+    /** Public input count */
+    publicInputCount: number;
+    /** Whether circuit uses recursion (Pickles) */
+    usesRecursion: boolean;
+    /** Verification key hash (for caching) */
+    verificationKeyHash?: string;
+}
+/**
+ * Kimchi provider configuration
+ */
+interface KimchiProviderConfig {
+    /**
+     * Pre-configured circuits
+     */
+    circuits?: KimchiCircuitConfig[];
+    /**
+     * Enable verbose logging
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Network for proof generation
+     * @default 'testnet'
+     */
+    network?: 'mainnet' | 'testnet' | 'local';
+    /**
+     * Enable Pickles recursive proving
+     * @default true
+     */
+    enablePickles?: boolean;
+    /**
+     * Proof compilation cache directory
+     */
+    cacheDir?: string;
+    /**
+     * Number of workers for parallel compilation
+     * @default 2
+     */
+    compileWorkers?: number;
+}
+/**
+ * Kimchi Proof Provider
+ *
+ * Implements ComposableProofProvider for Mina's Kimchi proof system.
+ *
+ * @example
+ * ```typescript
+ * const provider = new KimchiProvider({
+ *   enablePickles: true,
+ *   network: 'testnet',
+ * })
+ *
+ * await provider.initialize()
+ *
+ * const result = await provider.generateProof({
+ *   circuitId: 'transfer_proof',
+ *   privateInputs: { sender: '...', amount: '...' },
+ *   publicInputs: { commitment: '...' },
+ * })
+ * ```
+ */
+declare class KimchiProvider implements ComposableProofProvider {
+    readonly system: ProofSystem;
+    private _config;
+    private _status;
+    private _capabilities;
+    private _metrics;
+    private _circuits;
+    private _compiledCircuits;
+    private _initPromise;
+    private _initError;
+    constructor(config?: KimchiProviderConfig);
+    get capabilities(): ProofProviderCapabilities;
+    get status(): ProofProviderStatus;
+    initialize(): Promise<void>;
+    private doInitialize;
+    waitUntilReady(timeoutMs?: number): Promise<void>;
+    dispose(): Promise<void>;
+    getAvailableCircuits(): string[];
+    hasCircuit(circuitId: string): boolean;
+    /**
+     * Register a circuit configuration
+     */
+    registerCircuit(config: KimchiCircuitConfig): void;
+    /**
+     * Compile a circuit for proof generation
+     *
+     * Compiling in Kimchi/o1js creates the verification key and prepares
+     * the circuit for proving.
+     */
+    compileCircuit(circuitId: string): Promise<string>;
+    /**
+     * Check if a circuit is compiled
+     */
+    isCircuitCompiled(circuitId: string): boolean;
+    generateProof(request: ProofGenerationRequest): Promise<ProofGenerationResult>;
+    private generateMockProof;
+    verifyProof(proof: SingleProof): Promise<boolean>;
+    verifyBatch(proofs: SingleProof[]): Promise<boolean[]>;
+    private validateProofFormat;
+    /**
+     * Check if Pickles recursive proving is available
+     */
+    supportsRecursion(): boolean;
+    /**
+     * Merge multiple proofs recursively using Pickles
+     *
+     * This enables constant-size proofs regardless of how many
+     * proofs are combined.
+     */
+    mergeProofsRecursively(proofs: SingleProof[]): Promise<SingleProof | null>;
+    private simulateAsyncLoad;
+    private delay;
+    private generateProviderId;
+}
+/**
+ * Create a Kimchi provider with standard configuration
+ */
+declare function createKimchiProvider(config?: KimchiProviderConfig): KimchiProvider;
+/**
+ * Create a Kimchi provider configured for Mina mainnet
+ */
+declare function createMinaMainnetProvider(): KimchiProvider;
+/**
+ * Create a Kimchi provider configured for zkApp development
+ */
+declare function createZkAppProvider(network?: 'testnet' | 'local'): KimchiProvider;
+
+export { ComposableProofProvider, type KimchiCircuitConfig, KimchiProvider, type KimchiProviderConfig, createKimchiProvider, createMinaMainnetProvider, createZkAppProvider };

package/dist/proofs/kimchi.d.ts

@@ -0,0 +1,160 @@
+import { b as ComposableProofProvider, g as ProofGenerationRequest, h as ProofGenerationResult } from '../interface-Bf7w1PLW.js';
+import { ProofSystem, ProofProviderCapabilities, ProofProviderStatus, SingleProof } from '@sip-protocol/types';
+export { ProofMetadata, ProofProviderCapabilities, ProofProviderStatus, ProofSystem, SingleProof } from '@sip-protocol/types';
+
+/**
+ * Kimchi Proof Provider
+ *
+ * Implements ComposableProofProvider interface for Mina's Kimchi proof system.
+ * Kimchi is the proving system behind Mina Protocol, providing succinct proofs
+ * and efficient recursive composition via Pickles.
+ *
+ * Key features:
+ * - Constant-size proofs (~22KB)
+ * - Recursive proof composition (Pickles wrapper)
+ * - Efficient verification
+ * - Browser WASM support via o1js
+ *
+ * @see https://docs.minaprotocol.com/ for Kimchi documentation
+ * @packageDocumentation
+ */
+
+/**
+ * Kimchi circuit configuration
+ */
+interface KimchiCircuitConfig {
+    /** Circuit identifier */
+    id: string;
+    /** Circuit name */
+    name: string;
+    /** Number of gates in the circuit */
+    gateCount: number;
+    /** Public input count */
+    publicInputCount: number;
+    /** Whether circuit uses recursion (Pickles) */
+    usesRecursion: boolean;
+    /** Verification key hash (for caching) */
+    verificationKeyHash?: string;
+}
+/**
+ * Kimchi provider configuration
+ */
+interface KimchiProviderConfig {
+    /**
+     * Pre-configured circuits
+     */
+    circuits?: KimchiCircuitConfig[];
+    /**
+     * Enable verbose logging
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Network for proof generation
+     * @default 'testnet'
+     */
+    network?: 'mainnet' | 'testnet' | 'local';
+    /**
+     * Enable Pickles recursive proving
+     * @default true
+     */
+    enablePickles?: boolean;
+    /**
+     * Proof compilation cache directory
+     */
+    cacheDir?: string;
+    /**
+     * Number of workers for parallel compilation
+     * @default 2
+     */
+    compileWorkers?: number;
+}
+/**
+ * Kimchi Proof Provider
+ *
+ * Implements ComposableProofProvider for Mina's Kimchi proof system.
+ *
+ * @example
+ * ```typescript
+ * const provider = new KimchiProvider({
+ *   enablePickles: true,
+ *   network: 'testnet',
+ * })
+ *
+ * await provider.initialize()
+ *
+ * const result = await provider.generateProof({
+ *   circuitId: 'transfer_proof',
+ *   privateInputs: { sender: '...', amount: '...' },
+ *   publicInputs: { commitment: '...' },
+ * })
+ * ```
+ */
+declare class KimchiProvider implements ComposableProofProvider {
+    readonly system: ProofSystem;
+    private _config;
+    private _status;
+    private _capabilities;
+    private _metrics;
+    private _circuits;
+    private _compiledCircuits;
+    private _initPromise;
+    private _initError;
+    constructor(config?: KimchiProviderConfig);
+    get capabilities(): ProofProviderCapabilities;
+    get status(): ProofProviderStatus;
+    initialize(): Promise<void>;
+    private doInitialize;
+    waitUntilReady(timeoutMs?: number): Promise<void>;
+    dispose(): Promise<void>;
+    getAvailableCircuits(): string[];
+    hasCircuit(circuitId: string): boolean;
+    /**
+     * Register a circuit configuration
+     */
+    registerCircuit(config: KimchiCircuitConfig): void;
+    /**
+     * Compile a circuit for proof generation
+     *
+     * Compiling in Kimchi/o1js creates the verification key and prepares
+     * the circuit for proving.
+     */
+    compileCircuit(circuitId: string): Promise<string>;
+    /**
+     * Check if a circuit is compiled
+     */
+    isCircuitCompiled(circuitId: string): boolean;
+    generateProof(request: ProofGenerationRequest): Promise<ProofGenerationResult>;
+    private generateMockProof;
+    verifyProof(proof: SingleProof): Promise<boolean>;
+    verifyBatch(proofs: SingleProof[]): Promise<boolean[]>;
+    private validateProofFormat;
+    /**
+     * Check if Pickles recursive proving is available
+     */
+    supportsRecursion(): boolean;
+    /**
+     * Merge multiple proofs recursively using Pickles
+     *
+     * This enables constant-size proofs regardless of how many
+     * proofs are combined.
+     */
+    mergeProofsRecursively(proofs: SingleProof[]): Promise<SingleProof | null>;
+    private simulateAsyncLoad;
+    private delay;
+    private generateProviderId;
+}
+/**
+ * Create a Kimchi provider with standard configuration
+ */
+declare function createKimchiProvider(config?: KimchiProviderConfig): KimchiProvider;
+/**
+ * Create a Kimchi provider configured for Mina mainnet
+ */
+declare function createMinaMainnetProvider(): KimchiProvider;
+/**
+ * Create a Kimchi provider configured for zkApp development
+ */
+declare function createZkAppProvider(network?: 'testnet' | 'local'): KimchiProvider;
+
+export { ComposableProofProvider, type KimchiCircuitConfig, KimchiProvider, type KimchiProviderConfig, createKimchiProvider, createMinaMainnetProvider, createZkAppProvider };