zerc20-client-sdk 0.1.14 → 0.1.15

package/dist/zkp/worker.js

@@ -1,49 +1,2273 @@
-import { primeBatchTeleportArtifacts, primeSingleTeleportArtifacts } from "../wasm/artifacts.js";
-import { WasmRuntime } from "../wasm/index.js";
-import { ProofService } from "./proofService.js";
-const wasm = new WasmRuntime();
-const proofs = new ProofService(wasm);
-const ctx = self;
-ctx.addEventListener("message", async (event) => {
-    const message = event.data;
-    if (!message) {
-        return;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// dist/assets/wasm/web/zerc20_wasm.js
+var zerc20_wasm_exports = {};
+__export(zerc20_wasm_exports, {
+  SingleWithdrawWasm: () => SingleWithdrawWasm,
+  WithdrawNovaWasm: () => WithdrawNovaWasm,
+  aggregation_merkle_proof: () => aggregation_merkle_proof,
+  aggregation_root: () => aggregation_root,
+  build_full_burn_address: () => build_full_burn_address,
+  decode_full_burn_address: () => decode_full_burn_address,
+  default: () => zerc20_wasm_default,
+  derive_invoice_batch: () => derive_invoice_batch,
+  derive_invoice_single: () => derive_invoice_single,
+  derive_payment_advice: () => derive_payment_advice,
+  fetch_aggregation_tree_state: () => fetch_aggregation_tree_state,
+  fetch_local_teleport_merkle_proofs: () => fetch_local_teleport_merkle_proofs,
+  fetch_transfer_events: () => fetch_transfer_events,
+  general_recipient_fr: () => general_recipient_fr,
+  generate_global_teleport_merkle_proofs: () => generate_global_teleport_merkle_proofs,
+  initSync: () => initSync,
+  seed_message: () => seed_message,
+  separate_events_by_eligibility: () => separate_events_by_eligibility
+});
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+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);
+}
+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 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 addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_export_4.set(idx, obj);
+  return idx;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function debugString(val) {
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
     }
+  }
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+function makeMutClosure(arg0, arg1, dtor, f) {
+  const state = { a: arg0, b: arg1, cnt: 1, dtor };
+  const real = (...args) => {
+    state.cnt++;
+    const a = state.a;
+    state.a = 0;
     try {
-        if (message.type === "singleTeleport") {
-            primeSingleTeleportArtifacts(message.payload.artifacts);
-            const result = await proofs.createSingleTeleportProof(message.payload.params);
-            const response = {
-                id: message.id,
-                type: "result",
-                result,
-            };
-            ctx.postMessage(response);
-            return;
+      return f(a, state.b, ...args);
+    } finally {
+      if (--state.cnt === 0) {
+        wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
+        CLOSURE_DTORS.unregister(state);
+      } else {
+        state.a = a;
+      }
+    }
+  };
+  real.original = state;
+  CLOSURE_DTORS.register(real, state, state);
+  return real;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_export_4.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+function aggregation_root(snapshot_hex) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const ret = wasm.aggregation_root(snapshot_hex);
+    var ptr1 = ret[0];
+    var len1 = ret[1];
+    if (ret[3]) {
+      ptr1 = 0;
+      len1 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred2_0 = ptr1;
+    deferred2_1 = len1;
+    return getStringFromWasm0(ptr1, len1);
+  } finally {
+    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+  }
+}
+function aggregation_merkle_proof(snapshot_hex, index) {
+  const ret = wasm.aggregation_merkle_proof(snapshot_hex, index);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function derive_invoice_batch(seed_hex, invoice_id_hex, sub_id, recipient_chain_id, recipient_address_hex) {
+  const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(invoice_id_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(recipient_address_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.derive_invoice_batch(ptr0, len0, ptr1, len1, sub_id, recipient_chain_id, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function derive_invoice_single(seed_hex, invoice_id_hex, recipient_chain_id, recipient_address_hex) {
+  const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(invoice_id_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(recipient_address_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.derive_invoice_single(ptr0, len0, ptr1, len1, recipient_chain_id, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function general_recipient_fr(chain_id, recipient_address_hex, tweak_hex) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passStringToWasm0(recipient_address_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(tweak_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.general_recipient_fr(chain_id, ptr0, len0, ptr1, len1);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function seed_message() {
+  let deferred1_0;
+  let deferred1_1;
+  try {
+    const ret = wasm.seed_message();
+    deferred1_0 = ret[0];
+    deferred1_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+  }
+}
+function build_full_burn_address(recipient_chain_id, recipient_address_hex, secret_hex, tweak_hex) {
+  const ptr0 = passStringToWasm0(recipient_address_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(secret_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(tweak_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.build_full_burn_address(recipient_chain_id, ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function derive_payment_advice(seed_hex, payment_advice_id_hex, recipient_chain_id, recipient_address_hex) {
+  const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(payment_advice_id_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(recipient_address_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.derive_payment_advice(ptr0, len0, ptr1, len1, recipient_chain_id, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function decode_full_burn_address(full_burn_address_hex) {
+  const ptr0 = passStringToWasm0(full_burn_address_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.decode_full_burn_address(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function separate_events_by_eligibility(params) {
+  const ret = wasm.separate_events_by_eligibility(params);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function generate_global_teleport_merkle_proofs(params) {
+  const ret = wasm.generate_global_teleport_merkle_proofs(params);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function fetch_transfer_events(params) {
+  const ret = wasm.fetch_transfer_events(params);
+  return ret;
+}
+function fetch_local_teleport_merkle_proofs(params) {
+  const ret = wasm.fetch_local_teleport_merkle_proofs(params);
+  return ret;
+}
+function fetch_aggregation_tree_state(params) {
+  const ret = wasm.fetch_aggregation_tree_state(params);
+  return ret;
+}
+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 __wbg_adapter_6(arg0, arg1, arg2) {
+  wasm.closure1250_externref_shim(arg0, arg1, arg2);
+}
+function __wbg_adapter_11(arg0, arg1) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h258073e353b316af(arg0, arg1);
+}
+function __wbg_adapter_14(arg0, arg1) {
+  wasm.wasm_bindgen__convert__closures_____invoke__ha5dd837bc6b9ee0b(arg0, arg1);
+}
+function __wbg_adapter_151(arg0, arg1, arg2, arg3) {
+  wasm.closure1441_externref_shim(arg0, arg1, arg2, arg3);
+}
+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;
         }
-        if (message.type === "nova") {
-            primeBatchTeleportArtifacts(message.payload.artifacts);
-            const result = await proofs.runNovaProver(message.payload.params);
-            const response = {
-                id: message.id,
-                type: "result",
-                result,
-            };
-            ctx.postMessage(response);
-            return;
+      }
+    }
+    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_Error_e17e777aac105295 = function(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+  };
+  imports.wbg.__wbg_Number_998bea33bd87c3e0 = function(arg0) {
+    const ret = Number(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+    const ret = String(arg1);
+    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.__wbg_abort_67e1b49bf6614565 = function(arg0) {
+    arg0.abort();
+  };
+  imports.wbg.__wbg_abort_d830bf2e9aa6ec5b = function(arg0, arg1) {
+    arg0.abort(arg1);
+  };
+  imports.wbg.__wbg_append_72a3c0addd2bce38 = function() {
+    return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+      arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+    }, arguments);
+  };
+  imports.wbg.__wbg_arrayBuffer_9c99b8e2809e8cbb = function() {
+    return handleError(function(arg0) {
+      const ret = arg0.arrayBuffer();
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_call_13410aac570ffff7 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = arg0.call(arg1);
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_call_a5400b25a865cfd8 = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = arg0.call(arg1, arg2);
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_clearTimeout_7a42b49784aea641 = function(arg0) {
+    const ret = clearTimeout(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
+    const ret = arg0.crypto;
+    return ret;
+  };
+  imports.wbg.__wbg_done_75ed0ee6dd243d9d = function(arg0) {
+    const ret = arg0.done;
+    return ret;
+  };
+  imports.wbg.__wbg_entries_2be2f15bd5554996 = function(arg0) {
+    const ret = Object.entries(arg0);
+    return ret;
+  };
+  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_fetch_74a3e84ebd2c9a0e = function(arg0) {
+    const ret = fetch(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_fetch_87aed7f306ec6d63 = function(arg0, arg1) {
+    const ret = arg0.fetch(arg1);
+    return ret;
+  };
+  imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() {
+    return handleError(function(arg0, arg1) {
+      arg0.getRandomValues(arg1);
+    }, arguments);
+  };
+  imports.wbg.__wbg_get_0da715ceaecea5c8 = function(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+  };
+  imports.wbg.__wbg_get_458e874b43b18b25 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = Reflect.get(arg0, arg1);
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_getwithrefkey_1dc361bd10053bfe = function(arg0, arg1) {
+    const ret = arg0[arg1];
+    return ret;
+  };
+  imports.wbg.__wbg_has_b89e451f638123e3 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = Reflect.has(arg0, arg1);
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_headers_29fec3c72865cd75 = function(arg0) {
+    const ret = arg0.headers;
+    return ret;
+  };
+  imports.wbg.__wbg_instanceof_ArrayBuffer_67f3012529f6a2dd = function(arg0) {
+    let result;
+    try {
+      result = arg0 instanceof ArrayBuffer;
+    } catch (_) {
+      result = false;
+    }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_instanceof_Map_ebb01a5b6b5ffd0b = function(arg0) {
+    let result;
+    try {
+      result = arg0 instanceof Map;
+    } catch (_) {
+      result = false;
+    }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_instanceof_Response_50fde2cd696850bf = function(arg0) {
+    let result;
+    try {
+      result = arg0 instanceof Response;
+    } catch (_) {
+      result = false;
+    }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_instanceof_Uint8Array_9a8378d955933db7 = function(arg0) {
+    let result;
+    try {
+      result = arg0 instanceof Uint8Array;
+    } catch (_) {
+      result = false;
+    }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_isArray_030cce220591fb41 = function(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_isSafeInteger_1c0d1af5542e102a = function(arg0) {
+    const ret = Number.isSafeInteger(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_iterator_f370b34483c71a1c = function() {
+    const ret = Symbol.iterator;
+    return ret;
+  };
+  imports.wbg.__wbg_length_186546c51cd61acd = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+  };
+  imports.wbg.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+  };
+  imports.wbg.__wbg_log_6c7b5f4f00b8ce3f = function(arg0) {
+    console.log(arg0);
+  };
+  imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
+    const ret = arg0.msCrypto;
+    return ret;
+  };
+  imports.wbg.__wbg_new_19c25a3f2fa63a02 = function() {
+    const ret = new Object();
+    return ret;
+  };
+  imports.wbg.__wbg_new_1f3a344cf3123716 = function() {
+    const ret = new Array();
+    return ret;
+  };
+  imports.wbg.__wbg_new_2e3c58a15f39f5f9 = function(arg0, arg1) {
+    try {
+      var state0 = { a: arg0, b: arg1 };
+      var cb0 = (arg02, arg12) => {
+        const a = state0.a;
+        state0.a = 0;
+        try {
+          return __wbg_adapter_151(a, state0.b, arg02, arg12);
+        } finally {
+          state0.a = a;
         }
-        throw new Error(`Unknown ZKP worker job type ${message.type}`);
-    }
-    catch (error) {
-        const response = {
-            id: message.id,
-            type: "error",
-            error: {
-                message: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
-            },
+      };
+      const ret = new Promise(cb0);
+      return ret;
+    } finally {
+      state0.a = state0.b = 0;
+    }
+  };
+  imports.wbg.__wbg_new_638ebfaedbf32a5e = function(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_new_66b9434b4e59b63e = function() {
+    return handleError(function() {
+      const ret = new AbortController();
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+    const ret = new Error();
+    return ret;
+  };
+  imports.wbg.__wbg_new_f6e53210afea8e45 = function() {
+    return handleError(function() {
+      const ret = new Headers();
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_newfromslice_074c56947bd43469 = function(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return ret;
+  };
+  imports.wbg.__wbg_newnoargs_254190557c45b4ec = function(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+  };
+  imports.wbg.__wbg_newwithlength_a167dcc7aaa3ba77 = function(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+  };
+  imports.wbg.__wbg_newwithstrandinit_b5d168a29a3fd85f = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_next_5b3530e612fde77d = function(arg0) {
+    const ret = arg0.next;
+    return ret;
+  };
+  imports.wbg.__wbg_next_692e82279131b03c = function() {
+    return handleError(function(arg0) {
+      const ret = arg0.next();
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
+    const ret = arg0.node;
+    return ret;
+  };
+  imports.wbg.__wbg_now_0dc4920a47cf7280 = function(arg0) {
+    const ret = arg0.now();
+    return ret;
+  };
+  imports.wbg.__wbg_now_2c95c9de01293173 = function(arg0) {
+    const ret = arg0.now();
+    return ret;
+  };
+  imports.wbg.__wbg_performance_6adc3b899e448a23 = function(arg0) {
+    const ret = arg0.performance;
+    return ret;
+  };
+  imports.wbg.__wbg_performance_7a3ffd0b17f663ad = function(arg0) {
+    const ret = arg0.performance;
+    return ret;
+  };
+  imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
+    const ret = arg0.process;
+    return ret;
+  };
+  imports.wbg.__wbg_prototypesetcall_3d4a26c1ed734349 = function(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+  };
+  imports.wbg.__wbg_queueMicrotask_25d0739ac89e8c88 = function(arg0) {
+    queueMicrotask(arg0);
+  };
+  imports.wbg.__wbg_queueMicrotask_4488407636f5bf24 = function(arg0) {
+    const ret = arg0.queueMicrotask;
+    return ret;
+  };
+  imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() {
+    return handleError(function(arg0, arg1) {
+      arg0.randomFillSync(arg1);
+    }, arguments);
+  };
+  imports.wbg.__wbg_require_60cc747a6bc5215a = function() {
+    return handleError(function() {
+      const ret = module.require;
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_resolve_4055c623acdd6a1b = function(arg0) {
+    const ret = Promise.resolve(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_setTimeout_63008613644b07af = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = arg0.setTimeout(arg1, arg2);
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_setTimeout_7bb3429662ab1e70 = function(arg0, arg1) {
+    const ret = setTimeout(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+  };
+  imports.wbg.__wbg_set_90f6c0f7bd8c0415 = function(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+  };
+  imports.wbg.__wbg_setbody_c8460bdf44147df8 = function(arg0, arg1) {
+    arg0.body = arg1;
+  };
+  imports.wbg.__wbg_setcache_90ca4ad8a8ad40d3 = function(arg0, arg1) {
+    arg0.cache = __wbindgen_enum_RequestCache[arg1];
+  };
+  imports.wbg.__wbg_setcredentials_9cd60d632c9d5dfc = function(arg0, arg1) {
+    arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
+  };
+  imports.wbg.__wbg_setheaders_0052283e2f3503d1 = function(arg0, arg1) {
+    arg0.headers = arg1;
+  };
+  imports.wbg.__wbg_setmethod_9b504d5b855b329c = function(arg0, arg1, arg2) {
+    arg0.method = getStringFromWasm0(arg1, arg2);
+  };
+  imports.wbg.__wbg_setmode_a23e1a2ad8b512f8 = function(arg0, arg1) {
+    arg0.mode = __wbindgen_enum_RequestMode[arg1];
+  };
+  imports.wbg.__wbg_setsignal_8c45ad1247a74809 = function(arg0, arg1) {
+    arg0.signal = arg1;
+  };
+  imports.wbg.__wbg_signal_da4d466ce86118b5 = function(arg0) {
+    const ret = arg0.signal;
+    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.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12 = function() {
+    const ret = typeof global === "undefined" ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+  };
+  imports.wbg.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184 = function() {
+    const ret = typeof globalThis === "undefined" ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+  };
+  imports.wbg.__wbg_static_accessor_SELF_995b214ae681ff99 = function() {
+    const ret = typeof self === "undefined" ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+  };
+  imports.wbg.__wbg_static_accessor_WINDOW_cde3890479c675ea = function() {
+    const ret = typeof window === "undefined" ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+  };
+  imports.wbg.__wbg_status_3fea3036088621d6 = function(arg0) {
+    const ret = arg0.status;
+    return ret;
+  };
+  imports.wbg.__wbg_stringify_b98c93d0a190446a = function() {
+    return handleError(function(arg0) {
+      const ret = JSON.stringify(arg0);
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_subarray_70fd07feefe14294 = function(arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+    return ret;
+  };
+  imports.wbg.__wbg_then_b33a773d723afa3e = function(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+  };
+  imports.wbg.__wbg_then_e22500defe16819f = function(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+  };
+  imports.wbg.__wbg_url_e5720dfacf77b05e = function(arg0, arg1) {
+    const ret = arg1.url;
+    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.__wbg_value_dd9372230531eade = function(arg0) {
+    const ret = arg0.value;
+    return ret;
+  };
+  imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
+    const ret = arg0.versions;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenbigintgetasi64_ac743ece6ab9bba1 = function(arg0, arg1) {
+    const v = arg1;
+    const ret = typeof v === "bigint" ? v : void 0;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+  };
+  imports.wbg.__wbg_wbindgenbooleanget_3fe6f642c7d97746 = function(arg0) {
+    const v = arg0;
+    const ret = typeof v === "boolean" ? v : void 0;
+    return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
+  };
+  imports.wbg.__wbg_wbindgencbdrop_eb10308566512b88 = function(arg0) {
+    const obj = arg0.original;
+    if (obj.cnt-- == 1) {
+      obj.a = 0;
+      return true;
+    }
+    const ret = false;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d = function(arg0, arg1) {
+    const ret = debugString(arg1);
+    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.__wbg_wbindgenin_d7a1ee10933d2d55 = function(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenisbigint_ecb90cc08a5a9154 = function(arg0) {
+    const ret = typeof arg0 === "bigint";
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
+    const ret = typeof arg0 === "function";
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenisobject_307a53c6bd97fbf8 = function(arg0) {
+    const val = arg0;
+    const ret = typeof val === "object" && val !== null;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenisstring_d4fa939789f003b0 = function(arg0) {
+    const ret = typeof arg0 === "string";
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
+    const ret = arg0 === void 0;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenjsvaleq_e6f2ad59ccae1b58 = function(arg0, arg1) {
+    const ret = arg0 === arg1;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenjsvallooseeq_9bec8c9be826bed1 = function(arg0, arg1) {
+    const ret = arg0 == arg1;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgennumberget_f74b4c7525ac05cb = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof obj === "number" ? obj : void 0;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+  };
+  imports.wbg.__wbg_wbindgenstringget_0f16a6ddddef376f = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof obj === "string" ? obj : void 0;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  imports.wbg.__wbindgen_cast_0b55bcbfa1eb963a = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, 1208, __wbg_adapter_14);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_3a2781a2dff3ac5f = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, 1249, __wbg_adapter_6);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_4dfcf3514842f679 = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, 1205, __wbg_adapter_11);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+    const ret = arg0;
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    const ret = arg0;
+    return ret;
+  };
+  imports.wbg.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_export_4;
+    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_init_memory(imports, memory) {
+}
+function __wbg_finalize_init(instance, module2) {
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module2;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+function initSync(module2) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module2 !== "undefined") {
+    if (Object.getPrototypeOf(module2) === Object.prototype) {
+      ({ module: module2 } = module2);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  __wbg_init_memory(imports);
+  if (!(module2 instanceof WebAssembly.Module)) {
+    module2 = new WebAssembly.Module(module2);
+  }
+  const instance = new WebAssembly.Instance(module2, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+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("zerc20_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);
+  }
+  __wbg_init_memory(imports);
+  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+var wasm, cachedUint8ArrayMemory0, cachedTextDecoder, MAX_SAFARI_DECODE_BYTES, numBytesDecoded, WASM_VECTOR_LEN, cachedTextEncoder, cachedDataViewMemory0, CLOSURE_DTORS, __wbindgen_enum_RequestCache, __wbindgen_enum_RequestCredentials, __wbindgen_enum_RequestMode, SingleWithdrawWasmFinalization, SingleWithdrawWasm, WithdrawNovaWasmFinalization, WithdrawNovaWasm, EXPECTED_RESPONSE_TYPES, zerc20_wasm_default;
+var init_zerc20_wasm = __esm({
+  "dist/assets/wasm/web/zerc20_wasm.js"() {
+    "use strict";
+    cachedUint8ArrayMemory0 = null;
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    MAX_SAFARI_DECODE_BYTES = 2146435072;
+    numBytesDecoded = 0;
+    WASM_VECTOR_LEN = 0;
+    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
         };
-        ctx.postMessage(response);
+      };
+    }
+    cachedDataViewMemory0 = null;
+    CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry(
+      (state) => {
+        wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b);
+      }
+    );
+    __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
+    __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
+    __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+    SingleWithdrawWasmFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_singlewithdrawwasm_free(ptr >>> 0, 1));
+    SingleWithdrawWasm = class {
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SingleWithdrawWasmFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_singlewithdrawwasm_free(ptr, 0);
+      }
+      /**
+       * @param {Uint8Array} local_pk_bytes
+       * @param {Uint8Array} local_vk_bytes
+       * @param {Uint8Array} global_pk_bytes
+       * @param {Uint8Array} global_vk_bytes
+       */
+      constructor(local_pk_bytes, local_vk_bytes, global_pk_bytes, global_vk_bytes) {
+        const ptr0 = passArray8ToWasm0(local_pk_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(local_vk_bytes, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(global_pk_bytes, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray8ToWasm0(global_vk_bytes, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.singlewithdrawwasm_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        SingleWithdrawWasmFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /**
+       * @param {any} witness
+       * @returns {any}
+       */
+      prove(witness) {
+        const ret = wasm.singlewithdrawwasm_prove(this.__wbg_ptr, witness);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+    };
+    if (Symbol.dispose) SingleWithdrawWasm.prototype[Symbol.dispose] = SingleWithdrawWasm.prototype.free;
+    WithdrawNovaWasmFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_withdrawnovawasm_free(ptr >>> 0, 1));
+    WithdrawNovaWasm = class {
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WithdrawNovaWasmFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_withdrawnovawasm_free(ptr, 0);
+      }
+      /**
+       * @param {Uint8Array} local_pp_bytes
+       * @param {Uint8Array} local_vp_bytes
+       * @param {Uint8Array} global_pp_bytes
+       * @param {Uint8Array} global_vp_bytes
+       */
+      constructor(local_pp_bytes, local_vp_bytes, global_pp_bytes, global_vp_bytes) {
+        const ptr0 = passArray8ToWasm0(local_pp_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(local_vp_bytes, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(global_pp_bytes, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray8ToWasm0(global_vp_bytes, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.withdrawnovawasm_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WithdrawNovaWasmFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /**
+       * @param {any} z0
+       * @param {any} steps
+       * @returns {any}
+       */
+      prove(z0, steps) {
+        const ret = wasm.withdrawnovawasm_prove(this.__wbg_ptr, z0, steps);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+    };
+    if (Symbol.dispose) WithdrawNovaWasm.prototype[Symbol.dispose] = WithdrawNovaWasm.prototype.free;
+    EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set(["basic", "cors", "default"]);
+    zerc20_wasm_default = __wbg_init;
+  }
+});
+
+// dist/wasm/artifacts.js
+var TeleportArtifactsManager = class {
+  loader;
+  allPromise;
+  singlePromise;
+  batchPromise;
+  /**
+   * Configures the loader function for loading artifacts.
+   * Clears any existing cache when reconfigured.
+   */
+  configure(loader) {
+    this.loader = loader;
+    this.clearCache();
+  }
+  /**
+   * Clears all cached artifacts.
+   */
+  clearCache() {
+    this.allPromise = void 0;
+    this.singlePromise = void 0;
+    this.batchPromise = void 0;
+  }
+  /**
+   * Resets the manager to its initial state.
+   * Useful for testing to ensure clean state between tests.
+   */
+  reset() {
+    this.loader = void 0;
+    this.clearCache();
+  }
+  /**
+   * Returns true if a loader has been configured.
+   */
+  isConfigured() {
+    return this.loader !== void 0;
+  }
+  /**
+   * Primes all artifact caches.
+   */
+  primeAll(artifacts) {
+    this.allPromise = Promise.resolve(artifacts);
+    this.singlePromise = Promise.resolve(artifacts.single);
+    this.batchPromise = Promise.resolve(artifacts.batch);
+  }
+  /**
+   * Primes the single artifacts cache.
+   */
+  primeSingle(artifacts) {
+    this.singlePromise = Promise.resolve(artifacts);
+  }
+  /**
+   * Primes the batch artifacts cache.
+   */
+  primeBatch(artifacts) {
+    this.batchPromise = Promise.resolve(artifacts);
+  }
+  /**
+   * Loads all teleport artifacts.
+   * @param _options Reserved for future use (e.g., custom fetchImpl). Kept for API consistency.
+   * @throws Error if loader is not configured.
+   * @remarks Use this to pre-warm caches at app startup.
+   */
+  async loadAll(_options = {}) {
+    const artifacts = await this.resolveAll();
+    if (!this.singlePromise) {
+      this.singlePromise = Promise.resolve(artifacts.single);
+    }
+    if (!this.batchPromise) {
+      this.batchPromise = Promise.resolve(artifacts.batch);
+    }
+    return artifacts;
+  }
+  /**
+   * Loads single teleport artifacts.
+   * @throws Error if loader is not configured.
+   * @remarks This caches the resolved artifacts.
+   */
+  async loadSingle(options = {}) {
+    if (this.singlePromise) {
+      return this.singlePromise;
+    }
+    const promise = this.loadAll(options).then((artifacts) => artifacts.single);
+    this.singlePromise = promise;
+    return promise;
+  }
+  /**
+   * Loads batch teleport artifacts.
+   * @throws Error if loader is not configured.
+   * @remarks This caches the resolved artifacts.
+   */
+  async loadBatch(options = {}) {
+    if (this.batchPromise) {
+      return this.batchPromise;
+    }
+    const promise = this.loadAll(options).then((artifacts) => artifacts.batch);
+    this.batchPromise = promise;
+    return promise;
+  }
+  requireLoader() {
+    if (!this.loader) {
+      throw new Error("Teleport artifact loader is not configured. Call configureTeleportArtifactsLoader() first.");
+    }
+    return this.loader;
+  }
+  async resolveAll() {
+    if (!this.allPromise) {
+      const loader = this.requireLoader();
+      this.allPromise = Promise.resolve().then(() => loader());
+    }
+    return this.allPromise;
+  }
+};
+var defaultManager = new TeleportArtifactsManager();
+function primeSingleTeleportArtifacts(artifacts) {
+  defaultManager.primeSingle(artifacts);
+}
+function primeBatchTeleportArtifacts(artifacts) {
+  defaultManager.primeBatch(artifacts);
+}
+async function loadSingleTeleportArtifacts(options = {}) {
+  return defaultManager.loadSingle(options);
+}
+async function loadBatchTeleportArtifacts(options = {}) {
+  return defaultManager.loadBatch(options);
+}
+
+// dist/utils/hex.js
+import { bytesToHex as viemBytesToHex, hexToBytes as viemHexToBytes } from "viem";
+function ensureEvenHex(hex) {
+  if (hex.length === 0) {
+    return "00";
+  }
+  return hex.length % 2 === 0 ? hex : `0${hex}`;
+}
+function bytesToHex(bytes) {
+  return viemBytesToHex(bytes);
+}
+function normalizeHex(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      throw new Error("normalizeHex: empty string provided");
+    }
+    const lower = trimmed.startsWith("0X") ? `0x${trimmed.slice(2)}` : trimmed;
+    if (lower.startsWith("0x")) {
+      return `0x${ensureEvenHex(lower.slice(2).toLowerCase())}`;
+    }
+    return `0x${ensureEvenHex(lower.toLowerCase())}`;
+  }
+  if (typeof value === "bigint") {
+    return normalizeHex(value.toString(16));
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new Error(`normalizeHex: expected integer number, received ${value}`);
+    }
+    return normalizeHex(value.toString(16));
+  }
+  if (value instanceof Uint8Array) {
+    return bytesToHex(value);
+  }
+  if (value && typeof value === "object") {
+    if (typeof value.toHexString === "function") {
+      return normalizeHex(value.toHexString());
+    }
+    if (typeof value._hex === "string") {
+      return normalizeHex(value._hex);
+    }
+  }
+  throw new Error("normalizeHex: unsupported value type");
+}
+function hexToBytes(value) {
+  const normalized = normalizeHex(value);
+  if (normalized === "0x") {
+    return new Uint8Array();
+  }
+  return viemHexToBytes(normalized);
+}
+function toBigInt(value) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new Error(`toBigInt: expected integer number, received ${value}`);
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      throw new Error("toBigInt: empty string provided");
+    }
+    if (trimmed.startsWith("0x") || trimmed.startsWith("0X")) {
+      return BigInt(trimmed);
+    }
+    return BigInt(trimmed);
+  }
+  throw new Error("toBigInt: unsupported value type");
+}
+
+// dist/wasm/loader.js
+var DEFAULT_WASM_FILENAME = "assets/wasm/web/zerc20_wasm_bg.wasm";
+var BUNDLED_WASM_URL = new URL("../assets/wasm/web/zerc20_wasm_bg.wasm", import.meta.url).toString();
+function isNodeRuntime() {
+  return typeof process !== "undefined" && typeof process.versions?.node === "string";
+}
+var WasmBindingsLoader = class {
+  cache;
+  promise;
+  resolver;
+  constructor(options = {}) {
+    this.resolver = options.resolver ?? (() => resolveBindings());
+  }
+  /**
+   * Gets or loads the WASM bindings with caching.
+   * Returns cached bindings if available, otherwise loads them.
+   */
+  async getOrLoad() {
+    if (this.cache) {
+      return this.cache;
+    }
+    if (!this.promise) {
+      this.promise = this.resolver();
+    }
+    this.cache = await this.promise;
+    return this.cache;
+  }
+  /**
+   * Returns true if bindings are already cached.
+   */
+  isCached() {
+    return this.cache !== void 0;
+  }
+  /**
+   * Resets the loader to its initial state.
+   * Useful for testing to ensure clean state between tests.
+   */
+  reset() {
+    this.cache = void 0;
+    this.promise = void 0;
+  }
+  /**
+   * Primes the cache with pre-loaded bindings.
+   * Useful for testing or when bindings are loaded externally.
+   */
+  prime(bindings) {
+    this.cache = bindings;
+    this.promise = Promise.resolve(bindings);
+  }
+};
+async function resolveBindings() {
+  if (isNodeRuntime()) {
+    return loadNodeBindings();
+  }
+  return Promise.resolve().then(() => (init_zerc20_wasm(), zerc20_wasm_exports));
+}
+async function loadNodeBindings() {
+  const { createRequire } = await loadNodeModule();
+  const require2 = createRequire(import.meta.url);
+  return require2("../assets/wasm/node/zerc20_wasm.js");
+}
+async function loadNodeModule() {
+  const specifiers = ["node:module", "module"];
+  let lastError;
+  for (const specifier of specifiers) {
+    try {
+      const mod = await import(specifier);
+      return mod;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError ?? new Error("failed to load node:module for wasm bindings");
+}
+function requiresExplicitInit(bindings) {
+  return typeof bindings.default === "function";
+}
+var defaultLoader = new WasmBindingsLoader();
+async function getOrLoadBindings() {
+  return defaultLoader.getOrLoad();
+}
+
+// dist/wasm/serialization.js
+function asSecretAndTweak(value) {
+  const candidate = value;
+  if (!candidate || typeof candidate.secret !== "string" || typeof candidate.tweak !== "string") {
+    throw new Error("unexpected secret/tweak payload from wasm");
+  }
+  return {
+    secret: normalizeHex(candidate.secret),
+    tweak: normalizeHex(candidate.tweak)
+  };
+}
+function asBurnArtifacts(value) {
+  const raw = value;
+  if (!raw || typeof raw.burnAddress !== "string" || typeof raw.secret !== "string") {
+    throw new Error("unexpected burn artifacts payload from wasm");
+  }
+  const recipient = raw.generalRecipient;
+  if (!recipient || typeof recipient.address !== "string") {
+    throw new Error("missing general recipient payload from wasm");
+  }
+  const tweakSource = raw.tweak ?? recipient.tweak;
+  if (typeof tweakSource !== "string") {
+    throw new Error("missing burn tweak payload from wasm");
+  }
+  return {
+    burnAddress: normalizeHex(raw.burnAddress),
+    fullBurnAddress: normalizeHex(raw.fullBurnAddress),
+    secret: normalizeHex(raw.secret),
+    tweak: normalizeHex(tweakSource),
+    generalRecipient: {
+      chainId: toBigInt(recipient.chainId ?? 0),
+      address: normalizeHex(recipient.address),
+      tweak: normalizeHex(recipient.tweak),
+      fr: normalizeHex(recipient.fr),
+      u256: normalizeHex(recipient.u256)
+    }
+  };
+}
+function copyRpcUrls(urls, label) {
+  if (!Array.isArray(urls) || urls.length === 0) {
+    throw new Error(`${label} must provide at least one RPC URL`);
+  }
+  return urls.map((url, idx) => {
+    if (typeof url !== "string" || url.trim().length === 0) {
+      throw new Error(`${label} RPC URL at index ${idx} must be a non-empty string`);
+    }
+    return url.trim();
+  });
+}
+function serializeHubEntry(entry) {
+  return {
+    hub_address: normalizeHex(entry.hubAddress),
+    chain_id: entry.chainId,
+    rpc_urls: copyRpcUrls(entry.rpcUrls, "hub.rpcUrls")
+  };
+}
+function serializeTokenEntry(entry) {
+  return {
+    label: entry.label,
+    token_address: normalizeHex(entry.tokenAddress),
+    verifier_address: normalizeHex(entry.verifierAddress),
+    minter_address: entry.minterAddress ? normalizeHex(entry.minterAddress) : void 0,
+    chain_id: entry.chainId,
+    deployed_block_number: entry.deployedBlockNumber,
+    rpc_urls: copyRpcUrls(entry.rpcUrls, `${entry.label}.rpcUrls`),
+    legacy_tx: entry.legacyTx ?? false
+  };
+}
+function serializeAggregationTreeState(state) {
+  return {
+    latestAggSeq: state.latestAggSeq,
+    aggregationRoot: normalizeHex(state.aggregationRoot),
+    snapshot: state.snapshot.map((value) => normalizeHex(value)),
+    transferTreeIndices: state.transferTreeIndices.map((value) => value),
+    chainIds: state.chainIds.map((value) => value)
+  };
+}
+function serializeIndexedEvent(event) {
+  return {
+    event_index: event.eventIndex,
+    from: normalizeHex(event.from),
+    to: normalizeHex(event.to),
+    value: normalizeHex(event.value),
+    eth_block_number: event.ethBlockNumber
+  };
+}
+function serializeChainEvents(entry) {
+  return {
+    chainId: entry.chainId,
+    events: entry.events.map(serializeIndexedEvent)
+  };
+}
+function serializeLocalTeleportProof(proof) {
+  return {
+    treeIndex: proof.treeIndex,
+    event: serializeIndexedEvent(proof.event),
+    siblings: proof.siblings.map((value) => normalizeHex(value))
+  };
+}
+function serializeChainLocalTeleportProofs(entry) {
+  return {
+    chainId: entry.chainId,
+    proofs: entry.proofs.map(serializeLocalTeleportProof)
+  };
+}
+function deserializeAggregationTreeState(raw) {
+  return {
+    latestAggSeq: toBigInt(raw.latestAggSeq),
+    aggregationRoot: normalizeHex(raw.aggregationRoot),
+    snapshot: raw.snapshot.map((value) => normalizeHex(value)),
+    transferTreeIndices: raw.transferTreeIndices.map((value) => toBigInt(value)),
+    chainIds: raw.chainIds.map((value) => toBigInt(value))
+  };
+}
+function deserializeIndexedEvent(raw) {
+  return {
+    eventIndex: toBigInt(raw.event_index),
+    from: normalizeHex(raw.from),
+    to: normalizeHex(raw.to),
+    value: toBigInt(raw.value),
+    ethBlockNumber: toBigInt(raw.eth_block_number)
+  };
+}
+function deserializeChainEvents(raw) {
+  return {
+    chainId: toBigInt(raw.chainId),
+    events: raw.events.map(deserializeIndexedEvent)
+  };
+}
+function deserializeEventsWithEligibility(raw) {
+  return {
+    eligible: raw.eligible.map(deserializeIndexedEvent),
+    ineligible: raw.ineligible.map(deserializeIndexedEvent)
+  };
+}
+function deserializeSeparatedChainEvents(raw) {
+  return {
+    chainId: toBigInt(raw.chainId),
+    events: deserializeEventsWithEligibility(raw.events)
+  };
+}
+function deserializeLocalTeleportProof(raw) {
+  return {
+    treeIndex: toBigInt(raw.treeIndex),
+    event: deserializeIndexedEvent(raw.event),
+    siblings: raw.siblings.map((value) => normalizeHex(value))
+  };
+}
+function deserializeGlobalTeleportProof(raw) {
+  return {
+    event: deserializeIndexedEvent(raw.event),
+    siblings: raw.siblings.map((value) => normalizeHex(value)),
+    leafIndex: toBigInt(raw.leafIndex)
+  };
+}
+
+// dist/constants.js
+var AGGREGATION_TREE_HEIGHT = 6;
+var TRANSFER_TREE_HEIGHT = 40;
+var GLOBAL_TRANSFER_TREE_HEIGHT = TRANSFER_TREE_HEIGHT + AGGREGATION_TREE_HEIGHT;
+var NUM_BATCH_INVOICES = 10;
+var DEFAULT_DECIDER_TIMEOUT_MS = 5 * 60 * 1e3;
+
+// dist/wasm/helpers.js
+function normalizeOverride(url) {
+  if (!url) {
+    return void 0;
+  }
+  const trimmed = url.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function ensureTrailingSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function logWasmFallbackWarning(url, error) {
+  if (typeof console === "undefined" || typeof console.warn !== "function") {
+    return;
+  }
+  console.warn(`zerc20 wasm failed to load from '${url}'. Falling back to the next candidate.`, error);
+}
+function formatError(error) {
+  if (!error) {
+    return "unknown error";
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function assertValidInvoiceSubId(subId) {
+  if (!Number.isFinite(subId) || !Number.isInteger(subId)) {
+    throw new Error("subId must be a finite integer");
+  }
+  if (subId < 0 || subId >= NUM_BATCH_INVOICES) {
+    throw new Error(`subId must be between 0 and ${NUM_BATCH_INVOICES - 1}`);
+  }
+}
+function toSafeNumber(value, label) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+      throw new Error(`${label} must be a finite integer`);
+    }
+    if (value < 0) {
+      throw new Error(`${label} must be non-negative`);
+    }
+    return value;
+  }
+  if (value < 0n) {
+    throw new Error(`${label} must be non-negative`);
+  }
+  const asNumber = Number(value);
+  if (!Number.isFinite(asNumber) || BigInt(asNumber) !== value) {
+    throw new Error(`${label} exceeds JavaScript safe integer range`);
+  }
+  return asNumber;
+}
+
+// dist/wasm/runtime.js
+var WasmRuntime = class {
+  locator;
+  overrideUrl;
+  initPromise;
+  wasmBindings;
+  /**
+   * Create a new WASM runtime instance.
+   * @remarks
+   * - In Node.js, the WASM bindings are loaded from the bundled node build.
+   * - In browsers, the runtime lazily initializes on first use; call {@link ready} to pre-initialize.
+   */
+  constructor(options = {}) {
+    this.locator = { ...options };
+    this.overrideUrl = normalizeOverride(options.url);
+  }
+  /**
+   * Replace the locator options used to resolve the WASM binary.
+   * @remarks This resets any in-flight initialization so a subsequent call will re-initialize.
+   */
+  configure(options) {
+    this.locator = { ...options };
+    this.overrideUrl = normalizeOverride(options.url);
+    this.initPromise = void 0;
+  }
+  /**
+   * Override the resolved WASM URL.
+   * @remarks This takes precedence over `baseUrl`/`wasmFilename` resolution.
+   */
+  setOverrideUrl(url) {
+    this.overrideUrl = normalizeOverride(url);
+    this.initPromise = void 0;
+  }
+  /**
+   * Ensure the WASM runtime is initialized and ready to use.
+   * @remarks
+   * This is optional in Node.js (bindings are available immediately), but recommended in browsers
+   * to surface initialization errors early.
+   */
+  async ready() {
+    await this.ensureReady();
+  }
+  async getSeedMessage() {
+    const wasm3 = await this.readyBindings();
+    return wasm3.seed_message();
+  }
+  async derivePaymentAdvice(seedHex, paymentAdviceIdHex, recipientChainId, recipientAddress) {
+    const wasm3 = await this.readyBindings();
+    return asSecretAndTweak(wasm3.derive_payment_advice(normalizeHex(seedHex), normalizeHex(paymentAdviceIdHex), toBigInt(recipientChainId), normalizeHex(recipientAddress)));
+  }
+  async deriveInvoiceSingle(seedHex, invoiceIdHex, recipientChainId, recipientAddress) {
+    const wasm3 = await this.readyBindings();
+    return asSecretAndTweak(wasm3.derive_invoice_single(normalizeHex(seedHex), normalizeHex(invoiceIdHex), toBigInt(recipientChainId), normalizeHex(recipientAddress)));
+  }
+  async deriveInvoiceBatch(seedHex, invoiceIdHex, subId, recipientChainId, recipientAddress) {
+    assertValidInvoiceSubId(subId);
+    const wasm3 = await this.readyBindings();
+    return asSecretAndTweak(wasm3.derive_invoice_batch(normalizeHex(seedHex), normalizeHex(invoiceIdHex), subId, toBigInt(recipientChainId), normalizeHex(recipientAddress)));
+  }
+  async buildFullBurnAddress(recipientChainId, recipientAddress, secretHex, tweakHex) {
+    const wasm3 = await this.readyBindings();
+    const result = wasm3.build_full_burn_address(toBigInt(recipientChainId), normalizeHex(recipientAddress), normalizeHex(secretHex), normalizeHex(tweakHex));
+    return asBurnArtifacts(result);
+  }
+  async decodeFullBurnAddress(payloadHex) {
+    const wasm3 = await this.readyBindings();
+    return asBurnArtifacts(wasm3.decode_full_burn_address(normalizeHex(payloadHex)));
+  }
+  async generalRecipientFr(chainId, recipientAddress, tweakHex) {
+    const wasm3 = await this.readyBindings();
+    return normalizeHex(wasm3.general_recipient_fr(toBigInt(chainId), normalizeHex(recipientAddress), normalizeHex(tweakHex)));
+  }
+  async aggregationRoot(snapshot) {
+    const wasm3 = await this.readyBindings();
+    return normalizeHex(wasm3.aggregation_root(snapshot.slice()));
+  }
+  async aggregationMerkleProof(snapshot, index) {
+    const wasm3 = await this.readyBindings();
+    const siblings = wasm3.aggregation_merkle_proof(snapshot.slice(), index);
+    return siblings.map((value) => normalizeHex(value));
+  }
+  async fetchAggregationTreeState(params) {
+    const payload = {
+      hub: serializeHubEntry(params.hub),
+      token: serializeTokenEntry(params.token)
+    };
+    if (params.eventBlockSpan !== void 0) {
+      payload.eventBlockSpan = toSafeNumber(params.eventBlockSpan, "eventBlockSpan");
+    }
+    const wasm3 = await this.readyBindings();
+    const rawState = await wasm3.fetch_aggregation_tree_state(payload);
+    return deserializeAggregationTreeState(rawState);
+  }
+  async fetchTransferEvents(params) {
+    const payload = {
+      indexerUrl: params.indexerUrl,
+      indexerFetchLimit: params.indexerFetchLimit,
+      tokens: params.tokens.map(serializeTokenEntry),
+      burnAddresses: params.burnAddresses.map((address) => normalizeHex(address))
+    };
+    const wasm3 = await this.readyBindings();
+    const rawEvents = await wasm3.fetch_transfer_events(payload);
+    return rawEvents.map((entry) => deserializeChainEvents(entry));
+  }
+  async separateEventsByEligibility(params) {
+    const payload = {
+      aggregationState: serializeAggregationTreeState(params.aggregationState),
+      events: params.events.map(serializeChainEvents)
+    };
+    const wasm3 = await this.readyBindings();
+    const rawSeparated = wasm3.separate_events_by_eligibility(payload);
+    return rawSeparated.map((entry) => deserializeSeparatedChainEvents(entry));
+  }
+  async fetchLocalTeleportMerkleProofs(params) {
+    const payload = {
+      indexerUrl: params.indexerUrl,
+      token: serializeTokenEntry(params.token),
+      treeIndex: toBigInt(params.treeIndex),
+      events: params.events.map(serializeIndexedEvent)
+    };
+    const wasm3 = await this.readyBindings();
+    const rawProofs = await wasm3.fetch_local_teleport_merkle_proofs(payload);
+    return rawProofs.map((proof) => deserializeLocalTeleportProof(proof));
+  }
+  async generateGlobalTeleportMerkleProofs(params) {
+    const payload = {
+      aggregationState: serializeAggregationTreeState(params.aggregationState),
+      proofs: params.chains.map(serializeChainLocalTeleportProofs)
+    };
+    const wasm3 = await this.readyBindings();
+    const rawProofs = wasm3.generate_global_teleport_merkle_proofs(payload);
+    return rawProofs.map((proof) => deserializeGlobalTeleportProof(proof));
+  }
+  async createSingleWithdrawProgram(localPk, localVk, globalPk, globalVk) {
+    const wasm3 = await this.readyBindings();
+    return new wasm3.SingleWithdrawWasm(localPk, localVk, globalPk, globalVk);
+  }
+  async createWithdrawNovaProgram(localPp, localVp, globalPp, globalVp) {
+    const wasm3 = await this.readyBindings();
+    return new wasm3.WithdrawNovaWasm(localPp, localVp, globalPp, globalVp);
+  }
+  async ensureReady() {
+    if (!this.initPromise) {
+      this.initPromise = this.initialize();
+    }
+    await this.initPromise;
+  }
+  async readyBindings() {
+    await this.ensureReady();
+    return this.getBindings();
+  }
+  getBindings() {
+    if (!this.wasmBindings) {
+      throw new Error("zerc20 wasm bindings are not initialized");
+    }
+    return this.wasmBindings;
+  }
+  async initialize() {
+    const bindings = await getOrLoadBindings();
+    if (!requiresExplicitInit(bindings)) {
+      this.wasmBindings = bindings;
+      return;
+    }
+    const candidates = this.resolveCandidateUrls();
+    let lastError;
+    for (let idx = 0; idx < candidates.length; idx++) {
+      const candidate = candidates[idx];
+      try {
+        await bindings.default({ module_or_path: candidate });
+        this.wasmBindings = bindings;
+        return;
+      } catch (error) {
+        lastError = error;
+        if (idx < candidates.length - 1) {
+          logWasmFallbackWarning(candidate, error);
+        }
+      }
+    }
+    throw new Error(`failed to initialize zerc20 wasm: ${formatError(lastError)}`);
+  }
+  resolveCandidateUrls() {
+    const urls = [];
+    if (this.overrideUrl) {
+      urls.push(this.overrideUrl);
+    }
+    const configured = this.resolveConfiguredUrl();
+    if (configured && configured !== this.overrideUrl) {
+      urls.push(configured);
+    }
+    if (!urls.includes(BUNDLED_WASM_URL)) {
+      urls.push(BUNDLED_WASM_URL);
+    }
+    return urls;
+  }
+  resolveConfiguredUrl() {
+    const baseUrl = this.locator.baseUrl;
+    if (!baseUrl) {
+      return void 0;
+    }
+    const wasmFilename = this.locator.wasmFilename ?? DEFAULT_WASM_FILENAME;
+    if (/^https?:\/\//i.test(baseUrl)) {
+      return new URL(wasmFilename, ensureTrailingSlash(baseUrl)).toString();
+    }
+    const globalRef = this.locator.globalObject ?? (typeof globalThis !== "undefined" ? globalThis : void 0);
+    const origin = globalRef?.location?.origin;
+    if (!origin) {
+      throw new Error("WasmRuntime requires a global location.origin when baseUrl is relative");
+    }
+    const prefix = baseUrl.startsWith("/") ? `${origin}${baseUrl}` : `${origin}/${baseUrl}`;
+    return new URL(wasmFilename, ensureTrailingSlash(prefix)).toString();
+  }
+};
+
+// dist/utils/merkle.js
+import * as poseidonLite from "poseidon-lite";
+var BN254_FIELD_MODULUS = BigInt("0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47");
+function resolvePoseidon(mod, functionName) {
+  const defaultExport = mod.default;
+  const nestedDefault = typeof defaultExport === "object" && defaultExport !== null ? defaultExport : void 0;
+  const candidates = [
+    mod[functionName],
+    nestedDefault ? nestedDefault[functionName] : void 0,
+    defaultExport
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "function") {
+      return candidate;
+    }
+  }
+  throw new Error(`poseidon-lite did not expose a usable ${functionName} implementation`);
+}
+var poseidonHash2 = resolvePoseidon(poseidonLite, "poseidon2");
+var poseidonHash3 = resolvePoseidon(poseidonLite, "poseidon3");
+function ensureFieldElement(value, label) {
+  if (value < 0n) {
+    throw new Error(`${label} must be non-negative`);
+  }
+  if (value >= BN254_FIELD_MODULUS) {
+    throw new Error(`${label} exceeds the BN254 field modulus`);
+  }
+  return value;
+}
+function hexToField(value, label) {
+  const normalized = normalizeHex(value);
+  return ensureFieldElement(BigInt(normalized), label);
+}
+function intoField(value, label) {
+  const bigIntValue = typeof value === "bigint" ? value : toBigInt(value);
+  return ensureFieldElement(bigIntValue, label);
+}
+function hashPair(left, right) {
+  const result = poseidonHash2([left, right]);
+  if (typeof result !== "bigint") {
+    throw new Error("poseidon-lite returned a non-bigint result");
+  }
+  return ensureFieldElement(result, "poseidon result");
+}
+function hashTriple(left, middle, right) {
+  const result = poseidonHash3([left, middle, right]);
+  if (typeof result !== "bigint") {
+    throw new Error("poseidon-lite returned a non-bigint result");
+  }
+  return ensureFieldElement(result, "poseidon result");
+}
+function computeLeafHash(fromAddressHex, toAddressHex, value) {
+  const fromField = hexToField(fromAddressHex, "leaf from address");
+  const toField = hexToField(toAddressHex, "leaf to address");
+  const valueField = intoField(value, "leaf value");
+  return hashTriple(fromField, toField, valueField);
+}
+function computeMerkleRootFromSiblings(params) {
+  let state = ensureFieldElement(params.leaf, "leaf");
+  let index = toBigInt(params.leafIndex);
+  if (index < 0n) {
+    throw new Error("leafIndex must be non-negative");
+  }
+  params.siblings.forEach((siblingHex, level) => {
+    const sibling = hexToField(siblingHex, `siblings[${level}]`);
+    if ((index & 1n) === 1n) {
+      state = hashPair(sibling, state);
+    } else {
+      state = hashPair(state, sibling);
+    }
+    index >>= 1n;
+  });
+  return state;
+}
+function verifyGlobalTeleportProofs(args) {
+  const { aggregationRoot, events, proofs: proofs2 } = args;
+  if (events.length !== proofs2.length) {
+    throw new Error("events length must match proofs length for global teleport verification");
+  }
+  if (events.length === 0) {
+    return;
+  }
+  const expectedRoot = hexToField(aggregationRoot, "aggregationRoot");
+  for (let idx = 0; idx < proofs2.length; idx++) {
+    const proof = proofs2[idx];
+    const event = events[idx];
+    const leaf = computeLeafHash(event.from, event.to, event.value);
+    const derivedRoot = computeMerkleRootFromSiblings({
+      leaf,
+      siblings: proof.siblings,
+      leafIndex: proof.leafIndex
+    });
+    if (derivedRoot !== expectedRoot) {
+      const leafLabel = `leafIndex ${proof.leafIndex.toString()} (eventIndex ${event.eventIndex.toString()})`;
+      throw new Error(`merkle proof mismatch for ${leafLabel}`);
+    }
+  }
+}
+
+// dist/zkp/proofUtils.js
+function toFixedHex(value, bytes = 32) {
+  if (value < 0n) {
+    throw new Error("toFixedHex: negative values are not supported");
+  }
+  const hex = value.toString(16).padStart(bytes * 2, "0");
+  return `0x${hex}`;
+}
+function toFieldHex(value) {
+  return toFixedHex(value, 32);
+}
+function toLeafIndexString(index) {
+  return index.toString(10);
+}
+function zeroPadField(value, label) {
+  const normalized = normalizeHex(value);
+  const body = normalized.slice(2);
+  if (!/^[0-9a-f]*$/i.test(body)) {
+    throw new Error(`${label} contains non-hex characters: ${normalized}`);
+  }
+  if (body.length % 2 !== 0) {
+    throw new Error(`${label} must have an even number of hex digits: ${normalized}`);
+  }
+  if (body.length > 64) {
+    throw new Error(`${label} must fit within 32 bytes: ${normalized}`);
+  }
+  return `0x${body.padStart(64, "0")}`;
+}
+function formatFieldElement(value, label) {
+  return zeroPadField(value, label);
+}
+function randomDummySteps() {
+  const MIN_DUMMY_STEPS = 1;
+  const MAX_DUMMY_STEPS = 3;
+  const buffer = new Uint32Array(1);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(buffer);
+    const range = MAX_DUMMY_STEPS - MIN_DUMMY_STEPS + 1;
+    return MIN_DUMMY_STEPS + buffer[0] % range;
+  }
+  return MIN_DUMMY_STEPS;
+}
+function appendDummySteps(steps) {
+  const dummySteps = randomDummySteps();
+  const maxLeaves = 1n << BigInt(GLOBAL_TRANSFER_TREE_HEIGHT);
+  const offset = maxLeaves - 1n - BigInt(dummySteps);
+  for (let i = 0; i < dummySteps; i += 1) {
+    const leafIndex = offset + BigInt(i);
+    steps.push({
+      isDummy: true,
+      from: formatFieldElement("0x0", `dummySteps[${i}].from`),
+      value: formatFieldElement("0x0", `dummySteps[${i}].value`),
+      secret: formatFieldElement("0x0", `dummySteps[${i}].secret`),
+      leafIndex: toLeafIndexString(leafIndex),
+      siblings: Array(GLOBAL_TRANSFER_TREE_HEIGHT).fill(null).map((_, siblingIdx) => formatFieldElement("0x0", `dummySteps[${i}].siblings[${siblingIdx}]`))
+    });
+  }
+}
+function sortProofsByLeafIndex(events, proofs2) {
+  const proofEventPairs = events.map((event, idx) => ({
+    event,
+    proof: proofs2[idx]
+  }));
+  proofEventPairs.sort((a, b) => {
+    if (a.proof.leafIndex < b.proof.leafIndex) {
+      return -1;
+    }
+    if (a.proof.leafIndex > b.proof.leafIndex) {
+      return 1;
+    }
+    return 0;
+  });
+  return {
+    events: proofEventPairs.map((pair) => pair.event),
+    proofs: proofEventPairs.map((pair) => pair.proof)
+  };
+}
+
+// dist/zkp/workerClient.js
+function hasWorkerSupport() {
+  return typeof Worker !== "undefined";
+}
+var ZkpWorkerClient = class {
+  worker = null;
+  failed = false;
+  nextJobId = 0;
+  pendingJobs = /* @__PURE__ */ new Map();
+  createWorkerFn;
+  constructor(options = {}) {
+    this.createWorkerFn = options.createWorker;
+  }
+  /**
+   * Returns true if this client can run jobs (Worker API available and not failed).
+   */
+  canUse() {
+    return hasWorkerSupport() && !this.failed;
+  }
+  /**
+   * Runs a ZKP proof job in the worker.
+   *
+   * **Important:** Always await or catch the returned promise.
+   * Calling `disable()` or `reset()` will reject pending jobs,
+   * which can cause unhandled rejections if not properly awaited.
+   *
+   * @throws Error if worker is not available or has failed.
+   */
+  async runJob(type, payload) {
+    const instance = this.ensureWorker();
+    const jobId = this.nextJobId++;
+    const message = { id: jobId, type, payload };
+    const promise = new Promise((resolve, reject) => {
+      this.pendingJobs.set(jobId, {
+        resolve: (value) => resolve(value),
+        reject
+      });
+    });
+    instance.postMessage(message);
+    return promise;
+  }
+  /**
+   * Disables the worker and rejects all pending jobs.
+   */
+  disable(error) {
+    this.failed = true;
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.pendingJobs.forEach((pending) => pending.reject(error ?? new Error("ZKP worker disabled")));
+    this.pendingJobs.clear();
+  }
+  /**
+   * Resets the client to its initial state. Useful for testing.
+   */
+  reset() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.failed = false;
+    this.nextJobId = 0;
+    this.pendingJobs.clear();
+  }
+  ensureWorker() {
+    if (this.failed) {
+      throw new Error("ZKP worker previously failed and has been disabled");
+    }
+    if (!hasWorkerSupport()) {
+      throw new Error("Web Worker API is not available in this environment");
+    }
+    if (!this.worker) {
+      const instance = this.createWorkerFn ? this.createWorkerFn() : new Worker(new URL("./worker.js", import.meta.url), { type: "module" });
+      instance.addEventListener("message", (event) => this.handleMessage(event));
+      instance.addEventListener("error", (event) => this.handleError(event));
+      this.worker = instance;
+    }
+    return this.worker;
+  }
+  handleMessage(event) {
+    const message = event.data;
+    if (!message || typeof message !== "object") {
+      return;
+    }
+    const pending = this.pendingJobs.get(message.id);
+    if (!pending) {
+      return;
+    }
+    this.pendingJobs.delete(message.id);
+    if (message.type === "result") {
+      pending.resolve(message.result);
+    } else if (message.type === "error") {
+      const error = new Error(message.error?.message ?? "ZKP worker failure");
+      error.stack = message.error?.stack;
+      pending.reject(error);
+    } else {
+      pending.reject(new Error(`ZKP worker returned unexpected message type ${message.type}`));
+    }
+  }
+  handleError(event) {
+    this.pendingJobs.forEach((pending) => pending.reject(event.error ?? new Error("ZKP worker error")));
+    this.pendingJobs.clear();
+    this.failed = true;
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+  }
+};
+var defaultClient = new ZkpWorkerClient();
+function canUseZkpWorker() {
+  return defaultClient.canUse();
+}
+async function runZkpWorkerJob(type, payload) {
+  return defaultClient.runJob(type, payload);
+}
+function disableZkpWorker(error) {
+  defaultClient.disable(error);
+}
+
+// dist/zkp/proofService.js
+var ProofService = class {
+  wasm;
+  /**
+   * Create a proof service bound to a {@link WasmRuntime}.
+   */
+  constructor(wasm3) {
+    this.wasm = wasm3;
+  }
+  /**
+   * Create a single teleport (Groth16) proof for an eligible event.
+   * @remarks
+   * - Verifies global teleport proofs before proving.
+   * - Uses a worker when available; falls back to main thread if the worker fails.
+   * @throws If proof verification fails or the prover fails.
+   */
+  async createSingleTeleportProof(params) {
+    const wasmArtifacts = await loadSingleTeleportArtifacts();
+    if (this.shouldUseWorker()) {
+      try {
+        return await runZkpWorkerJob("singleTeleport", {
+          params,
+          artifacts: wasmArtifacts
+        });
+      } catch (error) {
+        console.warn("[zerc20] Worker single proof failed; falling back to main thread.", error);
+        disableZkpWorker(error);
+      }
+    }
+    return this.computeSingleTeleportProof(params, wasmArtifacts);
+  }
+  /**
+   * Run the Nova batch prover to produce an IVC proof for multiple events.
+   * @remarks
+   * - Requires `events.length === proofs.length` and that each event/proof pair correspond by index.
+   * - Uses a worker when available; falls back to main thread if the worker fails.
+   * @throws If inputs are invalid, proof verification fails, or the prover fails.
+   */
+  async runNovaProver(params) {
+    const wasmArtifacts = await loadBatchTeleportArtifacts();
+    if (this.shouldUseWorker()) {
+      try {
+        return await runZkpWorkerJob("nova", {
+          params,
+          artifacts: wasmArtifacts
+        });
+      } catch (error) {
+        console.warn("[zerc20] Worker nova prover failed; falling back to main thread.", error);
+        disableZkpWorker(error);
+      }
+    }
+    return this.computeNovaProof(params, wasmArtifacts);
+  }
+  shouldUseWorker() {
+    return canUseZkpWorker();
+  }
+  async computeSingleTeleportProof(params, wasmArtifacts) {
+    verifyGlobalTeleportProofs({
+      aggregationRoot: params.aggregationState.aggregationRoot,
+      events: [params.event],
+      proofs: [params.proof]
+    });
+    const wasm3 = await this.wasm.createSingleWithdrawProgram(wasmArtifacts.localPk, wasmArtifacts.localVk, wasmArtifacts.globalPk, wasmArtifacts.globalVk);
+    const zeroField = formatFieldElement("0x0", "delta");
+    const witness = {
+      merkleRoot: formatFieldElement(params.aggregationState.aggregationRoot, "merkleRoot"),
+      recipient: formatFieldElement(params.recipientFr, "recipient"),
+      withdrawValue: formatFieldElement(toFieldHex(params.event.value), "withdrawValue"),
+      from: formatFieldElement(params.event.from, "from"),
+      value: formatFieldElement(toFieldHex(params.event.value), "value"),
+      delta: zeroField,
+      secret: formatFieldElement(params.secretHex, "secret"),
+      leafIndex: toLeafIndexString(params.proof.leafIndex),
+      siblings: params.proof.siblings.map((sibling, idx) => formatFieldElement(sibling, `proof.siblings[${idx}]`))
+    };
+    try {
+      const result = await wasm3.prove(witness);
+      return {
+        proofCalldata: normalizeHex(result.proofCalldata),
+        publicInputs: result.publicInputs.map((input) => normalizeHex(input)),
+        treeDepth: result.treeDepth
+      };
+    } catch (error) {
+      console.error("[zerc20] createSingleTeleportProof failed", witness, error);
+      throw new Error(error instanceof Error ? `single teleport proof failed: ${error.message}` : `single teleport proof failed: ${String(error)}`);
+    }
+  }
+  async computeNovaProof(params, wasmArtifacts) {
+    if (params.proofs.length !== params.events.length) {
+      throw new Error("events length must match proofs length for batch teleport");
+    }
+    const { events: sortedEvents, proofs: sortedProofs } = sortProofsByLeafIndex(params.events, params.proofs);
+    verifyGlobalTeleportProofs({
+      aggregationRoot: params.aggregationState.aggregationRoot,
+      events: sortedEvents,
+      proofs: sortedProofs
+    });
+    const wasm3 = await this.wasm.createWithdrawNovaProgram(wasmArtifacts.localPp, wasmArtifacts.localVp, wasmArtifacts.globalPp, wasmArtifacts.globalVp);
+    const z0 = [
+      formatFieldElement(params.aggregationState.aggregationRoot, "z0[0]"),
+      formatFieldElement(params.recipientFr, "z0[1]"),
+      formatFieldElement("0x0", "z0[2]"),
+      formatFieldElement("0x0", "z0[3]")
+    ];
+    const steps = sortedEvents.map((event, idx) => ({
+      isDummy: false,
+      from: formatFieldElement(event.from, `events[${idx}].from`),
+      value: formatFieldElement(toFieldHex(event.value), `events[${idx}].value`),
+      secret: formatFieldElement(params.secretHex, `events[${idx}].secret`),
+      leafIndex: toLeafIndexString(sortedProofs[idx].leafIndex),
+      siblings: sortedProofs[idx].siblings.map((sibling, siblingIdx) => formatFieldElement(sibling, `proofs[${idx}].siblings[${siblingIdx}]`))
+    }));
+    appendDummySteps(steps);
+    try {
+      const proofResult = await wasm3.prove(z0, steps);
+      const ivcProofBytes = hexToBytes(proofResult.ivcProof);
+      return {
+        ivcProof: ivcProofBytes,
+        finalState: proofResult.finalState.map((value) => normalizeHex(value)),
+        steps: proofResult.steps
+      };
+    } catch (error) {
+      console.error("[zerc20] runNovaProver failed", { z0 }, { steps }, error);
+      throw new Error(error instanceof Error ? `batch teleport proof failed: ${error.message}` : `batch teleport proof failed: ${String(error)}`);
+    }
+  }
+};
+
+// dist/zkp/worker.js
+disableZkpWorker(new Error("Workers are not used inside a worker context"));
+var wasm2 = new WasmRuntime();
+var proofs = new ProofService(wasm2);
+var ctx = self;
+ctx.addEventListener("message", async (event) => {
+  const message = event.data;
+  if (!message) {
+    return;
+  }
+  try {
+    if (message.type === "singleTeleport") {
+      primeSingleTeleportArtifacts(message.payload.artifacts);
+      const result = await proofs.createSingleTeleportProof(message.payload.params);
+      const response = {
+        id: message.id,
+        type: "result",
+        result
+      };
+      ctx.postMessage(response);
+      return;
+    }
+    if (message.type === "nova") {
+      primeBatchTeleportArtifacts(message.payload.artifacts);
+      const result = await proofs.runNovaProver(message.payload.params);
+      const response = {
+        id: message.id,
+        type: "result",
+        result
+      };
+      ctx.postMessage(response);
+      return;
     }
+    throw new Error(`Unknown ZKP worker job type ${message.type}`);
+  } catch (error) {
+    const response = {
+      id: message.id,
+      type: "error",
+      error: {
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      }
+    };
+    ctx.postMessage(response);
+  }
 });
-//# sourceMappingURL=worker.js.map