@hinkal/common 0.0.104 → 0.0.107

package/data-structures/transactions-manager/history/getTxDetails.js

@@ -0,0 +1,74 @@
+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 { getNonLocalhostChainId as n } from "../../../constants/chains.constants.js";
+import "../../../constants/vite.constants.js";
+import "../../../constants/contracts.constants.js";
+import "../../../constants/kyc.constants.js";
+import "../../../constants/coingecko.constants.js";
+import "../../../constants/axelar.constants.js";
+import "../../../constants/rewards.constants.js";
+import "../../../constants/reorg-depths.constants.js";
+import "ethers";
+import "circomlibjs";
+import "../../crypto-keys/keys.js";
+import "axios";
+import "../../crypto-keys/encryptDecryptUtxo.js";
+import "../../../functions/web3/events/getShieldedBalance.js";
+import "../../../webworker/workerFactory.js";
+import { getExternalActionIdHash as r } from "../../../functions/utils/external-action.utils.js";
+import "../../custom-token-registry/CustomTokenRegistry.js";
+import "../../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import { logError as c } from "../../../error-handling/logError.js";
+import "../../../functions/utils/userAgent.js";
+import { getBeefyData as p } from "./getBeefyData.js";
+import { getConvexData as s } from "./getConvexData.js";
+import { getCurveData as l } from "./getCurveData.js";
+import { getDepositData as d } from "./getDepositData.js";
+import { getSwapData as f } from "./getSwapData.js";
+import { TransactionType as T, externalActionToTransactionType as g } from "./history.types.js";
+import { getLidoData as C } from "./getLidoData.js";
+import { getPendleData as D } from "./getPendleData.js";
+import { getVolatileData as I } from "./getVolatileData.js";
+import "../../volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+const tt = async (i, e, a = []) => {
+  try {
+    const o = n(i);
+    switch (e.externalActionId.toBigInt()) {
+      case r(t.Transact):
+      case 0n:
+        return d(e, o);
+      case r(t.Uniswap):
+      case r(t.Odos):
+      case r(t.OneInch):
+        return f(e, a, o);
+      case r(t.Beefy):
+        return p(e, a, o);
+      case r(t.Curve):
+      case r(t.CurveCRV):
+      case r(t.CurveDynamic):
+      case r(t.CurveCRVRewards):
+        return l(e, a, o);
+      case r(t.Convex):
+        return s(e, a, o);
+      case r(t.LidoETH):
+      case r(t.LidoETHNFT):
+      case r(t.LidoMATIC):
+      case r(t.LidoMATICNFT):
+        return C(e, a, o);
+      case r(t.Pendle):
+        return D(e, a, o);
+      case r(t.Volatile):
+        return await I(e, a, o);
+      default:
+        return { type: T.UNKNOWN };
+    }
+  } catch (o) {
+    return c(o), { type: g(e) };
+  }
+};
+export {
+  tt as getTxDetails
+};

package/data-structures/transactions-manager/history/getVolatileData.js

