@hinkal/common 0.0.103 → 0.0.106

package/constants/token-data/popularTokens.constants.js

@@ -0,0 +1,14 @@
+const o = [
+  { symbol: "hETH" },
+  { symbol: "BNB" },
+  { symbol: "DAI" },
+  { symbol: "ETH" },
+  { symbol: "MATIC" },
+  { symbol: "USDC" },
+  { symbol: "USDT" },
+  { symbol: "WETH" },
+  { symbol: "stETH" }
+];
+export {
+  o as PopularTokenSymbols
+};

package/constants/token-data/tokenPricing.consts.js

@@ -0,0 +1,8 @@
+const e = "https://api.beefy.finance/tvl", n = "https://api.beefy.finance/vaults", t = "https://api.beefy.finance/lps", a = "https://api.beefy.finance/prices", o = "https://api-v2.pendle.finance/core/v1/";
+export {
+  t as urlForBeefyVaultLpTokens,
+  n as urlForBeefyVaultTokens,
+  e as urlForBeefyVaultTotalInUSD,
+  o as urlForPendleAPI,
+  a as urlForRegularTokenPricesInBeefy
+};

package/constants/vite.constants.js

@@ -0,0 +1,29 @@
+import { toEnumValue as u } from "../functions/utils/enum.utils.js";
+import { isOnServer as r } from "../functions/utils/process.utils.js";
+var i = /* @__PURE__ */ ((n) => (n.DEVELOPMENT = "development", n.STAGING = "staging", n.PLAYGROUND = "playground", n.PRODUCTION = "production", n))(i || {});
+const e = {
+  development: ["localhost", "192.", "127."],
+  playground: ["playground"],
+  // The code deployed to the 'playground' branch is hosted by Netlify at 'hinkal-playground.netlify.app'
+  staging: ["working-branch"]
+  // The code deployed to the 'new' branch is hosted by Netlify at 'working-branch.netlify.app'
+};
+function o(n, d) {
+  return d.some((s) => n.includes(s));
+}
+const l = () => (require("dotenv").config(), u(i, process.env.DEPLOYMENT_MODE) || "development"), p = () => {
+  if (!r() && typeof window > "u")
+    return;
+  if (r())
+    return l();
+  const n = window?.location?.host;
+  return o(n, e.development) ? "development" : o(n, e.playground) ? "playground" : o(n, e.staging) ? "staging" : "production";
+}, t = p(), g = t === "staging", c = t === "playground", a = t === "development", v = g || a || c;
+export {
+  i as DEPLOYMENT_MODE,
+  t as deploymentMode,
+  a as isDevelopment,
+  v as isNotProduction,
+  c as isPlayground,
+  g as isStaging
+};

package/crypto/babyJub.js

@@ -0,0 +1,15 @@
+import { buildBabyjub as b } from "circomlibjs";
+class t {
+  babyjub = void 0;
+  async init() {
+    this.babyjub = await b();
+  }
+  getJub() {
+    return this.babyjub;
+  }
+}
+const u = new t(), n = () => u.getJub();
+export {
+  n as babyJubInstance,
+  u as jubHolder
+};

package/crypto/poseidon.js

@@ -0,0 +1,26 @@
+import { buildPoseidon as t } from "circomlibjs";
+import { BigNumber as e } from "ethers";
+import { toBigInt as s } from "../functions/utils/amounts.utils.js";
+class r {
+  poseidon = void 0;
+  async init() {
+    this.poseidon = await t();
+  }
+  getPoseidon() {
+    return this.poseidon;
+  }
+}
+const i = new r();
+function g(...n) {
+  const o = i.getPoseidon();
+  return s(o.F.toString(o(n)));
+}
+const m = (...n) => {
+  const o = i.getPoseidon();
+  return e.from(o.F.toString(o([...n]))).toHexString();
+};
+export {
+  g as poseidonFunction,
+  m as poseidonHash,
+  i as poseidonHolder
+};

