@sabaaa1/common 0.0.4 → 0.0.7

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

@@ -0,0 +1,190 @@
+/* eslint-disable no-param-reassign */
+import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
+import { outputUtxoProcessing } from '../../functions/pre-transaction/outputUtxoProcessing';
+import { constructZkProof } from '../../functions/snarkjs/constructGeneralZkProof';
+import { addPaddingToUtxos } from '../../functions/web3/events/getShieldedBalance';
+import { estimateGasRelayer } from '../../functions/web3/functionCalls/estimateGasRelayer';
+import { transactCallRelayer } from '../../functions/web3/functionCalls/transactCallRelayer';
+import { ExternalActionData, ExternalActionId } from '../../types/external-action.types';
+import { Utxo } from '../utxo/Utxo';
+import { IHinkal } from './IHinkal';
+import {
+  defaultUseApprovalUTXOData,
+  FeeStructure,
+  HinkalLogicAction,
+  type HinkalLogicArgs,
+  type ParsedInLogicMetadata,
+} from '../../types/hinkal.types';
+import { absBigInt } from '../../functions/utils/amounts.utils';
+import { outputApprovalDataProcessing } from '../../functions/pre-transaction/outputApprovalDataProcessing';
+import { APPROVED_UTXO_CONVERSION_COUNT } from '../../constants/conversion.constants';
+import { zeroAddress } from '../../constants/protocol.constants';
+import { mergeWithFeeStructure } from '../../functions/pre-transaction/merge-with-fee-structure';
+import { getFeeStructure } from '../../functions/pre-transaction/getFeeStructure';
+import { ContractType } from '../../types/ethereum-network.types';
+import { Logger } from '../../error-handling/logger';
+import { uniswapWorkaround } from '../../functions/utils/involves-permit2-op';
+import { getSignatureDataForTransact } from '../../functions/pre-transaction/getSignatureDataForTransact';
+import { shouldPatchAccessTokenMerkleTree } from '../../functions/pre-transaction/shouldPatchAccessTokenMerkleTree';
+import { encodeParsedInLogicMetadata } from '../../functions/utils/inLogicMetadata';
+import { getCurrentTimeInSeconds } from '../../functions/utils/time.utils';
+import { AdminTransactionType } from '../../types/admin.types';
+import { constructAdminData } from '../../functions/pre-transaction/constructAdminData';
+
+export const hinkalInsideTransact = async (
+  hinkal: IHinkal,
+  erc20Addresses: string[],
+  deltaChanges: bigint[], // total amount of tokens to be taken from hinkal
+  approvalChanges: bigint[], // part of deltaChanges that is already covered
+  externalAddress: string,
+  externalActionMetadata: string,
+  parsedInLogicMetadata: ParsedInLogicMetadata,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+  action?: AdminTransactionType,
+  onlyGasEstimate = false,
+) => {
+  // Encode the parsedInLogicMetadata to match the Solidity decode structure
+  const encodedMetadata = encodeParsedInLogicMetadata(parsedInLogicMetadata);
+
+  const externalActionData: ExternalActionData = {
+    externalActionId: ExternalActionId.Wallet,
+    externalAddress,
+    externalActionMetadata: encodedMetadata,
+  };
+
+  const hinkalContract = hinkal.getContractWithFetcher(ContractType.HinkalContract);
+
+  const ethIndex = erc20Addresses.findIndex((address) => address === zeroAddress);
+
+  const value = ethIndex !== -1 && deltaChanges[ethIndex] < 0n ? -deltaChanges[ethIndex] : 0n;
+
+  const feeStructure =
+    feeStructureOverride ??
+    (await getFeeStructure(hinkal.getCurrentChainId(), feeToken, erc20Addresses, ExternalActionId.Wallet, [
+      { from: hinkalContract.address, to: externalAddress, value, calldata: externalActionMetadata },
+    ]));
+
+  mergeWithFeeStructure(hinkal.getCurrentChainId(), erc20Addresses, deltaChanges, feeStructure);
+  approvalChanges = [...approvalChanges];
+  if (approvalChanges.length < deltaChanges.length) approvalChanges.push(0n);
+
+  const inputUtxosArray = [...(await addPaddingToUtxos(hinkal, erc20Addresses, deltaChanges))];
+  const circuitName = `swapperMHA${deltaChanges.length.toString()}x${inputUtxosArray[0].length}x1`;
+
+  const onChainCreation = deltaChanges.map((amount) => !(amount < 0n));
+  // 2) get output utxos
+  const outputUtxosArray: Utxo[][] = [];
+
+  const hinkalLogicArgs: HinkalLogicArgs = {
+    inHinkalAddress: hinkal.userKeys.getInHinkalAddress(externalAddress),
+    executeApprovalChanges: approvalChanges,
+    hinkalLogicAction: HinkalLogicAction.EXECUTE,
+    doPreTxApproval: false,
+    useApprovalUtxoData: [],
+  };
+
+  const timeStamp = getCurrentTimeInSeconds().toString();
+  // Logic: If we do not have enough approval utxos, then
+  // 1) we need to compensate it from normal utxos, or
+  // 2) we need to disapprove from other interactions
+  for (let i = 0; i < erc20Addresses.length; i += 1) {
+    const additionalDeltaChange = onChainCreation[i]
+      ? 0n
+      : -(absBigInt(deltaChanges[i]) - absBigInt(approvalChanges[i]));
+
+    const { outputUtxos } = outputUtxoProcessing(
+      hinkal.userKeys,
+      inputUtxosArray[i],
+      additionalDeltaChange,
+      timeStamp,
+      undefined,
+      false,
+    );
+    outputUtxosArray.push(outputUtxos);
+    const { useApprovalUtxoData } = outputApprovalDataProcessing(
+      hinkal,
+      inputUtxosArray[i],
+      additionalDeltaChange,
+      externalAddress,
+    );
+    hinkalLogicArgs.useApprovalUtxoData.push(
+      useApprovalUtxoData ?? defaultUseApprovalUTXOData(APPROVED_UTXO_CONVERSION_COUNT, 0n),
+    );
+    if (useApprovalUtxoData) hinkalLogicArgs.doPreTxApproval = true;
+  }
+
+  const relay = await hinkal.getRandomRelay(!onlyGasEstimate);
+  if (!relay) throw Error(transactionErrorCodes.RELAYER_NOT_AVAILABLE);
+
+  Logger.log('hinkaInAction', { hinkalLogicArgs, deltaChanges, approvalChanges });
+
+  const { patchAccessTokenMerkleTree, kycRequired, hasAccessToken } = await shouldPatchAccessTokenMerkleTree(
+    hinkal,
+    erc20Addresses,
+    deltaChanges,
+  );
+
+  const signatureData = await getSignatureDataForTransact(
+    hinkal.getCurrentChainId(),
+    await hinkal.getEthereumAddress(),
+    hinkal.userKeys,
+    kycRequired,
+    hasAccessToken,
+  );
+
+  // 3) generating proof and publicSignals from circom
+  const { zkCallData, circomData, dimData } = await constructZkProof(
+    'v1x1',
+    hinkal.merkleTreeHinkal,
+    hinkal.merkleTreeAccessToken,
+    inputUtxosArray,
+    outputUtxosArray,
+    hinkal.userKeys,
+    circuitName,
+    externalActionData.externalActionId,
+    externalActionData.externalAddress,
+    externalActionData.externalActionMetadata,
+    hinkal.generateProofRemotely,
+    relay,
+    hinkal.getCurrentChainId(),
+    onChainCreation,
+    undefined,
+    undefined,
+    undefined, // stakeArgs
+    patchAccessTokenMerkleTree,
+    hinkalLogicArgs,
+    undefined,
+    feeStructure,
+    hinkal.getContractWithFetcher(ContractType.HinkalHelperContract),
+    signatureData,
+  );
+  const withUniswapWorkAround = uniswapWorkaround([externalActionMetadata]);
+
+  Logger.log('hinkalInAction circomData', { circomData, withUniswapWorkAround });
+  // 4) Transaction Part
+  if (onlyGasEstimate) {
+    const gasEstimate = await estimateGasRelayer(hinkal, zkCallData, dimData, circomData);
+    return gasEstimate;
+  }
+
+  const adminData = constructAdminData(
+    action,
+    hinkal.getCurrentChainId(),
+    erc20Addresses,
+    deltaChanges,
+    await hinkal.getEthereumAddress(),
+  );
+
+  const tx = await transactCallRelayer(
+    hinkal.getCurrentChainId(),
+    zkCallData,
+    dimData,
+    circomData,
+    withUniswapWorkAround,
+    undefined,
+    undefined,
+    adminData,
+  );
+  return tx;
+};

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

