@zelana/sdk 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -47,4 +47,6 @@ export { ZelanaError } from './types';
 export { shielded, ShieldedTransactionBuilder, generateShieldedKeys, shieldedKeysFromSpendingKey, createNote, noteWithRandomness, computeCommitment, computeNullifier, tryDecryptNote, } from './shielded';
 export type { Note, EncryptedNote, ShieldedKeys, ShieldedInput, ShieldedOutput, PreparedShieldedTx, ShieldedTransaction, ShieldedWitness, ScanResult, MerklePath as ShieldedMerklePath, } from './shielded';
 export { bytesToHex, hexToBytes, bytesToBase58, base58ToBytes, u64ToLeBytes, leBytesToU64, concatBytes, bytesEqual, randomBytes, } from './utils';
+export { OwnershipProver, MockOwnershipProver, mockProver, getProver, computeOwnershipWitness, } from './prover';
+export type { OwnershipWitness, OwnershipProof, DelegatedShieldedRequest, } from './prover';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAGnD,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC/C,YAAY,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD,YAAY,EAEV,OAAO,EACP,YAAY,EAGZ,MAAM,EACN,QAAQ,EACR,SAAS,EACT,WAAW,EACX,YAAY,EAGZ,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAGhB,UAAU,EACV,eAAe,EACf,UAAU,EACV,WAAW,EAGX,UAAU,EACV,WAAW,EAGX,iBAAiB,EAGjB,mBAAmB,EACnB,aAAa,EAGb,gBAAgB,EAChB,iBAAiB,EAGjB,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,eAAe,EAGf,QAAQ,GACT,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGtC,OAAO,EACL,QAAQ,EACR,0BAA0B,EAC1B,oBAAoB,EACpB,2BAA2B,EAC3B,UAAU,EACV,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,GACf,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,IAAI,EACJ,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,UAAU,EACV,UAAU,IAAI,kBAAkB,GACjC,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,UAAU,EACV,WAAW,GACZ,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAGnD,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC/C,YAAY,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD,YAAY,EAEV,OAAO,EACP,YAAY,EAGZ,MAAM,EACN,QAAQ,EACR,SAAS,EACT,WAAW,EACX,YAAY,EAGZ,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAGhB,UAAU,EACV,eAAe,EACf,UAAU,EACV,WAAW,EAGX,UAAU,EACV,WAAW,EAGX,iBAAiB,EAGjB,mBAAmB,EACnB,aAAa,EAGb,gBAAgB,EAChB,iBAAiB,EAGjB,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,eAAe,EAGf,QAAQ,GACT,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGtC,OAAO,EACL,QAAQ,EACR,0BAA0B,EAC1B,oBAAoB,EACpB,2BAA2B,EAC3B,UAAU,EACV,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,GACf,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,IAAI,EACJ,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,UAAU,EACV,UAAU,IAAI,kBAAkB,GACjC,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,UAAU,EACV,WAAW,GACZ,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,UAAU,EACV,SAAS,EACT,uBAAuB,GACxB,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,wBAAwB,GACzB,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -1,3 +1,27 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // node_modules/@noble/ed25519/index.js
 /*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
 var ed25519_CURVE = {
@@ -1783,6 +1807,187 @@ var shielded = {
   computeNullifier,
   TransactionBuilder: ShieldedTransactionBuilder
 };
+// src/prover.ts
+class OwnershipProver {
+  wasmModule = null;
+  noirCircuit = null;
+  backend = null;
+  initialized = false;
+  async init(options) {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      const wasmModule = await this.loadWasmModule(options?.wasmUrl);
+      this.wasmModule = wasmModule;
+    } catch (error) {
+      throw new Error(`Failed to load ownership-prover WASM: ${error}`);
+    }
+    if (!options?.witnessOnly) {
+      try {
+        await this.loadNoirCircuit(options?.circuitUrl);
+      } catch (error) {
+        console.warn("Noir circuit not loaded, proof generation disabled:", error);
+      }
+    }
+    this.initialized = true;
+  }
+  async loadWasmModule(wasmUrl) {
+    try {
+      const module = await import("zelana-ownership-prover");
+      await module.default();
+      return module;
+    } catch {
+      if (wasmUrl) {
+        const importFn = new Function("url", "return import(url)");
+        const module = await importFn(wasmUrl);
+        await module.default();
+        return module;
+      }
+      throw new Error("Could not load WASM module");
+    }
+  }
+  async loadNoirCircuit(circuitUrl) {
+    console.log("Noir circuit loading not yet implemented");
+    this.noirCircuit = null;
+    this.backend = null;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  canProve() {
+    return this.initialized && this.noirCircuit !== null;
+  }
+  derivePublicKey(spendingKey) {
+    this.ensureInitialized();
+    const hex = this.wasmModule.derivePublicKey(bytesToHex2(spendingKey));
+    return hexToBytes2(hex);
+  }
+  computeCommitment(ownerPk, value, blinding) {
+    this.ensureInitialized();
+    const hex = this.wasmModule.computeCommitment(bytesToHex2(ownerPk), value, bytesToHex2(blinding));
+    return hexToBytes2(hex);
+  }
+  computeNullifier(spendingKey, commitment, position) {
+    this.ensureInitialized();
+    const hex = this.wasmModule.computeNullifier(bytesToHex2(spendingKey), bytesToHex2(commitment), position);
+    return hexToBytes2(hex);
+  }
+  computeBlindedProxy(commitment, position) {
+    this.ensureInitialized();
+    const hex = this.wasmModule.computeBlindedProxy(bytesToHex2(commitment), position);
+    return hexToBytes2(hex);
+  }
+  computeWitness(spendingKey, value, blinding, position) {
+    this.ensureInitialized();
+    return this.wasmModule.generateWitness(bytesToHex2(spendingKey), value, bytesToHex2(blinding), position);
+  }
+  verifyWitness(spendingKey, value, blinding, position, expectedCommitment, expectedNullifier, expectedProxy) {
+    this.ensureInitialized();
+    return this.wasmModule.verifyWitness(bytesToHex2(spendingKey), value, bytesToHex2(blinding), position, bytesToHex2(expectedCommitment), bytesToHex2(expectedNullifier), bytesToHex2(expectedProxy));
+  }
+  async prove(spendingKey, value, blinding, position) {
+    this.ensureInitialized();
+    if (!this.canProve()) {
+      throw new Error("Noir circuit not loaded - proof generation unavailable");
+    }
+    const witness = this.computeWitness(spendingKey, value, blinding, position);
+    throw new Error("Proof generation not yet implemented");
+  }
+  async verify(proof) {
+    if (!this.canProve()) {
+      throw new Error("Noir circuit not loaded - verification unavailable");
+    }
+    throw new Error("Proof verification not yet implemented");
+  }
+  ensureInitialized() {
+    if (!this.initialized || !this.wasmModule) {
+      throw new Error("Prover not initialized - call init() first");
+    }
+  }
+}
+var globalProver = null;
+async function getProver() {
+  if (!globalProver) {
+    globalProver = new OwnershipProver;
+    await globalProver.init({ witnessOnly: true });
+  }
+  return globalProver;
+}
+async function computeOwnershipWitness(spendingKey, value, blinding, position) {
+  const prover = await getProver();
+  return prover.computeWitness(spendingKey, value, blinding, position);
+}
+
+class MockOwnershipProver extends OwnershipProver {
+  async init() {}
+  isInitialized() {
+    return true;
+  }
+  canProve() {
+    return true;
+  }
+  derivePublicKey(spendingKey) {
+    return this.mockHash("PK", spendingKey);
+  }
+  computeCommitment(ownerPk, value, blinding) {
+    const valueBytes = new Uint8Array(8);
+    new DataView(valueBytes.buffer).setBigUint64(0, value, true);
+    return this.mockHash("CM", ownerPk, valueBytes, blinding);
+  }
+  computeNullifier(spendingKey, commitment, position) {
+    const posBytes = new Uint8Array(8);
+    new DataView(posBytes.buffer).setBigUint64(0, position, true);
+    return this.mockHash("NF", spendingKey, commitment, posBytes);
+  }
+  computeBlindedProxy(commitment, position) {
+    const posBytes = new Uint8Array(8);
+    new DataView(posBytes.buffer).setBigUint64(0, position, true);
+    return this.mockHash("BP", commitment, posBytes);
+  }
+  computeWitness(spendingKey, value, blinding, position) {
+    const ownerPk = this.derivePublicKey(spendingKey);
+    const commitment = this.computeCommitment(ownerPk, value, blinding);
+    const nullifier = this.computeNullifier(spendingKey, commitment, position);
+    const blindedProxy = this.computeBlindedProxy(commitment, position);
+    return {
+      ownerPk: bytesToHex2(ownerPk),
+      commitment: bytesToHex2(commitment),
+      nullifier: bytesToHex2(nullifier),
+      blindedProxy: bytesToHex2(blindedProxy)
+    };
+  }
+  async prove(spendingKey, value, blinding, position) {
+    const witness = this.computeWitness(spendingKey, value, blinding, position);
+    const fakeProof = this.mockHash("PROOF", hexToBytes2(witness.commitment), hexToBytes2(witness.nullifier));
+    return {
+      proof: fakeProof,
+      publicInputs: {
+        commitment: hexToBytes2(witness.commitment),
+        nullifier: hexToBytes2(witness.nullifier),
+        blindedProxy: hexToBytes2(witness.blindedProxy)
+      }
+    };
+  }
+  mockHash(domain, ...inputs) {
+    const domainBytes = new TextEncoder().encode(domain);
+    const combined = new Uint8Array(domainBytes.length + inputs.reduce((acc, i) => acc + i.length, 0));
+    let offset = 0;
+    combined.set(domainBytes, offset);
+    offset += domainBytes.length;
+    for (const input of inputs) {
+      combined.set(input, offset);
+      offset += input.length;
+    }
+    const result = new Uint8Array(32);
+    for (let i = 0;i < combined.length; i++) {
+      result[i % 32] ^= combined[i];
+      result[(i + 1) % 32] ^= combined[i] << 4 | combined[i] >> 4;
+    }
+    return result;
+  }
+}
+var mockProver = new MockOwnershipProver;
 export {
   u64ToLeBytes,
   tryDecryptNote,
@@ -1790,11 +1995,14 @@ export {
   shielded,
   randomBytes2 as randomBytes,
   noteWithRandomness,
+  mockProver,
   leBytesToU64,
   hexToBytes2 as hexToBytes,
+  getProver,
   generateShieldedKeys,
   createNote,
   concatBytes2 as concatBytes,
+  computeOwnershipWitness,
   computeNullifier,
   computeCommitment,
   bytesToHex2 as bytesToHex,
@@ -1805,6 +2013,8 @@ export {
   ZelanaClient,
   ShieldedTransactionBuilder,
   PublicKey,
+  OwnershipProver,
+  MockOwnershipProver,
   Keypair,
   ApiClient
 };

package/dist/prover.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Ownership Prover - Client-Side ZK Proof Generation
+ *
+ * This module provides the client-side proving functionality for Split Proving.
+ * Users generate lightweight ownership proofs in their browser, which are then
+ * verified by the sequencer and enhanced with Merkle proofs by the Swarm.
+ *
+ * Architecture:
+ * 1. User computes witness using WASM MiMC (matches Noir circuit exactly)
+ * 2. User generates ownership proof using Noir WASM prover (~500ms)
+ * 3. Proof is sent to sequencer for verification and batching
+ * 4. Swarm generates validity proof with Merkle membership (heavy work)
+ */
+import type { Bytes32 } from './types';
+/**
+ * Witness data computed from private inputs
+ */
+export interface OwnershipWitness {
+    /** Owner's derived public key (32 bytes hex) */
+    ownerPk: string;
+    /** Note commitment (32 bytes hex) */
+    commitment: string;
+    /** Nullifier revealed when spending (32 bytes hex) */
+    nullifier: string;
+    /** Blinded proxy for swarm delegation (32 bytes hex) */
+    blindedProxy: string;
+}
+/**
+ * Complete ownership proof ready for submission
+ */
+export interface OwnershipProof {
+    /** The ZK proof bytes */
+    proof: Uint8Array;
+    /** Public inputs to the circuit */
+    publicInputs: {
+        commitment: Bytes32;
+        nullifier: Bytes32;
+        blindedProxy: Bytes32;
+    };
+}
+/**
+ * Request to submit a delegated shielded transaction
+ */
+export interface DelegatedShieldedRequest {
+    /** Ownership proof (serialized) */
+    ownershipProof: Uint8Array;
+    /** Nullifier being spent */
+    nullifier: Bytes32;
+    /** Input commitment */
+    commitment: Bytes32;
+    /** Blinded proxy for swarm lookup */
+    blindedProxy: Bytes32;
+    /** Output commitment for new note */
+    outputCommitment: Bytes32;
+    /** Encrypted note data */
+    ciphertext: Uint8Array;
+    /** Ephemeral key for decryption */
+    ephemeralKey: Bytes32;
+}
+/**
+ * OwnershipProver handles client-side ownership proof generation.
+ *
+ * This class:
+ * 1. Loads the WASM module for MiMC hash computation
+ * 2. Loads the Noir circuit for proof generation
+ * 3. Provides methods to compute witnesses and generate proofs
+ *
+ * Usage:
+ * ```typescript
+ * const prover = new OwnershipProver();
+ * await prover.init();
+ *
+ * // Compute witness from private inputs
+ * const witness = prover.computeWitness(spendingKey, value, blinding, position);
+ *
+ * // Generate proof
+ * const proof = await prover.prove(spendingKey, value, blinding, position);
+ * ```
+ */
+export declare class OwnershipProver {
+    private wasmModule;
+    private noirCircuit;
+    private backend;
+    private initialized;
+    /**
+     * Initialize the prover
+     *
+     * This loads:
+     * 1. The ownership-prover WASM module (MiMC hash)
+     * 2. The Noir circuit definition
+     * 3. The Barretenberg backend for proving
+     *
+     * @param options Configuration options
+     */
+    init(options?: {
+        /** URL to fetch WASM from (defaults to CDN) */
+        wasmUrl?: string;
+        /** URL to fetch circuit JSON from (defaults to CDN) */
+        circuitUrl?: string;
+        /** Skip Noir initialization (for witness-only mode) */
+        witnessOnly?: boolean;
+    }): Promise<void>;
+    /**
+     * Load the WASM module
+     */
+    private loadWasmModule;
+    /**
+     * Load the Noir circuit and backend
+     */
+    private loadNoirCircuit;
+    /**
+     * Check if the prover is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Check if proof generation is available
+     */
+    canProve(): boolean;
+    /**
+     * Derive public key from spending key
+     *
+     * pk = MiMC_hash3(PK_DOMAIN, spending_key, 0)
+     */
+    derivePublicKey(spendingKey: Bytes32): Bytes32;
+    /**
+     * Compute note commitment
+     *
+     * commitment = MiMC_hash3(owner_pk, value, blinding)
+     */
+    computeCommitment(ownerPk: Bytes32, value: bigint, blinding: Bytes32): Bytes32;
+    /**
+     * Compute nullifier
+     *
+     * nullifier = MiMC_hash4(NULLIFIER_DOMAIN, spending_key, commitment, position)
+     */
+    computeNullifier(spendingKey: Bytes32, commitment: Bytes32, position: bigint): Bytes32;
+    /**
+     * Compute blinded proxy for swarm delegation
+     *
+     * blinded_proxy = MiMC_hash3(DELEGATE_DOMAIN, commitment, position)
+     */
+    computeBlindedProxy(commitment: Bytes32, position: bigint): Bytes32;
+    /**
+     * Compute complete witness from private inputs
+     *
+     * This computes all public outputs that will be revealed to the sequencer.
+     */
+    computeWitness(spendingKey: Bytes32, value: bigint, blinding: Bytes32, position: bigint): OwnershipWitness;
+    /**
+     * Verify that computed witness matches expected values
+     *
+     * Useful for debugging before generating a proof.
+     */
+    verifyWitness(spendingKey: Bytes32, value: bigint, blinding: Bytes32, position: bigint, expectedCommitment: Bytes32, expectedNullifier: Bytes32, expectedProxy: Bytes32): boolean;
+    /**
+     * Generate an ownership proof
+     *
+     * This is the main entry point for proof generation. It:
+     * 1. Computes the witness using WASM MiMC
+     * 2. Generates the Noir proof using Barretenberg
+     *
+     * @param spendingKey The user's spending key (secret)
+     * @param value The note value in lamports
+     * @param blinding Random blinding factor
+     * @param position Position in the commitment tree
+     * @returns The proof and public inputs
+     */
+    prove(spendingKey: Bytes32, value: bigint, blinding: Bytes32, position: bigint): Promise<OwnershipProof>;
+    /**
+     * Verify an ownership proof locally
+     *
+     * This is for debugging/testing. In production, the sequencer verifies proofs.
+     */
+    verify(proof: OwnershipProof): Promise<boolean>;
+    private ensureInitialized;
+}
+/**
+ * Get or create the global prover instance
+ */
+export declare function getProver(): Promise<OwnershipProver>;
+/**
+ * Compute witness using the global prover
+ */
+export declare function computeOwnershipWitness(spendingKey: Bytes32, value: bigint, blinding: Bytes32, position: bigint): Promise<OwnershipWitness>;
+/**
+ * MockOwnershipProver provides a fake prover for development.
+ *
+ * It generates deterministic "proofs" using SHA-256 instead of real ZK proofs.
+ * This is useful for:
+ * - Development without WASM setup
+ * - Testing the API flow
+ * - Benchmarking non-proof overhead
+ *
+ * WARNING: This does NOT provide any cryptographic security!
+ */
+export declare class MockOwnershipProver extends OwnershipProver {
+    init(): Promise<void>;
+    isInitialized(): boolean;
+    canProve(): boolean;
+    derivePublicKey(spendingKey: Bytes32): Bytes32;
+    computeCommitment(ownerPk: Bytes32, value: bigint, blinding: Bytes32): Bytes32;
+    computeNullifier(spendingKey: Bytes32, commitment: Bytes32, position: bigint): Bytes32;
+    computeBlindedProxy(commitment: Bytes32, position: bigint): Bytes32;
+    computeWitness(spendingKey: Bytes32, value: bigint, blinding: Bytes32, position: bigint): OwnershipWitness;
+    prove(spendingKey: Bytes32, value: bigint, blinding: Bytes32, position: bigint): Promise<OwnershipProof>;
+    private mockHash;
+}
+export declare const mockProver: MockOwnershipProver;
+//# sourceMappingURL=prover.d.ts.map

package/dist/prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover.d.ts","sourceRoot":"","sources":["../src/prover.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zelana/sdk",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "TypeScript SDK for Zelana L2",
   "type": "module",
   "main": "dist/index.js",
@@ -44,4 +44,4 @@
     "type": "git",
     "url": "https://github.com/zelana/zelana"
   }
-}
+}