@@ -0,0 +1,75 @@
+import { TransactionType as d } from "./history.types.js";
+import "../../../types/circom-data.types.js";
+import { VolatileAction as A } from "../../../types/hinkal.types.js";
+import "../../../types/transactions.types.js";
+import "../../../types/curve.types.js";
+import { getERC20Registry as W } from "../../../constants/token-data/ERC20Registry.js";
+import "../../../constants/chains.constants.js";
+import "../../../constants/vite.constants.js";
+import "../../../constants/contracts.constants.js";
+import "../../../constants/kyc.constants.js";
+import "../../../constants/coingecko.constants.js";
+import "../../../constants/axelar.constants.js";
+import "../../../constants/rewards.constants.js";
+import "../../../constants/reorg-depths.constants.js";
+import { caseInsensitiveEqual as a } from "../../../functions/utils/caseInsensitive.utils.js";
+import "ethers";
+import "circomlibjs";
+import "../../crypto-keys/keys.js";
+import "axios";
+import "../../crypto-keys/encryptDecryptUtxo.js";
+import "../../../functions/web3/events/getShieldedBalance.js";
+import "../../../webworker/workerFactory.js";
+import "../../../functions/utils/external-action.utils.js";
+import { getERC20Token as l } from "../../../functions/utils/erc20tokenFunctions.js";
+import "../../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../../functions/utils/userAgent.js";
+import { VolatileHelper as g } from "../../volatile-helper/VolatileHelper.js";
+import "../../custom-token-registry/CustomTokenRegistry.js";
+import "libsodium-wrappers";
+const _ = async (r, u, n) => {
+  const c = W(n), { externalActionMetadata: B } = r, { volatileAmounts: m, redirectActionId: E, volatileAction: p } = g.decodeVolatileMetadata(B);
+  if (p === A.Deposit) {
+    const s = r.erc20TokenAddresses[0], t = c.find((e) => a(e.sharedAddress, s));
+    if (!t)
+      throw Error("Volatile not found in statistics");
+    return {
+      tokenWithBalance: {
+        token: l(t.erc20TokenAddress, n) ?? { erc20TokenAddress: t.erc20TokenAddress },
+        balance: m[0].toBigInt()
+      },
+      type: d.DEPOSIT
+    };
+  }
+  if (p === A.Withdraw) {
+    const s = r.erc20TokenAddresses[0], t = c.find((e) => a(e.sharedAddress, s));
+    if (!t)
+      throw Error("Volatile not found in statistics");
+    return {
+      tokenWithBalance: {
+        token: l(t.erc20TokenAddress, n) ?? { erc20TokenAddress: t.erc20TokenAddress },
+        balance: m[0].toBigInt()
+      },
+      type: d.WITHDRAW
+    };
+  }
+  if (p === A.Swap) {
+    const s = r.erc20TokenAddresses[0], t = r.erc20TokenAddresses[1], k = r.amountChanges[0].toBigInt(), i = c.find((o) => a(o.sharedAddress, s)), e = c.find((o) => a(o.sharedAddress, t));
+    if (!i && !e)
+      throw Error("Volatile not found in swap statistics");
+    const V = {
+      token: l(i ? i.erc20TokenAddress : s, n),
+      balance: i ? m[0].toBigInt() : k
+    }, T = u.find((o) => a(o.erc20TokenAddress, t));
+    let f = { token: l(t, n), balance: T?.amount };
+    if (e) {
+      const o = await g.getVolatileTokenBalance(n, t, T?.amount ?? 0n);
+      console.log("VOLATILE OUTPUT BALANCE: ", { balance: o }), f = { token: e, balance: o };
+    }
+    return { tokenIn: V, tokenOut: f, type: d.SWAP, protocol: E.toBigInt() };
+  }
+  return { type: d.UNKNOWN };
+};
+export {
+  _ as getVolatileData
+};

package/data-structures/transactions-manager/history/history.types.js

@@ -0,0 +1,62 @@
+import "../../../constants/chains.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 "../../../constants/vite.constants.js";
+import "../../../constants/contracts.constants.js";
+import "../../../constants/kyc.constants.js";
+import "../../../constants/coingecko.constants.js";
+import "../../../constants/axelar.constants.js";
+import "../../../constants/rewards.constants.js";
+import "../../../constants/reorg-depths.constants.js";
+import "ethers";
+import "circomlibjs";
+import "../../crypto-keys/keys.js";
+import "axios";
+import "../../crypto-keys/encryptDecryptUtxo.js";
+import "../../../functions/web3/events/getShieldedBalance.js";
+import "../../../webworker/workerFactory.js";
+import { getExternalActionIdFromNumber as o } from "../../../functions/utils/external-action.utils.js";
+import "../../custom-token-registry/CustomTokenRegistry.js";
+import "../../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../../functions/utils/userAgent.js";
+import "../../volatile-helper/VolatileHelper.js";
+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
+};

package/data-structures/transactions-manager/history/history.utils.js

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

package/data-structures/utxo/Utxo.js

@@ -0,0 +1,134 @@
+import { ethers as y } from "ethers";
+import { CIRCOM_P as o } from "../../constants/protocol.constants.js";
+import { poseidonHash as a } from "../../crypto/poseidon.js";
+import { randomBigInt as S } from "../../functions/web3/etherFunctions.js";
+import { UserKeys as d } from "../crypto-keys/keys.js";
+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/data-structures/volatile-helper/VolatileHelper.js

