@sabaaa1/common 0.0.9 → 0.0.11

package/src/data-structures/utxo/Utxo.ts

@@ -1,189 +0,0 @@
-import { ethers } from 'ethers';
-import { CIRCOM_P } from '../../constants/protocol.constants';
-import { poseidonHash } from '../../crypto/poseidon';
-import { randomBigInt } from '../../functions/web3/etherFunctions';
-import { UserKeys } from '../crypto-keys/keys';
-import { getCurrentTimeInSeconds } from '../../functions/utils/time.utils';
-
-// TODO: Should be implemented using serializer/deserializer pattern
-export type IUtxoConstructor<T = bigint> = {
-  amount: T;
-  erc20TokenAddress: string;
-  timeStamp?: string;
-  shieldedPrivateKey?: string;
-  randomization?: T;
-  stealthAddress?: string;
-  encryptionKey?: string;
-  tokenId?: number;
-  isStake?: boolean;
-  isStakeOrUnstakeInput?: boolean;
-  isUnstakeOutput?: boolean;
-
-  // allow option to pass computed value so we don't need to recompute them
-  // each time web worker process UTXO
-  commitment?: string;
-  nullifier?: string;
-};
-
-/**
- * UTXO class for transactions
- */
-export class Utxo {
-  public amount: bigint;
-
-  public erc20TokenAddress: string;
-
-  public timeStamp: string;
-
-  public tokenId: number;
-
-  public shieldedPrivateKey?: string; // 1) if it's own UTXO one provides private key and  randomization -> computes stealth address and and eKey
-
-  public randomization: bigint;
-
-  public stealthAddress?: string; // 2) if it's other's utxo, stealth address and encryption key should be provided
-
-  public encryptionKey?: string;
-
-  public commitment?: string; // computed
-
-  public nullifier?: string; // computed
-
-  public isStake: boolean;
-
-  public isStakeOrUnstakeInput: boolean;
-
-  public isUnstakeOutput: boolean;
-
-  /**
-   * creates new UTXO instance
-   * @param amount UTXO amount
-   * @param erc20TokenAddress contract address of ERC-20/ERC-721 token
-   * @param timeStamp timestamp
-   * @param tokenId tokenId
-   * @param randomization randomization parameter
-   * @param stealthAddress  stealth address as a parameter(e.g. in case of transfers we will not know private key and randomization of payee
-   * @param encryptionKey  encryption public key
-   * @param shieldedPrivateKey private key for nullification
-   * @param commitment [optional] commitment value if already computed
-   * @param nullifier [optional] nullifier value if already computed
-   */
-  constructor({
-    amount,
-    erc20TokenAddress,
-    timeStamp,
-    tokenId,
-    shieldedPrivateKey,
-    randomization,
-    stealthAddress,
-    encryptionKey,
-    commitment = undefined,
-    nullifier = undefined,
-    isStake = false,
-    isStakeOrUnstakeInput = false,
-    isUnstakeOutput = false,
-  }: IUtxoConstructor) {
-    this.amount = amount;
-    this.erc20TokenAddress = erc20TokenAddress;
-    this.timeStamp = timeStamp ?? getCurrentTimeInSeconds().toString();
-    this.tokenId = tokenId ?? 0;
-    this.shieldedPrivateKey = shieldedPrivateKey;
-    this.randomization = randomization ?? Utxo.findCorrectRandomization(randomBigInt(31), shieldedPrivateKey); // randomization which will stay within 253 after multiplication
-    this.stealthAddress = stealthAddress;
-    this.encryptionKey = encryptionKey;
-    this.commitment = commitment;
-    this.nullifier = nullifier;
-    this.isStake = isStake;
-    this.isStakeOrUnstakeInput = isStakeOrUnstakeInput;
-    this.isUnstakeOutput = isUnstakeOutput;
-  }
-
-  static createFrom(utxoToCreateFrom: Utxo, patch: Partial<IUtxoConstructor>): Utxo {
-    return new Utxo({
-      ...utxoToCreateFrom.getConstructableParams(),
-      nullifier: undefined,
-      commitment: undefined,
-      ...patch,
-    });
-  }
-
-  getConstructableParams(): IUtxoConstructor {
-    return {
-      amount: this.amount,
-      erc20TokenAddress: this.erc20TokenAddress,
-      timeStamp: this.timeStamp,
-      shieldedPrivateKey: this.shieldedPrivateKey,
-      randomization: this.randomization,
-      stealthAddress: this.stealthAddress,
-      encryptionKey: this.encryptionKey,
-      tokenId: this.tokenId,
-      commitment: this.commitment,
-      nullifier: this.nullifier,
-      isStake: this.isStake,
-      isStakeOrUnstakeInput: this.isStakeOrUnstakeInput,
-      isUnstakeOutput: this.isUnstakeOutput,
-    };
-  }
-
-  /**
-   * @returns commitment hash of the UTXO instance
-   */
-  getCommitment() {
-    if (!this.commitment) {
-      const dataToHash = [this.amount, this.erc20TokenAddress, BigInt(this.getStealthAddress()), this.timeStamp];
-      if (this.tokenId > 0) dataToHash.push(this.tokenId.toString());
-      if (this.isStake || this.isUnstakeOutput) dataToHash.push(0n, 1n);
-      this.commitment = poseidonHash(...dataToHash);
-    }
-    return this.commitment;
-  }
-
-  /**
-   * @returns nullifier hash of the UTXO instance
-   */
-  getNullifier() {
-    if (!this.nullifier) {
-      if (!this.shieldedPrivateKey) throw new Error('No Nullifiers if private key is not provided');
-      const signature = poseidonHash(this.shieldedPrivateKey, this.getCommitment());
-      const nullifierBigInt = BigInt(poseidonHash(this.commitment, signature));
-      const isStakeOrUnstakeInputBigInt = BigInt(this.isStakeOrUnstakeInput);
-      this.nullifier = ethers.BigNumber.from(nullifierBigInt + isStakeOrUnstakeInputBigInt).toHexString();
-    }
-    return this.nullifier;
-  }
-
-  /**
-   * @returns stealth address from randomization and private shieldedPrivateKey
-   */
-  getStealthAddress(): string {
-    if (!this.stealthAddress) {
-      if (!this.shieldedPrivateKey) throw Error('No stealth address in UTXO if private key is not provided');
-      const stelathAddress = UserKeys.getStealthAddress(this.randomization, this.shieldedPrivateKey);
-      this.stealthAddress = stelathAddress;
-    }
-    return this.stealthAddress;
-  }
-
-  getEncryptionKey(): string {
-    if (!this.shieldedPrivateKey) {
-      if (!this.encryptionKey) throw Error('No encryption key provided in UTXO');
-      return this.encryptionKey;
-    }
-    return UserKeys.getEncryptionKeyPair(this.shieldedPrivateKey).publicKey;
-  }
-
-  public static findCorrectRandomization(initialRandomization: bigint, privateKey?: string): bigint {
-    if (!privateKey) throw Error('No Private Shielded Key Provided');
-    const privateKeyAdjusted = BigInt(privateKey) % CIRCOM_P;
-    let s;
-    let sPk;
-    let i = 0n;
-    do {
-      s = (initialRandomization * 10n ** i) % CIRCOM_P;
-      sPk = (s * privateKeyAdjusted) % CIRCOM_P;
-      i += 1n;
-    } while (sPk >= 2n ** 253n || s >= 2n ** 253n); // within 253 bits
-
-    return s;
-  }
-}

