@sabaaa1/common 0.0.1

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

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

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

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

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

@@ -0,0 +1,74 @@
+/* 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

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

@@ -0,0 +1,31 @@
+// @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/index.ts

@@ -0,0 +1,3 @@
+export * from './poseidon';
+export * from './babyJub';
+export * from './preProcessing';

package/src/crypto/poseidon.ts

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

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

@@ -0,0 +1,288 @@
+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();

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

@@ -0,0 +1 @@
+export * from './EventsPublicApprovalsDB';