@ethproofs/airbender-wasm-stark-verifier 0.1.1 → 0.2.0

package/README.md

@@ -1,90 +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` function from `sp1-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
-
-```typescript
-import init, {
-  main,
-  verify_stark,
-} from '@ethproofs/airbender-wasm-stark-verifier';
-
-await init(); // Initialize WASM (if needed)
-main(); // Initialize panic hook
-
-// Verify a proof
-const isValid = verify_stark(proofBytes, vkBytes);
-```
-
-### Node.js Usage
+## Usage
 
-```javascript
-const {
-  main,
-  verify_stark,
-} = require('@ethproofs/airbender-wasm-stark-verifier');
+### Simple API
 
-// The Node.js version initializes automatically
+```typescript
+import { verify_stark } from '@ethproofs/airbender-wasm-stark-verifier';
 
-main(); // Initialize panic hook
-const result = verify_stark(proofBytes, vkBytes);
+// Verify a proof - returns true if valid
+const isValid = await verify_stark(proofBytes);
 ```
 
-## Testing
+### With Error Details
 
-### Installation
+```typescript
+import { verify_stark_with_result } from '@ethproofs/airbender-wasm-stark-verifier';
 
-```bash
-npm install
+const result = await verify_stark_with_result(proofBytes);
+if (!result.success) {
+  console.error('Verification failed:', result.error);
+}
 ```
 
-### Prerequisites
+### Advanced Usage
 
-- [sp1](https://docs.succinct.xyz/docs/sp1/getting-started/install)
-- [wasm-pack](https://github.com/drager/wasm-pack)
+For more control, use the full verifier API:
 
-### Building
+```typescript
+import { createVerifier } from '@ethproofs/airbender-wasm-stark-verifier';
 
-```bash
-# Build for all targets
-npm run build:all
-```
+// Create verifier with default options
+const verifier = await createVerifier();
 
-### Node.js Example
+// Or with custom setup/layout for non-default circuit versions
+const verifier = await createVerifier({
+  setupBin: setupBytes,
+  layoutBin: layoutBytes,
+});
 
-```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,58 @@
+"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: () => import_ethproofs_airbender_verifier.createVerifier,
+  resetVerifier: () => resetVerifier,
+  verify_stark: () => verify_stark,
+  verify_stark_with_result: () => verify_stark_with_result
+});
+module.exports = __toCommonJS(index_exports);
+var import_ethproofs_airbender_verifier = require("@matterlabs/ethproofs-airbender-verifier");
+var cachedVerifier = null;
+async function getVerifier() {
+  if (!cachedVerifier) {
+    cachedVerifier = await (0, import_ethproofs_airbender_verifier.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"],"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"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0CAMO;AAYP,IAAI,iBAAkC;AAMtC,eAAe,cAAiC;AAC9C,MAAI,CAAC,gBAAgB;AACnB,qBAAiB,UAAM,oDAAe;AAAA,EACxC;AACA,SAAO;AACT;AAWA,eAAsB,aAAa,YAA0C;AAC3E,QAAM,WAAW,MAAM,YAAY;AACnC,QAAM,SAAS,SAAS,sBAAsB,UAAU;AACxD,QAAM,SAAS,SAAS,YAAY,MAAM;AAC1C,SAAO,OAAO;AAChB;AAQA,eAAsB,yBACpB,YAC6B;AAC7B,QAAM,WAAW,MAAM,YAAY;AACnC,QAAM,SAAS,SAAS,sBAAsB,UAAU;AACxD,SAAO,SAAS,YAAY,MAAM;AACpC;AAMO,SAAS,gBAAsB;AACpC,mBAAiB;AACnB;","names":[]}

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 };

package/dist/index.js

@@ -0,0 +1,32 @@
+// src/index.ts
+import {
+  createVerifier
+} from "@matterlabs/ethproofs-airbender-verifier";
+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;
+}
+export {
+  createVerifier,
+  resetVerifier,
+  verify_stark,
+  verify_stark_with_result
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"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"],"mappings":";AAAA;AAAA,EACE;AAAA,OAKK;AAYP,IAAI,iBAAkC;AAMtC,eAAe,cAAiC;AAC9C,MAAI,CAAC,gBAAgB;AACnB,qBAAiB,MAAM,eAAe;AAAA,EACxC;AACA,SAAO;AACT;AAWA,eAAsB,aAAa,YAA0C;AAC3E,QAAM,WAAW,MAAM,YAAY;AACnC,QAAM,SAAS,SAAS,sBAAsB,UAAU;AACxD,QAAM,SAAS,SAAS,YAAY,MAAM;AAC1C,SAAO,OAAO;AAChB;AAQA,eAAsB,yBACpB,YAC6B;AAC7B,QAAM,WAAW,MAAM,YAAY;AACnC,QAAM,SAAS,SAAS,sBAAsB,UAAU;AACxD,SAAO,SAAS,YAAY,MAAM;AACpC;AAMO,SAAS,gBAAsB;AACpC,mBAAiB;AACnB;","names":[]}

