@sabaaa1/common 0.0.1

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

@@ -0,0 +1,315 @@
+// Types
+import {
+  ApprovedUtxo,
+  ApprovedUtxoWithInteractionAddress,
+  FeeStructure,
+  type ParsedInLogicMetadata,
+} from '../../types/hinkal.types';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { type IMultiThreadedUtxoUtils } from '../../types/IMultiThreadedUtxoUtils';
+import { RelayerTransaction } from '../../types/relayer.types';
+import { SignatureData } from '../../types/crypto.types';
+import { ERC20Token, TokenBalance, TokenChanges } from '../../types/token.types';
+
+import { Bytes, ethers } from 'ethers';
+import { type UserKeys } from '../crypto-keys/keys';
+import { IProviderAdapter } from '../provider-adapter/IProviderAdapter';
+import { ClientAccessTokenSnapshotService } from '../snapshot/ClientAccessTokenSnapshotService';
+import { ClientCommitmentsSnapshotService } from '../snapshot/ClientCommitmentsSnapshotService';
+import { ClientNullifierSnapshotService } from '../snapshot/ClientNullifierSnapshotService';
+import { ClientApprovalsSnapshotService } from '../snapshot/ClientApprovalsSnapshotService';
+
+import { MerkleTree } from '../merkle-tree';
+import { IAPI } from '../../API/API';
+import { type ICacheDevice } from '../../types/ICacheDevice';
+import type { StealthAddressStructure, TypedData } from '../../types/circom-data.types';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '@hinkal/common/types';
+
+export interface IHinkal<ConnectorType = unknown> {
+  userKeys: UserKeys;
+
+  readonly signingMessage: string;
+
+  merkleTreeHinkal: MerkleTree<bigint>;
+
+  merkleTreeAccessToken: MerkleTree<bigint>;
+
+  nullifiers: Set<string>;
+
+  encryptedOutputs: EncryptedOutputWithSign[];
+
+  approvals: Map<string, ApprovedUtxo[]>;
+
+  commitmentsSnapshotService?: ClientCommitmentsSnapshotService;
+
+  nullifierSnapshotService?: ClientNullifierSnapshotService;
+
+  accessTokenSnapshotService?: ClientAccessTokenSnapshotService;
+
+  approvalsSnapshotService?: ClientApprovalsSnapshotService;
+
+  generateProofRemotely: boolean;
+
+  utxoUtils: IMultiThreadedUtxoUtils;
+
+  cacheDevice: ICacheDevice;
+
+  getBalances(
+    chainId: number,
+    passedShieldedPrivateKey: string,
+    passedShieldedPublicKey: string,
+    ethAddress: string,
+    resetCacheBefore?: boolean,
+    updateTokensListBefore?: boolean,
+  ): Promise<Map<string, TokenBalance>>;
+
+  getApprovedBalances(resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<Map<string, TokenBalance>>;
+
+  getTotalBalance(
+    chainId?: number,
+    userKeys?: UserKeys,
+    ethAddress?: string,
+    resetCacheBefore?: boolean,
+    updateTokensListBefore?: boolean,
+  ): Promise<TokenBalance[]>;
+
+  getSupportedPassportLinks(): string[];
+
+  checkAccessToken(): Promise<boolean>;
+
+  getEthereumAddress(): Promise<string>;
+
+  resetMerkleTreesIfNecessary(): Promise<void>;
+
+  resetMerkle(): Promise<void>;
+
+  getEventsFromHinkal(): Promise<void>;
+
+  mintHinkalAccessToken(signatureData: SignatureData, fromWallet?: boolean): Promise<ethers.ContractTransaction>;
+
+  getRandomRelay(markAsPending?: boolean): Promise<string | undefined>;
+
+  getGasPrice(): Promise<bigint>;
+
+  getAPI(): IAPI;
+
+  resetCache(): void;
+
+  snapshotsClearInterval(): void;
+
+  checkTokenRegistry(erc20Addresses: string[], amountChanges: bigint[]): Promise<boolean>;
+
+  getRecipientInfo(extendedInfo?: boolean): string;
+
+  getInteractionApprovals(interactionAddress: string): Promise<ApprovedUtxo[]>;
+
+  getApprovedUtxos(resetCacheBefore?: boolean): ApprovedUtxoWithInteractionAddress[];
+
+  getApprovedUtxosForToken(erc20Address: string, resetCacheBefore?: boolean): ApprovedUtxoWithInteractionAddress[];
+
+  getMyApprovalAmountForInteraction(interactionAddress: string, tokenAddress: string): bigint;
+
+  checkExistingApprovalFromHinkal(erc20Address: string, interactionAddress: string): Promise<bigint>;
+
+  getBufferEntry(approveTo: string, tokenAddress: string, inHinkalAddress: bigint): Promise<bigint>;
+
+  deposit(erc20Tokens: ERC20Token[], amountChanges: bigint[]): Promise<ethers.ContractTransaction>;
+
+  depositForOther(
+    erc20Tokens: ERC20Token[],
+    amountChanges: bigint[],
+    recepinetInfo: string,
+  ): Promise<ethers.ContractTransaction>;
+
+  prooflessDeposit(
+    erc20Tokens: ERC20Token[],
+    amountChanges: bigint[],
+    stealthAddressStructures?: StealthAddressStructure[],
+  ): Promise<ethers.ContractTransaction>;
+
+  transfer(
+    erc20Tokens: ERC20Token[],
+    amountChanges: bigint[],
+    recipientAddress: string,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+    action?: AdminTransactionType,
+    onlyGasEstimate?: boolean,
+  ): Promise<RelayerTransaction | bigint>;
+
+  withdraw(
+    erc20Tokens: ERC20Token[],
+    deltaAmounts: bigint[],
+    recipientAddress: string,
+    isRelayerOff: boolean,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+    action?: AdminTransactionType,
+    onlyGasEstimate?: boolean,
+  ): Promise<ethers.ContractTransaction | RelayerTransaction | bigint>;
+
+  swap(
+    erc20Tokens: ERC20Token[],
+    deltaAmounts: bigint[],
+    externalActionId: ExternalActionId,
+    swapData: string,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+    action?: AdminTransactionType,
+    onlyGasEstimate?: boolean,
+    withPrivateMempool?: boolean,
+  ): Promise<RelayerTransaction | bigint>;
+
+  getProviderAdapter(): IProviderAdapter;
+
+  initUserKeys(): Promise<void>;
+
+  initUserKeysWithPassword(password: string): Promise<void>;
+
+  initProviderAdapter(connector: ConnectorType, providerAdapter: IProviderAdapter<ConnectorType>): Promise<void>;
+
+  connectAndPatchProvider(connector: ConnectorType): Promise<number>;
+
+  disconnectFromConnector(): Promise<void>;
+
+  updateProviderAdapter(providerAdapter: IProviderAdapter): Promise<void>;
+
+  setListeners(providerAdapter: IProviderAdapter): Promise<void>;
+
+  waitForTransaction(transactionHash: string, confirmations?: number): Promise<boolean>;
+
+  getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+
+  getContract(contract: ContractType, contractAddress?: string, chainId?: number): ethers.Contract;
+
+  getContractWithSigner(contract: ContractType, contractAddress?: string): ethers.Contract;
+
+  getContractWithFetcher(contract: ContractType, contractAddress?: string): ethers.Contract;
+
+  getContractWithFetcherByChainId(
+    chainId: number,
+    contractType: ContractType,
+    contractAddress?: string,
+  ): ethers.Contract;
+
+  getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: string): ethers.Contract;
+
+  isSelectedNetworkSupported(): boolean;
+
+  switchNetwork(network: EthereumNetwork): Promise<unknown>;
+
+  switchAccount(signer: ethers.Signer): Promise<unknown>;
+
+  getCurrentChainId(): number;
+
+  monitorConnectedAddress(): Promise<void>;
+
+  getSelectedNetwork(): EthereumNetwork | undefined;
+
+  isPermitterAvailable(): boolean;
+
+  signMessage(message: Bytes | string): Promise<string>;
+
+  signTypedData(
+    domain: ethers.TypedDataDomain,
+    types: Record<string, ethers.TypedDataField[]>,
+    value: Record<string, unknown>,
+  ): Promise<string>;
+
+  signWithSubAccount(
+    messageToSign: string | undefined,
+    typedData: TypedData | undefined,
+    subAccount: SubAccount,
+  ): Promise<string>;
+
+  actionFundApproveAndTransact(
+    tokenChanges: TokenChanges<bigint>[],
+    subAccount: SubAccount,
+    spenderAddress?: string,
+    to?: string,
+    callDataString?: string,
+    value?: bigint,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+    autoDepositBack?: boolean,
+    maxGasInDollar?: string,
+    action?: AdminTransactionType,
+    onlyGasEstimate?: boolean,
+  ): Promise<RelayerTransaction | bigint>;
+
+  actionPrivateWallet(
+    erc20Addresses: string[],
+    deltaAmounts: bigint[],
+    onChainCreation: boolean[],
+    ops: string[],
+    emporiumTokenChanges: TokenChanges<bigint>[],
+    subAccount: SubAccount,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+    relayOverride?: string,
+    autoDepositBack?: boolean,
+    maxGasInDollar?: string,
+    action?: AdminTransactionType,
+    onlyGasEstimate?: boolean,
+  ): Promise<RelayerTransaction | bigint>;
+
+  actionReceive(
+    erc20Tokens: ERC20Token[],
+    deltaAmounts: bigint[],
+    feeTokens?: string,
+    feeStructureOverride?: FeeStructure,
+    subAccount?: SubAccount,
+    action?: AdminTransactionType,
+    onlyGasEstimate?: boolean,
+  ): Promise<RelayerTransaction | bigint>;
+
+  approve(
+    erc20Addresses: string[],
+    amount: bigint,
+    approvedTo: string,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+    onlyGasEstimate?: boolean,
+  ): Promise<RelayerTransaction | bigint>;
+
+  hinkalInsideTransact(
+    erc20Addresses: string[],
+    deltaChanges: bigint[],
+    approvalChanges: bigint[],
+    externalAddress: string,
+    externalActionMetadata: string,
+    parsedInLogicMetadata: ParsedInLogicMetadata,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+    action?: AdminTransactionType,
+    onlyGasEstimate?: boolean,
+  ): Promise<RelayerTransaction | bigint>;
+
+  proxySwap(
+    erc20Tokens: ERC20Token[],
+    deltaAmounts: bigint[],
+    externalActionId: ExternalActionId,
+    swapData: string,
+    isTheSameChainSwap: boolean,
+    subAccount: SubAccount,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+    autoDepositBack?: boolean,
+    maxGasInDollar?: string,
+    action?: AdminTransactionType,
+    onlyGasEstimate?: boolean,
+  ): Promise<RelayerTransaction | bigint>;
+
+  multiSendPrivateRecipients(
+    erc20Tokens: ERC20Token[],
+    amounts: bigint[],
+    extendedRecipientInfos?: string[],
+  ): Promise<ethers.ContractTransaction>;
+
+  areMerkleTreeUpdatesDisabled(): boolean;
+
+  updateMerkleTreeUpdates(value: boolean): void;
+}

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

