@sabaaa1/common 0.0.1

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

@@ -0,0 +1,157 @@
+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 { getFeeStructure } from '../../functions/pre-transaction/getFeeStructure';
+import { mergeWithFeeStructure } from '../../functions/pre-transaction/merge-with-fee-structure';
+
+import { ExternalActionData, 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 { ContractType } from '../../types/ethereum-network.types';
+import { shouldPatchAccessTokenMerkleTree } from '../../functions/pre-transaction/shouldPatchAccessTokenMerkleTree';
+import { getSignatureDataForTransact } from '../../functions/pre-transaction/getSignatureDataForTransact';
+import { getExternalSwapAddress } from '../../functions/pre-transaction/getExternalSwapAddress';
+import { type ERC20Token } from '../../types/token.types';
+import { getCurrentTimeInSeconds } from '../../functions/utils/time.utils';
+import { HINKAL_SWAP_VARIABLE_RATE } from '../../constants/protocol.constants';
+import { AdminTransactionType } from '../../types/admin.types';
+import { constructAdminData } from '../../functions/pre-transaction';
+
+export const hinkalSwap = async (
+  hinkal: IHinkal,
+  erc20tokens: ERC20Token[],
+  deltaAmounts: bigint[],
+  externalActionId: ExternalActionId,
+  data: string, // call data used to call the router contracts.
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+  action?: AdminTransactionType,
+  onlyGasEstimate = false,
+  withPrivateMempool = false,
+) => {
+  const erc20Addresses = erc20tokens.map((token) => token.erc20TokenAddress);
+  const ethereumAddress = await hinkal.getEthereumAddress();
+
+  const feeStructure =
+    feeStructureOverride ??
+    (await getFeeStructure(
+      hinkal.getCurrentChainId(),
+      feeToken,
+      erc20Addresses,
+      ExternalActionId.Transact,
+      undefined,
+      HINKAL_SWAP_VARIABLE_RATE,
+    ));
+  mergeWithFeeStructure(hinkal.getCurrentChainId(), erc20Addresses, deltaAmounts, feeStructure);
+
+  const externalAddress = getExternalSwapAddress(hinkal, externalActionId);
+  const externalActionData: ExternalActionData = {
+    externalActionId,
+    externalAddress,
+    externalActionMetadata: data,
+  };
+
+  const inputUtxosArray = [...(await addPaddingToUtxos(hinkal, erc20Addresses, deltaAmounts))];
+  const circuitName = `swapperM${deltaAmounts.length.toString()}x${inputUtxosArray[0].length}x1`;
+
+  const onChainCreation = [false, true, false].slice(0, deltaAmounts.length);
+  // 2) get output utxos
+  const outputUtxosArray: Utxo[][] = [];
+
+  const hinkalLogicArgs: HinkalLogicArgs = defaultHinkalLogicArgs(deltaAmounts.length, hinkal.userKeys);
+
+  const timeStamp = getCurrentTimeInSeconds().toString();
+  for (let i = 0; i < erc20Addresses.length; i += 1) {
+    const { outputUtxos } = outputUtxoProcessing(
+      hinkal.userKeys,
+      inputUtxosArray[i],
+      deltaAmounts[i],
+      timeStamp,
+      undefined,
+      false,
+    );
+    outputUtxosArray.push(outputUtxos);
+    const { useApprovalUtxoData } = outputApprovalDataProcessing(hinkal, inputUtxosArray[i], deltaAmounts[i]);
+    if (useApprovalUtxoData) {
+      hinkalLogicArgs.useApprovalUtxoData[i] = useApprovalUtxoData;
+      hinkalLogicArgs.doPreTxApproval = true;
+    }
+  }
+
+  const relay = await hinkal.getRandomRelay(!onlyGasEstimate);
+  if (!relay) throw Error(transactionErrorCodes.RELAYER_NOT_AVAILABLE);
+
+  const { patchAccessTokenMerkleTree, kycRequired, hasAccessToken } = await shouldPatchAccessTokenMerkleTree(
+    hinkal,
+    erc20Addresses,
+    deltaAmounts,
+  );
+
+  const signatureData = await getSignatureDataForTransact(
+    hinkal.getCurrentChainId(),
+    ethereumAddress,
+    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,
+    patchAccessTokenMerkleTree,
+    hinkalLogicArgs,
+    undefined,
+    feeStructure,
+    hinkal.getContractWithFetcher(ContractType.HinkalHelperContract),
+    signatureData,
+  );
+  // 4) Transaction part
+  if (onlyGasEstimate) {
+    const gasEstimate = await estimateGasRelayer(hinkal, zkCallData, dimData, circomData);
+    return gasEstimate;
+  }
+
+  const adminData = constructAdminData(
+    action,
+    hinkal.getCurrentChainId(),
+    erc20Addresses,
+    deltaAmounts,
+    ethereumAddress,
+  );
+
+  const relayerResponse = await transactCallRelayer(
+    hinkal.getCurrentChainId(),
+    zkCallData,
+    dimData,
+    circomData,
+    withPrivateMempool,
+    undefined,
+    undefined,
+    adminData,
+  );
+
+  return relayerResponse;
+};

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

@@ -0,0 +1,171 @@
+import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
+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 { getFeeStructure } from '../../functions/pre-transaction/getFeeStructure';
+import { mergeWithFeeStructure } from '../../functions/pre-transaction/merge-with-fee-structure';
+import {
+  constructAdminData,
+  modifyVolatileTokenAmountChanges,
+  outputUtxoProcessing,
+} from '../../functions/pre-transaction';
+import { shouldPatchAccessTokenMerkleTree } from '../../functions/pre-transaction/shouldPatchAccessTokenMerkleTree';
+import { getSignatureDataForTransact } from '../../functions/pre-transaction/getSignatureDataForTransact';
+import { getCurrentTimeInSeconds } from '../../functions/utils/time.utils';
+import { ExternalActionData, ExternalActionId } from '../../types/external-action.types';
+import { defaultHinkalLogicArgs, FeeStructure, HinkalLogicArgs } from '../../types/hinkal.types';
+import { outputApprovalDataProcessing } from '../../functions/pre-transaction/outputApprovalDataProcessing';
+import { AdminTransactionType, ContractType, ERC20Token } from '../../types';
+import { Utxo } from '../utxo/Utxo';
+import { IHinkal } from './IHinkal';
+import { isValidPrivateAddress } from '../../functions/utils/addresses';
+import { HINKAL_PRIVATE_SEND_VARIABLE_RATE } from '../../constants/protocol.constants';
+
+export const hinkalTransfer = async (
+  hinkal: IHinkal,
+  erc20Tokens: ERC20Token[],
+  amountChangesBase: bigint[],
+  recipientAddress: string,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+  action?: AdminTransactionType,
+  onlyGasEstimate = false,
+) => {
+  if (!isValidPrivateAddress(recipientAddress)) {
+    throw Error(transactionErrorCodes.RECIPIENT_FORMAT_INCORRECT);
+  }
+
+  const erc20Addresses = erc20Tokens.map((token) => token.erc20TokenAddress);
+  const amountChanges = await modifyVolatileTokenAmountChanges(
+    hinkal.getCurrentChainId(),
+    erc20Tokens,
+    amountChangesBase,
+  );
+
+  const recipientAmount = (-amountChanges[0] * (10000n - HINKAL_PRIVATE_SEND_VARIABLE_RATE)) / 10000n;
+
+  if (recipientAmount <= 0n) {
+    throw Error(transactionErrorCodes.RECIPIENT_AMOUNT_INVALID);
+  }
+
+  const feeStructure =
+    feeStructureOverride ??
+    (await getFeeStructure(hinkal.getCurrentChainId(), feeToken, erc20Addresses, ExternalActionId.Transact));
+
+  mergeWithFeeStructure(hinkal.getCurrentChainId(), erc20Addresses, amountChanges, feeStructure);
+
+  const chainId = hinkal.getCurrentChainId();
+
+  const token = erc20Tokens[0];
+  if (!token) throw Error('Transfer Action: No Token Found');
+
+  const relay = await hinkal.getRandomRelay();
+
+  const externalActionData: ExternalActionData = {
+    externalActionId: 0n,
+    externalAddress: relay ?? (await hinkal.getEthereumAddress()),
+    externalActionMetadata: '0x00',
+  };
+
+  const inputUtxosArray = [...(await addPaddingToUtxos(hinkal, erc20Addresses, amountChanges))];
+
+  const circuitName = `swapperM${amountChanges.length}x${inputUtxosArray[0].length}x2`;
+
+  // 2) get output utxos
+  const outputUtxosArray: Utxo[][] = [];
+
+  const hinkalLogicArgs: HinkalLogicArgs = defaultHinkalLogicArgs(amountChanges.length, hinkal.userKeys);
+  const timeStamp = getCurrentTimeInSeconds().toString();
+  for (let i = 0; i < erc20Addresses.length; i += 1) {
+    const { outputUtxos } = outputUtxoProcessing(
+      hinkal.userKeys,
+      inputUtxosArray[i],
+      amountChanges[i],
+      timeStamp,
+      undefined,
+      false,
+      recipientAddress,
+      i === 0 ? recipientAmount : 0n, // first token is which is sent to recipient
+    );
+
+    outputUtxosArray.push(outputUtxos);
+
+    const { useApprovalUtxoData } = outputApprovalDataProcessing(hinkal, inputUtxosArray[i], amountChanges[i]);
+
+    if (useApprovalUtxoData) {
+      hinkalLogicArgs.useApprovalUtxoData[i] = useApprovalUtxoData;
+      hinkalLogicArgs.doPreTxApproval = true;
+    }
+  }
+
+  if (!relay) throw Error(transactionErrorCodes.RELAYER_NOT_AVAILABLE);
+
+  const { patchAccessTokenMerkleTree, kycRequired, hasAccessToken } = await shouldPatchAccessTokenMerkleTree(
+    hinkal,
+    erc20Addresses,
+    amountChanges,
+  );
+
+  const signatureData = await getSignatureDataForTransact(
+    chainId,
+    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,
+    chainId,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    patchAccessTokenMerkleTree,
+    hinkalLogicArgs,
+    undefined,
+    feeStructure,
+    hinkal.getContractWithFetcher(ContractType.HinkalHelperContract),
+    signatureData,
+  );
+
+  // 4) Transaction Part
+  if (onlyGasEstimate) {
+    const gasEstimate = await estimateGasRelayer(hinkal, zkCallData, dimData, circomData);
+    return gasEstimate;
+  }
+
+  const adminData = constructAdminData(
+    action,
+    chainId,
+    erc20Addresses,
+    amountChanges,
+    await hinkal.getEthereumAddress(),
+  );
+
+  const tx = await transactCallRelayer(
+    chainId,
+    zkCallData,
+    dimData,
+    circomData,
+    undefined,
+    undefined,
+    undefined,
+    adminData,
+  );
+
+  return tx;
+};

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

@@ -0,0 +1,161 @@
+import { zeroAddress } from '../../constants/protocol.constants';
+
+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 { transactCallDirect } from '../../functions/web3/functionCalls/transactCallDirect';
+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 { defaultHinkalLogicArgs, FeeStructure, HinkalLogicArgs } from '../../types/hinkal.types';
+import { outputApprovalDataProcessing } from '../../functions/pre-transaction/outputApprovalDataProcessing';
+import { getFeeStructure } from '../../functions/pre-transaction/getFeeStructure';
+import { mergeWithFeeStructure } from '../../functions/pre-transaction/merge-with-fee-structure';
+import { AdminTransactionType, ContractType, ERC20Token } from '../../types';
+import { getSignatureDataForTransact } from '../../functions/pre-transaction/getSignatureDataForTransact';
+import { shouldPatchAccessTokenMerkleTree } from '../../functions/pre-transaction/shouldPatchAccessTokenMerkleTree';
+import { constructAdminData, modifyVolatileTokenAmountChanges } from '../../functions/pre-transaction';
+import { getCurrentTimeInSeconds } from '../../functions/utils/time.utils';
+
+export const hinkalWithdraw = async (
+  hinkal: IHinkal,
+  erc20Tokens: ERC20Token[],
+  deltaAmountsBase: bigint[], // should differentiate now: amountChanges is about off-chain utxos
+  recipientAddress: string,
+  isRelayerOff: boolean,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+  action?: AdminTransactionType,
+  onlyGasEstimate = false,
+) => {
+  const erc20Addresses = erc20Tokens.map((token) => token.erc20TokenAddress);
+  const deltaAmounts = await modifyVolatileTokenAmountChanges(
+    hinkal.getCurrentChainId(),
+    erc20Tokens,
+    deltaAmountsBase,
+  );
+
+  let feeStructure: FeeStructure | undefined;
+  if (!isRelayerOff) {
+    feeStructure =
+      feeStructureOverride ??
+      (await getFeeStructure(hinkal.getCurrentChainId(), feeToken, erc20Addresses, ExternalActionId.Transact));
+    mergeWithFeeStructure(hinkal.getCurrentChainId(), erc20Addresses, deltaAmounts, feeStructure);
+  }
+
+  const token = erc20Tokens[0];
+  if (!token) throw Error('Deposit Action: No Token Found');
+
+  const externalActionData: ExternalActionData = {
+    externalActionId: 0n,
+    externalAddress: recipientAddress,
+    externalActionMetadata: '0x00',
+  };
+
+  const inputUtxosArray = [...(await addPaddingToUtxos(hinkal, erc20Addresses, deltaAmounts))];
+  const circuitName = `swapperM${deltaAmounts.length.toString()}x${inputUtxosArray[0].length}x1`;
+
+  // 2) get output utxos
+  const outputUtxosArray: Utxo[][] = [];
+
+  const hinkalLogicArgs: HinkalLogicArgs = defaultHinkalLogicArgs(deltaAmounts.length, hinkal.userKeys);
+
+  const timeStamp = getCurrentTimeInSeconds().toString();
+  for (let i = 0; i < erc20Addresses.length; i += 1) {
+    const { outputUtxos } = outputUtxoProcessing(
+      hinkal.userKeys,
+      inputUtxosArray[i],
+      deltaAmounts[i],
+      timeStamp,
+      undefined,
+      false,
+    );
+    outputUtxosArray.push(outputUtxos);
+
+    const { useApprovalUtxoData } = outputApprovalDataProcessing(hinkal, inputUtxosArray[i], deltaAmounts[i]);
+
+    if (useApprovalUtxoData) {
+      hinkalLogicArgs.useApprovalUtxoData[i] = useApprovalUtxoData;
+      hinkalLogicArgs.doPreTxApproval = true;
+    }
+  }
+
+  const relay = await hinkal.getRandomRelay(!onlyGasEstimate);
+  if (!isRelayerOff && !relay) throw Error(transactionErrorCodes.RELAYER_NOT_AVAILABLE);
+
+  const { patchAccessTokenMerkleTree, kycRequired, hasAccessToken } = await shouldPatchAccessTokenMerkleTree(
+    hinkal,
+    erc20Addresses,
+    deltaAmounts,
+  );
+
+  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,
+    isRelayerOff ? zeroAddress : relay,
+    hinkal.getCurrentChainId(),
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    patchAccessTokenMerkleTree,
+    hinkalLogicArgs,
+    undefined,
+    feeStructure,
+    hinkal.getContractWithFetcher(ContractType.HinkalHelperContract),
+    signatureData,
+  );
+
+  // 4) Transaction Part
+  if (onlyGasEstimate) {
+    const gasEstimate = await estimateGasRelayer(hinkal, zkCallData, dimData, circomData);
+    return gasEstimate;
+  }
+  if (isRelayerOff) {
+    if (!token) throw Error('Withdraw Action: No Token Found');
+    const tx = await transactCallDirect(hinkal, deltaAmounts[0], token, zkCallData, circomData, dimData);
+    return tx;
+  }
+
+  const adminData = constructAdminData(
+    action,
+    hinkal.getCurrentChainId(),
+    erc20Addresses,
+    deltaAmounts,
+    await hinkal.getEthereumAddress(),
+  );
+
+  const tx = await transactCallRelayer(
+    hinkal.getCurrentChainId(),
+    zkCallData,
+    dimData,
+    circomData,
+    undefined,
+    undefined,
+    undefined,
+    adminData,
+  );
+  return tx;
+};

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