package/package.json

@@ -1,32 +1,25 @@
 {
   "name": "@ethproofs/airbender-wasm-stark-verifier",
-  "version": "0.1.1",
-  "description": "WASM wrapper for Airbender STARK verifier",
+  "version": "0.2.0",
+  "description": "Simplified API wrapper for Airbender STARK proof verification",
   "type": "module",
-  "main": "pkg/ethproofs_verifier_lib.js",
-  "module": "pkg/ethproofs_verifier_lib.js",
-  "types": "pkg/ethproofs_verifier_lib.d.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./pkg/ethproofs_verifier_lib.d.ts",
-      "import": "./pkg/ethproofs_verifier_lib.js",
-      "require": "./pkg/ethproofs_verifier_lib.js"
-    },
-    "./pkg/*": "./pkg/*"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
   },
   "files": [
-    "pkg/",
-    "README.md",
-    "test-browser.html",
-    "test-serve.mjs"
+    "dist/",
+    "README.md"
   ],
   "scripts": {
-    "build": "wasm-pack build --target bundler --out-dir pkg --no-opt",
-    "build:node": "wasm-pack build --target nodejs --out-dir pkg-node  --no-opt",
-    "build:web": "wasm-pack build --target web --out-dir pkg-web --no-opt",
-    "build:all": "npm run build && npm run build:node && npm run build:web",
-    "test": "npm run build && node test-serve.mjs",
-    "test:node": "npm run build:node && node test-node.mjs"
+    "build": "tsup",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "wasm",
@@ -56,7 +49,11 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@matterlabs/ethproofs-airbender-verifier": "^0.1.1"
+  },
   "devDependencies": {
-    "wasm-pack": "^1.3.4"
+    "tsup": "^8.0.1",
+    "typescript": "^5.4.5"
   }
 }

package/pkg/README.md