@@ -0,0 +1,26 @@
+import { type StealthAddressStructure } from '../../types/circom-data.types';
+import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
+import { constructStealthAddressStructure, isValidExtendedPrivateAddress } from '../../functions/utils/addresses';
+import { type IHinkal } from './IHinkal';
+import { type ERC20Token } from '../../types/token.types';
+
+// we want to send to several private recipients
+
+export const hinkalMultiSendPrivateRecipients = async (
+  hinkal: IHinkal,
+  erc20Tokens: ERC20Token[],
+  amounts: bigint[],
+  extendedRecipientInfos?: string[],
+) => {
+  let stealthAddressStructures: StealthAddressStructure[] | undefined;
+  if (extendedRecipientInfos) {
+    stealthAddressStructures = extendedRecipientInfos.map((recipientInfo) => {
+      if (!isValidExtendedPrivateAddress(recipientInfo)) {
+        throw Error(transactionErrorCodes.RECIPIENT_FORMAT_INCORRECT);
+      }
+      return constructStealthAddressStructure(recipientInfo);
+    });
+  }
+  const tx = await hinkal.prooflessDeposit(erc20Tokens, amounts, stealthAddressStructures);
+  return tx;
+};

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

@@ -0,0 +1,198 @@
+import { networkRegistry } from '../../constants/chains.constants';
+import { transactionErrorCodes } from '../../error-handling';
+
+import { constructEmporiumProof } from '../../functions/snarkjs/constructEmporiumProof';
+import { outputUtxoProcessing } from '../../functions/pre-transaction/outputUtxoProcessing';
+import { addPaddingToUtxos } from '../../functions/web3/events/getShieldedBalance';
+import { estimateGasRelayer } from '../../functions/web3/functionCalls/estimateGasRelayer';
+import { transactCallRelayer } from '../../functions/web3/functionCalls/transactCallRelayer';
+import { uniswapWorkaround } from '../../functions/utils/involves-permit2-op';
+
+import { ExternalActionId } from '../../types/external-action.types';
+import { Utxo } from '../utxo/Utxo';
+import { IHinkal } from './IHinkal';
+import { defaultHinkalLogicArgs, FeeStructure, HinkalLogicArgs } from '../../types/hinkal.types';
+import { outputApprovalDataProcessing } from '../../functions/pre-transaction/outputApprovalDataProcessing';
+import { convertEmporiumOpToCallInfo } from '../../functions/utils/convertEmporiumOpToCallInfo';
+import { getFeeStructure } from '../../functions/pre-transaction/getFeeStructure';
+import { ContractType } from '../../types/ethereum-network.types';
+
+import { shouldPatchAccessTokenMerkleTree } from '../../functions/pre-transaction/shouldPatchAccessTokenMerkleTree';
+import { getSignatureDataForTransact } from '../../functions/pre-transaction/getSignatureDataForTransact';
+import { mergeWithFeeStructureEmporium } from '../../functions/pre-transaction/merge-with-fee-structure-emporium';
+import { TokenChanges } from '../../types/token.types';
+import { caseInsensitiveEqual } from '../../functions/utils/caseInsensitive.utils';
+import { getCurrentTimeInSeconds } from '../../functions/utils/time.utils';
+import { handleAutoDepositBack } from './handleAutoDepositBack';
+import { UserKeys } from '../crypto-keys/keys';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+import { constructAdminData } from '../../functions/pre-transaction';
+
+export const hinkalPrivateWallet = async (
+  hinkal: IHinkal,
+  erc20Addresses: string[],
+  deltaChanges: bigint[],
+  onChainCreation: boolean[],
+  ops: string[],
+  emporiumTokenChanges: TokenChanges<bigint>[],
+  subAccount: SubAccount,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+  relayOverride?: string,
+  autoDepositBack = false,
+  maxGasInDollar?: string,
+  action?: AdminTransactionType,
+  onlyGasEstimate = false,
+) => {
+  const walletAddress = UserKeys.getSignerAddressFromPrivateKey(subAccount.privateKey);
+
+  const { contractData } = networkRegistry[hinkal.getCurrentChainId()];
+  const { emporiumAddress } = contractData;
+  if (!emporiumAddress) throw Error('No Emporium Address Provided');
+
+  const feeStructure =
+    feeStructureOverride ??
+    (await getFeeStructure(
+      hinkal.getCurrentChainId(),
+      feeToken,
+      erc20Addresses,
+      ExternalActionId.Emporium,
+      ops.map((op) => convertEmporiumOpToCallInfo(op, walletAddress ?? '', hinkal.getCurrentChainId())),
+    ));
+
+  const feeTokenChange =
+    emporiumTokenChanges.find((tokenChange) =>
+      caseInsensitiveEqual(tokenChange.token.erc20TokenAddress, feeStructure.feeToken),
+    )?.amount ?? 0n;
+
+  if (walletAddress) {
+    await mergeWithFeeStructureEmporium(
+      hinkal,
+      walletAddress,
+      ops,
+      erc20Addresses,
+      deltaChanges,
+      feeStructure,
+      feeTokenChange,
+    );
+  }
+
+  while (onChainCreation.length < erc20Addresses.length) {
+    onChainCreation.push(false);
+  }
+
+  const inputUtxosArray = [...(await addPaddingToUtxos(hinkal, erc20Addresses, deltaChanges))];
+
+  // 2) get output utxos
+  const outputUtxosArray: Utxo[][] = [];
+
+  const hinkalLogicArgs: HinkalLogicArgs = defaultHinkalLogicArgs(deltaChanges.length, hinkal.userKeys);
+
+  const timeStamp = getCurrentTimeInSeconds().toString();
+  for (let i = 0; i < erc20Addresses.length; i += 1) {
+    const { outputUtxos } = outputUtxoProcessing(
+      hinkal.userKeys,
+      inputUtxosArray[i],
+      deltaChanges[i],
+      timeStamp,
+      undefined,
+      false,
+    );
+    outputUtxosArray.push(outputUtxos);
+    const { useApprovalUtxoData } = outputApprovalDataProcessing(hinkal, inputUtxosArray[i], deltaChanges[i]);
+    if (useApprovalUtxoData) {
+      hinkalLogicArgs.doPreTxApproval = true;
+      hinkalLogicArgs.useApprovalUtxoData[i] = useApprovalUtxoData;
+      hinkalLogicArgs.interactionAddress = emporiumAddress; // this does not matter if hinkalLogicAction is NONE
+      hinkalLogicArgs.inHinkalAddress = hinkal.userKeys.getInHinkalAddress(emporiumAddress); // this as well
+    }
+  }
+
+  const relay = relayOverride ?? (await hinkal.getRandomRelay(!onlyGasEstimate));
+  if (!relay) throw Error(transactionErrorCodes.RELAYER_NOT_AVAILABLE);
+
+  const { patchAccessTokenMerkleTree, kycRequired, hasAccessToken } = await shouldPatchAccessTokenMerkleTree(
+    hinkal,
+    erc20Addresses,
+    deltaChanges,
+  );
+
+  const signatureData = await getSignatureDataForTransact(
+    hinkal.getCurrentChainId(),
+    await hinkal.getEthereumAddress(),
+    hinkal.userKeys,
+    kycRequired,
+    hasAccessToken,
+  );
+
+  // 3) generating proof and publicSignals from circom
+  const { zkCallData, circomData, dimData, authorizationData } = await constructEmporiumProof(
+    'v1x1',
+    hinkal.merkleTreeHinkal,
+    hinkal.merkleTreeAccessToken,
+    erc20Addresses,
+    erc20Addresses.map(() => 0),
+    inputUtxosArray,
+    outputUtxosArray,
+    hinkal.userKeys,
+    deltaChanges.length,
+    inputUtxosArray.length > 0 ? inputUtxosArray[0].length : 0,
+    emporiumAddress,
+    ops,
+    hinkal.generateProofRemotely,
+    relay,
+    hinkal.getCurrentChainId(),
+    onChainCreation,
+    undefined,
+    subAccount,
+    hinkalLogicArgs,
+    patchAccessTokenMerkleTree,
+    undefined,
+    feeStructure,
+    hinkal.getContractWithFetcher(ContractType.HinkalHelperContract),
+    signatureData,
+  );
+
+  const withUniswapWorkAround = uniswapWorkaround(ops);
+
+  // 4) Transaction Part
+  if (onlyGasEstimate) {
+    // TODO: add authorizationData to gas estimate
+    const gasEstimate = await estimateGasRelayer(hinkal, zkCallData, dimData, circomData, authorizationData);
+    return gasEstimate;
+  }
+
+  const adminData = constructAdminData(
+    action,
+    hinkal.getCurrentChainId(),
+    erc20Addresses.length === 0 ? emporiumTokenChanges.map((c) => c.token.erc20TokenAddress) : erc20Addresses,
+    deltaChanges.length === 0 ? emporiumTokenChanges.map((c) => c.amount) : deltaChanges,
+    await hinkal.getEthereumAddress(),
+  );
+
+  const tx = await transactCallRelayer(
+    hinkal.getCurrentChainId(),
+    zkCallData,
+    dimData,
+    circomData,
+    false,
+    withUniswapWorkAround,
+    authorizationData,
+    adminData,
+  );
+
+  if (autoDepositBack) {
+    handleAutoDepositBack(
+      hinkal,
+      walletAddress,
+      subAccount,
+      feeStructure.feeToken,
+      maxGasInDollar,
+      emporiumTokenChanges,
+      circomData,
+    );
+  }
+
+  return tx;
+};

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

