@hinkal/common 0.2.13 → 0.2.14

package/data-structures/Hinkal/Hinkal.mjs

@@ -1,52 +1,73 @@
-import { EventType as o } from "../../types/hinkal.types.mjs";
-import { ContractType as c } from "../../types/ethereum-network.types.mjs";
-import { checkHinkalAccessToken as g, mintAccessToken as u, mintTokenCrossChain as v } from "../../functions/web3/functionCalls/accessTokenCalls.mjs";
-import { getShieldedBalance as k } from "../../functions/web3/events/getShieldedBalance.mjs";
-import { UserKeys as s } from "../crypto-keys/keys.mjs";
-import { hinkalActionBeefy as A } from "./hinkalActionBeefy.mjs";
-import { hinkalActionConvex as y } from "./hinkalActionConvex.mjs";
-import { hinkalActionCurve as C } from "./hinkalActionCurve.mjs";
-import { hinkalActionPendle as f } from "./hinkalActionPendle.mjs";
-import { hinkalDeposit as w, hinkalDepositForOther as P } from "./hinkalDeposit.mjs";
-import { hinkalSwap as T } from "./hinkalSwap.mjs";
-import { hinkalWithdraw as S } from "./hinkalWithdraw.mjs";
-import { resetMerkleTrees as E } from "./resetMerkleTrees.mjs";
-import { MerkleTree as h } from "../merkle-tree/MerkleTree.mjs";
-import { poseidonFunction as d } from "../../crypto/poseidon.mjs";
+import { EventType as k } from "../../types/hinkal.types.mjs";
+import { ContractType as l } from "../../types/ethereum-network.types.mjs";
+import { checkHinkalAccessToken as T, mintAccessToken as S, mintTokenCrossChain as E } from "../../functions/web3/functionCalls/accessTokenCalls.mjs";
+import { getShieldedBalance as F } from "../../functions/web3/events/getShieldedBalance.mjs";
+import { UserKeys as d } from "../crypto-keys/keys.mjs";
+import { hinkalActionBeefy as I } from "./hinkalActionBeefy.mjs";
+import { hinkalActionConvex as R } from "./hinkalActionConvex.mjs";
+import { hinkalActionCurve as H } from "./hinkalActionCurve.mjs";
+import { hinkalActionPendle as M } from "./hinkalActionPendle.mjs";
+import { hinkalDeposit as B, hinkalDepositForOther as b } from "./hinkalDeposit.mjs";
+import { hinkalSwap as x } from "./hinkalSwap.mjs";
+import { hinkalWithdraw as U } from "./hinkalWithdraw.mjs";
+import { resetMerkleTrees as W } from "./resetMerkleTrees.mjs";
+import { MerkleTree as f } from "../merkle-tree/MerkleTree.mjs";
+import "ethers";
+import { transactionErrorCodes as A } from "../../error-handling/error-codes.constants.mjs";
+import { poseidonFunction as y } from "../../crypto/poseidon.mjs";
 import "circomlibjs-hinkal-fork";
 import "libsodium-wrappers";
 import "process";
 import "buffer";
-import { networkRegistry as H } from "../../constants/chains.constants.mjs";
-import { transactionErrorCodes as p } from "../../error-handling/error-codes.constants.mjs";
-import { monitor as F } from "../../API/callMonitor.mjs";
-import { hinkalActionLido as I } from "./hinkalActionLidoEth.mjs";
-import "../../constants/vite.constants.mjs";
+import { networkRegistry as K } from "../../constants/chains.constants.mjs";
+import { monitor as L } from "../../API/callMonitor.mjs";
+import { hinkalActionLido as D } from "./hinkalActionLidoEth.mjs";
+import { isExtension as N } from "../../constants/vite.constants.mjs";
 import "axios";
 import "../../constants/coingecko.constants.mjs";
-import { getAxelarGasEstimate as R } from "../../API/getAxelarGasEstimate.mjs";
-import { API as l } from "../../API/API.mjs";
-import "ethers";
+import { getAxelarGasEstimate as O } from "../../API/getAxelarGasEstimate.mjs";
+import { API as C } from "../../API/API.mjs";
 import "../../types/curve.types.mjs";
+import "../../constants/token-data/index.mjs";
 import "../../constants/contracts.constants.mjs";
