@hinkal/common 0.0.113 → 0.0.115

package/common127.mjs

@@ -0,0 +1,29 @@
+import { networkRegistry as i, chainIdsByType as o } 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 "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const B = (t) => i[t], R = (t) => Object.keys(o)[Object.values(o).findIndex((r) => r.includes(t.chainId))];
+export {
+  B as getNetworkObject,
+  R as getNetworkType
+};

package/common128.mjs

@@ -0,0 +1,38 @@
+import "./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 "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import { AxelarRegistry as p } from "./common36.mjs";
+import "./common41.mjs";
+const z = (i) => {
+  const r = p.find((m) => m.chainId === i.chainId);
+  if (!r)
+    return;
+  const { sourceChain: t, sourceAddress: o } = r;
+  return {
+    destinationChain: t,
+    destinationAddress: o,
+    messageFee: i.gasFeeInWei ?? 0n
+  };
+};
+export {
+  z as getAxelarMigrationInfo
+};

package/common129.mjs

@@ -0,0 +1,15 @@
+import { UAParser as s } from "ua-parser-js";
+const a = new s(), n = ["17"], u = () => {
+  const { name: e, version: r } = a.getBrowser(), t = r?.substring(0, 2);
+  return !(e === "Safari" && t && !n.includes(t));
+}, o = {
+  mpcVault: "MPCVault - Multisig Wallet",
+  utila: "UtilaWallet"
+}, i = (e) => {
+  const r = e?.session?.peer?.metadata?.name;
+  return !Object.values(o).includes(r);
+};
+export {
+  u as browserSupported,
+  i as walletSupported
+};

package/common13.mjs