package/src/error-handling/customErrors/ErrorWithAmount.ts

@@ -1,8 +0,0 @@
-export class ErrorWithAmount extends Error {
-  public amount: number;
-
-  constructor(providedAmount: number, message: string) {
-    super(message);
-    this.amount = providedAmount;
-  }
-}

package/src/error-handling/customErrors/ErrorWithTx.ts

@@ -1,10 +0,0 @@
-import { RelayerTransaction } from '../../types/relayer.types';
-
-export class ErrorWithRelayerTransaction extends Error {
-  tx: RelayerTransaction | undefined;
-
-  constructor(message: string, tx: RelayerTransaction | undefined) {
-    super(message);
-    this.tx = tx;
-  }
-}

package/src/error-handling/customErrors/FeeOverTransactionValueError.ts

@@ -1,16 +0,0 @@
-import { ERC20Token } from '../../types';
-import { transactionErrorCodes } from '../error-codes.constants';
-
-export interface FeeOverTransactionValueErrorData {
-  totalFeeWEI: bigint;
-  feeUnit: ERC20Token | undefined;
-}
-
-export class FeeOverTransactionValueError extends Error {
-  constructor(public data: FeeOverTransactionValueErrorData) {
-    // This ensure that the Error object is still treated the same as
-    // `new Error(transactionErrorCodes.FEES_OVER_TRANSACTION_VALUE)` everywhere else in the code.
-    super(transactionErrorCodes.FEES_OVER_TRANSACTION_VALUE);
-    this.name = this.constructor.name;
-  }
-}

