@hinkal/common 0.0.104 → 0.0.106

package/functions/protocols/curve.protocols.js

@@ -0,0 +1,45 @@
+import { getNonLocalhostChainId as o, chainIds as t } from "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "ethers";
+import "circomlibjs";
+import "../../data-structures/crypto-keys/keys.js";
+import "axios";
+import "../../data-structures/crypto-keys/encryptDecryptUtxo.js";
+import "../web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../utils/external-action.utils.js";
+import "../../data-structures/custom-token-registry/CustomTokenRegistry.js";
+import "../utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "../utils/userAgent.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import "../../data-structures/volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+const v = (r) => {
+  switch (o(r)) {
+    case t.polygon:
+      return "0x172370d5Cd63279eFa6d502DAB29171933a610AF";
+    case t.arbMainnet:
+      return "0x11cdb42b0eb46d95f990bedd4695a6e3fa034978";
+    case t.ethMainnet:
+      return "0xD533a949740bb3306d119CC777fa900bA034cd52";
+    case t.avalanche:
+      return "0x47536F17F4fF30e64A96a7555826b8f9e66ec468";
+    case t.optimism:
+      return "0x0994206dfe8de6ec6920ff4d779b0d950605fb53";
+    case t.base:
+      return "0x8Ee73c484A26e0A5df2Ee2a4960B789967dd0415";
+    default:
+      return "0xD533a949740bb3306d119CC777fa900bA034cd52";
+  }
+};
+export {
+  v as getCRV
+};

package/functions/protocols/pendle.helpers.js

@@ -0,0 +1,108 @@
+import "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import { PendleAction as n } from "../../types/hinkal.types.js";
+import "../../types/transactions.types.js";
+import { PendleAssetType as i, PendleSwapType as t } from "../../types/pendle.types.js";
+import "../../types/curve.types.js";
+import "ethers";
+import "circomlibjs";
+import "../../data-structures/crypto-keys/keys.js";
+import "axios";
+import "../../data-structures/crypto-keys/encryptDecryptUtxo.js";
+import "../web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../utils/external-action.utils.js";
+import { getERC20Token as T } from "../utils/erc20tokenFunctions.js";
+import "../utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import { API_CONFIG as p } from "../../constants/server.constants.js";
+import "../../constants/vite.constants.js";
+import { caseInsensitiveEqual as d } from "../utils/caseInsensitive.utils.js";
+import "../utils/userAgent.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import { isInEnum as w } from "../utils/enum.utils.js";
+import "../../data-structures/volatile-helper/VolatileHelper.js";
+import "../../data-structures/custom-token-registry/CustomTokenRegistry.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+function H(e) {
+  if (!e)
+    return;
+  const r = T(e.address, e.chainId);
+  if (!r?.isVolatile)
+    return r?.symbol.toLowerCase() === "weth" && console.log("token:", r), r;
+}
+function J(e, r) {
+  if (!e || !r)
+    return;
+  let o;
+  switch (r) {
+    case i.YT:
+      o = e?.yt;
+      break;
+    case i.PT:
+      o = e?.pt;
+      break;
+    case i.PENDLE_LP:
+      o = e?.lp;
+      break;
+    case i.SY:
+      o = e?.sy;
+      break;
+    default:
+      o = void 0;
+      break;
+  }
+  return o;
+}
+const K = (e, r, o) => {
+  if (d(e.yt.address, o.erc20TokenAddress))
+    return t.SwapExactTokenForYt;
+  if (d(e.pt.address, o.erc20TokenAddress))
+    return t.SwapExactTokenForPt;
+  if (d(e.yt.address, r.erc20TokenAddress))
+    return t.SwapExactYtForToken;
+  if (d(e.pt.address, r.erc20TokenAddress))
+    return t.SwapExactPtForToken;
+}, Q = (e) => {
+  let r;
+  switch (e) {
+    case t.SwapExactTokenForYt:
+      r = p.ROUTES.pendleSwapExactTokenForYT;
+      break;
+    case t.SwapExactTokenForPt:
+      r = p.ROUTES.pendleSwapExactTokenForPt;
+      break;
+    case t.SwapExactYtForToken:
+      r = p.ROUTES.pendleSwapExactYtForToken;
+      break;
+    case t.SwapExactPtForToken:
+      r = p.ROUTES.pendleSwapExactPtForToken;
+      break;
+    default:
+      throw new Error("Cant determine Pendle Swap Type Api Route");
+  }
+  return r;
+}, W = (e, r, o, s) => {
+  if (!w(n, e))
+    throw new Error("getTokenIndexForPendleFlatFee: Invalid Pendle Action");
+  if (s)
+    return o.findIndex(
+      (a) => a.toLowerCase() === s?.toLowerCase()
+    );
+  const l = r.findIndex((a) => a > 0n), c = r.length - 1;
+  if (r[c] <= 0n)
+    throw new Error("getTokenIndexForPendleFlatFee: Last token in amountChange is not > 0");
+  let m = l;
+  return (e === n.Mint || e === n.Redeem || e === n.PoolRemove) && (m = l), m;
+};
+export {
+  K as determinePendleSwapType,
+  Q as determinePendleSwapTypeApiRoute,
+  H as erc20TokenFromPendleAsset,
+  J as getAssetTypeFromPendleMarket,
+  W as getTokenIndexForPendleFlatFee
+};