@@ -0,0 +1,181 @@
+import { ethers as T } from "ethers";
+import { networkRegistry as h } from "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import { ContractType as w } from "../../types/ethereum-network.types.js";
+import { ExternalActionId as f } from "../../types/external-action.types.js";
+import { VolatileAction as l } from "../../types/hinkal.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import { zeroAddress as d, ethVolatileAddress as u } from "../../constants/protocol.constants.js";
+import "circomlibjs";
+import "../crypto-keys/keys.js";
+import "axios";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import "../../functions/web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import { decodeMetadata as v, getExternalActionIdHash as g } from "../../functions/utils/external-action.utils.js";
+import { getERC20Token as m } from "../../functions/utils/erc20tokenFunctions.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "../../functions/utils/userAgent.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import { toEnumValue as A } from "../../functions/utils/enum.utils.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+const p = new T.utils.Interface([
+  "function volatileTokenToShareToken(address volatileToken) external view returns (address)",
+  "function shareTokenToVolatileToken(address volatileToken) external view returns (address)",
+  "function shareToVolatile(address shareToken, uint shareValue) external view returns (uint)",
+  "function volatileToShare(address volatileToken, uint volatileTokenValue, uint volatileTokenBalanceOverride) external view returns (uint)"
+]);
+class a {
+  static getVolatileTokenAction(r) {
+    const o = h[r], { fetchRpcUrl: t } = o, { volatileTokenActionInstanceAddress: e } = o.contractData;
+    if (!e)
+      throw Error("Volatile Token Address not found");
+    const n = new T.providers.JsonRpcProvider(t);
+    return new T.Contract(e, p, n);
+  }
+  static getVolatileTokenAddress = async (r, o) => {
+    try {
+      const e = await a.getVolatileTokenAction(r).shareTokenToVolatileToken(o);
+      if (e === d)
+        throw new Error("Can't get share token address");
+      return e;
+    } catch (t) {
+      console.log("getShareTokenAddress error ", t.message);
+      return;
+    }
+  };
+  static getShareTokenAddress = async (r, o) => {
+    if (o === d)
+      return a.getShareTokenAddress(r, u);
+    try {
+      const e = await a.getVolatileTokenAction(r).volatileTokenToShareToken(o);
+      if (e === d)
+        throw new Error("Can't get share token address");
+      return e;
+    } catch (t) {
+      console.log("getShareTokenAddress error ", t.message);
+      return;
+    }
+  };
+  static getVolatileTokenBalance = async (r, o, t, e) => {
+    try {
+      if (t === 0n)
+        return 0n;
+      const n = a.getVolatileTokenAction(r), c = t < 0n ? -1n : 1n, s = e ? { blockTag: e } : {};
+      return c * (await n.shareToVolatile(
+        o,
+        c * t,
+        s
+      )).toBigInt();
+    } catch (n) {
+      return console.log("getVolatileTokenBalance convertToShare error", n), 0n;
+    }
+  };
+  static getShareTokenBalance = async (r, o, t) => {
+    if (o === d)
+      return this.getShareTokenBalance(r, u, t);
+    try {
+      if (t === 0n)
+        return 0n;
+      const e = a.getVolatileTokenAction(r), n = t < 0n ? -1n : 1n;
+      return n * (await e.volatileToShare(
+        o,
+        n * t,
+        0n
+      )).toBigInt();
+    } catch (e) {
+      return console.log("getShareTokenBalance convertToShare error", e), 0n;
+    }
+  };
+  static processVolatileData = async (r, o, t, e) => {
+    let n = [];
+    if (o === l.Deposit)
+      e[0] = 0n, t[0] = await a.getShareTokenAddress(r, t[0]), n = [!0];
+    else if (o === l.Withdraw)
+      e[0] = -1n * await a.getShareTokenBalance(r, t[0], -e[0]), t[0] = await a.getShareTokenAddress(r, t[0]), n = [!1];
+    else if (o === l.Swap) {
+      const c = t.map((s) => m(s, r));
+      await Promise.all(
+        c.map(async (s, i) => {
+          s?.isVolatile && (console.log("is volotile", s.erc20TokenAddress), e[i] < 0n ? e[i] = -1n * await a.getShareTokenBalance(r, t[i], -e[i]) : e[i] >= 0n && (e[i] = 0n), t[i] = await a.getShareTokenAddress(r, s.erc20TokenAddress), console.log("change address ", t[i]));
+        })
+      ), n = [!1, !0];
+    }
+    return { erc20Addresses: t, amountChanges: e, onChainCreation: n };
+  };
+  static decodeVolatileMetadata = (r) => {
+    const o = v(f.Volatile, r), t = o[0], e = o[2], n = o[4], c = A(l, n);
+    return { volatileAmounts: t, redirectActionId: e, volatileAction: c };
+  };
+  // TODO: Type descriminate these base on actionType
+  static encodeVolatileActionMetadata = ({
+    actionType: r = l.Deposit,
+    volatileAmounts: o = [],
+    withdrawRecipient: t = d,
+    redirectActionId: e = 0,
+    redirectMetadata: n = "0x00"
+  }) => (console.log({ volatileAmounts: o }), T.utils.defaultAbiCoder.encode(
+    ["uint256[]", "address", "uint256", "bytes", "uint8"],
+    [o, t, e, n, r]
+  ));
+  static getVolotileMetadata = (r, o, t, e, n) => {
+    if (r === l.Deposit)
+      return {
+        actionType: r,
+        volatileAmounts: o
+      };
+    if (r === l.Withdraw) {
+      if (!t)
+        throw Error("No withdrawal recipient");
+      return {
+        actionType: r,
+        volatileAmounts: o,
+        withdrawRecipient: t
+      };
+    }
+    if (r === l.Swap) {
+      if (e === void 0 || !n)
+        throw Error("No redirect action Id");
+      return {
+        actionType: r,
+        volatileAmounts: o,
+        redirectActionId: g(e),
+        redirectMetadata: n
+      };
+    }
+    throw new Error("Invalid Request");
+  };
+  static getVolatileExternalData = async (r, o, t, e, n, c) => {
+    const i = r.getContractWithFetcher(w.VolatileTokenAction).address;
+    let k = [];
+    return o === l.Deposit && (k = t), o === l.Withdraw && (k = [-t[0]]), o === l.Swap && (k = [-t[0], 0n]), {
+      externalActionId: f.Volatile,
+      externalAddress: i,
+      externalActionMetadata: this.encodeVolatileActionMetadata(
+        this.getVolotileMetadata(
+          o,
+          k,
+          e,
+          n,
+          c
+        )
+      )
+    };
+  };
+  static decodeExternalActionId = (r) => {
+    let o = !1, t;
+    const { externalActionId: e } = r.decodedInput;
+    return (typeof e == "string" ? e : e.toBigInt()) === g(f.Volatile) && ({ redirectActionId: t } = a.decodeVolatileMetadata(r.decodedInput.externalActionMetadata), o = !0), { isVolatile: o, redirectActionId: t };
+  };
+}
+export {
+  a as VolatileHelper
+};

