@sabaaa1/common 0.0.1

package/src/functions/snarkjs/constructEmporiumProof.ts

@@ -0,0 +1,301 @@
+import { MerkleTree } from '../../data-structures/merkle-tree';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { defaultSignatureData, zeroAddress } from '../../constants/protocol.constants';
+import { chainIds } from '../../constants/chains.constants';
+import {
+  ZKProofWorkerActionType,
+  ZKProofWorkerBuildInNullifiersReturn,
+  ZKProofWorkerCalcAccessTokenReturn,
+  ZKProofWorkerCalcCommitmentsReturn,
+  ZKProofWorkerPayload,
+} from '../../webworker/zkProofWorker/zkProofWorker.types';
+import { performTaskWithWorker } from '../../webworker/performTaskWithWorker';
+import { WorkerVariant } from '../../webworker/worker.registry';
+import {
+  buildOutCommitments,
+  calcAmountChanges,
+  calcEncryptedOutputs,
+  calcPublicSignalCount,
+  calcStealthAddressStructure,
+  createCallDataHash,
+  getSlippageValues,
+} from './common.snarkjs';
+import { randomBigInt } from '../web3/etherFunctions';
+import { encodeEmporiumMetadata, getAuthorizationDataIfNeeded } from '../private-wallet/emporium.helpers';
+import { ExternalActionId } from '../../types/external-action.types';
+import { CircomDataBaseType, CircomDataV1x1, defaultHookData, DimDataType } from '../../types/circom-data.types';
+import { generateCircomData } from './generateCircomData';
+import { generateZkProof } from './generateZkProof';
+import { ethers } from 'ethers';
+import { getCurrentTimeInSeconds } from '../utils/time.utils';
+import {
+  AuthorizationData,
+  defaultHinkalLogicArgs,
+  FeeStructure,
+  HinkalLogicArgs,
+  type ProverVersion,
+} from '../../types/hinkal.types';
+import { generateFeeStructure } from '../utils/fees.utils';
+import {
+  createHinkalHelperFromData,
+  hinkalCheckTokenRegistry,
+} from '../../data-structures/Hinkal/hinkalCheckTokenRegistry';
+import { getPatchedAccessTokenMerkleTree } from '../../data-structures/merkle-tree/getPatchedAccessTokenMerkleTree';
+import { Logger } from '../../error-handling/logger';
+import { poseidonFunction } from '../../crypto';
+import { SubAccount } from '../../types/proxy.types';
+
+export const constructEmporiumProof = async <T = CircomDataV1x1>(
+  proverVersion: ProverVersion,
+  merkleTree: MerkleTree<bigint>,
+  merkleTreeAccessToken: MerkleTree<bigint>,
+  erc20TokenAddresses: string[],
+  tokenIds: number[],
+  inputUtxos: Utxo[][],
+  outputUtxos: Utxo[][],
+  userKeys: UserKeys,
+  tokenCount: number,
+  inputCount: number,
+  emporiumAddress: string,
+  operations: string[],
+  generateProofRemotely: boolean,
+  relay = zeroAddress,
+  chainId = chainIds.localhost,
+  onChainCreation = inputUtxos.map(() => false),
+  flatFees = inputUtxos.map(() => 0n),
+  subAccount?: SubAccount,
+  hinkalLogicArgs: HinkalLogicArgs | undefined = undefined,
+  patchAccessTokenMerkleTree = false,
+  slippageValues?: bigint[],
+  feeStructure: FeeStructure | undefined = undefined,
+  hinkalHelper?: ethers.Contract,
+  signatureData = defaultSignatureData,
+  messageSeedOverride?: bigint,
+) => {
+  const amountChanges = calcAmountChanges(inputUtxos, outputUtxos);
+
+  const encryptedOutputs = calcEncryptedOutputs(outputUtxos, false);
+
+  const shieldedPrivateKey = userKeys.getShieldedPrivateKey();
+
+  const extraRandomization = Utxo.findCorrectRandomization(randomBigInt(31), shieldedPrivateKey);
+
+  const kycRequired = await hinkalCheckTokenRegistry(
+    hinkalHelper ?? createHinkalHelperFromData(chainId),
+    erc20TokenAddresses,
+    calcAmountChanges(inputUtxos, outputUtxos, true),
+  );
+
+  const patchedMerkleTree = getPatchedAccessTokenMerkleTree(
+    merkleTreeAccessToken,
+    userKeys,
+    patchAccessTokenMerkleTree,
+    kycRequired,
+  );
+
+  Logger.log({ kycRequiredEmporium: kycRequired, patchedMerkleTree, amountChanges, erc20TokenAddresses });
+
+  const merkleTreeAccessTokenJSON = patchedMerkleTree.toJSON();
+
+  // get root hash
+  const rootHashHinkal = merkleTree.getRootHash();
+  const rootHashAccessToken = patchedMerkleTree.getRootHash();
+
+  const inputUtxosSerialized = inputUtxos.map((utxoList) => utxoList.map((utxo) => utxo.getConstructableParams()));
+  const userSignature = userKeys.getSignature();
+
+  const { accessTokenSiblings, accessTokenSiblingSides } = await performTaskWithWorker<
+    ZKProofWorkerPayload,
+    ZKProofWorkerCalcAccessTokenReturn
+  >({
+    type: WorkerVariant.ZKProof,
+    payload: {
+      type: ZKProofWorkerActionType.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES,
+      data: {
+        userSignature,
+        merkleTreeAccessTokenSerialized: merkleTreeAccessTokenJSON,
+      },
+    },
+  });
+
+  const { inCommitmentSiblings, inCommitmentSiblingSides } = await performTaskWithWorker<
+    ZKProofWorkerPayload,
+    ZKProofWorkerCalcCommitmentsReturn
+  >({
+    type: WorkerVariant.ZKProof,
+    payload: {
+      type: ZKProofWorkerActionType.CALC_COMMITMENTS_SIBLING_AND_SIDES,
+      data: { inputUtxosSerialized, userSignature, merkleTreeSerialized: merkleTree.toJSON() },
+    },
+  });
+
+  const inNullifiers = await performTaskWithWorker<ZKProofWorkerPayload, ZKProofWorkerBuildInNullifiersReturn>({
+    type: WorkerVariant.ZKProof,
+    payload: {
+      type: ZKProofWorkerActionType.BUILD_IN_NULLIFIERS,
+      data: { inputUtxosSerialized, onChainCreation, proverVersion },
+    },
+  });
+
+  const outCommitments = buildOutCommitments(proverVersion, outputUtxos, onChainCreation);
+
+  const messageSeed = messageSeedOverride ?? randomBigInt(31);
+  const message = poseidonFunction(messageSeed);
+
+  const input: any = {
+    rootHashHinkal,
+    erc20TokenAddresses,
+    tokenIds,
+    inNullifiers,
+    outTimeStamp: outputUtxos.length > 0 ? BigInt(outputUtxos[0][0].timeStamp) : getCurrentTimeInSeconds(),
+    extraRandomization,
+    amountChanges,
+    outCommitments,
+    rootHashAccessToken,
+    calldataHash: 0n,
+    shieldedPrivateKey,
+    accessTokenSiblings,
+    accessTokenSiblingSides,
+    outAmounts: outputUtxos.map((out) => out[0].amount),
+    outPublicKeys: outputUtxos.map((out) => out[0].getStealthAddress()),
+    inAmounts: inputUtxos.map((token) => token.map((utxo) => utxo.amount.toString())),
+    inTimeStamps: inputUtxos.map((token) => token.map((utxo) => utxo.timeStamp)),
+    inRandomizations: inputUtxos.map((token) => token.map((utxo) => utxo.randomization)),
+    inCommitmentSiblings,
+    inCommitmentSiblingSides,
+    messageSeed,
+  };
+
+  const signerAddress = subAccount ? UserKeys.getSignerAddressFromPrivateKey(subAccount.privateKey) : undefined;
+
+  const externalAddress = emporiumAddress;
+  const externalActionId = ExternalActionId.Emporium;
+
+  const externalActionMetadata = await encodeEmporiumMetadata(
+    chainId,
+    emporiumAddress,
+    subAccount?.privateKey,
+    operations,
+    message,
+    signerAddress,
+  );
+
+  const verifierName =
+    outputUtxos.length === 0 ? 'swapperMWMin0' : `swapperMW${tokenCount}x${inputCount}x${outputUtxos[0].length}`;
+
+  const publicSignalCount = calcPublicSignalCount(
+    verifierName,
+    input.erc20TokenAddresses,
+    input.amountChanges,
+    input.inNullifiers,
+    input.outCommitments,
+    tokenIds.length,
+  );
+
+  if (!hinkalLogicArgs) {
+    hinkalLogicArgs = defaultHinkalLogicArgs(amountChanges.length, userKeys);
+    hinkalLogicArgs.interactionAddress = '0x032f580aFFE7a5f17025fAF83c13B4277A880532';
+    hinkalLogicArgs.inHinkalAddress = userKeys.getInHinkalAddress(hinkalLogicArgs.interactionAddress);
+  }
+
+  if (proverVersion === 'v1x1') {
+    input.interactionAddress = hinkalLogicArgs.interactionAddress;
+    if (userKeys.getInHinkalAddress(input.interactionAddress) !== hinkalLogicArgs.inHinkalAddress)
+      throw new Error('inHinkalAddress mismatch');
+    input.externalApprovalAddresses =
+      hinkalLogicArgs?.useApprovalUtxoData?.map(({ externalApprovalAddresses }) => externalApprovalAddresses) ??
+      Array(tokenCount).fill([zeroAddress, zeroAddress, zeroAddress]);
+  }
+
+  if (!feeStructure) {
+    feeStructure = generateFeeStructure(flatFees, erc20TokenAddresses);
+  }
+
+  // below amountchanges with negative values (not ones with CIRCOM_P-value)
+  const amountChangesBased = calcAmountChanges(inputUtxos, outputUtxos, true);
+
+  if (!slippageValues) {
+    slippageValues = getSlippageValues(amountChangesBased, hinkalLogicArgs);
+  }
+
+  input.calldataHash = createCallDataHash(
+    proverVersion,
+    publicSignalCount,
+    relay,
+    externalAddress,
+    externalActionId,
+    externalActionMetadata,
+    encryptedOutputs,
+    flatFees,
+    undefined,
+    slippageValues,
+    onChainCreation,
+    hinkalLogicArgs,
+    feeStructure,
+    signatureData,
+  );
+
+  const swapperMWMin0Input = {
+    outTimeStamp: getCurrentTimeInSeconds(),
+    rootHashAccessToken,
+    calldataHash: input.calldataHash,
+    shieldedPrivateKey,
+    accessTokenSiblings,
+    accessTokenSiblingSides,
+    messageSeed,
+  };
+
+  const { zkCallData } = await generateZkProof(
+    proverVersion,
+    chainId,
+    verifierName,
+    verifierName === 'swapperMWMin0' ? swapperMWMin0Input : input,
+    generateProofRemotely,
+  );
+
+  const stealthAddressStructure = calcStealthAddressStructure(extraRandomization, shieldedPrivateKey);
+
+  const circomData: CircomDataBaseType = await generateCircomData(
+    proverVersion,
+    outCommitments,
+    inNullifiers,
+    rootHashHinkal,
+    rootHashAccessToken,
+    amountChangesBased,
+    erc20TokenAddresses,
+    inputUtxos,
+    outputUtxos,
+    encryptedOutputs,
+    flatFees,
+    publicSignalCount,
+    externalActionId,
+    externalAddress,
+    externalActionMetadata,
+    relay,
+    input.calldataHash,
+    tokenIds,
+    stealthAddressStructure,
+    onChainCreation,
+    defaultHookData,
+    verifierName === 'swapperMWMin0' ? swapperMWMin0Input.outTimeStamp : input.outTimeStamp, // although these variables seem to contain the same value, there can actually be a single second difference if the timing is unlucky
+    hinkalLogicArgs,
+    slippageValues,
+    feeStructure,
+    signatureData,
+  );
+
+  // Logger.log('circomdata in emporium proof', { circomData });
+  const dimData: DimDataType = {
+    tokenNumber: inputUtxos.length,
+    nullifierAmount: inputUtxos.length > 0 ? inputUtxos[0].length : 0,
+    outputAmount: outputUtxos.length > 0 ? outputUtxos[0].length : 0,
+  };
+
+  const authorizationData: AuthorizationData | undefined = await getAuthorizationDataIfNeeded(
+    chainId,
+    subAccount?.privateKey,
+  );
+
+  return { zkCallData, circomData: <T>circomData, dimData, encryptedOutputs, authorizationData };
+};

