@sabaaa1/common 0.0.7 → 0.0.8

package/src/data-structures/Hinkal/Hinkal.ts

@@ -1,746 +0,0 @@
-import { BigNumber, ethers } from 'ethers';
-import {
-  type ApprovedUtxo,
-  ApprovedUtxoWithInteractionAddress,
-  EventType,
-  FeeStructure,
-  HinkalConfig,
-  type ParsedInLogicMetadata,
-} from '../../types/hinkal.types';
-import { type ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
-import type { EncryptedOutputWithSign } from '../../types/commitments.types';
-import { ExternalActionId } from '../../types/external-action.types';
-import { type IMultiThreadedUtxoUtils } from '../../types/IMultiThreadedUtxoUtils';
-import { type RelayerTransaction } from '../../types/relayer.types';
-import { type SignatureData } from '../../types/crypto.types';
-import type { ERC20Token, TokenBalance, TokenChanges } from '../../types/token.types';
-
-import { checkHinkalAccessToken, mintAccessToken } from '../../functions/web3/functionCalls/accessTokenCalls';
-import { getShieldedBalance } from '../../functions/web3/events/getShieldedBalance';
-import { UserKeys } from '../crypto-keys/keys';
-import { type ClientAccessTokenSnapshotService } from '../snapshot/ClientAccessTokenSnapshotService';
-import { type ClientCommitmentsSnapshotService } from '../snapshot/ClientCommitmentsSnapshotService';
-import { type ClientNullifierSnapshotService } from '../snapshot/ClientNullifierSnapshotService';
-import { type ClientApprovalsSnapshotService } from '../snapshot/ClientApprovalsSnapshotService';
-import { type IProviderAdapter } from '../provider-adapter/IProviderAdapter';
-import { hinkalDeposit, hinkalDepositForOther } from './hinkalDeposit';
-import { hinkalSwap } from './hinkalSwap';
-import { hinkalWithdraw } from './hinkalWithdraw';
-import { type IHinkal } from './IHinkal';
-import { resetMerkleTrees } from './resetMerkleTrees';
-import { MerkleTree } from '../merkle-tree';
-import { poseidonFunction } from '../../crypto';
-
-import { networkRegistry } from '../../constants/chains.constants';
-import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
-import { API, IAPI } from '../../API';
-import { reloadPage } from '../../functions/utils/reloadPage';
-import { MultiThreadedUtxoUtils } from '../MultiThreadedUtxoUtils/MultiThreadedUtxoUtils';
-import { hinkalPrivateWallet } from './hinkalPrivateWallet';
-
-// TODO: review and fix circular in kyc constants
-import { supportedPassportLinks } from '../../constants/kyc.constants';
-import { resetCache } from '../../functions/utils/cacheFunctions';
-import { type ICacheDevice } from '../../types/ICacheDevice';
-import { createCacheDevice } from '../../functions/utils/cacheDevice.utils';
-import { getContractWithFetcherByChainId } from '../../functions/web3/getContractMetadata';
-import { getRecipientInfo } from './hinkalGetRecipientInfo';
-import { hinkalApprove } from './hinkalApprove';
-import { hinkalInsideTransact } from './hinkalInsideTransact';
-import {
-  getApprovedBalance,
-  getApprovedUtxos,
-  getApprovedUtxosForToken,
-  getMyApprovalAmountForInteraction,
-} from '../../functions/web3/events/getApprovedBalance';
-import {
-  checkExistingApprovalFromHinkal,
-  getBufferEntry,
-  getInteractionApprovals,
-} from '../../functions/web3/functionCalls/inHinkalApprovalCalls';
-import { hinkalSignSubAccount } from './hinkalSignSubAccount';
-import { hinkalCheckTokenRegistry } from './hinkalCheckTokenRegistry';
-import { hinkalActionReceive } from './hinkalActionReceive';
-import { hinkalActionFundApproveAndTransact } from './hinkalActionFundApproveAndTransact';
-import { privateTokensDB } from '../TokenDBs';
-import { hinkalProoflessDeposit } from './hinkalProoflessDeposit';
-import type { StealthAddressStructure, TypedData } from '../../types/circom-data.types';
-import { hinkalProxySwap } from './hinkalProxySwap';
-import { hinkalMultiSendPrivateRecipients } from './hinkalMultiSend';
-import { isExtension } from '../../constants/vite.constants';
-import { getErc20TokensForChain } from '../../functions/utils/erc20tokenFunctions';
-import { hinkalTransfer } from './hinkalTransfer';
-import { SubAccount } from '../../types/proxy.types';
-import { AdminTransactionType } from '../../types/admin.types';
-
-export class Hinkal<ConnectorType> implements IHinkal {
-  private providerAdapter?: IProviderAdapter<ConnectorType>;
-
-  public userKeys: UserKeys;
-
-  public readonly signingMessage: string = 'Login to Hinkal Protocol';
-
-  public merkleTreeHinkal: MerkleTree<bigint>;
-
-  public merkleTreeAccessToken: MerkleTree<bigint>;
-
-  public nullifiers: Set<string>;
-
-  public encryptedOutputs: EncryptedOutputWithSign[];
-
-  public approvals: Map<string, ApprovedUtxo[]>;
-
-  public commitmentsSnapshotService?: ClientCommitmentsSnapshotService;
-
-  public nullifierSnapshotService?: ClientNullifierSnapshotService;
-
-  public accessTokenSnapshotService?: ClientAccessTokenSnapshotService;
-
-  public approvalsSnapshotService?: ClientApprovalsSnapshotService;
-
-  public utxoUtils: IMultiThreadedUtxoUtils;
-
-  public cacheDevice: ICacheDevice;
-
-  public generateProofRemotely: boolean;
-
-  private disableMerkleTreeUpdates: boolean;
-
-  constructor(hinkalConfig?: HinkalConfig) {
-    this.userKeys = new UserKeys(undefined);
-    this.merkleTreeHinkal = MerkleTree.create(poseidonFunction, 0n);
-    this.merkleTreeAccessToken = MerkleTree.create(poseidonFunction, 0n);
-    this.nullifiers = new Set<string>();
-    this.encryptedOutputs = [];
-    this.approvals = new Map<string, ApprovedUtxo[]>();
-    this.generateProofRemotely = hinkalConfig?.generateProofRemotely ?? false;
-    this.utxoUtils = new MultiThreadedUtxoUtils();
-    this.cacheDevice = createCacheDevice(hinkalConfig);
-    this.disableMerkleTreeUpdates = hinkalConfig?.disableMerkleTreeUpdates ?? false;
-  }
-
-  public async initProviderAdapter(connector: ConnectorType, providerAdapter: IProviderAdapter<ConnectorType>) {
-    await this.updateProviderAdapter(providerAdapter); // 1) clean previous and set new hinkal provider 2) set listeners on it
-    this.providerAdapter?.initConnector(connector);
-    const chainId = await this.connectAndPatchProvider(connector); // 1) disconnect and release if connected 2)re-connect
-    await providerAdapter.init(chainId);
-    await this.setListeners();
-  }
-
-  public async initUserKeys(): Promise<void> {
-    this.userKeys = new UserKeys(await this.getProviderAdapter().signMessage(this.signingMessage));
-  }
-
-  public async initUserKeysWithPassword(password: string): Promise<void> {
-    this.userKeys = new UserKeys(password);
-  }
-
-  public async resetMerkle() {
-    if (this.disableMerkleTreeUpdates) return;
-    if (this.isSelectedNetworkSupported()) {
-      await resetMerkleTrees(this);
-    }
-  }
-
-  public getProviderAdapter() {
-    if (!this.providerAdapter) {
-      throw new Error('ProviderAdapter is not initialized');
-    }
-    return this.providerAdapter;
-  }
-
-  async waitForTransaction(transactionHash: string, confirmations = 1): Promise<boolean> {
-    const response = await this.providerAdapter?.waitForTransaction(transactionHash, confirmations);
-    return !!response;
-  }
-
-  getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata {
-    return this.getProviderAdapter().getContractMetadata(contractType, chainId);
-  }
-
-  getContract(contractType: ContractType, contractAddress = undefined, chainId?: number): ethers.Contract {
-    return this.getProviderAdapter().getContract(contractType, contractAddress, chainId);
-  }
-
-  getContractWithFetcherByChainId(
-    chainId: number,
-    contractType: ContractType,
-    contractAddress = undefined,
-  ): ethers.Contract {
-    return getContractWithFetcherByChainId(chainId, contractType, contractAddress);
-  }
-
-  async signMessage(message: string): Promise<string> {
-    const sig = await this.getProviderAdapter().signMessage(message);
-    return sig;
-  }
-
-  async signTypedData(
-    domain: ethers.TypedDataDomain,
-    types: Record<string, ethers.TypedDataField[]>,
-    value: Record<string, unknown>,
-  ): Promise<string> {
-    const sig = await this.getProviderAdapter().signTypedData(domain, types, value);
-    return sig;
-  }
-
-  async signWithSubAccount(
-    messageToSign: string | undefined,
-    typedData: TypedData | undefined,
-    subAccount: SubAccount,
-  ): Promise<string> {
-    return hinkalSignSubAccount(this, messageToSign, typedData, subAccount);
-  }
-
-  getContractWithSigner(contract: ContractType, contractAddress = ''): ethers.Contract {
-    return this.getProviderAdapter().getContractWithSigner(contract, contractAddress);
-  }
-
-  getContractWithFetcher(contract: ContractType, contractAddress = ''): ethers.Contract {
-    return this.getProviderAdapter().getContractWithFetcher(contract, contractAddress);
-  }
-
-  getContractWithFetcherForEthereum(contract: ContractType, address: string): ethers.Contract {
-    return this.getProviderAdapter().getContractWithFetcherForEthereum(contract, address);
-  }
-
-  isSelectedNetworkSupported(): boolean {
-    return !!networkRegistry[this.getCurrentChainId()];
-  }
-
-  async switchNetwork(network: EthereumNetwork) {
-    try {
-      await this.getProviderAdapter().switchNetwork(network);
-    } catch {
-      throw new Error(transactionErrorCodes.FAILED_TO_SWITCH_NETWORKS);
-    }
-  }
-
-  async switchAccount(signer: ethers.Signer) {
-    await this.getProviderAdapter().switchAccount(signer);
-  }
-
-  getCurrentChainId(): number {
-    const { chainId } = this.getProviderAdapter();
-    if (!chainId) throw new Error('Illegal State: no chainId');
-
-    return chainId;
-  }
-
-  getSelectedNetwork(): EthereumNetwork | undefined {
-    return this.providerAdapter?.getSelectedNetwork();
-  }
-
-  isPermitterAvailable(): boolean {
-    return this.getProviderAdapter().isPermitterAvailable();
-  }
-
-  async connectAndPatchProvider(connector: ConnectorType): Promise<number> {
-    const chainId = await this.getProviderAdapter().connectAndPatchProvider(connector);
-    return chainId;
-  }
-
-  async disconnectFromConnector() {
-    await this.getProviderAdapter().disconnectFromConnector();
-  }
-
-  async updateProviderAdapter(providerAdapter: IProviderAdapter): Promise<void> {
-    try {
-      if (this.providerAdapter) this.providerAdapter.release();
-      this.providerAdapter = providerAdapter;
-    } catch (err) {
-      console.error(err);
-      throw Error('updateProviderAdapter failed, please try again.');
-    }
-  }
-
-  async setListeners(): Promise<void> {
-    this.providerAdapter?.setChainEventListener({
-      onAccountChanged: () => {
-        this.onAccountChanged();
-      },
-      onChainChanged: (chainId?: number) => {
-        this.onChainChanged(chainId);
-      },
-    });
-  }
-
-  private async onAccountChanged() {
-    await this.getProviderAdapter().onAccountChanged();
-    const eventType = EventType.AccountChanged;
-    if (typeof document !== 'undefined') {
-      document?.dispatchEvent(new Event(eventType));
-    } else {
-      process?.emit('message', eventType, undefined);
-    }
-  }
-
-  private async onChainChanged(chainId?: number) {
-    // case of network switch
-    if (chainId) {
-      await this.getProviderAdapter().onChainChanged(chainId);
-      const eventType = EventType.NetworkChange;
-      if (typeof document !== 'undefined') {
-        document.dispatchEvent(new Event(eventType));
-      } else {
-        process?.emit('message', eventType, undefined);
-      }
-    } // case of disconnect
-    else {
-      await this.disconnectFromConnector();
-      reloadPage();
-    }
-  }
-
-  public async monitorConnectedAddress(): Promise<void> {
-    await API.monitor(await this.getEthereumAddress(), this.getCurrentChainId());
-  }
-
-  async getBalances(
-    chainId: number,
-    passedShieldedPrivateKey: string,
-    passedShieldedPublicKey: string,
-    ethAddress: string,
-    resetCacheBefore = false,
-    updateTokensListBefore?: boolean,
-  ): Promise<Map<string, TokenBalance>> {
-    return getShieldedBalance(
-      this,
-      chainId,
-      passedShieldedPrivateKey,
-      passedShieldedPublicKey,
-      ethAddress,
-      resetCacheBefore,
-      this.generateProofRemotely,
-      updateTokensListBefore,
-    );
-  }
-
-  async getApprovedBalances(
-    resetCacheBefore = false,
-    updateTokensListBefore = false,
-  ): Promise<Map<string, TokenBalance>> {
-    return getApprovedBalance(this, resetCacheBefore, updateTokensListBefore);
-  }
-
-  async getTotalBalance(
-    _chainId?: number,
-    _userKeys?: UserKeys,
-    _ethAddress?: string,
-    resetCacheBefore = false,
-    updateTokensListBefore?: boolean,
-  ): Promise<TokenBalance[]> {
-    const chainId = _chainId ?? this.getCurrentChainId();
-    const ethAddress = _ethAddress ?? (await this.getEthereumAddress());
-    const userKeys = _userKeys ?? this.userKeys;
-
-    const shieldedBalances = await this.getBalances(
-      chainId,
-      userKeys.getShieldedPrivateKey(),
-      userKeys.getShieldedPublicKey(),
-      ethAddress,
-      resetCacheBefore,
-      updateTokensListBefore,
-    );
-    // TODO: use the same mechanism as getBalances for handling race conditions
-    const approvedBalances = await this.getApprovedBalances(resetCacheBefore, updateTokensListBefore);
-
-    const tokenRegistry = isExtension
-      ? await privateTokensDB.getPrivateTokens(chainId, ethAddress)
-      : getErc20TokensForChain(chainId);
-    const totalBalances: TokenBalance[] = [];
-
-    tokenRegistry.forEach((token) => {
-      const tokenAddress = token.erc20TokenAddress.toLowerCase();
-      const shieldedBalance = shieldedBalances.get(tokenAddress);
-      const approvedBalance = approvedBalances.get(tokenAddress);
-
-      const combinedBalance: TokenBalance = {
-        token,
-        balance: (shieldedBalance?.balance ?? 0n) + (approvedBalance?.balance ?? 0n),
-        timestamp: shieldedBalance?.timestamp || approvedBalance?.timestamp || '0',
-        nfts: shieldedBalance?.nfts || [],
-      };
-
-      totalBalances.push(combinedBalance);
-    });
-
-    return totalBalances;
-  }
-
-  getSupportedPassportLinks(): string[] {
-    return supportedPassportLinks;
-  }
-
-  checkAccessToken(): Promise<boolean> {
-    return checkHinkalAccessToken(this);
-  }
-
-  async mintHinkalAccessToken(signatureData: SignatureData, fromWallet?: boolean): Promise<ethers.ContractTransaction> {
-    return mintAccessToken(this, signatureData, fromWallet);
-  }
-
-  async getHinkalTreeRootHash() {
-    const hinkalContract = this.getContractWithFetcher(ContractType.HinkalContract);
-    // eslint-disable-next-line @typescript-eslint/dot-notation
-    return hinkalContract['getRootHash']();
-  }
-
-  async getAccessTokenTreeRootHash() {
-    const accessToken = this.getContractWithFetcher(ContractType.AccessTokenContract);
-    // eslint-disable-next-line @typescript-eslint/dot-notation
-    return accessToken['getRootHash']();
-  }
-
-  async resetMerkleTreesIfNecessary() {
-    if (!this.isSelectedNetworkSupported()) throw new Error(transactionErrorCodes.UNSUPPORTED_NETWORK);
-    const [hinkalRootHash, accessTokenRootHash] = await Promise.all([
-      this.getHinkalTreeRootHash(),
-      this.getAccessTokenTreeRootHash(),
-    ]);
-    if (
-      (hinkalRootHash as BigNumber).toBigInt() !== this.merkleTreeHinkal.getRootHash() ||
-      (accessTokenRootHash as BigNumber).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.approvalsSnapshotService?.retrieveEventsFromLatestBlock(),
-    ]);
-  }
-
-  getEthereumAddress() {
-    return this.getProviderAdapter().getAddress();
-  }
-
-  async getRandomRelay(markAsPending = false) {
-    const relayObject = await API.getIdleRelay(this.getCurrentChainId(), markAsPending);
-    return relayObject.relay;
-  }
-
-  getGasPrice(): Promise<bigint> {
-    if (!this.providerAdapter?.chainId) throw new Error('Illegal State of providerAdapter in Hinkal: no chainId');
-    return this.providerAdapter.getGasPrice();
-  }
-
-  public getAPI(): IAPI {
-    return API;
-  }
-
-  public resetCache() {
-    resetCache(this, this.getCurrentChainId(), this.userKeys.getShieldedPublicKey());
-  }
-
-  public snapshotsClearInterval() {
-    this.commitmentsSnapshotService?.intervalClear();
-    this.accessTokenSnapshotService?.intervalClear();
-    this.nullifierSnapshotService?.intervalClear();
-    this.approvalsSnapshotService?.intervalClear();
-  }
-
-  public checkTokenRegistry(erc20Addresses: string[], amountChanges: bigint[]): Promise<boolean> {
-    const hinkalHelper = this.getContractWithFetcher(ContractType.HinkalHelperContract);
-    return hinkalCheckTokenRegistry(hinkalHelper, erc20Addresses, amountChanges);
-  }
-
-  public getRecipientInfo(extendedInfo = false): string {
-    return getRecipientInfo(this, extendedInfo);
-  }
-
-  public async getInteractionApprovals(interactionAddress: string): Promise<ApprovedUtxo[]> {
-    const approvedUtxos = await getInteractionApprovals(this, interactionAddress);
-    return approvedUtxos;
-  }
-
-  public getApprovedUtxos(resetCacheBefore = false): ApprovedUtxoWithInteractionAddress[] {
-    return getApprovedUtxos(this, resetCacheBefore);
-  }
-
-  public getApprovedUtxosForToken(
-    erc20Address: string,
-    resetCacheBefore = false,
-  ): ApprovedUtxoWithInteractionAddress[] {
-    return getApprovedUtxosForToken(this, erc20Address, resetCacheBefore);
-  }
-
-  public getMyApprovalAmountForInteraction(interactionAddress: string, tokenAddress: string): bigint {
-    const approvedAmount = getMyApprovalAmountForInteraction(this, interactionAddress, tokenAddress);
-    return approvedAmount;
-  }
-
-  public async checkExistingApprovalFromHinkal(erc20Address: string, interactionAddress: string): Promise<bigint> {
-    const approvalAmount = await checkExistingApprovalFromHinkal(this, erc20Address, interactionAddress);
-    return approvalAmount;
-  }
-
-  public async getBufferEntry(approveTo: string, tokenAddress: string, inHinkalAddress: bigint): Promise<bigint> {
-    const amount = getBufferEntry(this, approveTo, tokenAddress, inHinkalAddress);
-    return amount;
-  }
-
-  async deposit(erc20Tokens: ERC20Token[], amountChanges: bigint[]): Promise<ethers.ContractTransaction> {
-    return hinkalDeposit(this, erc20Tokens, amountChanges);
-  }
-
-  async depositForOther(
-    erc20Tokens: ERC20Token[],
-    amountChanges: bigint[],
-    recipientInfo: string,
-  ): Promise<ethers.ContractTransaction> {
-    return hinkalDepositForOther(this, erc20Tokens, amountChanges, recipientInfo);
-  }
-
-  async prooflessDeposit(
-    erc20Tokens: ERC20Token[],
-    amountChanges: bigint[],
-    stealthAddressStructures?: StealthAddressStructure[],
-  ): Promise<ethers.ContractTransaction> {
-    return hinkalProoflessDeposit(this, erc20Tokens, amountChanges, stealthAddressStructures);
-  }
-
-  async transfer(
-    erc20Tokens: ERC20Token[],
-    amountChanges: bigint[],
-    recipientAddress: string,
-    feeToken?: string,
-    feeStructureOverride?: FeeStructure,
-    action?: AdminTransactionType,
-    onlyGasEstimate = false,
-  ): Promise<RelayerTransaction | bigint> {
-    return hinkalTransfer(
-      this,
-      erc20Tokens,
-      amountChanges,
-      recipientAddress,
-      feeToken,
-      feeStructureOverride,
-      action,
-      onlyGasEstimate,
-    );
-  }
-
-  async withdraw(
-    erc20Tokens: ERC20Token[],
-    deltaAmounts: bigint[],
-    recipientAddress: string,
-    isRelayerOff: boolean,
-    feeToken?: string,
-    feeStructureOverride?: FeeStructure,
-    action?: AdminTransactionType,
-    onlyGasEstimate = false,
-  ): Promise<ethers.ContractTransaction | RelayerTransaction | bigint> {
-    return hinkalWithdraw(
-      this,
-      erc20Tokens,
-      deltaAmounts,
-      recipientAddress,
-      isRelayerOff,
-      feeToken,
-      feeStructureOverride,
-      action,
-      onlyGasEstimate,
-    );
-  }
-
-  async swap(
-    erc20Tokens: ERC20Token[],
-    deltaAmounts: bigint[],
-    externalActionId: ExternalActionId,
-    swapData: string,
-    feeToken?: string,
-    feeStructureOverride?: FeeStructure,
-    action?: AdminTransactionType,
-    onlyGasEstimate = false,
-    withPrivateMempool = false,
-  ): Promise<RelayerTransaction | bigint> {
-    return hinkalSwap(
-      this,
-      erc20Tokens,
-      deltaAmounts,
-      externalActionId,
-      swapData,
-      feeToken,
-      feeStructureOverride,
-      action,
-      onlyGasEstimate,
-      withPrivateMempool,
-    );
-  }
-
-  async actionReceive(
-    erc20Tokens: ERC20Token[],
-    deltaAmounts: bigint[],
-    feeToken?: string,
-    feeStructureOverride?: FeeStructure,
-    subAccount?: SubAccount,
-    action?: AdminTransactionType,
-    onlyGasEstimate = false,
-  ): Promise<RelayerTransaction | bigint> {
-    return hinkalActionReceive(
-      this,
-      erc20Tokens,
-      deltaAmounts,
-      feeToken,
-      feeStructureOverride,
-      subAccount,
-      action,
-      onlyGasEstimate,
-    );
-  }
-
-  async actionFundApproveAndTransact(
-    tokenChanges: TokenChanges<bigint>[],
-    subAccount: SubAccount,
-    spenderAddress?: string,
-    to?: string,
-    callDataString?: string,
-    value?: bigint,
-    feeToken?: string,
-    feeStructureOverride?: FeeStructure,
-    autoDepositBack = false,
-    maxGasInDollar?: string,
-    action?: AdminTransactionType,
-    onlyGasEstimate?: boolean,
-  ): Promise<RelayerTransaction | bigint> {
-    return hinkalActionFundApproveAndTransact(
-      this,
-      tokenChanges,
-      subAccount,
-      spenderAddress,
-      to,
-      callDataString,
-      value,
-      feeToken,
-      feeStructureOverride,
-      autoDepositBack,
-      maxGasInDollar,
-      action,
-      onlyGasEstimate,
-    );
-  }
-
-  async actionPrivateWallet(
-    erc20Addresses: string[],
-    deltaAmounts: bigint[],
-    onChainCreation: boolean[],
-    ops: string[],
-    emporiumTokenChanges: TokenChanges<bigint>[],
-    subAccount: SubAccount,
-    feeToken?: string,
-    feeStructureOverride?: FeeStructure,
-    relayOverride?: string,
-    autoDepositBack = false,
-    maxGasInDollar?: string,
-    action?: AdminTransactionType,
-    onlyGasEstimate = false,
-  ): Promise<RelayerTransaction | bigint> {
-    return hinkalPrivateWallet(
-      this,
-      erc20Addresses,
-      deltaAmounts,
-      onChainCreation,
-      ops,
-      emporiumTokenChanges,
-      subAccount,
-      feeToken,
-      feeStructureOverride,
-      relayOverride,
-      autoDepositBack,
-      maxGasInDollar,
-      action,
-      onlyGasEstimate,
-    );
-  }
-
-  async approve(
-    erc20Addresses: string[],
-    amount: bigint,
-    approveTo: string,
-    feeToken?: string,
-    feeStructureOverride?: FeeStructure,
-    onlyGasEstimate = false,
-  ): Promise<RelayerTransaction | bigint> {
-    return hinkalApprove(this, erc20Addresses, amount, approveTo, feeToken, feeStructureOverride, onlyGasEstimate);
-  }
-
-  async hinkalInsideTransact(
-    erc20Addresses: string[],
-    deltaChanges: bigint[],
-    approvalChanges: bigint[],
-    externalAddress: string,
-    externalActionMetadata: string,
-    parsedInLogicMetadata: ParsedInLogicMetadata,
-    feeToken?: string,
-    feeStructureOverride?: FeeStructure,
-    action?: AdminTransactionType,
-    onlyGasEstimate = false,
-  ): Promise<RelayerTransaction | bigint> {
-    return hinkalInsideTransact(
-      this,
-      erc20Addresses,
-      deltaChanges,
-      approvalChanges,
-      externalAddress,
-      externalActionMetadata,
-      parsedInLogicMetadata,
-      feeToken,
-      feeStructureOverride,
-      action,
-      onlyGasEstimate,
-    );
-  }
-
-  async proxySwap(
-    erc20Tokens: ERC20Token[],
-    deltaAmounts: bigint[],
-    externalActionId: ExternalActionId,
-    swapData: string,
-    isTheSameChainSwap: boolean,
-    subAccount: SubAccount,
-    feeToken?: string,
-    feeStructureOverride?: FeeStructure,
-    autoDepositBack = false,
-    maxGasInDollar?: string,
-    action?: AdminTransactionType,
-    onlyGasEstimate = false,
-  ): Promise<RelayerTransaction | bigint> {
-    return hinkalProxySwap(
-      this,
-      erc20Tokens,
-      deltaAmounts,
-      externalActionId,
-      swapData,
-      isTheSameChainSwap,
-      subAccount,
-      feeToken,
-      feeStructureOverride,
-      autoDepositBack,
-      maxGasInDollar,
-      action,
-      onlyGasEstimate,
-    );
-  }
-
-  async multiSendPrivateRecipients(
-    erc20Tokens: ERC20Token[],
-    amounts: bigint[],
-    extendedRecipientInfos?: string[],
-  ): Promise<ethers.ContractTransaction> {
-    return hinkalMultiSendPrivateRecipients(this, erc20Tokens, amounts, extendedRecipientInfos);
-  }
-
-  public areMerkleTreeUpdatesDisabled() {
-    return this.disableMerkleTreeUpdates;
-  }
-
-  public updateMerkleTreeUpdates(value: boolean) {
-    this.disableMerkleTreeUpdates = value;
-  }
-}