@hinkal/common 0.0.113 → 0.0.115

package/common71.mjs

@@ -0,0 +1,134 @@
+import { ethers as y } from "ethers";
+import { CIRCOM_P as o } from "./common34.mjs";
+import { poseidonHash as a } from "./common45.mjs";
+import { randomBigInt as S } from "./common137.mjs";
+import { UserKeys as d } from "./common51.mjs";
+class h {
+  amount;
+  erc20TokenAddress;
+  timeStamp;
+  tokenId;
+  shieldedPrivateKey;
+  // 1) if it's own UTXO one provides private key and  randomization -> computes stealth address and and eKey
+  randomization;
+  stealthAddress;
+  // 2) if it's other's utxo, stealth address and encryption key should be provided
+  encryptionKey;
+  commitment;
+  // computed
+  nullifier;
+  // computed
+  isStake;
+  isStakeOrUnstakeInput;
+  isUnstakeOutput;
+  /**
+   * creates new UTXO instance
+   * @param amount UTXO amount
+   * @param erc20TokenAddress contract address of ERC-20/ERC-721 token
+   * @param timeStamp timestamp
+   * @param tokenId tokenId
+   * @param randomization randomization parameter
+   * @param stealthAddress  stealth address as a parameter(e.g. in case of transfers we will not know private key and randomization of payee
+   * @param encryptionKey  encryption public key
+   * @param shieldedPrivateKey private key for nullification
+   * @param commitment [optional] commitment value if already computed
+   * @param nullifier [optional] nullifier value if already computed
+   */
+  constructor({
+    amount: t,
+    erc20TokenAddress: e,
+    timeStamp: s,
+    tokenId: i,
+    shieldedPrivateKey: r,
+    randomization: n,
+    stealthAddress: m,
+    encryptionKey: l,
+    commitment: u = void 0,
+    nullifier: c = void 0,
+    isStake: p = !1,
+    isStakeOrUnstakeInput: k = !1,
+    isUnstakeOutput: f = !1
+  }) {
+    this.amount = t, this.erc20TokenAddress = e, this.timeStamp = s ?? Math.floor(Date.now() / 1e3).toString(), this.tokenId = i ?? 0, this.shieldedPrivateKey = r, this.randomization = n ?? h.findCorrectRandomization(S(31), r), this.stealthAddress = m, this.encryptionKey = l, this.commitment = u, this.nullifier = c, this.isStake = p, this.isStakeOrUnstakeInput = k, this.isUnstakeOutput = f;
+  }
+  static createFrom(t, e) {
+    return new h({
+      ...t.getConstructableParams(),
+      nullifier: void 0,
+      commitment: void 0,
+      ...e
+    });
+  }
+  getConstructableParams() {
+    return {
+      amount: this.amount,
+      erc20TokenAddress: this.erc20TokenAddress,
+      timeStamp: this.timeStamp,
+      shieldedPrivateKey: this.shieldedPrivateKey,
+      randomization: this.randomization,
+      stealthAddress: this.stealthAddress,
+      encryptionKey: this.encryptionKey,
+      tokenId: this.tokenId,
+      commitment: this.commitment,
+      nullifier: this.nullifier,
+      isStake: this.isStake,
+      isStakeOrUnstakeInput: this.isStakeOrUnstakeInput,
+      isUnstakeOutput: this.isUnstakeOutput
+    };
+  }
+  /**
+   * @returns commitment hash of the UTXO instance
+   */
+  getCommitment() {
+    if (!this.commitment) {
+      const t = [this.amount, this.erc20TokenAddress, BigInt(this.getStealthAddress()), this.timeStamp];
+      this.tokenId > 0 && t.push(this.tokenId.toString()), (this.isStake || this.isUnstakeOutput) && t.push(0n, 1n), this.commitment = a(...t);
+    }
+    return this.commitment;
+  }
+  /**
+   * @returns nullifier hash of the UTXO instance
+   */
+  getNullifier() {
+    if (!this.nullifier) {
+      if (!this.shieldedPrivateKey)
+        throw new Error("No Nullifiers if private key is not provided");
+      const t = a(this.shieldedPrivateKey, this.getCommitment()), e = BigInt(a(this.commitment, t)), s = BigInt(this.isStakeOrUnstakeInput);
+      this.nullifier = y.BigNumber.from(e + s).toHexString();
+    }
+    return this.nullifier;
+  }
+  /**
+   * @returns stealth address from randomization and private shieldedPrivateKey
+   */
+  getStealthAddress() {
+    if (!this.stealthAddress) {
+      if (!this.shieldedPrivateKey)
+        throw Error("No stealth address in UTXO if private key is not provided");
+      const t = d.getStealthAddress(this.randomization, this.shieldedPrivateKey);
+      this.stealthAddress = t;
+    }
+    return this.stealthAddress;
+  }
+  getEncryptionKey() {
+    if (!this.shieldedPrivateKey) {
+      if (!this.encryptionKey)
+        throw Error("No encryption key provided in UTXO");
+      return this.encryptionKey;
+    }
+    return d.getEncryptionKeyPair(this.shieldedPrivateKey).publicKey;
+  }
+  static findCorrectRandomization(t, e) {
+    if (!e)
+      throw Error("No Private Shielded Key Provided");
+    const s = BigInt(e) % o;
+    let i, r, n = 0n;
+    do
+      i = t * 10n ** n % o, r = i * s % o, n += 1n;
+    while (r >= 2n ** 253n || i >= 2n ** 253n);
+    return i;
+  }
+}
+export {
+  h as Utxo
+};

