@sip-protocol/sdk 0.7.3 → 0.8.0

package/dist/proofs/kimchi.js

@@ -0,0 +1,431 @@
+"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/kimchi.ts
+var kimchi_exports = {};
+__export(kimchi_exports, {
+  KimchiProvider: () => KimchiProvider,
+  createKimchiProvider: () => createKimchiProvider,
+  createMinaMainnetProvider: () => createMinaMainnetProvider,
+  createZkAppProvider: () => createZkAppProvider
+});
+module.exports = __toCommonJS(kimchi_exports);
+
+// src/proofs/providers/halo2.ts
+var import_utils = require("@noble/hashes/utils");
+var import_types = require("@sip-protocol/types");
+
+// src/proofs/providers/kimchi.ts
+var import_utils2 = require("@noble/hashes/utils");
+var import_types2 = require("@sip-protocol/types");
+var DEFAULT_KIMCHI_CONFIG = {
+  circuits: [],
+  verbose: false,
+  network: "testnet",
+  enablePickles: true,
+  cacheDir: "",
+  compileWorkers: 2
+};
+var KIMCHI_PROOF_SIZE = 22 * 1024;
+var KIMCHI_VERSION = "1.0.0";
+var KimchiProvider = class {
+  system = "kimchi";
+  _config;
+  _status;
+  _capabilities;
+  _metrics;
+  _circuits = /* @__PURE__ */ new Map();
+  _compiledCircuits = /* @__PURE__ */ new Map();
+  _initPromise = null;
+  _initError = null;
+  constructor(config = {}) {
+    this._config = { ...DEFAULT_KIMCHI_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: "kimchi",
+      supportsRecursion: this._config.enablePickles,
+      supportsBatchVerification: true,
+      supportsBrowser: true,
+      supportsNode: true,
+      maxProofSize: KIMCHI_PROOF_SIZE * 10,
+      // Allow some overhead
+      supportedStrategies: [
+        import_types2.ProofAggregationStrategy.SEQUENTIAL,
+        import_types2.ProofAggregationStrategy.PARALLEL,
+        import_types2.ProofAggregationStrategy.BATCH,
+        ...this._config.enablePickles ? [import_types2.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("[KimchiProvider] Initializing...");
+        console.log(`[KimchiProvider] Network: ${this._config.network}`);
+        console.log(`[KimchiProvider] Pickles enabled: ${this._config.enablePickles}`);
+      }
+      await this.simulateAsyncLoad();
+      this._status.isReady = true;
+      if (this._config.verbose) {
+        console.log("[KimchiProvider] Initialization complete");
+        console.log(`[KimchiProvider] Available circuits: ${Array.from(this._circuits.keys()).join(", ") || "none"}`);
+      }
+    } 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(`KimchiProvider initialization timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    await Promise.race([this._initPromise, timeoutPromise]);
+  }
+  async dispose() {
+    this._compiledCircuits.clear();
+    this._status.isReady = false;
+    this._initPromise = null;
+    this._initError = null;
+    if (this._config.verbose) {
+      console.log("[KimchiProvider] 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(`[KimchiProvider] Registered circuit: ${config.id} (${config.gateCount} gates)`);
+    }
+  }
+  /**
+   * Compile a circuit for proof generation
+   *
+   * Compiling in Kimchi/o1js creates the verification key and prepares
+   * the circuit for proving.
+   */
+  async compileCircuit(circuitId) {
+    const circuit = this._circuits.get(circuitId);
+    if (!circuit) {
+      throw new Error(`Circuit not found: ${circuitId}`);
+    }
+    if (this._config.verbose) {
+      console.log(`[KimchiProvider] Compiling circuit: ${circuitId}`);
+    }
+    await this.delay(100 + circuit.gateCount * 0.1);
+    const vkHash = `0x${(0, import_utils2.bytesToHex)((0, import_utils2.randomBytes)(32))}`;
+    this._compiledCircuits.set(circuitId, {
+      compiled: true,
+      vkHash
+    });
+    if (this._config.verbose) {
+      console.log(`[KimchiProvider] Circuit compiled: ${circuitId}, vkHash: ${vkHash.slice(0, 18)}...`);
+    }
+    return vkHash;
+  }
+  /**
+   * Check if a circuit is compiled
+   */
+  isCircuitCompiled(circuitId) {
+    return this._compiledCircuits.get(circuitId)?.compiled === true;
+  }
+  // ─── 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: `kimchi-${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: `kimchi-${this.generateProviderId()}`
+      };
+    }
+    try {
+      this._status.isBusy = true;
+      if (!this.isCircuitCompiled(request.circuitId)) {
+        await this.compileCircuit(request.circuitId);
+      }
+      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: `kimchi-${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: `kimchi-${this.generateProviderId()}`
+      };
+    } finally {
+      this._status.isBusy = false;
+    }
+  }
+  async generateMockProof(request, circuit) {
+    const simulatedTimeMs = Math.min(200 + circuit.gateCount * 0.5, 5e3);
+    await this.delay(simulatedTimeMs);
+    const proofBytes = (0, import_utils2.randomBytes)(KIMCHI_PROOF_SIZE);
+    const proofHex = `0x${(0, import_utils2.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")}`;
+    });
+    const vkHash = this._compiledCircuits.get(request.circuitId)?.vkHash;
+    return {
+      id: `kimchi-proof-${Date.now()}-${(0, import_utils2.randomBytes)(4).reduce((a, b) => a + b.toString(16), "")}`,
+      proof: proofHex,
+      publicInputs,
+      verificationKey: vkHash,
+      metadata: {
+        system: "kimchi",
+        systemVersion: KIMCHI_VERSION,
+        circuitId: circuit.id,
+        circuitVersion: "1.0.0",
+        generatedAt: Date.now(),
+        proofSizeBytes: KIMCHI_PROOF_SIZE,
+        verificationCost: BigInt(Math.ceil(circuit.gateCount / 10)),
+        targetChainId: this._config.network === "mainnet" ? "mina:mainnet" : "mina:testnet"
+      }
+    };
+  }
+  // ─── 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 !== "kimchi") {
+      return false;
+    }
+    if (!proof.proof.startsWith("0x")) {
+      return false;
+    }
+    const proofBytes = (proof.proof.length - 2) / 2;
+    if (proofBytes < KIMCHI_PROOF_SIZE * 0.5 || proofBytes > KIMCHI_PROOF_SIZE * 2) {
+      if (this._config.verbose) {
+        console.warn(`[KimchiProvider] Unusual proof size: ${proofBytes} bytes (expected ~${KIMCHI_PROOF_SIZE})`);
+      }
+    }
+    if (proof.metadata.expiresAt && proof.metadata.expiresAt < Date.now()) {
+      return false;
+    }
+    return true;
+  }
+  // ─── Recursive Proving (Pickles) ──────────────────────────────────────────
+  /**
+   * Check if Pickles recursive proving is available
+   */
+  supportsRecursion() {
+    return this._config.enablePickles;
+  }
+  /**
+   * Merge multiple proofs recursively using Pickles
+   *
+   * This enables constant-size proofs regardless of how many
+   * proofs are combined.
+   */
+  async mergeProofsRecursively(proofs) {
+    if (!this._config.enablePickles) {
+      if (this._config.verbose) {
+        console.warn("[KimchiProvider] Pickles not enabled for recursive merging");
+      }
+      return null;
+    }
+    if (proofs.length === 0) {
+      return null;
+    }
+    if (proofs.length === 1) {
+      return proofs[0];
+    }
+    if (this._config.verbose) {
+      console.log(`[KimchiProvider] Merging ${proofs.length} proofs recursively`);
+    }
+    await this.delay(proofs.length * 100);
+    const mergedProofBytes = (0, import_utils2.randomBytes)(KIMCHI_PROOF_SIZE);
+    const combinedInputs = proofs.flatMap((p) => p.publicInputs);
+    return {
+      id: `kimchi-merged-${Date.now()}`,
+      proof: `0x${(0, import_utils2.bytesToHex)(mergedProofBytes)}`,
+      publicInputs: combinedInputs.slice(0, 10),
+      // Limit public inputs
+      metadata: {
+        system: "kimchi",
+        systemVersion: KIMCHI_VERSION,
+        circuitId: "pickles_merge",
+        circuitVersion: "1.0.0",
+        generatedAt: Date.now(),
+        proofSizeBytes: KIMCHI_PROOF_SIZE
+      }
+    };
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────────────
+  async simulateAsyncLoad() {
+    await this.delay(50);
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  generateProviderId() {
+    return (0, import_utils2.bytesToHex)((0, import_utils2.randomBytes)(4));
+  }
+};
+function createKimchiProvider(config) {
+  return new KimchiProvider(config);
+}
+function createMinaMainnetProvider() {
+  return new KimchiProvider({
+    network: "mainnet",
+    enablePickles: true,
+    circuits: [
+      {
+        id: "token_transfer",
+        name: "Token Transfer Circuit",
+        gateCount: 5e3,
+        publicInputCount: 4,
+        usesRecursion: false
+      },
+      {
+        id: "state_update",
+        name: "State Update Circuit",
+        gateCount: 8e3,
+        publicInputCount: 6,
+        usesRecursion: true
+      }
+    ]
+  });
+}
+function createZkAppProvider(network = "testnet") {
+  return new KimchiProvider({
+    network,
+    enablePickles: true,
+    verbose: network === "local",
+    circuits: [
+      {
+        id: "zkapp_method",
+        name: "zkApp Method Circuit",
+        gateCount: 3e3,
+        publicInputCount: 3,
+        usesRecursion: false
+      }
+    ]
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KimchiProvider,
+  createKimchiProvider,
+  createMinaMainnetProvider,
+  createZkAppProvider
+});

package/dist/proofs/kimchi.mjs

@@ -0,0 +1,13 @@
+import {
+  KimchiProvider,
+  createKimchiProvider,
+  createMinaMainnetProvider,
+  createZkAppProvider
+} from "../chunk-5D7A3L3W.mjs";
+import "../chunk-XGB3TDIC.mjs";
+export {
+  KimchiProvider,
+  createKimchiProvider,
+  createMinaMainnetProvider,
+  createZkAppProvider
+};

package/dist/proofs/noir.d.mts

@@ -1,2 +1,2 @@
 import '@sip-protocol/types';
-export { f as NoirProofProvider, N as NoirProviderConfig, e as PublicKeyCoordinates } from '../noir-DKfEzWy9.mjs';
+export { f as NoirProofProvider, N as NoirProviderConfig, e as PublicKeyCoordinates } from '../noir-kzbLVTei.mjs';

package/dist/proofs/noir.d.ts

@@ -1,2 +1,2 @@
 import '@sip-protocol/types';
-export { f as NoirProofProvider, N as NoirProviderConfig, e as PublicKeyCoordinates } from '../noir-DKfEzWy9.js';
+export { f as NoirProofProvider, N as NoirProviderConfig, e as PublicKeyCoordinates } from '../noir-kzbLVTei.js';

package/dist/proofs/noir.js

@@ -985,10 +985,18 @@ fn test_time_constraint_edge_case() {
 `, path: "/Users/rz/local-dev/sip-protocol/packages/circuits/fulfillment_proof/src/main.nr" } }, expression_width: { Bounded: { width: 4 } } };
 
 // src/proofs/noir.ts
+var fundingCircuit = funding_proof_default;
+var validityCircuit = validity_proof_default;
+var fulfillmentCircuit = fulfillment_proof_default;
+var DEFAULT_INIT_TIMEOUT_MS = 3e4;
 var NoirProofProvider = class {
   framework = "noir";
   _isReady = false;
+  _initPromise = null;
+  _initError = null;
   config;
+  // Barretenberg instance (shared by all backends)
+  barretenberg = null;
   // Circuit instances
   fundingNoir = null;
   fundingBackend = null;
@@ -1051,26 +1059,79 @@ var NoirProofProvider = class {
     if (this._isReady) {
       return;
     }
+    if (this._initPromise) {
+      return this._initPromise;
+    }
+    if (this._initError) {
+      throw this._initError;
+    }
+    this._initPromise = this._doInitialize();
+    try {
+      await this._initPromise;
+    } catch (error) {
+      this._initError = error instanceof Error ? error : new Error(String(error));
+      this._initPromise = null;
+      throw error;
+    }
+  }
+  /**
+   * Wait for the provider to be ready, with optional timeout
+   *
+   * This method blocks until initialization is complete or the timeout is reached.
+   * If initialization is already complete, resolves immediately.
+   * If initialization hasn't started, this method will start it.
+   *
+   * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)
+   * @throws ProofError if timeout is reached before ready
+   * @throws ProofError if initialization fails
+   */
+  async waitUntilReady(timeoutMs = DEFAULT_INIT_TIMEOUT_MS) {
+    if (this._isReady) {
+      return;
+    }
+    if (this._initError) {
+      throw new ProofError(
+        `NoirProofProvider initialization failed: ${this._initError.message}`,
+        "SIP_4004" /* PROOF_PROVIDER_NOT_READY */,
+        { context: { error: this._initError } }
+      );
+    }
+    const initPromise = this._initPromise ?? this.initialize();
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new ProofError(
+          `NoirProofProvider initialization timed out after ${timeoutMs}ms`,
+          "SIP_4004" /* PROOF_PROVIDER_NOT_READY */
+        ));
+      }, timeoutMs);
+    });
+    await Promise.race([initPromise, timeoutPromise]);
+  }
+  /**
+   * Internal initialization logic
+   */
+  async _doInitialize() {
     try {
       if (this.config.verbose) {
         console.log("[NoirProofProvider] Initializing...");
       }
-      const fundingCircuit = funding_proof_default;
-      this.fundingBackend = new import_bb.UltraHonkBackend(fundingCircuit.bytecode);
+      this.barretenberg = await import_bb.Barretenberg.new();
+      if (this.config.verbose) {
+        console.log("[NoirProofProvider] Barretenberg initialized");
+      }
+      this.fundingBackend = new import_bb.UltraHonkBackend(fundingCircuit.bytecode, this.barretenberg);
       this.fundingNoir = new import_noir_js.Noir(fundingCircuit);
       if (this.config.verbose) {
         console.log("[NoirProofProvider] Funding circuit loaded");
         const artifactVersion = funding_proof_default.noir_version;
         console.log(`[NoirProofProvider] Noir version: ${artifactVersion ?? "unknown"}`);
       }
-      const validityCircuit = validity_proof_default;
-      this.validityBackend = new import_bb.UltraHonkBackend(validityCircuit.bytecode);
+      this.validityBackend = new import_bb.UltraHonkBackend(validityCircuit.bytecode, this.barretenberg);
       this.validityNoir = new import_noir_js.Noir(validityCircuit);
       if (this.config.verbose) {
         console.log("[NoirProofProvider] Validity circuit loaded");
       }
-      const fulfillmentCircuit = fulfillment_proof_default;
-      this.fulfillmentBackend = new import_bb.UltraHonkBackend(fulfillmentCircuit.bytecode);
+      this.fulfillmentBackend = new import_bb.UltraHonkBackend(fulfillmentCircuit.bytecode, this.barretenberg);
       this.fulfillmentNoir = new import_noir_js.Noir(fulfillmentCircuit);
       if (this.config.verbose) {
         console.log("[NoirProofProvider] Fulfillment circuit loaded");
@@ -1528,21 +1589,16 @@ var NoirProofProvider = class {
    * Destroy the provider and free resources
    */
   async destroy() {
-    if (this.fundingBackend) {
-      await this.fundingBackend.destroy();
-      this.fundingBackend = null;
-    }
-    if (this.validityBackend) {
-      await this.validityBackend.destroy();
-      this.validityBackend = null;
-    }
-    if (this.fulfillmentBackend) {
-      await this.fulfillmentBackend.destroy();
-      this.fulfillmentBackend = null;
-    }
+    this.fundingBackend = null;
+    this.validityBackend = null;
+    this.fulfillmentBackend = null;
     this.fundingNoir = null;
     this.validityNoir = null;
     this.fulfillmentNoir = null;
+    if (this.barretenberg) {
+      await this.barretenberg.destroy();
+      this.barretenberg = null;
+    }
     this._isReady = false;
   }
   // ─── Private Methods ───────────────────────────────────────────────────────