@matterlabs/ethproofs-airbender-verifier 0.1.2 → 0.1.4

package/README.md

@@ -14,8 +14,9 @@ yarn add @matterlabs/ethproofs-airbender-verifier
 ```ts
 import { createVerifier } from "@matterlabs/ethproofs-airbender-verifier";
 
-// Create the verifier object
-const verifier = await createVerifier();
+const verifier = await createVerifier({
+  verificationKey
+});
 
 // Deserialize the submitted proof (without `base64` encoding; e.g. format that is used on EthProofs to store proofs)
 const handle = verifier.deserializeProofBytes(proofBytes);
@@ -27,9 +28,29 @@ if (!result.success) {
 }
 ```
 
-## Custom setup/layout
+`createVerifier()` requires explicit verification keys.
+`verifyProof(handle)` requires the proof security level to match the supplied
+verification key. Legacy proof payloads do not carry that metadata, so they are
+verified as 80-bit proofs.
+
+## Verification keys
+
+Use single-file verification keys for new integrations:
+
+```ts
+import { createVerifier } from "proof-verifier-js";
+
+const verifier = await createVerifier({
+  verificationKey
+});
+```
+
+The key must match the proof’s circuit version and security level.
+
+## Legacy setup/layout
 
-Use this when you need to verify proofs against a non-default circuit version.
+Use this only when you need to verify with existing 80-bit split setup/layout
+artifacts.
 
 ```ts
 import { createVerifier } from "proof-verifier-js";
@@ -40,8 +61,8 @@ const verifier = await createVerifier({
 });
 ```
 
-`setupBin` is the verifier setup artifact and `layoutBin` is the circuit layout metadata.
-Both must match the proof’s circuit version.
+The legacy `setupBin` / `layoutBin` pair initializes 80-bit verification only.
+Use the single-file VK format for 100-bit verification.
 
 ## License
 

package/dist/index.d.ts

@@ -13,18 +13,27 @@ type VerificationResult = {
     /** Error details reported by the verifier, or null on success. */
     error: string | null;
 };
+type VerificationKey = Uint8Array;
+type SingleFileVerifierOptions = {
+    /** Single-file verification key. Its embedded security level must match verified proofs. */
+    verificationKey: VerificationKey;
+    setupBin?: never;
+    layoutBin?: never;
+};
+type LegacySingleVerifierOptions = {
+    /** Legacy 80-bit setup data for existing split-key deployments. */
+    setupBin: Uint8Array;
+    /** Legacy 80-bit layout data for existing split-key deployments. */
+    layoutBin: Uint8Array;
+    verificationKey?: never;
+};
 /**
- * Optional verifier configuration for custom setup and layout for circuits.
+ * Verifier configuration with explicit verification keys.
  *
  * These correspond to the precomputed verifier artifacts used by the
  * Ethereum STF ZK proof system and must match the proof's circuit version.
  */
-type VerifierOptions = {
-    /** Binary setup data that defines the verifier's cryptographic setup. */
-    setupBin: Uint8Array;
-    /** Binary layout data that defines circuit layout metadata. */
-    layoutBin: Uint8Array;
-};
+type VerifierOptions = SingleFileVerifierOptions | LegacySingleVerifierOptions;
 /**
  * Verifier API for Ethereum STF ZK proofs submitted to EthProofs.
  */