package/functions/snarkjs/common.snarkjs.js

@@ -0,0 +1,96 @@
+import { ethers as i } from "ethers";
+import { CIRCOM_P as u } from "../../constants/protocol.constants.js";
+import { UserKeys as g } from "../../data-structures/crypto-keys/keys.js";
+import { encryptUtxo as h } from "../../data-structures/crypto-keys/encryptDecryptUtxo.js";
+import { defaultHookData as S } from "../../types/circom-data.types.js";
+import { getExternalActionIdHash as m } from "../utils/external-action.utils.js";
+const k = (t, e) => t.map((r, n) => r.map((s) => e[n] ? "0" : s.getNullifier())), B = (t, e) => t.map((r, n) => r.map((s) => e[n] ? "0" : s.getCommitment())), y = (t, e, r = !1) => {
+  const n = [];
+  for (let s = 0; s < t.length; s += 1) {
+    let o = 0n, l = 0n;
+    for (let a = 0; a < t[s].length; a += 1)
+      o += t[s][a].amount;
+    for (let a = 0; a < e[s].length; a += 1)
+      l += e[s][a].amount;
+    l - o < 0 ? r ? n.push(l - o) : n.push(u + (l - o)) : n.push(l - o);
+  }
+  return n;
+}, O = (t, e) => {
+  const r = [[""]];
+  for (let n = 0; n < t.length; n += 1)
+    n > 0 && r.push([""]), t[n].forEach((s, o) => {
+      r[n][o] = `0x${Buffer.from(h(s, e)).toString("hex")}`;
+    });
+  return r;
+}, T = (t, e) => {
+  const r = [];
+  for (let s = 0; s < t.length; s += 1) {
+    r.push([]);
+    for (let o = 0; o < t[s].length; o += 1)
+      r[s][o] = e.getSiblingHashesForVerification(BigInt(t[s][o].getCommitment())).map((l) => l.toString());
+  }
+  const n = [];
+  for (let s = 0; s < t.length; s += 1) {
+    n.push([]);
+    for (let o = 0; o < t[s].length; o += 1)
+      n[s][o] = e.getSiblingSides(BigInt(t[s][o].getCommitment())).map((l) => l.toString());
+  }
+  return { inCommitmentSiblings: r, inCommitmentSiblingSides: n };
+}, j = (t, e) => {
+  const r = e.getSiblingHashesForVerification(BigInt(t.getAccessKey())).map((s) => s.toString()), n = e.getSiblingSides(BigInt(t.getAccessKey())).map((s) => s.toString());
+  return { accessTokenSiblings: r, accessTokenSiblingSides: n };
+}, E = (t) => {
+  const e = { ...t };
+  return e.amountChanges = t.amountChanges.map((r) => r.toString()), e.calldataHash = t.calldataHash.toString(), e.rootHashAccessToken = t.rootHashAccessToken?.toString(), e.stealthAddressStructure.extraRandomization = t.stealthAddressStructure.extraRandomization.toString(), e.stealthAddressStructure.stealthAddress = t.stealthAddressStructure.stealthAddress.toString(), e.stealthAddressStructure.H0 = t.stealthAddressStructure.H0.toString(), e.stealthAddressStructure.H1 = t.stealthAddressStructure.H1.toString(), e.rootHashHinkal = t.rootHashHinkal?.toString(), e.externalActionId = t.externalActionId?.toString(), e.flatFees = t.flatFees.map((r) => r.toString()), e;
+}, F = (t) => {
+  const e = { ...t };
+  return e.amountChanges = t.amountChanges.map((r) => BigInt(r)), e.calldataHash = BigInt(t.calldataHash), e.rootHashAccessToken = BigInt(t.rootHashAccessToken), e.rootHashHinkal = BigInt(t.rootHashHinkal), e.externalActionId = BigInt(t.externalActionId), e;
+}, M = (t, e, r, n, s, o, l, a) => {
+  const d = Object.values(a || S), c = i.utils.defaultAbiCoder.encode(
+    [
+      "uint16",
+      "address",
+      "address",
+      "uint256",
+      "bytes",
+      "tuple(address, address, bytes, bytes)",
+      "bytes[][]",
+      "uint256[]"
+    ],
+    [
+      t,
+      e,
+      r,
+      typeof n == "bigint" ? n : m(n),
+      s,
+      d,
+      o,
+      l
+    ]
+  );
+  return BigInt(i.utils.keccak256(c)) % u;
+}, f = (t) => t.startsWith("swapperMO") || t.startsWith("swapperME") ? 2 : t.startsWith("swapperMW") ? 1 : 0, W = (t, e, r, n, s, o) => {
+  const l = f(t);
+  return 9 + e.length + r.length + n.flat().length + s.length + l + o;
+}, w = (t, e) => {
+  const { h0: r, h1: n } = g.getStealthAddressCompressedPoints(t, e), s = BigInt(g.getStealthAddress(t, e));
+  return {
+    extraRandomization: t,
+    H0: r,
+    H1: n,
+    stealthAddress: s
+  };
+};
+export {
+  k as buildInNullifiers,
+  B as buildOutCommitments,
+  j as calcAccessTokenSiblingsAndSides,
+  y as calcAmountChanges,
+  T as calcCommitmentsSiblingAndSides,
+  O as calcEncryptedOutputs,
+  W as calcPublicSignalCount,
+  w as calcStealthAddressStructure,
+  M as createCallDataHash,
+  F as deserializeCircomData,
+  E as serializeCircomData
+};

