@sabaaa1/common 0.0.4 → 0.0.7

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

@@ -0,0 +1,189 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,214 @@
+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

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,25 @@
+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

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