-import { supportedPassportLinks as L } from "../../constants/kyc.constants.mjs";
+import { supportedPassportLinks as G } from "../../constants/kyc.constants.mjs";
 import "../../constants/axelar.constants.mjs";
 import "../../constants/rewards.constants.mjs";
 import "../../constants/reorg-depths.constants.mjs";
-import { TransactionsManager as M } from "../transactions-manager/TransactionsManager.mjs";
+import "../../constants/addresses.constants.mjs";
+import "../../constants/token.limits.constants.mjs";
+import { TransactionsManager as _ } from "../transactions-manager/TransactionsManager.mjs";
 import "../../functions/utils/external-action.utils.mjs";
 import "../../types/circom-data.types.mjs";
 import "../../types/transactions.types.mjs";
-import { reloadPage as W } from "../../functions/utils/reloadPage.mjs";
-import { hinkalActionVolatile as N } from "./hinkalActionVolatile.mjs";
-import { hinkalActionPendleLP as K, hinkalGetPendleLPClaimableParams as x } from "./hinkalActionPendleLP.mjs";
-import { getConnextReceiveFee as O } from "../../API/getConnextReceiveFee.mjs";
-import { hinkalActionStake as B } from "./hinkalActionStake.mjs";
-import { MultiThreadedUtxoUtils as D } from "../MultiThreadedUtxoUtils/MultiThreadedUtxoUtils.mjs";
-import { hinkalPrivateWallet as U } from "./hinkalPrivateWallet.mjs";
-import { resetCache as b } from "../../functions/utils/cacheFunctions.mjs";
-import { createCacheDevice as G } from "../../functions/utils/cacheDevice.utils.mjs";
-class Be {
+import "../../types/activities.types.mjs";
+import { reloadPage as j } from "../../functions/utils/reloadPage.mjs";
+import { hinkalActionVolatile as V } from "./hinkalActionVolatile.mjs";
+import { hinkalActionPendleLP as z, hinkalGetPendleLPClaimableParams as q } from "./hinkalActionPendleLP.mjs";
+import { getConnextReceiveFee as J } from "../../API/getConnextReceiveFee.mjs";
+import { hinkalActionStake as Q } from "./hinkalActionStake.mjs";
+import { MultiThreadedUtxoUtils as X } from "../MultiThreadedUtxoUtils/MultiThreadedUtxoUtils.mjs";
+import { hinkalPrivateWallet as Y } from "./hinkalPrivateWallet.mjs";
+import { resetCache as Z } from "../../functions/utils/cacheFunctions.mjs";
+import { createCacheDevice as $ } from "../../functions/utils/cacheDevice.utils.mjs";
+import { getContractWithFetcherByChainId as ee } from "../../functions/web3/getContractMetadata.mjs";
+import { getRecipientInfo as te } from "./hinkalGetRecipientInfo.mjs";
+import { hinkalApprove as re } from "./hinkalApprove.mjs";
+import { hinkalInsideTransact as ie } from "./hinkalInsideTransact.mjs";
+import { getApprovedBalance as ne, getApprovedUtxos as ae, getApprovedUtxosForToken as se, getMyApprovalAmountForInteraction as oe } from "../../functions/web3/events/getApprovedBalance.mjs";
+import { getInteractionApprovals as ce, checkExistingApprovalFromHinkal as he, getBufferEntry as pe } from "../../functions/web3/functionCalls/inHinkalApprovalCalls.mjs";
+import { hinkalSignSubAccount as le } from "./hinkalSignSubAccount.mjs";
+import { hinkalDeploySubAccount as de } from "./hinkalDeploySubAccount.mjs";
+import { hinkalCheckTokenRegistry as me } from "./hinkalCheckTokenRegistry.mjs";
+import { hinkalActionReceive as ge } from "./hinkalActionReceive.mjs";
+import { hinkalActionFundApproveAndTransact as ue } from "./hinkalActionFundApproveAndTransact.mjs";
+import { privateTokensDB as ve } from "../TokenDBs/PrivateTokensDB.mjs";
+import "idb-keyval";
+import { hinkalProoflessDeposit as ke } from "./hinkalProoflessDeposit.mjs";
+import { hinkalProxySwap as fe } from "./hinkalProxySwap.mjs";
+import { hinkalMultiSendPrivateRecipients as Ae } from "./hinkalMultiSend.mjs";
+import { getErc20TokensForChain as ye } from "../../functions/utils/erc20tokenFunctions.mjs";
+class Kt {
   providerAdapter;
   userKeys;
   signingMessage = "Login to Hinkal Protocol";
@@ -54,14 +75,18 @@ class Be {
   merkleTreeAccessToken;
   nullifiers;
   encryptedOutputs;
+  approvals;
   commitmentsSnapshotService;
   nullifierSnapshotService;
   accessTokenSnapshotService;
+  approvalsSnapshotService;
   transactionsManager;
   utxoUtils;
   cacheDevice;
+  generateProofRemotely;
+  disableMerkleTreeUpdates;
   constructor(e) {
-    this.userKeys = new s(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(), this.utxoUtils = new D(), this.cacheDevice = G(e);
+    this.userKeys = new d(void 0), this.merkleTreeHinkal = f.create(y, 25n, 0n), this.merkleTreeAccessToken = f.create(y, 25n, 0n), this.nullifiers = /* @__PURE__ */ new Set(), this.encryptedOutputs = [], this.approvals = /* @__PURE__ */ new Map(), this.transactionsManager = new _(), this.generateProofRemotely = e?.generateProofRemotely ?? !1, this.utxoUtils = new X(), this.cacheDevice = $(e), this.disableMerkleTreeUpdates = e?.disableMerkleTreeUpdates ?? !1;
   }
   async initProviderAdapter(e, t) {
     await this.updateProviderAdapter(t), this.providerAdapter?.initConnector(e);
@@ -69,13 +94,13 @@ class Be {
     await t.init(r), await this.setListeners();
   }
   async initUserKeys() {
-    this.userKeys = new s(await this.getProviderAdapter().signMessage(this.signingMessage));
+    this.userKeys = new d(await this.getProviderAdapter().signMessage(this.signingMessage));
   }
   async initUserKeysWithPassword(e) {
-    this.userKeys = new s(e);
+    this.userKeys = new d(e);
   }
   async resetMerkle() {
-    this.isSelectedNetworkSupported() && await E(this);
+    this.disableMerkleTreeUpdates || this.isSelectedNetworkSupported() && await W(this);
   }
   getProviderAdapter() {
     if (!this.providerAdapter)
@@ -91,12 +116,21 @@ class Be {
   getContract(e, t = void 0, r) {
     return this.getProviderAdapter().getContract(e, t, r);
   }
+  getContractWithFetcherByChainId(e, t, r = void 0) {
+    return ee(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);
   }
+  async deploySubAccount(e, t) {
+    return de(this, e, t);
+  }
+  async signWithSubAccount(e, t, r, i) {
+    return le(this, e, t, r, i);
+  }
   getContractWithSigner(e, t = "") {
     return this.getProviderAdapter().getContractWithSigner(e, t);
   }
@@ -107,15 +141,18 @@ class Be {
     return this.getProviderAdapter().getContractWithFetcherForEthereum(e, t);
   }
   isSelectedNetworkSupported() {
-    return !!H[this.getCurrentChainId()];
+    return !!K[this.getCurrentChainId()];
   }
   async switchNetwork(e) {
     try {
       await this.getProviderAdapter().switchNetwork(e);
     } catch {
-      throw new Error(p.FAILED_TO_SWITCH_NETWORKS);
+      throw new Error(A.FAILED_TO_SWITCH_NETWORKS);
     }
   }
+  async switchAccount(e) {
+    await this.getProviderAdapter().switchAccount(e);
+  }
   getCurrentChainId() {
     const { chainId: e } = this.getProviderAdapter();
     if (!e)
@@ -153,31 +190,62 @@ class Be {
   }
   async onAccountChanged() {
     await this.getProviderAdapter().onAccountChanged();
-    const e = o.AccountChanged;
+    const e = k.AccountChanged;
     typeof document < "u" ? document?.dispatchEvent(new Event(e)) : process?.emit("message", e, void 0);
   }
   async onChainChanged(e) {
     if (e) {
       await this.getProviderAdapter().onChainChanged(e);
-      const t = o.NetworkChange;
+      const t = k.NetworkChange;
       typeof document < "u" ? document.dispatchEvent(new Event(t)) : process?.emit("message", t, void 0);
     } else
-      await this.disconnectFromConnector(), W();
+      await this.disconnectFromConnector(), j();
   }
   async monitorConnectedAddress() {
-    F(await this.getEthereumAddress(), this.getCurrentChainId());
+    L(await this.getEthereumAddress(), this.getCurrentChainId());
+  }
+  async getBalances(e, t, r, i, n = !1, a) {
+    return F(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n,
+      this.generateProofRemotely,
+      a
+    );
   }
-  async getBalances() {
-    return k(this);
+  async getApprovedBalances(e = !1, t = !1) {
+    return ne(this, e, t);
+  }
+  async getTotalBalance(e, t, r, i = !1, n) {
+    const a = e ?? this.getCurrentChainId(), s = r ?? await this.getEthereumAddress(), o = t ?? this.userKeys, c = await this.getBalances(
+      a,
+      o.getShieldedPrivateKey(),
+      o.getShieldedPublicKey(),
+      s,
+      i,
+      n
+    ), h = await this.getApprovedBalances(i, n), w = N ? await ve.getPrivateTokens(a, s) : ye(a), m = [];
+    return w.forEach((g) => {
+      const u = g.erc20TokenAddress.toLowerCase(), p = c.get(u), v = h.get(u), P = {
+        token: g,
+        balance: (p?.balance ?? 0n) + (v?.balance ?? 0n),
+        timestamp: p?.timestamp || v?.timestamp || "0",
+        nfts: p?.nfts || []
+      };
+      m.push(P);
+    }), m;
   }
   getSupportedPassportLinks() {
-    return L;
+    return G;
   }
   checkAccessToken() {
-    return g(this);
+    return T(this);
   }
   async getAxelarEstimate(e, t, r, i) {
-    return R(
+    return O(
       e,
       t,
       r,
@@ -186,41 +254,42 @@ class Be {
     );
   }
   async getConnextReceiveFee(e, t) {
-    return O(this.getCurrentChainId(), e, t);
+    return J(this.getCurrentChainId(), e, t);
   }
-  async mintHinkalAccessToken(e) {
-    return u(this, e);
+  async mintHinkalAccessToken(e, t) {
+    return S(this, e, t);
   }
-  async mintHinkalAccessTokenCrossChain(e, t) {
-    return v(this, e, t);
+  async mintHinkalAccessTokenCrossChain(e, t, r) {
+    return E(this, e, t, r);
   }
   async getHinkalTreeRootHash() {
-    return this.getContractWithFetcher(c.HinkalContract).getRootHash();
+    return this.getContractWithFetcher(l.HinkalContract).getRootHash();
   }
   async getAccessTokenTreeRootHash() {
-    return this.getContractWithFetcher(c.CrossChainAccessTokenContract).getRootHash();
+    return this.getContractWithFetcher(l.AccessTokenContract).getRootHash();
   }
   async resetMerkleTreesIfNecessary() {
     if (!this.isSelectedNetworkSupported())
-      throw new Error(p.UNSUPPORTED_NETWORK);
+      throw new Error(A.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();
+    (e.toBigInt() !== this.merkleTreeHinkal.getRootHash() || t.toBigInt() !== this.merkleTreeAccessToken.getRootHash()) && (console.log("resetting merkle tree in resetMerkleTreesIfNecessary"), await this.resetMerkle());
   }
   async getEventsFromHinkal() {
     await Promise.all([
       this.accessTokenSnapshotService?.retrieveEventsFromLatestBlock(),
       this.commitmentsSnapshotService?.retrieveEventsFromLatestBlock(),
-      this.nullifierSnapshotService?.retrieveEventsFromLatestBlock()
+      this.nullifierSnapshotService?.retrieveEventsFromLatestBlock(),
+      this.approvalsSnapshotService?.retrieveEventsFromLatestBlock()
     ]);
   }
   getEthereumAddress() {
     return this.getProviderAdapter().getAddress();
   }
   async getRandomRelay() {
-    return (await l.getIdleRelay(this.getCurrentChainId())).relay;
+    return (await C.getIdleRelay(this.getCurrentChainId())).relay;
   }
   getGasPrice() {
     if (!this.providerAdapter?.chainId)
@@ -228,45 +297,84 @@ class Be {
     return this.providerAdapter.getGasPrice();
   }
   getAPI() {
-    return l;
+    return C;
   }
   resetCache() {
-    b(this);
+    Z(this, this.getCurrentChainId(), this.userKeys.getShieldedPublicKey());
   }
   snapshotsClearInterval() {
-    this.commitmentsSnapshotService?.intervalClear(), this.accessTokenSnapshotService?.intervalClear(), this.nullifierSnapshotService?.intervalClear();
+    this.commitmentsSnapshotService?.intervalClear(), this.accessTokenSnapshotService?.intervalClear(), this.nullifierSnapshotService?.intervalClear(), this.approvalsSnapshotService?.intervalClear();
+  }
+  checkTokenRegistry(e, t) {
+    const r = this.getContractWithFetcher(l.HinkalHelperContract);
+    return me(r, e, t);
+  }
+  getRecipientInfo(e = !1) {
+    return te(this, e);
+  }
+  async getInteractionApprovals(e) {
+    return await ce(this, e);
+  }
+  getApprovedUtxos(e = !1) {
+    return ae(this, e);
+  }
+  getApprovedUtxosForToken(e, t = !1) {
+    return se(this, e, t);
+  }
+  getMyApprovalAmountForInteraction(e, t) {
+    return oe(this, e, t);
+  }
+  async checkExistingApprovalFromHinkal(e, t) {
+    return await he(this, e, t);
+  }
+  async getBufferEntry(e, t, r) {
+    return pe(this, e, t, r);
   }
   async deposit(e, t) {
-    return w(this, e, t);
+    return B(this, e, t);
   }
   async depositForOther(e, t, r) {
-    return P(this, e, t, r);
+    return b(this, e, t, r);
+  }
+  async prooflessDeposit(e, t, r) {
+    return ke(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 withdraw(e, t, r, i, n, a, s = !1) {
+    return U(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n,
+      a,
+      s
+    );
   }
-  async swap(e, t, r, i, n = !1, a = !1) {
-    return T(
+  async swap(e, t, r, i, n, a, s = !1, o = !1) {
+    return x(
       this,
       e,
       t,
       r,
       i,
       n,
-      a
+      a,
+      s,
+      o
     );
   }
   async actionCurve(e, t, r, i, n, a = !1) {
-    return C(this, e, t, r, i, n, a);
+    return H(this, e, t, r, i, n, a);
   }
   async actionConvex(e, t, r, i, n = !1) {
-    return y(this, e, t, r, i, n);
+    return R(this, e, t, r, i, n);
   }
-  async actionBeefy(e, t, r, i, n, a, m = !1) {
-    return A(
+  async actionBeefy(e, t, r, i, n, a, s = !1) {
+    return I(
       this,
       e,
       t,
@@ -274,17 +382,17 @@ class Be {
       i,
       n,
       a,
-      m
+      s
     );
   }
   async actionLido(e, t, r, i, n, a = !1) {
-    return I(this, e, t, r, i, n, a);
+    return D(this, e, t, r, i, n, a);
   }
   async actionPendle(e, t, r, i, n = !1) {
-    return f(this, e, t, r, i, n);
+    return M(this, e, t, r, i, n);
   }
   async actionPendleLP(e, t, r, i, n = !1) {
-    return K(
+    return z(
       this,
       e,
       t,
@@ -294,18 +402,88 @@ class Be {
     );
   }
   async actionVolatile(e, t, r, i = !1) {
-    return N(this, e, t, r, i);
+    return V(this, e, t, r, i);
   }
   async actionStake(e, t, r, i) {
-    return B(this, e, t, r, i);
+    return Q(this, e, t, r, i);
   }
-  async actionPrivateWallet(e, t, r, i = [], n, a = !1) {
-    return U(this, e, t, r, i, n, a);
+  async actionReceive(e, t, r, i, n, a = !1) {
+    return ge(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n,
+      a
+    );
+  }
+  async actionFundApproveAndTransact(e, t, r, i, n, a, s, o, c, h) {
+    return ue(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n,
+      a,
+      s,
+      o,
+      c,
+      h
+    );
+  }
+  async actionPrivateWallet(e, t, r, i = [], n, a, s, o = !1) {
+    return Y(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n,
+      a,
+      s,
+      o
+    );
   }
   async getPendleLPClaimableParams(e, t) {
-    return x(this, e, t);
+    return q(this, e, t);
+  }
+  async approve(e, t, r, i, n = !1) {
+    return re(this, e, t, r, i, n);
+  }
+  async hinkalInsideTransact(e, t, r, i, n, a, s = !1) {
+    return ie(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n,
+      a,
+      s
+    );
+  }
+  async proxySwap(e, t, r, i, n, a, s, o = !1) {
+    return fe(
+      this,
+      e,
+      t,
+      r,
+      i,
+      n,
+      a,
+      s,
+      o
+    );
+  }
+  async multiSendPrivateRecipients(e, t, r) {
+    return Ae(this, e, t, r);
+  }
+  areMerkleTreeUpdatesDisabled() {
+    return this.disableMerkleTreeUpdates;
   }
 }
 export {
-  Be as Hinkal
+  Kt as Hinkal
 };

package/data-structures/Hinkal/IHinkal.d.ts

@@ -1,5 +1,5 @@
 import { AxelarMigrationInfo } from '../../types/axelar.types';
-import { BeefyAction, ConvexAction, CurveAction, LidoAction, LidoVariant, VolatileHelperData } from '../../types/hinkal.types';
+import { ApprovedUtxo, ApprovedUtxoWithInteractionAddress, BeefyAction, ConvexAction, CurveAction, FeeStructure, LidoAction, LidoVariant, VolatileHelperData } from '../../types/hinkal.types';
 import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
 import { EncryptedOutputWithSign } from '../../types/commitments.types';
 import { ExternalActionId } from '../../types/external-action.types';
@@ -8,18 +8,20 @@ import { type IMultiThreadedUtxoUtils } from '../../types/IMultiThreadedUtxoUtil
 import { PendleLPMetadata, PendleMetadata } from '../../types/pendle.types';
 import { RelayerTransaction } from '../../types/relayer.types';
 import { SignatureData } from '../../types/crypto.types';
-import { TokenBalance } from '../../types/token.types';
+import { ERC20Token, TokenBalance } from '../../types/token.types';
 import { Bytes, ContractTransaction, ethers } from 'ethers';
 import { type UserKeys } from '../crypto-keys/keys';
 import { IProviderAdapter } from '../provider-adapter/IProviderAdapter';
 import { ClientAccessTokenSnapshotService } from '../snapshot/ClientAccessTokenSnapshotService';
 import { ClientCommitmentsSnapshotService } from '../snapshot/ClientCommitmentsSnapshotService';
 import { ClientNullifierSnapshotService } from '../snapshot/ClientNullifierSnapshotService';
+import { ClientApprovalsSnapshotService } from '../snapshot/ClientApprovalsSnapshotService';
 import { MerkleTree } from '../merkle-tree';
 import { TransactionsManager } from '../transactions-manager/TransactionsManager';
 import { IAPI } from '../../API/API';
 import { AxelarGasResponse } from '../../API/getAxelarGasEstimate';
 import { type ICacheDevice } from '../../types/ICacheDevice';
+import { StealthAddressStructure } from '../../types/circom-data.types';
 export interface IHinkal<ConnectorType = unknown> {
     userKeys: UserKeys;
     readonly signingMessage: string;
@@ -27,13 +29,18 @@ export interface IHinkal<ConnectorType = unknown> {
     merkleTreeAccessToken: MerkleTree<bigint>;
     nullifiers: Set<string>;
     encryptedOutputs: EncryptedOutputWithSign[];
+    approvals: Map<string, ApprovedUtxo[]>;
     commitmentsSnapshotService?: ClientCommitmentsSnapshotService;
     nullifierSnapshotService?: ClientNullifierSnapshotService;
     accessTokenSnapshotService?: ClientAccessTokenSnapshotService;
+    approvalsSnapshotService?: ClientApprovalsSnapshotService;
     transactionsManager: TransactionsManager;
+    generateProofRemotely: boolean;
     utxoUtils: IMultiThreadedUtxoUtils;
     cacheDevice: ICacheDevice;
-    getBalances(): Promise<TokenBalance[]>;
+    getBalances(chainId: number, passedShieldedPrivateKey: string, passedShieldedPublicKey: string, ethAddress: string, resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<Map<string, TokenBalance>>;
+    getApprovedBalances(resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<Map<string, TokenBalance>>;
+    getTotalBalance(chainId?: number, userKeys?: UserKeys, ethAddress?: string, resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<TokenBalance[]>;
     getSupportedPassportLinks(): string[];
     checkAccessToken(): Promise<boolean>;
     getAxelarEstimate(chainId: number, sourceChainName: string, destChainName: string, sourceChainToken: string): Promise<AxelarGasResponse>;
@@ -41,17 +48,26 @@ export interface IHinkal<ConnectorType = unknown> {
     resetMerkleTreesIfNecessary(): Promise<void>;
     resetMerkle(): Promise<void>;
     getEventsFromHinkal(): Promise<void>;
-    mintHinkalAccessToken(signatureData: SignatureData): Promise<ethers.ContractTransaction>;
-    mintHinkalAccessTokenCrossChain(signatureData: SignatureData, axelarMigrationInfos: AxelarMigrationInfo[]): Promise<ethers.ContractTransaction>;
+    mintHinkalAccessToken(signatureData: SignatureData, fromWallet?: boolean): Promise<ethers.ContractTransaction>;
+    mintHinkalAccessTokenCrossChain(signatureData: SignatureData, axelarMigrationInfos: AxelarMigrationInfo[], fromWallet?: boolean): Promise<ethers.ContractTransaction>;
     getRandomRelay(): Promise<string | undefined>;
     getGasPrice(): Promise<bigint>;
     getAPI(): IAPI;
     resetCache(): void;
     snapshotsClearInterval(): void;
-    deposit(erc20Addresses: string[], amountChanges: bigint[]): Promise<ethers.ContractTransaction>;
-    depositForOther(erc20Addresses: string[], amountChanges: bigint[], recepinetInfo: string): Promise<ethers.ContractTransaction>;
-    withdraw(erc20Addresses: string[], amountChanges: bigint[], recipientAddress: string, isRelayerOff: boolean, onlyGasEstimate?: boolean): Promise<ethers.ContractTransaction | RelayerTransaction | bigint>;
-    swap(erc20Addresses: string[], amountChanges: bigint[], externalActionId: ExternalActionId, swapData: string, onlyGasEstimate?: boolean, withPrivateMempool?: boolean): Promise<RelayerTransaction | bigint>;
+    checkTokenRegistry(erc20Addresses: string[], amountChanges: bigint[]): Promise<boolean>;
+    getRecipientInfo(extendedInfo?: boolean): string;
+    getInteractionApprovals(interactionAddress: string): Promise<ApprovedUtxo[]>;
+    getApprovedUtxos(resetCacheBefore?: boolean): ApprovedUtxoWithInteractionAddress[];
+    getApprovedUtxosForToken(erc20Address: string, resetCacheBefore?: boolean): ApprovedUtxoWithInteractionAddress[];
+    getMyApprovalAmountForInteraction(interactionAddress: string, tokenAddress: string): bigint;
+    checkExistingApprovalFromHinkal(erc20Address: string, interactionAddress: string): Promise<bigint>;
+    getBufferEntry(approveTo: string, tokenAddress: string, inHinkalAddress: bigint): Promise<bigint>;
+    deposit(erc20Tokens: ERC20Token[], amountChanges: bigint[]): Promise<ethers.ContractTransaction>;
+    depositForOther(erc20Tokens: ERC20Token[], amountChanges: bigint[], recepinetInfo: string): Promise<ethers.ContractTransaction>;
+    prooflessDeposit(erc20Tokens: ERC20Token[], amountChanges: bigint[], stealthAddressStructures?: StealthAddressStructure[]): Promise<ethers.ContractTransaction>;
+    withdraw(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], recipientAddress: string, isRelayerOff: boolean, feeToken?: string, feeStructureOverride?: FeeStructure, onlyGasEstimate?: boolean): Promise<ethers.ContractTransaction | RelayerTransaction | bigint>;
+    swap(erc20Addresses: string[], deltaAmounts: bigint[], externalActionId: ExternalActionId, swapData: string, feeToken?: string, feeStructureOverride?: FeeStructure, onlyGasEstimate?: boolean, withPrivateMempool?: boolean): Promise<RelayerTransaction | bigint>;
     actionCurve(tokens: string[], tokenAmounts: bigint[], poolAddress: string, curveAction: CurveAction, newVersion: boolean, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
     actionConvex(tokens: string[], tokenAmounts: bigint[], poolId: number, convexAction: ConvexAction, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
     actionBeefy(tokens: string[], tokenAmounts: bigint[], beefyAction: BeefyAction, oneInchData: string[], zapAddress: string, boostAddress: string | undefined, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
@@ -69,22 +85,33 @@ export interface IHinkal<ConnectorType = unknown> {
     getContract(contract: ContractType, contractAddress?: string, chainId?: number): ethers.Contract;
     getContractWithSigner(contract: ContractType, contractAddress?: string): ethers.Contract;
     getContractWithFetcher(contract: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcherByChainId(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
     getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: string): ethers.Contract;
     isSelectedNetworkSupported(): boolean;
     switchNetwork(network: EthereumNetwork): Promise<unknown>;
+    switchAccount(signer: ethers.Signer): Promise<unknown>;
     getCurrentChainId(): number;
     monitorConnectedAddress(): Promise<void>;
     getSelectedNetwork(): EthereumNetwork | undefined;
     isPermitterAvailable(): boolean;
     signMessage(message: Bytes | string): Promise<string>;
     signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    deploySubAccount(walletNonce: bigint, feeToken?: string): Promise<RelayerTransaction>;
+    signWithSubAccount(dataHash: string, walletNonce: bigint, shouldBeProxyDeployed?: boolean, feeToken?: string): Promise<string>;
     actionLido(lidoVariant: LidoVariant, lidoAction: LidoAction, tokens: string[], tokenAmounts: bigint[], tokenIds: number[], onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
     actionPendle(erc20Addresses: string[], amountChanges: bigint[], pendleMetadata: PendleMetadata, gasTokenAddress?: string, onlyGasEstimate?: boolean): Promise<RelayerTransaction | ContractTransaction | bigint>;
     actionPendleLP(erc20Addresses: string[], amountChanges: bigint[], pendleLPMetadata: PendleLPMetadata, gasTokenAddress?: string, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
     actionVolatile(erc20Addresses: string[], amountChanges: bigint[], volatileHelperData: VolatileHelperData, onlyGasEstimate?: boolean): Promise<RelayerTransaction | ContractTransaction | bigint>;
-    actionPrivateWallet(erc20Addresses: string[], amountChanges: bigint[], onChainCreation: boolean[], ops: string[], walletNonce?: bigint, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionFundApproveAndTransact(erc20Addresses: string[], fundAmounts: bigint[], approveTokenAddresses: string[], approveAmounts: bigint[], walletNonce: bigint, to: string, callDataString: string, value: bigint, feeToken?: string, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionPrivateWallet(erc20Addresses: string[], deltaAmounts: bigint[], onChainCreation: boolean[], ops: string[], walletNonce?: bigint, feeToken?: string, feeStructureOverride?: FeeStructure, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionReceive(erc20Addresses: string[], deltaAmounts: bigint[], feeTokens?: string, feeStructureOverride?: FeeStructure, walletNonce?: bigint, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
     getPendleLPClaimableParams(wlpTokenAddress: string, wlpTokenBalance: bigint): Promise<{
         amount: bigint;
         timestamp: string;
     }>;
+    approve(erc20Addresses: string[], amount: bigint, approvedTo: string, feeToken?: string, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    hinkalInsideTransact(erc20Addresses: string[], deltaChanges: bigint[], approvalChanges: bigint[], externalAddress: string, externalActionMetadata: string, feeToken?: string, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    proxySwap(erc20Addresses: string[], deltaAmounts: bigint[], externalActionId: ExternalActionId, swapData: string, walletNonce: bigint, feeToken?: string, feeStructureOverride?: FeeStructure, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    multiSendPrivateRecipients(erc20Tokens: ERC20Token[], amounts: bigint[], extendedRecipientInfos?: string[]): Promise<ethers.ContractTransaction>;
+    areMerkleTreeUpdatesDisabled(): boolean;
 }