@@ -0,0 +1,9 @@
+export * from './Hinkal';
+export * from './IHinkal';
+export * from './hinkalDeposit';
+export * from './hinkalSwap';
+export * from './hinkalTransfer';
+export * from './hinkalWithdraw';
+export * from './hinkalPrivateWallet';
+export * from './resetMerkleTrees';
+export * from './hinkalProxySwap';

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

@@ -0,0 +1,64 @@
+import { networkRegistry } from '../../constants/chains.constants';
+import { ContractType } from '../../types';
+import { BlockchainEventEmitter } from '../event-service/BlockchainEventEmitter';
+import { ClientAccessTokenSnapshotService } from '../snapshot/ClientAccessTokenSnapshotService';
+import { ClientApprovalsSnapshotService } from '../snapshot/ClientApprovalsSnapshotService';
+import { ClientCommitmentsSnapshotService } from '../snapshot/ClientCommitmentsSnapshotService';
+import { ClientNullifierSnapshotService } from '../snapshot/ClientNullifierSnapshotService';
+import { IHinkal } from './IHinkal';
+import { balanceChangedCustomHandler } from '../../functions/web3/events/balanceChangedCustomHandler';
+import { PrivateBalanceUpdateType } from '../../types/balances.types';
+import { SnapshotFetcherService } from '../snapshot';
+
+export const resetMerkleTrees = async (hinkal: IHinkal) => {
+  const currentChainId = hinkal.getCurrentChainId();
+  const { maxPageSize } = networkRegistry[hinkal.getCurrentChainId()];
+
+  const hinkalContract = hinkal.getContractWithFetcher(ContractType.HinkalContract);
+
+  const hinkalEventEmitter = new BlockchainEventEmitter(hinkalContract, 0, false, maxPageSize);
+
+  const accessTokenEventEmitter = new BlockchainEventEmitter(
+    hinkal.getContractWithFetcher(ContractType.AccessTokenContract),
+    0,
+    false,
+    maxPageSize,
+  );
+
+  const snapshotFetcher = new SnapshotFetcherService(currentChainId, hinkalContract.address);
+
+  hinkal.commitmentsSnapshotService?.intervalClear();
+  hinkal.commitmentsSnapshotService = new ClientCommitmentsSnapshotService(hinkalEventEmitter, snapshotFetcher);
+
+  hinkal.nullifierSnapshotService?.intervalClear();
+  hinkal.nullifierSnapshotService = new ClientNullifierSnapshotService(hinkalEventEmitter, snapshotFetcher);
+
+  hinkal.accessTokenSnapshotService?.intervalClear();
+  hinkal.accessTokenSnapshotService = new ClientAccessTokenSnapshotService(accessTokenEventEmitter, snapshotFetcher);
+
+  hinkal.approvalsSnapshotService?.intervalClear();
+  hinkal.approvalsSnapshotService = new ClientApprovalsSnapshotService(hinkalEventEmitter, snapshotFetcher);
+
+  await Promise.all([
+    hinkal.commitmentsSnapshotService.init(),
+    hinkal.nullifierSnapshotService.init(),
+    hinkal.accessTokenSnapshotService.init(),
+    hinkal.approvalsSnapshotService.init(),
+  ]);
+
+  await Promise.all([hinkalEventEmitter.init(), accessTokenEventEmitter.init()]);
+
+  hinkal.merkleTreeHinkal = hinkal.commitmentsSnapshotService.merkleTree;
+  hinkal.merkleTreeAccessToken = hinkal.accessTokenSnapshotService.merkleTree;
+  hinkal.nullifiers = hinkal.nullifierSnapshotService.nullifiers;
+  hinkal.encryptedOutputs = hinkal.commitmentsSnapshotService.encryptedOutputs;
+  hinkal.approvals = hinkal.approvalsSnapshotService.approvals;
+
+  hinkalEventEmitter.onEventsProcessed = (acceptedEventCount: number) => {
+    if (acceptedEventCount > 0)
+      balanceChangedCustomHandler({
+        updateType: PrivateBalanceUpdateType.FreshWithoutLoader,
+        updateTokensListBefore: true,
+      });
+  };
+};