@hinkal/common 0.0.113 → 0.0.115

package/common250.mjs

@@ -0,0 +1,59 @@
+import { TransactionType as P } from "./common76.mjs";
+import "./common157.mjs";
+import { ExternalActionId as h } from "./common159.mjs";
+import { PendleAction as t } from "./common160.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "./common28.mjs";
+import "./common33.mjs";
+import "./common30.mjs";
+import "./common31.mjs";
+import "./common35.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+import "./common42.mjs";
+import "ethers";
+import "circomlibjs";
+import "./common51.mjs";
+import "axios";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import { getActionFromMetadata as g } from "./common117.mjs";
+import { getERC20Token as y } from "./common118.mjs";
+import "./common121.mjs";
+import "./common129.mjs";
+import { toEnumValue as A } from "./common206.mjs";
+import { txHistoryToBigInt as E } from "./common256.mjs";
+import { TokenChecker as m } from "./common73.mjs";
+import "./common77.mjs";
+import "./common72.mjs";
+import "libsodium-wrappers";
+const oo = (r, p, T) => {
+  const k = g(h.Pendle, E(r)), e = A(t, k), s = [], a = [];
+  let c;
+  const l = p[0], f = p[1];
+  return r.amountChanges.forEach((u, d) => {
+    let n = u.toBigInt(), i = 0n;
+    (e === t.SwapToYt || e === t.Mint) && (n += l.amount, i = f.amount), e && [
+      t.Deposit,
+      t.Withdraw,
+      t.Redeem,
+      t.SwapFromYt,
+      t.Checkpoint
+    ].includes(e) && (i = l.amount);
+    const o = y(r.erc20TokenAddresses[d], T) ?? {
+      erc20TokenAddress: r.erc20TokenAddresses[d]
+    };
+    "decimals" in o && m.isPendleToken(o) && !m.isPendleSyToken(o) ? a.push({ token: o, balance: n }) : "decimals" in o && m.isPendleSyToken(o) ? c = { token: o, balance: i } : s.push({ token: o, balance: n });
+  }), {
+    pendleTokens: a,
+    nonPendleTokens: s,
+    pendleAction: e,
+    syToken: c,
+    type: P.PENDLE
+  };
+};
+export {
+  oo as getPendleData
+};

package/common251.mjs

@@ -0,0 +1,75 @@
+import { TransactionType as d } from "./common76.mjs";
+import "./common157.mjs";
+import { VolatileAction as A } from "./common160.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import { getERC20Registry as W } from "./common170.mjs";
+import "./common28.mjs";
+import "./common33.mjs";
+import "./common30.mjs";
+import "./common31.mjs";
+import "./common35.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+import "./common42.mjs";
+import { caseInsensitiveEqual as a } from "./common134.mjs";
+import "ethers";
+import "circomlibjs";
+import "./common51.mjs";
+import "axios";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import { getERC20Token as l } from "./common118.mjs";
+import "./common121.mjs";
+import "./common129.mjs";
+import { VolatileHelper as g } from "./common77.mjs";
+import "./common72.mjs";
+import "libsodium-wrappers";
+const _ = async (r, u, n) => {
+  const c = W(n), { externalActionMetadata: B } = r, { volatileAmounts: m, redirectActionId: E, volatileAction: p } = g.decodeVolatileMetadata(B);
+  if (p === A.Deposit) {
+    const s = r.erc20TokenAddresses[0], t = c.find((e) => a(e.sharedAddress, s));
+    if (!t)
+      throw Error("Volatile not found in statistics");
+    return {
+      tokenWithBalance: {
+        token: l(t.erc20TokenAddress, n) ?? { erc20TokenAddress: t.erc20TokenAddress },
+        balance: m[0].toBigInt()
+      },
+      type: d.DEPOSIT
+    };
+  }
+  if (p === A.Withdraw) {
+    const s = r.erc20TokenAddresses[0], t = c.find((e) => a(e.sharedAddress, s));
+    if (!t)
+      throw Error("Volatile not found in statistics");
+    return {
+      tokenWithBalance: {
+        token: l(t.erc20TokenAddress, n) ?? { erc20TokenAddress: t.erc20TokenAddress },
+        balance: m[0].toBigInt()
+      },
+      type: d.WITHDRAW
+    };
+  }
+  if (p === A.Swap) {
+    const s = r.erc20TokenAddresses[0], t = r.erc20TokenAddresses[1], k = r.amountChanges[0].toBigInt(), i = c.find((o) => a(o.sharedAddress, s)), e = c.find((o) => a(o.sharedAddress, t));
+    if (!i && !e)
+      throw Error("Volatile not found in swap statistics");
+    const V = {
+      token: l(i ? i.erc20TokenAddress : s, n),
+      balance: i ? m[0].toBigInt() : k
+    }, T = u.find((o) => a(o.erc20TokenAddress, t));
+    let f = { token: l(t, n), balance: T?.amount };
+    if (e) {
+      const o = await g.getVolatileTokenBalance(n, t, T?.amount ?? 0n);
+      console.log("VOLATILE OUTPUT BALANCE: ", { balance: o }), f = { token: e, balance: o };
+    }
+    return { tokenIn: V, tokenOut: f, type: d.SWAP, protocol: E.toBigInt() };
+  }
+  return { type: d.UNKNOWN };
+};
+export {
+  _ as getVolatileData
+};