@@ -0,0 +1,138 @@
+import { API } from '../../API/API';
+import { networkRegistry } from '../../constants/chains.constants';
+import { getErrorMessageFromSandboxRequest } from '../../error-handling/get-error.message';
+import { TokenChanges } from '../../types/token.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { TransactionStatus } from '../../types/transactions.types';
+import { SandboxRequestType } from '../../types/sandbox.types';
+import { createTransaferEmporiumOpsBatch } from '../../functions/private-wallet';
+import {
+  caseInsensitiveEqual,
+  convertEmporiumOpToCallInfo,
+  createTorRpcProvider,
+  getERC20Token,
+  getPublicBalance,
+  postToOffscreen,
+} from '../../functions/utils';
+import { getAmountInToken } from '../../functions/web3';
+import { getFeeStructure } from '../../functions/pre-transaction/getFeeStructure';
+import { modifyVolatileTokenAmountChanges } from '../../functions/pre-transaction/getVolatileTransferAmount';
+import { IHinkal } from './IHinkal';
+import { Logger } from '../../error-handling/logger';
+import { MessagesFromOffscreen } from '../../types/offscreen.types';
+import { gasErrorCodes } from '../../error-handling';
+import { SubAccount } from '../../types/proxy.types';
+import { CircomDataV1x1 } from '../../types';
+
+export const handleAutoDepositBack = async (
+  hinkal: IHinkal,
+  walletAddress: string | undefined,
+  subAccount: SubAccount,
+  feeToken: string | undefined,
+  maxGasInDollar: string | undefined,
+  emporiumTokenChanges: TokenChanges<bigint>[],
+  circomData: CircomDataV1x1,
+) => {
+  if (!walletAddress) return;
+  try {
+    const chainId = hinkal.getCurrentChainId();
+
+    const tokensToDepositBack = emporiumTokenChanges
+      .filter((tc) => !caseInsensitiveEqual(tc.token.erc20TokenAddress, feeToken))
+      .map((tc) => tc.token);
+
+    if (!tokensToDepositBack.length) return;
+
+    const { fetchRpcUrl } = networkRegistry[chainId];
+    if (!fetchRpcUrl) throw new Error(`No RPC URL configured for chain ${chainId}`);
+
+    const providerAdapter = createTorRpcProvider(fetchRpcUrl);
+
+    const amounts: bigint[] = await Promise.all(
+      tokensToDepositBack.map(async (token) => {
+        const balance = await getPublicBalance(providerAdapter as any, walletAddress, token);
+        return BigInt(balance?.balance || 0);
+      }),
+    );
+
+    const erc20Addresses = tokensToDepositBack.map(({ erc20TokenAddress }) => erc20TokenAddress);
+
+    const deltaAmounts = await modifyVolatileTokenAmountChanges(chainId, tokensToDepositBack, amounts, walletAddress);
+
+    const transferOps = createTransaferEmporiumOpsBatch(hinkal, erc20Addresses, deltaAmounts);
+
+    const feeStructure = await getFeeStructure(
+      chainId,
+      feeToken,
+      erc20Addresses,
+      ExternalActionId.Emporium,
+      transferOps.map((transferOp) => convertEmporiumOpToCallInfo(transferOp, walletAddress, chainId)),
+    );
+
+    const erc20FeeToken = getERC20Token(feeStructure.feeToken, chainId);
+    if (!erc20FeeToken) return;
+    const gasAmount = getAmountInToken(erc20FeeToken, feeStructure.flatFee);
+
+    const tokenPrice = await API.getTokenPrice(chainId, erc20FeeToken.erc20TokenAddress);
+    const gasFeeInDollar = tokenPrice.price * Number(gasAmount);
+
+    if (maxGasInDollar && +maxGasInDollar < gasFeeInDollar) {
+      postToOffscreen(MessagesFromOffscreen.AutoShieldTxStatus, {
+        message: gasErrorCodes.GAS_PRICE_EXCEEDS_AUTOSHIELD_LIMIT,
+      });
+
+      return;
+    }
+    postToOffscreen(MessagesFromOffscreen.AutoShieldTxStatus, { status: TransactionStatus.Loading });
+
+    const outCommitments = circomData.outCommitments?.flat();
+    const encryptedOutputs = circomData.encryptedOutputs?.flat();
+    const inputNullifiers = circomData.inputNullifiers?.flat();
+
+    const merkleTreeStartIndex = hinkal.merkleTreeHinkal.getStartIndex();
+    const merkleTreeCount = BigInt(hinkal.merkleTreeHinkal.toJSON().count);
+
+    const updateHinkal = outCommitments.length !== 0 || encryptedOutputs.length !== 0 || inputNullifiers.length !== 0;
+
+    if (updateHinkal) {
+      if (outCommitments.length !== 0) {
+        outCommitments.forEach((commitment) => {
+          if (commitment === '0' || commitment === '0x') {
+            return;
+          }
+          hinkal.merkleTreeHinkal.insert(BigInt(commitment), merkleTreeStartIndex + merkleTreeCount);
+        });
+      }
+      if (encryptedOutputs.length !== 0) {
+        encryptedOutputs.forEach((encryptedOutput) => {
+          if (encryptedOutput === '0' || encryptedOutput === '0x') {
+            return;
+          }
+          hinkal.encryptedOutputs.push({
+            value: encryptedOutput,
+            isPositive: true,
+          });
+        });
+      }
+      if (inputNullifiers.length !== 0) {
+        inputNullifiers.forEach((inputNullifier) => {
+          if (inputNullifier === '0' || inputNullifier === '0x') {
+            return;
+          }
+          hinkal.nullifiers.add(inputNullifier);
+        });
+      }
+      hinkal.updateMerkleTreeUpdates(false);
+    }
+
+    await hinkal.actionReceive(tokensToDepositBack, amounts, feeStructure?.feeToken, undefined, subAccount);
+
+    postToOffscreen(MessagesFromOffscreen.AutoShieldTxStatus, { status: TransactionStatus.Confirmed });
+  } catch (error) {
+    postToOffscreen(MessagesFromOffscreen.AutoShieldTxStatus, {
+      status: TransactionStatus.Failed,
+      error: getErrorMessageFromSandboxRequest(error, SandboxRequestType.ReceiveFromShieldedAccount),
+    });
+    Logger.error('Error in auto deposit back:', error);
+  }
+};

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