package/common72.mjs

@@ -0,0 +1,33 @@
+class o {
+  localStorageKey = "tokenRegistry";
+  tokenRegistry;
+  constructor() {
+    if (this.tokenRegistry = [], typeof localStorage < "u") {
+      const t = localStorage.getItem(this.localStorageKey);
+      t && (this.tokenRegistry = JSON.parse(t));
+    }
+  }
+  persistRegistry() {
+    typeof localStorage < "u" && localStorage.setItem(this.localStorageKey, JSON.stringify(this.tokenRegistry));
+  }
+  getCustomTokens(t) {
+    return this.tokenRegistry.filter((s) => s.chainId === t);
+  }
+  tokenExists(t, s) {
+    return t.find(
+      (e) => e.erc20TokenAddress === s.erc20TokenAddress || e.symbol === s.symbol || e.name === s.name
+    );
+  }
+  addCustomToken(t) {
+    const { chainId: s } = t, e = this.getCustomTokens(s);
+    this.tokenExists(e, t) || this.tokenRegistry.push(t), this.persistRegistry();
+  }
+  removeCustomToken(t) {
+    const { chainId: s } = t, r = this.getCustomTokens(s).filter((i) => i.erc20TokenAddress !== t.erc20TokenAddress);
+    this.tokenRegistry = r, this.persistRegistry();
+  }
+}
+const g = new o();
+export {
+  g as customTokenRegistry
+};

package/common73.mjs

