@hinkal/common 0.0.104 → 0.0.106

package/functions/snarkjs/constructGeneralZkProof.js

@@ -0,0 +1,129 @@
+import { chainIds as J } from "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import { HinkalStakeMode as c } from "../../types/hinkal.stake.types.js";
+import { randomBigInt as V } from "../web3/etherFunctions.js";
+import { Utxo as j } from "../../data-structures/utxo/Utxo.js";
+import "axios";
+import "ethers";
+import "../../data-structures/crypto-keys/keys.js";
+import "../../data-structures/crypto-keys/encryptDecryptUtxo.js";
+import { zeroAddress as q } from "../../constants/protocol.constants.js";
+import "../web3/events/getShieldedBalance.js";
+import { performTaskWithWorker as s } from "../../webworker/performTaskWithWorker.js";
+import { WorkerVariant as l } from "../../webworker/worker.registry.js";
+import { ZKProofWorkerActionType as S } from "../../webworker/zkProofWorker/zkProofWorker.types.js";
+import { calcAmountChanges as F, calcEncryptedOutputs as Q, buildOutCommitments as X, calcPublicSignalCount as Y, createCallDataHash as $, calcStealthAddressStructure as U } from "./common.snarkjs.js";
+import { generateCircomData as x } from "./generateCircomData.js";
+import { generateZkProof as oo } from "./generateZkProof.js";
+import "circomlibjs";
+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 Lo = async (f, g, e, a, h, u, k, C, I, T = q, R = J.localhost, r = e.map(() => !1), y = e.map(() => 0n), b = void 0, m) => {
+  const N = f.getRootHash(), P = g.getRootHash(), D = e.map((o) => o.map((i) => i.getConstructableParams())), _ = h.getSignature(), { accessTokenSiblings: B, accessTokenSiblingSides: E } = await s({
+    type: l.ZKProof,
+    payload: {
+      type: S.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES,
+      data: {
+        userSignature: _,
+        merkleTreeAccessTokenSerialized: g.toJSON()
+      }
+    }
+  }), { inCommitmentSiblings: K, inCommitmentSiblingSides: L } = await s({
+    type: l.ZKProof,
+    payload: {
+      type: S.CALC_COMMITMENTS_SIBLING_AND_SIDES,
+      data: { inputUtxosSerialized: D, userSignature: _, merkleTreeSerialized: f.toJSON() }
+    }
+  }), O = F(e, a), d = Q(
+    a,
+    (m && m.mode !== c.Deposit) ?? !1
+  ), p = h.getShieldedPrivateKey(), H = j.findCorrectRandomization(V(31), p), Z = await s({
+    type: l.ZKProof,
+    payload: {
+      type: S.BUILD_IN_NULLIFIERS,
+      data: { inputUtxosSerialized: D, onChainCreation: r }
+    }
+  }), t = {
+    rootHashHinkal: N,
+    shieldedPrivateKey: p,
+    erc20TokenAddresses: e.map((o) => o[0].erc20TokenAddress),
+    inAmounts: e.map((o) => o.map((i) => i.amount.toString())),
+    inTimeStamps: e.map((o) => o.map((i) => i.timeStamp)),
+    inRandomizations: e.map((o) => o.map((i) => i.randomization)),
+    inNullifiers: Z,
+    inCommitmentSiblings: K,
+    inCommitmentSiblingSides: L,
+    outAmounts: a.map((o) => o.map((i) => i.amount.toString())),
+    outTimeStamp: BigInt(a[0][0].timeStamp),
+    outPublicKeys: a.map((o) => o.map((i) => i.getStealthAddress())),
+    extraRandomization: H,
+    amountChanges: O,
+    outCommitments: X(a, r),
+    rootHashAccessToken: P,
+    accessTokenSiblings: B,
+    accessTokenSiblingSides: E,
+    calldataHash: 0n
+  };
+  m || (t.onChainCreation = r);
+  const n = e.map((o) => o[0].tokenId ?? 0), z = n.reduce((o, i) => o + i, 0) > 0 ? n.length : 0;
+  z > 0 && (t.tokenIds = n);
+  const A = Y(
+    u,
+    t.erc20TokenAddresses,
+    t.amountChanges,
+    t.inNullifiers,
+    t.outCommitments,
+    z
+  );
+  t.calldataHash = $(
+    A,
+    T,
+    C,
+    k,
+    I,
+    d,
+    y,
+    b
+  ), m && (m.mode === c.Deposit && (t.mode = 0), m.mode === c.Stake && (t.mode = 1), m.mode === c.Unstake && (t.mode = 2), t.stakedTokenRecipient = m.stakedTokenRecipient, t.stakeBlinding = m.stakeBlinding, t.depositorAddress = m.depositorAddress);
+  const { zkCallData: w, publicSignals: W } = await oo(R, u, t);
+  console.log("publicSignals", W);
+  const v = U(H, p), M = await x(
+    N,
+    P,
+    e,
+    a,
+    d,
+    y,
+    A,
+    k,
+    C,
+    I,
+    T,
+    t.calldataHash,
+    n,
+    v,
+    r,
+    b
+  ), G = {
+    tokenNumber: e.length,
+    nullifierAmount: e[0].length,
+    outputAmount: a[0].length
+  };
+  return { zkCallData: w, circomData: M, dimData: G, encryptedOutputs: d };
+};
+export {
+  Lo as constructZkProof
+};