package/src/error-handling/customErrors/SimulationFailureError.ts

@@ -1,9 +0,0 @@
-export class SimulationFailureError extends Error {
-  errorStructure: { error: string; errorReason: string };
-
-  constructor(data: { error: string; errorReason: string }) {
-    super(data.error);
-    this.errorStructure = data;
-    this.name = this.constructor.name;
-  }
-}

package/src/error-handling/customErrors/customErrors.helpers.ts

@@ -1,39 +0,0 @@
-import { fixDecimalsAmount } from '../../functions/utils/amounts.utils';
-import { getAmountInToken } from '../../functions/web3/etherFunctions';
-import { transactionErrorCodes } from '../error-codes.constants';
-import { ErrorCategory } from '../types';
-import { FeeOverTransactionValueError } from './FeeOverTransactionValueError';
-
-export const getGenericFeeOverTransactionValueErrorMessage = (
-  error: FeeOverTransactionValueError,
-  type?: ErrorCategory,
-) => {
-  const { totalFeeWEI, feeUnit } = error.data;
-  if (!feeUnit) {
-    // This is the default `Fees are over transaction value...` message
-    return error.message;
-  }
-  const feeInToken = getAmountInToken(feeUnit, totalFeeWEI);
-  let verb = 'transact';
-  let equivalentText = 'an equivalent of ';
-  // Swap use its own handling because of unit mismatch, Deposit does not throw this error.
-  if (type === ErrorCategory.WITHDRAW) {
-    verb = 'withdraw';
-    equivalentText = '';
-  }
-
-  return `Fees are over transaction value. Please ${verb} at least ${equivalentText} ${fixDecimalsAmount(
-    Number(feeInToken),
-  )} of ${feeUnit?.symbol} (subject to real-time price)`;
-};
-
-/** If the error is a known gas err type, rethrow it, otherwise throw a new Error */
-export const rethrowKnownGasErrorIfPossible = (err: unknown, fallbackErrorMsg: string) => {
-  if (
-    err instanceof FeeOverTransactionValueError ||
-    (err as Error)?.message === transactionErrorCodes.INSUFFICIENT_FUNDS_TO_TRANSACT
-  ) {
-    throw err;
-  }
-  throw Error(fallbackErrorMsg);
-};

package/src/error-handling/error-codes.constants.ts