@@ -0,0 +1,29 @@
+import { lowerCaseIncludes as a } from "./common134.mjs";
+import { wstEthSymbol as r, stMaticSymbol as o } from "./common40.mjs";
+import { chainIds as T } from "./common28.mjs";
+class m {
+  static isCurveLPToken = (s, e) => a(e, s.erc20TokenAddress);
+  static isCurveStakeToken = (s) => s.name.includes("Gauge") && s.symbol.includes("-gauge");
+  static isConvexToken = (s) => s.name.includes("Convex") && s.symbol.includes("cvx");
+  static isBeefyLpToken = (s) => s.name.startsWith("moo") && s.symbol.startsWith("moo");
+  static isBeefyStakeToken = (s) => s.name.includes("-Boost") && s.symbol.includes("-Boost");
+  static isLidoToken = (s) => s.symbol === r || s.symbol === o;
+  static isCurveOrConvex = (s, e) => this.isCurveLPToken(s, e) || this.isCurveStakeToken(s) || this.isConvexToken(s);
+  static isBeefyToken = (s) => this.isBeefyLpToken(s) || this.isBeefyStakeToken(s);
+  static isStakeToken = (s) => this.isCurveStakeToken(s) || this.isConvexToken(s) || this.isBeefyStakeToken(s);
+  static isPendleYtToken = (s) => s.name.startsWith("Pendle-YT-") && s.symbol.startsWith("Pendle-YT-");
+  static isPendleLPToken = (s) => s.name.startsWith("Pendle-LP-") && s.symbol.startsWith("Pendle-LP-");
+  static isPendleSyToken = (s) => s.name.startsWith("SY ") && s.symbol.includes("SY-");
+  static isPendleNativeToken = (s) => {
+    const e = s.name.startsWith("YT ") && s.symbol.includes("YT-"), i = this.isPendleSyToken(s), t = s.name.startsWith("PT ") && s.symbol.includes("PT-"), n = s.name.startsWith("LP ") && s.symbol.includes("LP-");
+    return e || i || t || n;
+  };
+  static isPendleToken = (s) => this.isPendleYtToken(s) || this.isPendleLPToken(s) || this.isPendleNativeToken(s);
+  static isAaveToken = (s) => s.aaveToken;
+  static isNonRebasingBlastToken = (s) => s.chainId === T.blast && s.symbol.startsWith("nr");
+  static isKinzaToken = (s) => s.name.startsWith("Kinza");
+  static isProtocolToken = (s, e) => this.isCurveLPToken(s, e) || this.isCurveStakeToken(s) || this.isConvexToken(s) || this.isBeefyLpToken(s) || this.isBeefyStakeToken(s) || this.isLidoToken(s) || this.isPendleToken(s) || this.isAaveToken(s) || this.isNonRebasingBlastToken(s);
+}
+export {
+  m as TokenChecker
+};

package/common74.mjs