package/functions/snarkjs/generateCircomData.js

@@ -0,0 +1,60 @@
+import "../../constants/chains.constants.js";
+import { defaultHookData as S } from "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "ethers";
+import { zeroAddress as h } from "../../constants/protocol.constants.js";
+import "circomlibjs";
+import "../../data-structures/crypto-keys/keys.js";
+import "axios";
+import "../../data-structures/crypto-keys/encryptDecryptUtxo.js";
+import "../web3/events/getShieldedBalance.js";
+import { performTaskWithWorker as C } from "../../webworker/performTaskWithWorker.js";
+import { WorkerVariant as T } from "../../webworker/worker.registry.js";
+import { ZKProofWorkerActionType as W } from "../../webworker/zkProofWorker/zkProofWorker.types.js";
+import { calcAmountChanges as b, buildOutCommitments as L } from "./common.snarkjs.js";
+import { getExternalActionIdHash as N } from "../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 ir = async (e, a, o, t, n, s, c, m, i, d, f, k, l, g, p, u) => {
+  const y = b(o, t, !0), A = o.map((r) => r.map((I) => I.getConstructableParams())), D = await C({
+    type: T.ZKProof,
+    payload: {
+      type: W.BUILD_IN_NULLIFIERS,
+      data: { inputUtxosSerialized: A, onChainCreation: p }
+    }
+  });
+  return {
+    rootHashHinkal: e,
+    erc20TokenAddresses: o.map((r) => r[0].erc20TokenAddress),
+    tokenIds: l.map((r) => String(r)),
+    amountChanges: y,
+    inputNullifiers: D,
+    outCommitments: L(t, p),
+    encryptedOutputs: n,
+    flatFees: s,
+    timeStamp: t[0][0].timeStamp,
+    stealthAddressStructure: g,
+    rootHashAccessToken: a,
+    relay: f,
+    externalAddress: i === void 0 ? h : i,
+    externalActionMetadata: d,
+    externalActionId: typeof m == "bigint" ? 0n : N(m),
+    hookData: u || S,
+    publicSignalCount: c,
+    calldataHash: k
+  };
+};
+export {
+  ir as generateCircomData
+};

package/functions/snarkjs/generateZkProof.js

@@ -0,0 +1,18 @@
+import { performTaskWithWorker as p } from "../../webworker/performTaskWithWorker.js";
+import { SnarkJSWorkerActionType as i } from "../../webworker/snarkjsWorker/snarkjsWorker.types.js";
+import { WorkerVariant as c } from "../../webworker/worker.registry.js";
+import { getZKeyFile as r, getWASMFile as g } from "./getZKFiles.js";
+const S = async (o, t, e) => {
+  console.log("Zero Knowledge proof construction started, please wait...", r(t, o));
+  const a = g(t, o), n = r(t, o), { publicSignals: l, zkCallData: s } = await p({
+    type: c.SnarkJS,
+    payload: {
+      type: i.FULL_PROVE,
+      data: { input: e, chainId: o, wasmFilePath: a, zKeyFilePath: n }
+    }
+  });
+  return console.log("Zero Knowledge proof construction finished "), { zkCallData: s, publicSignals: l };
+};
+export {
+  S as generateZkProof
+};

package/functions/snarkjs/getZKFiles.js

@@ -0,0 +1,30 @@
+import { chainIds as o } 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 { prodVerifiers as t, localVerifiers as m } from "./constant.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 j = (r, i) => i === o.localhost ? m[`${r}Wasm`] : t(i)[`${r}Wasm`], q = (r, i) => i === o.localhost ? m[`${r}Zkey`] : t(i)[`${r}Zkey`];
+export {
+  j as getWASMFile,
+  q as getZKeyFile
+};