@@ -47,9 +56,9 @@ type Verifier = {
 /**
  * Initializes the WASM dependency and creates a Verifier instance.
  *
- * @param options Optional verifier configuration for custom setup and layout for circuits.
+ * @param options Verifier configuration with an explicit key or legacy artifacts.
  * @returns A Promise that resolves to a Verifier instance.
  */
-declare function createVerifier(options?: VerifierOptions): Promise<Verifier>;
+declare function createVerifier(options: VerifierOptions): Promise<Verifier>;
 
-export { type ProofHandle, type VerificationResult, type Verifier, type VerifierOptions, createVerifier };
+export { type ProofHandle, type VerificationKey, type VerificationResult, type Verifier, type VerifierOptions, createVerifier };

package/dist/index.js

@@ -1,9 +1,7 @@
 // src/index.ts
 import init, {
   deserialize_proof_bytes,
-  init_defaults,
-  init_with,
-  verify_proof
+  WasmVerifier
 } from "../wasm/pkg/proof_verifier_wasm";
 var initPromise = null;
 function ensureInit() {
@@ -12,26 +10,43 @@ function ensureInit() {
   }
   return initPromise;
 }
+function resultFromWasm(result) {
+  const typed = result;
+  return {
+    success: typed.success,
+    error: typed.error()
+  };
+}
 var VerifierImpl = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
   deserializeProofBytes(proofBytes) {
     return deserialize_proof_bytes(proofBytes);
   }
   verifyProof(handle) {
-    const result = verify_proof(handle);
-    return {
-      success: result.success,
-      error: result.error()
-    };
+    return resultFromWasm(this.inner.verifyProof(handle));
   }
 };