package/crypto/preProcessing.js

@@ -0,0 +1,9 @@
+import { jubHolder as e } from "./babyJub.js";
+import { poseidonHolder as i } from "./poseidon.js";
+let r = !1;
+const s = async () => {
+  r || (await i.init(), await e.init(), r = !0);
+};
+export {
+  s as preProcessing
+};

package/data-structures/Hinkal/Hinkal.js

@@ -0,0 +1,299 @@
+import "../../types/circom-data.types.js";
+import { ContractType as s } from "../../types/ethereum-network.types.js";
+import { EventType as c } from "../../types/hinkal.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import { checkHinkalAccessToken as g, mintAccessToken as u, mintTokenCrossChain as k } from "../../functions/web3/functionCalls/accessTokenCalls.js";
+import { getShieldedBalance as A } from "../../functions/web3/events/getShieldedBalance.js";
+import { UserKeys as o } from "../crypto-keys/keys.js";
+import { hinkalActionBeefy as v } from "./hinkalActionBeefy.js";
+import { hinkalActionConvex as y } from "./hinkalActionConvex.js";
+import { hinkalActionCurve as C } from "./hinkalActionCurve.js";
+import { hinkalActionPendle as f } from "./hinkalActionPendle.js";
+import { hinkalDeposit as w, hinkalDepositForOther as P } from "./hinkalDeposit.js";
+import { hinkalSwap as T } from "./hinkalSwap.js";
+import { hinkalWithdraw as S } from "./hinkalWithdraw.js";
+import { resetMerkleTrees as E } from "./resetMerkleTrees.js";
+import { MerkleTree as h } from "../merkle-tree/MerkleTree.js";
+import { poseidonFunction as d } from "../../crypto/poseidon.js";
+import "circomlibjs";
+import { networkRegistry as H } from "../../constants/chains.constants.js";
+import { transactionErrorCodes as p } from "../../error-handling/error-codes.constants.js";
+import "ethers";
+import "axios";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import { supportedPassportLinks as F } from "../../constants/kyc.constants.js";
+import { monitor as I } from "../../API/callMonitor.js";
+import { hinkalActionLido as R } from "./hinkalActionLidoEth.js";
+import "../../constants/coingecko.constants.js";
+import { getAxelarGasEstimate as L } from "../../API/getAxelarGasEstimate.js";
+import { API as l } from "../../API/API.js";
+import "../../constants/vite.constants.js";
+import { TransactionsManager as M } from "../transactions-manager/TransactionsManager.js";
+import { hinkalActionVolatile as W } from "./hinkalActionVolatile.js";
+import { hinkalActionPendleLP as N, hinkalGetPendleLPClaimableParams as K } from "./hinkalActionPendleLP.js";
+import { getConnextReceiveFee as O } from "../../API/getConnextReceiveFee.js";
+import { hinkalActionStake as x } from "./hinkalActionStake.js";
+import { multiThreadedUtxoUtils as B } from "../MultiThreadedUtxoUtils/MultiThreadedUtxoUtils.js";
+import { hinkalPrivateWallet as U } from "./hinkalPrivateWallet.js";
+import "../../constants/reorg-depths.constants.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../volatile-helper/VolatileHelper.js";
+import "../../functions/utils/external-action.utils.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../functions/utils/userAgent.js";
+import { reloadPage as b } from "../../functions/utils/reloadPage.js";
+import "../../webworker/workerFactory.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+class Be {
+  providerAdapter;
+  userKeys;
+  signingMessage = "Login to Hinkal Protocol";
+  merkleTreeHinkal;
+  merkleTreeAccessToken;
+  nullifiers;
+  encryptedOutputs;
+  commitmentsSnapshotService;
+  nullifierSnapshotService;
+  accessTokenSnapshotService;
+  transactionsManager;
+  utxoUtils = B;
+  constructor() {
+    this.userKeys = new o(void 0), this.merkleTreeHinkal = h.create(d, 25n, 0n), this.merkleTreeAccessToken = h.create(d, 25n, 0n), this.nullifiers = /* @__PURE__ */ new Set(), this.encryptedOutputs = [], this.transactionsManager = new M();
+  }
+  async initProviderAdapter(e, t) {
+    await this.updateProviderAdapter(t);
+    const r = await this.connectAndPatchProvider(e);
+    await t.init(r), await this.setListeners();
+  }
+  async initUserKeys() {
+    this.userKeys = new o(await this.getProviderAdapter().signMessage(this.signingMessage));
+  }
+  async initUserKeysWithPassword(e) {
+    this.userKeys = new o(e);
+  }
+  async resetMerkle() {
+    this.isSelectedNetworkSupported() && await E(this);
+  }
+  getProviderAdapter() {
+    if (!this.providerAdapter)
+      throw new Error("ProviderAdapter is not initialized");
+    return this.providerAdapter;
+  }
+  async waitForTransaction(e, t = 1) {
+    return !!await this.providerAdapter?.waitForTransaction(e, t);
+  }
+  getContractMetadata(e, t) {
+    return this.getProviderAdapter().getContractMetadata(e, t);
+  }
+  getContract(e, t = void 0, r) {
+    return this.getProviderAdapter().getContract(e, t, r);
+  }
+  async signMessage(e) {
+    return await this.getProviderAdapter().signMessage(e);
+  }
+  async signTypedData(e, t, r) {
+    return await this.getProviderAdapter().signTypedData(e, t, r);
+  }
+  getContractWithSigner(e, t = "") {
+    return this.getProviderAdapter().getContractWithSigner(e, t);
+  }
+  getContractWithFetcher(e, t = "") {
+    return this.getProviderAdapter().getContractWithFetcher(e, t);
+  }
+  getContractWithFetcherForEthereum(e, t) {
+    return this.getProviderAdapter().getContractWithFetcherForEthereum(e, t);
+  }
+  isSelectedNetworkSupported() {
+    return !!H[this.getCurrentChainId()];
+  }
+  async switchNetwork(e) {
+    try {
+      await this.getProviderAdapter().switchNetwork(e);
+    } catch {
+      throw new Error(p.FAILED_TO_SWITCH_NETWORKS);
+    }
+  }
+  getCurrentChainId() {
+    const { chainId: e } = this.getProviderAdapter();
+    if (!e)
+      throw new Error("Illegal State: no chainId");
+    return e;
+  }
+  getSelectedNetwork() {
+    return this.providerAdapter?.getSelectedNetwork();
+  }
+  isPermitterAvailable() {
+    return this.getProviderAdapter().isPermitterAvailable();
+  }
+  async connectAndPatchProvider(e) {
+    return await this.getProviderAdapter().connectAndPatchProvider(e);
+  }
+  async disconnectFromConnector() {
+    await this.getProviderAdapter().disconnectFromConnector();
+  }
+  async updateProviderAdapter(e) {
+    try {
+      this.providerAdapter && this.providerAdapter.release(), this.providerAdapter = e;
+    } catch (t) {
+      throw console.error(t), Error("updateProviderAdapter failed, please try again.");
+    }
+  }
+  async setListeners() {
+    this.providerAdapter?.setChainEventListener({
+      onAccountChanged: () => {
+        this.onAccountChanged();
+      },
+      onChainChanged: (e) => {
+        this.onChainChanged(e);
+      }
+    });
+  }
+  async onAccountChanged() {
+    await this.getProviderAdapter().onAccountChanged(), document.dispatchEvent(new Event(c.AccountChanged));
+  }
+  async onChainChanged(e) {
+    e ? (await this.getProviderAdapter().onChainChanged(e), document.dispatchEvent(new Event(c.NetworkChange))) : (await this.disconnectFromConnector(), b());
+  }
+  async monitorConnectedAddress() {
+    I(await this.getEthereumAddress(), this.getCurrentChainId());
+  }
+  async getBalances() {
+    return A(this);
+  }
+  getSupportedPassportLinks() {
+    return F;
+  }
+  checkAccessToken() {
+    return g(this);
+  }
+  async getAxelarEstimate(e, t, r, i) {
+    return L(
+      e,
+      t,
+      r,
+      i,
+      this.userKeys.getAccessKey()
+    );
+  }
+  async getConnextReceiveFee(e, t) {
+    return O(this.getCurrentChainId(), e, t);
+  }
+  async mintHinkalAccessToken(e) {
+    return u(this, e);
+  }
+  async mintHinkalAccessTokenCrossChain(e, t) {
+    return k(this, e, t);
+  }
+  async getHinkalTreeRootHash() {
+    return this.getContractWithFetcher(s.HinkalContract).getRootHash();
+  }
+  async getAccessTokenTreeRootHash() {
+    return this.getContractWithFetcher(s.CrossChainAccessTokenContract).getRootHash();
+  }
+  async resetMerkleTreesIfNecessary() {
+    if (!this.isSelectedNetworkSupported())
+      throw new Error(p.UNSUPPORTED_NETWORK);
+    const [e, t] = await Promise.all([
+      this.getHinkalTreeRootHash(),
+      this.getAccessTokenTreeRootHash()
+    ]);
+    (e.toBigInt() !== this.merkleTreeHinkal.getRootHash() || t.toBigInt() !== this.merkleTreeAccessToken.getRootHash()) && await this.resetMerkle();
+  }
+  async getEventsFromHinkal() {
+    await Promise.all([
+      this.accessTokenSnapshotService?.retrieveEventsFromLatestBlock(),
+      this.commitmentsSnapshotService?.retrieveEventsFromLatestBlock(),
+      this.nullifierSnapshotService?.retrieveEventsFromLatestBlock()
+    ]);
+  }
+  getEthereumAddress() {
+    return this.getProviderAdapter().getAddress();
+  }
+  async getRandomRelay() {
+    return (await l.getIdleRelay(this.getCurrentChainId())).relay;
+  }
+  getGasPrice() {
+    if (!this.providerAdapter?.chainId)
+      throw new Error("Illegal State of providerAdapter in Hinkal: no chainId");
+    return this.providerAdapter.getGasPrice();
+  }
+  getAPI() {
+    return l;
+  }
+  async deposit(e, t) {
+    return w(this, e, t);
+  }
+  async depositForOther(e, t, r) {
+    return P(this, e, t, r);
+  }
+  // async transfer(token: ERC20Token, amount: bigint, recipientAddress: string): Promise<ethers.ContractTransaction> {
+  //   return hinkalTransfer(this, token, amount, recipientAddress);
+  // }
+  async withdraw(e, t, r, i, n = !1) {
+    return S(this, e, t, r, i, n);
+  }
+  async swap(e, t, r, i, n = !1, a = !1) {
+    return T(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n,
+      a
+    );
+  }
+  async actionCurve(e, t, r, i, n, a = !1) {
+    return C(this, e, t, r, i, n, a);
+  }
+  async actionConvex(e, t, r, i, n = !1) {
+    return y(this, e, t, r, i, n);
+  }
+  async actionBeefy(e, t, r, i, n, a, m = !1) {
+    return v(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n,
+      a,
+      m
+    );
+  }
+  async actionLido(e, t, r, i, n, a = !1) {
+    return R(this, e, t, r, i, n, a);
+  }
+  async actionPendle(e, t, r, i, n = !1) {
+    return f(this, e, t, r, i, n);
+  }
+  async actionPendleLP(e, t, r, i, n = !1) {
+    return N(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n
+    );
+  }
+  async actionVolatile(e, t, r, i = !1) {
+    return W(this, e, t, r, i);
+  }
+  async actionStake(e, t, r, i) {
+    return x(this, e, t, r, i);
+  }
+  async actionPrivateWallet(e, t, r, i = [], n, a = !1) {
+    return U(this, e, t, r, i, n, a);
+  }
+  async getPendleLPClaimableParams(e, t) {
+    return K(this, e, t);
+  }
+}
+export {
+  Be as Hinkal
+};