@@ -1,90 +0,0 @@
-# Airbender Wasm STARK Verifier
-
-WebAssembly bindings for the Airbender verifier.
-
-## Overview
-
-This module builds the `verify` function from `sp1-verifier` into WebAssembly, enabling STARK proof verification to run directly in both web browsers and Node.js environments.
-
-## Usage
-
-### Installation
-
-```bash
-npm install @ethproofs/airbender-wasm-stark-verifier
-```
-
-### React Integration
-
-```typescript
-import init, {
-  main,
-  verify_stark,
-} from '@ethproofs/airbender-wasm-stark-verifier';
-
-await init(); // Initialize WASM (if needed)
-main(); // Initialize panic hook
-
-// Verify a proof
-const isValid = verify_stark(proofBytes, vkBytes);
-```
-
-### Node.js Usage
-
-```javascript
-const {
-  main,
-  verify_stark,
-} = require('@ethproofs/airbender-wasm-stark-verifier');
-
-// The Node.js version initializes automatically
-
-main(); // Initialize panic hook
-const result = verify_stark(proofBytes, vkBytes);
-```
-
-## Testing
-
-### Installation
-
-```bash
-npm install
-```
-
-### Prerequisites
-
-- [sp1](https://docs.succinct.xyz/docs/sp1/getting-started/install)
-- [wasm-pack](https://github.com/drager/wasm-pack)
-
-### Building
-
-```bash
-# Build for all targets
-npm run build:all
-```
-
-### Node.js Example
-
-```bash
-npm run test:node
-```
-
-This runs the Node.js example that loads proof and verification key files from the filesystem and verifies them.
-
-### Browser Example
-
-```bash
-npm run test
-```
-
-This starts a local HTTP server at `http://localhost:8080` with a browser example that demonstrates:
-
-- 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
-
-The browser example provides a complete UI for testing the WASM verifier with drag-and-drop file selection and real-time verification results.
-
-**Note:** The browser example requires files to be served over HTTP due to WASM CORS restrictions. The included server script handles this automatically.

package/pkg/ethproofs_verifier_lib.d.ts

@@ -1,4 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export function main(): void;
-export function verify_stark(data: Uint8Array): Array<any>;

package/pkg/ethproofs_verifier_lib.js

@@ -1,5 +0,0 @@
-import * as wasm from "./ethproofs_verifier_lib_bg.wasm";
-export * from "./ethproofs_verifier_lib_bg.js";
-import { __wbg_set_wasm } from "./ethproofs_verifier_lib_bg.js";
-__wbg_set_wasm(wasm);
-wasm.__wbindgen_start();

package/pkg/ethproofs_verifier_lib_bg.js

@@ -1,176 +0,0 @@
-let wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}
-
-
-let cachedUint8ArrayMemory0 = null;
-
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let 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));
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
-}
-
-let WASM_VECTOR_LEN = 0;
-
-const 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
-        };
-    }
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    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 > 0x7F) 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;
-}
-
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-export function main() {
-    wasm.main();
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-/**
- * @param {Uint8Array} data
- * @returns {Array<any>}
- */
-export function verify_stark(data) {
-    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.verify_stark(ptr0, len0);
-    return ret;
-}
-
-export function __wbg___wbindgen_throw_b855445ff6a94295(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-};
-
-export function __wbg_error_7534b8e9a36f1ab4(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);
-    }
-};
-
-export function __wbg_new_8a6f238a6ece86ea() {
-    const ret = new Error();
-    return ret;
-};
-
-export function __wbg_new_e17d9f43105b08be() {
-    const ret = new Array();
-    return ret;
-};
-
-export function __wbg_push_df81a39d04db858c(arg0, arg1) {
-    const ret = arg0.push(arg1);
-    return ret;
-};
-
-export function __wbg_stack_0ed75d68575b0f3c(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);
-};
-
-export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
-    // Cast intrinsic for `Ref(String) -> Externref`.
-    const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
-};
-
-export function __wbindgen_init_externref_table() {
-    const table = wasm.__wbindgen_externrefs;
-    const offset = table.grow(4);
-    table.set(0, undefined);
-    table.set(offset + 0, undefined);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
-    ;
-};
-

package/pkg/ethproofs_verifier_lib_bg.wasm.d.ts

@@ -1,10 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export const memory: WebAssembly.Memory;
-export const verify_stark: (a: number, b: number) => any;
-export const main: () => void;
-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;
-export const __wbindgen_externrefs: WebAssembly.Table;
-export const __wbindgen_start: () => void;

package/pkg/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "ethproofs_verifier",
-  "type": "module",
-  "version": "0.1.0",
-  "files": [
-    "ethproofs_verifier_lib_bg.wasm",
-    "ethproofs_verifier_lib.js",
-    "ethproofs_verifier_lib_bg.js",
-    "ethproofs_verifier_lib.d.ts"
-  ],
-  "main": "ethproofs_verifier_lib.js",
-  "types": "ethproofs_verifier_lib.d.ts",
-  "sideEffects": [
-    "./ethproofs_verifier_lib.js",
-    "./snippets/*"
-  ]
-}

package/test-browser.html

