@sabaaa1/common 0.0.9 → 0.0.12

package/src/constants/token-data/popularTokens.constants.ts

@@ -1,11 +0,0 @@
-export const PopularTokenSymbols = [
-  { symbol: 'hETH' },
-  { symbol: 'BNB' },
-  { symbol: 'DAI' },
-  { symbol: 'ETH' },
-  { symbol: 'MATIC' },
-  { symbol: 'USDC' },
-  { symbol: 'USDT' },
-  { symbol: 'WETH' },
-  { symbol: 'stETH' },
-];

package/src/constants/token-data/tokenPricing.consts.ts

@@ -1,2 +0,0 @@
-export const urlForBeefyVaultTokens = 'https://api.beefy.finance/vaults';
-export const urlForBeefyVaultLpTokens = 'https://api.beefy.finance/lps';

package/src/constants/token.limits.constants.ts

@@ -1,31 +0,0 @@
-import { getAmountInWei } from '../functions/web3/etherFunctions';
-import { getERC20TokenBySymbol } from '../functions/utils/erc20tokenFunctions';
-import { chainIds } from './chains.constants';
-
-export const TOKEN_LIMITS: Record<number, Record<string, string>> = {
-  [chainIds.optimism]: {
-    ETH: '0.5',
-    WETH: '0.5',
-    rETH: '0.5',
-    USDC: '1000',
-    'USDC.e': '1000',
-    USDT: '1000',
-    DAI: '1000',
-    WBTC: '0.0125',
-  },
-};
-
-export const getTokensLimits = (chainId: number): { erc20Addresses: string[]; limits: bigint[] } => {
-  if (!(chainId in TOKEN_LIMITS)) return { erc20Addresses: [], limits: [] };
-  const limitsObject = Object.entries(TOKEN_LIMITS[chainId]);
-  const erc20Addresses: string[] = [];
-  const limits: bigint[] = [];
-  for (let i = 0; i < limitsObject.length; i += 1) {
-    const [symbol, limit] = limitsObject[i];
-    const token = getERC20TokenBySymbol(symbol, chainId);
-    if (!token) throw Error('no token in getTokenLimit');
-    erc20Addresses.push(token.erc20TokenAddress);
-    limits.push(getAmountInWei(token, limit));
-  }
-  return { erc20Addresses, limits };
-};

package/src/constants/vite.constants.ts

@@ -1,74 +0,0 @@
-/* eslint-disable @typescript-eslint/dot-notation */
-/* eslint-disable global-require */
-/* eslint-disable import/no-extraneous-dependencies */
-/* eslint-disable @typescript-eslint/no-var-requires */
-
-import { toEnumValue } from '../functions/utils/enum.utils';
-
-/* eslint-disable @typescript-eslint/naming-convention */
-export enum DEPLOYMENT_MODE {
-  DEVELOPMENT = 'development',
-  PLAYGROUND = 'playground',
-  PRODUCTION = 'production',
-  STAGING = 'staging',
-}
-
-const URLS = {
-  [DEPLOYMENT_MODE.DEVELOPMENT]: ['localhost', '192.', '127.'],
-  [DEPLOYMENT_MODE.PLAYGROUND]: ['playground'],
-  [DEPLOYMENT_MODE.STAGING]: ['working', 'staging'],
-};
-
-declare const WALLET_DEPLOYMENT_MODE: DEPLOYMENT_MODE; // passed from vite.config.ts as hardcoded value
-
-const isServer = typeof process !== 'undefined' && process?.release?.name === 'node';
-export const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-export const isSandbox = !isNode && typeof window !== 'undefined' && window.origin === 'null';
-// @ts-expect-error webpack check is done like this
-export const isWebpack = typeof __webpack_require__ !== 'undefined';
-export const isExtension = typeof window !== 'undefined' && window?.location?.protocol === 'chrome-extension:';
-
-function includesAny(str: string, substrings: string[]) {
-  return substrings.some((substring) => str.includes(substring));
-}
-
-const getDeploymentModeOnServer = (): DEPLOYMENT_MODE | undefined => {
-  require('dotenv').config({
-    // allow overriding .env file path, see startServer.sh script for explenation on why it is needed
-    path: 'DOTENV_OVERRIDE' in process.env ? process.env['DOTENV_OVERRIDE'] : undefined,
-  });
-  const deploymentMode = toEnumValue(DEPLOYMENT_MODE, process.env['DEPLOYMENT_MODE']);
-  return deploymentMode || DEPLOYMENT_MODE.DEVELOPMENT; // default to development if not set
-};
-
-const getDeploymentMode = (): DEPLOYMENT_MODE | undefined => {
-  if (!isServer && typeof window === 'undefined') return undefined; // on client but no window - just files being loaded into memory most likely
-
-  // case for server: server, relayer, staging, data server
-  if (isServer) return getDeploymentModeOnServer();
-
-  // case of chrome extension
-  if (window?.location?.protocol === 'chrome-extension:') {
-    const envDeploymentMode = toEnumValue(DEPLOYMENT_MODE, WALLET_DEPLOYMENT_MODE);
-    if (envDeploymentMode) {
-      return envDeploymentMode;
-    }
-    return DEPLOYMENT_MODE.STAGING;
-  }
-
-  // case of browser window: client, onboarding, rewards
-  const url = window?.location?.host;
-  if (includesAny(url, URLS[DEPLOYMENT_MODE.DEVELOPMENT])) return DEPLOYMENT_MODE.DEVELOPMENT;
-  if (includesAny(url, URLS[DEPLOYMENT_MODE.PLAYGROUND])) return DEPLOYMENT_MODE.PLAYGROUND;
-  if (includesAny(url, URLS[DEPLOYMENT_MODE.STAGING])) return DEPLOYMENT_MODE.STAGING;
-  return DEPLOYMENT_MODE.PRODUCTION;
-};
-
-export const deploymentMode = getDeploymentMode();
-
-export const isDevelopment = deploymentMode === DEPLOYMENT_MODE.DEVELOPMENT;
-export const isPlayground = deploymentMode === DEPLOYMENT_MODE.PLAYGROUND;
-export const isStaging = deploymentMode === DEPLOYMENT_MODE.STAGING;
-export const isNotProduction = isStaging || isDevelopment || isPlayground;
-
-export const isNotClientProduction = isNotProduction || (isServer && deploymentMode === DEPLOYMENT_MODE.PRODUCTION);