package/error-handling/customErrors/ErrorWithAmount.js

@@ -0,0 +1,9 @@
+class s extends Error {
+  amount;
+  constructor(r, t) {
+    super(t), this.amount = r;
+  }
+}
+export {
+  s as ErrorWithAmount
+};

package/error-handling/customErrors/FeeOverTransactionValueError.js

@@ -0,0 +1,9 @@
+import { transactionErrorCodes as t } from "../error-codes.constants.js";
+class e extends Error {
+  constructor(r) {
+    super(t.FEES_OVER_TRANSACTION_VALUE), this.data = r, this.name = this.constructor.name;
+  }
+}
+export {
+  e as FeeOverTransactionValueError
+};

package/error-handling/customErrors/customErrors.helpers.js

@@ -0,0 +1,21 @@
+import { fixDecimalsAmount as i } from "../../functions/utils/amounts.utils.js";
+import { getAmountInToken as m } from "../../functions/web3/etherFunctions.js";
+import { transactionErrorCodes as f } from "../error-codes.constants.js";
+import { ErrorCategory as c } from "../types.js";
+import { FeeOverTransactionValueError as l } from "./FeeOverTransactionValueError.js";
+const v = (e, r) => {
+  const { totalFeeWEI: n, feeUnit: t } = e.data;
+  if (!t)
+    return e.message;
+  const s = m(t, n);
+  let o = "transact", a = "an equivalent of ";
+  return r === c.WITHDRAW && (o = "withdraw", a = ""), `Fees are over transaction value. Please ${o} at least ${a} ${i(
+    Number(s)
+  )} of ${t?.symbol} (subject to real-time price)`;
+}, F = (e, r) => {
+  throw e instanceof l || e?.message === f.INSUFFICIENT_FUNDS_TO_TRANSACT ? e : Error(r);
+};
+export {
+  v as getGenericFeeOverTransactionValueErrorMessage,
+  F as rethrowKnownGasErrorIfPossible
+};