package/{snarkjsWorkerLogic-CVna_BW9.mjs → common252.mjs}

@@ -1,4 +1,4 @@
-import { W as k } from "./workerProxy-BDj498Ht.mjs";
+import { WorkerProxy as k } from "./common257.mjs";
 import * as c from "snarkjs";
 const $ = typeof process < "u" && process.versions != null && process.versions.node != null, i = (
   // @ts-expect-error webpack check is done like this

package/common253.mjs

@@ -0,0 +1,66 @@
+import { preProcessing as u } from "./common47.mjs";
+import { UserKeys as I } from "./common51.mjs";
+import { Utxo as S } from "./common71.mjs";
+import { poseidonFunction as g } from "./common45.mjs";
+import { MerkleTree as T } from "./common64.mjs";
+import { calcCommitmentsSiblingAndSides as k, calcAccessTokenSiblingsAndSides as C } from "./common148.mjs";
+import { WorkerProxy as M } from "./common257.mjs";
+import { ZKProofWorkerActionType as d } from "./common236.mjs";
+const l = new M(), f = (e) => {
+  const { inputUtxosSerialized: t, merkleTreeSerialized: n } = e.data, m = n.tree, r = new Map(
+    Object.entries(m).map(([a, c]) => [BigInt(a), BigInt(c)])
+  ), o = T.createWithData(
+    r,
+    BigInt(n.index),
+    BigInt(n.count),
+    g,
+    25n,
+    0n
+  ), i = t.map(
+    (a) => a.map((c) => new S(c))
+  ), { inCommitmentSiblings: s, inCommitmentSiblingSides: p } = k(i, o);
+  l.postMessageToMainThread({ inCommitmentSiblings: s, inCommitmentSiblingSides: p });
+}, A = (e) => {
+  const { userSignature: t, merkleTreeAccessTokenSerialized: n } = e.data, m = new I(t), r = n.tree, o = new Map(
+    Object.entries(r).map(([a, c]) => [BigInt(a), BigInt(c)])
+  ), i = T.createWithData(
+    o,
+    BigInt(n.index),
+    BigInt(n.count),
+    g,
+    25n,
+    0n
+  ), { accessTokenSiblings: s, accessTokenSiblingSides: p } = C(m, i);
+  l.postMessageToMainThread({ accessTokenSiblings: s, accessTokenSiblingSides: p });
+}, h = (e) => {
+  const { inputUtxosSerialized: t, onChainCreation: n } = e.data, r = t.map(
+    (o) => o.map((i) => new S(i))
+  ).map(
+    (o, i) => o.map((s) => n[i] ? "0" : s.getNullifier())
+  );
+  l.postMessageToMainThread(r);
+}, w = async (e) => {
+  await u();
+  const { type: t } = e.payload;
+  switch (t) {
+    case d.CALC_COMMITMENTS_SIBLING_AND_SIDES:
+      f(e.payload);
+      return;
+    case d.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES:
+      A(e.payload);
+      return;
+    case d.BUILD_IN_NULLIFIERS:
+      h(e.payload);
+      return;
+    default:
+      throw Error(`Unknown worker message type ${t}`);
+  }
+};
+l.attachWorkerSideOnMessage(w);
+export {
+  l as default,
+  h as handleBuildInNullifiers,
+  A as handleCalcAccessTokenSiblingAndSides,
+  f as handleCalcCommitmentsSiblingAndSides,
+  w as onWorkerMessage
+};

package/common254.mjs

@@ -0,0 +1,70 @@
+import { preProcessing as f } from "./common47.mjs";
+import { UserKeys as p } from "./common51.mjs";
+import { Utxo as h } from "./common71.mjs";
+import { decryptUtxoConstructorArgs as y, decryptUtxo as m } from "./common50.mjs";
+import { decodeUtxoConstructorArgs as U, checkUtxoSignature as g } from "./common49.mjs";
+import { logError as d } from "./common84.mjs";
+import { WorkerProxy as x } from "./common257.mjs";
+import { UtxoWorkerActionType as l } from "./common210.mjs";
+const a = new x(), T = async ({ data: e }) => {
+  const { utxos: t, nullifiers: o } = e, s = t.filter((r) => {
+    const c = new h(r);
+    return !o.has(c.getNullifier());
+  });
+  a.postMessageToMainThread(s);
+}, v = async ({ data: e }) => {
+  const t = new p(e.signature), o = t.getShieldedPrivateKey(), s = e.encryptedOutputs.map((r) => {
+    try {
+      return r.isPositive ? y(Buffer.from(r.value.slice(2), "hex"), t) : U(r.value, o);
+    } catch {
+      return;
+    }
+  }).filter((r) => r !== void 0);
+  a.postMessageToMainThread(s);
+}, k = async ({ data: e }) => {
+  const t = new p(e.signature), o = [], { encryptedOutputs: s } = e;
+  let { lastOutput: r } = e;
+  for (let c = 0; c < s.length; c += 1) {
+    const n = s[c];
+    if (r = n.value, n.isPositive)
+      try {
+        const i = m(Buffer.from(r.slice(2), "hex"), t);
+        if (!i.erc20TokenAddress || !i.amount || !i.stealthAddress)
+          throw Error("bruh");
+        o.map((u) => u.value).includes(n.value) || o.push(n);
+      } catch {
+        d("Utxo not decrypted");
+      }
+    else
+      try {
+        g(r, t.getShieldedPrivateKey()) && (o.map((u) => u.value).includes(n.value) || o.push(n));
+      } catch {
+        d("Utxo not decoded");
+      }
+  }
+  a.postMessageToMainThread({ additionalEncryptedOutputs: o, lastOutput: r });
+}, w = async (e) => {
+  await f();
+  const { type: t } = e.payload;
+  switch (t) {
+    case l.BATCH_FILTER_UTXOS_WITH_NULLIFIER:
+      T(e.payload);
+      return;
+    case l.BUILD_UTXOS:
+      v(e.payload);
+      return;
+    case l.DECIPHER_OUTPUTS:
+      k(e.payload);
+      return;
+    default:
+      throw Error(`Unknown worker message type ${t}`);
+  }
+};
+a.attachWorkerSideOnMessage(w);
+export {
+  a as default,
+  v as handleBuildUtxosMessage,
+  k as handleDecipherMessage,
+  T as handleFilterUtxosWithNullifier,
+  w as onWorkerMessage
+};

package/common255.mjs

@@ -0,0 +1,211 @@
+import { chainIds as e } from "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "ethers";
+import "circomlibjs";
+import "./common51.mjs";
+import "axios";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import { logError as x } from "./common84.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common33.mjs";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const p = {
+  ethMainnet: "https://hinkal-zk-verifiers-may-2024.s3.us-west-1.amazonaws.com/",
+  polygon: "https://hinkal-zk-new-verifiers.s3.us-west-1.amazonaws.com/",
+  bnb: "https://hinkal-zk-verifiers-may-2024.s3.us-west-1.amazonaws.com/",
+  arbitrum: "https://hinkal-zk-verifiers-may-2024.s3.us-west-1.amazonaws.com/",
+  optimism: "https://hinkal-zk-new-verifiers.s3.us-west-1.amazonaws.com/",
+  avalanche: "https://hinkal-zk-new-verifiers.s3.us-west-1.amazonaws.com/",
+  base: "https://hinkal-zk-verifiers-may-2024.s3.us-west-1.amazonaws.com/",
+  blast: "https://hinkal-zk-verifiers-may-2024.s3.us-west-1.amazonaws.com/"
+}, r = (s) => {
+  switch (s) {
+    case e.ethMainnet:
+      return p.ethMainnet;
+    case e.polygon:
+      return p.polygon;
+    case e.bnbMainnet:
+      return p.bnb;
+    case e.arbMainnet:
+      return p.arbitrum;
+    case e.optimism:
+      return p.optimism;
+    case e.avalanche:
+      return p.avalanche;
+    case e.base:
+      return p.base;
+    case e.blast:
+      return p.blast;
+    default:
+      return x("Warning: no S3 bucket specified for selected chainid: ", s), p.polygon;
+  }
+}, E = (s) => {
+  const a = r(s);
+  return {
+    swapperM1x2x1Zkey: `${a}swapperM1x2x1_final-31337.zkey`,
+    swapperM1x2x1Wasm: `${a}swapperM1x2x1-31337.wasm`,
+    swapperM1x6x1Zkey: `${a}swapperM1x6x1_final-31337.zkey`,
+    swapperM1x6x1Wasm: `${a}swapperM1x6x1-31337.wasm`,
+    swapperME1x2x1Zkey: `${a}swapperME1x2x1_final-31337.zkey`,
+    swapperME1x2x1Wasm: `${a}swapperME1x2x1-31337.wasm`,
+    swapperM2x2x1Zkey: `${a}swapperM2x2x1_final-31337.zkey`,
+    swapperM2x2x1Wasm: `${a}swapperM2x2x1-31337.wasm`,
+    swapperM2x6x1Zkey: `${a}swapperM2x6x1_final-31337.zkey`,
+    swapperM2x6x1Wasm: `${a}swapperM2x6x1-31337.wasm`,
+    swapperMO2x2x1Zkey: `${a}swapperMO2x2x1_final-31337.zkey`,
+    swapperMO2x2x1Wasm: `${a}swapperMO2x2x1-31337.wasm`,
+    swapperMO2x6x1Zkey: `${a}swapperMO2x6x1_final-31337.zkey`,
+    swapperMO2x6x1Wasm: `${a}swapperMO2x6x1-31337.wasm`,
+    swapperToken2x2x1Zkey: `${a}swapperToken2x2x1_final-31337.zkey`,
+    swapperToken2x2x1Wasm: `${a}swapperToken2x2x1-31337.wasm`,
+    swapperToken2x6x1Zkey: `${a}swapperToken2x6x1_final-31337.zkey`,
+    swapperToken2x6x1Wasm: `${a}swapperToken2x6x1-31337.wasm`,
+    swapperM3x2x1Zkey: `${a}swapperM3x2x1_final-31337.zkey`,
+    swapperM3x2x1Wasm: `${a}swapperM3x2x1-31337.wasm`,
+    swapperM3x6x1Zkey: `${a}swapperM3x6x1_final-31337.zkey`,
+    swapperM3x6x1Wasm: `${a}swapperM3x6x1-31337.wasm`,
+    swapperMO3x2x1Zkey: `${a}swapperMO3x2x1_final-31337.zkey`,
+    swapperMO3x2x1Wasm: `${a}swapperMO3x2x1-31337.wasm`,
+    swapperMO3x6x1Zkey: `${a}swapperMO3x6x1_final-31337.zkey`,
+    swapperMO3x6x1Wasm: `${a}swapperMO3x6x1-31337.wasm`,
+    swapperM4x2x1Zkey: `${a}swapperM4x2x1_final-31337.zkey`,
+    swapperM4x2x1Wasm: `${a}swapperM4x2x1-31337.wasm`,
+    swapperM4x6x1Zkey: `${a}swapperM4x6x1_final-31337.zkey`,
+    swapperM4x6x1Wasm: `${a}swapperM4x6x1-31337.wasm`,
+    swapperMO4x2x1Zkey: `${a}swapperMO4x2x1_final-31337.zkey`,
+    swapperMO4x2x1Wasm: `${a}swapperMO4x2x1-31337.wasm`,
+    swapperMO4x6x1Zkey: `${a}swapperMO4x6x1_final-31337.zkey`,
+    swapperMO4x6x1Wasm: `${a}swapperMO4x6x1-31337.wasm`,
+    swapperM5x2x1Zkey: `${a}swapperM5x2x1_final-31337.zkey`,
+    swapperM5x2x1Wasm: `${a}swapperM5x2x1-31337.wasm`,
+    swapperM5x6x1Zkey: `${a}swapperM5x6x1_final-31337.zkey`,
+    swapperM5x6x1Wasm: `${a}swapperM5x6x1-31337.wasm`,
+    swapperMO5x2x1Zkey: `${a}swapperMO5x2x1_final-31337.zkey`,
+    swapperMO5x2x1Wasm: `${a}swapperMO5x2x1-31337.wasm`,
+    swapperMO5x6x1Zkey: `${a}swapperMO5x6x1_final-31337.zkey`,
+    swapperMO5x6x1Wasm: `${a}swapperMO5x6x1-31337.wasm`,
+    swapperMTS2x2x1Zkey: "swapperMTS2x2x1_final-31337.zkey",
+    swapperMTS2x2x1Wasm: "swapperMTS2x2x1-31337.wasm",
+    transactionsProverZkey: `${a}transactionsProver.zkey`,
+    transactionsProverWasm: `${a}transactionsProver.wasm`,
+    stakeProverZkey: `${a}StakeProver_final-31337.zkey`,
+    stakeProverWasm: `${a}StakeProver-31337.wasm`,
+    stakeProverPermissionlessZkey: `${a}StakeProverPermissionless_final-31337.zkey`,
+    stakeProverPermissionlessWasm: `${a}StakeProverPermissionless-31337.wasm`,
+    swapperMW1x2Wasm: `${a}swapperMW1x2-31337.wasm`,
+    swapperMW1x2Zkey: `${a}swapperMW1x2_final-31337.zkey`,
+    swapperMW1x6Wasm: `${a}swapperMW1x6-31337.wasm`,
+    swapperMW1x6Zkey: `${a}swapperMW1x6_final-31337.zkey`,
+    swapperMW2x2Wasm: `${a}swapperMW2x2-31337.wasm`,
+    swapperMW2x2Zkey: `${a}swapperMW2x2_final-31337.zkey`,
+    swapperMW2x6Wasm: `${a}swapperMW2x6-31337.wasm`,
+    swapperMW2x6Zkey: `${a}swapperMW2x6_final-31337.zkey`,
+    swapperMW3x2Wasm: `${a}swapperMW3x2-31337.wasm`,
+    swapperMW3x2Zkey: `${a}swapperMW3x2_final-31337.zkey`,
+    swapperMW3x6Wasm: `${a}swapperMW3x6-31337.wasm`,
+    swapperMW3x6Zkey: `${a}swapperMW3x6_final-31337.zkey`,
+    swapperMW4x2Wasm: `${a}swapperMW4x2-31337.wasm`,
+    swapperMW4x2Zkey: `${a}swapperMW4x2_final-31337.zkey`,
+    swapperMW4x6Wasm: `${a}swapperMW4x6-31337.wasm`,
+    swapperMW4x6Zkey: `${a}swapperMW4x6_final-31337.zkey`,
+    swapperMW5x2Wasm: `${a}swapperMW5x2-31337.wasm`,
+    swapperMW5x2Zkey: `${a}swapperMW5x2_final-31337.zkey`,
+    swapperMW5x6Wasm: `${a}swapperMW5x6-31337.wasm`,
+    swapperMW5x6Zkey: `${a}swapperMW5x6_final-31337.zkey`
+  };
+}, g = {
+  swapperM1x2x1Zkey: "swapperM1x2x1_final-31337.zkey",
+  swapperM1x2x1Wasm: "swapperM1x2x1-31337.wasm",
+  swapperM1x6x1Zkey: "swapperM1x6x1_final-31337.zkey",
+  swapperM1x6x1Wasm: "swapperM1x6x1-31337.wasm",
+  swapperMO1x2x1Zkey: "swapperMO1x2x1_final-31337.zkey",
+  swapperMO1x2x1Wasm: "swapperMO1x2x1-31337.wasm",
+  swapperMO1x6x1Zkey: "swapperMO1x6x1_final-31337.zkey",
+  swapperMO1x6x1Wasm: "swapperMO1x6x1-31337.wasm",
+  swapperME1x2x1Zkey: "swapperME1x2x1_final-31337.zkey",
+  swapperME1x2x1Wasm: "swapperME1x2x1-31337.wasm",
+  swapperM2x2x1Zkey: "swapperM2x2x1_final-31337.zkey",
+  swapperM2x2x1Wasm: "swapperM2x2x1-31337.wasm",
+  swapperM2x6x1Zkey: "swapperM2x6x1_final-31337.zkey",
+  swapperM2x6x1Wasm: "swapperM2x6x1-31337.wasm",
+  swapperMO2x2x1Zkey: "swapperMO2x2x1_final-31337.zkey",
+  swapperMO2x2x1Wasm: "swapperMO2x2x1-31337.wasm",
+  swapperMO2x6x1Zkey: "swapperMO2x6x1_final-31337.zkey",
+  swapperMO2x6x1Wasm: "swapperMO2x6x1-31337.wasm",
+  swapperToken2x2x1Zkey: "swapperToken2x2x1_final-31337.zkey",
+  swapperToken2x2x1Wasm: "swapperToken2x2x1-31337.wasm",
+  swapperToken2x6x1Zkey: "swapperToken2x6x1_final-31337.zkey",
+  swapperToken2x6x1Wasm: "swapperToken2x6x1-31337.wasm",
+  swapperM3x2x1Zkey: "swapperM3x2x1_final-31337.zkey",
+  swapperM3x2x1Wasm: "swapperM3x2x1-31337.wasm",
+  swapperM3x6x1Zkey: "swapperM3x6x1_final-31337.zkey",
+  swapperM3x6x1Wasm: "swapperM3x6x1-31337.wasm",
+  swapperMO3x2x1Zkey: "swapperMO3x2x1_final-31337.zkey",
+  swapperMO3x2x1Wasm: "swapperMO3x2x1-31337.wasm",
+  swapperMO3x6x1Zkey: "swapperMO3x6x1_final-31337.zkey",
+  swapperMO3x6x1Wasm: "swapperMO3x6x1-31337.wasm",
+  swapperM4x2x1Zkey: "swapperM4x2x1_final-31337.zkey",
+  swapperM4x2x1Wasm: "swapperM4x2x1-31337.wasm",
+  swapperM4x6x1Zkey: "swapperM4x6x1_final-31337.zkey",
+  swapperM4x6x1Wasm: "swapperM4x6x1-31337.wasm",
+  swapperMO4x2x1Zkey: "swapperMO4x2x1_final-31337.zkey",
+  swapperMO4x2x1Wasm: "swapperMO4x2x1-31337.wasm",
+  swapperMO4x6x1Zkey: "swapperMO4x6x1_final-31337.zkey",
+  swapperMO4x6x1Wasm: "swapperMO4x6x1-31337.wasm",
+  swapperM5x2x1Zkey: "swapperM5x2x1_final-31337.zkey",
+  swapperM5x2x1Wasm: "swapperM5x2x1-31337.wasm",
+  swapperM5x6x1Zkey: "swapperM5x6x1_final-31337.zkey",
+  swapperM5x6x1Wasm: "swapperM5x6x1-31337.wasm",
+  swapperMO5x2x1Zkey: "swapperMO5x2x1_final-31337.zkey",
+  swapperMO5x2x1Wasm: "swapperMO5x2x1-31337.wasm",
+  swapperMO5x6x1Zkey: "swapperMO5x6x1_final-31337.zkey",
+  swapperMO5x6x1Wasm: "swapperMO5x6x1-31337.wasm",
+  swapperMTS2x2x1Zkey: "swapperMTS2x2x1_final-31337.zkey",
+  swapperMTS2x2x1Wasm: "swapperMTS2x2x1-31337.wasm",
+  transactionsProverZkey: "transactionsProver.zkey",
+  transactionsProverWasm: "transactionsProver.wasm",
+  stakeProverZkey: "StakeProver_final-31337.zkey",
+  stakeProverWasm: "StakeProver-31337.wasm",
+  stakeProverPermissionlessZkey: "StakeProverPermissionless_final-31337.zkey",
+  stakeProverPermissionlessWasm: "StakeProverPermissionless-31337.wasm",
+  receiverZkey: "receiver_final-31337.zkey",
+  receiverWasm: "receiver-31337.wasm",
+  swapperMW1x2Wasm: "swapperMW1x2-31337.wasm",
+  swapperMW1x2Zkey: "swapperMW1x2_final-31337.zkey",
+  swapperMW1x6Wasm: "swapperMW1x6-31337.wasm",
+  swapperMW1x6Zkey: "swapperMW1x6_final-31337.zkey",
+  swapperMW2x2Wasm: "swapperMW2x2-31337.wasm",
+  swapperMW2x2Zkey: "swapperMW2x2_final-31337.zkey",
+  swapperMW2x6Wasm: "swapperMW2x6-31337.wasm",
+  swapperMW2x6Zkey: "swapperMW2x6_final-31337.zkey",
+  swapperMW3x2Wasm: "swapperMW3x2-31337.wasm",
+  swapperMW3x2Zkey: "swapperMW3x2_final-31337.zkey",
+  swapperMW3x6Wasm: "swapperMW3x6-31337.wasm",
+  swapperMW3x6Zkey: "swapperMW3x6_final-31337.zkey",
+  swapperMW4x2Wasm: "swapperMW4x2-31337.wasm",
+  swapperMW4x2Zkey: "swapperMW4x2_final-31337.zkey",
+  swapperMW4x6Wasm: "swapperMW4x6-31337.wasm",
+  swapperMW4x6Zkey: "swapperMW4x6_final-31337.zkey",
+  swapperMW5x2Wasm: "swapperMW5x2-31337.wasm",
+  swapperMW5x2Zkey: "swapperMW5x2_final-31337.zkey",
+  swapperMW5x6Wasm: "swapperMW5x6-31337.wasm",
+  swapperMW5x6Zkey: "swapperMW5x6_final-31337.zkey"
+};
+export {
+  g as localVerifiers,
+  E as prodVerifiers
+};

package/common256.mjs

@@ -0,0 +1,8 @@
+const o = (t) => ({
+  ...t,
+  amountChanges: t.amountChanges.map((n) => BigInt(n.toString())),
+  externalActionId: t.externalActionId.toBigInt()
+});
+export {
+  o as txHistoryToBigInt
+};

package/{workerProxy-BDj498Ht.mjs → common257.mjs}

@@ -50,5 +50,5 @@ class i {
   }
 }
 export {
-  i as W
+  i as WorkerProxy
 };