@@ -1,323 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Airbender WASM STARK Verifier - Browser Example</title>
-    <style>
-        body {
-            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
-            max-width: 800px;
-            margin: 0 auto;
-            padding: 20px;
-            background-color: #1a1a1a;
-            color: #e0e0e0;
-            line-height: 1.6;
-        }
-
-        .container {
-            background-color: #2d2d2d;
-            border-radius: 8px;
-            padding: 20px;
-            margin-bottom: 20px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.3);
-        }
-
-        h1 {
-            color: #4CAF50;
-            text-align: center;
-            margin-bottom: 30px;
-        }
-
-        h2 {
-            color: #81C784;
-            border-bottom: 2px solid #4CAF50;
-            padding-bottom: 5px;
-        }
-
-        .status {
-            padding: 10px;
-            border-radius: 4px;
-            margin: 10px 0;
-            font-weight: bold;
-        }
-
-        .status.loading {
-            background-color: #FFF3E0;
-            color: #FF8F00;
-            border: 1px solid #FFB74D;
-        }
-
-        .status.success {
-            background-color: #E8F5E8;
-            color: #2E7D32;
-            border: 1px solid #4CAF50;
-        }
-
-        .status.error {
-            background-color: #FFEBEE;
-            color: #C62828;
-            border: 1px solid #F44336;
-        }
-
-        .file-info {
-            background-color: #424242;
-            padding: 10px;
-            border-radius: 4px;
-            margin: 10px 0;
-            font-family: monospace;
-        }
-
-        button {
-            background-color: #4CAF50;
-            color: white;
-            padding: 10px 20px;
-            border: none;
-            border-radius: 4px;
-            cursor: pointer;
-            font-size: 16px;
-            margin: 10px 5px;
-        }
-
-        button:hover {
-            background-color: #45a049;
-        }
-
-        button:disabled {
-            background-color: #666;
-            cursor: not-allowed;
-        }
-
-        .file-input {
-            margin: 10px 0;
-        }
-
-        input[type="file"] {
-            background-color: #424242;
-            color: #e0e0e0;
-            padding: 5px;
-            border: 1px solid #666;
-            border-radius: 4px;
-        }
-
-        .log {
-            background-color: #1e1e1e;
-            border: 1px solid #444;
-            border-radius: 4px;
-            padding: 15px;
-            margin: 15px 0;
-            font-family: monospace;
-            font-size: 12px;
-            white-space: pre-wrap;
-            max-height: 300px;
-            overflow-y: auto;
-        }
-
-        .performance {
-            background-color: #263238;
-            padding: 10px;
-            border-radius: 4px;
-            margin: 10px 0;
-        }
-
-        .result {
-            font-size: 18px;
-            font-weight: bold;
-            padding: 15px;
-            border-radius: 4px;
-            margin: 15px 0;
-            text-align: center;
-        }
-
-        .result.valid {
-            background-color: #1B5E20;
-            color: #4CAF50;
-            border: 2px solid #4CAF50;
-        }
-
-        .result.invalid {
-            background-color: #B71C1C;
-            color: #F44336;
-            border: 2px solid #F44336;
-        }
-    </style>
-</head>
-<body>
-    <h1>🧪 Airbender WASM STARK Verifier</h1>
-
-    <div class="container">
-        <h2>Browser Integration Example</h2>
-        <p>This example demonstrates how to use the Airbender WASM STARK verifier in a web browser environment.</p>
-
-        <div id="wasmStatus" class="status loading">Loading WASM module...</div>
-    </div>
-
-    <div class="container">
-        <h2>File Selection</h2>
-        <p>Select the proof file to test verification:</p>
-
-        <div class="file-input">
-            <label for="proofFile"><strong>Proof file (.bin):</strong></label><br>
-            <input type="file" id="proofFile" accept=".bin" />
-            <div id="proofInfo" class="file-info" style="display: none;"></div>
-        </div>
-    </div>
-
-    <div class="container">
-        <h2>Verification</h2>
-        <button id="verifyBtn" disabled onclick="runVerification()">Run Verification</button>
-        <button id="clearLogBtn" onclick="clearLog()">Clear Log</button>
-
-        <div id="result" class="result" style="display: none;"></div>
-        <div id="performance" class="performance" style="display: none;"></div>
-    </div>
-
-    <div class="container">
-        <h2>Console Output</h2>
-        <div id="log" class="log"></div>
-    </div>
-
-    <script type="module">
-        import init, { main, verify_stark } from './pkg-web/airbender_wasm_stark_verifier.js';
-
-        let wasmModule = null;
-        let proofBytes = null;
-
-        // Log function to display messages in the UI
-        function log(message) {
-            const logElement = document.getElementById('log');
-            const timestamp = new Date().toLocaleTimeString();
-            logElement.textContent += `[${timestamp}] ${message}\n`;
-            logElement.scrollTop = logElement.scrollHeight;
-            console.log(message);
-        }
-
-        function clearLog() {
-            document.getElementById('log').textContent = '';
-        }
-
-        function updateStatus(elementId, message, className) {
-            const element = document.getElementById(elementId);
-            element.textContent = message;
-            element.className = `status ${className}`;
-        }
-
-        function updateFileInfo(elementId, file) {
-            const element = document.getElementById(elementId);
-            element.style.display = 'block';
-            element.innerHTML = `
-                <strong>File:</strong> ${file.name}<br>
-                <strong>Size:</strong> ${file.size.toLocaleString()} bytes<br>
-                <strong>Type:</strong> ${file.type || 'binary'}
-            `;
-        }
-
-        function checkCanVerify() {
-            const canVerify = wasmModule && proofBytes;
-            document.getElementById('verifyBtn').disabled = !canVerify;
-            return canVerify;
-        }
-
-        // Initialize WASM module
-        async function initializeWasm() {
-            try {
-                log('🚀 Initializing WASM module...');
-                wasmModule = await init();
-                log('📦 WASM module loaded, initializing panic hook...');
-                main(); // Initialize panic hook and other setup
-                updateStatus('wasmStatus', '✅ WASM module loaded successfully', 'success');
-                log('✅ WASM module initialized successfully');
-                checkCanVerify();
-            } catch (error) {
-                updateStatus('wasmStatus', `❌ Failed to load WASM module: ${error.message}`, 'error');
-                log(`❌ Error initializing WASM: ${error.message}`);
-                console.error('WASM initialization error:', error);
-            }
-        }
-
-        // File reading helper
-        function readFileAsArrayBuffer(file) {
-            return new Promise((resolve, reject) => {
-                const reader = new FileReader();
-                reader.onload = (e) => resolve(new Uint8Array(e.target.result));
-                reader.onerror = (e) => reject(new Error(`Failed to read file: ${e.target.error}`));
-                reader.readAsArrayBuffer(file);
-            });
-        }
-
-        // File input handlers
-        document.getElementById('proofFile').addEventListener('change', async (e) => {
-            const file = e.target.files[0];
-            if (file) {
-                try {
-                    log(`📄 Loading proof file: ${file.name}`);
-                    proofBytes = await readFileAsArrayBuffer(file);
-                    updateFileInfo('proofInfo', file);
-                    log(`✅ Proof file loaded: ${proofBytes.length} bytes`);
-                    checkCanVerify();
-                } catch (error) {
-                    log(`❌ Error loading proof file: ${error.message}`);
-                }
-            }
-        });
-
-
-        // Main verification function
-        window.runVerification = async function() {
-            if (!checkCanVerify()) {
-                log('❌ Cannot run verification: missing WASM module or proof');
-                return;
-            }
-
-            const resultElement = document.getElementById('result');
-            const performanceElement = document.getElementById('performance');
-
-            try {
-                log('🔍 Starting verification...');
-                log(`📊 Proof size: ${proofBytes.length.toLocaleString()} bytes`);
-
-                const startTime = performance.now();
-                const result = verify_stark(proofBytes);
-                const endTime = performance.now();
-                const duration = endTime - startTime;
-
-                // Display result
-                resultElement.style.display = 'block';
-                resultElement.className = `result ${result ? 'valid' : 'invalid'}`;
-                resultElement.textContent = result ? '✅ PROOF VALID' : '❌ PROOF INVALID';
-
-                // Display performance metrics
-                performanceElement.style.display = 'block';
-                performanceElement.innerHTML = `
-                    <strong>⏱️ Performance Metrics:</strong><br>
-                    Verification time: ${duration.toFixed(2)} milliseconds<br>
-                    Throughput: ${(proofBytes.length / 1024 / (duration / 1000)).toFixed(2)} KB/s
-                `;
-
-                log(`✅ Verification completed: ${result ? 'VALID' : 'INVALID'}`);
-                log(`⏱️ Time taken: ${duration.toFixed(2)} milliseconds`);
-
-            } catch (error) {
-                resultElement.style.display = 'block';
-                resultElement.className = 'result invalid';
-                resultElement.textContent = `❌ VERIFICATION ERROR: ${error.message}`;
-
-                log(`❌ Verification error: ${error.message}`);
-                console.error('Verification error:', error);
-            }
-        };
-
-        // Initialize on page load
-        initializeWasm();
-
-        // Add some helpful information
-        log('🌐 Airbender WASM STARK Verifier browser example loaded');
-        log('📝 Instructions:');
-        log('   1. Wait for WASM module to load');
-        log('   2. Select a proof file (.bin)');
-        log('   3. Click "Run Verification"');
-        log('');
-        log('💡 Tip: You can use the proof file from the data/ directory');
-    </script>
-</body>
-</html>