@@ -0,0 +1,91 @@
+/* eslint-disable no-await-in-loop */
+import { ERC20Token, TokenBalance } from '../../types/token.types';
+import { calcStealthAddressStructure } from '../../functions/snarkjs/common.snarkjs';
+import { randomBigInt } from '../../functions/web3/etherFunctions';
+import { ContractType } from '../../types/ethereum-network.types';
+import { Utxo } from '../utxo/Utxo';
+import { IHinkal } from './IHinkal';
+import { StealthAddressStructure } from '../../types/circom-data.types';
+import { zeroAddress } from '../../constants/protocol.constants';
+import { caseInsensitiveEqual } from '../../functions/utils/caseInsensitive.utils';
+
+const aggregateAmountsForApproval = (erc20Tokens: ERC20Token[], amounts: bigint[]): TokenBalance[] => {
+  const uniqueTokens = [];
+  let uniqueCount = 0;
+
+  for (let i = 0; i < erc20Tokens.length; i += 1) {
+    let found = false;
+    for (let j = 0; j < uniqueCount; j += 1) {
+      if (caseInsensitiveEqual(uniqueTokens[j].token.erc20TokenAddress, erc20Tokens[i].erc20TokenAddress)) {
+        uniqueTokens[j].balance += amounts[i];
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      uniqueTokens[uniqueCount] = {
+        token: erc20Tokens[i],
+        balance: amounts[i],
+      };
+      uniqueCount += 1;
+    }
+  }
+  return uniqueTokens;
+};
+
+const approveTokens = async (hinkal: IHinkal, erc20Tokens: ERC20Token[], amounts: bigint[]) => {
+  const tokensWithBalances = aggregateAmountsForApproval(erc20Tokens, amounts);
+
+  const hinkalContract = hinkal.getContractWithSigner(ContractType.HinkalContract);
+  const hinkalAddress = hinkalContract.address;
+
+  for (let i = 0; i < tokensWithBalances.length; i += 1) {
+    if (!caseInsensitiveEqual(tokensWithBalances[i].token.erc20TokenAddress, zeroAddress)) {
+      const erc20Contract = hinkal.getContractWithSigner(
+        ContractType.ERC20Contract,
+        tokensWithBalances[i].token.erc20TokenAddress,
+      );
+
+      const tx = await erc20Contract['approve'](hinkalAddress, tokensWithBalances[i].balance);
+      await tx.wait();
+    }
+  }
+};
+
+export const hinkalProoflessDeposit = async (
+  hinkal: IHinkal,
+  erc20Tokens: ERC20Token[],
+  amountChanges: bigint[],
+  stealthAddressStructuresOverride?: StealthAddressStructure[],
+) => {
+  const hinkalContract = hinkal.getContractWithSigner(ContractType.HinkalContract);
+
+  const shieldedPrivateKey = hinkal.userKeys.getShieldedPrivateKey();
+
+  const extraRandomization = Utxo.findCorrectRandomization(randomBigInt(31), shieldedPrivateKey);
+
+  const stealthAddressStructures =
+    stealthAddressStructuresOverride ??
+    Array(erc20Tokens.length).fill(calcStealthAddressStructure(extraRandomization, shieldedPrivateKey));
+
+  if (stealthAddressStructures.length !== erc20Tokens.length) {
+    throw new Error('Stealth address structures length must be equal to erc20 tokens length');
+  }
+
+  await approveTokens(hinkal, erc20Tokens, amountChanges);
+
+  const ethIndex = erc20Tokens.findIndex((item) => item.erc20TokenAddress === zeroAddress);
+  const ethAmount = amountChanges[ethIndex] ?? 0n;
+
+  const tx = await hinkalContract['prooflessDeposit'](
+    erc20Tokens.map(({ erc20TokenAddress }) => erc20TokenAddress),
+    amountChanges,
+    erc20Tokens.map(() => 0n),
+    stealthAddressStructures,
+    { value: ethAmount },
+  );
+
+  await tx.wait();
+
+  return tx;
+};

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

@@ -0,0 +1,91 @@
+import { ERC20Token } from '../../types/token.types';
+import { SWAP_ROUTER_ADDRESSES } from '../../constants/addresses.constants';
+import { getFeeStructure } from '../../functions/pre-transaction/getFeeStructure';
+import { createSwapToEmporiumOps } from '../../functions/private-wallet/emporium.swap.helpers';
+import { convertEmporiumOpToCallInfo } from '../../functions/utils/convertEmporiumOpToCallInfo';
+import { ExternalActionId } from '../../types/external-action.types';
+import { FeeStructure } from '../../types/hinkal.types';
+import { RelayerTransaction } from '../../types/relayer.types';
+import { IHinkal } from './IHinkal';
+import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
+import { HINKAL_SWAP_VARIABLE_RATE } from '../../constants/protocol.constants';
+import { UserKeys } from '../crypto-keys/keys';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+
+export const hinkalProxySwap = async (
+  hinkal: IHinkal,
+  erc20Tokens: ERC20Token[],
+  deltaAmounts: bigint[],
+  externalActionId: ExternalActionId,
+  data: string,
+  isTheSameChainSwap: boolean,
+  subAccount: SubAccount,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+  autoDepositBack = false,
+  maxGasInDollar?: string,
+  action?: AdminTransactionType,
+  onlyGasEstimate = false,
+): Promise<RelayerTransaction | bigint> => {
+  if (!feeToken) throw new Error('Fee token is required in hinkalProxySwap');
+
+  const chainId = hinkal.getCurrentChainId();
+
+  const walletAddress = UserKeys.getSignerAddressFromPrivateKey(subAccount.privateKey);
+
+  const erc20Addresses = erc20Tokens.map((token) => token.erc20TokenAddress);
+
+  // we need a relay as part of calldata
+  const relay = await hinkal.getRandomRelay(!onlyGasEstimate);
+  if (!relay) throw Error(transactionErrorCodes.RELAYER_NOT_AVAILABLE);
+
+  const transferOps = await createSwapToEmporiumOps(
+    hinkal,
+    externalActionId,
+    SWAP_ROUTER_ADDRESSES[externalActionId as keyof typeof SWAP_ROUTER_ADDRESSES][chainId],
+    data,
+    erc20Addresses[0],
+    deltaAmounts[0],
+    deltaAmounts[1],
+    erc20Addresses[1],
+    isTheSameChainSwap,
+    walletAddress,
+    relay,
+    true,
+  );
+
+  const feeStructure =
+    feeStructureOverride ??
+    (await getFeeStructure(
+      chainId,
+      feeToken,
+      erc20Addresses,
+      ExternalActionId.Emporium,
+      transferOps.map((transferOp) =>
+        convertEmporiumOpToCallInfo(transferOp, walletAddress, hinkal.getCurrentChainId()),
+      ),
+      HINKAL_SWAP_VARIABLE_RATE,
+    ));
+
+  const emporiumTokenChanges = erc20Tokens.map((token, index) => ({
+    token,
+    amount: deltaAmounts[index],
+  }));
+
+  return hinkal.actionPrivateWallet(
+    [],
+    [],
+    [],
+    transferOps,
+    emporiumTokenChanges,
+    subAccount,
+    feeToken,
+    feeStructure,
+    relay,
+    autoDepositBack,
+    maxGasInDollar,
+    action,
+    onlyGasEstimate,
+  );
+};

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

@@ -0,0 +1,28 @@
+import { SubAccount } from '../../types/proxy.types';
+import { type TypedData } from '../../types/circom-data.types';
+import { UserKeys } from '../crypto-keys/keys';
+import { type IHinkal } from './IHinkal';
+
+export const hinkalSignSubAccount = async (
+  hinkal: IHinkal,
+  messageToSign: string | undefined, // it should be a hex number in string format
+  typedData: TypedData | undefined,
+  subAccount: SubAccount,
+) => {
+  let signature: string;
+
+  if (typedData) {
+    signature = await UserKeys.signTypedDataFromPrivateKey(
+      subAccount.privateKey,
+      typedData.domain,
+      typedData.types,
+      typedData.value,
+    );
+  } else {
+    if (!messageToSign) throw Error('dataHash must be provided if typedData is not provided');
+
+    signature = await UserKeys.signMessageFromPrivateKey(subAccount.privateKey, messageToSign);
+  }
+
+  return signature;
+};