@@ -0,0 +1,156 @@
+import p from "axios";
+import { ethers as A } from "ethers";
+import "./common157.mjs";
+import "./common164.mjs";
+import { curveNetworkNames as f, curvePools as w } from "./common168.mjs";
+import { getCrvCvxWithChainId as C } from "./common38.mjs";
+import { getERC20Registry as l } from "./common170.mjs";
+import { getNonLocalhostChainId as u } from "./common28.mjs";
+import { zeroAddress as m } from "./common34.mjs";
+import { logError as D } from "./common84.mjs";
+import { lowerCaseIncludes as k, caseInsensitiveEqual as h } from "./common134.mjs";
+const T = /* @__PURE__ */ new Set(), L = {}, y = (e, o) => {
+  const n = l(e), a = n.find((t) => t.erc20TokenAddress.toLocaleLowerCase() === o.toLocaleLowerCase());
+  return a ? a ? a.symbol : o : n[0].symbol;
+}, P = (e, o) => {
+  const n = l(e), a = n.find((t) => t.erc20TokenAddress.toLocaleLowerCase() === o.toLocaleLowerCase());
+  return a ? a.logoURI ? a.logoURI : "" : n[0].logoURI ? n[0].logoURI : "";
+};
+async function b(e) {
+  const o = u(e), n = f[o];
+  return p.get(`https://api.curve.fi/api/getSubgraphData/${n}`, { timeout: 7e3 }).then((a) => a.data ? a.data.data.poolList.map((t) => ({
+    address: t.address,
+    volumeUSD: t.volumeUSD,
+    dailyApy: t.latestDailyApy,
+    weeklyApy: t.latestWeeklyApy
+  })) : []).catch(() => []);
+}
+async function U(e, o) {
+  const n = u(e), a = f[n];
+  return a ? p.get(`https://api.curve.fi/api/getPools/${a}/${o}`).then((t) => t.data?.data.poolData.map((s) => {
+    const { usdTotal: i } = s, d = Number(A.utils.formatEther(s.totalSupply || "0")), c = d > 0 ? Number(i) / d : 0;
+    return {
+      id: s.id,
+      name: s.name,
+      address: s.address,
+      lpToken: y(e, s.lpTokenAddress || ""),
+      lpTokenAddress: s.lpTokenAddress,
+      coins: s.underlyingCoins ? s.underlyingCoins : s.coins,
+      tokensForDeposit: s.coins,
+      coinAddresses: (s.coinsAddresses || []).filter((r) => r !== m).map((r) => y(e, r)),
+      coinLogos: (s.coinsAddresses || []).filter((r) => r !== m).map((r) => P(e, r)),
+      gaugeAddress: s.gaugeAddress ? s.gaugeAddress : void 0,
+      gaugeCrvApy: s.gaugeCrvApy && s.gaugeCrvApy[0] && s.gaugeCrvApy[0] !== 0 ? { base: s.gaugeCrvApy[0], boosted: s.gaugeCrvApy[1] } : void 0,
+      gaugeRewards: s.gaugeRewards,
+      usdTotal: i,
+      totalSupply: d,
+      lpPrice: c,
+      liquidityUtilization: void 0
+    };
+  })) : [];
+}
+async function N(e) {
+  let o = [];
+  return await Promise.all(
+    w.map(async (n) => {
+      const a = await U(e, n);
+      return o = o.concat(a), a;
+    })
+  ), Promise.all(o);
+}
+async function v(e) {
+  const o = await b(e), n = await N(e), a = [];
+  for (const t of n) {
+    if (a.map((d) => d.address).includes(t.address))
+      continue;
+    const s = t.lpTokenAddress.toLowerCase();
+    T.add(s.toLowerCase()), L[s] = t.address.toLowerCase();
+    const i = {
+      id: t.id,
+      name: t.name,
+      address: t.address,
+      lpToken: s,
+      lpTokenAddress: s,
+      coins: t.coins,
+      coinNames: t.coinAddresses.join(" "),
+      coinAddresses: t.coinAddresses,
+      coinLogos: t.coinLogos,
+      tokensForDeposit: t.tokensForDeposit,
+      gaugeAddress: t.gaugeAddress,
+      usdTotal: t.usdTotal,
+      totalSupply: t.totalSupply,
+      lpPrice: t.lpPrice,
+      tvl: Math.round(t.usdTotal),
+      gaugeRewards: t.gaugeRewards,
+      gaugeCrvApy: t.gaugeCrvApy ? {
+        base: Math.round(t.gaugeCrvApy.base * 100) / 100,
+        boosted: Math.round(t.gaugeCrvApy.boosted * 100) / 100
+      } : void 0,
+      liquidityUtilization: 0,
+      volumeUSD: 0,
+      dailyApy: 0,
+      weeklyApy: 0
+    };
+    for (const d of o)
+      if (h(t.address, d.address)) {
+        i.liquidityUtilization = d.volumeUSD / t.usdTotal, i.volumeUSD = Math.round(d.volumeUSD), i.dailyApy = Math.round(d.dailyApy * 100) / 100, i.weeklyApy = Math.round(d.weeklyApy * 100) / 100;
+        break;
+      }
+    a.push(i);
+  }
+  return a;
+}
+const j = async (e) => {
+  const o = u(e), n = await v(o), a = C(o).map((s) => s.lpToken.toLowerCase());
+  return n.filter((s) => k(a, s.lpTokenAddress));
+}, G = async (e) => {
+  const o = u(e), n = await v(o), t = l(e).map((i) => i.erc20TokenAddress.toLowerCase());
+  return n.filter((i) => k(t, i.lpTokenAddress));
+};
+async function $(e, o) {
+  let n = 0;
+  for (let r = 0; r < e.tokensForDeposit.length; r += 1)
+    e.tokensForDeposit[r].usdTotal = Number(
+      A.utils.formatUnits(
+        BigInt(e.tokensForDeposit[r].poolBalance),
+        Number(e.tokensForDeposit[r].decimals)
+      )
+    ) * e.tokensForDeposit[r].usdPrice, n += e.tokensForDeposit[r].usdTotal || 0, e.tokensForDeposit[r].symbol.startsWith("am") && (e.tokensForDeposit[r].symbol = e.tokensForDeposit[r].symbol.slice(2));
+  for (let r = 0; r < e.tokensForDeposit.length; r += 1)
+    e.tokensForDeposit[r].weighting = (e.tokensForDeposit[r].usdTotal || 0) / n;
+  const a = await o.functions.fee();
+  let t, s, i, d = !1;
+  try {
+    const r = (await o.functions.future_A_time())[0].toNumber(), g = new Date(r * 1e3);
+    s = g.toLocaleString(), i = (await o.functions.future_A())[0].toNumber() / 100, d = !!r && g >= /* @__PURE__ */ new Date(), t = (await o.functions.initial_A())[0].toNumber() / 100;
+  } catch {
+    D("A ramp up not found");
+  }
+  return {
+    poolAddress: o.address,
+    lpToken: e.lpTokenAddress,
+    gaugeAddress: e.gaugeAddress,
+    gaugeCrvApy: e.gaugeCrvApy,
+    currencyReserves: e.coins,
+    liquidityUtilization: e.liquidityUtilization,
+    volumeUSD: e.volumeUSD,
+    dailyApy: e.dailyApy,
+    weeklyApy: e.weeklyApy,
+    gaugeRewards: e?.gaugeRewards,
+    A: (await o.functions.A())[0].toNumber(),
+    initialA: t,
+    futureTime: s,
+    futureA: i,
+    hasRampUp: d,
+    fee: a[0].toNumber() / 1e8,
+    daoFee: a[0].toNumber() / 2e8,
+    virtualPrice: Number((await o.functions.get_virtual_price())[0].toBigInt() / 100000000000000n) / 1e4
+  };
+}
+export {
+  j as getCurvePools,
+  G as getCurvePoolsforPriceFetching,
+  $ as getExtendedPoolInfo,
+  T as lpTokens,
+  L as lpTokensToBasePool
+};

