@sabaaa1/common 0.0.1

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

@@ -0,0 +1,746 @@
+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;
+  }
+}