@@ -1,214 +0,0 @@
-const rewardsErrorCodes = {
-  CANNOT_CERTIFY_FOR_PAST_WEEK: 'Certification for the past week is not available',
-  CYCLICAL_REFERRALS_FORBIDDEN: 'Cyclical referrals are forbidden',
-
-  USER_IS_UNRANKED: 'Please certify transactions to see rank',
-};
-
-const connectionErrorCodes = {
-  WC_NO_MATCHING_KEY: 'creating the transaction failed\nversion',
-};
-
-export const walletConnectErrorCodes = {
-  WC_INVALID_URI: 'Invalid WalletConnect URI. Please, try again',
-  WC_PAIRINNG_ERROR: 'Pairing failed. Check your code and retry',
-};
-
-export const insufficientResourcesErrorCodes = {
-  INSUFFICIENT_FUNDS: 'Insufficient funds',
-  INSUFFICIENT_FUNDS_WITHDRAW: 'Not enough funds to withdraw',
-  INSUFFICIENT_FUNDS_TRANSFER: 'Not enough funds to transfer',
-  INSUFFICIENT_FUNDS_TO_TRANSACT: 'Not enough funds to transact',
-  INSUFFICIENT_FUNDS_GAS: 'Insufficient funds for gas * price',
-};
-
-export const gasErrorCodes = {
-  GAS_PRICE_EXCEEDS_AUTOSHIELD_LIMIT: 'Gas prices too high to autoshield',
-};
-
-export const transactionErrorCodes = {
-  ...rewardsErrorCodes,
-  ...connectionErrorCodes,
-  ...insufficientResourcesErrorCodes,
-  ...gasErrorCodes,
-  SOME_ERROR:
-    'Some error has occurred. Please try again in a few minutes. If the issue persists, please report it in Discord',
-  TOO_HIGH_AMOUNT: 'ApproxParamsInvalid',
-  NOT_ENOUGH_TOKENS: 'Transfer amount exceeds balance',
-  TRANSACTION_NOT_CONFIRMED: 'The transaction was not confirmed by the network. Please, try again',
-  RPC_PROVIDER_LIMIT_ERROR: "Non-200 status code: '429'",
-  RELAYER_NOT_AVAILABLE: 'All relayers are busy, please try in a few seconds',
-  TRANSACTION_TIMEOUT: 'Your transaction got stale. Please, try in a few seconds',
-  CONNECT_ERROR: 'Connection error',
-  CONNECT_ERROR2: 'DOMException: Failed',
-  USER_REJECTED_TX: 'Transaction rejected',
-  USER_REJECTED_SIGN: 'User rejected signing',
-  USER_REJECTED_TRANSACTION: 'user rejected transaction',
-  USER_REJECTED_SIGN2: 'User rejected the request',
-  SIGNING_FAILED: 'The signing failed. Please, try again',
-  SIGNATURE_UNSUPPORTED_CHAINS: 'Details: Unsupported chains',
-  SIGNATURE_UNSUPPORTED_CHAINS2: 'User disapproved requested chains',
-  SIGNATURE_REQUEST_EXPIRED: 'Request expired. Please try again',
-  SIGNATURE_UNSUPPORTED_PERSONAL_SIGN: 'The method personal_sign does not exist',
-  USER_DISAPPROVED_REQUESTED_METHODS: 'User disapproved requested methods',
-  INVALID_AUTHORIZATION: 'The requested account and/or method has not been authorized by the user',
-  INVALID_NULLIFIER: 'Nullifier cannot be reused',
-  SANCTIONED_ADDRESS: 'Address is sanctioned',
-  INVALID_AMOUNT: 'Please, select correct amount',
-  RECIPIENT_FORMAT_INCORRECT: 'Recipient Information format is incorrect',
-  INVALID_TOKEN: 'Invalid token provided',
-  STATE_TO_UPDATE: 'Error in template Verifier_219 line: 121',
-  HAS_TOKEN: 'User already has an access token',
-  INVALID_RECEIVER: "Receiver address doesn't match",
-  INVALID_RELAYER: "Relayer address doesn't match",
-  INVALID_RELAYER_FEE: "Relayer fee amount doesn't match",
-  TIMESTAMP_STALE: 'Timestamp provided does not align with current time',
-  INVALID_ZKP: 'Proof must be valid',
-  NO_TRANSACTIONS_TO_CERTIFY: 'This week, you do not have transactions to certify',
-  RECIPIENT_AMOUNT_INVALID: 'Recipient amount is invalid',
-  UNSUPPORTED_NETWORK: 'Unsupported network: please choose Polygon, BNB Chain',
-  SIG_BY_OWNER: 'Signature must be signed by the owner of the contract',
-  AMOUNT_EMPTY: 'Please, specify amount',
-  UNVERIFIED_USER: 'Please, pass KYC verification',
-  RELAYER_ISSUE: 'Relayer has some issues. Try again later',
-  RELAYER_GAS_ESTIMATE: 'Relayer was not able to estimate the gas costs of tx. Please, try later',
-  RECEIVER_EMPTY: 'Please, enter recipient address',
-  VALID_ETHEREUM_ADDRESS: 'Please, input valid ethereum address',
-  METAMASK_NOT_INSTALLED: 'Please, install Metamask Wallet',
-  VIABLE_TX: 'The transaction is not viable. Please increase the swap amount to swap with Relayer',
-  TRANSACTION_REPLACED: 'transaction was replaced',
-  TRANSACTION_REPLACED2: 'replacement fee too low',
-  TRANSACTION_CANCELED: 'Transaction was cancelled. Please try again',
-  NONCE_HIGH: 'Nonce too high',
-  WALLET_CONNECT_MATCHING_KEYS: 'No matching key. keychain',
-  UNKNOWN_PROVIDER: 'Unknown provider',
-  SAFE_ERC: 'SafeERC20: low-level call failed',
-  SAFE_ERC_APPROVE: 'SafeERC20: approve from non-zero to non-zero allowance',
-  SWAP_RELAYER_MIN: 'Relayer minimum fee is not satisfied',
-  LOW_LEVEL_CALL: 'low-level delegate call failed',
-  INTEGRAL_CURVE_ZERO: 'previous integral cannot be zero',
-  ODOS_FETCH: 'Odos API Fetch Error',
-  YOU_CANCELED_REQUEST: 'You canceled the request',
-  SLIPPAGE_LIMIT: 'Slippage Limit Exceeded',
-  SLIPPAGE_LIMIT_1: 'Slippage screwed you',
-  QUOTE_EXPIRED: 'Quote has expired',
-  REVERT_NO_STRING: 'Transaction reverted without a reason string',
-  UNISWAP_NOT_ENOUGH_LIQUIDITY: 'Not Enough Liquidity',
-  CONNECTION_FAILED: 'Failed to connect',
-  FAILED_TO_SWITCH_NETWORKS: "Failed to switch network, Please switch networks using your wallet's settings",
-  INVALID_FROM: 'Invalid from token',
-  INVALID_TO: 'Invalid to token',
-  Invalid_Password: 'Invalid password',
-  INTERNAL_ERROR: 'Internal error: please, try again',
-  INVALID_MERKLE_ROOT: 'Invalid merkle tree root',
-  ACCESS_TOKEN_INVALID_HASH: 'Access Token not minted',
-  MERLE_TREE_SNARK: 'Error in template ForceEqualIfEnabled',
-  ERROR_MESSAGE_CHAIN_ADDRESS_CHANGED: 'Chain/address changed: balance updated canceled',
-  DECIMALS_LIMIT: 'Number of decimals exceed maximum',
-  MERKLE_TREE_INCOMPLETE: 'Merkle tree is incomplete',
-  FAIL_ESTIMATE_GAS: 'Failed to estimate gas: check the transaction parameters',
-  ODOS_SWAP_FAILED: 'Odos swap call failed',
-  ONEINCH_SWAP_FAILED: 'One inch swap failed',
-  GAS_ESTIMATION_ERROR: 'Failed Gas Estimates Response',
-  GAS_ESTIMATE_INCORRECT_PARAMETERS: 'Incorrect Parameters for Gas Estimate',
-  CONNECTIVITY_ERROR: 'Request failed with status code 500',
-  TRANSACTION_FAILED: 'Transaction Failed: Revert',
-  NO_UNISWAP_PRICE: 'Cannot get Uniswap Price',
-  NO_ODOS_PRICE: 'Cannot get Odos Price',
-  NO_ONEINCH_PRICE: 'Cannot get OneInch Price',
-  NO_LIFI_PRICE: 'Cannot get LiFi Price',
-  FEES_OVER_TRANSACTION_VALUE: 'Fees are over transaction value. Please, increase the amount',
-  GAS_STATION_NOT_AVAILABLE: 'Gas Station Not Available',
-  INBALANCE_IN_TOKEN: 'Inbalance in token detected',
-  BALANCE_EQUATION_FAILED: 'Balance Diff Should be equal to sum of onchain and offchain created commitments',
-  TOKEN_ADD_ERROR: 'Error occoured while adding token. Please make sure you are adding a valid ERC-20 token',
-  CANNOT_ESTIMATE_GAS: 'transaction may require manual gas limit',
-  NETWORK_ERROR: 'Network Error',
-  MAX_FEE_GAS_ERROR: 'max fee per gas less than block base fee',
-  CORS_ERROR: 'has been blocked by CORS policy',
-  CANNOT_ESTIMATE_GAS2: 'transaction may fail or may require manual gas limit',
-  NO_RESPONSE_PRIVATE: 'No resonse from private relay',
-  TRY_AGAIN_AFTER_TRANSACTION: 'Please, try again',
-  ALREADY_SUBSCRIBED: 'User Already Subscribed',
-  PREFERRED_TOKEN_OR_ADDRESS_MISSING: 'Please, specify both the preferred token and public wallet address',
-  SNAPSHOT_FILE_NOT_FOUND: 'We are updating our servers. Please try again in some time',
-  SAME_ADDRESS_FORBIDDEN: 'You cannot recieve staked tokens on the same ethereum address',
-  NOT_VALID_ETHEREUM_ADDRESS: 'Please enter a valid Ethereum address',
-  MUST_STAKE_AT_LEAST_ONE_ETH: 'Amount too low, Please stake at least 1 ETH',
-  // there are 3 possible out of memory errors we can get
-  OUT_OF_MEMORY: 'Out of memory: Cannot allocate Wasm memory',
-  OUT_OF_MEMORY2: 'could not allocate memory',
-  OUT_OF_MEMORY3: 'out of memory',
-  UNKNOWN: 'Unknown error',
-  SANDBOX_WRONG_REQUEST: 'The requested Transaction type is not supported',
-};
-
-const OUT_OF_MEMORY_USER_FRIENDLY =
-  'Not enough memory. Please, close some tabs/applications to free up memory and try again';
-
-export const UserFriendlyErrorCodes = {
-  USER_REJECTED_TRANSACTION: 'You cancelled the transaction',
-  SOME_ERROR:
-    'Some error has occurred. Please try again in a few minutes. If the issue persists, please report it in Discord',
-  TOO_HIGH_AMOUNT: 'The amount you provided is too high, please adjust the amount',
-  WC_NO_MATCHING_KEY: 'Wallet Connect error. Please, try again',
-  RPC_PROVIDER_LIMIT_ERROR: 'Rate Limit: please, use different rpc provider in your wallet',
-  INSUFFICIENT_FUNDS_GAS: 'Your balance is too low to cover the transaction fees. Please add funds to proceed',
-  INVALID_NULLIFIER:
-    'There seems to be an issue with syncing your balance. Please press the refresh icon next to your shielded balance',
-  STATE_TO_UPDATE: 'A technical issue has occurred. Please create a ticket on Hinkal discord server',
-  INVALID_ZKP: 'The Zero Knowledge Proof provided is invalid. Please check and try again',
-  NONCE_HIGH: 'To resolve this issue, please reset your wallet in the Settings',
-  UNKNOWN_PROVIDER: 'The provider is not recognized. Please check your settings',
-  TRANSACTION_REPLACED: 'Your transaction was replaced by another. Please submit your transaction again',
-  TRANSACTION_REPLACED2: 'This transaction was replaced. Please try submitting again',
-  TRANSACTION_TIMEOUT: 'Your transaction got stale. Please, try in a few seconds',
-  SAFE_ERC: 'The selected ERC20 Token could not be transferred. Please contact the Hinkal support team',
-  SIMULATION_FAILED: 'Transaction failed during simulation:',
-  SAFE_ERC_APPROVE: 'The selected ERC20 Token could not be approved. Please contact the Hinkal support team',
-  INTEGRAL_CURVE_ZERO: `There's an issue with the pool's staking function. Please contact the Hinkal support team for assistance`,
-  LOW_LEVEL_CALL: 'A technical issue occurred. Please contact the Hinkal team for assistance',
-  YOU_CANCELED_REQUEST: 'You canceled the request',
-  USER_REJECTED_SIGN2: 'You canceled the request',
-  ODOS_FETCH: 'Current Odos price is unavailable. Please try again',
-  ODOS_SWAP_FAILED: 'Your Odos Swap transaction didn’t go through. Please try again',
-  ONEINCH_SWAP_FAILED: 'Your 1inch Swap transaction didn’t go through. Please try again',
-  CONNECT_ERROR2: 'Oops, there are connectivity issues. Please check your internet connection and try again',
-  WALLET_CONNECT_MATCHING_KEYS: 'An internal WalletConnect error occurred. Please try reconnecting',
-  SIGNATURE_UNSUPPORTED_CHAINS: 'The transaction couldn’t be signed: this network is not supported',
-  SIGNATURE_UNSUPPORTED_CHAINS2: 'The transaction couldn’t be signed: this network is not supported',
-  SIGNATURE_UNSUPPORTED_PERSONAL_SIGN: `Your active wallet doesn't support personal signatures. Please use a different wallet`,
-  REVERT_NO_STRING:
-    'Your transaction didn’t go through due to technical issues. Please submit a ticket on Hinkal discord server',
-  INVALID_MERKLE_ROOT: `There's an issue with the merkle tree root. Please submit a ticket on Hinkal discord server`,
-  MERLE_TREE_SNARK: 'An error occurred in the circuit processing. Please submit a ticket on Hinkal discord server',
-  MAX_FEE_GAS_ERROR: 'Your transaction was rejected due to high network congestion',
-  MERKLE_TREE_INCOMPLETE: 'A technical issue has occurred. Please submit a ticket on Hinkal discord server',
-  CORS_ERROR: 'Unable to reach the remote client. Please submit a ticket on Hinkal discord server',
-  NETWORK_ERROR: 'Connection error. Please, check back later',
-  CONNECTIVITY_ERROR: 'A connectivity issue occurred. Please check your network connection',
-  INBALANCE_IN_TOKEN:
-    'Your transaction didn’t go through due to price slippage. Try increasing your slippage tolerance',
-  BALANCE_EQUATION_FAILED: `There's an issue with the balance calculation. Please adjust your transaction parameters`,
-  SLIPPAGE_LIMIT_1: 'Your transaction didn’t go through due to price slippage. Adjust slippage settings and retry',
-  CANNOT_ESTIMATE_GAS: 'Unable to estimate the gas required. Please set the gas limit manually',
-  CANNOT_ESTIMATE_GAS2: 'Your transaction didn’t go through. Please try setting gas limit manually',
-  GAS_STATION_NOT_AVAILABLE:
-    'The Gas Station service is currently unavailable. Please submit a ticket on Hinkal discord server',
-  TIMESTAMP_STALE: 'This transaction is outdated. Please initiate a new transaction',
-  ALREADY_SUBSCRIBED: 'This email is already subscribed to the Hinkal newsletter',
-  OUT_OF_MEMORY: OUT_OF_MEMORY_USER_FRIENDLY,
-  OUT_OF_MEMORY2: OUT_OF_MEMORY_USER_FRIENDLY,
-  OUT_OF_MEMORY3: OUT_OF_MEMORY_USER_FRIENDLY,
-  INVALID_RECOVERY_PHRASE: 'Invalid recovery phrase',
-  PHRASES_DONT_MATCH: 'Phrases do not match. You can always go back and check!',
-  PASSWORDS_DONT_MATCH: 'Passwords do not match',
-  PASSWORD_SAME_AS_OLD: 'Password cannot be the same as the old one',
-  PASSWORD_TOO_SMALL: 'Password must be at least 8 characters',
-  PASSWORD_NOT_CORRECT: 'Incorrect current password',
-  CODE_ALREADY_USED: 'This code has already been used',
-  ACCESS_CODE_REQUIRED: 'Access code is required',
-  ACCESS_CODE_IS_ALREADY_IN_USE: 'Access code is already in use',
-  ACCESS_CODE_IS_ALREADY_IN_USE1: 'Access code already in use. Import or connect existing wallet',
-  ERROR_DURING_PHRASE_CONFIRMATION: 'Error during Phrase confirmation',
-};