@@ -0,0 +1,64 @@
+import { FeeStructure } from '../../types/hinkal.types';
+import { getNecessaryAssetsForFunding } from '../../functions/utils/walletBalances.utils';
+import { generateFundApproveAndTransactOps } from '../../functions/private-wallet/emporium.helpers';
+import { RelayerTransaction } from '../../types/relayer.types';
+import { IHinkal } from './IHinkal';
+import { TokenChanges } from '../../types/token.types';
+import { UserKeys } from '../crypto-keys/keys';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+
+export const hinkalActionFundApproveAndTransact = async (
+  hinkal: IHinkal,
+  tokenChanges: TokenChanges<bigint>[],
+  subAccount: SubAccount,
+  spenderAddress?: string,
+  to?: string,
+  callDataString?: string,
+  value?: bigint,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+  autoDepositBack?: boolean,
+  maxGasInDollar?: string,
+  action?: AdminTransactionType,
+  onlyGasEstimate?: boolean,
+): Promise<RelayerTransaction | bigint> => {
+  const walletAddress = UserKeys.getSignerAddressFromPrivateKey(subAccount.privateKey);
+
+  const { fundAmounts, tokensToFund, approveTokenAddresses, approvedTokenAmounts } = await getNecessaryAssetsForFunding(
+    hinkal,
+    walletAddress,
+    tokenChanges,
+  );
+
+  const erc20AddressesToFund = tokensToFund.map((token) => token.erc20TokenAddress);
+
+  const emporiumOps = generateFundApproveAndTransactOps(
+    hinkal,
+    erc20AddressesToFund,
+    fundAmounts,
+    approveTokenAddresses,
+    approvedTokenAmounts,
+    walletAddress,
+    spenderAddress,
+    to,
+    callDataString,
+    value,
+  );
+
+  return hinkal.actionPrivateWallet(
+    erc20AddressesToFund,
+    fundAmounts.map((amount) => -1n * amount), // deltaAmounts
+    erc20AddressesToFund.map(() => false), // onChainCreation
+    emporiumOps,
+    tokenChanges,
+    subAccount,
+    feeToken,
+    feeStructureOverride,
+    undefined,
+    autoDepositBack,
+    maxGasInDollar,
+    action,
+    onlyGasEstimate,
+  );
+};

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