package/src/functions/snarkjs/constructGeneralZkProof.ts

@@ -0,0 +1,281 @@
+import { chainIds } from '../../constants/chains.constants';
+import { defaultSignatureData, zeroAddress } from '../../constants/protocol.constants';
+
+import { MerkleTree } from '../../data-structures/merkle-tree';
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+
+import { CircomDataBaseType, CircomDataV1x1, DimDataType, HookDataType } from '../../types/circom-data.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { HinkalStakeMode, StakeArgs } from '../../types/hinkal.stake.types';
+
+import { performTaskWithWorker } from '../../webworker/performTaskWithWorker';
+import { WorkerVariant } from '../../webworker/worker.registry';
+import {
+  ZKProofWorkerActionType,
+  ZKProofWorkerBuildInNullifiersReturn,
+  ZKProofWorkerCalcAccessTokenReturn,
+  ZKProofWorkerCalcCommitmentsReturn,
+  ZKProofWorkerPayload,
+} from '../../webworker/zkProofWorker/zkProofWorker.types';
+import { randomBigInt } from '../web3/etherFunctions';
+import {
+  buildOutCommitments,
+  calcAmountChanges,
+  calcEncryptedOutputs,
+  calcPublicSignalCount,
+  calcStealthAddressStructure,
+  createCallDataHash,
+  getSlippageValues,
+} from './common.snarkjs';
+import { generateCircomData } from './generateCircomData';
+import { generateZkProof } from './generateZkProof';
+import { getPatchedAccessTokenMerkleTree } from '../../data-structures/merkle-tree/getPatchedAccessTokenMerkleTree';
+import { defaultHinkalLogicArgs, FeeStructure, HinkalLogicArgs, ProverVersion } from '../../types/hinkal.types';
+import { generateFeeStructure } from '../utils/fees.utils';
+import {
+  createHinkalHelperFromData,
+  hinkalCheckTokenRegistry,
+} from '../../data-structures/Hinkal/hinkalCheckTokenRegistry';
+import { Logger } from '../../error-handling/logger';
+import { ethers } from 'ethers';
+
+export const constructZkProof = async <T = CircomDataV1x1>(
+  proverVersion: ProverVersion,
+  merkleTree: MerkleTree<bigint>,
+  merkleTreeAccessToken: MerkleTree<bigint>,
+  inputUtxos: Utxo[][],
+  outputUtxos: Utxo[][],
+  userKeys: UserKeys,
+  verifierName: string,
+  externalActionId: ExternalActionId | 0n,
+  externalAddress: string | undefined,
+  externalActionMetadata: string,
+  generateProofRemotely: boolean,
+  relay = zeroAddress,
+  chainId = chainIds.localhost,
+  onChainCreation = inputUtxos.map(() => false),
+  flatFees = inputUtxos.map(() => 0n),
+  hookData: HookDataType | undefined = undefined,
+  stakeArgs?: StakeArgs,
+  patchAccessTokenMerkleTree = false,
+  hinkalLogicArgs: HinkalLogicArgs | undefined = undefined,
+  slippageValues?: bigint[],
+  feeStructure: FeeStructure | undefined = undefined,
+  // performance optimization, if we use hinkalHelper from `hinkal.getContractWithFetcher` it will be faster than creating a new JsonRpcProvider
+  hinkalHelper?: ethers.Contract,
+  signatureData = defaultSignatureData,
+) => {
+  //  amount changes and encrypted outputs
+  const amountChanges = calcAmountChanges(inputUtxos, outputUtxos);
+  const erc20TokenAddresses = inputUtxos.map((utxo) => utxo[0].erc20TokenAddress);
+  const encryptedOutputs = calcEncryptedOutputs(
+    outputUtxos,
+    (stakeArgs && stakeArgs.mode !== HinkalStakeMode.Deposit) ?? false,
+  );
+
+  const shieldedPrivateKey = userKeys.getShieldedPrivateKey();
+
+  const extraRandomization = Utxo.findCorrectRandomization(randomBigInt(31), shieldedPrivateKey);
+
+  const kycRequired = await hinkalCheckTokenRegistry(
+    hinkalHelper ?? createHinkalHelperFromData(chainId),
+    erc20TokenAddresses,
+    calcAmountChanges(inputUtxos, outputUtxos, true),
+  );
+
+  const patchedMerkleTree = getPatchedAccessTokenMerkleTree(
+    merkleTreeAccessToken,
+    userKeys,
+    patchAccessTokenMerkleTree,
+    kycRequired,
+  );
+  // get root hash
+  const rootHashAccessToken = patchedMerkleTree.getRootHash();
+  const merkleTreeAccessTokenJSON = patchedMerkleTree.toJSON();
+  const rootHashHinkal = merkleTree.getRootHash();
+
+  const inputUtxosSerialized = inputUtxos.map((utxoList) => utxoList.map((utxo) => utxo.getConstructableParams()));
+  const userSignature = userKeys.getSignature();
+
+  const { accessTokenSiblings, accessTokenSiblingSides } = await performTaskWithWorker<
+    ZKProofWorkerPayload,
+    ZKProofWorkerCalcAccessTokenReturn
+  >({
+    type: WorkerVariant.ZKProof,
+    payload: {
+      type: ZKProofWorkerActionType.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES,
+      data: {
+        userSignature,
+        merkleTreeAccessTokenSerialized: merkleTreeAccessTokenJSON,
+      },
+    },
+  });
+
+  const { inCommitmentSiblings, inCommitmentSiblingSides } = await performTaskWithWorker<
+    ZKProofWorkerPayload,
+    ZKProofWorkerCalcCommitmentsReturn
+  >({
+    type: WorkerVariant.ZKProof,
+    payload: {
+      type: ZKProofWorkerActionType.CALC_COMMITMENTS_SIBLING_AND_SIDES,
+      data: { inputUtxosSerialized, userSignature, merkleTreeSerialized: merkleTree.toJSON() },
+    },
+  });
+
+  const inNullifiers = await performTaskWithWorker<ZKProofWorkerPayload, ZKProofWorkerBuildInNullifiersReturn>({
+    type: WorkerVariant.ZKProof,
+    payload: {
+      type: ZKProofWorkerActionType.BUILD_IN_NULLIFIERS,
+      data: { inputUtxosSerialized, onChainCreation, proverVersion },
+    },
+  });
+
+  const outCommitments = buildOutCommitments(proverVersion, outputUtxos, onChainCreation);
+
+  const input: any = {
+    rootHashHinkal,
+    shieldedPrivateKey,
+    erc20TokenAddresses,
+    inAmounts: inputUtxos.map((token) => token.map((utxo) => utxo.amount.toString())),
+    inTimeStamps: inputUtxos.map((token) => token.map((utxo) => utxo.timeStamp)),
+    inRandomizations: inputUtxos.map((token) => token.map((utxo) => utxo.randomization)),
+    inNullifiers,
+    inCommitmentSiblings,
+    inCommitmentSiblingSides,
+    outAmounts: outputUtxos.map((token) => token.map((utxo) => utxo.amount.toString())),
+    outTimeStamp: BigInt(outputUtxos[0][0].timeStamp),
+    outPublicKeys: outputUtxos.map((token) => token.map((utxo) => utxo.getStealthAddress())),
+    extraRandomization,
+    amountChanges,
+    outCommitments,
+    rootHashAccessToken,
+    accessTokenSiblings,
+    accessTokenSiblingSides,
+    calldataHash: 0n,
+  };
+
+  // case with NFTs
+  const tokenIds = inputUtxos.map((utxos) => utxos[0].tokenId ?? 0);
+  const tokenIdsPositive = tokenIds.reduce((prev, cur) => prev + cur, 0) > 0 ? tokenIds.length : 0;
+  if (tokenIdsPositive > 0) input.tokenIds = tokenIds;
+
+  const publicSignalCount = calcPublicSignalCount(
+    verifierName,
+    input.erc20TokenAddresses,
+    input.amountChanges,
+    input.inNullifiers,
+    input.outCommitments,
+    tokenIdsPositive,
+  );
+
+  if (!hinkalLogicArgs) {
+    hinkalLogicArgs = defaultHinkalLogicArgs(amountChanges.length, userKeys);
+    hinkalLogicArgs.interactionAddress = externalAddress ?? zeroAddress;
+    const inHinkalAddress = userKeys.getInHinkalAddress(hinkalLogicArgs.interactionAddress);
+    hinkalLogicArgs.inHinkalAddress = inHinkalAddress;
+  }
+
+  if (proverVersion === 'v1x1') {
+    input.interactionAddress = hinkalLogicArgs?.interactionAddress ?? externalAddress ?? zeroAddress;
+    // sanity check to avoid confusing invalid proof errors
+    if (userKeys.getInHinkalAddress(input.interactionAddress) !== hinkalLogicArgs.inHinkalAddress)
+      throw new Error('inHinkalAddress mismatch');
+    input.externalApprovalAddresses = hinkalLogicArgs.useApprovalUtxoData?.map(
+      ({ externalApprovalAddresses }) => externalApprovalAddresses,
+    ) ?? [zeroAddress, zeroAddress, zeroAddress];
+  }
+
+  if (!feeStructure) {
+    feeStructure = generateFeeStructure(
+      flatFees,
+      inputUtxos.map((inputUtxoList) => inputUtxoList[0].erc20TokenAddress),
+    );
+  }
+
+  // below amountchanges with negative values (not ones with CIRCOM_P-value)
+  const amountChangesBased = calcAmountChanges(inputUtxos, outputUtxos, true);
+
+  if (!slippageValues) {
+    slippageValues = getSlippageValues(amountChangesBased, hinkalLogicArgs);
+  }
+
+  Logger.log({ publicSignalCount });
+
+  input.calldataHash = createCallDataHash(
+    proverVersion,
+    publicSignalCount,
+    relay,
+    externalAddress,
+    externalActionId,
+    externalActionMetadata,
+    encryptedOutputs,
+    flatFees,
+    hookData,
+    slippageValues,
+    onChainCreation,
+    hinkalLogicArgs,
+    feeStructure,
+    signatureData,
+  );
+
+  if (stakeArgs) {
+    if (stakeArgs.mode === HinkalStakeMode.Deposit) input.mode = 0;
+    if (stakeArgs.mode === HinkalStakeMode.Stake) input.mode = 1;
+    if (stakeArgs.mode === HinkalStakeMode.Unstake) input.mode = 2;
+    input.stakedTokenRecipient = stakeArgs.stakedTokenRecipient;
+    input.stakeBlinding = stakeArgs.stakeBlinding;
+    input.depositorAddress = stakeArgs.depositorAddress;
+  }
+
+  const { zkCallData, publicSignals } = await generateZkProof(
+    proverVersion,
+    chainId,
+    verifierName,
+    input,
+    generateProofRemotely,
+  );
+
+  Logger.log({ publicSignals });
+
+  const stealthAddressStructure = calcStealthAddressStructure(extraRandomization, shieldedPrivateKey);
+
+  const circomData: CircomDataBaseType = await generateCircomData(
+    proverVersion,
+    outCommitments,
+    inNullifiers,
+    rootHashHinkal,
+    rootHashAccessToken,
+    amountChangesBased,
+    erc20TokenAddresses,
+    inputUtxos,
+    outputUtxos,
+    encryptedOutputs,
+    flatFees,
+    publicSignalCount,
+    externalActionId,
+    externalAddress,
+    externalActionMetadata,
+    relay,
+    input.calldataHash,
+    tokenIds,
+    stealthAddressStructure,
+    onChainCreation,
+    hookData,
+    undefined,
+    hinkalLogicArgs,
+    slippageValues,
+    feeStructure,
+    signatureData,
+  );
+
+  Logger.log({ circomData });
+
+  const dimData: DimDataType = {
+    tokenNumber: inputUtxos.length,
+    nullifierAmount: inputUtxos[0].length,
+    outputAmount: outputUtxos[0].length,
+  };
+
+  return { zkCallData, circomData: <T>circomData, dimData, encryptedOutputs };
+};