package/data-structures/Hinkal/hinkalActionBeefy.js

@@ -0,0 +1,101 @@
+import { utils as p } from "ethers";
+import { networkRegistry as N } from "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import { ExternalActionId as m } from "../../types/external-action.types.js";
+import { BeefyAction as I } from "../../types/hinkal.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import { transactionErrorCodes as M } from "../../error-handling/error-codes.constants.js";
+import "circomlibjs";
+import "../crypto-keys/keys.js";
+import "axios";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import { addPaddingToUtxos as T } from "../../functions/web3/events/getShieldedBalance.js";
+import { outputUtxoProcessing as U } from "../../functions/pre-transaction/outputUtxoProcessing.js";
+import { constructZkProof as k } from "../../functions/snarkjs/constructGeneralZkProof.js";
+import { estimateGasRelayer as F } from "../../functions/web3/functionCalls/estimateGasRelayer.js";
+import { transactCallRelayer as L } from "../../functions/web3/functionCalls/transactCallRelayer.js";
+import "../../functions/utils/external-action.utils.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import { processAmountChanges as O } from "../../functions/pre-transaction/processAmountChanges.js";
+import { getFlatFees as P } from "../../functions/pre-transaction/getFlatFees.js";
+import "../../functions/utils/userAgent.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import "../../webworker/workerFactory.js";
+import "../volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+const $ = (t, r, e, o, c, f) => {
+  let i;
+  return c === m.BeefyStake ? (i = p.defaultAbiCoder.encode(
+    ["uint8", "address", "uint256", "uint256"],
+    [Number(o), f, t[0][0].amount, t[0][0].timeStamp]
+  ), i) : (r.length === 1 ? i = p.defaultAbiCoder.encode(
+    ["uint8", "bytes", "bytes", "address"],
+    [Number(o), r[0], "0x00", e]
+  ) : r.length === 2 ? i = p.defaultAbiCoder.encode(
+    ["uint8", "bytes", "bytes", "address"],
+    [Number(o), r[0], r[1], e]
+  ) : i = p.defaultAbiCoder.encode(
+    ["uint8", "bytes", "bytes", "address"],
+    [Number(o), "0x00", "0x00", e]
+  ), i);
+}, G = (t, r, e) => r === m.BeefyStake ? e === I.GetRewards ? [!1, !0] : [!1, !1, !0] : t.map((o) => o > 0n), Ct = async (t, r, e, o, c, f, i, E = !1) => {
+  const s = [...await T(t, r, e)], w = `swapper${i ? "MO" : "M"}${e.length.toString()}x${s[0].length}x1`, a = i ? m.BeefyStake : m.Beefy, { flatFees: u, feeUnit: b } = await P(
+    t.getCurrentChainId(),
+    r,
+    a,
+    e,
+    o
+  );
+  e = O({
+    erc20Addresses: r,
+    amountChanges: e,
+    flatFees: u,
+    feeUnit: b,
+    externalActionId: a,
+    action: o
+  });
+  const l = G(e, a, o);
+  console.log({ amountChanges: e, onChainCreation: l });
+  const d = [];
+  for (let n = 0; n < r.length; n += 1) {
+    const { outputUtxos: S } = U(t.userKeys, s[n], e[n]);
+    d.push(S);
+  }
+  const { contractData: x } = N[t.getCurrentChainId()], B = a === m.BeefyStake ? x.beefyStakeExternalActionInstanceAddress : x.beefyExternalActionInstanceAddress, R = $(
+    s,
+    c,
+    f,
+    o,
+    a,
+    i
+  ), y = await t.getRandomRelay();
+  if (!y)
+    throw Error(M.RELAYER_NOT_AVAILABLE);
+  const { zkCallData: g, circomData: C, dimData: A } = await k(
+    t.merkleTreeHinkal,
+    t.merkleTreeAccessToken,
+    s,
+    d,
+    t.userKeys,
+    w,
+    a,
+    B,
+    R,
+    y,
+    t.getCurrentChainId(),
+    l,
+    u
+  );
+  return E ? await F(t, g, A, C) : await L(t.getCurrentChainId(), g, A, C);
+};
+export {
+  Ct as hinkalActionBeefy
+};