package/src/constants/wallet.constants.ts

@@ -1,9 +0,0 @@
-export const UNSUPPORTED_WALLETS_WALLETCONNECT_NAMES = {
-  mpcVault: 'MPCVault - Multisig Wallet',
-  utila: 'UtilaWallet',
-};
-
-// Utila may need to be added here in the future, but it cannot be tested currently due to its institutional nature
-export const UNSUPPORTED_WALLET_IDS = {
-  mpcVault: 'com.mpcvault.console',
-};

package/src/crypto/babyJub.ts

@@ -1,31 +0,0 @@
-// @ts-ignore
-import { buildBabyjub } from 'circomlibjs-hinkal-fork';
-
-class JubHolder {
-  private babyjub: any = undefined;
-
-  public async init() {
-    if (this.babyjub) return;
-    this.babyjub = await buildBabyjub();
-  }
-
-  public getJub() {
-    return this.babyjub;
-  }
-}
-
-export const jubHolder = new JubHolder();
-
-export const babyJubInstance = () => {
-  return jubHolder.getJub();
-};
-
-export type JubPoint = [bigint, bigint];
-
-export interface BabyJubType {
-  mulPointEscalar: (point: [Uint8Array, Uint8Array], s: bigint) => [Uint8Array, Uint8Array];
-  F: {
-    toString: (arr: Uint8Array) => string;
-  };
-  Base8: [Uint8Array, Uint8Array];
-}

package/src/crypto/poseidon.ts

@@ -1,36 +0,0 @@
-import { BigNumber } from 'ethers';
-import { toBigInt } from '../functions/utils/amounts.utils';
-// @ts-ignore
-import { buildPoseidon } from 'circomlibjs-hinkal-fork';
-
-class PoseidonHolder {
-  private poseidon: any = undefined;
-
-  public async init() {
-    if (this.poseidon) return;
-    this.poseidon = await buildPoseidon();
-  }
-
-  public getPoseidon() {
-    return this.poseidon;
-  }
-}
-
-export const poseidonHolder = new PoseidonHolder();
-
-export function poseidonFunction<T = any>(...args: T[]) {
-  const poseidon = poseidonHolder.getPoseidon();
-  return toBigInt(poseidon.F.toString(poseidon(args)));
-}
-
-/**
- * hashing algorithm implementation
- * @param args rest parameter to take unlimited number of arguments
- * @returns poseidon hash in base 16
- */
-export const poseidonHash = (...args: unknown[]) => {
-  const poseidon = poseidonHolder.getPoseidon();
-  return BigNumber.from(poseidon.F.toString(poseidon([...args]))).toHexString();
-};
-
-export type PoseidonHasher = (...args: unknown[]) => string;

package/src/crypto/preProcessing.ts

