@ethproofs/openvm2-wasm-stark-verifier 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ethproofs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# OpenVM v2 Wasm Stark Verifier
+
+WebAssembly bindings for the OpenVM v2 STARK verifier.
+
+## Overview
+
+This module builds the `verify_vm_stark_proof_decoded` function from the OpenVM v2 `openvm-verify-stark-host` library into WebAssembly, enabling STARK proof verification to run directly in both web browsers and Node.js environments.
+
+This is the v2 counterpart of [openvm-wasm-stark-verifier](https://github.com/ethproofs/openvm-wasm-stark-verifier), updated to work with the OpenVM v2 proof format from [openvm-eth](https://github.com/axiom-crypto/openvm-eth/tree/develop-v2.0.0-rc.1).
+
+## Usage
+
+### Installation
+
+```bash
+npm install @ethproofs/openvm2-wasm-stark-verifier
+```
+
+### React Integration
+
+```typescript
+import init, {
+  main,
+  verify_stark,
+} from '@ethproofs/openvm2-wasm-stark-verifier';
+
+await init(); // Initialize WASM (if needed)
+main(); // Initialize panic hook
+
+// Verify a proof (supports both raw and zstd-compressed proofs)
+const isValid = verify_stark(proofBytes, vkBytes);
+```
+
+### Node.js Usage
+
+```javascript
+const { main, verify_stark } = require('@ethproofs/openvm2-wasm-stark-verifier');
+
+// The Node.js version initializes automatically
+
+main(); // Initialize panic hook
+const result = verify_stark(proofBytes, vkBytes);
+```
+
+## Proof Format
+
+- **Proof bytes**: Serialized `StarkProofWithPublicValue<F>` in bincode v1 format, optionally zstd-compressed
+- **VK bytes**: Serialized `VmStarkVerifyingKey` in bitcode format
+
+This matches the proof format produced by the [openvm-eth reth-benchmark](https://github.com/axiom-crypto/openvm-eth) tooling.
+
+## Testing
+
+### Installation
+
+```bash
+npm install
+```
+
+### Prerequisites
+
+- [Rust](https://www.rust-lang.org/tools/install)
+- [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/)
+
+### 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
+
+**Note:** The browser example requires files to be served over HTTP due to WASM CORS restrictions. The included server script handles this automatically.

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@ethproofs/openvm2-wasm-stark-verifier",
+  "version": "0.1.0",
+  "description": "WASM wrapper for OpenVM v2 STARK verifier - verify OpenVM v2 proofs in browsers and Node.js",
+  "type": "module",
+  "main": "pkg/openvm2_wasm_stark_verifier.js",
+  "module": "pkg/openvm2_wasm_stark_verifier.js",
+  "types": "pkg/openvm2_wasm_stark_verifier.d.ts",
+  "exports": {
+    ".": {
+      "types": "./pkg/openvm2_wasm_stark_verifier.d.ts",
+      "import": "./pkg/openvm2_wasm_stark_verifier.js",
+      "require": "./pkg/openvm2_wasm_stark_verifier.js"
+    },
+    "./pkg/*": "./pkg/*"
+  },
+  "files": [
+    "pkg/",
+    "README.md",
+    "test-browser.html",
+    "test-serve.mjs"
+  ],
+  "scripts": {
+    "build": "wasm-pack build --target bundler --out-dir pkg",
+    "build:node": "wasm-pack build --target nodejs --out-dir pkg-node",
+    "build:web": "wasm-pack build --target web --out-dir pkg-web",
+    "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"
+  },
+  "keywords": [
+    "wasm",
+    "webassembly",
+    "stark",
+    "verifier",
+    "openvm",
+    "zero-knowledge",
+    "zk",
+    "proof",
+    "blockchain",
+    "cryptography",
+    "vm"
+  ],
+  "author": "Ethproofs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ethproofs/openvm2-wasm-stark-verifier"
+  },
+  "homepage": "https://github.com/ethproofs/openvm2-wasm-stark-verifier#readme",
+  "bugs": {
+    "url": "https://github.com/ethproofs/openvm2-wasm-stark-verifier/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "wasm-pack": "^0.0.0"
+  }
+}

package/pkg/README.md

@@ -0,0 +1,94 @@
+# OpenVM v2 Wasm Stark Verifier
+
+WebAssembly bindings for the OpenVM v2 STARK verifier.
+
+## Overview
+
+This module builds the `verify_vm_stark_proof_decoded` function from the OpenVM v2 `openvm-verify-stark-host` library into WebAssembly, enabling STARK proof verification to run directly in both web browsers and Node.js environments.
+
+This is the v2 counterpart of [openvm-wasm-stark-verifier](https://github.com/ethproofs/openvm-wasm-stark-verifier), updated to work with the OpenVM v2 proof format from [openvm-eth](https://github.com/axiom-crypto/openvm-eth/tree/develop-v2.0.0-rc.1).
+
+## Usage
+
+### Installation
+
+```bash
+npm install @ethproofs/openvm2-wasm-stark-verifier
+```
+
+### React Integration
+
+```typescript
+import init, {
+  main,
+  verify_stark,
+} from '@ethproofs/openvm2-wasm-stark-verifier';
+
+await init(); // Initialize WASM (if needed)
+main(); // Initialize panic hook
+
+// Verify a proof (supports both raw and zstd-compressed proofs)
+const isValid = verify_stark(proofBytes, vkBytes);
+```
+
+### Node.js Usage
+
+```javascript
+const { main, verify_stark } = require('@ethproofs/openvm2-wasm-stark-verifier');
+
+// The Node.js version initializes automatically
+
+main(); // Initialize panic hook
+const result = verify_stark(proofBytes, vkBytes);
+```
+
+## Proof Format
+
+- **Proof bytes**: Serialized `StarkProofWithPublicValue<F>` in bincode v1 format, optionally zstd-compressed
+- **VK bytes**: Serialized `VmStarkVerifyingKey` in bitcode format
+
+This matches the proof format produced by the [openvm-eth reth-benchmark](https://github.com/axiom-crypto/openvm-eth) tooling.
+
+## Testing
+
+### Installation
+
+```bash
+npm install
+```
+
+### Prerequisites
+
+- [Rust](https://www.rust-lang.org/tools/install)
+- [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/)
+
+### 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
+
+**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/openvm2_wasm_stark_verifier.d.ts

@@ -0,0 +1,16 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function main(): void;
+
+/**
+ * Verify an OpenVM v2 STARK proof
+ *
+ * # Arguments
+ * * `proof_bytes` - The serialized proof data (zstd-compressed, custom codec format)
+ * * `vk_bytes` - The serialized verification key (bitcode format)
+ *
+ * # Returns
+ * * `Result<bool, JsValue>` - Ok(true) if proof is valid, Ok(false) if invalid, Err for errors
+ */
+export function verify_stark(proof_bytes: Uint8Array, vk_bytes: Uint8Array): boolean;

package/pkg/openvm2_wasm_stark_verifier.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./openvm2_wasm_stark_verifier.d.ts" */
+
+import * as wasm from "./openvm2_wasm_stark_verifier_bg.wasm";
+import { __wbg_set_wasm } from "./openvm2_wasm_stark_verifier_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();
+export {
+    main, verify_stark
+} from "./openvm2_wasm_stark_verifier_bg.js";

package/pkg/openvm2_wasm_stark_verifier_bg.js

@@ -0,0 +1,175 @@
+export function main() {
+    wasm.main();
+}
+
+/**
+ * Verify an OpenVM v2 STARK proof
+ *
+ * # Arguments
+ * * `proof_bytes` - The serialized proof data (zstd-compressed, custom codec format)
+ * * `vk_bytes` - The serialized verification key (bitcode format)
+ *
+ * # Returns
+ * * `Result<bool, JsValue>` - Ok(true) if proof is valid, Ok(false) if invalid, Err for errors
+ * @param {Uint8Array} proof_bytes
+ * @param {Uint8Array} vk_bytes
+ * @returns {boolean}
+ */
+export function verify_stark(proof_bytes, vk_bytes) {
+    const ptr0 = passArray8ToWasm0(proof_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(vk_bytes, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.verify_stark(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+export function __wbg___wbindgen_throw_81fc77679af83bc6(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_error_a6fa202b58aa1cd3(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_log_9ea0fc1d68ddc809(arg0, arg1) {
+    console.log(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_new_227d7c05414eb861() {
+    const ret = new Error();
+    return ret;
+}
+export function __wbg_stack_3b0d974bbf31e44f(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_0000000000000001(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);
+}
+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;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let 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 === 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;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+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));
+}
+
+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
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}

package/pkg/openvm2_wasm_stark_verifier_bg.wasm.d.ts

@@ -0,0 +1,19 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const main: () => void;
+export const verify_stark: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const rust_zstd_wasm_shim_calloc: (a: number, b: number) => number;
+export const rust_zstd_wasm_shim_free: (a: number) => void;
+export const rust_zstd_wasm_shim_malloc: (a: number) => number;
+export const rust_zstd_wasm_shim_memcmp: (a: number, b: number, c: number) => number;
+export const rust_zstd_wasm_shim_memcpy: (a: number, b: number, c: number) => number;
+export const rust_zstd_wasm_shim_memmove: (a: number, b: number, c: number) => number;
+export const rust_zstd_wasm_shim_memset: (a: number, b: number, c: number) => number;
+export const rust_zstd_wasm_shim_qsort: (a: number, b: number, c: number, d: number) => 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 __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/pkg/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "openvm2-wasm-stark-verifier",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "openvm2_wasm_stark_verifier_bg.wasm",
+    "openvm2_wasm_stark_verifier.js",
+    "openvm2_wasm_stark_verifier_bg.js",
+    "openvm2_wasm_stark_verifier.d.ts"
+  ],
+  "main": "openvm2_wasm_stark_verifier.js",
+  "types": "openvm2_wasm_stark_verifier.d.ts",
+  "sideEffects": [
+    "./openvm2_wasm_stark_verifier.js",
+    "./snippets/*"
+  ]
+}

package/test-browser.html

@@ -0,0 +1,337 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>OpenVM v2 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>OpenVM v2 WASM STARK Verifier</h1>
+
+    <div class="container">
+        <h2>Browser Integration Example</h2>
+        <p>This example demonstrates how to use the OpenVM v2 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 and verification key files 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 class="file-input">
+            <label for="vkFile"><strong>Verification Key file (.bin):</strong></label><br>
+            <input type="file" id="vkFile" accept=".bin" />
+            <div id="vkInfo" 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/openvm2_wasm_stark_verifier.js';
+
+        let wasmModule = null;
+        let proofBytes = null;
+        let vkBytes = null;
+
+        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 && vkBytes;
+            document.getElementById('verifyBtn').disabled = !canVerify;
+            return canVerify;
+        }
+
+        async function initializeWasm() {
+            try {
+                log('Initializing WASM module...');
+                wasmModule = await init();
+                log('WASM module loaded, initializing panic hook...');
+                main();
+                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);
+            }
+        }
+
+        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);
+            });
+        }
+
+        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}`);
+                }
+            }
+        });
+
+        document.getElementById('vkFile').addEventListener('change', async (e) => {
+            const file = e.target.files[0];
+            if (file) {
+                try {
+                    log(`Loading verification key file: ${file.name}`);
+                    vkBytes = await readFileAsArrayBuffer(file);
+                    updateFileInfo('vkInfo', file);
+                    log(`Verification key loaded: ${vkBytes.length} bytes`);
+                    checkCanVerify();
+                } catch (error) {
+                    log(`Error loading verification key file: ${error.message}`);
+                }
+            }
+        });
+
+        window.runVerification = async function() {
+            if (!checkCanVerify()) {
+                log('Cannot run verification: missing WASM module, proof, or verification key');
+                return;
+            }
+
+            const resultElement = document.getElementById('result');
+            const performanceElement = document.getElementById('performance');
+
+            try {
+                log('Starting verification...');
+                log(`Proof size: ${proofBytes.length.toLocaleString()} bytes`);
+                log(`VK size: ${vkBytes.length.toLocaleString()} bytes`);
+
+                const startTime = performance.now();
+                const result = verify_stark(proofBytes, vkBytes);
+                const endTime = performance.now();
+                const duration = endTime - startTime;
+
+                resultElement.style.display = 'block';
+                resultElement.className = `result ${result ? 'valid' : 'invalid'}`;
+                resultElement.textContent = result ? 'PROOF VALID' : 'PROOF INVALID';
+
+                performanceElement.style.display = 'block';
+                performanceElement.innerHTML = `
+                    <strong>Performance Metrics:</strong><br>
+                    Verification time: ${duration.toFixed(2)} milliseconds<br>
+                    Throughput: ${((proofBytes.length + vkBytes.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);
+            }
+        };
+
+        initializeWasm();
+
+        log('OpenVM v2 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. Select a verification key file (.bin)');
+        log('   4. Click "Run Verification"');
+        log('');
+        log('Tip: You can use the proof and verification key files from the proofs/ and vks/ directories');
+    </script>
+</body>
+</html>

package/test-serve.mjs

@@ -0,0 +1,118 @@
+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) {
+      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',
+    };
+
+    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;
+
+  if (url === '/') {
+    url = '/test-browser.html';
+  }
+
+  url = decodeURIComponent(url.split('?')[0]);
+
+  if (url.includes('..')) {
+    res.writeHead(400, { 'Content-Type': 'text/plain' });
+    res.end('Bad Request');
+    return;
+  }
+
+  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;
+  }
+
+  const filePath = url.startsWith('/') ? url.slice(1) : url;
+
+  console.log(`Request: ${req.method} ${req.url} -> ${filePath}`);
+
+  serveFile(res, filePath);
+});
+
+server.listen(PORT, () => {
+  console.log('OpenVM v2 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}/proofs/              - Proof files`);
+  console.log(
+    `   http://localhost:${PORT}/vks/                 - Verification keys`
+  );
+  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');
+});
+
+process.on('SIGINT', () => {
+  console.log('\nShutting down server...');
+  server.close(() => {
+    console.log('Server shut down gracefully');
+    process.exit(0);
+  });
+});