@@ -0,0 +1,218 @@
+import l from "axios";
+import { ethers as u } from "ethers";
+import { getCoingeckoPrice as g, getCoingeckoPrice2 as m } from "./common3.mjs";
+import { getCurvePoolsforPriceFetching as y } from "./common13.mjs";
+import { coingeckoRegistry as P } from "./common16.mjs";
+import { getNonLocalhostChainId as h, chainIds as k, networkRegistry as T } from "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import { zeroAddress as p, beefyChainIds as v } from "./common34.mjs";
+import "circomlibjs";
+import "./common51.mjs";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import { getERC20Token as I } from "./common118.mjs";
+import "./common121.mjs";
+import { getOdosPriceForToken as b } from "./common216.mjs";
+import "./common129.mjs";
+import { caseInsensitiveEqual as c } from "./common134.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import { TokenChecker as a } from "./common73.mjs";
+import { abi as C } from "./common87.mjs";
+import { urlForBeefyVaultTokens as A, urlForBeefyVaultTotalInUSD as w, urlForPendleAPI as B, urlForBeefyVaultLpTokens as D } from "./common188.mjs";
+import "./common77.mjs";
+import "./common72.mjs";
+import "./common33.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import { CoinGeckoChainLabels as R, getCoingeckoIdForNativeTokens as E, getCoingeckoPlatform as S } from "./common35.mjs";
+import "./common36.mjs";
+import { getCrvCvxWithChainId as L } from "./common38.mjs";
+import "./common41.mjs";
+import { getERC20Registry as x } from "./common170.mjs";
+class Pe extends a {
+  chainId;
+  provider;
+  erc20Registry = [];
+  // Curve state variables
+  crvCvxRegistry = [];
+  curvePools = [];
+  // Beefy state variables:
+  beefyVaults = [];
+  beefyTvlData = {};
+  usdcSymbol = "USDC";
+  supportsCurve = () => h(this.chainId) !== k.bnbMainnet;
+  constructor(r, t) {
+    super(), this.chainId = r, this.provider = t;
+    const e = h(this.chainId);
+    this.erc20Registry = x(this.chainId), this.crvCvxRegistry = L(e), this.supportsCurve() && y(this.chainId).then((i) => {
+      this.curvePools = i;
+    });
+  }
+  async updateBeefyVault() {
+    this.beefyVaults.length === 0 && (this.beefyVaults = (await l.get(A)).data);
+  }
+  findTokenId(r) {
+    let t;
+    const e = R[this.chainId];
+    return r === p ? E[this.chainId] : (P.find((i) => Object.entries(i.platforms).find(
+      ([s, n]) => s === e && (r ? c(r, n) : !1)
+    ) ? (t = i.id, !0) : !1), t);
+  }
+  async fetchPriceById(r) {
+    const t = await g(r);
+    return { usd: t?.usd, eth: t.eth };
+  }
+  async fetchPriceByAddress(r) {
+    const t = S(this.chainId);
+    return (await m(r, t))?.usd;
+  }
+  async fetchHETHPrice(r) {
+    const t = I(r, this.chainId);
+    if (!t || t.underlyingErc20TokenAddress !== p || !t.isHToken || !this.provider)
+      return;
+    const { contractData: e } = T[this.chainId];
+    if (!e.hETHOracleAddress || !e.HTokenOracleABI)
+      return;
+    const o = await new u.Contract(
+      e.hETHOracleAddress,
+      e.HTokenOracleABI,
+      this.provider
+    ).callStatic.exchangeRate(), s = Number(u.utils.formatEther(o)), n = await this.fetchPriceByTokenAddress(t.underlyingErc20TokenAddress);
+    if (n)
+      return s * n;
+  }
+  // This is general fetch price function: it has flexibility to fetch only with coingecko or also to try to find protocol specific price (use onlyMainRegistry parameter)
+  async fetchPriceByTokenAddress(r, t = !1) {
+    try {
+      console.log("fetchPriceByTokenAddress", { address: r });
+      const e = await this.fetchHETHPrice(r);
+      if (e)
+        return e;
+      const i = this.findTokenId(r);
+      if (i) {
+        const f = (await this.fetchPriceById(i)).usd;
+        if (f)
+          return f;
+      }
+      const o = await this.fetchPriceByAddress(r);
+      if (console.log({ coingecko: o }), o || t)
+        return o;
+      const s = await this.fetchProtocolPriceinUSD(r);
+      if (console.log({ protocolPrice: s }), s)
+        return s;
+      const n = await this.fetchOdosPriceinUSD(r);
+      if (console.log({ odosPrice: n }), n)
+        return n;
+      const d = await this.findBeefyLpPrice(r);
+      return console.log({ beefyLpPrice: d }), d || void 0;
+    } catch (e) {
+      console.log("fetchPriceByTokenAddress error ", e);
+      return;
+    }
+  }
+  async fetchOdosPriceinUSD(r) {
+    const t = h(this.chainId), e = await b(t, r);
+    if (e)
+      return e;
+  }
+  async fetchProtocolPriceinUSD(r) {
+    const t = this.erc20Registry.find(
+      (e) => c(e.erc20TokenAddress, r)
+    );
+    if (t) {
+      if (this.supportsCurve() && this.curvePools.length === 0 && (this.curvePools = await y(this.chainId)), a.isCurveOrConvex(
+        t,
+        this.curvePools.map((e) => e.lpTokenAddress)
+      )) {
+        const e = await this.fetchCurvePriceinUSD(t.underlyingErc20TokenAddress ?? r);
+        if (e)
+          return e;
+      }
+      if (a.isBeefyToken(t)) {
+        const e = await this.findBeefyPriceInUSD(t.underlyingErc20TokenAddress ?? r);
+        if (e)
+          return e;
+      }
+      if (a.isPendleToken(t)) {
+        const e = await this.fetchPendleTokenPriceInUSD(r);
+        if (e)
+          return e;
+      }
+      if (a.isAaveToken(t)) {
+        const { underlyingErc20TokenAddress: e } = t;
+        if (!e)
+          return console.log("missing underlying token for aave"), 0;
+        const i = await this.fetchPriceByTokenAddress(e);
+        if (i)
+          return i;
+      }
+      if (a.isNonRebasingBlastToken(t)) {
+        const e = this.erc20Registry.find((o) => o.symbol === t.symbol.slice(2));
+        if (!e)
+          return console.log("missing rebasing variant for non-rebasing token"), 0;
+        const i = await this.fetchPriceByTokenAddress(e.erc20TokenAddress);
+        if (i)
+          return i;
+      }
+      if (a.isKinzaToken(t)) {
+        const { underlyingErc20TokenAddress: e } = t;
+        if (!e)
+          return console.log("underlying token does not exists for Kinza token"), 0;
+        const i = await this.fetchPriceByTokenAddress(e);
+        if (i)
+          return i;
+      }
+    }
+  }
+  // this should work for Curve Pools, Curve Staking and Convex
+  async fetchCurvePriceinUSD(r) {
+    const t = this.crvCvxRegistry.find(
+      (i) => c(i.lpToken, r) || c(i.gauge, r) || c(i.cvxRewards, r)
+    ), e = this.curvePools.find(
+      (i) => c(i.address, t?.pool) || c(i.lpTokenAddress, r) || c(i.gaugeAddress, r)
+    );
+    if (e?.lpPrice)
+      return e.lpPrice;
+  }
+  // this should work for Beefy Lp Provision and Beefy Staking
+  async findBeefyPriceInUSD(r) {
+    await this.updateBeefyVault();
+    const t = h(this.chainId), e = this.beefyVaults.find(
+      (i) => c(r, i.earnedTokenAddress) && v[t] === i.chain
+    );
+    if (e && this.provider) {
+      const { earnedTokenAddress: i, id: o } = e, n = (await new u.Contract(i, C, this.provider).totalSupply()).toBigInt(), d = Number(u.utils.formatUnits(n, 18));
+      Object.keys(this.beefyTvlData).length === 0 && (this.beefyTvlData = (await l.get(w)).data);
+      const f = this.beefyTvlData[t][o];
+      return !f || !d ? void 0 : f / d;
+    }
+  }
+  async fetchPendleTokenPriceInUSD(r) {
+    const t = h(this.chainId), i = this.erc20Registry.find(
+      (n) => c(n.erc20TokenAddress, r)
+    )?.underlyingErc20TokenAddress ?? r;
+    console.log({ searchToken: i });
+    const o = `${t}/assets/${i}`, s = (await l.get(`${B}${o}`)).data;
+    return s ? s?.price.usd : 0;
+  }
+  async findBeefyLpPrice(r) {
+    await this.updateBeefyVault();
+    const t = this.beefyVaults.find((e) => c(r, e.tokenAddress));
+    if (t)
+      try {
+        const { oracleId: e } = t;
+        return (await l.get(D)).data?.[e];
+      } catch (e) {
+        console.log("findBeefyLpPrice error:", e);
+        return;
+      }
+  }
+}
+export {
+  Pe as TokenPriceFetcher
+};