package/src/error-handling/get-error.message.ts

@@ -1,149 +0,0 @@
-import { ErrorWithAmount, FeeOverTransactionValueError } from './customErrors';
-import { transactionErrorCodes, UserFriendlyErrorCodes } from './error-codes.constants';
-import { getGenericFeeOverTransactionValueErrorMessage } from './customErrors/customErrors.helpers';
-import { ErrorCategory } from './types';
-import { SandboxRequestType } from '../types';
-
-export const extractMessage = (maybeError: unknown) => {
-  if (typeof maybeError === 'object' && maybeError !== null) {
-    if (
-      'response' in maybeError &&
-      typeof maybeError.response === 'object' &&
-      maybeError.response !== null &&
-      'data' in maybeError.response &&
-      typeof maybeError.response.data === 'object' &&
-      maybeError.response.data !== null &&
-      'message' in maybeError.response.data &&
-      typeof maybeError.response.data.message === 'string'
-    ) {
-      return maybeError.response.data.message;
-    }
-    if (
-      'data' in maybeError &&
-      typeof maybeError.data === 'object' &&
-      maybeError.data !== null &&
-      'message' in maybeError.data &&
-      typeof maybeError.data.message === 'string'
-    ) {
-      return maybeError.data.message;
-    }
-
-    if ('message' in maybeError && typeof maybeError.message === 'string') {
-      return maybeError.message;
-    }
-  }
-  if (maybeError instanceof Error) {
-    return maybeError.message;
-  }
-  if (typeof maybeError === 'string') return maybeError;
-
-  return undefined;
-};
-
-const getDefaultMessageBasedOnCategory = (type: ErrorCategory): string => {
-  switch (type) {
-    case ErrorCategory.DEPOSIT:
-      return 'Deposit failed';
-    case ErrorCategory.SWAP:
-      return 'Swap failed';
-    case ErrorCategory.BRIDGE:
-      return 'Bridge failed';
-    case ErrorCategory.WITHDRAW:
-      return 'Send failed';
-    case ErrorCategory.Fund:
-      return 'Unshield failed';
-    case ErrorCategory.Receive:
-      return 'Shield failed';
-    case ErrorCategory.DappTransaction:
-      return 'DApp transaction failed';
-    case ErrorCategory.Approve:
-      return 'Approval failed';
-    default:
-      return transactionErrorCodes.UNKNOWN;
-  }
-};
-
-export const getErrorMessage = (error: unknown, type?: ErrorCategory) => {
-  // Handle custom errors first
-  if (error instanceof FeeOverTransactionValueError) {
-    return getGenericFeeOverTransactionValueErrorMessage(error as FeeOverTransactionValueError, type);
-  }
-  if (error instanceof ErrorWithAmount) {
-    const { amount, message } = error;
-    return `${message} ${amount}`;
-  }
-
-  const originalErrorMessage = extractMessage(error);
-
-  if (originalErrorMessage) {
-    const lowerCasedMessage = originalErrorMessage.toLowerCase();
-    // 1) Finding if message exactly equals to one of the values in dictionary
-    const foundItemByKey = Object.keys(transactionErrorCodes).find(
-      (errorCodePlain) =>
-        lowerCasedMessage === transactionErrorCodes[errorCodePlain as keyof typeof transactionErrorCodes].toLowerCase(),
-    );
-
-    if (foundItemByKey && foundItemByKey in UserFriendlyErrorCodes) {
-      return UserFriendlyErrorCodes[foundItemByKey as keyof typeof UserFriendlyErrorCodes];
-    }
-    // 2) Finding if error message contains one of dictionary values
-    const foundItem = Object.entries(transactionErrorCodes).find(([_transactionKey, _transactionValue]) => {
-      return lowerCasedMessage.includes(_transactionValue.toLowerCase());
-    });
-
-    if (foundItem) {
-      const userFriendlyValue = UserFriendlyErrorCodes[foundItem[0] as keyof typeof UserFriendlyErrorCodes];
-      return userFriendlyValue ?? foundItem[1];
-    }
-  }
-
-  // if no specific error message found, return default message based on type/category
-  if (type) {
-    return getDefaultMessageBasedOnCategory(type);
-  }
-  return transactionErrorCodes.UNKNOWN;
-};
-
-export const getErrorMessageFromSandboxRequest = (error: unknown, requestType: SandboxRequestType) => {
-  let errorCategory: ErrorCategory | undefined;
-
-  switch (requestType) {
-    case SandboxRequestType.Send:
-    case SandboxRequestType.ProxySend:
-      errorCategory = ErrorCategory.WITHDRAW;
-      break;
-
-    case SandboxRequestType.SwapTokens:
-    case SandboxRequestType.ProxySwapTokens:
-      errorCategory = ErrorCategory.SWAP;
-      break;
-
-    case SandboxRequestType.ReceiveFromShieldedAccount:
-      errorCategory = ErrorCategory.Receive;
-      break;
-
-    case SandboxRequestType.Fund:
-      errorCategory = ErrorCategory.Fund;
-      break;
-
-    case SandboxRequestType.ShieldTokens:
-      errorCategory = ErrorCategory.DEPOSIT;
-      break;
-
-    case SandboxRequestType.FundApproveAndTransact:
-    case SandboxRequestType.PrivateTransactionFromProxy:
-    case SandboxRequestType.InsideTransact:
-      errorCategory = ErrorCategory.DappTransaction;
-      break;
-
-    case SandboxRequestType.Approve:
-    case SandboxRequestType.FundAndApprove:
-      errorCategory = ErrorCategory.Approve;
-      break;
-
-    default:
-      errorCategory = undefined;
-      break;
-  }
-  return getErrorMessage(error, errorCategory);
-};