package/src/functions/snarkjs/generateCircomData.ts

@@ -0,0 +1,81 @@
+import { FeeStructure, HinkalLogicArgs, ProverVersion } from '../../types/hinkal.types';
+import { defaultSignatureData, zeroAddress } from '../../constants/protocol.constants';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+
+import {
+  CircomDataBaseType,
+  CircomDataV1,
+  CircomDataV1x1,
+  defaultHookData,
+  HookDataType,
+  StealthAddressStructure,
+} from '../../types/circom-data.types';
+import { ExternalActionId } from '../../types/external-action.types';
+
+import { getExternalActionIdHash } from '../utils/external-action.utils';
+import { getOriginalSender } from './getOriginalSender';
+
+export const generateCircomData = async (
+  proverVersion: ProverVersion,
+  outCommitments: string[][],
+  inputNullifiers: string[][],
+  rootHashHinkal: bigint | undefined,
+  rootHashAccessToken: bigint | undefined,
+  amountChanges: bigint[],
+  erc20TokenAddresses: string[],
+  inputUtxos: Utxo[][],
+  outputUtxos: Utxo[][],
+  encryptedOutputs: string[][],
+  flatFees: bigint[],
+  publicSignalCount: number,
+  externalActionId: ExternalActionId | bigint,
+  externalAddress: string | undefined,
+  externalActionMetadata: string,
+  relay: string,
+  calldataHash: bigint,
+  tokenIds: number[],
+  stealthAddressStructure: StealthAddressStructure,
+  onChainCreation: boolean[],
+  hookData: HookDataType | undefined,
+  timeStampFallback: number | undefined,
+  hinkalLogicArgs: HinkalLogicArgs,
+  slippageValues: bigint[],
+  feeStructure: FeeStructure,
+  signatureData = defaultSignatureData,
+): Promise<CircomDataBaseType> => {
+  const circomData: CircomDataBaseType = {
+    rootHashHinkal,
+    erc20TokenAddresses,
+    tokenIds: tokenIds.map((tokenId) => String(tokenId)),
+    amountChanges,
+    inputNullifiers,
+    outCommitments,
+    encryptedOutputs,
+    timeStamp: outputUtxos.length > 0 ? outputUtxos[0][0].timeStamp : String(timeStampFallback ?? ''),
+    stealthAddressStructure,
+    rootHashAccessToken,
+    relay,
+    externalAddress: externalAddress === undefined ? zeroAddress : externalAddress,
+    externalActionMetadata,
+    externalActionId: typeof externalActionId === 'bigint' ? 0n : getExternalActionIdHash(externalActionId),
+    hookData: hookData || defaultHookData,
+    publicSignalCount,
+    calldataHash,
+  };
+  if (proverVersion === 'v1x0') {
+    const circomDataV1 = circomData as CircomDataV1;
+    circomDataV1.flatFees = flatFees;
+    return circomDataV1;
+  } else {
+    const circomDataV1x1 = circomData as CircomDataV1x1;
+    circomDataV1x1.onChainCreation = onChainCreation;
+    circomDataV1x1.slippageValues = slippageValues;
+    const newHinkalLogicArgs = structuredClone(hinkalLogicArgs);
+    if ('interactionAddress' in newHinkalLogicArgs) delete newHinkalLogicArgs.interactionAddress;
+    circomDataV1x1.hinkalLogicArgs = newHinkalLogicArgs;
+    circomDataV1x1.feeStructure = feeStructure;
+    circomDataV1x1.signatureData = signatureData;
+    circomDataV1x1.originalSender = getOriginalSender(externalAddress ?? zeroAddress, relay);
+    return circomDataV1x1;
+  }
+};

package/src/functions/snarkjs/generateZkProof.ts

@@ -0,0 +1,21 @@
+import { Logger } from '../../error-handling/logger';
+import { NewZkCallDataType, ProverVersion } from '../../types';
+import { generateZkProofEnclave } from './generateZkProofEnclave';
+import { generateZkProofSelf } from './generateZkProofSelf';
+
+export const generateZkProof = async (
+  proverVersion: ProverVersion,
+  chainId: number,
+  verifierName: string,
+  input: any,
+  remotely?: boolean,
+): Promise<{ zkCallData: NewZkCallDataType; publicSignals: string[] }> => {
+  if (remotely) {
+    try {
+      return await generateZkProofEnclave(proverVersion, chainId, verifierName, input);
+    } catch (err) {
+      Logger.error('enclave proof error', err);
+    }
+  }
+  return generateZkProofSelf(proverVersion, chainId, verifierName, input);
+};