@@ -1,20 +0,0 @@
-import { jubHolder } from './babyJub';
-import { poseidonHolder } from './poseidon';
-import sodium from 'libsodium-wrappers'; // added * as for jest
-import process from 'process';
-import { Buffer } from 'buffer';
-
-// ToDo: For corner cases will be good to implement somthing like .ready folw or event emmeter here to fix potential async based issues
-export const preProcessing = async () => {
-  // eslint-disable-next-line no-restricted-globals
-  if (typeof window !== 'undefined' || typeof self !== 'undefined') {
-    if (typeof window !== 'undefined') {
-      window.global = window;
-    }
-    // We need to inject it to global scopre before we import snarkjs
-    globalThis.Buffer = Buffer;
-    globalThis.process = process;
-  }
-
-  await Promise.all([sodium.ready, poseidonHolder.init(), jubHolder.init()]);
-};

package/src/data-structures/ApprovalDBs/EventsPublicApprovalsDB.ts

@@ -1,288 +0,0 @@
-import { ethers } from 'ethers';
-import { get, update } from 'idb-keyval';
-import { Mutex } from 'async-mutex';
-import { ALCHEMY_API_KEY, chainIds, networkRegistry } from '../../constants/chains.constants';
-import { Logger } from '../../error-handling/logger';
-import { getStateKey } from '../../functions/utils/string.utils';
-import { StorageKeys } from '../../types/cache.types';
-import { httpClient } from '../tor/HttpClient';
-import { API } from '../../API/API';
-import {
-  AlchemyBatchRequest,
-  AlchemyBatchResponse,
-  ApprovalPair,
-  ApprovalRequestMetadata,
-  RevokeType,
-  TokenApproval,
-} from '../../types/approvals.types';
-import { isNFTToken } from '../../functions/utils/erc20tokenFunctions';
-import { createTorRpcProvider } from '../../functions/utils/create-provider';
-import { EVENTS_INITIAL_BLOCKS } from '../../constants/events.constants';
-import { ERC20Token } from '../../types/token.types';
-import { caseInsensitiveEqual } from '../../functions/utils/caseInsensitive.utils';
-import { zeroAddress } from '../../constants/protocol.constants';
-
-export class EventsPublicApprovalsDB {
-  private updateMutexes: Record<string, Mutex> = {};
-
-  private readonly approvalTopic = ethers.utils.id('Approval(address,address,uint256)');
-
-  private readonly approvalForAllTopic = ethers.utils.id('ApprovalForAll(address,address,bool)');
-
-  private readonly getApprovedSelector = ethers.utils.id('getApproved(uint256)').substring(0, 10);
-
-  private readonly isApprovedForAllSelector = ethers.utils.id('isApprovedForAll(address,address)').substring(0, 10);
-
-  private readonly ALCHEMY_URLS = {
-    [chainIds.ethMainnet]: `eth-mainnet`,
-    [chainIds.polygon]: `polygon-mainnet`,
-    [chainIds.arbMainnet]: `arb-mainnet`,
-    [chainIds.optimism]: `opt-mainnet`,
-    [chainIds.base]: `base-mainnet`,
-    [chainIds.arcTestnet]: `arc-testnet`,
-    [chainIds.avalanche]: `avax-mainnet`,
-  };
-
-  private getMutex(stateKey: string): Mutex {
-    if (!this.updateMutexes[stateKey]) {
-      this.updateMutexes[stateKey] = new Mutex();
-    }
-    return this.updateMutexes[stateKey];
-  }
-
-  private getAlchemyUrl(chainId: number): string {
-    const network = this.ALCHEMY_URLS[chainId];
-    if (!network) {
-      throw new Error(`Unsupported chainId for Alchemy: ${chainId}`);
-    }
-    return `https://${network}.g.alchemy.com/v2/${ALCHEMY_API_KEY}`;
-  }
-
-  public async getApprovals(chainId: number, walletAddress: string): Promise<TokenApproval[]> {
-    const key = getStateKey(walletAddress, chainId);
-    const approvals = await get<Record<string, TokenApproval[]>>(StorageKeys.EVENTS_PUBLIC_APPROVALS);
-    return approvals?.[key] || [];
-  }
-
-  private async getLastProcessedBlock(chainId: number, walletAddress: string): Promise<number> {
-    const lastBlocks = (await get<Record<string, number>>(StorageKeys.PUBLIC_APPROVALS_LAST_PROCESSED_BLOCKS)) || {};
-    const key = getStateKey(walletAddress, chainId);
-    return lastBlocks[key] || EVENTS_INITIAL_BLOCKS[chainId];
-  }
-
-  private async updateLastProcessedBlock(chainId: number, walletAddress: string, blockNumber: number): Promise<void> {
-    await update(StorageKeys.PUBLIC_APPROVALS_LAST_PROCESSED_BLOCKS, (lastBlocks: Record<string, number> = {}) => {
-      const key = getStateKey(walletAddress, chainId);
-      return {
-        ...lastBlocks,
-        [key]: blockNumber,
-      };
-    });
-  }
-
-  private async getApprovalEvents(
-    walletAddress: string,
-    chainId: number,
-  ): Promise<{ approvalEvents: ethers.providers.Log[]; latestBlock: number | undefined }> {
-    try {
-      const { fetchRpcUrl } = networkRegistry[chainId];
-      if (!fetchRpcUrl) throw Error('No fetchRpcUrl in EventsPublicApprovalsDB');
-      const provider = createTorRpcProvider(fetchRpcUrl);
-
-      const fromBlock = (await this.getLastProcessedBlock(chainId, walletAddress)) + 1;
-      const latestBlock = await provider.getBlockNumber();
-
-      if (fromBlock > latestBlock) {
-        return { approvalEvents: [], latestBlock };
-      }
-
-      const paddedWalletAddress = ethers.utils.hexZeroPad(walletAddress.toLowerCase(), 32);
-
-      const filter = {
-        topics: [[this.approvalTopic, this.approvalForAllTopic], paddedWalletAddress],
-        fromBlock,
-        toBlock: latestBlock,
-      };
-
-      const approvalEvents = await provider.getLogs(filter);
-      return { approvalEvents, latestBlock };
-    } catch (error) {
-      Logger.error('Failed to fetch approval events', error);
-      return { approvalEvents: [], latestBlock: undefined };
-    }
-  }
-
-  private async checkCurrentAllowances(
-    chainId: number,
-    walletAddress: string,
-    approvalPairs: ApprovalPair[],
-  ): Promise<TokenApproval[]> {
-    const alchemyUrl = this.getAlchemyUrl(chainId);
-    const paddedOwner = `0x${walletAddress.substring(2).padStart(64, '0')}`;
-
-    const uniqueAddresses = [...new Set(approvalPairs.map((p) => p.contractAddress))];
-    const tokens = (await API.tokensInfoCall(chainId, uniqueAddresses)).filter((token): token is ERC20Token => !!token);
-    const tokenMap = new Map(tokens.map((token) => [token.erc20TokenAddress.toLowerCase(), token]));
-
-    const batchRequests: AlchemyBatchRequest[] = [];
-    const requestMetadata: ApprovalRequestMetadata[] = [];
-
-    approvalPairs.forEach((pair, pairIndex) => {
-      const token = tokenMap.get(pair.contractAddress.toLowerCase());
-      if (!token) return;
-
-      if (!isNFTToken(token)) {
-        batchRequests.push({
-          jsonrpc: '2.0',
-          id: batchRequests.length,
-          method: 'alchemy_getTokenAllowance',
-          params: [{ contract: pair.contractAddress, owner: walletAddress, spender: pair.spenderAddress }],
-        });
-        requestMetadata.push({ pairIndex, type: RevokeType.ERC20 });
-      } else {
-        const paddedSpender = `0x${pair.spenderAddress.substring(2).padStart(64, '0')}`;
-        const dataAll = `${this.isApprovedForAllSelector}${paddedOwner.substring(2)}${paddedSpender.substring(2)}`;
-
-        batchRequests.push({
-          jsonrpc: '2.0',
-          id: batchRequests.length,
-          method: 'eth_call',
-          params: [{ to: pair.contractAddress, data: dataAll }, 'latest'],
-        });
-        requestMetadata.push({ pairIndex, type: RevokeType.approvedForAll });
-
-        if (pair.tokenIds && pair.tokenIds.size > 0) {
-          pair.tokenIds.forEach((tokenId) => {
-            const hexTokenId = ethers.BigNumber.from(tokenId).toHexString().substring(2).padStart(64, '0');
-            const dataSingle = `${this.getApprovedSelector}${hexTokenId}`;
-
-            batchRequests.push({
-              jsonrpc: '2.0',
-              id: batchRequests.length,
-              method: 'eth_call',
-              params: [{ to: pair.contractAddress, data: dataSingle }, 'latest'],
-            });
-            requestMetadata.push({ pairIndex, type: RevokeType.tokenId, tokenId });
-          });
-        }
-      }
-    });
-
-    if (batchRequests.length === 0) return [];
-
-    const responses = await httpClient.post<AlchemyBatchResponse[]>(alchemyUrl, batchRequests);
-
-    const approvals: TokenApproval[] = [];
-    const approvedForAllPairs = new Set<number>();
-
-    responses.forEach((resp, index) => {
-      const metadata = requestMetadata[index];
-      if (!metadata) return;
-
-      const pair = approvalPairs[metadata.pairIndex];
-      const token = tokenMap.get(pair.contractAddress.toLowerCase());
-      if (!token || caseInsensitiveEqual(pair.spenderAddress, zeroAddress)) return;
-
-      if (!resp?.error && !!resp?.result && resp.result !== '0x') {
-        try {
-          if (metadata.type === RevokeType.ERC20 && BigInt(resp.result) > 0n) {
-            approvals.push({ token, spenderAddress: pair.spenderAddress, allowance: BigInt(resp.result) });
-          } else if (metadata.type === RevokeType.approvedForAll && BigInt(resp.result) === 1n) {
-            approvedForAllPairs.add(metadata.pairIndex);
-            approvals.push({ token, spenderAddress: pair.spenderAddress, allowance: 1n });
-          } else if (metadata.type === RevokeType.tokenId && !approvedForAllPairs.has(metadata.pairIndex)) {
-            const approvedAddress = `0x${resp.result.substring(26)}`.toLowerCase();
-            if (
-              !caseInsensitiveEqual(approvedAddress, zeroAddress) &&
-              caseInsensitiveEqual(approvedAddress, pair.spenderAddress)
-            ) {
-              approvals.push({
-                token,
-                spenderAddress: pair.spenderAddress,
-                allowance: 1n,
-                tokenId: metadata.tokenId,
-              });
-            }
-          }
-        } catch (error) {
-          Logger.error('Error processing approval response', error);
-        }
-      }
-    });
-
-    return approvals;
-  }
-
-  public async fetchAndUpdatePublicApprovals(walletAddress: string, chainId: number): Promise<void> {
-    const stateKey = getStateKey(walletAddress, chainId);
-    const mutex = this.getMutex(stateKey);
-
-    await mutex.runExclusive(async () => {
-      try {
-        const { approvalEvents, latestBlock } = await this.getApprovalEvents(walletAddress, chainId);
-        if (!latestBlock) return;
-
-        const existingApprovals = await this.getApprovals(chainId, walletAddress);
-        const pairsMap = new Map<string, ApprovalPair>();
-
-        existingApprovals.forEach((approval) => {
-          const contract = approval.token.erc20TokenAddress.toLowerCase();
-          const spender = approval.spenderAddress.toLowerCase();
-
-          const pairKey = `${contract}_${spender}`;
-
-          let pair = pairsMap.get(pairKey);
-          if (!pair) {
-            pair = { contractAddress: contract, spenderAddress: spender, tokenIds: new Set() };
-            pairsMap.set(pairKey, pair);
-          }
-
-          if (approval.tokenId && pair.tokenIds) {
-            pair.tokenIds.add(approval.tokenId);
-          }
-        });
-
-        approvalEvents.forEach((log) => {
-          if (!log.topics[2]) return;
-
-          const contract = log.address.toLowerCase();
-          const spender = `0x${log.topics[2].substring(26)}`.toLowerCase();
-
-          if (caseInsensitiveEqual(spender, zeroAddress)) return;
-
-          const pairKey = `${contract}_${spender}`;
-
-          let pair = pairsMap.get(pairKey);
-          if (!pair) {
-            pair = { contractAddress: contract, spenderAddress: spender, tokenIds: new Set() };
-            pairsMap.set(pairKey, pair);
-          }
-
-          if (log.topics.length === 4 && pair.tokenIds) {
-            const tokenId = BigInt(log.topics[3]).toString();
-            pair.tokenIds.add(tokenId);
-          }
-        });
-
-        if (pairsMap.size === 0) {
-          await this.updateLastProcessedBlock(chainId, walletAddress, latestBlock);
-          return;
-        }
-
-        const allPairs = Array.from(pairsMap.values());
-        const currentApprovals = await this.checkCurrentAllowances(chainId, walletAddress, allPairs);
-
-        await update(StorageKeys.EVENTS_PUBLIC_APPROVALS, (stored: Record<string, TokenApproval[]> = {}) => ({
-          ...stored,
-          [stateKey]: currentApprovals,
-        }));
-
-        await this.updateLastProcessedBlock(chainId, walletAddress, latestBlock);
-      } catch (error: unknown) {
-        Logger.error('Failed to sync approvals', error);
-      }
-    });
-  }
-}
-
-export const eventsPublicApprovalsDB = new EventsPublicApprovalsDB();