package/src/error-handling/handleErrorRestore.ts

@@ -1,25 +0,0 @@
-import { extractMessage } from './get-error.message';
-import { restoreSnapshots } from '../API/restoreSnapshots';
-import { transactionErrorCodes } from './error-codes.constants';
-import { IHinkal } from '../data-structures/Hinkal/IHinkal';
-import { resetMerkleTrees } from '../data-structures/Hinkal/resetMerkleTrees';
-
-export async function checkErrorForSnapshotRestore(err: unknown, hinkal: IHinkal) {
-  const chainId = hinkal.getCurrentChainId();
-  const errMessage = extractMessage(err);
-  if (
-    errMessage === transactionErrorCodes.INVALID_NULLIFIER ||
-    errMessage === transactionErrorCodes.MERKLE_TREE_INCOMPLETE ||
-    errMessage === transactionErrorCodes.ACCESS_TOKEN_INVALID_HASH ||
-    errMessage === transactionErrorCodes.INVALID_MERKLE_ROOT ||
-    errMessage === transactionErrorCodes.MERLE_TREE_SNARK ||
-    errMessage === transactionErrorCodes.STATE_TO_UPDATE
-  ) {
-    await restoreSnapshots(chainId);
-    await resetMerkleTrees(hinkal);
-
-    const currentErr = new Error(transactionErrorCodes.INTERNAL_ERROR);
-    return currentErr;
-  }
-  return err;
-}

package/src/error-handling/logError.ts

@@ -1,8 +0,0 @@
-import { isNotClientProduction } from '../constants/vite.constants';
-
-export const logError = (...logErr: unknown[]) => {
-  if (isNotClientProduction) {
-    // eslint-disable-next-line no-console
-    console.log(...logErr);
-  }
-};