package/common130.mjs

@@ -0,0 +1,105 @@
+import { BigNumber as m } from "ethers";
+import "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "circomlibjs";
+import "./common51.mjs";
+import "axios";
+import { abiDecodeUtxo as g } from "./common49.mjs";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import { getHinkalParameters as x } from "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const G = (e, r) => {
+  const n = e.parseTransaction({ data: r }), { circomData: t } = n.args, {
+    extraRandomization: o,
+    stealthAddress: i,
+    H0: u,
+    H1: s
+  } = t.stealthAddressStructure;
+  return {
+    erc20TokenAddresses: t.erc20TokenAddresses,
+    amountChanges: t.amountChanges,
+    flatFees: t.flatFees,
+    externalActionId: t.externalActionId,
+    externalActionMetadata: t.externalActionMetadata,
+    encryptedOutputs: t.encryptedOutputs.map((d) => d[0]),
+    hookData: t.hookData,
+    stealthAddressStructure: {
+      extraRandomization: o.toBigInt(),
+      stealthAddress: i.toBigInt(),
+      H0: u.toBigInt(),
+      H1: s.toBigInt()
+    }
+  };
+}, J = (e, r) => {
+  const { transactMethodId: n, transactWithExternalActionMethodId: t, NewCommitment: o, NewCommitmentTopic: i, hinkalInterface: u } = x(e), s = [];
+  for (let a = 0; a < r.length; a += 1) {
+    s.push(r[a]), s[a].utxosArray = [];
+    const { methodId: d } = s[a];
+    s[a].logs.forEach((c, S) => {
+      if (d !== n && d !== t || c.topics[0] !== i)
+        return;
+      const p = u.decodeEventLog(o, c.data);
+      if (p.index.toBigInt() < 0n) {
+        const { amount: l, erc20TokenAddress: h, timeStamp: A, tokenId: I } = g(p.encryptedOutput);
+        s[a].utxosArray?.push({ amount: l, erc20TokenAddress: h, timeStamp: A, tokenId: I });
+      }
+    });
+  }
+  return s;
+}, K = (e) => ({
+  ...e,
+  utxosArray: e.utxosArray?.map((r) => ({ ...r, amount: BigInt(r.amount) })),
+  decodedInput: {
+    ...e.decodedInput,
+    amountChanges: e.decodedInput.amountChanges.map(m.from),
+    flatFees: e.decodedInput.flatFees.map(m.from),
+    externalActionId: m.from(e.decodedInput.externalActionId),
+    stealthAddressStructure: {
+      ...e.decodedInput.stealthAddressStructure,
+      extraRandomization: BigInt(e.decodedInput.stealthAddressStructure.extraRandomization),
+      stealthAddress: BigInt(e.decodedInput.stealthAddressStructure.stealthAddress),
+      H0: BigInt(e.decodedInput.stealthAddressStructure.H0),
+      H1: BigInt(e.decodedInput.stealthAddressStructure.H1)
+    }
+  }
+}), Q = (e) => e.map((n) => {
+  const { decodedInput: t } = n;
+  return {
+    ...n,
+    input: "",
+    decodedInput: {
+      ...t,
+      amountChanges: t.amountChanges.map((o) => o.toString()),
+      flatFees: t.flatFees.map((o) => o.toString()),
+      externalActionId: t.externalActionId.toString(),
+      stealthAddressStructure: {
+        ...t.stealthAddressStructure,
+        extraRandomization: String(t.stealthAddressStructure.extraRandomization),
+        stealthAddress: String(t.stealthAddressStructure.stealthAddress),
+        H0: String(t.stealthAddressStructure.H0),
+        H1: String(t.stealthAddressStructure.H1)
+      }
+    }
+  };
+});
+export {
+  G as decodeTxInput,
+  J as decodeTxLogs,
+  K as deserializeDecodedTxs,
+  Q as serializeDecodedTxs
+};