package/functions/snarkjs/constant.js

@@ -0,0 +1,211 @@
+import { chainIds as e } from "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "ethers";
+import "circomlibjs";
+import "../../data-structures/crypto-keys/keys.js";
+import "axios";
+import "../../data-structures/crypto-keys/encryptDecryptUtxo.js";
+import "../web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../utils/external-action.utils.js";
+import "../../data-structures/custom-token-registry/CustomTokenRegistry.js";
+import "../utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import { logError as x } from "../../error-handling/logError.js";
+import "../utils/userAgent.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import "../../data-structures/volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+import "../../constants/vite.constants.js";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+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/functions/snarkjs/constructEmporiumProof.js

@@ -0,0 +1,105 @@
+import { Utxo as $ } from "../../data-structures/utxo/Utxo.js";
+import { zeroAddress as V } from "../../constants/protocol.constants.js";
+import { chainIds as j } from "../../constants/chains.constants.js";
+import { ZKProofWorkerActionType as d } from "../../webworker/zkProofWorker/zkProofWorker.types.js";
+import { performTaskWithWorker as p } from "../../webworker/performTaskWithWorker.js";
+import { WorkerVariant as S } from "../../webworker/worker.registry.js";
+import { calcAmountChanges as q, calcEncryptedOutputs as F, buildOutCommitments as Q, calcPublicSignalCount as X, createCallDataHash as Y, calcStealthAddressStructure as x } from "./common.snarkjs.js";
+import { randomBigInt as U } from "../web3/etherFunctions.js";
+import { encodeEmporiumMetadata as tt } from "../private-wallet/emporium.helpers.js";
+import { ExternalActionId as at } from "../../types/external-action.types.js";
+import { defaultHookData as et } from "../../types/circom-data.types.js";
+import { generateCircomData as ot } from "./generateCircomData.js";
+import { generateZkProof as rt } from "./generateZkProof.js";
+const It = async (f, g, a, e, n, _, b, H, z, A = V, v = j.localhost, m = a.map(() => !1), h = a.map(() => 0n), i, mt, nt) => {
+  const u = f.getRootHash(), k = g.getRootHash(), I = a.map((t) => t.map((r) => r.getConstructableParams())), C = n.getSignature(), { accessTokenSiblings: L, accessTokenSiblingSides: O } = await p({
+    type: S.ZKProof,
+    payload: {
+      type: d.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES,
+      data: {
+        userSignature: C,
+        merkleTreeAccessTokenSerialized: g.toJSON()
+      }
+    }
+  }), { inCommitmentSiblings: W, inCommitmentSiblingSides: K } = await p({
+    type: S.ZKProof,
+    payload: {
+      type: d.CALC_COMMITMENTS_SIBLING_AND_SIDES,
+      data: { inputUtxosSerialized: I, userSignature: C, merkleTreeSerialized: f.toJSON() }
+    }
+  }), M = q(a, e), l = F(e, !1), s = n.getShieldedPrivateKey(), y = $.findCorrectRandomization(U(31), s), R = await p({
+    type: S.ZKProof,
+    payload: {
+      type: d.BUILD_IN_NULLIFIERS,
+      data: { inputUtxosSerialized: I, onChainCreation: m }
+    }
+  }), c = a.map((t) => t[0].tokenId ?? 0), o = {
+    rootHashHinkal: u,
+    erc20TokenAddresses: a.map((t) => t[0].erc20TokenAddress),
+    tokenIds: c,
+    inNullifiers: R,
+    outTimeStamp: BigInt(e[0][0].timeStamp),
+    extraRandomization: y,
+    amountChanges: M,
+    outCommitments: Q(e, m).map((t) => t[0]),
+    rootHashAccessToken: k,
+    calldataHash: 0n,
+    shieldedPrivateKey: s,
+    hinkalWalletNonce: i ?? 0n,
+    accessTokenSiblings: L,
+    accessTokenSiblingSides: O,
+    onChainCreation: m,
+    outAmounts: e.map((t) => t[0].amount),
+    outPublicKeys: e.map((t) => t[0].getStealthAddress()),
+    inAmounts: a.map((t) => t.map((r) => r.amount.toString())),
+    inTimeStamps: a.map((t) => t.map((r) => r.timeStamp)),
+    inRandomizations: a.map((t) => t.map((r) => r.randomization)),
+    inCommitmentSiblings: W,
+    inCommitmentSiblingSides: K
+  }, w = i ? n.getWalletSalt(i) : void 0;
+  let N = H, T = at.Emporium, D = tt(z, w);
+  const E = `swapperMW${_}x${b}`, P = X(
+    E,
+    o.erc20TokenAddresses,
+    o.amountChanges,
+    o.inNullifiers,
+    o.outCommitments,
+    c.length
+  );
+  o.calldataHash = Y(
+    P,
+    A,
+    N,
+    T,
+    D,
+    l,
+    h,
+    void 0
+  );
+  const { zkCallData: B } = await rt(v, E, o), Z = x(y, s), G = await ot(
+    u,
+    k,
+    a,
+    e,
+    l,
+    h,
+    P,
+    T,
+    N,
+    D,
+    A,
+    o.calldataHash,
+    c,
+    Z,
+    m,
+    et
+  ), J = {
+    tokenNumber: a.length,
+    nullifierAmount: a[0].length,
+    outputAmount: e[0].length
+  };
+  return { zkCallData: B, circomData: G, dimData: J, encryptedOutputs: l };
+};
+export {
+  It as constructEmporiumProof
+};