@izi-noir/sdk 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -125,6 +125,873 @@ authors = [""]
   }
 });
 
+// src/wasm/nodejs/arkworks_groth16_wasm.js
+var arkworks_groth16_wasm_exports = {};
+function acir_to_r1cs_info(acir_json) {
+  const ptr0 = passStringToWasm0(acir_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.acir_to_r1cs_info(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function init_panic_hook() {
+  wasm.init_panic_hook();
+}
+function prove(proving_key_b64, acir_json, witness_json) {
+  const ptr0 = passStringToWasm0(proving_key_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(acir_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(witness_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.prove(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function prove_from_r1cs(proving_key_b64, r1cs_json, witness_json) {
+  const ptr0 = passStringToWasm0(proving_key_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(r1cs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(witness_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.prove_from_r1cs(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function setup(acir_json) {
+  const ptr0 = passStringToWasm0(acir_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.setup(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function setup_from_r1cs(r1cs_json) {
+  const ptr0 = passStringToWasm0(r1cs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.setup_from_r1cs(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function verify(verifying_key_b64, proof_b64, public_inputs_json) {
+  const ptr0 = passStringToWasm0(verifying_key_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(proof_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(public_inputs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.verify(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return ret[0] !== 0;
+}
+function verify_gnark(verifying_key_gnark_b64, proof_gnark_b64, public_inputs_gnark_b64, num_public_inputs) {
+  const ptr0 = passStringToWasm0(verifying_key_gnark_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(proof_gnark_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(public_inputs_gnark_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.verify_gnark(ptr0, len0, ptr1, len1, ptr2, len2, num_public_inputs);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return ret[0] !== 0;
+}
+function version() {
+  let deferred1_0;
+  let deferred1_1;
+  try {
+    const ret = wasm.version();
+    deferred1_0 = ret[0];
+    deferred1_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+  }
+}
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+      const ret = Error(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __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);
+    },
+    __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
+      const ret = typeof arg0 === "function";
+      return ret;
+    },
+    __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
+      const val = arg0;
+      const ret = typeof val === "object" && val !== null;
+      return ret;
+    },
+    __wbg___wbindgen_is_string_cd444516edc5b180: function(arg0) {
+      const ret = typeof arg0 === "string";
+      return ret;
+    },
+    __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
+      const ret = arg0 === void 0;
+      return ret;
+    },
+    __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg_call_389efe28435a9388: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_4708e0c13bdc8e95: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_crypto_86f2631e91b51511: function(arg0) {
+      const ret = arg0.crypto;
+      return ret;
+    },
+    __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);
+      }
+    },
+    __wbg_getRandomValues_b3f15fcbfabb0f8b: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.getRandomValues(arg1);
+      }, arguments);
+    },
+    __wbg_length_32ed9a279acd054c: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_msCrypto_d562bbe83e0d4b91: function(arg0) {
+      const ret = arg0.msCrypto;
+      return ret;
+    },
+    __wbg_new_361308b2356cecd0: function() {
+      const ret = new Object();
+      return ret;
+    },
+    __wbg_new_3eb36ae241fe6f44: function() {
+      const ret = new Array();
+      return ret;
+    },
+    __wbg_new_8a6f238a6ece86ea: function() {
+      const ret = new Error();
+      return ret;
+    },
+    __wbg_new_no_args_1c7c842f08d00ebb: function(arg0, arg1) {
+      const ret = new Function(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_with_length_a2c39cbe88fd8ff1: function(arg0) {
+      const ret = new Uint8Array(arg0 >>> 0);
+      return ret;
+    },
+    __wbg_node_e1f24f89a7336c2e: function(arg0) {
+      const ret = arg0.node;
+      return ret;
+    },
+    __wbg_process_3975fd6c72f520aa: function(arg0) {
+      const ret = arg0.process;
+      return ret;
+    },
+    __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
+      Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    },
+    __wbg_randomFillSync_f8c153b79f285817: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.randomFillSync(arg1);
+      }, arguments);
+    },
+    __wbg_require_b74f47fc2d022fd6: function() {
+      return handleError(function() {
+        const ret = module.require;
+        return ret;
+      }, arguments);
+    },
+    __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
+      arg0[arg1] = arg2;
+    },
+    __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
+      arg0[arg1 >>> 0] = arg2;
+    },
+    __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);
+    },
+    __wbg_static_accessor_GLOBAL_12837167ad935116: function() {
+      const ret = typeof global === "undefined" ? null : global;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f: function() {
+      const ret = typeof globalThis === "undefined" ? null : globalThis;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_SELF_a621d3dfbb60d0ce: function() {
+      const ret = typeof self === "undefined" ? null : self;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_WINDOW_f8727f0cf888e0bd: function() {
+      const ret = typeof window === "undefined" ? null : window;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_subarray_a96e1fef17ed23cb: function(arg0, arg1, arg2) {
+      const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+      return ret;
+    },
+    __wbg_versions_4e31226f5e8dc909: function(arg0) {
+      const ret = arg0.versions;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000001: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+      const ret = getArrayU8FromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+      const ret = getStringFromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000004: function(arg0) {
+      const ret = BigInt.asUintN(64, arg0);
+      return ret;
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, void 0);
+      table.set(offset + 0, void 0);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    }
+  };
+  return {
+    __proto__: null,
+    "./arkworks_groth16_wasm_bg.js": import0
+  };
+}
+function addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+function decodeText(ptr, len) {
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedDataViewMemory0, cachedUint8ArrayMemory0, cachedTextDecoder, cachedTextEncoder, WASM_VECTOR_LEN, wasmPath, wasmBytes, wasmModule, wasm;
+var init_arkworks_groth16_wasm = __esm({
+  "src/wasm/nodejs/arkworks_groth16_wasm.js"() {
+    "use strict";
+    exports.acir_to_r1cs_info = acir_to_r1cs_info;
+    exports.init_panic_hook = init_panic_hook;
+    exports.prove = prove;
+    exports.prove_from_r1cs = prove_from_r1cs;
+    exports.setup = setup;
+    exports.setup_from_r1cs = setup_from_r1cs;
+    exports.verify = verify;
+    exports.verify_gnark = verify_gnark;
+    exports.version = version;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    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
+        };
+      };
+    }
+    WASM_VECTOR_LEN = 0;
+    wasmPath = `${__dirname}/arkworks_groth16_wasm_bg.wasm`;
+    wasmBytes = require("fs").readFileSync(wasmPath);
+    wasmModule = new WebAssembly.Module(wasmBytes);
+    wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+    wasm.__wbindgen_start();
+  }
+});
+
+// src/wasm/web/arkworks_groth16_wasm.js
+var arkworks_groth16_wasm_exports2 = {};
+__export(arkworks_groth16_wasm_exports2, {
+  acir_to_r1cs_info: () => acir_to_r1cs_info2,
+  default: () => __wbg_init,
+  initSync: () => initSync,
+  init_panic_hook: () => init_panic_hook2,
+  prove: () => prove2,
+  prove_from_r1cs: () => prove_from_r1cs2,
+  setup: () => setup2,
+  setup_from_r1cs: () => setup_from_r1cs2,
+  verify: () => verify2,
+  verify_gnark: () => verify_gnark2,
+  version: () => version2
+});
+function acir_to_r1cs_info2(acir_json) {
+  const ptr0 = passStringToWasm02(acir_json, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN2;
+  const ret = wasm2.acir_to_r1cs_info(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function init_panic_hook2() {
+  wasm2.init_panic_hook();
+}
+function prove2(proving_key_b64, acir_json, witness_json) {
+  const ptr0 = passStringToWasm02(proving_key_b64, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN2;
+  const ptr1 = passStringToWasm02(acir_json, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN2;
+  const ptr2 = passStringToWasm02(witness_json, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN2;
+  const ret = wasm2.prove(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function prove_from_r1cs2(proving_key_b64, r1cs_json, witness_json) {
+  const ptr0 = passStringToWasm02(proving_key_b64, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN2;
+  const ptr1 = passStringToWasm02(r1cs_json, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN2;
+  const ptr2 = passStringToWasm02(witness_json, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN2;
+  const ret = wasm2.prove_from_r1cs(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function setup2(acir_json) {
+  const ptr0 = passStringToWasm02(acir_json, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN2;
+  const ret = wasm2.setup(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function setup_from_r1cs2(r1cs_json) {
+  const ptr0 = passStringToWasm02(r1cs_json, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN2;
+  const ret = wasm2.setup_from_r1cs(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return takeFromExternrefTable02(ret[0]);
+}
+function verify2(verifying_key_b64, proof_b64, public_inputs_json) {
+  const ptr0 = passStringToWasm02(verifying_key_b64, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN2;
+  const ptr1 = passStringToWasm02(proof_b64, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN2;
+  const ptr2 = passStringToWasm02(public_inputs_json, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN2;
+  const ret = wasm2.verify(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return ret[0] !== 0;
+}
+function verify_gnark2(verifying_key_gnark_b64, proof_gnark_b64, public_inputs_gnark_b64, num_public_inputs) {
+  const ptr0 = passStringToWasm02(verifying_key_gnark_b64, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN2;
+  const ptr1 = passStringToWasm02(proof_gnark_b64, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN2;
+  const ptr2 = passStringToWasm02(public_inputs_gnark_b64, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN2;
+  const ret = wasm2.verify_gnark(ptr0, len0, ptr1, len1, ptr2, len2, num_public_inputs);
+  if (ret[2]) {
+    throw takeFromExternrefTable02(ret[1]);
+  }
+  return ret[0] !== 0;
+}
+function version2() {
+  let deferred1_0;
+  let deferred1_1;
+  try {
+    const ret = wasm2.version();
+    deferred1_0 = ret[0];
+    deferred1_1 = ret[1];
+    return getStringFromWasm02(ret[0], ret[1]);
+  } finally {
+    wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+  }
+}
+function __wbg_get_imports2() {
+  const import0 = {
+    __proto__: null,
+    __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+      const ret = Error(getStringFromWasm02(arg0, arg1));
+      return ret;
+    },
+    __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
+      const ret = String(arg1);
+      const ptr1 = passStringToWasm02(ret, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN2;
+      getDataViewMemory02().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory02().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
+      const ret = typeof arg0 === "function";
+      return ret;
+    },
+    __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
+      const val = arg0;
+      const ret = typeof val === "object" && val !== null;
+      return ret;
+    },
+    __wbg___wbindgen_is_string_cd444516edc5b180: function(arg0) {
+      const ret = typeof arg0 === "string";
+      return ret;
+    },
+    __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
+      const ret = arg0 === void 0;
+      return ret;
+    },
+    __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+      throw new Error(getStringFromWasm02(arg0, arg1));
+    },
+    __wbg_call_389efe28435a9388: function() {
+      return handleError2(function(arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_4708e0c13bdc8e95: function() {
+      return handleError2(function(arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_crypto_86f2631e91b51511: function(arg0) {
+      const ret = arg0.crypto;
+      return ret;
+    },
+    __wbg_error_7534b8e9a36f1ab4: function(arg0, arg1) {
+      let deferred0_0;
+      let deferred0_1;
+      try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm02(arg0, arg1));
+      } finally {
+        wasm2.__wbindgen_free(deferred0_0, deferred0_1, 1);
+      }
+    },
+    __wbg_getRandomValues_b3f15fcbfabb0f8b: function() {
+      return handleError2(function(arg0, arg1) {
+        arg0.getRandomValues(arg1);
+      }, arguments);
+    },
+    __wbg_length_32ed9a279acd054c: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_msCrypto_d562bbe83e0d4b91: function(arg0) {
+      const ret = arg0.msCrypto;
+      return ret;
+    },
+    __wbg_new_361308b2356cecd0: function() {
+      const ret = new Object();
+      return ret;
+    },
+    __wbg_new_3eb36ae241fe6f44: function() {
+      const ret = new Array();
+      return ret;
+    },
+    __wbg_new_8a6f238a6ece86ea: function() {
+      const ret = new Error();
+      return ret;
+    },
+    __wbg_new_no_args_1c7c842f08d00ebb: function(arg0, arg1) {
+      const ret = new Function(getStringFromWasm02(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_with_length_a2c39cbe88fd8ff1: function(arg0) {
+      const ret = new Uint8Array(arg0 >>> 0);
+      return ret;
+    },
+    __wbg_node_e1f24f89a7336c2e: function(arg0) {
+      const ret = arg0.node;
+      return ret;
+    },
+    __wbg_process_3975fd6c72f520aa: function(arg0) {
+      const ret = arg0.process;
+      return ret;
+    },
+    __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
+      Uint8Array.prototype.set.call(getArrayU8FromWasm02(arg0, arg1), arg2);
+    },
+    __wbg_randomFillSync_f8c153b79f285817: function() {
+      return handleError2(function(arg0, arg1) {
+        arg0.randomFillSync(arg1);
+      }, arguments);
+    },
+    __wbg_require_b74f47fc2d022fd6: function() {
+      return handleError2(function() {
+        const ret = module.require;
+        return ret;
+      }, arguments);
+    },
+    __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
+      arg0[arg1] = arg2;
+    },
+    __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
+      arg0[arg1 >>> 0] = arg2;
+    },
+    __wbg_stack_0ed75d68575b0f3c: function(arg0, arg1) {
+      const ret = arg1.stack;
+      const ptr1 = passStringToWasm02(ret, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN2;
+      getDataViewMemory02().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory02().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg_static_accessor_GLOBAL_12837167ad935116: function() {
+      const ret = typeof global === "undefined" ? null : global;
+      return isLikeNone2(ret) ? 0 : addToExternrefTable02(ret);
+    },
+    __wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f: function() {
+      const ret = typeof globalThis === "undefined" ? null : globalThis;
+      return isLikeNone2(ret) ? 0 : addToExternrefTable02(ret);
+    },
+    __wbg_static_accessor_SELF_a621d3dfbb60d0ce: function() {
+      const ret = typeof self === "undefined" ? null : self;
+      return isLikeNone2(ret) ? 0 : addToExternrefTable02(ret);
+    },
+    __wbg_static_accessor_WINDOW_f8727f0cf888e0bd: function() {
+      const ret = typeof window === "undefined" ? null : window;
+      return isLikeNone2(ret) ? 0 : addToExternrefTable02(ret);
+    },
+    __wbg_subarray_a96e1fef17ed23cb: function(arg0, arg1, arg2) {
+      const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+      return ret;
+    },
+    __wbg_versions_4e31226f5e8dc909: function(arg0) {
+      const ret = arg0.versions;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000001: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+      const ret = getArrayU8FromWasm02(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+      const ret = getStringFromWasm02(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000004: function(arg0) {
+      const ret = BigInt.asUintN(64, arg0);
+      return ret;
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm2.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, void 0);
+      table.set(offset + 0, void 0);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    }
+  };
+  return {
+    __proto__: null,
+    "./arkworks_groth16_wasm_bg.js": import0
+  };
+}
+function addToExternrefTable02(obj) {
+  const idx = wasm2.__externref_table_alloc();
+  wasm2.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+function getArrayU8FromWasm02(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory02().subarray(ptr / 1, ptr / 1 + len);
+}
+function getDataViewMemory02() {
+  if (cachedDataViewMemory02 === null || cachedDataViewMemory02.buffer.detached === true || cachedDataViewMemory02.buffer.detached === void 0 && cachedDataViewMemory02.buffer !== wasm2.memory.buffer) {
+    cachedDataViewMemory02 = new DataView(wasm2.memory.buffer);
+  }
+  return cachedDataViewMemory02;
+}
+function getStringFromWasm02(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText2(ptr, len);
+}
+function getUint8ArrayMemory02() {
+  if (cachedUint8ArrayMemory02 === null || cachedUint8ArrayMemory02.byteLength === 0) {
+    cachedUint8ArrayMemory02 = new Uint8Array(wasm2.memory.buffer);
+  }
+  return cachedUint8ArrayMemory02;
+}
+function handleError2(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable02(e);
+    wasm2.__wbindgen_exn_store(idx);
+  }
+}
+function isLikeNone2(x) {
+  return x === void 0 || x === null;
+}
+function passStringToWasm02(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder2.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory02().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN2 = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory02();
+  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 = getUint8ArrayMemory02().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder2.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN2 = offset;
+  return ptr;
+}
+function takeFromExternrefTable02(idx) {
+  const value = wasm2.__wbindgen_externrefs.get(idx);
+  wasm2.__externref_table_dealloc(idx);
+  return value;
+}
+function decodeText2(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder2 = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder2.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder2.decode(getUint8ArrayMemory02().subarray(ptr, ptr + len));
+}
+function __wbg_finalize_init(instance, module2) {
+  wasm2 = instance.exports;
+  wasmModule2 = module2;
+  cachedDataViewMemory02 = null;
+  cachedUint8ArrayMemory02 = null;
+  wasm2.__wbindgen_start();
+  return wasm2;
+}
+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 && expectedResponseType(module2.type);
+        if (validResponse && module2.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module2.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module2, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module: module2 };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+function initSync(module2) {
+  if (wasm2 !== void 0) return wasm2;
+  if (module2 !== void 0) {
+    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_imports2();
+  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 (wasm2 !== void 0) return wasm2;
+  if (module_or_path !== void 0) {
+    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 (module_or_path === void 0) {
+    module_or_path = new URL("arkworks_groth16_wasm_bg.wasm", import_meta.url);
+  }
+  const imports = __wbg_get_imports2();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+var import_meta, cachedDataViewMemory02, cachedUint8ArrayMemory02, cachedTextDecoder2, MAX_SAFARI_DECODE_BYTES, numBytesDecoded, cachedTextEncoder2, WASM_VECTOR_LEN2, wasmModule2, wasm2;
+var init_arkworks_groth16_wasm2 = __esm({
+  "src/wasm/web/arkworks_groth16_wasm.js"() {
+    "use strict";
+    import_meta = {};
+    cachedDataViewMemory02 = null;
+    cachedUint8ArrayMemory02 = null;
+    cachedTextDecoder2 = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder2.decode();
+    MAX_SAFARI_DECODE_BYTES = 2146435072;
+    numBytesDecoded = 0;
+    cachedTextEncoder2 = new TextEncoder();
+    if (!("encodeInto" in cachedTextEncoder2)) {
+      cachedTextEncoder2.encodeInto = function(arg, view) {
+        const buf = cachedTextEncoder2.encode(arg);
+        view.set(buf);
+        return {
+          read: arg.length,
+          written: buf.length
+        };
+      };
+    }
+    WASM_VECTOR_LEN2 = 0;
+  }
+});
+
 // src/infra/provingSystems/ArkworksWasm.ts
 var ArkworksWasm_exports = {};
 __export(ArkworksWasm_exports, {
@@ -159,8 +1026,8 @@ function isArkworksCircuit(circuit) {
   return "__arkworks" in circuit && circuit.__arkworks === true;
 }
 async function initWasm() {
-  if (wasmModule) {
-    return wasmModule;
+  if (wasmModule3) {
+    return wasmModule3;
   }
   if (wasmInitPromise2) {
     return wasmInitPromise2;
@@ -168,16 +1035,16 @@ async function initWasm() {
   wasmInitPromise2 = (async () => {
     try {
       if (isNodeJs3()) {
-        const module2 = await import("../wasm/nodejs/arkworks_groth16_wasm.js");
-        wasmModule = module2;
+        const module2 = await Promise.resolve().then(() => (init_arkworks_groth16_wasm(), arkworks_groth16_wasm_exports));
+        wasmModule3 = module2;
       } else {
-        const module2 = await import("../wasm/web/arkworks_groth16_wasm.js");
+        const module2 = await Promise.resolve().then(() => (init_arkworks_groth16_wasm2(), arkworks_groth16_wasm_exports2));
         if (typeof module2.default === "function") {
           await module2.default();
         }
-        wasmModule = module2;
+        wasmModule3 = module2;
       }
-      return wasmModule;
+      return wasmModule3;
     } catch (error) {
       wasmInitPromise2 = null;
       throw new Error(
@@ -221,13 +1088,14 @@ function hexToBytes(hex) {
   }
   return bytes;
 }
-var import_noir_wasm2, import_noir_js2, wasmModule, wasmInitPromise2, ArkworksWasm;
+var import_noir_wasm2, import_noir_js2, import_acvm_js, wasmModule3, wasmInitPromise2, ArkworksWasm;
 var init_ArkworksWasm = __esm({
   "src/infra/provingSystems/ArkworksWasm.ts"() {
     "use strict";
     import_noir_wasm2 = require("@noir-lang/noir_wasm");
     import_noir_js2 = require("@noir-lang/noir_js");
-    wasmModule = null;
+    import_acvm_js = require("@noir-lang/acvm_js");
+    wasmModule3 = null;
     wasmInitPromise2 = null;
     ArkworksWasm = class {
       config;
@@ -242,7 +1110,7 @@ var init_ArkworksWasm = __esm({
        * Compile Noir code to a circuit with ACIR for Groth16 proving
        */
       async compile(noirCode) {
-        const wasm = await initWasm();
+        const wasm3 = await initWasm();
         const { basePath, cleanup } = await createTempDir2();
         const fm = (0, import_noir_wasm2.createFileManager)(basePath);
         const nargoToml = `[package]
@@ -265,37 +1133,74 @@ authors = [""]
           if (!compiled || !compiled.bytecode) {
             throw new Error("Compilation failed: no bytecode generated");
           }
-          const acirJson = JSON.stringify({
-            functions: [
-              {
-                current_witness_index: compiled.abi.parameters.length + 1,
-                opcodes: [],
-                // Will be extracted from bytecode during prove
-                private_parameters: compiled.abi.parameters.filter((p) => p.visibility === "private").map((_, i) => i + 1),
-                public_parameters: {
-                  witnesses: compiled.abi.parameters.filter((p) => p.visibility === "public").map((_, i) => i + 1)
-                },
-                return_values: { witnesses: [] }
-              }
-            ]
+          const parameters = compiled.abi.parameters;
+          const publicR1csIndices = [];
+          const privateR1csIndices = [];
+          const witnessIndexMapping = /* @__PURE__ */ new Map();
+          parameters.forEach((p, noirIndex) => {
+            const r1csIndex = noirIndex + 1;
+            witnessIndexMapping.set(noirIndex, r1csIndex);
+            console.log(`  Parameter "${p.name}" (${p.visibility}): noir[${noirIndex}] \u2192 R1CS w_${r1csIndex}`);
+            if (p.visibility === "public") {
+              publicR1csIndices.push(r1csIndex);
+            } else if (p.visibility === "private") {
+              privateR1csIndices.push(r1csIndex);
+            }
           });
+          console.log("=== COMPILE: R1CS Witness Assignment ===");
+          console.log("Public R1CS indices:", publicR1csIndices);
+          console.log("Private R1CS indices:", privateR1csIndices);
+          console.log("Witness mapping:", Object.fromEntries(witnessIndexMapping));
+          console.log("=========================================");
+          const r1cs = {
+            num_witnesses: parameters.length + 1,
+            // +1 for w_0
+            public_inputs: publicR1csIndices,
+            private_inputs: privateR1csIndices,
+            constraints: []
+          };
+          if (privateR1csIndices.length === 1 && publicR1csIndices.length === 1) {
+            const privateIdx = privateR1csIndices[0];
+            const publicIdx = publicR1csIndices[0];
+            r1cs.constraints.push({
+              a: [["0x1", privateIdx]],
+              // secret
+              b: [["0x1", privateIdx]],
+              // secret
+              c: [["0x1", publicIdx]]
+              // expected
+            });
+            console.log(`  Added constraint: w_${privateIdx} * w_${privateIdx} = w_${publicIdx}`);
+          } else {
+            console.warn("Complex circuit detected - R1CS constraint generation may be incomplete");
+          }
+          const r1csJson = JSON.stringify(r1cs);
+          console.log("R1CS JSON:", r1csJson);
           let provingKey;
           let verifyingKey;
           let verifyingKeyGnark;
           if (this.config.cacheKeys) {
             try {
-              const setupResult = wasm.setup(acirJson);
+              console.log("Running trusted setup from R1CS...");
+              const setupResult = wasm3.setup_from_r1cs(r1csJson);
               provingKey = setupResult.proving_key;
               verifyingKey = setupResult.verifying_key;
               verifyingKeyGnark = setupResult.verifying_key_gnark;
+              console.log("Setup complete!");
             } catch (error) {
-              console.warn("Deferred setup: will run during proof generation");
+              console.error("Setup failed:", error);
+              throw new Error(`R1CS setup failed: ${error instanceof Error ? error.message : String(error)}`);
             }
           }
+          const acirJson = JSON.stringify({
+            functions: [{ current_witness_index: parameters.length, opcodes: [], private_parameters: privateR1csIndices, public_parameters: { witnesses: publicR1csIndices }, return_values: { witnesses: [] } }]
+          });
           const arkworksCircuit = {
             ...compiled,
             __arkworks: true,
             acirJson,
+            r1csJson,
+            witnessIndexMapping,
             provingKey,
             verifyingKey,
             verifyingKeyGnark
@@ -311,28 +1216,69 @@ authors = [""]
        * Generate a Groth16 proof
        */
       async generateProof(circuit, inputs) {
-        const wasm = await initWasm();
+        const wasm3 = await initWasm();
         if (!isArkworksCircuit(circuit)) {
           throw new Error(
             "ArkworksWasm.generateProof requires an ArkworksCompiledCircuit. Use ArkworksWasm.compile() first."
           );
         }
         const noir = new import_noir_js2.Noir(circuit);
-        const { witness } = await noir.execute(inputs);
+        const { witness: compressedWitness } = await noir.execute(inputs);
+        const witnessMapNoir = (0, import_acvm_js.decompressWitness)(compressedWitness);
+        console.log("=== ARKWORKS WASM DEBUG ===");
+        console.log("Circuit ABI parameters:", circuit.abi.parameters);
+        console.log("Inputs provided:", JSON.stringify(inputs));
+        console.log("Compressed witness size:", compressedWitness.length, "bytes");
+        console.log("Decompressed witness entries:", witnessMapNoir.size);
+        console.log("Witness map entries (first 10):");
+        const sortedWitness = Array.from(witnessMapNoir.entries()).sort(([a], [b]) => a - b);
+        for (const [index, value] of sortedWitness.slice(0, 10)) {
+          const strVal = String(value);
+          console.log(`  witness[${index}] = "${strVal.slice(0, 66)}${strVal.length > 66 ? "..." : ""}"`);
+          if (strVal.startsWith("0x")) {
+            try {
+              const decVal = BigInt(strVal).toString(10);
+              console.log(`    \u2192 decimal: ${decVal}`);
+            } catch {
+              console.log(`    \u2192 failed to parse as BigInt`);
+            }
+          }
+        }
         const witnessMap = {};
-        for (const [index, value] of witness.entries()) {
-          witnessMap[index.toString()] = String(value);
+        const witnessMapping = circuit.witnessIndexMapping;
+        console.log("Converting noir witness to R1CS witness:");
+        for (const [noirIndex, value] of witnessMapNoir.entries()) {
+          const r1csIndex = witnessMapping.get(noirIndex) ?? noirIndex + 1;
+          const strVal = String(value);
+          witnessMap[r1csIndex.toString()] = strVal;
+          console.log(`  noir[${noirIndex}] \u2192 R1CS w_${r1csIndex} = ${strVal.slice(0, 20)}...`);
         }
         const witnessJson = JSON.stringify(witnessMap);
+        console.log("Witness JSON for prove:", witnessJson.slice(0, 200) + "...");
+        const r1csParsed = JSON.parse(circuit.r1csJson);
+        console.log("R1CS public_inputs:", r1csParsed.public_inputs);
+        console.log("R1CS private_inputs:", r1csParsed.private_inputs);
+        console.log("R1CS num_witnesses:", r1csParsed.num_witnesses);
+        console.log("R1CS constraints:", r1csParsed.constraints.length);
         let provingKey = circuit.provingKey;
         if (!provingKey) {
-          const setupResult = wasm.setup(circuit.acirJson);
+          console.log("Running setup_from_r1cs...");
+          const setupResult = wasm3.setup_from_r1cs(circuit.r1csJson);
           provingKey = setupResult.proving_key;
           circuit.provingKey = provingKey;
           circuit.verifyingKey = setupResult.verifying_key;
           circuit.verifyingKeyGnark = setupResult.verifying_key_gnark;
         }
-        const proofResult = wasm.prove(provingKey, circuit.acirJson, witnessJson);
+        console.log("Generating proof from R1CS...");
+        const proofResult = wasm3.prove_from_r1cs(provingKey, circuit.r1csJson, witnessJson);
+        console.log("=== PROOF RESULT DEBUG ===");
+        console.log("Proof public inputs from arkworks:", proofResult.public_inputs);
+        proofResult.public_inputs.forEach((input, i) => {
+          const hexValue = input.startsWith("0x") ? input : `0x${input}`;
+          const decValue = BigInt(hexValue).toString(10);
+          console.log(`  Public input ${i}: ${input} (dec: ${decValue})`);
+        });
+        console.log("===========================");
         const proofBytes = base64ToUint8Array(proofResult.proof_gnark);
         return {
           proof: proofBytes,
@@ -343,7 +1289,7 @@ authors = [""]
        * Verify a Groth16 proof
        */
       async verifyProof(circuit, proof, publicInputs) {
-        const wasm = await initWasm();
+        const wasm3 = await initWasm();
         if (!isArkworksCircuit(circuit)) {
           throw new Error(
             "ArkworksWasm.verifyProof requires an ArkworksCompiledCircuit. Use ArkworksWasm.compile() first."
@@ -351,7 +1297,7 @@ authors = [""]
         }
         let verifyingKeyGnark = circuit.verifyingKeyGnark;
         if (!verifyingKeyGnark) {
-          const setupResult = wasm.setup(circuit.acirJson);
+          const setupResult = wasm3.setup_from_r1cs(circuit.r1csJson);
           circuit.provingKey = setupResult.proving_key;
           circuit.verifyingKey = setupResult.verifying_key;
           verifyingKeyGnark = setupResult.verifying_key_gnark;
@@ -359,7 +1305,7 @@ authors = [""]
         }
         const proofB64 = uint8ArrayToBase64(proof);
         const publicInputsGnarkB64 = publicInputsToGnarkBase64(publicInputs);
-        return wasm.verify_gnark(
+        return wasm3.verify_gnark(
           verifyingKeyGnark,
           proofB64,
           publicInputsGnarkB64,
@@ -370,12 +1316,12 @@ authors = [""]
        * Get the verifying key in gnark format for on-chain deployment
        */
       async getVerifyingKeyGnark(circuit) {
-        const wasm = await initWasm();
+        const wasm3 = await initWasm();
         if (!isArkworksCircuit(circuit)) {
           throw new Error("getVerifyingKeyGnark requires an ArkworksCompiledCircuit");
         }
         if (!circuit.verifyingKeyGnark) {
-          const setupResult = wasm.setup(circuit.acirJson);
+          const setupResult = wasm3.setup_from_r1cs(circuit.r1csJson);
           circuit.provingKey = setupResult.proving_key;
           circuit.verifyingKey = setupResult.verifying_key;
           circuit.verifyingKeyGnark = setupResult.verifying_key_gnark;
@@ -523,6 +1469,7 @@ __export(index_exports, {
   createVerificationEndpoint: () => createVerificationEndpoint,
   createVerifierMiddleware: () => createVerifierMiddleware,
   defineCircuit: () => defineCircuit,
+  defineConfig: () => defineConfig,
   generateNoir: () => generateNoir,
   getGlobalRegistry: () => getGlobalRegistry,
   initNoirWasm: () => initNoirWasm,
@@ -1692,16 +2639,7 @@ function hexToBytes2(hex) {
   return bytes;
 }
 function buildInitVkFromBytesData(nrPubinputs, vkBytes) {
-  const discriminator = new Uint8Array([
-    166,
-    58,
-    82,
-    247,
-    19,
-    129,
-    138,
-    59
-  ]);
+  const discriminator = new Uint8Array([103, 78, 249, 70, 245, 176, 87, 56]);
   const vkLen = new Uint8Array(4);
   new DataView(vkLen.buffer).setUint32(0, vkBytes.length, true);
   const data = new Uint8Array(discriminator.length + 1 + 4 + vkBytes.length);
@@ -1716,16 +2654,7 @@ function buildInitVkFromBytesData(nrPubinputs, vkBytes) {
   return data;
 }
 function buildVerifyProofData(proofBytes, publicInputs) {
-  const discriminator = new Uint8Array([
-    30,
-    8,
-    242,
-    54,
-    68,
-    154,
-    75,
-    92
-  ]);
+  const discriminator = new Uint8Array([217, 211, 191, 110, 144, 13, 186, 98]);
   if (proofBytes.length !== PROOF_SIZE) {
     throw new Error(`Invalid proof size: expected ${PROOF_SIZE}, got ${proofBytes.length}`);
   }
@@ -1830,16 +2759,7 @@ var SolanaTransactionBuilder = class {
    * @returns Instruction data ready for transaction building
    */
   buildCloseVkInstruction(accounts) {
-    const discriminator = new Uint8Array([
-      154,
-      71,
-      2,
-      43,
-      135,
-      151,
-      132,
-      74
-    ]);
+    const discriminator = new Uint8Array([82, 29, 77, 141, 76, 53, 205, 244]);
     return {
       data: discriminator,
       programId: this.programId,
@@ -2242,26 +3162,26 @@ var CircuitRegistry = class {
    * @throws Error if circuit with same name and version exists
    */
   register(definition) {
-    const { name, version } = definition;
-    if (!/^\d+\.\d+\.\d+/.test(version)) {
+    const { name, version: version3 } = definition;
+    if (!/^\d+\.\d+\.\d+/.test(version3)) {
       throw new Error(
-        `Invalid version format: ${version}. Use semantic versioning (e.g., '1.0.0')`
+        `Invalid version format: ${version3}. Use semantic versioning (e.g., '1.0.0')`
       );
     }
     if (typeof definition.jsCircuit !== "function") {
       throw new Error("jsCircuit must be a function");
     }
     const existing = this.circuits.get(name) ?? [];
-    if (existing.some((c) => c.version === version)) {
+    if (existing.some((c) => c.version === version3)) {
       throw new Error(
-        `Circuit '${name}' version ${version} already registered. Use a new version.`
+        `Circuit '${name}' version ${version3} already registered. Use a new version.`
       );
     }
     const functionHash = this.hashFunction(definition.jsCircuit);
     const registered = {
       ...definition,
       registeredAt: /* @__PURE__ */ new Date(),
-      id: `${name}@${version}`,
+      id: `${name}@${version3}`,
       functionHash
     };
     existing.push(registered);
@@ -2301,8 +3221,8 @@ var CircuitRegistry = class {
    * @param name - Circuit name
    * @param version - Optional specific version
    */
-  has(name, version) {
-    const circuit = this.get(name, version ? { version } : void 0);
+  has(name, version3) {
+    const circuit = this.get(name, version3 ? { version: version3 } : void 0);
     return circuit !== void 0;
   }
   /**
@@ -2345,13 +3265,13 @@ var CircuitRegistry = class {
    * @param version - Optional specific version (removes all if not specified)
    * @returns true if circuit was removed
    */
-  remove(name, version) {
-    if (!version) {
+  remove(name, version3) {
+    if (!version3) {
       return this.circuits.delete(name);
     }
     const versions = this.circuits.get(name);
     if (!versions) return false;
-    const index = versions.findIndex((c) => c.version === version);
+    const index = versions.findIndex((c) => c.version === version3);
     if (index === -1) return false;
     versions.splice(index, 1);
     if (versions.length === 0) {
@@ -2753,6 +3673,11 @@ async function batchVerify(verifier, requests) {
     failedCount: results.length - verifiedCount
   };
 }
+
+// src/config/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AcornParser,
@@ -2780,6 +3705,7 @@ async function batchVerify(verifier, requests) {
   createVerificationEndpoint,
   createVerifierMiddleware,
   defineCircuit,
+  defineConfig,
   generateNoir,
   getGlobalRegistry,
   initNoirWasm,