package/common75.mjs

@@ -0,0 +1,194 @@
+import { getNonLocalhostChainId as T, chainIdsByType as y, EthereumNetworkType as S } from "./common28.mjs";
+import "./common157.mjs";
+import { emptyDecodedTx as k } from "./common164.mjs";
+import { getCurrentWeek as A } from "./common165.mjs";
+import "./common168.mjs";
+import "ethers";
+import { transactionErrorCodes as I } from "./common81.mjs";
+import "circomlibjs";
+import { UserKeys as x } from "./common51.mjs";
+import { saveTxsCache as C, loadTxsCache as w } from "./common115.mjs";
+import "./common139.mjs";
+import "axios";
+import { decryptUtxo as P } from "./common50.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common129.mjs";
+import { decodeTxInput as v, decodeTxLogs as H } from "./common130.mjs";
+import { generateZkProof as z } from "./common149.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import { getTxDetails as E } from "./common235.mjs";
+import "./common77.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "libsodium-wrappers";
+import { getHinkalParameters as b } from "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+import { API as p } from "./common12.mjs";
+class dt {
+  circuitSize = 50;
+  hinkalContract;
+  init(r) {
+    this.hinkalContract = r;
+  }
+  requireInit() {
+    if (!this.hinkalContract)
+      throw Error("TransactionsManager not initialized");
+  }
+  filterOwnTransactions = async (r, e, t, n) => {
+    const { transactMethodId: s, transactWithExternalActionMethodId: a, hinkalInterface: o } = b(
+      T(r)
+    ), c = (i) => "decodedInput" in i, l = e.filter(
+      (i) => i.methodId === s || i.methodId === a
+    ).map((i) => c(i) ? i : {
+      ...i,
+      decodedInput: v(o, i.input),
+      status: i.isError === "0" ? "SUCCESS" : "FAILURE"
+    }), u = t.getShieldedPrivateKey();
+    return l.filter((i) => {
+      try {
+        if (c(i)) {
+          if (P(Buffer.from(i.decodedInput.encryptedOutputs[0].slice(2), "hex"), t), !n && i.methodId === s) {
+            const { extraRandomization: m, H0: f, H1: g } = i.decodedInput.stealthAddressStructure;
+            return x.checkSignature(m, f, g, u);
+          }
+          return !0;
+        }
+        return !1;
+      } catch {
+        return !1;
+      }
+    });
+  };
+  saveTxsInStorage = (r, e, t, n) => {
+    const s = t.getShieldedPublicKey();
+    C(r, e, s, this.hinkalContract.address, n);
+  };
+  loadTxsFromStorage = (r, e) => {
+    const t = e.getShieldedPublicKey();
+    return w(r, t, this.hinkalContract.address);
+  };
+  getAllTransactions = async (r, e, t) => {
+    if (t) {
+      const { transactions: o } = await p.userGetTransactions(r, t);
+      return o;
+    }
+    const { decodedTxs: n, lastHash: s } = this.loadTxsFromStorage(r, e), { transactions: a } = await p.userGetTransactions(r, t, s);
+    return [...a, ...n];
+  };
+  getHinkalHistoryBase = async (r, e, t, n = !1) => {
+    this.requireInit();
+    const s = await this.getAllTransactions(r, e, t) ?? [];
+    s.sort((o, c) => c.timeStamp - o.timeStamp);
+    const a = await this.filterOwnTransactions(r, s, e, n);
+    return !t && s.length > 0 && this.saveTxsInStorage(a, r, e, s[0].hash), a;
+  };
+  getHinkalHistory = async (r, e) => {
+    const t = await this.getHinkalHistoryBase(r, e, void 0, !0), n = H(r, t);
+    return await Promise.all(
+      n.map(async (a) => ({
+        ...a,
+        status: a.status,
+        details: await E(r, a.decodedInput, a.utxosArray)
+      }))
+    );
+  };
+  sortInBatches = (r) => {
+    const e = [];
+    let t = 0, n = 0;
+    r.forEach((o) => {
+      t === 0 && e.push([]), e[n].push(o), t += 1, t === this.circuitSize && (t = 0, n += 1);
+    });
+    const s = e[e.length - 1], a = s.length;
+    if (a < this.circuitSize) {
+      const o = this.circuitSize - a, c = new Array(o).fill(k);
+      e[e.length - 1] = s.concat(c);
+    }
+    return e;
+  };
+  generateTransactionsProof = async (r, e, t) => {
+    const n = this.sortInBatches(e), s = new Array(n.length).fill([]);
+    for (let a = 0; a < n.length; a += 1) {
+      const o = n[a].map(
+        (h) => h.decodedInput.stealthAddressStructure
+      ), c = o.map((h) => h.extraRandomization), d = o.map((h) => h.stealthAddress);
+      console.log({ extraRandomizations: c, stealthAddresses: d });
+      const l = {
+        shieldedPrivateKey: t,
+        extraRandomizations: c,
+        stealthAddresses: d
+      };
+      console.log({ chainId: r, input: l });
+      const { zkCallData: u } = await z(r, "transactionsProver", l);
+      console.log({ zkCallData: u }), s[a] = u;
+    }
+    return { zkCallDataArray: s };
+  };
+  userVerifyTransactions = async (r, e, t, n, s, a) => await p.userVerifyTransactions(
+    r,
+    e,
+    t,
+    n,
+    s,
+    a
+  );
+  processAndSendTransactionsForVerification = async (r, e, t, n) => {
+    this.requireInit();
+    const s = A(), a = n ? s - 1 : s;
+    console.log("retrieving transactions in processAndSendTransactionsForVerification", { week: a });
+    const o = await this.getHinkalHistoryBase(r, e, a);
+    console.log("retrieved transactions", o);
+    let c = [], d = [];
+    o.length > 0 && ({ zkCallDataArray: d } = await this.generateTransactionsProof(
+      r,
+      o,
+      e.getShieldedPrivateKey()
+    ), c = o.map((f) => f.hash));
+    const l = e.getBackendToken(), {
+      trade: u,
+      transactions: h,
+      lockedDeposit: i,
+      verification: m
+    } = await this.userVerifyTransactions(
+      r,
+      c,
+      d,
+      l,
+      t,
+      a
+    );
+    return { trade: u, transactions: h, lockedDeposit: i, verification: m };
+  };
+  multiProcessAndSendTransactionsForVerification = async (r, e) => {
+    console.log("Multi Certify Starts");
+    const t = y[S.Mainnet];
+    let n = !0;
+    for (let s = 0; s < t.length; s += 1)
+      try {
+        const { hasCertified: a } = await p.verificationStartDate(t[s], e);
+        if (console.log(`certification status for chain ${t[s]} is ${a}`), a)
+          continue;
+        const {
+          trade: o,
+          transactions: c,
+          lockedDeposit: d,
+          verification: l
+        } = await this.processAndSendTransactionsForVerification(t[s], r, e, !0);
+        if (console.log({ chainId: t[s], trade: o, totalTransactions: c, lockedDeposit: d, verification: l }), n = n && l, !n)
+          break;
+      } catch (a) {
+        console.log(`current chain ${t[s]} certification error`, { err: a }), n = !1;
+        break;
+      }
+    if (!n)
+      throw Error(I.MULTI_VERIFICATION_FAILED);
+    return !0;
+  };
+}
+export {
+  dt as TransactionsManager
+};