package/functions/staking/index.js

@@ -0,0 +1,40 @@
+import { ethers as i } from "ethers";
+import { UserKeys as f } from "../../data-structures/crypto-keys/keys.js";
+import s from "libsodium-wrappers";
+import { poseidonHash as c } from "../../crypto/poseidon.js";
+import "circomlibjs";
+const S = (t, e, r) => {
+  const o = i.utils.defaultAbiCoder.encode(
+    ["uint256", "address"],
+    [t, e]
+  ), n = s.crypto_box_seal(o, i.utils.arrayify(r));
+  return `0x${Buffer.from(n).toString("hex")}`;
+}, k = (t, e) => {
+  const r = Buffer.from(t.slice(2), "hex"), { publicKey: o, privateKey: n } = f.getEncryptionKeyPair(e.getShieldedPrivateKey());
+  try {
+    const a = s.crypto_box_seal_open(
+      r,
+      i.utils.arrayify(o),
+      i.utils.arrayify(n)
+    ), d = Buffer.from(a).toString("utf-8"), [u, y] = i.utils.defaultAbiCoder.decode(
+      ["uint256", "address"],
+      d
+    );
+    return { stakeBlinding: u.toBigInt(), stakedTokenRecipient: y };
+  } catch {
+    console.log("failed to decrypt");
+    return;
+  }
+}, B = (t, e, r, o, n, a) => BigInt(
+  c(...[t, e, r, o, n, a].map(BigInt))
+), h = (t, e) => c(t, e), x = (t, e, r, o, n) => i.utils.defaultAbiCoder.encode(
+  ["uint8", "uint256", "address", "bytes", "bytes"],
+  [t, e, r, o, n]
+);
+export {
+  h as calculateStakeNullifier,
+  B as createStakeCommitment,
+  k as decryptStake,
+  x as encodeHStakeMetadata,
+  S as encryptStake
+};

package/functions/utils/amounts.utils.js

@@ -0,0 +1,70 @@
+const s = (t) => t.reduce((n, e) => n + e, 0), u = (t) => t / 100, a = (t, n) => n * t / 10000n;
+function d(t) {
+  return typeof t == "object" && "toBigInt" in t ? t.toBigInt() : BigInt(t);
+}
+const g = (t) => {
+  try {
+    return BigInt(t);
+  } catch {
+    return;
+  }
+}, f = (t) => {
+  const n = Number(t);
+  return Number.isNaN(n) ? void 0 : n;
+}, m = (t, n) => t ? parseInt(t, 10) : n;
+function l() {
+  BigInt.prototype.toJSON = function() {
+    return this.toString();
+  };
+}
+function p(...t) {
+  return t.reduce((n, e) => e > n ? e : n);
+}
+function I(t) {
+  return t === 0 ? 0 : t < 99999e-11 ? "< 0.000001" : +Number(t).toFixed(6);
+}
+const B = (t, n) => {
+  const e = t.toFixed(20), r = e.indexOf(".");
+  if (r === -1)
+    return e;
+  const o = r + n + 1;
+  return e.substring(0, o);
+}, i = (t) => {
+  if (/^0+$/.test(t))
+    return "0";
+  if (/^0\.\d+$/.test(t))
+    return t;
+  const n = t.replace(/^0+/, "");
+  return n.startsWith(".") ? `0${n}` : n;
+}, N = (t) => {
+  const n = t.split("."), e = n[0], r = n.length > 1 ? `.${n[1]}` : "";
+  return `${i(e).replace(/\B(?=(\d{3})+(?!\d))/g, ",")}${r}`;
+}, P = (t) => {
+  const n = t.match(/^(\d+)(\.\d{1,18})?\d*$/);
+  if (n) {
+    const e = n[1], r = n[2] || "";
+    return `${e}${r}`;
+  }
+  return t;
+}, $ = (t) => t < 0n ? -t : t, b = (t, n, e) => {
+  const r = t < n ? t : n;
+  return e ? r < e ? r : e : r;
+};
+export {
+  $ as absBigInt,
+  u as beepsToPercentage,
+  l as bigintApplySugar,
+  p as bigintMax,
+  a as calculateAmountUsingBeeps,
+  s as calculateSum,
+  I as fixDecimalsAmount,
+  B as getValueFirstNDigit,
+  b as minBigInt,
+  d as toBigInt,
+  g as toBigIntOrUndefined,
+  N as toCommaSeparatedNumberString,
+  m as toInt,
+  f as toNumberOrUndefined,
+  i as trimLeadingZeros,
+  P as truncateTo18DecimalPlaces
+};