+function createWasmVerifier(options) {
+  if (options.verificationKey) {
+    return WasmVerifier.fromKey(options.verificationKey);
+  }
+  if (options.setupBin && options.layoutBin) {
+    return WasmVerifier.fromLegacyKey(options.setupBin, options.layoutBin);
+  }
+  throw new Error(
+    "verifier options must include a verification key or legacy setup/layout artifacts"
+  );
+}
 async function createVerifier(options) {
   await ensureInit();
-  if (options) {
-    init_with(options.setupBin, options.layoutBin);
-  } else {
-    init_defaults();
+  if (!options) {
+    throw new Error(
+      "verifier options must include a verification key or legacy setup/layout artifacts"
+    );
   }
-  return new VerifierImpl();
+  return new VerifierImpl(createWasmVerifier(options));
 }
 export {
   createVerifier

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterlabs/ethproofs-airbender-verifier",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Airbender ZK Proof Verifier for EthProofs",
   "license": "(MIT OR Apache-2.0)",
   "repository": {

package/wasm/pkg/package.json

@@ -1,7 +1,7 @@
 {
   "name": "proof_verifier_wasm",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "MIT OR Apache-2.0",
   "files": [
     "proof_verifier_wasm_bg.wasm",

package/wasm/pkg/proof_verifier_wasm.d.ts

@@ -7,6 +7,11 @@ export class ProofHandle {
     [Symbol.dispose](): void;
 }
 
+export enum SecurityLevel {
+    Security80 = 0,
+    Security100 = 1,
+}
+
 export class VerifyResult {
     private constructor();
     free(): void;
@@ -15,13 +20,16 @@ export class VerifyResult {
     readonly success: boolean;
 }
 
-export function deserialize_proof_bytes(proof_bytes: Uint8Array): ProofHandle;
-
-export function init_defaults(): void;
-
-export function init_with(setup_bin: Uint8Array, layout_bin: Uint8Array): void;
+export class WasmVerifier {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static fromKey(vk_bin: Uint8Array): WasmVerifier;
+    static fromLegacyKey(setup_bin: Uint8Array, layout_bin: Uint8Array): WasmVerifier;
+    verifyProof(handle: ProofHandle): VerifyResult;
+}
 
-export function verify_proof(handle: ProofHandle): VerifyResult;
+export function deserialize_proof_bytes(proof_bytes: Uint8Array): ProofHandle;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
@@ -29,12 +37,13 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_proofhandle_free: (a: number, b: number) => void;
     readonly __wbg_verifyresult_free: (a: number, b: number) => void;
+    readonly __wbg_wasmverifier_free: (a: number, b: number) => void;
     readonly deserialize_proof_bytes: (a: number, b: number) => [number, number, number];
-    readonly init_defaults: () => [number, number];
-    readonly init_with: (a: number, b: number, c: number, d: number) => [number, number];
-    readonly verify_proof: (a: number) => number;
     readonly verifyresult_error: (a: number) => any;
     readonly verifyresult_success: (a: number) => number;
+    readonly wasmverifier_fromKey: (a: number, b: number) => [number, number, number];
+    readonly wasmverifier_fromLegacyKey: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly wasmverifier_verifyProof: (a: number, b: number) => number;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

package/wasm/pkg/proof_verifier_wasm.js

@@ -21,6 +21,14 @@ export class ProofHandle {
 }
 if (Symbol.dispose) ProofHandle.prototype[Symbol.dispose] = ProofHandle.prototype.free;
 
+/**
+ * @enum {0 | 1}
+ */
+export const SecurityLevel = Object.freeze({
+    Security80: 0, "0": "Security80",
+    Security100: 1, "1": "Security100",
+});
+
 export class VerifyResult {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -56,6 +64,65 @@ export class VerifyResult {
 }
 if (Symbol.dispose) VerifyResult.prototype[Symbol.dispose] = VerifyResult.prototype.free;
 
+export class WasmVerifier {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmVerifier.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmVerifierFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmVerifierFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmverifier_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} vk_bin
+     * @returns {WasmVerifier}
+     */
+    static fromKey(vk_bin) {
+        const ptr0 = passArray8ToWasm0(vk_bin, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmverifier_fromKey(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmVerifier.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} setup_bin
+     * @param {Uint8Array} layout_bin
+     * @returns {WasmVerifier}
+     */
+    static fromLegacyKey(setup_bin, layout_bin) {
+        const ptr0 = passArray8ToWasm0(setup_bin, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(layout_bin, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmverifier_fromLegacyKey(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmVerifier.__wrap(ret[0]);
+    }
+    /**
+     * @param {ProofHandle} handle
+     * @returns {VerifyResult}
+     */
+    verifyProof(handle) {
+        _assertClass(handle, ProofHandle);
+        const ret = wasm.wasmverifier_verifyProof(this.__wbg_ptr, handle.__wbg_ptr);
+        return VerifyResult.__wrap(ret);
+    }
+}
+if (Symbol.dispose) WasmVerifier.prototype[Symbol.dispose] = WasmVerifier.prototype.free;
+
 /**
  * @param {Uint8Array} proof_bytes
  * @returns {ProofHandle}
@@ -70,38 +137,6 @@ export function deserialize_proof_bytes(proof_bytes) {
     return ProofHandle.__wrap(ret[0]);
 }
 
-export function init_defaults() {
-    const ret = wasm.init_defaults();
-    if (ret[1]) {
-        throw takeFromExternrefTable0(ret[0]);
-    }
-}
-
-/**
- * @param {Uint8Array} setup_bin
- * @param {Uint8Array} layout_bin
- */
-export function init_with(setup_bin, layout_bin) {
-    const ptr0 = passArray8ToWasm0(setup_bin, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(layout_bin, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.init_with(ptr0, len0, ptr1, len1);
-    if (ret[1]) {
-        throw takeFromExternrefTable0(ret[0]);
-    }
-}
-
-/**
- * @param {ProofHandle} handle
- * @returns {VerifyResult}
- */
-export function verify_proof(handle) {
-    _assertClass(handle, ProofHandle);
-    const ret = wasm.verify_proof(handle.__wbg_ptr);
-    return VerifyResult.__wrap(ret);
-}
-
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -157,6 +192,9 @@ const ProofHandleFinalization = (typeof FinalizationRegistry === 'undefined')
 const VerifyResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_verifyresult_free(ptr >>> 0, 1));
+const WasmVerifierFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmverifier_free(ptr >>> 0, 1));
 
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {

package/wasm/pkg/proof_verifier_wasm_bg.wasm.d.ts

@@ -3,12 +3,13 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_proofhandle_free: (a: number, b: number) => void;
 export const __wbg_verifyresult_free: (a: number, b: number) => void;
+export const __wbg_wasmverifier_free: (a: number, b: number) => void;
 export const deserialize_proof_bytes: (a: number, b: number) => [number, number, number];
-export const init_defaults: () => [number, number];
-export const init_with: (a: number, b: number, c: number, d: number) => [number, number];
-export const verify_proof: (a: number) => number;
 export const verifyresult_error: (a: number) => any;
 export const verifyresult_success: (a: number) => number;
+export const wasmverifier_fromKey: (a: number, b: number) => [number, number, number];
+export const wasmverifier_fromLegacyKey: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const wasmverifier_verifyProof: (a: number, b: number) => number;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;