package/test-serve.mjs

@@ -1,123 +0,0 @@
-import http from 'http';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const PORT = process.env.PORT || 8080;
-
-// MIME types for different file extensions
-const mimeTypes = {
-  '.html': 'text/html',
-  '.js': 'application/javascript',
-  '.wasm': 'application/wasm',
-  '.json': 'application/json',
-  '.bin': 'application/octet-stream',
-  '.css': 'text/css',
-  '.ts': 'application/typescript',
-};
-
-function getMimeType(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  return mimeTypes[ext] || 'application/octet-stream';
-}
-
-function serveFile(res, filePath) {
-  const fullPath = path.join(__dirname, filePath);
-
-  fs.readFile(fullPath, (err, data) => {
-    if (err) {
-      // Only log file not found for legitimate requests, not for browser probes
-      if (
-        !filePath.includes('favicon') &&
-        !filePath.includes('ws') &&
-        !filePath.includes('socket')
-      ) {
-        console.error(`❌ File not found: ${filePath}`);
-      }
-      res.writeHead(404, { 'Content-Type': 'text/plain' });
-      res.end('File not found');
-      return;
-    }
-
-    const mimeType = getMimeType(filePath);
-    const headers = {
-      'Content-Type': mimeType,
-      'Cross-Origin-Embedder-Policy': 'require-corp',
-      'Cross-Origin-Opener-Policy': 'same-origin',
-    };
-
-    // Ensure WASM files are served with correct MIME type for streaming
-    if (filePath.endsWith('.wasm')) {
-      headers['Content-Type'] = 'application/wasm';
-    }
-
-    res.writeHead(200, headers);
-    res.end(data);
-
-    console.log(`📄 Served: ${filePath} (${mimeType})`);
-  });
-}
-
-const server = http.createServer((req, res) => {
-  let url = req.url;
-
-  // Handle root path
-  if (url === '/') {
-    url = '/test-browser.html';
-  }
-
-  // Remove query parameters and decode URL
-  url = decodeURIComponent(url.split('?')[0]);
-
-  // Security check - prevent directory traversal
-  if (url.includes('..')) {
-    res.writeHead(400, { 'Content-Type': 'text/plain' });
-    res.end('Bad Request');
-    return;
-  }
-
-  // Handle WebSocket upgrade attempts (reject them gracefully)
-  if (req.url === '/ws' || req.headers.upgrade === 'websocket') {
-    res.writeHead(400, { 'Content-Type': 'text/plain' });
-    res.end('WebSocket connections not supported by this server');
-    return;
-  }
-
-  // Remove leading slash for path.join
-  const filePath = url.startsWith('/') ? url.slice(1) : url;
-
-  console.log(`🌐 Request: ${req.method} ${req.url} -> ${filePath}`);
-
-  serveFile(res, filePath);
-});
-
-server.listen(PORT, () => {
-  console.log('🚀 Airbender WASM STARK Verifier Example Server');
-  console.log(`📡 Server running at http://localhost:${PORT}`);
-  console.log('');
-  console.log('📝 Available endpoints:');
-  console.log(
-    `   http://localhost:${PORT}/                     - Browser example`
-  );
-  console.log(
-    `   http://localhost:${PORT}/pkg/                 - WASM package files`
-  );
-  console.log(`   http://localhost:${PORT}/data/                - Proof files`);
-  console.log('');
-  console.log(
-    '💡 Open your browser and navigate to the server URL to test the WASM verifier!'
-  );
-  console.log('⏹️  Press Ctrl+C to stop the server');
-});
-
-// Graceful shutdown
-process.on('SIGINT', () => {
-  console.log('\n🛑 Shutting down server...');
-  server.close(() => {
-    console.log('✅ Server shut down gracefully');
-    process.exit(0);
-  });
-});