@ethproofs/airbender-wasm-stark-verifier 0.1.2 → 0.3.0

package/README.md

@@ -1,85 +1,66 @@
-# Airbender Wasm STARK Verifier
+# Airbender WASM STARK Verifier
 
-WebAssembly bindings for the Airbender verifier.
+A wrapper around [@matterlabs/ethproofs-airbender-verifier](https://www.npmjs.com/package/@matterlabs/ethproofs-airbender-verifier) providing a simple API for STARK proof verification.
 
-## Overview
-
-This module builds the `verify_proof` function from `ethproofs_verifier` into WebAssembly, enabling STARK proof verification to run directly in both web browsers and Node.js environments.
-
-## Usage
-
-### Installation
+## Installation
 
 ```bash
 npm install @ethproofs/airbender-wasm-stark-verifier
 ```
 
-### React Integration
+## Usage
 
-```typescript
-import init, {
-  main,
-  verify_stark,
-} from '@ethproofs/airbender-wasm-stark-verifier';
+### Simple API
 
-await init(); // Initialize WASM (if needed)
-main(); // Initialize panic hook
+```typescript
+import { verify_stark } from '@ethproofs/airbender-wasm-stark-verifier';
 
-// Verify a proof
-const isValid = verify_stark(proofBytes);
+// Verify a proof - returns true if valid
+const isValid = await verify_stark(proofBytes);
 ```
 
-### Node.js Usage
+### With Error Details
 
-```javascript
-const {
-  main,
-  verify_stark,
-} = require('@ethproofs/airbender-wasm-stark-verifier');
-
-// The Node.js version initializes automatically
+```typescript
+import { verify_stark_with_result } from '@ethproofs/airbender-wasm-stark-verifier';
 
-main(); // Initialize panic hook
-const result = verify_stark(proofBytes);
+const result = await verify_stark_with_result(proofBytes);
+if (!result.success) {
+  console.error('Verification failed:', result.error);
+}
 ```
 
-## Testing
+### Advanced Usage
 
-### Installation
+For more control, use the full verifier API:
 
-```bash
-npm install
-```
+```typescript
+import { createVerifier } from '@ethproofs/airbender-wasm-stark-verifier';
 
-### Building
+// Create verifier with default options
+const verifier = await createVerifier();
 
-```bash
-# Build for all targets
-npm run build:all
-```
+// Or with custom setup/layout for non-default circuit versions
+const verifier = await createVerifier({
+  setupBin: setupBytes,
+  layoutBin: layoutBytes,
+});
 
-### Node.js Example
-
-```bash
-npm run test:node
+// Deserialize and verify
+const handle = verifier.deserializeProofBytes(proofBytes);
+const result = verifier.verifyProof(handle);
 ```
 
-This runs the Node.js example that loads proof and verification key files from the filesystem and verifies them.
+## API Reference
 
-### Browser Example
+- `verify_stark(proofBytes: Uint8Array): Promise<boolean>` - simple verification that returns `true` if the proof is valid.
 
-```bash
-npm run test
-```
+- `verify_stark_with_result(proofBytes: Uint8Array): Promise<VerificationResult>` - returns an object with `success` boolean and optional `error` string.
 
-This starts a local HTTP server at `http://localhost:8080` with a browser example that demonstrates:
+- `createVerifier(options?: VerifierOptions): Promise<Verifier>` - creates a verifier instance for advanced usage. Optionally accepts custom `setupBin` and `layoutBin` for non-default circuit versions.
 
-- Loading the WASM module in a browser environment
-- File upload interface for proof and verification key files
-- Interactive STARK proof verification
-- Performance metrics and detailed logging
-- Error handling and user feedback
+- `resetVerifier(): void` - resets the cached verifier instance used by the simple API.
 
-The browser example provides a complete UI for testing the WASM verifier with drag-and-drop file selection and real-time verification results.
+## License
 
-**Note:** The browser example requires files to be served over HTTP due to WASM CORS restrictions. The included server script handles this automatically.
+MIT

package/dist/index.cjs

@@ -0,0 +1,369 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createVerifier: () => createVerifier,
+  resetVerifier: () => resetVerifier,
+  verify_stark: () => verify_stark,
+  verify_stark_with_result: () => verify_stark_with_result
+});
+module.exports = __toCommonJS(index_exports);
+
+// node_modules/@matterlabs/ethproofs-airbender-verifier/wasm/pkg/proof_verifier_wasm.js
+var import_meta = {};
+var wasm;
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var ProofHandleFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_proofhandle_free(ptr >>> 0, 1));
+var VerifyResultFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_verifyresult_free(ptr >>> 0, 1));
+var ProofHandle = class _ProofHandle {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_ProofHandle.prototype);
+    obj.__wbg_ptr = ptr;
+    ProofHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    ProofHandleFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_proofhandle_free(ptr, 0);
+  }
+};
+if (Symbol.dispose) ProofHandle.prototype[Symbol.dispose] = ProofHandle.prototype.free;
+var VerifyResult = class _VerifyResult {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_VerifyResult.prototype);
+    obj.__wbg_ptr = ptr;
+    VerifyResultFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    VerifyResultFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_verifyresult_free(ptr, 0);
+  }
+  /**
+   * @returns {any | undefined}
+   */
+  error() {
+    const ret = wasm.verifyresult_error(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @returns {boolean}
+   */
+  get success() {
+    const ret = wasm.verifyresult_success(this.__wbg_ptr);
+    return ret !== 0;
+  }
+};
+if (Symbol.dispose) VerifyResult.prototype[Symbol.dispose] = VerifyResult.prototype.free;
+function deserialize_proof_bytes(proof_bytes) {
+  const ptr0 = passArray8ToWasm0(proof_bytes, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.deserialize_proof_bytes(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return ProofHandle.__wrap(ret[0]);
+}
+function init_defaults() {
+  const ret = wasm.init_defaults();
+  if (ret[1]) {
+    throw takeFromExternrefTable0(ret[0]);
+  }
+}
+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]);
+  }
+}
+function verify_proof(handle) {
+  _assertClass(handle, ProofHandle);
+  const ret = wasm.verify_proof(handle.__wbg_ptr);
+  return VerifyResult.__wrap(ret);
+}
+var EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set(["basic", "cors", "default"]);
+async function __wbg_load(module2, imports) {
+  if (typeof Response === "function" && module2 instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module2, imports);
+      } catch (e) {
+        const validResponse = module2.ok && EXPECTED_RESPONSE_TYPES.has(module2.type);
+        if (validResponse && module2.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module2.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module2, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module: module2 };
+    } else {
+      return instance;
+    }
+  }
+}
+function __wbg_get_imports() {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+      deferred0_0 = arg0;
+      deferred0_1 = arg1;
+      console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+      wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+  };
+  imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+    const ret = new Error();
+    return ret;
+  };
+  imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+    const ret = arg1.stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, void 0);
+    table.set(offset + 0, void 0);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+  };
+  return imports;
+}
+function __wbg_finalize_init(instance, module2) {
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module2;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module_or_path !== "undefined") {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (typeof module_or_path === "undefined") {
+    module_or_path = new URL("proof_verifier_wasm_bg.wasm", import_meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+var proof_verifier_wasm_default = __wbg_init;
+
+// node_modules/@matterlabs/ethproofs-airbender-verifier/dist/index.js
+var initPromise = null;
+function ensureInit() {
+  if (!initPromise) {
+    initPromise = proof_verifier_wasm_default();
+  }
+  return initPromise;
+}
+var VerifierImpl = class {
+  deserializeProofBytes(proofBytes) {
+    return deserialize_proof_bytes(proofBytes);
+  }
+  verifyProof(handle) {
+    const result = verify_proof(handle);
+    return {
+      success: result.success,
+      error: result.error()
+    };
+  }
+};
+async function createVerifier(options) {
+  await ensureInit();
+  if (options) {
+    init_with(options.setupBin, options.layoutBin);
+  } else {
+    init_defaults();
+  }
+  return new VerifierImpl();
+}
+
+// src/index.ts
+var cachedVerifier = null;
+async function getVerifier() {
+  if (!cachedVerifier) {
+    cachedVerifier = await createVerifier();
+  }
+  return cachedVerifier;
+}
+async function verify_stark(proofBytes) {
+  const verifier = await getVerifier();
+  const handle = verifier.deserializeProofBytes(proofBytes);
+  const result = verifier.verifyProof(handle);
+  return result.success;
+}
+async function verify_stark_with_result(proofBytes) {
+  const verifier = await getVerifier();
+  const handle = verifier.deserializeProofBytes(proofBytes);
+  return verifier.verifyProof(handle);
+}
+function resetVerifier() {
+  cachedVerifier = null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createVerifier,
+  resetVerifier,
+  verify_stark,
+  verify_stark_with_result
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../node_modules/@matterlabs/ethproofs-airbender-verifier/wasm/pkg/proof_verifier_wasm.js","../node_modules/@matterlabs/ethproofs-airbender-verifier/dist/index.js"],"sourcesContent":["import {\n  createVerifier,\n  type Verifier,\n  type VerifierOptions,\n  type VerificationResult,\n  type ProofHandle,\n} from \"@matterlabs/ethproofs-airbender-verifier\";\n\n// Re-export all types and the createVerifier function for advanced usage\nexport {\n  createVerifier,\n  type Verifier,\n  type VerifierOptions,\n  type VerificationResult,\n  type ProofHandle,\n};\n\n// Cached verifier instance for the simple API\nlet cachedVerifier: Verifier | null = null;\n\n/**\n * Gets or creates a verifier instance with default options.\n * The verifier is cached for subsequent calls.\n */\nasync function getVerifier(): Promise<Verifier> {\n  if (!cachedVerifier) {\n    cachedVerifier = await createVerifier();\n  }\n  return cachedVerifier;\n}\n\n/**\n * Simple verification API that takes proof bytes and returns a boolean.\n *\n * This is a convenience wrapper around the full verifier API.\n * For more control, use `createVerifier()` directly.\n *\n * @param proofBytes - The raw proof bytes to verify\n * @returns Promise<boolean> - true if the proof is valid, false otherwise\n */\nexport async function verify_stark(proofBytes: Uint8Array): Promise<boolean> {\n  const verifier = await getVerifier();\n  const handle = verifier.deserializeProofBytes(proofBytes);\n  const result = verifier.verifyProof(handle);\n  return result.success;\n}\n\n/**\n * Verification API that returns the full result including error details.\n *\n * @param proofBytes - The raw proof bytes to verify\n * @returns Promise<VerificationResult> - Object with success boolean and optional error string\n */\nexport async function verify_stark_with_result(\n  proofBytes: Uint8Array\n): Promise<VerificationResult> {\n  const verifier = await getVerifier();\n  const handle = verifier.deserializeProofBytes(proofBytes);\n  return verifier.verifyProof(handle);\n}\n\n/**\n * Resets the cached verifier instance.\n * Call this if you need to reinitialize with different options.\n */\nexport function resetVerifier(): void {\n  cachedVerifier = null;\n}\n","let wasm;\n\nfunction _assertClass(instance, klass) {\n    if (!(instance instanceof klass)) {\n        throw new Error(`expected instance of ${klass.name}`);\n    }\n}\n\nlet cachedDataViewMemory0 = null;\nfunction getDataViewMemory0() {\n    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {\n        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);\n    }\n    return cachedDataViewMemory0;\n}\n\nfunction getStringFromWasm0(ptr, len) {\n    ptr = ptr >>> 0;\n    return decodeText(ptr, len);\n}\n\nlet cachedUint8ArrayMemory0 = null;\nfunction getUint8ArrayMemory0() {\n    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {\n        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);\n    }\n    return cachedUint8ArrayMemory0;\n}\n\nfunction passArray8ToWasm0(arg, malloc) {\n    const ptr = malloc(arg.length * 1, 1) >>> 0;\n    getUint8ArrayMemory0().set(arg, ptr / 1);\n    WASM_VECTOR_LEN = arg.length;\n    return ptr;\n}\n\nfunction passStringToWasm0(arg, malloc, realloc) {\n    if (realloc === undefined) {\n        const buf = cachedTextEncoder.encode(arg);\n        const ptr = malloc(buf.length, 1) >>> 0;\n        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);\n        WASM_VECTOR_LEN = buf.length;\n        return ptr;\n    }\n\n    let len = arg.length;\n    let ptr = malloc(len, 1) >>> 0;\n\n    const mem = getUint8ArrayMemory0();\n\n    let offset = 0;\n\n    for (; offset < len; offset++) {\n        const code = arg.charCodeAt(offset);\n        if (code > 0x7F) break;\n        mem[ptr + offset] = code;\n    }\n    if (offset !== len) {\n        if (offset !== 0) {\n            arg = arg.slice(offset);\n        }\n        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;\n        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);\n        const ret = cachedTextEncoder.encodeInto(arg, view);\n\n        offset += ret.written;\n        ptr = realloc(ptr, len, offset, 1) >>> 0;\n    }\n\n    WASM_VECTOR_LEN = offset;\n    return ptr;\n}\n\nfunction takeFromExternrefTable0(idx) {\n    const value = wasm.__wbindgen_externrefs.get(idx);\n    wasm.__externref_table_dealloc(idx);\n    return value;\n}\n\nlet cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });\ncachedTextDecoder.decode();\nconst MAX_SAFARI_DECODE_BYTES = 2146435072;\nlet numBytesDecoded = 0;\nfunction decodeText(ptr, len) {\n    numBytesDecoded += len;\n    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {\n        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });\n        cachedTextDecoder.decode();\n        numBytesDecoded = len;\n    }\n    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));\n}\n\nconst cachedTextEncoder = new TextEncoder();\n\nif (!('encodeInto' in cachedTextEncoder)) {\n    cachedTextEncoder.encodeInto = function (arg, view) {\n        const buf = cachedTextEncoder.encode(arg);\n        view.set(buf);\n        return {\n            read: arg.length,\n            written: buf.length\n        };\n    }\n}\n\nlet WASM_VECTOR_LEN = 0;\n\nconst ProofHandleFinalization = (typeof FinalizationRegistry === 'undefined')\n    ? { register: () => {}, unregister: () => {} }\n    : new FinalizationRegistry(ptr => wasm.__wbg_proofhandle_free(ptr >>> 0, 1));\n\nconst VerifyResultFinalization = (typeof FinalizationRegistry === 'undefined')\n    ? { register: () => {}, unregister: () => {} }\n    : new FinalizationRegistry(ptr => wasm.__wbg_verifyresult_free(ptr >>> 0, 1));\n\nexport class ProofHandle {\n    static __wrap(ptr) {\n        ptr = ptr >>> 0;\n        const obj = Object.create(ProofHandle.prototype);\n        obj.__wbg_ptr = ptr;\n        ProofHandleFinalization.register(obj, obj.__wbg_ptr, obj);\n        return obj;\n    }\n    __destroy_into_raw() {\n        const ptr = this.__wbg_ptr;\n        this.__wbg_ptr = 0;\n        ProofHandleFinalization.unregister(this);\n        return ptr;\n    }\n    free() {\n        const ptr = this.__destroy_into_raw();\n        wasm.__wbg_proofhandle_free(ptr, 0);\n    }\n}\nif (Symbol.dispose) ProofHandle.prototype[Symbol.dispose] = ProofHandle.prototype.free;\n\nexport class VerifyResult {\n    static __wrap(ptr) {\n        ptr = ptr >>> 0;\n        const obj = Object.create(VerifyResult.prototype);\n        obj.__wbg_ptr = ptr;\n        VerifyResultFinalization.register(obj, obj.__wbg_ptr, obj);\n        return obj;\n    }\n    __destroy_into_raw() {\n        const ptr = this.__wbg_ptr;\n        this.__wbg_ptr = 0;\n        VerifyResultFinalization.unregister(this);\n        return ptr;\n    }\n    free() {\n        const ptr = this.__destroy_into_raw();\n        wasm.__wbg_verifyresult_free(ptr, 0);\n    }\n    /**\n     * @returns {any | undefined}\n     */\n    error() {\n        const ret = wasm.verifyresult_error(this.__wbg_ptr);\n        return ret;\n    }\n    /**\n     * @returns {boolean}\n     */\n    get success() {\n        const ret = wasm.verifyresult_success(this.__wbg_ptr);\n        return ret !== 0;\n    }\n}\nif (Symbol.dispose) VerifyResult.prototype[Symbol.dispose] = VerifyResult.prototype.free;\n\n/**\n * @param {Uint8Array} proof_bytes\n * @returns {ProofHandle}\n */\nexport function deserialize_proof_bytes(proof_bytes) {\n    const ptr0 = passArray8ToWasm0(proof_bytes, wasm.__wbindgen_malloc);\n    const len0 = WASM_VECTOR_LEN;\n    const ret = wasm.deserialize_proof_bytes(ptr0, len0);\n    if (ret[2]) {\n        throw takeFromExternrefTable0(ret[1]);\n    }\n    return ProofHandle.__wrap(ret[0]);\n}\n\nexport function init_defaults() {\n    const ret = wasm.init_defaults();\n    if (ret[1]) {\n        throw takeFromExternrefTable0(ret[0]);\n    }\n}\n\n/**\n * @param {Uint8Array} setup_bin\n * @param {Uint8Array} layout_bin\n */\nexport function init_with(setup_bin, layout_bin) {\n    const ptr0 = passArray8ToWasm0(setup_bin, wasm.__wbindgen_malloc);\n    const len0 = WASM_VECTOR_LEN;\n    const ptr1 = passArray8ToWasm0(layout_bin, wasm.__wbindgen_malloc);\n    const len1 = WASM_VECTOR_LEN;\n    const ret = wasm.init_with(ptr0, len0, ptr1, len1);\n    if (ret[1]) {\n        throw takeFromExternrefTable0(ret[0]);\n    }\n}\n\n/**\n * @param {ProofHandle} handle\n * @returns {VerifyResult}\n */\nexport function verify_proof(handle) {\n    _assertClass(handle, ProofHandle);\n    const ret = wasm.verify_proof(handle.__wbg_ptr);\n    return VerifyResult.__wrap(ret);\n}\n\nconst EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);\n\nasync function __wbg_load(module, imports) {\n    if (typeof Response === 'function' && module instanceof Response) {\n        if (typeof WebAssembly.instantiateStreaming === 'function') {\n            try {\n                return await WebAssembly.instantiateStreaming(module, imports);\n            } catch (e) {\n                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);\n\n                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {\n                    console.warn(\"`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n\", e);\n\n                } else {\n                    throw e;\n                }\n            }\n        }\n\n        const bytes = await module.arrayBuffer();\n        return await WebAssembly.instantiate(bytes, imports);\n    } else {\n        const instance = await WebAssembly.instantiate(module, imports);\n\n        if (instance instanceof WebAssembly.Instance) {\n            return { instance, module };\n        } else {\n            return instance;\n        }\n    }\n}\n\nfunction __wbg_get_imports() {\n    const imports = {};\n    imports.wbg = {};\n    imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {\n        throw new Error(getStringFromWasm0(arg0, arg1));\n    };\n    imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {\n        let deferred0_0;\n        let deferred0_1;\n        try {\n            deferred0_0 = arg0;\n            deferred0_1 = arg1;\n            console.error(getStringFromWasm0(arg0, arg1));\n        } finally {\n            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);\n        }\n    };\n    imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {\n        const ret = new Error();\n        return ret;\n    };\n    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {\n        const ret = arg1.stack;\n        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);\n        const len1 = WASM_VECTOR_LEN;\n        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);\n        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);\n    };\n    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {\n        // Cast intrinsic for `Ref(String) -> Externref`.\n        const ret = getStringFromWasm0(arg0, arg1);\n        return ret;\n    };\n    imports.wbg.__wbindgen_init_externref_table = function() {\n        const table = wasm.__wbindgen_externrefs;\n        const offset = table.grow(4);\n        table.set(0, undefined);\n        table.set(offset + 0, undefined);\n        table.set(offset + 1, null);\n        table.set(offset + 2, true);\n        table.set(offset + 3, false);\n    };\n\n    return imports;\n}\n\nfunction __wbg_finalize_init(instance, module) {\n    wasm = instance.exports;\n    __wbg_init.__wbindgen_wasm_module = module;\n    cachedDataViewMemory0 = null;\n    cachedUint8ArrayMemory0 = null;\n\n\n    wasm.__wbindgen_start();\n    return wasm;\n}\n\nfunction initSync(module) {\n    if (wasm !== undefined) return wasm;\n\n\n    if (typeof module !== 'undefined') {\n        if (Object.getPrototypeOf(module) === Object.prototype) {\n            ({module} = module)\n        } else {\n            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')\n        }\n    }\n\n    const imports = __wbg_get_imports();\n    if (!(module instanceof WebAssembly.Module)) {\n        module = new WebAssembly.Module(module);\n    }\n    const instance = new WebAssembly.Instance(module, imports);\n    return __wbg_finalize_init(instance, module);\n}\n\nasync function __wbg_init(module_or_path) {\n    if (wasm !== undefined) return wasm;\n\n\n    if (typeof module_or_path !== 'undefined') {\n        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {\n            ({module_or_path} = module_or_path)\n        } else {\n            console.warn('using deprecated parameters for the initialization function; pass a single object instead')\n        }\n    }\n\n    if (typeof module_or_path === 'undefined') {\n        module_or_path = new URL('proof_verifier_wasm_bg.wasm', import.meta.url);\n    }\n    const imports = __wbg_get_imports();\n\n    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {\n        module_or_path = fetch(module_or_path);\n    }\n\n    const { instance, module } = await __wbg_load(await module_or_path, imports);\n\n    return __wbg_finalize_init(instance, module);\n}\n\nexport { initSync };\nexport default __wbg_init;\n","// src/index.ts\nimport init, {\n  deserialize_proof_bytes,\n  init_defaults,\n  init_with,\n  verify_proof\n} from \"../wasm/pkg/proof_verifier_wasm\";\nvar initPromise = null;\nfunction ensureInit() {\n  if (!initPromise) {\n    initPromise = init();\n  }\n  return initPromise;\n}\nvar VerifierImpl = class {\n  deserializeProofBytes(proofBytes) {\n    return deserialize_proof_bytes(proofBytes);\n  }\n  verifyProof(handle) {\n    const result = verify_proof(handle);\n    return {\n      success: result.success,\n      error: result.error()\n    };\n  }\n};\nasync function createVerifier(options) {\n  await ensureInit();\n  if (options) {\n    init_with(options.setupBin, options.layoutBin);\n  } else {\n    init_defaults();\n  }\n  return new VerifierImpl();\n}\nexport {\n  createVerifier\n};\n"],"mappings":"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","names":["ptr","module","module"]}

package/dist/index.d.cts

@@ -0,0 +1,27 @@
+import { VerificationResult } from '@matterlabs/ethproofs-airbender-verifier';
+export { ProofHandle, VerificationResult, Verifier, VerifierOptions, createVerifier } from '@matterlabs/ethproofs-airbender-verifier';
+
+/**
+ * Simple verification API that takes proof bytes and returns a boolean.
+ *
+ * This is a convenience wrapper around the full verifier API.
+ * For more control, use `createVerifier()` directly.
+ *
+ * @param proofBytes - The raw proof bytes to verify
+ * @returns Promise<boolean> - true if the proof is valid, false otherwise
+ */
+declare function verify_stark(proofBytes: Uint8Array): Promise<boolean>;
+/**
+ * Verification API that returns the full result including error details.
+ *
+ * @param proofBytes - The raw proof bytes to verify
+ * @returns Promise<VerificationResult> - Object with success boolean and optional error string
+ */
+declare function verify_stark_with_result(proofBytes: Uint8Array): Promise<VerificationResult>;
+/**
+ * Resets the cached verifier instance.
+ * Call this if you need to reinitialize with different options.
+ */
+declare function resetVerifier(): void;
+
+export { resetVerifier, verify_stark, verify_stark_with_result };

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { VerificationResult } from '@matterlabs/ethproofs-airbender-verifier';
+export { ProofHandle, VerificationResult, Verifier, VerifierOptions, createVerifier } from '@matterlabs/ethproofs-airbender-verifier';
+
+/**
+ * Simple verification API that takes proof bytes and returns a boolean.
+ *
+ * This is a convenience wrapper around the full verifier API.
+ * For more control, use `createVerifier()` directly.
+ *
+ * @param proofBytes - The raw proof bytes to verify
+ * @returns Promise<boolean> - true if the proof is valid, false otherwise
+ */
+declare function verify_stark(proofBytes: Uint8Array): Promise<boolean>;
+/**
+ * Verification API that returns the full result including error details.
+ *
+ * @param proofBytes - The raw proof bytes to verify
+ * @returns Promise<VerificationResult> - Object with success boolean and optional error string
+ */
+declare function verify_stark_with_result(proofBytes: Uint8Array): Promise<VerificationResult>;
+/**
+ * Resets the cached verifier instance.
+ * Call this if you need to reinitialize with different options.
+ */
+declare function resetVerifier(): void;
+
+export { resetVerifier, verify_stark, verify_stark_with_result };