@@ -0,0 +1,65 @@
+import { createTransaferEmporiumOpsBatch } from '../../functions/private-wallet/emporium.helpers';
+import { RelayerTransaction } from '../../types/relayer.types';
+import { IHinkal } from './IHinkal';
+import { getFeeStructure } from '../../functions/pre-transaction/getFeeStructure';
+import { convertEmporiumOpToCallInfo } from '../../functions/utils/convertEmporiumOpToCallInfo';
+import { ExternalActionId } from '../../types/external-action.types';
+import { FeeStructure } from '../../types/hinkal.types';
+import { ERC20Token } from '../../types/token.types';
+import { modifyVolatileTokenAmountChanges } from '../../functions/pre-transaction/getVolatileTransferAmount';
+import { UserKeys } from '../crypto-keys/keys';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+
+export const hinkalActionReceive = async (
+  hinkal: IHinkal,
+  erc20Tokens: ERC20Token[],
+  deltaAmountsBase: bigint[], // should be positive
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+  subAccount?: SubAccount,
+  action?: AdminTransactionType,
+  onlyGasEstimate = false,
+): Promise<RelayerTransaction | bigint> => {
+  if (!subAccount) throw Error('hinkalActionReceive: subAccount should be provided');
+  if (!feeToken) throw new Error('Fee token is required in hinkalActionReceive');
+
+  const chainId = hinkal.getCurrentChainId();
+
+  const walletAddress = UserKeys.getSignerAddressFromPrivateKey(subAccount.privateKey);
+  const erc20Addresses = erc20Tokens.map((token) => token.erc20TokenAddress);
+  const deltaAmounts = await modifyVolatileTokenAmountChanges(chainId, erc20Tokens, deltaAmountsBase, walletAddress);
+
+  const transferOps = createTransaferEmporiumOpsBatch(hinkal, erc20Addresses, deltaAmounts);
+
+  const feeStructure =
+    feeStructureOverride ??
+    (await getFeeStructure(
+      chainId,
+      feeToken,
+      erc20Addresses,
+      ExternalActionId.Emporium,
+      transferOps.map((transferOp) => convertEmporiumOpToCallInfo(transferOp, walletAddress, chainId)),
+    ));
+
+  const emporiumTokenChanges = erc20Tokens.map((token, index) => ({
+    token,
+    amount: -1n * deltaAmounts[index],
+  }));
+
+  return hinkal.actionPrivateWallet(
+    erc20Addresses,
+    deltaAmounts,
+    deltaAmounts.map(() => false),
+    transferOps,
+    emporiumTokenChanges,
+    subAccount,
+    feeToken,
+    feeStructure,
+    undefined,
+    undefined,
+    undefined,
+    action,
+    onlyGasEstimate,
+  );
+};