package/data-structures/Hinkal/hinkalActionConvex.js

@@ -0,0 +1,83 @@
+import { utils as R } from "ethers";
+import { getNonLocalhostChainId as U, networkRegistry as h, chainIds as d } from "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import { ExternalActionId as P } from "../../types/external-action.types.js";
+import { ConvexAction as g } from "../../types/hinkal.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import { transactionErrorCodes as T } from "../../error-handling/error-codes.constants.js";
+import "circomlibjs";
+import "../crypto-keys/keys.js";
+import "axios";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import { addPaddingToUtxos as D } from "../../functions/web3/events/getShieldedBalance.js";
+import { outputUtxoProcessing as M } from "../../functions/pre-transaction/outputUtxoProcessing.js";
+import { constructZkProof as N } from "../../functions/snarkjs/constructGeneralZkProof.js";
+import { estimateGasRelayer as O } from "../../functions/web3/functionCalls/estimateGasRelayer.js";
+import { transactCallRelayer as S } from "../../functions/web3/functionCalls/transactCallRelayer.js";
+import "../../functions/utils/external-action.utils.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import { processAmountChanges as F } from "../../functions/pre-transaction/processAmountChanges.js";
+import { getFlatFees as b } from "../../functions/pre-transaction/getFlatFees.js";
+import "../../functions/utils/userAgent.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import "../../webworker/workerFactory.js";
+import "../volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+const xt = async (t, i, o, C, n, x = !1) => {
+  const r = [...await D(t, i, o)], A = `swapperMO${o.length.toString()}x${r[0].length}x1`, s = U(t.getCurrentChainId());
+  console.log({ inputUtxosArray: r });
+  const a = P.Convex, { flatFees: c, feeUnit: I } = await b(
+    t.getCurrentChainId(),
+    i,
+    a,
+    o,
+    n
+  );
+  o = F({
+    erc20Addresses: i,
+    amountChanges: o,
+    flatFees: c,
+    feeUnit: I,
+    externalActionId: a,
+    action: n
+  }), console.log("new amount changes", { amountChanges: o });
+  const w = [g.StakeLP, g.UnStakeLP].includes(n) ? [!1, !1, ...s === d.ethMainnet ? [!0, !0] : [!0]] : [!1, ...s === d.ethMainnet ? [!0, !0] : [!0]], m = [];
+  for (let e = 0; e < i.length; e += 1) {
+    const { outputUtxos: L } = M(t.userKeys, r[e], o[e]);
+    m.push(L);
+  }
+  console.log({ outputUtxosArray: m });
+  const y = h[t.getCurrentChainId()].contractData.convexExternalActionInstanceAddress, E = R.defaultAbiCoder.encode(
+    ["uint8", "uint256", "uint256", "uint256"],
+    [Number(n), C, r[0][0].amount, r[0][0].timeStamp]
+  ), p = await t.getRandomRelay();
+  if (!p)
+    throw Error(T.RELAYER_NOT_AVAILABLE);
+  const { zkCallData: u, circomData: l, dimData: f } = await N(
+    t.merkleTreeHinkal,
+    t.merkleTreeAccessToken,
+    r,
+    m,
+    t.userKeys,
+    A,
+    a,
+    y,
+    E,
+    p,
+    t.getCurrentChainId(),
+    w,
+    c
+  );
+  return x ? await O(t, u, f, l) : await S(t.getCurrentChainId(), u, f, l);
+};
+export {
+  xt as hinkalActionConvex
+};