package/common131.mjs

@@ -0,0 +1,4 @@
+const o = () => window.location.reload();
+export {
+  o as reloadPage
+};

package/common132.mjs

@@ -0,0 +1,14 @@
+function e(t) {
+  return t?.toLowerCase().split(" ").map((r) => r.charAt(0).toUpperCase() + r.substring(1)).join(" ");
+}
+function n(t) {
+  return t.charAt(0).toUpperCase() + t.slice(1);
+}
+function i(t) {
+  return !t || t === null || Array.isArray(t) && t.length === 0 ? !0 : Object.keys(t).length === 0 && t.constructor === Object;
+}
+export {
+  n as capitalizeFirstLetter,
+  i as isNullOrEmpty,
+  e as toTitleCase
+};

package/common133.mjs

@@ -0,0 +1,7 @@
+const t = (e) => {
+  const n = /^[a-zA-Z0-9_]{5,24}$/;
+  return e.length > 0 && n.test(e);
+};
+export {
+  t as isNicknameValid
+};

package/common134.mjs

@@ -0,0 +1,6 @@
+const o = (e, s) => !e || !s ? !1 : e.toLowerCase() === s.toLowerCase(), r = (e, s) => e.some((t) => o(t, s)), a = (e, s) => e.some((t) => t.toLowerCase().startsWith(s.toLowerCase()));
+export {
+  o as caseInsensitiveEqual,
+  r as lowerCaseIncludes,
+  a as lowerCaseStartsWith
+};

package/common135.mjs

@@ -0,0 +1,8 @@
+const i = (e = 1e3) => new Promise((t) => {
+  setTimeout(() => {
+    t(void 0);
+  }, e);
+});
+export {
+  i as waitLittle
+};

package/common136.mjs

@@ -0,0 +1,40 @@
+import { getERC20Registry as p } from "./common170.mjs";
+import "./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 { customTokenRegistry as s } from "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import { VolatileHelper as e } from "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const m = { chains: [] }, v = async (r) => {
+  let o = [...p(r), ...s.getCustomTokens(r)];
+  m.chains.includes(r) || (o = await Promise.all(
+    o.map(async (t) => {
+      if (t.isVolatile) {
+        const i = await e.getShareTokenAddress(r, t.erc20TokenAddress);
+        i && (t.sharedAddress = i);
+      }
+      return t;
+    })
+  ), m.chains.push(r));
+};
+export {
+  v as patchRegistry
+};

package/common137.mjs

