@zkclaw/sdk 2.0.0 → 2.0.3

package/dist/node-SQKRJHE6.mjs

@@ -0,0 +1,3378 @@
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-XGB3TDIC.mjs";
+
+// ../../node_modules/ms/index.js
+var require_ms = __commonJS({
+  "../../node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// ../../node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "../../node_modules/debug/src/common.js"(exports, module) {
+    "use strict";
+    function setup(env) {
+      createDebug6.debug = createDebug6;
+      createDebug6.default = createDebug6;
+      createDebug6.coerce = coerce;
+      createDebug6.disable = disable;
+      createDebug6.enable = enable;
+      createDebug6.enabled = enabled;
+      createDebug6.humanize = require_ms();
+      createDebug6.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug6[key] = env[key];
+      });
+      createDebug6.names = [];
+      createDebug6.skips = [];
+      createDebug6.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug6.colors[Math.abs(hash) % createDebug6.colors.length];
+      }
+      createDebug6.selectColor = selectColor;
+      function createDebug6(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug6(...args) {
+          if (!debug6.enabled) {
+            return;
+          }
+          const self = debug6;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          self.prev = prevTime;
+          self.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug6.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug6.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug6.formatArgs.call(self, args);
+          const logFn = self.log || createDebug6.log;
+          logFn.apply(self, args);
+        }
+        debug6.namespace = namespace;
+        debug6.useColors = createDebug6.useColors();
+        debug6.color = createDebug6.selectColor(namespace);
+        debug6.extend = extend;
+        debug6.destroy = createDebug6.destroy;
+        Object.defineProperty(debug6, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug6.namespaces) {
+              namespacesCache = createDebug6.namespaces;
+              enabledCache = createDebug6.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug6.init === "function") {
+          createDebug6.init(debug6);
+        }
+        return debug6;
+      }
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug6(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug6.save(namespaces);
+        createDebug6.namespaces = namespaces;
+        createDebug6.names = [];
+        createDebug6.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug6.skips.push(ns.slice(1));
+          } else {
+            createDebug6.names.push(ns);
+          }
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
+          } else {
+            return false;
+          }
+        }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug6.names,
+          ...createDebug6.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug6.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        for (const skip of createDebug6.skips) {
+          if (matchesTemplate(name, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug6.names) {
+          if (matchesTemplate(name, ns)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug6.enable(createDebug6.load());
+      return createDebug6;
+    }
+    module.exports = setup;
+  }
+});
+
+// ../../node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "../../node_modules/debug/src/browser.js"(exports, module) {
+    "use strict";
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../node_modules/has-flag/index.js"(exports, module) {
+    "use strict";
+    module.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// ../../node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../../node_modules/supports-color/index.js"(exports, module) {
+    "use strict";
+    var os2 = __require("os");
+    var tty = __require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os2.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// ../../node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "../../node_modules/debug/src/node.js"(exports, module) {
+    "use strict";
+    var tty = __require("tty");
+    var util = __require("util");
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = require_supports_color();
+      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+        exports.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error) {
+    }
+    exports.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+        return k.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color;
+        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug6) {
+      debug6.inspectOpts = {};
+      const keys = Object.keys(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug6.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// ../../node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/debug/src/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module.exports = require_browser();
+    } else {
+      module.exports = require_node();
+    }
+  }
+});
+
+// ../../node_modules/@aztec/bb.js/dest/node/crs/net_crs.js
+var NetCrs = class {
+  constructor(numPoints) {
+    this.numPoints = numPoints;
+  }
+  /**
+   * Download the data.
+   */
+  async init() {
+    await this.downloadG1Data();
+    await this.downloadG2Data();
+  }
+  async downloadG1Data() {
+    if (this.numPoints === 0) {
+      return this.data = new Uint8Array([]);
+    }
+    const g1End = this.numPoints * 64 - 1;
+    const response = await fetch("https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g1.dat", {
+      headers: {
+        Range: `bytes=0-${g1End}`
+      },
+      cache: "force-cache"
+    });
+    return this.data = new Uint8Array(await response.arrayBuffer());
+  }
+  /**
+   * Download the G2 points data.
+   */
+  async downloadG2Data() {
+    const response2 = await fetch("https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g2.dat", {
+      cache: "force-cache"
+    });
+    return this.g2Data = new Uint8Array(await response2.arrayBuffer());
+  }
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data() {
+    return this.data;
+  }
+  /**
+   * G2 points data for verification key.
+   * @returns The points data.
+   */
+  getG2Data() {
+    return this.g2Data;
+  }
+};
+
+// ../../node_modules/@aztec/bb.js/dest/node/crs/node/ignition_files_crs.js
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+function getCurrentDir() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  } else {
+    return dirname(fileURLToPath(import.meta.url));
+  }
+}
+var SRS_DEV_PATH = getCurrentDir() + "/../../../../../cpp/srs_db/ignition/monomial";
+var GRUMPKIN_SRS_DEV_PATH = getCurrentDir() + "/../../../../../cpp/srs_db/grumpkin/monomial";
+
+// ../../node_modules/@aztec/bb.js/dest/node/crs/node/index.js
+var import_debug = __toESM(require_src(), 1);
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import { homedir } from "os";
+var debug = (0, import_debug.default)("bb.js:crs");
+var Crs = class _Crs {
+  constructor(numPoints, path) {
+    this.numPoints = numPoints;
+    this.path = path;
+  }
+  static async new(numPoints, crsPath = homedir() + "/.bb-crs") {
+    const crs = new _Crs(numPoints, crsPath);
+    await crs.init();
+    return crs;
+  }
+  async init() {
+    mkdirSync(this.path, { recursive: true });
+    const g1FileSize = await stat(this.path + "/bn254_g1.dat").then((stats) => stats.size).catch(() => 0);
+    const g2FileSize = await stat(this.path + "/bn254_g2.dat").then((stats) => stats.size).catch(() => 0);
+    if (g1FileSize >= this.numPoints * 64 && g1FileSize % 64 == 0 && g2FileSize == 128) {
+      debug(`using cached crs of size: ${g1FileSize / 64}`);
+      return;
+    }
+    debug(`downloading crs of size: ${this.numPoints}`);
+    const crs = new NetCrs(this.numPoints);
+    await crs.init();
+    writeFileSync(this.path + "/bn254_g1.dat", crs.getG1Data());
+    writeFileSync(this.path + "/bn254_g2.dat", crs.getG2Data());
+  }
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data() {
+    return readFileSync(this.path + "/bn254_g1.dat");
+  }
+  /**
+   * G2 points data for verification key.
+   * @returns The points data.
+   */
+  getG2Data() {
+    return readFileSync(this.path + "/bn254_g2.dat");
+  }
+};
+
+// ../../node_modules/comlink/dist/esm/comlink.mjs
+var proxyMarker = /* @__PURE__ */ Symbol("Comlink.proxy");
+var createEndpoint = /* @__PURE__ */ Symbol("Comlink.endpoint");
+var releaseProxy = /* @__PURE__ */ Symbol("Comlink.releaseProxy");
+var finalizer = /* @__PURE__ */ Symbol("Comlink.finalizer");
+var throwMarker = /* @__PURE__ */ Symbol("Comlink.thrown");
+var isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+var proxyTransferHandler = {
+  canHandle: (val) => isObject(val) && val[proxyMarker],
+  serialize(obj) {
+    const { port1, port2 } = new MessageChannel();
+    expose(obj, port1);
+    return [port2, [port2]];
+  },
+  deserialize(port) {
+    port.start();
+    return wrap(port);
+  }
+};
+var throwTransferHandler = {
+  canHandle: (value) => isObject(value) && throwMarker in value,
+  serialize({ value }) {
+    let serialized;
+    if (value instanceof Error) {
+      serialized = {
+        isError: true,
+        value: {
+          message: value.message,
+          name: value.name,
+          stack: value.stack
+        }
+      };
+    } else {
+      serialized = { isError: false, value };
+    }
+    return [serialized, []];
+  },
+  deserialize(serialized) {
+    if (serialized.isError) {
+      throw Object.assign(new Error(serialized.value.message), serialized.value);
+    }
+    throw serialized.value;
+  }
+};
+var transferHandlers = /* @__PURE__ */ new Map([
+  ["proxy", proxyTransferHandler],
+  ["throw", throwTransferHandler]
+]);
+function isAllowedOrigin(allowedOrigins, origin) {
+  for (const allowedOrigin of allowedOrigins) {
+    if (origin === allowedOrigin || allowedOrigin === "*") {
+      return true;
+    }
+    if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+      return true;
+    }
+  }
+  return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+  ep.addEventListener("message", function callback(ev) {
+    if (!ev || !ev.data) {
+      return;
+    }
+    if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+      console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+      return;
+    }
+    const { id, type, path } = Object.assign({ path: [] }, ev.data);
+    const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+    let returnValue;
+    try {
+      const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+      const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+      switch (type) {
+        case "GET":
+          {
+            returnValue = rawValue;
+          }
+          break;
+        case "SET":
+          {
+            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+            returnValue = true;
+          }
+          break;
+        case "APPLY":
+          {
+            returnValue = rawValue.apply(parent, argumentList);
+          }
+          break;
+        case "CONSTRUCT":
+          {
+            const value = new rawValue(...argumentList);
+            returnValue = proxy(value);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1, port2 } = new MessageChannel();
+            expose(obj, port2);
+            returnValue = transfer(port1, [port1]);
+          }
+          break;
+        case "RELEASE":
+          {
+            returnValue = void 0;
+          }
+          break;
+        default:
+          return;
+      }
+    } catch (value) {
+      returnValue = { value, [throwMarker]: 0 };
+    }
+    Promise.resolve(returnValue).catch((value) => {
+      return { value, [throwMarker]: 0 };
+    }).then((returnValue2) => {
+      const [wireValue, transferables] = toWireValue(returnValue2);
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      if (type === "RELEASE") {
+        ep.removeEventListener("message", callback);
+        closeEndPoint(ep);
+        if (finalizer in obj && typeof obj[finalizer] === "function") {
+          obj[finalizer]();
+        }
+      }
+    }).catch((error) => {
+      const [wireValue, transferables] = toWireValue({
+        value: new TypeError("Unserializable return value"),
+        [throwMarker]: 0
+      });
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+    });
+  });
+  if (ep.start) {
+    ep.start();
+  }
+}
+function isMessagePort(endpoint) {
+  return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+  if (isMessagePort(endpoint))
+    endpoint.close();
+}
+function wrap(ep, target) {
+  const pendingListeners = /* @__PURE__ */ new Map();
+  ep.addEventListener("message", function handleMessage(ev) {
+    const { data } = ev;
+    if (!data || !data.id) {
+      return;
+    }
+    const resolver = pendingListeners.get(data.id);
+    if (!resolver) {
+      return;
+    }
+    try {
+      resolver(data);
+    } finally {
+      pendingListeners.delete(data.id);
+    }
+  });
+  return createProxy(ep, pendingListeners, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+  if (isReleased) {
+    throw new Error("Proxy has been released and is not useable");
+  }
+}
+function releaseEndpoint(ep) {
+  return requestResponseMessage(ep, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    closeEndPoint(ep);
+  });
+}
+var proxyCounter = /* @__PURE__ */ new WeakMap();
+var proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+  const newCount = (proxyCounter.get(ep) || 0) - 1;
+  proxyCounter.set(ep, newCount);
+  if (newCount === 0) {
+    releaseEndpoint(ep);
+  }
+});
+function registerProxy(proxy2, ep) {
+  const newCount = (proxyCounter.get(ep) || 0) + 1;
+  proxyCounter.set(ep, newCount);
+  if (proxyFinalizers) {
+    proxyFinalizers.register(proxy2, ep, proxy2);
+  }
+}
+function unregisterProxy(proxy2) {
+  if (proxyFinalizers) {
+    proxyFinalizers.unregister(proxy2);
+  }
+}
+function createProxy(ep, pendingListeners, path = [], target = function() {
+}) {
+  let isProxyReleased = false;
+  const proxy2 = new Proxy(target, {
+    get(_target, prop) {
+      throwIfProxyReleased(isProxyReleased);
+      if (prop === releaseProxy) {
+        return () => {
+          unregisterProxy(proxy2);
+          releaseEndpoint(ep);
+          pendingListeners.clear();
+          isProxyReleased = true;
+        };
+      }
+      if (prop === "then") {
+        if (path.length === 0) {
+          return { then: () => proxy2 };
+        }
+        const r = requestResponseMessage(ep, pendingListeners, {
+          type: "GET",
+          path: path.map((p) => p.toString())
+        }).then(fromWireValue);
+        return r.then.bind(r);
+      }
+      return createProxy(ep, pendingListeners, [...path, prop]);
+    },
+    set(_target, prop, rawValue) {
+      throwIfProxyReleased(isProxyReleased);
+      const [value, transferables] = toWireValue(rawValue);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "SET",
+        path: [...path, prop].map((p) => p.toString()),
+        value
+      }, transferables).then(fromWireValue);
+    },
+    apply(_target, _thisArg, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const last = path[path.length - 1];
+      if (last === createEndpoint) {
+        return requestResponseMessage(ep, pendingListeners, {
+          type: "ENDPOINT"
+        }).then(fromWireValue);
+      }
+      if (last === "bind") {
+        return createProxy(ep, pendingListeners, path.slice(0, -1));
+      }
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "APPLY",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    },
+    construct(_target, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "CONSTRUCT",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    }
+  });
+  registerProxy(proxy2, ep);
+  return proxy2;
+}
+function myFlat(arr) {
+  return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+  const processed = argumentList.map(toWireValue);
+  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+var transferCache = /* @__PURE__ */ new WeakMap();
+function transfer(obj, transfers) {
+  transferCache.set(obj, transfers);
+  return obj;
+}
+function proxy(obj) {
+  return Object.assign(obj, { [proxyMarker]: true });
+}
+function toWireValue(value) {
+  for (const [name, handler] of transferHandlers) {
+    if (handler.canHandle(value)) {
+      const [serializedValue, transferables] = handler.serialize(value);
+      return [
+        {
+          type: "HANDLER",
+          name,
+          value: serializedValue
+        },
+        transferables
+      ];
+    }
+  }
+  return [
+    {
+      type: "RAW",
+      value
+    },
+    transferCache.get(value) || []
+  ];
+}
+function fromWireValue(value) {
+  switch (value.type) {
+    case "HANDLER":
+      return transferHandlers.get(value.name).deserialize(value.value);
+    case "RAW":
+      return value.value;
+  }
+}
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+  return new Promise((resolve) => {
+    const id = generateUUID();
+    pendingListeners.set(id, resolve);
+    if (ep.start) {
+      ep.start();
+    }
+    ep.postMessage(Object.assign({ id }, msg), transfers);
+  });
+}
+function generateUUID() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/serialize/buffer_reader.js
+var BufferReader = class _BufferReader {
+  constructor(buffer, offset = 0) {
+    this.buffer = buffer;
+    this.index = offset;
+  }
+  static asReader(bufferOrReader) {
+    return bufferOrReader instanceof _BufferReader ? bufferOrReader : new _BufferReader(bufferOrReader);
+  }
+  readNumber() {
+    const dataView = new DataView(this.buffer.buffer, this.buffer.byteOffset + this.index, 4);
+    this.index += 4;
+    return dataView.getUint32(0, false);
+  }
+  readBoolean() {
+    this.index += 1;
+    return Boolean(this.buffer.at(this.index - 1));
+  }
+  readBytes(n) {
+    this.index += n;
+    return this.buffer.slice(this.index - n, this.index);
+  }
+  readNumberVector() {
+    return this.readVector({
+      fromBuffer: (reader) => reader.readNumber()
+    });
+  }
+  readVector(itemDeserializer) {
+    const size = this.readNumber();
+    const result = new Array(size);
+    for (let i = 0; i < size; i++) {
+      result[i] = itemDeserializer.fromBuffer(this);
+    }
+    return result;
+  }
+  readArray(size, itemDeserializer) {
+    const result = new Array(size);
+    for (let i = 0; i < size; i++) {
+      result[i] = itemDeserializer.fromBuffer(this);
+    }
+    return result;
+  }
+  readObject(deserializer) {
+    return deserializer.fromBuffer(this);
+  }
+  peekBytes(n) {
+    return this.buffer.subarray(this.index, n ? this.index + n : void 0);
+  }
+  readString() {
+    return new TextDecoder().decode(this.readBuffer());
+  }
+  readBuffer() {
+    const size = this.readNumber();
+    return this.readBytes(size);
+  }
+  readMap(deserializer) {
+    const numEntries = this.readNumber();
+    const map = {};
+    for (let i = 0; i < numEntries; i++) {
+      const key = this.readString();
+      const value = this.readObject(deserializer);
+      map[key] = value;
+    }
+    return map;
+  }
+};
+
+// ../../node_modules/@aztec/bb.js/dest/node/serialize/output_type.js
+function BoolDeserializer() {
+  return {
+    SIZE_IN_BYTES: 1,
+    fromBuffer: (buf) => {
+      const reader = BufferReader.asReader(buf);
+      return reader.readBoolean();
+    }
+  };
+}
+function NumberDeserializer() {
+  return {
+    SIZE_IN_BYTES: 4,
+    fromBuffer: (buf) => {
+      const reader = BufferReader.asReader(buf);
+      return reader.readNumber();
+    }
+  };
+}
+function VectorDeserializer(t) {
+  return {
+    fromBuffer: (buf) => {
+      const reader = BufferReader.asReader(buf);
+      return reader.readVector(t);
+    }
+  };
+}
+function BufferDeserializer() {
+  return {
+    fromBuffer: (buf) => {
+      const reader = BufferReader.asReader(buf);
+      return reader.readBuffer();
+    }
+  };
+}
+function StringDeserializer() {
+  return {
+    fromBuffer: (buf) => {
+      const reader = BufferReader.asReader(buf);
+      return reader.readString();
+    }
+  };
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/types/raw_buffer.js
+var RawBuffer = class extends Uint8Array {
+};
+
+// ../../node_modules/@aztec/bb.js/dest/node/serialize/serialize.js
+function boolToBuffer(b) {
+  const buf = new Uint8Array(1);
+  buf[0] = b ? 1 : 0;
+  return buf;
+}
+function numToUInt32BE(n, bufferSize = 4) {
+  const buf = new Uint8Array(bufferSize);
+  new DataView(buf.buffer).setUint32(buf.byteLength - 4, n, false);
+  return buf;
+}
+function numToInt32BE(n, bufferSize = 4) {
+  const buf = new Uint8Array(bufferSize);
+  new DataView(buf.buffer).setInt32(buf.byteLength - 4, n, false);
+  return buf;
+}
+function concatenateUint8Arrays(arrayOfUint8Arrays) {
+  const totalLength = arrayOfUint8Arrays.reduce((prev, curr) => prev + curr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let length = 0;
+  for (const array of arrayOfUint8Arrays) {
+    result.set(array, length);
+    length += array.length;
+  }
+  return result;
+}
+function uint8ArrayToHexString(uint8Array) {
+  return uint8Array.reduce((accumulator, byte) => accumulator + byte.toString(16).padStart(2, "0"), "");
+}
+function serializeBufferToVector(buf) {
+  return concatenateUint8Arrays([numToInt32BE(buf.length), buf]);
+}
+function serializeBigInt(n, width = 32) {
+  const buf = new Uint8Array(width);
+  for (let i = 0; i < width; i++) {
+    buf[width - i - 1] = Number(n >> BigInt(i * 8) & 0xffn);
+  }
+  return buf;
+}
+function serializeBufferArrayToVector(arr) {
+  return concatenateUint8Arrays([numToUInt32BE(arr.length), ...arr.flat()]);
+}
+function serializeBufferable(obj) {
+  if (Array.isArray(obj)) {
+    return serializeBufferArrayToVector(obj.map(serializeBufferable));
+  } else if (obj instanceof RawBuffer) {
+    return obj;
+  } else if (obj instanceof Uint8Array) {
+    return serializeBufferToVector(obj);
+  } else if (typeof obj === "boolean") {
+    return boolToBuffer(obj);
+  } else if (typeof obj === "number") {
+    return numToUInt32BE(obj);
+  } else if (typeof obj === "bigint") {
+    return serializeBigInt(obj);
+  } else if (typeof obj === "string") {
+    return serializeBufferToVector(new TextEncoder().encode(obj));
+  } else {
+    return obj.toBuffer();
+  }
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/types/ptr.js
+var Ptr = class {
+  constructor(value) {
+    this.value = value;
+  }
+  static fromBuffer(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(reader.readBytes(this.SIZE_IN_BYTES));
+  }
+  toBuffer() {
+    return this.value;
+  }
+};
+Ptr.SIZE_IN_BYTES = 4;
+
+// ../../node_modules/@aztec/bb.js/dest/node/random/node/index.js
+import { randomBytes as cryptoRandomBytes } from "crypto";
+function randomBytes(len) {
+  return new Uint8Array(cryptoRandomBytes(len));
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/bigint-array/index.js
+function toBigIntBE(bytes) {
+  bytes = new Uint8Array(bytes);
+  let bigint = BigInt(0);
+  const view = new DataView(bytes.buffer);
+  for (let i = 0; i < bytes.byteLength; i++) {
+    bigint = (bigint << BigInt(8)) + BigInt(view.getUint8(i));
+  }
+  return bigint;
+}
+function toBufferBE(value, byteLength = 32) {
+  const bytes = new Uint8Array(byteLength);
+  const view = new DataView(bytes.buffer);
+  for (let i = 0; i < byteLength; i++) {
+    view.setUint8(byteLength - i - 1, Number(value & BigInt(255)));
+    value >>= BigInt(8);
+  }
+  return bytes;
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/types/fields.js
+var _a;
+var _b;
+var Fr = class {
+  constructor(value) {
+    const valueBigInt = typeof value === "bigint" ? value : toBigIntBE(value);
+    if (valueBigInt > _a.MAX_VALUE) {
+      throw new Error(`Value 0x${valueBigInt.toString(16)} is greater or equal to field modulus.`);
+    }
+    this.value = typeof value === "bigint" ? toBufferBE(value) : value;
+  }
+  static random() {
+    const r = toBigIntBE(randomBytes(64)) % _a.MODULUS;
+    return new this(r);
+  }
+  static fromBuffer(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(reader.readBytes(this.SIZE_IN_BYTES));
+  }
+  static fromBufferReduce(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(toBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % _a.MODULUS);
+  }
+  static fromString(str) {
+    return this.fromBuffer(Buffer.from(str.replace(/^0x/i, ""), "hex"));
+  }
+  toBuffer() {
+    return this.value;
+  }
+  toString() {
+    return "0x" + uint8ArrayToHexString(this.toBuffer());
+  }
+  equals(rhs) {
+    return this.value.every((v, i) => v === rhs.value[i]);
+  }
+  isZero() {
+    return this.value.every((v) => v === 0);
+  }
+};
+_a = Fr;
+Fr.ZERO = new _a(0n);
+Fr.MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
+Fr.MAX_VALUE = _a.MODULUS - 1n;
+Fr.SIZE_IN_BYTES = 32;
+var Fq = class {
+  constructor(value) {
+    this.value = value;
+    if (value > _b.MAX_VALUE) {
+      throw new Error(`Fq out of range ${value}.`);
+    }
+  }
+  static random() {
+    const r = toBigIntBE(randomBytes(64)) % _b.MODULUS;
+    return new this(r);
+  }
+  static fromBuffer(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(toBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)));
+  }
+  static fromBufferReduce(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(toBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % Fr.MODULUS);
+  }
+  static fromString(str) {
+    return this.fromBuffer(Buffer.from(str.replace(/^0x/i, ""), "hex"));
+  }
+  toBuffer() {
+    return toBufferBE(this.value, _b.SIZE_IN_BYTES);
+  }
+  toString() {
+    return "0x" + this.value.toString(16);
+  }
+  equals(rhs) {
+    return this.value === rhs.value;
+  }
+  isZero() {
+    return this.value === 0n;
+  }
+};
+_b = Fq;
+Fq.MODULUS = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47n;
+Fq.MAX_VALUE = _b.MODULUS - 1n;
+Fq.SIZE_IN_BYTES = 32;
+
+// ../../node_modules/@aztec/bb.js/dest/node/types/point.js
+var Point = class _Point {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  static random() {
+    return new _Point(Fr.random(), Fr.random());
+  }
+  static fromBuffer(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+  }
+  static fromString(address) {
+    return _Point.fromBuffer(Buffer.from(address.replace(/^0x/i, ""), "hex"));
+  }
+  toBuffer() {
+    return Buffer.concat([this.x.toBuffer(), this.y.toBuffer()]);
+  }
+  toString() {
+    return "0x" + this.toBuffer().toString("hex");
+  }
+  equals(rhs) {
+    return this.x.equals(rhs.x) && this.y.equals(rhs.y);
+  }
+};
+Point.SIZE_IN_BYTES = 64;
+Point.EMPTY = new Point(Fr.ZERO, Fr.ZERO);
+
+// ../../node_modules/@aztec/bb.js/dest/node/types/fixed_size_buffer.js
+var Buffer32 = class _Buffer32 {
+  constructor(buffer) {
+    this.buffer = buffer;
+  }
+  static fromBuffer(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new _Buffer32(reader.readBytes(this.SIZE_IN_BYTES));
+  }
+  static random() {
+    return new _Buffer32(randomBytes(this.SIZE_IN_BYTES));
+  }
+  toBuffer() {
+    return this.buffer;
+  }
+};
+Buffer32.SIZE_IN_BYTES = 32;
+var Buffer64 = class _Buffer64 {
+  constructor(buffer) {
+    this.buffer = buffer;
+  }
+  static fromBuffer(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new _Buffer64(reader.readBytes(this.SIZE_IN_BYTES));
+  }
+  static random() {
+    return new _Buffer64(randomBytes(this.SIZE_IN_BYTES));
+  }
+  toBuffer() {
+    return this.buffer;
+  }
+};
+Buffer64.SIZE_IN_BYTES = 64;
+var Buffer128 = class _Buffer128 {
+  constructor(buffer) {
+    this.buffer = buffer;
+  }
+  static fromBuffer(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new _Buffer128(reader.readBytes(this.SIZE_IN_BYTES));
+  }
+  static random() {
+    return new _Buffer128(randomBytes(this.SIZE_IN_BYTES));
+  }
+  toBuffer() {
+    return this.buffer;
+  }
+};
+Buffer128.SIZE_IN_BYTES = 128;
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_api/index.js
+var BarretenbergApi = class {
+  constructor(wasm) {
+    this.wasm = wasm;
+  }
+  async pedersenCommit(inputsBuffer, ctxIndex) {
+    const inArgs = [inputsBuffer, ctxIndex].map(serializeBufferable);
+    const outTypes = [Point];
+    const result = await this.wasm.callWasmExport("pedersen_commit", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async pedersenHash(inputsBuffer, hashIndex) {
+    const inArgs = [inputsBuffer, hashIndex].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = await this.wasm.callWasmExport("pedersen_hash", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async pedersenHashes(inputsBuffer, hashIndex) {
+    const inArgs = [inputsBuffer, hashIndex].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = await this.wasm.callWasmExport("pedersen_hashes", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async pedersenHashBuffer(inputBuffer, hashIndex) {
+    const inArgs = [inputBuffer, hashIndex].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = await this.wasm.callWasmExport("pedersen_hash_buffer", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async poseidon2Hash(inputsBuffer) {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = await this.wasm.callWasmExport("poseidon2_hash", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async poseidon2Hashes(inputsBuffer) {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = await this.wasm.callWasmExport("poseidon2_hashes", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async poseidon2Permutation(inputsBuffer) {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr)];
+    const result = await this.wasm.callWasmExport("poseidon2_permutation", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async blake2s(data) {
+    const inArgs = [data].map(serializeBufferable);
+    const outTypes = [Buffer32];
+    const result = await this.wasm.callWasmExport("blake2s", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async blake2sToField(data) {
+    const inArgs = [data].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = await this.wasm.callWasmExport("blake2s_to_field_", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async schnorrComputePublicKey(privateKey) {
+    const inArgs = [privateKey].map(serializeBufferable);
+    const outTypes = [Point];
+    const result = await this.wasm.callWasmExport("schnorr_compute_public_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async schnorrNegatePublicKey(publicKeyBuffer) {
+    const inArgs = [publicKeyBuffer].map(serializeBufferable);
+    const outTypes = [Point];
+    const result = await this.wasm.callWasmExport("schnorr_negate_public_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async schnorrConstructSignature(message, privateKey) {
+    const inArgs = [message, privateKey].map(serializeBufferable);
+    const outTypes = [Buffer32, Buffer32];
+    const result = await this.wasm.callWasmExport("schnorr_construct_signature", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  async schnorrVerifySignature(message, pubKey, sigS, sigE) {
+    const inArgs = [message, pubKey, sigS, sigE].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("schnorr_verify_signature", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async schnorrMultisigCreateMultisigPublicKey(privateKey) {
+    const inArgs = [privateKey].map(serializeBufferable);
+    const outTypes = [Buffer128];
+    const result = await this.wasm.callWasmExport("schnorr_multisig_create_multisig_public_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async schnorrMultisigValidateAndCombineSignerPubkeys(signerPubkeyBuf) {
+    const inArgs = [signerPubkeyBuf].map(serializeBufferable);
+    const outTypes = [Point, BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("schnorr_multisig_validate_and_combine_signer_pubkeys", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  async schnorrMultisigConstructSignatureRound1() {
+    const inArgs = [].map(serializeBufferable);
+    const outTypes = [Buffer128, Buffer128];
+    const result = await this.wasm.callWasmExport("schnorr_multisig_construct_signature_round_1", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  async schnorrMultisigConstructSignatureRound2(message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf) {
+    const inArgs = [message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf].map(serializeBufferable);
+    const outTypes = [Fq, BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("schnorr_multisig_construct_signature_round_2", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  async schnorrMultisigCombineSignatures(message, signerPubkeysBuf, roundOneBuf, roundTwoBuf) {
+    const inArgs = [message, signerPubkeysBuf, roundOneBuf, roundTwoBuf].map(serializeBufferable);
+    const outTypes = [Buffer32, Buffer32, BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("schnorr_multisig_combine_signatures", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  async aesEncryptBufferCbc(input, iv, key, length) {
+    const inArgs = [input, iv, key, length].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport("aes_encrypt_buffer_cbc", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async aesDecryptBufferCbc(input, iv, key, length) {
+    const inArgs = [input, iv, key, length].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport("aes_decrypt_buffer_cbc", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async srsInitSrs(pointsBuf, numPoints, g2PointBuf) {
+    const inArgs = [pointsBuf, numPoints, g2PointBuf].map(serializeBufferable);
+    const outTypes = [];
+    const result = await this.wasm.callWasmExport("srs_init_srs", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  async srsInitGrumpkinSrs(pointsBuf, numPoints) {
+    const inArgs = [pointsBuf, numPoints].map(serializeBufferable);
+    const outTypes = [];
+    const result = await this.wasm.callWasmExport("srs_init_grumpkin_srs", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  async examplesSimpleCreateAndVerifyProof() {
+    const inArgs = [].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("examples_simple_create_and_verify_proof", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async testThreads(threads, iterations) {
+    const inArgs = [threads, iterations].map(serializeBufferable);
+    const outTypes = [NumberDeserializer()];
+    const result = await this.wasm.callWasmExport("test_threads", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async commonInitSlabAllocator(circuitSize) {
+    const inArgs = [circuitSize].map(serializeBufferable);
+    const outTypes = [];
+    const result = await this.wasm.callWasmExport("common_init_slab_allocator", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  async acirGetCircuitSizes(constraintSystemBuf, honkRecursion) {
+    const inArgs = [constraintSystemBuf, honkRecursion].map(serializeBufferable);
+    const outTypes = [NumberDeserializer(), NumberDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_get_circuit_sizes", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  async acirNewAcirComposer(sizeHint) {
+    const inArgs = [sizeHint].map(serializeBufferable);
+    const outTypes = [Ptr];
+    const result = await this.wasm.callWasmExport("acir_new_acir_composer", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirDeleteAcirComposer(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [];
+    const result = await this.wasm.callWasmExport("acir_delete_acir_composer", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  async acirInitProvingKey(acirComposerPtr, constraintSystemBuf) {
+    const inArgs = [acirComposerPtr, constraintSystemBuf].map(serializeBufferable);
+    const outTypes = [];
+    const result = await this.wasm.callWasmExport("acir_init_proving_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  async acirCreateProof(acirComposerPtr, constraintSystemBuf, witnessBuf) {
+    const inArgs = [acirComposerPtr, constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_create_proof", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirProveAndVerifyUltraHonk(constraintSystemBuf, witnessBuf) {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_prove_and_verify_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirProveAndVerifyMegaHonk(constraintSystemBuf, witnessBuf) {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_prove_and_verify_mega_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirFoldAndVerifyProgramStack(constraintSystemBuf, witnessBuf) {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_fold_and_verify_program_stack", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirLoadVerificationKey(acirComposerPtr, vkBuf) {
+    const inArgs = [acirComposerPtr, vkBuf].map(serializeBufferable);
+    const outTypes = [];
+    const result = await this.wasm.callWasmExport("acir_load_verification_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  async acirInitVerificationKey(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [];
+    const result = await this.wasm.callWasmExport("acir_init_verification_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  async acirGetVerificationKey(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_get_verification_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirGetProvingKey(acirComposerPtr, acirVec) {
+    const inArgs = [acirComposerPtr, acirVec].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_get_proving_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirVerifyProof(acirComposerPtr, proofBuf) {
+    const inArgs = [acirComposerPtr, proofBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_verify_proof", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirGetSolidityVerifier(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [StringDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_get_solidity_verifier", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirSerializeProofIntoFields(acirComposerPtr, proofBuf, numInnerPublicInputs) {
+    const inArgs = [acirComposerPtr, proofBuf, numInnerPublicInputs].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr)];
+    const result = await this.wasm.callWasmExport("acir_serialize_proof_into_fields", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirSerializeVerificationKeyIntoFields(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr), Fr];
+    const result = await this.wasm.callWasmExport("acir_serialize_verification_key_into_fields", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  async acirProveUltraHonk(acirVec, witnessVec) {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_prove_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirVerifyUltraHonk(proofBuf, vkBuf) {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_verify_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirWriteVkUltraHonk(acirVec) {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport("acir_write_vk_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirProofAsFieldsUltraHonk(proofBuf) {
+    const inArgs = [proofBuf].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr)];
+    const result = await this.wasm.callWasmExport("acir_proof_as_fields_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  async acirVkAsFieldsUltraHonk(vkBuf) {
+    const inArgs = [vkBuf].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr)];
+    const result = await this.wasm.callWasmExport("acir_vk_as_fields_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+};
+var BarretenbergApiSync = class {
+  constructor(wasm) {
+    this.wasm = wasm;
+  }
+  pedersenCommit(inputsBuffer, ctxIndex) {
+    const inArgs = [inputsBuffer, ctxIndex].map(serializeBufferable);
+    const outTypes = [Point];
+    const result = this.wasm.callWasmExport("pedersen_commit", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  pedersenHash(inputsBuffer, hashIndex) {
+    const inArgs = [inputsBuffer, hashIndex].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = this.wasm.callWasmExport("pedersen_hash", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  pedersenHashes(inputsBuffer, hashIndex) {
+    const inArgs = [inputsBuffer, hashIndex].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = this.wasm.callWasmExport("pedersen_hashes", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  pedersenHashBuffer(inputBuffer, hashIndex) {
+    const inArgs = [inputBuffer, hashIndex].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = this.wasm.callWasmExport("pedersen_hash_buffer", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  poseidon2Hash(inputsBuffer) {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = this.wasm.callWasmExport("poseidon2_hash", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  poseidon2Hashes(inputsBuffer) {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = this.wasm.callWasmExport("poseidon2_hashes", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  poseidon2Permutation(inputsBuffer) {
+    const inArgs = [inputsBuffer].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr)];
+    const result = this.wasm.callWasmExport("poseidon2_permutation", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  blake2s(data) {
+    const inArgs = [data].map(serializeBufferable);
+    const outTypes = [Buffer32];
+    const result = this.wasm.callWasmExport("blake2s", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  blake2sToField(data) {
+    const inArgs = [data].map(serializeBufferable);
+    const outTypes = [Fr];
+    const result = this.wasm.callWasmExport("blake2s_to_field_", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  schnorrComputePublicKey(privateKey) {
+    const inArgs = [privateKey].map(serializeBufferable);
+    const outTypes = [Point];
+    const result = this.wasm.callWasmExport("schnorr_compute_public_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  schnorrNegatePublicKey(publicKeyBuffer) {
+    const inArgs = [publicKeyBuffer].map(serializeBufferable);
+    const outTypes = [Point];
+    const result = this.wasm.callWasmExport("schnorr_negate_public_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  schnorrConstructSignature(message, privateKey) {
+    const inArgs = [message, privateKey].map(serializeBufferable);
+    const outTypes = [Buffer32, Buffer32];
+    const result = this.wasm.callWasmExport("schnorr_construct_signature", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  schnorrVerifySignature(message, pubKey, sigS, sigE) {
+    const inArgs = [message, pubKey, sigS, sigE].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport("schnorr_verify_signature", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  schnorrMultisigCreateMultisigPublicKey(privateKey) {
+    const inArgs = [privateKey].map(serializeBufferable);
+    const outTypes = [Buffer128];
+    const result = this.wasm.callWasmExport("schnorr_multisig_create_multisig_public_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  schnorrMultisigValidateAndCombineSignerPubkeys(signerPubkeyBuf) {
+    const inArgs = [signerPubkeyBuf].map(serializeBufferable);
+    const outTypes = [Point, BoolDeserializer()];
+    const result = this.wasm.callWasmExport("schnorr_multisig_validate_and_combine_signer_pubkeys", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  schnorrMultisigConstructSignatureRound1() {
+    const inArgs = [].map(serializeBufferable);
+    const outTypes = [Buffer128, Buffer128];
+    const result = this.wasm.callWasmExport("schnorr_multisig_construct_signature_round_1", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  schnorrMultisigConstructSignatureRound2(message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf) {
+    const inArgs = [message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf].map(serializeBufferable);
+    const outTypes = [Fq, BoolDeserializer()];
+    const result = this.wasm.callWasmExport("schnorr_multisig_construct_signature_round_2", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  schnorrMultisigCombineSignatures(message, signerPubkeysBuf, roundOneBuf, roundTwoBuf) {
+    const inArgs = [message, signerPubkeysBuf, roundOneBuf, roundTwoBuf].map(serializeBufferable);
+    const outTypes = [Buffer32, Buffer32, BoolDeserializer()];
+    const result = this.wasm.callWasmExport("schnorr_multisig_combine_signatures", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  aesEncryptBufferCbc(input, iv, key, length) {
+    const inArgs = [input, iv, key, length].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport("aes_encrypt_buffer_cbc", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  aesDecryptBufferCbc(input, iv, key, length) {
+    const inArgs = [input, iv, key, length].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport("aes_decrypt_buffer_cbc", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  srsInitSrs(pointsBuf, numPoints, g2PointBuf) {
+    const inArgs = [pointsBuf, numPoints, g2PointBuf].map(serializeBufferable);
+    const outTypes = [];
+    const result = this.wasm.callWasmExport("srs_init_srs", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  srsInitGrumpkinSrs(pointsBuf, numPoints) {
+    const inArgs = [pointsBuf, numPoints].map(serializeBufferable);
+    const outTypes = [];
+    const result = this.wasm.callWasmExport("srs_init_grumpkin_srs", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  examplesSimpleCreateAndVerifyProof() {
+    const inArgs = [].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport("examples_simple_create_and_verify_proof", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  testThreads(threads, iterations) {
+    const inArgs = [threads, iterations].map(serializeBufferable);
+    const outTypes = [NumberDeserializer()];
+    const result = this.wasm.callWasmExport("test_threads", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  commonInitSlabAllocator(circuitSize) {
+    const inArgs = [circuitSize].map(serializeBufferable);
+    const outTypes = [];
+    const result = this.wasm.callWasmExport("common_init_slab_allocator", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  acirGetCircuitSizes(constraintSystemBuf, honkRecursion) {
+    const inArgs = [constraintSystemBuf, honkRecursion].map(serializeBufferable);
+    const outTypes = [NumberDeserializer(), NumberDeserializer()];
+    const result = this.wasm.callWasmExport("acir_get_circuit_sizes", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  acirNewAcirComposer(sizeHint) {
+    const inArgs = [sizeHint].map(serializeBufferable);
+    const outTypes = [Ptr];
+    const result = this.wasm.callWasmExport("acir_new_acir_composer", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirDeleteAcirComposer(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [];
+    const result = this.wasm.callWasmExport("acir_delete_acir_composer", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  acirInitProvingKey(acirComposerPtr, constraintSystemBuf) {
+    const inArgs = [acirComposerPtr, constraintSystemBuf].map(serializeBufferable);
+    const outTypes = [];
+    const result = this.wasm.callWasmExport("acir_init_proving_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  acirCreateProof(acirComposerPtr, constraintSystemBuf, witnessBuf) {
+    const inArgs = [acirComposerPtr, constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport("acir_create_proof", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirProveAndVerifyUltraHonk(constraintSystemBuf, witnessBuf) {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport("acir_prove_and_verify_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirProveAndVerifyMegaHonk(constraintSystemBuf, witnessBuf) {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport("acir_prove_and_verify_mega_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirFoldAndVerifyProgramStack(constraintSystemBuf, witnessBuf) {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport("acir_fold_and_verify_program_stack", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirLoadVerificationKey(acirComposerPtr, vkBuf) {
+    const inArgs = [acirComposerPtr, vkBuf].map(serializeBufferable);
+    const outTypes = [];
+    const result = this.wasm.callWasmExport("acir_load_verification_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  acirInitVerificationKey(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [];
+    const result = this.wasm.callWasmExport("acir_init_verification_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return;
+  }
+  acirGetVerificationKey(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport("acir_get_verification_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirGetProvingKey(acirComposerPtr, acirVec) {
+    const inArgs = [acirComposerPtr, acirVec].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport("acir_get_proving_key", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirVerifyProof(acirComposerPtr, proofBuf) {
+    const inArgs = [acirComposerPtr, proofBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport("acir_verify_proof", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirGetSolidityVerifier(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [StringDeserializer()];
+    const result = this.wasm.callWasmExport("acir_get_solidity_verifier", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirSerializeProofIntoFields(acirComposerPtr, proofBuf, numInnerPublicInputs) {
+    const inArgs = [acirComposerPtr, proofBuf, numInnerPublicInputs].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr)];
+    const result = this.wasm.callWasmExport("acir_serialize_proof_into_fields", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirSerializeVerificationKeyIntoFields(acirComposerPtr) {
+    const inArgs = [acirComposerPtr].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr), Fr];
+    const result = this.wasm.callWasmExport("acir_serialize_verification_key_into_fields", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out;
+  }
+  acirProveUltraHonk(acirVec, witnessVec) {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport("acir_prove_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirVerifyUltraHonk(proofBuf, vkBuf) {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport("acir_verify_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirWriteVkUltraHonk(acirVec) {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport("acir_write_vk_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirProofAsFieldsUltraHonk(proofBuf) {
+    const inArgs = [proofBuf].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr)];
+    const result = this.wasm.callWasmExport("acir_proof_as_fields_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+  acirVkAsFieldsUltraHonk(vkBuf) {
+    const inArgs = [vkBuf].map(serializeBufferable);
+    const outTypes = [VectorDeserializer(Fr)];
+    const result = this.wasm.callWasmExport("acir_vk_as_fields_ultra_honk", inArgs, outTypes.map((t) => t.SIZE_IN_BYTES));
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+};
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js
+import { Worker } from "worker_threads";
+import { dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getCurrentDir2() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  } else {
+    return dirname2(fileURLToPath2(import.meta.url));
+  }
+}
+function createMainWorker() {
+  const __dirname2 = getCurrentDir2();
+  return new Worker(__dirname2 + `/main.worker.js`);
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/barretenberg_wasm_main/index.js
+var import_debug3 = __toESM(require_src(), 1);
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/helpers/node/index.js
+import os from "os";
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/helpers/node/node_endpoint.js
+function nodeEndpoint(nep) {
+  const listeners = /* @__PURE__ */ new WeakMap();
+  return {
+    postMessage: nep.postMessage.bind(nep),
+    addEventListener: (_, eh) => {
+      const l = (data) => {
+        if ("handleEvent" in eh) {
+          eh.handleEvent({ data });
+        } else {
+          eh({ data });
+        }
+      };
+      nep.on("message", l);
+      listeners.set(eh, l);
+    },
+    removeEventListener: (_, eh) => {
+      const l = listeners.get(eh);
+      if (!l) {
+        return;
+      }
+      nep.off("message", l);
+      listeners.delete(eh);
+    },
+    start: nep.start && nep.start.bind(nep)
+  };
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/helpers/node/index.js
+function getSharedMemoryAvailable() {
+  return true;
+}
+function getRemoteBarretenbergWasm(worker) {
+  return wrap(nodeEndpoint(worker));
+}
+function getNumCpu() {
+  return +process.env.HARDWARE_CONCURRENCY || os.cpus().length;
+}
+function killSelf() {
+  process.kill(process.pid);
+  throw new Error();
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/barretenberg_wasm_thread/factory/node/index.js
+import { Worker as Worker2 } from "worker_threads";
+import { dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function getCurrentDir3() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  } else {
+    return dirname3(fileURLToPath3(import.meta.url));
+  }
+}
+function createThreadWorker() {
+  const __dirname2 = getCurrentDir3();
+  return new Worker2(__dirname2 + `/thread.worker.js`);
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/barretenberg_wasm_base/index.js
+var import_debug2 = __toESM(require_src(), 1);
+var debug2 = (0, import_debug2.default)("bb.js:wasm");
+var BarretenbergWasmBase = class {
+  constructor() {
+    this.memStore = {};
+    this.logger = debug2;
+  }
+  getImportObj(memory) {
+    const importObj = {
+      // We need to implement a part of the wasi api:
+      // https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
+      // We literally only need to support random_get, everything else is noop implementated in barretenberg.wasm.
+      wasi_snapshot_preview1: {
+        random_get: (out, length) => {
+          out = out >>> 0;
+          const randomData = randomBytes(length);
+          const mem = this.getMemory();
+          mem.set(randomData, out);
+        },
+        clock_time_get: (a1, a2, out) => {
+          out = out >>> 0;
+          const ts = BigInt((/* @__PURE__ */ new Date()).getTime()) * 1000000n;
+          const view = new DataView(this.getMemory().buffer);
+          view.setBigUint64(out, ts, true);
+        },
+        proc_exit: () => {
+          this.logger('PANIC: proc_exit was called. This is maybe caused by "joining" with unstable wasi pthreads.');
+          this.logger(new Error().stack);
+          killSelf();
+        }
+      },
+      // These are functions implementations for imports we've defined are needed.
+      // The native C++ build defines these in a module called "env". We must implement TypeScript versions here.
+      env: {
+        /**
+         * The 'info' call we use for logging in C++, calls this under the hood.
+         * The native code will just print to std:err (to avoid std::cout which is used for IPC).
+         * Here we just emit the log line for the client to decide what to do with.
+         */
+        logstr: (addr) => {
+          const str = this.stringFromAddress(addr);
+          const m = this.getMemory();
+          const str2 = `${str} (mem: ${(m.length / (1024 * 1024)).toFixed(2)}MiB)`;
+          this.logger(str2);
+          if (str2.startsWith("WARNING:")) {
+            this.logger(new Error().stack);
+          }
+        },
+        get_data: (keyAddr, outBufAddr) => {
+          const key = this.stringFromAddress(keyAddr);
+          outBufAddr = outBufAddr >>> 0;
+          const data = this.memStore[key];
+          if (!data) {
+            this.logger(`get_data miss ${key}`);
+            return;
+          }
+          this.writeMemory(outBufAddr, data);
+        },
+        set_data: (keyAddr, dataAddr, dataLength) => {
+          const key = this.stringFromAddress(keyAddr);
+          dataAddr = dataAddr >>> 0;
+          this.memStore[key] = this.getMemorySlice(dataAddr, dataAddr + dataLength);
+        },
+        memory
+      }
+    };
+    return importObj;
+  }
+  exports() {
+    return this.instance.exports;
+  }
+  /**
+   * When returning values from the WASM, use >>> operator to convert signed representation to unsigned representation.
+   */
+  call(name, ...args) {
+    if (!this.exports()[name]) {
+      throw new Error(`WASM function ${name} not found.`);
+    }
+    try {
+      return this.exports()[name](...args) >>> 0;
+    } catch (err2) {
+      const message = `WASM function ${name} aborted, error: ${err2}`;
+      this.logger(message);
+      this.logger(err2.stack);
+      throw err2;
+    }
+  }
+  memSize() {
+    return this.getMemory().length;
+  }
+  /**
+   * Returns a copy of the data, not a view.
+   */
+  getMemorySlice(start, end) {
+    return this.getMemory().subarray(start, end).slice();
+  }
+  writeMemory(offset, arr) {
+    const mem = this.getMemory();
+    mem.set(arr, offset);
+  }
+  // PRIVATE METHODS
+  getMemory() {
+    return new Uint8Array(this.memory.buffer);
+  }
+  stringFromAddress(addr) {
+    addr = addr >>> 0;
+    const m = this.getMemory();
+    let i = addr;
+    for (; m[i] !== 0; ++i)
+      ;
+    const textDecoder = new TextDecoder("ascii");
+    return textDecoder.decode(m.slice(addr, i));
+  }
+};
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/barretenberg_wasm_main/heap_allocator.js
+var HeapAllocator = class {
+  constructor(wasm) {
+    this.wasm = wasm;
+    this.allocs = [];
+    this.inScratchRemaining = 1024;
+    this.outScratchRemaining = 1024;
+  }
+  copyToMemory(buffers) {
+    return buffers.map((buf) => {
+      if (buf.length <= this.inScratchRemaining) {
+        const ptr = this.inScratchRemaining -= buf.length;
+        this.wasm.writeMemory(ptr, buf);
+        return ptr;
+      } else {
+        const ptr = this.wasm.call("bbmalloc", buf.length);
+        this.wasm.writeMemory(ptr, buf);
+        this.allocs.push(ptr);
+        return ptr;
+      }
+    });
+  }
+  getOutputPtrs(outLens) {
+    return outLens.map((len) => {
+      const size = len || 4;
+      if (size <= this.outScratchRemaining) {
+        return this.outScratchRemaining -= size;
+      } else {
+        const ptr = this.wasm.call("bbmalloc", size);
+        this.allocs.push(ptr);
+        return ptr;
+      }
+    });
+  }
+  addOutputPtr(ptr) {
+    if (ptr >= 1024) {
+      this.allocs.push(ptr);
+    }
+  }
+  freeAll() {
+    for (const ptr of this.allocs) {
+      this.wasm.call("bbfree", ptr);
+    }
+  }
+};
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/barretenberg_wasm_main/index.js
+var debug3 = (0, import_debug3.default)("bb.js:wasm");
+var BarretenbergWasmMain = class _BarretenbergWasmMain extends BarretenbergWasmBase {
+  constructor() {
+    super(...arguments);
+    this.workers = [];
+    this.remoteWasms = [];
+    this.nextWorker = 0;
+    this.nextThreadId = 1;
+  }
+  getNumThreads() {
+    return this.workers.length + 1;
+  }
+  /**
+   * Init as main thread. Spawn child threads.
+   */
+  async init(module, threads = Math.min(getNumCpu(), _BarretenbergWasmMain.MAX_THREADS), logger = debug3, initial = 30, maximum = 2 ** 16) {
+    this.logger = logger;
+    const initialMb = initial * 2 ** 16 / (1024 * 1024);
+    const maxMb = maximum * 2 ** 16 / (1024 * 1024);
+    const shared = getSharedMemoryAvailable();
+    this.logger(`initial mem: ${initial} pages, ${initialMb}MiB. max mem: ${maximum} pages, ${maxMb}MiB. threads: ${threads}, shared: ${shared}`);
+    this.memory = new WebAssembly.Memory({ initial, maximum, shared });
+    const instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
+    this.instance = instance;
+    this.call("_initialize");
+    if (threads > 1) {
+      this.logger(`creating ${threads} worker threads...`);
+      this.workers = await Promise.all(Array.from({ length: threads - 1 }).map(createThreadWorker));
+      this.remoteWasms = await Promise.all(this.workers.map(getRemoteBarretenbergWasm));
+      await Promise.all(this.remoteWasms.map((w) => w.initThread(module, this.memory)));
+    }
+    this.logger("init complete.");
+  }
+  /**
+   * Called on main thread. Signals child threads to gracefully exit.
+   */
+  async destroy() {
+    await Promise.all(this.workers.map((w) => w.terminate()));
+  }
+  getImportObj(memory) {
+    const baseImports = super.getImportObj(memory);
+    return {
+      ...baseImports,
+      wasi: {
+        "thread-spawn": (arg) => {
+          arg = arg >>> 0;
+          const id = this.nextThreadId++;
+          const worker = this.nextWorker++ % this.remoteWasms.length;
+          this.remoteWasms[worker].call("wasi_thread_start", id, arg).catch(this.logger);
+          return id;
+        }
+      },
+      env: {
+        ...baseImports.env,
+        env_hardware_concurrency: () => {
+          return this.remoteWasms.length + 1;
+        }
+      }
+    };
+  }
+  callWasmExport(funcName, inArgs, outLens) {
+    const alloc = new HeapAllocator(this);
+    const inPtrs = alloc.copyToMemory(inArgs);
+    const outPtrs = alloc.getOutputPtrs(outLens);
+    this.call(funcName, ...inPtrs, ...outPtrs);
+    const outArgs = this.getOutputArgs(outLens, outPtrs, alloc);
+    alloc.freeAll();
+    return outArgs;
+  }
+  getOutputArgs(outLens, outPtrs, alloc) {
+    return outLens.map((len, i) => {
+      if (len) {
+        return this.getMemorySlice(outPtrs[i], outPtrs[i] + len);
+      }
+      const slice = this.getMemorySlice(outPtrs[i], outPtrs[i] + 4);
+      const ptr = new DataView(slice.buffer, slice.byteOffset, slice.byteLength).getUint32(0, true);
+      alloc.addOutputPtr(ptr);
+      const lslice = this.getMemorySlice(ptr, ptr + 4);
+      const length = new DataView(lslice.buffer, lslice.byteOffset, lslice.byteLength).getUint32(0, false);
+      return this.getMemorySlice(ptr + 4, ptr + 4 + length);
+    });
+  }
+};
+BarretenbergWasmMain.MAX_THREADS = 32;
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/index.js
+var import_debug4 = __toESM(require_src(), 1);
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/fetch_code/node/index.js
+import { readFile as readFile2 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function getCurrentDir4() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  } else {
+    return dirname4(fileURLToPath4(import.meta.url));
+  }
+}
+async function fetchCode(multithreaded) {
+  const path = getCurrentDir4() + "/../../barretenberg-threads.wasm";
+  return await readFile2(path);
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg_wasm/index.js
+var debug4 = (0, import_debug4.default)("bb.js:wasm");
+async function fetchModuleAndThreads(desiredThreads = 32) {
+  const shared = getSharedMemoryAvailable();
+  const availableThreads = shared ? await getAvailableThreads() : 1;
+  const limitedThreads = Math.min(desiredThreads, availableThreads, 32);
+  const code = await fetchCode(shared);
+  const module = await WebAssembly.compile(code);
+  return { module, threads: limitedThreads };
+}
+async function getAvailableThreads() {
+  if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) {
+    return navigator.hardwareConcurrency;
+  } else {
+    try {
+      const os2 = await import("os");
+      return os2.cpus().length;
+    } catch (e) {
+      debug4(`Could not detect environment. Falling back to one thread.: {e}`);
+      return 1;
+    }
+  }
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg/index.js
+var import_debug5 = __toESM(require_src(), 1);
+
+// ../../node_modules/@aztec/bb.js/dest/node/proof/index.js
+var serializedBufferSize = 4;
+var fieldByteSize = 32;
+var publicInputOffset = 3;
+var publicInputsOffsetBytes = publicInputOffset * fieldByteSize;
+function splitHonkProof(proofWithPublicInputs) {
+  const proofAsStrings = deflattenFields(proofWithPublicInputs.slice(4));
+  const numPublicInputs = Number(proofAsStrings[1]);
+  const publicInputsOffset = publicInputsOffsetBytes + serializedBufferSize;
+  const proofStart = proofWithPublicInputs.slice(0, publicInputsOffset);
+  const publicInputsSplitIndex = numPublicInputs * fieldByteSize;
+  const proofEnd = proofWithPublicInputs.slice(publicInputsOffset + publicInputsSplitIndex);
+  const proof = new Uint8Array([...proofStart, ...proofEnd]);
+  const publicInputs = proofWithPublicInputs.slice(publicInputsOffset, publicInputsOffset + publicInputsSplitIndex);
+  return {
+    proof,
+    publicInputs
+  };
+}
+function reconstructHonkProof(publicInputs, proof) {
+  const proofStart = proof.slice(0, publicInputsOffsetBytes + serializedBufferSize);
+  const proofEnd = proof.slice(publicInputsOffsetBytes + serializedBufferSize);
+  const proofWithPublicInputs = Uint8Array.from([...proofStart, ...publicInputs, ...proofEnd]);
+  return proofWithPublicInputs;
+}
+function reconstructUltraPlonkProof(proofData) {
+  const publicInputsConcatenated = flattenFieldsAsArray(proofData.publicInputs);
+  const proofWithPublicInputs = Uint8Array.from([...publicInputsConcatenated, ...proofData.proof]);
+  return proofWithPublicInputs;
+}
+function deflattenFields(flattenedFields) {
+  const publicInputSize = 32;
+  const chunkedFlattenedPublicInputs = [];
+  for (let i = 0; i < flattenedFields.length; i += publicInputSize) {
+    const publicInput = flattenedFields.slice(i, i + publicInputSize);
+    chunkedFlattenedPublicInputs.push(publicInput);
+  }
+  return chunkedFlattenedPublicInputs.map(uint8ArrayToHex);
+}
+function flattenFieldsAsArray(fields) {
+  const flattenedPublicInputs = fields.map(hexToUint8Array);
+  return flattenUint8Arrays(flattenedPublicInputs);
+}
+function flattenUint8Arrays(arrays) {
+  const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function uint8ArrayToHex(buffer) {
+  const hex = [];
+  buffer.forEach(function(i) {
+    let h = i.toString(16);
+    if (h.length % 2) {
+      h = "0" + h;
+    }
+    hex.push(h);
+  });
+  return "0x" + hex.join("");
+}
+function hexToUint8Array(hex) {
+  const sanitisedHex = BigInt(hex).toString(16).padStart(64, "0");
+  const len = sanitisedHex.length / 2;
+  const u82 = new Uint8Array(len);
+  let i = 0;
+  let j = 0;
+  while (i < len) {
+    u82[i] = parseInt(sanitisedHex.slice(j, j + 2), 16);
+    i += 1;
+    j += 2;
+  }
+  return u82;
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg/verifier.js
+var BarretenbergVerifier = class {
+  constructor(options = { threads: 1 }) {
+    this.options = options;
+  }
+  /** @ignore */
+  async instantiate() {
+    if (!this.api) {
+      const api = await Barretenberg.new(this.options);
+      await api.initSRSForCircuitSize(0);
+      this.acirComposer = await api.acirNewAcirComposer(0);
+      this.api = api;
+    }
+  }
+  /** @description Verifies a proof */
+  async verifyUltraPlonkProof(proofData, verificationKey) {
+    await this.instantiate();
+    await this.api.acirLoadVerificationKey(this.acirComposer, new RawBuffer(verificationKey));
+    const proof = reconstructUltraPlonkProof(proofData);
+    return await this.api.acirVerifyProof(this.acirComposer, proof);
+  }
+  /** @description Verifies a proof */
+  async verifyUltraHonkProof(proofData, verificationKey) {
+    await this.instantiate();
+    const proof = reconstructHonkProof(flattenFieldsAsArray(proofData.publicInputs), proofData.proof);
+    return await this.api.acirVerifyUltraHonk(proof, new RawBuffer(verificationKey));
+  }
+  async destroy() {
+    if (!this.api) {
+      return;
+    }
+    await this.api.destroy();
+  }
+};
+
+// ../../node_modules/fflate/esm/index.mjs
+import { createRequire } from "module";
+var require2 = createRequire("/");
+var Worker3;
+try {
+  Worker3 = require2("worker_threads").Worker;
+} catch (e) {
+}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1; i < 30; ++i) {
+    for (var j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a2 = freb(fleb, 2);
+var fl = _a2.b;
+var revfl = _a2.r;
+fl[28] = 258, revfl[258] = 28;
+var _b2 = freb(fdeb, 0);
+var fd = _b2.b;
+var revfd = _b2.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        var sv = i << 4 | cd[i];
+        var r_1 = mb - cd[i];
+        var v = le[cd[i] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i = 1; i < a.length; ++i) {
+    if (a[i] > m)
+      m = a[i];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i = 0; i < hcLen; ++i) {
+          clt[clim[i]] = bits(dat, pos + i * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i = 0; i < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (; ; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i = sym - 257, b = fleb[i];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (; bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (; bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var gzs = function(d) {
+  if (d[0] != 31 || d[1] != 139 || d[2] != 8)
+    err(6, "invalid gzip data");
+  var flg = d[3];
+  var st = 10;
+  if (flg & 4)
+    st += (d[10] | d[11] << 8) + 2;
+  for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
+    ;
+  return st + (flg & 2);
+};
+var gzl = function(d) {
+  var l = d.length;
+  return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+};
+var zls = function(d, dict) {
+  if ((d[0] & 15) != 8 || d[0] >> 4 > 7 || (d[0] << 8 | d[1]) % 31)
+    err(6, "invalid zlib data");
+  if ((d[1] >> 5 & 1) == +!dict)
+    err(6, "invalid zlib data: " + (d[1] & 32 ? "need" : "unexpected") + " dictionary");
+  return (d[1] >> 3 & 4) + 2;
+};
+function inflateSync(data, opts) {
+  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+function gunzipSync(data, opts) {
+  var st = gzs(data);
+  if (st + 8 > data.length)
+    err(6, "invalid gzip data");
+  return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
+}
+function unzlibSync(data, opts) {
+  return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+function decompressSync(data, opts) {
+  return data[0] == 31 && data[1] == 139 && data[2] == 8 ? gunzipSync(data, opts) : (data[0] & 15) != 8 || data[0] >> 4 > 7 || (data[0] << 8 | data[1]) % 31 ? inflateSync(data, opts) : unzlibSync(data, opts);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg/backend.js
+var UltraPlonkBackend = class {
+  constructor(acirBytecode, options = { threads: 1 }) {
+    this.options = options;
+    this.acirUncompressedBytecode = acirToUint8Array(acirBytecode);
+  }
+  /** @ignore */
+  async instantiate() {
+    if (!this.api) {
+      const api = await Barretenberg.new(this.options);
+      const honkRecursion = false;
+      const [_total, subgroupSize] = await api.acirGetCircuitSizes(this.acirUncompressedBytecode, honkRecursion);
+      await api.initSRSForCircuitSize(subgroupSize);
+      this.acirComposer = await api.acirNewAcirComposer(subgroupSize);
+      await api.acirInitProvingKey(this.acirComposer, this.acirUncompressedBytecode);
+      this.api = api;
+    }
+  }
+  /** @description Generates a proof */
+  async generateProof(compressedWitness) {
+    await this.instantiate();
+    const proofWithPublicInputs = await this.api.acirCreateProof(this.acirComposer, this.acirUncompressedBytecode, decompressSync(compressedWitness));
+    const numBytesInProofWithoutPublicInputs = 2144;
+    const splitIndex = proofWithPublicInputs.length - numBytesInProofWithoutPublicInputs;
+    const publicInputsConcatenated = proofWithPublicInputs.slice(0, splitIndex);
+    const proof = proofWithPublicInputs.slice(splitIndex);
+    const publicInputs = deflattenFields(publicInputsConcatenated);
+    return { proof, publicInputs };
+  }
+  /**
+   * Generates artifacts that will be passed to a circuit that will verify this proof.
+   *
+   * Instead of passing the proof and verification key as a byte array, we pass them
+   * as fields which makes it cheaper to verify in a circuit.
+   *
+   * The proof that is passed here will have been created using a circuit
+   * that has the #[recursive] attribute on its `main` method.
+   *
+   * The number of public inputs denotes how many public inputs are in the inner proof.
+   *
+   * @example
+   * ```typescript
+   * const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+   * ```
+   */
+  async generateRecursiveProofArtifacts(proofData, numOfPublicInputs = 0) {
+    await this.instantiate();
+    const proof = reconstructUltraPlonkProof(proofData);
+    const proofAsFields = (await this.api.acirSerializeProofIntoFields(this.acirComposer, proof, numOfPublicInputs)).slice(numOfPublicInputs);
+    await this.api.acirInitVerificationKey(this.acirComposer);
+    const vk = await this.api.acirSerializeVerificationKeyIntoFields(this.acirComposer);
+    return {
+      proofAsFields: proofAsFields.map((p) => p.toString()),
+      vkAsFields: vk[0].map((vk2) => vk2.toString()),
+      vkHash: vk[1].toString()
+    };
+  }
+  /** @description Verifies a proof */
+  async verifyProof(proofData) {
+    await this.instantiate();
+    await this.api.acirInitVerificationKey(this.acirComposer);
+    const proof = reconstructUltraPlonkProof(proofData);
+    return await this.api.acirVerifyProof(this.acirComposer, proof);
+  }
+  async getVerificationKey() {
+    await this.instantiate();
+    await this.api.acirInitVerificationKey(this.acirComposer);
+    return await this.api.acirGetVerificationKey(this.acirComposer);
+  }
+  async destroy() {
+    if (!this.api) {
+      return;
+    }
+    await this.api.destroy();
+  }
+};
+var serializedBufferSize2 = 4;
+var fieldByteSize2 = 32;
+var publicInputOffset2 = 3;
+var publicInputsOffsetBytes2 = publicInputOffset2 * fieldByteSize2;
+var UltraHonkBackend = class {
+  constructor(acirBytecode, options = { threads: 1 }) {
+    this.options = options;
+    this.acirUncompressedBytecode = acirToUint8Array(acirBytecode);
+  }
+  /** @ignore */
+  async instantiate() {
+    if (!this.api) {
+      const api = await Barretenberg.new(this.options);
+      const honkRecursion = true;
+      await api.acirInitSRS(this.acirUncompressedBytecode, honkRecursion);
+      this.api = api;
+    }
+  }
+  async generateProof(compressedWitness) {
+    await this.instantiate();
+    const proofWithPublicInputs = await this.api.acirProveUltraHonk(this.acirUncompressedBytecode, decompressSync(compressedWitness));
+    const proofAsStrings = deflattenFields(proofWithPublicInputs.slice(4));
+    const numPublicInputs = Number(proofAsStrings[1]);
+    const publicInputsOffset = publicInputsOffsetBytes2 + serializedBufferSize2;
+    const proofStart = proofWithPublicInputs.slice(0, publicInputsOffset);
+    const publicInputsSplitIndex = numPublicInputs * fieldByteSize2;
+    const proofEnd = proofWithPublicInputs.slice(publicInputsOffset + publicInputsSplitIndex);
+    const proof = new Uint8Array([...proofStart, ...proofEnd]);
+    const publicInputsConcatenated = proofWithPublicInputs.slice(publicInputsOffset, publicInputsOffset + publicInputsSplitIndex);
+    const publicInputs = deflattenFields(publicInputsConcatenated);
+    return { proof, publicInputs };
+  }
+  async verifyProof(proofData) {
+    await this.instantiate();
+    const proof = reconstructHonkProof(flattenFieldsAsArray(proofData.publicInputs), proofData.proof);
+    const vkBuf = await this.api.acirWriteVkUltraHonk(this.acirUncompressedBytecode);
+    return await this.api.acirVerifyUltraHonk(proof, new RawBuffer(vkBuf));
+  }
+  async getVerificationKey() {
+    await this.instantiate();
+    return await this.api.acirWriteVkUltraHonk(this.acirUncompressedBytecode);
+  }
+  // TODO(https://github.com/noir-lang/noir/issues/5661): Update this to handle Honk recursive aggregation in the browser once it is ready in the backend itself
+  async generateRecursiveProofArtifacts(_proof, _numOfPublicInputs) {
+    await this.instantiate();
+    const vkBuf = await this.api.acirWriteVkUltraHonk(this.acirUncompressedBytecode);
+    const vk = await this.api.acirVkAsFieldsUltraHonk(vkBuf);
+    return {
+      // TODO(https://github.com/noir-lang/noir/issues/5661)
+      proofAsFields: [],
+      vkAsFields: vk.map((vk2) => vk2.toString()),
+      // We use an empty string for the vk hash here as it is unneeded as part of the recursive artifacts
+      // The user can be expected to hash the vk inside their circuit to check whether the vk is the circuit
+      // they expect
+      vkHash: ""
+    };
+  }
+  async destroy() {
+    if (!this.api) {
+      return;
+    }
+    await this.api.destroy();
+  }
+};
+function acirToUint8Array(base64EncodedBytecode) {
+  const compressedByteCode = base64Decode(base64EncodedBytecode);
+  return decompressSync(compressedByteCode);
+}
+function base64Decode(input) {
+  if (typeof Buffer !== "undefined") {
+    const b = Buffer.from(input, "base64");
+    return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+  } else if (typeof atob === "function") {
+    return Uint8Array.from(atob(input), (c) => c.charCodeAt(0));
+  } else {
+    throw new Error("No implementation found for base64 decoding.");
+  }
+}
+
+// ../../node_modules/@aztec/bb.js/dest/node/barretenberg/index.js
+var debug5 = (0, import_debug5.default)("bb.js:wasm");
+var Barretenberg = class _Barretenberg extends BarretenbergApi {
+  constructor(worker, wasm, options) {
+    super(wasm);
+    this.worker = worker;
+    this.options = options;
+  }
+  /**
+   * Constructs an instance of Barretenberg.
+   * Launches it within a worker. This is necessary as it blocks waiting on child threads to complete,
+   * and blocking the main thread in the browser is not allowed.
+   * It threads > 1 (defaults to hardware availability), child threads will be created on their own workers.
+   */
+  static async new(options = {}) {
+    const worker = createMainWorker();
+    const wasm = getRemoteBarretenbergWasm(worker);
+    const { module, threads } = await fetchModuleAndThreads(options.threads);
+    await wasm.init(module, threads, proxy(debug5), options.memory?.initial, options.memory?.maximum);
+    return new _Barretenberg(worker, wasm, options);
+  }
+  async getNumThreads() {
+    return await this.wasm.getNumThreads();
+  }
+  async initSRSForCircuitSize(circuitSize) {
+    const crs = await Crs.new(circuitSize + 1, this.options.crsPath);
+    await this.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
+  }
+  async acirInitSRS(bytecode, honkRecursion) {
+    const [_total, subgroupSize] = await this.acirGetCircuitSizes(bytecode, honkRecursion);
+    return this.initSRSForCircuitSize(subgroupSize);
+  }
+  async destroy() {
+    await this.wasm.destroy();
+    await this.worker.terminate();
+  }
+};
+var barretenbergSyncSingleton;
+var barretenbergSyncSingletonPromise;
+var BarretenbergSync = class _BarretenbergSync extends BarretenbergApiSync {
+  constructor(wasm) {
+    super(wasm);
+  }
+  static async new() {
+    const wasm = new BarretenbergWasmMain();
+    const { module, threads } = await fetchModuleAndThreads(1);
+    await wasm.init(module, threads);
+    return new _BarretenbergSync(wasm);
+  }
+  static initSingleton() {
+    if (!barretenbergSyncSingletonPromise) {
+      barretenbergSyncSingletonPromise = _BarretenbergSync.new().then((s) => barretenbergSyncSingleton = s);
+    }
+    return barretenbergSyncSingletonPromise;
+  }
+  static getSingleton() {
+    if (!barretenbergSyncSingleton) {
+      throw new Error("First call BarretenbergSync.initSingleton() on @aztec/bb.js module.");
+    }
+    return barretenbergSyncSingleton;
+  }
+  getWasm() {
+    return this.wasm;
+  }
+};
+await BarretenbergSync.initSingleton();
+export {
+  Barretenberg,
+  BarretenbergSync,
+  BarretenbergVerifier,
+  Crs,
+  Fr,
+  RawBuffer,
+  UltraHonkBackend,
+  UltraPlonkBackend,
+  reconstructHonkProof,
+  splitHonkProof
+};
+/*! Bundled license information:
+
+comlink/dist/esm/comlink.mjs:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/