package/functions/utils/axelar.utils.js

@@ -0,0 +1,38 @@
+import "../../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 "./external-action.utils.js";
+import "../../data-structures/custom-token-registry/CustomTokenRegistry.js";
+import "./convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "./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 { AxelarRegistry as p } from "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+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/functions/utils/cacheFunctions.js

@@ -0,0 +1,67 @@
+import "ethers";
+import "axios";
+import "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "circomlibjs";
+import "../../data-structures/crypto-keys/keys.js";
+import { serializeDecodedTxs as g, deserializeDecodedTxs as C } from "./getDataFromTransaction.js";
+import "../web3/events/getShieldedBalance.js";
+import "./external-action.utils.js";
+import "../../data-structures/custom-token-registry/CustomTokenRegistry.js";
+import "./convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import { logError as p } from "../../error-handling/logError.js";
+import "./userAgent.js";
+import "../../data-structures/crypto-keys/encryptDecryptUtxo.js";
+import "../../webworker/workerFactory.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 l = {
+  encryptedOutputs: [],
+  lastOutput: ""
+}, c = (o, t) => {
+  const r = o.substring(0, 25), s = t.substring(0, 25);
+  return { shortPublicKey: r, shortHinkalAddress: s };
+}, L = (o, t, r) => {
+  if (!o || !t || !r)
+    throw Error("GetHinkalCache: incorrect arguments");
+  const { shortPublicKey: s, shortHinkalAddress: e } = c(t, r);
+  return JSON.parse(
+    localStorage.getItem(`hinkalCache-${o}-${s}-${e}`) ?? JSON.stringify(l)
+  );
+}, u = (o, t, r, s) => {
+  if (!t || !r || !s)
+    throw Error("SetHinkalCache: incorrect arguments");
+  const { shortPublicKey: e, shortHinkalAddress: a } = c(r, s);
+  localStorage.setItem(`hinkalCache-${t}-${e}-${a}`, JSON.stringify(o));
+}, M = (o, t, r) => {
+  u(l, o, t, r);
+}, Q = (o, t, r, s, e) => {
+  if (!t || !r || !s)
+    throw Error("saveTxsCache: incorrect arguments");
+  const { shortPublicKey: a, shortHinkalAddress: n } = c(r, s), i = g(o);
+  p("saveTxsCache before saving", { serializedTxs: i }), localStorage.setItem(
+    `txsCache-${t}-${a}-${n}`,
+    JSON.stringify({ serializedTxs: i, lastHash: e })
+  );
+}, x = { serializedTxs: [], lastHash: "" }, R = (o, t, r) => {
+  if (!o || !t || !r)
+    throw Error("loadTxsCache: incorrect arguments");
+  const { shortPublicKey: s, shortHinkalAddress: e } = c(t, r), a = localStorage.getItem(`txsCache-${o}-${s}-${e}`), { serializedTxs: n, lastHash: i } = JSON.parse(a ?? JSON.stringify(x)), m = n.map((h) => C(h));
+  return p("loadTxsCache ", { decodedTxs: m, lastHash: i }), { decodedTxs: m, lastHash: i === "" ? void 0 : i };
+};
+export {
+  L as getHinkalCache,
+  R as loadTxsCache,
+  M as resetCache,
+  Q as saveTxsCache,
+  u as setHinkalCache
+};

package/functions/utils/caseInsensitive.utils.js

@@ -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/functions/utils/convertIntegrationProviderToExternalActionId.js

@@ -0,0 +1,16 @@
+import "../../types/circom-data.types.js";
+import { ExternalActionId as r } from "../../types/external-action.types.js";
+import { IntegrationProvider as o } from "../../types/hinkal.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+const t = {
+  [o.UNISWAP]: r.Uniswap,
+  [o.ODOS]: r.Odos,
+  [o.ONEINCH]: r.OneInch,
+  [o.PENDLE]: r.Pendle,
+  [o.ALL]: void 0,
+  [o.NONE]: void 0
+}, p = (n) => t[n];
+export {
+  p as convertIntegrationProviderToExternalActionId
+};

package/functions/utils/create-provider.js

@@ -0,0 +1,5 @@
+import { ethers as e } from "ethers";
+const t = (r) => new e.providers.JsonRpcProvider(r);
+export {
+  t as createProvider
+};

package/functions/utils/enum.utils.js

@@ -0,0 +1,14 @@
+function e(r, n) {
+  return Object.values(r).includes(n);
+}
+function o(r, n, i = !1) {
+  if (e(r, n))
+    return n;
+  const t = `Value ${JSON.stringify(n)} is not a valid member of enum ${JSON.stringify(r)}.`;
+  if (i)
+    throw new Error(t);
+}
+export {
+  e as isInEnum,
+  o as toEnumValue
+};