@@ -0,0 +1,41 @@
+import { ethers as i, BigNumber as a } from "ethers";
+import { transactionErrorCodes as c } from "./common81.mjs";
+const h = (t) => i.utils.parseEther(t).toBigInt(), P = (t) => i.BigNumber.from(i.utils.randomBytes(t)).toBigInt(), f = (t, n) => i.utils.formatUnits(n, t.decimals), m = (t, n) => {
+  const r = 10 ** (18 - t.decimals);
+  try {
+    return i.utils.parseUnits(n).div(a.from(r.toString())).toBigInt();
+  } catch {
+    throw new Error(c.DECIMALS_LIMIT);
+  }
+}, g = (t) => {
+  const n = t.toFixed(30), [r, e] = n.split("."), s = e ? e.length : 0, o = `${r}${e || ""}`;
+  return [BigInt(o), s];
+}, v = (t, n) => {
+  try {
+    return m(t, n);
+  } catch {
+    return BigInt(0);
+  }
+}, u = (t, n, r) => {
+  const e = i.utils.formatUnits(t, n.decimals), s = BigInt(10 ** (18 - r));
+  try {
+    const o = i.utils.parseUnits(e).div(a.from(s.toString())).toBigInt();
+    return i.utils.formatUnits(o, r);
+  } catch {
+    throw new Error(c.DECIMALS_LIMIT);
+  }
+}, D = (t, n, r, e) => {
+  const [s, o] = g(r);
+  return { totalValueDollarsBigInt: n * s / BigInt(10 ** (t.decimals - e)) / BigInt(10 ** o), precision: e };
+}, E = (t, n) => !t || !n ? "0" : u(n ?? 0n, t, t.decimals).toString() ?? "0";
+export {
+  D as calculateDollarValue,
+  h as ethToWei,
+  f as getAmountInToken,
+  m as getAmountInWei,
+  v as getAmountInWeiOrZero,
+  u as getAmountWithPrecision,
+  E as getAmountWithPrecisionOrZero,
+  P as randomBigInt,
+  g as toBigIntWithDecimals
+};

package/common138.mjs

@@ -0,0 +1,72 @@
+import { Utxo as C } from "./common71.mjs";
+import "./common157.mjs";
+import { ContractType as m } from "./common158.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import { getHinkalCache as O, setHinkalCache as P } from "./common115.mjs";
+const b = async (e, r, u, n, i = 0) => (await e.utxoUtils.buildBatchProcess(r, u)).reduce((s, t) => n && i !== 0 ? t.erc20TokenAddress.toLowerCase() === n.toLowerCase() && t.tokenId === i ? [...s, t] : s : n ? t.erc20TokenAddress.toLowerCase() === n.toLowerCase() ? [...s, t] : s : [...s, t], []), I = async (e, r, u, n, i, a, s, t = 0) => {
+  const o = await e.utxoUtils.batchFilterUtxosWithNullifier(r, u);
+  if (s) {
+    for (o.sort((l, c) => l.amount <= c.amount ? 1 : -1); o.length < n || o.length > n && o.length < 6; )
+      o.push(new C({ amount: 0n, erc20TokenAddress: s, shieldedPrivateKey: a, tokenId: t }));
+    if (i)
+      for (; o.length > 6; )
+        o.splice(o.length - 1);
+  }
+  return {
+    inputUtxos: o
+  };
+}, B = async ({
+  hinkal: e,
+  erc20TokenAddress: r = void 0,
+  minInput: u = 2,
+  sliceIfMore6: n = !0,
+  tokenId: i = 0
+}) => {
+  if (!e.getCurrentChainId || !e.getSelectedNetwork())
+    return { inputUtxos: [] };
+  const { encryptedOutputs: a, nullifiers: s, userKeys: t } = e, o = Array.from(a), l = e.getCurrentChainId(), c = e.getContract(m.HinkalContract).address, y = t.getShieldedPublicKey(), U = t.getShieldedPrivateKey();
+  let p = [], f = [], { encryptedOutputs: g, lastOutput: d } = O(
+    l,
+    y,
+    c
+  ), h = o.findIndex((x) => x.value === d);
+  if (h > -1 || g.length === 0) {
+    h += 1;
+    const x = o.slice(h);
+    ({ lastOutput: d, additionalEncryptedOutputs: f } = await e.utxoUtils.batchProcess(
+      x,
+      d,
+      t
+    )), p = [...g, ...f], P(
+      {
+        lastOutput: d,
+        encryptedOutputs: p
+      },
+      l,
+      y,
+      c
+    );
+  }
+  const w = await b(
+    e,
+    p,
+    t,
+    r,
+    i
+  );
+  return await I(
+    e,
+    w,
+    s,
+    u,
+    n,
+    U,
+    r,
+    i
+  );
+};
+export {
+  B as getInputUtxoAndBalance,
+  b as getInputUtxosFromEncryptedOutputs
+};