package/common76.mjs

@@ -0,0 +1,62 @@
+import "./common28.mjs";
+import "./common157.mjs";
+import { ExternalActionId as t } from "./common159.mjs";
+import "./common164.mjs";
+import "./common168.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 { getExternalActionIdFromNumber as o } from "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common129.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+var m = /* @__PURE__ */ ((r) => (r[r.DEPOSIT = 0] = "DEPOSIT", r[r.WITHDRAW = 1] = "WITHDRAW", r[r.SWAP = 2] = "SWAP", r[r.BEEFY = 3] = "BEEFY", r[r.CURVE = 4] = "CURVE", r[r.CONVEX = 5] = "CONVEX", r[r.LIDO = 6] = "LIDO", r[r.PENDLE = 7] = "PENDLE", r[r.VOLATILE = 8] = "VOLATILE", r[r.UNKNOWN = 9] = "UNKNOWN", r))(m || {});
+const p = (r) => {
+  const e = r.externalActionId.toBigInt();
+  switch (o(e)) {
+    case t.Transact:
+      return r.amountChanges[0].toBigInt() >= 0n ? 0 : 1;
+    case t.Uniswap:
+    case t.Odos:
+    case t.OneInch:
+      return 2;
+    case t.Beefy:
+    case t.BeefyStake:
+      return 3;
+    case t.Curve:
+    case t.CurveDynamic:
+    case t.CurveCRV:
+    case t.CurveCRVRewards:
+      return 4;
+    case t.Convex:
+      return 5;
+    case t.LidoETH:
+    case t.LidoMATIC:
+    case t.LidoETHNFT:
+    case t.LidoMATICNFT:
+      return 6;
+    case t.Pendle:
+      return 7;
+    case t.Volatile:
+      return r.amountChanges.length === 1 ? r.amountChanges[0].toBigInt() < 0n ? 1 : 0 : r.amountChanges.length === 2 ? 2 : 9;
+    default:
+      return 9;
+  }
+};
+export {
+  m as TransactionType,
+  p as externalActionToTransactionType
+};