package/functions/utils/erc20tokenFunctions.js

@@ -0,0 +1,20 @@
+import { getERC20Registry as n } from "../../constants/token-data/ERC20Registry.js";
+import { customTokenRegistry as i } from "../../data-structures/custom-token-registry/CustomTokenRegistry.js";
+const T = (e, o) => {
+  const r = n(o), t = i.getCustomTokens(o);
+  return [...r, ...t].find((s) => e === void 0 ? !1 : s.erc20TokenAddress.toLowerCase() === e.toLowerCase());
+}, g = (e, o) => {
+  const r = n(o), t = i.getCustomTokens(o);
+  return [...r, ...t].find((s) => e === void 0 ? !1 : s.symbol.toLowerCase() === e.toLowerCase());
+}, c = (e, o) => {
+  const r = n(o);
+  if (e.hasHToken)
+    return r.find(
+      (t) => t.underlyingErc20TokenAddress?.toLowerCase() === e.erc20TokenAddress.toLowerCase() && t.isHToken
+    );
+};
+export {
+  T as getERC20Token,
+  g as getERC20TokenBySymbol,
+  c as getHToken
+};

package/functions/utils/evmNetworkFunctions.js

@@ -0,0 +1,29 @@
+import { networkRegistry as i, chainIdsByType as o } 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 "./external-action.utils.js";
+import "../../data-structures/custom-token-registry/CustomTokenRegistry.js";
+import "./convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "./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 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/functions/utils/external-action.utils.js

@@ -0,0 +1,61 @@
+import { ethers as u } from "ethers";
+import { CIRCOM_P as r } from "../../constants/protocol.constants.js";
+import "../../types/circom-data.types.js";
+import { ExternalActionId as t } from "../../types/external-action.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import { toNumberOrUndefined as a } from "./amounts.utils.js";
+const s = (n) => n === 0n ? 0n : BigInt(u.utils.id(n)) % r, g = (n) => BigInt(n) === 0n ? t.Transact : Object.values(t).find(
+  (e) => BigInt(n) === s(e)
+), i = {
+  [t.Curve]: ["uint8", "address", "uint256", "uint256"],
+  [t.CurveDynamic]: ["uint8", "address", "uint256", "uint256"],
+  [t.CurveCRV]: ["uint8", "address", "uint256", "uint256"],
+  [t.CurveCRVRewards]: ["uint8", "address", "uint256", "uint256"],
+  [t.Convex]: ["uint8", "uint256", "uint256", "uint256"],
+  [t.Beefy]: ["uint8", "bytes", "bytes", "address"],
+  [t.BeefyStake]: ["uint8", "address", "uint256", "uint256"],
+  [t.Volatile]: ["uint256[]", "address", "uint256", "bytes", "uint8"],
+  [t.LidoETH]: ["uint8"],
+  [t.LidoMATIC]: ["uint8"],
+  [t.LidoETHNFT]: ["uint8"],
+  [t.LidoMATICNFT]: ["uint8"],
+  [t.Pendle]: ["uint8", "address", "uint256", "uint256", "address", "bool", "bytes"],
+  [t.PendleLP]: ["uint8", "address", "uint256", "uint256", "bytes"],
+  [t.Connext]: [
+    "bool",
+    "bool",
+    "uint32",
+    "uint256",
+    "uint256",
+    "uint256",
+    "uint256[2]",
+    "uint256[2][2]",
+    "uint256[2]"
+  ]
+}, c = {
+  [t.Pendle]: !0
+}, d = {
+  [t.Volatile]: 4
+}, y = (n, e) => {
+  if (c[n])
+    return a(e?.hookData?.preHookMetadata);
+  if (!i[n] || !e?.externalActionMetadata)
+    return;
+  let o = 0;
+  return d[n] && (o = d[n]), u.utils.defaultAbiCoder.decode(
+    i[n],
+    e.externalActionMetadata
+  )[o];
+}, v = (n, e) => {
+  if (!e || !i[n])
+    throw Error("No externalActionMetadata");
+  return u.utils.defaultAbiCoder.decode(i[n], e);
+}, E = (n) => BigInt(u.utils.keccak256(n)) % r;
+export {
+  v as decodeMetadata,
+  y as getActionFromMetadata,
+  g as getExternalActionIdFromNumber,
+  s as getExternalActionIdHash,
+  E as getExternalMetadataHash
+};