package/common139.mjs

@@ -0,0 +1,107 @@
+import { Mutex as A } from "async-mutex";
+import { getERC20Registry as w } from "./common170.mjs";
+import { Utxo as k } from "./common71.mjs";
+import { customTokenRegistry as I } from "./common72.mjs";
+import { getInputUtxoAndBalance as T } from "./common138.mjs";
+import { getAmountWithPrecision as U } from "./common137.mjs";
+import { ErrorWithAmount as P } from "./common219.mjs";
+import "axios";
+import "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "ethers";
+import "./common191.mjs";
+import "./common51.mjs";
+import "./common50.mjs";
+import "./common117.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import { caseInsensitiveEqual as h } from "./common134.mjs";
+import "libsodium-wrappers";
+import "circomlibjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import { VolatileHelper as b } from "./common77.mjs";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+import { getERC20Token as x } from "./common118.mjs";
+import "./common121.mjs";
+import "./common129.mjs";
+import { patchRegistry as S } from "./common136.mjs";
+const C = new A(), at = async (a) => {
+  const s = await C.acquire(), { inputUtxos: m } = await T({ hinkal: a, sliceIfMore6: !1 }), r = a.getCurrentChainId(), l = [...w(r), ...I.getCustomTokens(r)];
+  await S(r);
+  const f = l.map((t) => ({
+    token: t,
+    balance: m.reduce((e, n) => {
+      const o = t.isVolatile ? t.sharedAddress : t.erc20TokenAddress;
+      return h(o, n.erc20TokenAddress) ? e + n.amount : e;
+    }, 0n),
+    timestamp: m.filter(
+      (e) => h(e.erc20TokenAddress, t.erc20TokenAddress)
+    )[0]?.timeStamp,
+    nfts: m.filter(
+      (e) => h(e.erc20TokenAddress, t.erc20TokenAddress) && e.tokenId !== 0
+    ).map((e) => ({ tokenId: e.tokenId, timestamp: e.timeStamp }))
+  })), u = await Promise.all(
+    f.map(async (t) => {
+      if (!t.token.isVolatile)
+        return t;
+      t.token?.sharedAddress || console.log("VolatileToken must have a corresponding sharedAddress");
+      let e = 0n;
+      return t.balance > 0n && (e = await b.getVolatileTokenBalance(
+        r,
+        t.token.sharedAddress,
+        t.balance
+      )), {
+        ...t,
+        balance: BigInt(e)
+      };
+    })
+  );
+  return s(), u;
+}, mt = async (a, s, m, r = 6, l = s.map(() => 0), f = !1) => {
+  const { userKeys: u } = a, t = [], e = [];
+  let n = 0;
+  for (let o = 0; o < s.length; o += 1)
+    if (f === !1) {
+      const { inputUtxos: i } = await T({
+        hinkal: a,
+        erc20TokenAddress: s[o],
+        tokenId: l[o],
+        sliceIfMore6: !1
+      });
+      n = Math.max(i.length, n), e.push(i);
+    } else
+      e.push([]);
+  return console.log({ maxUtxoNum: n }), n === 2 ? e : (e.forEach((o, i) => {
+    if (o.length > r) {
+      const d = o.slice(0, r), p = d.reduce((c, g) => c + g.amount, 0n);
+      if (m[i] < 0n && p < -m[i]) {
+        const c = x(s[i], a.getCurrentChainId()), g = Number(U(p, c, 2)), y = `Unfortunately your transaction did not go through due to UTXOs limitations. 
+ Please try again with ${c.symbol}`;
+        throw new P(g, y);
+      }
+      t.push(d);
+    } else if (o.length <= r) {
+      const d = [...o];
+      let p = r - o.length;
+      for (; p > 0; )
+        p -= 1, d.push(
+          new k({
+            amount: 0n,
+            erc20TokenAddress: s[i],
+            shieldedPrivateKey: u.getShieldedPrivateKey(),
+            tokenId: l[i]
+          })
+        );
+      t.push(d);
+    }
+  }), t);
+};
+export {
+  mt as addPaddingToUtxos,
+  at as getShieldedBalance
+};