@sabaaa1/common 0.0.9 → 0.0.12

package/src/functions/utils/memoize.utils.ts

@@ -1,23 +0,0 @@
-import { CustomJSONStringify } from './serialize.utils';
-
-export const memoizeFunc = <T extends any[], R>(fn: (...args: T) => R) => {
-  const cache = new Map<string, R>();
-
-  return (...args: T) => {
-    const key = CustomJSONStringify(args);
-    if (cache.has(key)) {
-      // Uncomment to do equivalency check to make sure memoized values are correct
-      // =================================================================================
-      // const result = fn(...args);
-      // if (CustomJSONStringify(result) !== CustomJSONStringify(cache.get(key))) {
-      //   throw Error('Memoized result do not equal compute result');
-      // }
-
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      return cache.get(key)!;
-    }
-    const result = fn(...args);
-    cache.set(key, result);
-    return result;
-  };
-};

package/src/functions/utils/merkleTree.utils.ts

@@ -1,27 +0,0 @@
-import { MERKLE_LEVELS } from '../../constants/protocol.constants';
-import { poseidonFunction } from '../../crypto/poseidon';
-import { MerkleTree, MerkleTreeJson } from '../../data-structures/merkle-tree/MerkleTree';
-
-const serializedTreeToMap = (tree: Record<string, string>): Map<bigint, bigint> => {
-  return new Map<bigint, bigint>(
-    Object.entries(tree).map(([key, value]: [string, string]) => [BigInt(key), BigInt(value)]),
-  );
-};
-
-export const contructMerkleTreeFromSerialized = (merkleTreeSerialized: MerkleTreeJson) => {
-  const tree = serializedTreeToMap(merkleTreeSerialized.tree);
-  const reverseTree = merkleTreeSerialized.reverseTree
-    ? serializedTreeToMap(merkleTreeSerialized.reverseTree)
-    : undefined;
-
-  const merkleTree = MerkleTree.createWithData(
-    tree,
-    reverseTree,
-    BigInt(merkleTreeSerialized.index),
-    BigInt(merkleTreeSerialized.count),
-    poseidonFunction,
-    MERKLE_LEVELS,
-    0n,
-  );
-  return merkleTree;
-};

package/src/functions/utils/mutexes.utils.ts

@@ -1,3 +0,0 @@
-import { Mutex } from 'async-mutex';
-
-export const balanceFetchingMutex = new Mutex();

package/src/functions/utils/mystery-box-auction.utils.ts

@@ -1,61 +0,0 @@
-import { Rank } from '../../types';
-import { BOX_AUCTION_DURATIONS_MINUTES, BOX_ENDING_PRICES, BOX_STARTING_PRICES } from '../../constants';
-import { getCurrentDayStart } from './time.utils';
-
-const getAuctionTiming = (rank: Rank, utcOverride?: number) => {
-  const now = utcOverride ? new Date(utcOverride) : new Date();
-  const startOfDay = getCurrentDayStart().getTime();
-  const durationMs = BOX_AUCTION_DURATIONS_MINUTES[rank] * 60 * 1000;
-  const totalElapsed = now.getTime() - startOfDay;
-  const elapsedInInterval = totalElapsed % durationMs;
-  return { now: now.getTime(), startOfDay, durationMs, totalElapsed, elapsedInInterval };
-};
-
-export const getLinearPrice = (rank: Rank, utcOverride?: number): number => {
-  const { durationMs, elapsedInInterval } = getAuctionTiming(rank, utcOverride);
-  const startPrice = BOX_STARTING_PRICES[rank];
-  const endPrice = BOX_ENDING_PRICES[rank];
-  const priceDrop = startPrice - endPrice;
-  const price = startPrice - (elapsedInInterval / durationMs) * priceDrop;
-  return Math.ceil(Math.max(price, endPrice));
-};
-
-export const getAuctionTime = (rank: Rank, mode: 'remaining' | 'elapsed', utcOverride?: number): string => {
-  const { durationMs, elapsedInInterval } = getAuctionTiming(rank, utcOverride);
-
-  const remainingMs = durationMs - elapsedInInterval;
-  const targetMs = mode === 'remaining' ? remainingMs : elapsedInInterval;
-
-  const minutes = Math.floor(targetMs / 60000);
-  const seconds = Math.floor((targetMs % 60000) / 1000);
-
-  if (minutes === 0) return `${seconds}s`;
-  return `${minutes}m ${seconds}s`;
-};
-
-export const getCurrentAuctionIntervalStartUTC = (rank: Rank): Date => {
-  const now = new Date();
-  const { elapsedInInterval } = getAuctionTiming(rank);
-
-  const intervalStart = new Date(now.getTime() - elapsedInInterval);
-  return new Date(
-    Date.UTC(
-      intervalStart.getUTCFullYear(),
-      intervalStart.getUTCMonth(),
-      intervalStart.getUTCDate(),
-      intervalStart.getUTCHours(),
-      intervalStart.getUTCMinutes(),
-      intervalStart.getUTCSeconds(),
-      intervalStart.getUTCMilliseconds(),
-    ),
-  );
-};
-
-export const parseAuctionTime = (timeStr: string): { minutes: number; seconds: number } => {
-  const match = timeStr.match(/(?:(\d+)m)?\s*(\d+)?s?/);
-  if (!match) return { minutes: 0, seconds: 0 };
-
-  const minutes = match[1] ? parseInt(match[1], 10) : 0;
-  const seconds = match[2] ? parseInt(match[2], 10) : 0;
-  return { minutes, seconds };
-};

package/src/functions/utils/networks.utils.ts

@@ -1,6 +0,0 @@
-import { networkRegistry } from '../../constants';
-
-export const getNetworkName = (chainId: number) => {
-  const network = networkRegistry[chainId];
-  return network ? network.name : 'Unsupported network';
-};

package/src/functions/utils/nftTokenFunctions.ts

@@ -1,25 +0,0 @@
-import { NFT_TRANSACTION_TYPES } from '../../constants/protocol.constants';
-import { Logger } from '../../error-handling';
-import { RPCSimulationAssetChange } from '../../types/tenderly.api.types';
-
-export const extractTokenIdsFromAssetChanges = (assetChanges: RPCSimulationAssetChange[]) => {
-  const nftTokenIds: Record<string, string[]> = {};
-
-  assetChanges.forEach(({ assetInfo, id }) => {
-    if (NFT_TRANSACTION_TYPES.includes(assetInfo.standard) && id) {
-      try {
-        if (assetInfo?.contractAddress) {
-          const contractAddress = assetInfo.contractAddress.toLowerCase();
-          if (!nftTokenIds[contractAddress]) {
-            nftTokenIds[contractAddress] = [];
-          }
-          nftTokenIds[contractAddress].push(BigInt(id).toString());
-        }
-      } catch (err) {
-        Logger.error(`Failed to parse tokenId: ${id}`, err);
-      }
-    }
-  });
-
-  return nftTokenIds;
-};

package/src/functions/utils/nickname.utils.ts

@@ -1,4 +0,0 @@
-export const isNicknameValid = (input: string) => {
-  const nickanameRegexp = /^[a-zA-Z0-9_]{5,24}$/;
-  return input.length > 0 && nickanameRegexp.test(input);
-};

package/src/functions/utils/postToOffscreen.ts

@@ -1,6 +0,0 @@
-import { MessagesFromOffscreen } from '../../types/offscreen.types';
-
-export const postToOffscreen = (type: MessagesFromOffscreen, payload: any) => {
-  if (!window.parent) return;
-  window.parent.postMessage({ type, payload }, '*');
-};

package/src/functions/utils/prepareHinkal.ts

@@ -1,78 +0,0 @@
-import { ethers, Signer } from 'ethers';
-import { preProcessing } from '../../crypto/preProcessing';
-import ethersProvider from '../../providers/EthersProviderAdapter';
-import { networkRegistry } from '../../constants/chains.constants';
-import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
-import { UserKeys } from '../../data-structures/crypto-keys/keys';
-import { createTorRpcProvider } from './create-provider';
-
-export const createSigner = (privateKey: string, chainId: number) => {
-  const rpcUrl = networkRegistry[chainId].fetchRpcUrl;
-  if (!rpcUrl) throw new Error('RPC URL not found for the specified chain ID');
-  const provider = createTorRpcProvider(rpcUrl);
-  return new ethers.Wallet(privateKey, provider);
-};
-
-export const createVoidSigner = (address: string, chainId: number) => {
-  const rpcUrl = networkRegistry[chainId].fetchRpcUrl;
-  if (!rpcUrl) throw new Error('RPC URL not found for the specified chain ID');
-  const provider = createTorRpcProvider(rpcUrl);
-  return new ethers.VoidSigner(address, provider);
-};
-
-export const prepareHinkal = async (hinkal: IHinkal, signer: ethers.Wallet) => {
-  await preProcessing();
-  const providerAdapter = ethersProvider<Signer>();
-  providerAdapter.initSigner?.(signer);
-  await hinkal.initProviderAdapter(undefined, providerAdapter);
-  await hinkal.initUserKeys();
-};
-
-// CASE: INIT WALLET WITH SIGNATURE
-export const prepareHinkalWithSignature = async (
-  hinkal: IHinkal,
-  address: string,
-  chainId: number,
-  signature: string,
-) => {
-  await preProcessing();
-  const providerAdapter = ethersProvider<Signer>();
-  const signer = createVoidSigner(address, chainId);
-  providerAdapter.initSigner?.(signer);
-  await hinkal.initProviderAdapter(undefined, providerAdapter);
-  await hinkal.initUserKeysWithPassword(signature);
-  return signer;
-};
-
-// CASE: CREATE NEW ACCOUNT IN WALLET
-export const prepareToAccessNewWallet = async (hinkal: IHinkal, privateKey: string) => {
-  await preProcessing();
-  const chainId = hinkal.getSelectedNetwork()?.chainId;
-  if (!chainId) throw Error('chainId is undefined');
-
-  const signer = createSigner(privateKey, chainId);
-
-  // We init userKeys here to avoid concurrency issues, userKeys don't depend on Hinkal, requires signer only
-  const providerAdapter = ethersProvider<Signer>();
-  providerAdapter.initSigner?.(signer);
-  const userKeys = new UserKeys(await providerAdapter.signMessage(hinkal.signingMessage));
-
-  return { userKeys, signer };
-};
-
-// CASE: SWITCH TO NEW ACCOUNT IN WALLET
-export const prepareToAccessNewWalletWithSignature = async (hinkal: IHinkal, address: string, signature: string) => {
-  await preProcessing();
-  const chainId = hinkal.getSelectedNetwork()?.chainId;
-  if (!chainId) throw Error('chainId is undefined');
-
-  const signer = createVoidSigner(address, chainId);
-  // We init userKeys here to avoid concurrency issues, userKeys don't depend on Hinkal, requires signer only
-  const providerAdapter = ethersProvider<Signer>();
-  providerAdapter.initSigner?.(signer);
-  const userKeys = new UserKeys(signature);
-
-  await hinkal.switchAccount(signer);
-
-  return userKeys;
-};

package/src/functions/utils/process.utils.ts

@@ -1,23 +0,0 @@
-/** pause execution for a number of miliseconds */
-export const wait = (miliseconds: number) =>
-  new Promise((r) => {
-    setTimeout(r, miliseconds);
-  });
-
-/** only call function once with a given number of milliseconds
- * Ex: let debounceMyFunc = debounce(myFunc, 1000);
- * debounceMyFunc(); debounceMyFunc();
- */
-export function debounce(func: (...args: any[]) => void, debounceForMs: number) {
-  let timeout: string | number | NodeJS.Timeout | undefined;
-
-  return function executedFunction(...args: any[]) {
-    const later = () => {
-      clearTimeout(timeout);
-      func(...args);
-    };
-
-    clearTimeout(timeout);
-    timeout = setTimeout(later, debounceForMs);
-  };
-}

package/src/functions/utils/processUseApprovalUtxoData.ts

@@ -1,26 +0,0 @@
-import { zeroAddress } from '../../constants/protocol.constants';
-import { APPROVED_UTXO_CONVERSION_COUNT } from '../../constants/conversion.constants';
-import { UseApprovalUTXOData } from '../../types/hinkal.types';
-
-const padArray = <T>(arr: T[], padWith: T, targetLength: number) => {
-  const arrClone = [...arr];
-  while (arrClone.length < targetLength) arrClone.push(padWith);
-  return arrClone;
-};
-
-export const padUseApprovalUtxoData = (useApprovalUtxoData: UseApprovalUTXOData) => {
-  const result = structuredClone(useApprovalUtxoData);
-
-  result.approvalChanges = padArray(result.approvalChanges, 0n, APPROVED_UTXO_CONVERSION_COUNT);
-  result.conversionInHinkalAddress = padArray(result.conversionInHinkalAddress, 0n, APPROVED_UTXO_CONVERSION_COUNT);
-  result.externalApprovalAddresses = padArray(
-    result.externalApprovalAddresses,
-    zeroAddress,
-    APPROVED_UTXO_CONVERSION_COUNT,
-  );
-  return result;
-};
-
-export const isUseApprovalDataEmpty = (useApprovalUtxoData: UseApprovalUTXOData) => {
-  return useApprovalUtxoData.approvalChanges[0] === 0n;
-};

package/src/functions/utils/publicBalance.utils.ts

@@ -1,131 +0,0 @@
-import { ethers } from 'ethers';
-import { networkRegistry } from '../../constants/chains.constants';
-import { TokenType, zeroAddress } from '../../constants/protocol.constants';
-import { ERC20Token, NFT, TokenBalance } from '../../types/token.types';
-import { getErc20TokensForChain, isNFTToken } from './erc20tokenFunctions';
-import { ERC20ABI } from '../../externalABIs/swapAbi';
-import { Logger } from '../../error-handling/logger';
-import { ERC1155ABI, ERC721ABI } from '../../externalABIs';
-import { getFormattedIpfsUrl } from './ipfs';
-import { createTorRpcProvider } from './create-provider';
-import { httpClient } from '../../data-structures/tor';
-
-const createProvider = (chainId: number): ethers.providers.Provider => {
-  const { fetchRpcUrl } = networkRegistry[chainId];
-
-  if (!fetchRpcUrl) {
-    throw new Error(`No RPC URL configured for chain ${chainId}`);
-  }
-
-  return createTorRpcProvider(fetchRpcUrl);
-};
-
-export const getPublicBalance = async (
-  provider: ethers.providers.JsonRpcProvider,
-  ethereumAddress: string,
-  token: ERC20Token,
-) => {
-  try {
-    const contractAddress = token.erc20TokenAddress;
-    let fetchedBalance;
-
-    const contract = new ethers.Contract(token.erc20TokenAddress, ERC20ABI, provider);
-    if (contractAddress !== zeroAddress) {
-      fetchedBalance = await contract?.['balanceOf'](ethereumAddress);
-    } else {
-      fetchedBalance = await contract.provider.getBalance(ethereumAddress);
-    }
-
-    const balance = fetchedBalance.toBigInt();
-    if (balance <= 0n) return null;
-
-    return { token, balance } as TokenBalance;
-  } catch {
-    return null;
-  }
-};
-
-const getNFTBalance = async (
-  provider: ethers.providers.JsonRpcProvider,
-  token: ERC20Token,
-): Promise<TokenBalance | null> => {
-  const isERC721 = token.nftTokenType === TokenType.ERC721;
-  const nftContract = new ethers.Contract(token.erc20TokenAddress, isERC721 ? ERC721ABI : ERC1155ABI, provider);
-  const { tokenIds } = token;
-  if (!tokenIds?.length) return null;
-
-  const nfts: NFT[] = await Promise.all(
-    tokenIds.map(async (tokenId) => {
-      try {
-        const uri = await nftContract[isERC721 ? 'tokenURI' : 'uri'](tokenId);
-        const tokenURI = uri.startsWith('ipfs://') ? getFormattedIpfsUrl(uri, false) : uri;
-        const replacedUri = isERC721 ? tokenURI : tokenURI.replace('{id}', tokenId);
-        if (replacedUri) {
-          const metaData = await httpClient.get(replacedUri);
-          if (metaData?.image?.startsWith('ipfs://')) {
-            metaData.image = getFormattedIpfsUrl(metaData.image, false);
-          }
-          return { image: metaData.image, tokenId: Number(tokenId), name: metaData.name };
-        }
-        return { tokenId: Number(tokenId) };
-      } catch (e) {
-        return { tokenId: Number(tokenId) };
-      }
-    }),
-  );
-
-  return {
-    token,
-    balance: tokenIds?.length ? BigInt(tokenIds.length) : 0n,
-    nfts,
-  };
-};
-
-export const getPublicBalancesOfTokens = async (
-  chainId: number,
-  ethereumAddress: string,
-  tokens?: ERC20Token[],
-): Promise<TokenBalance[]> => {
-  const tokensList = tokens ?? getErc20TokensForChain(chainId);
-  const provider = createProvider(chainId);
-
-  const balances: (TokenBalance | null)[] = await Promise.all(
-    tokensList.map(async (token) => {
-      return isNFTToken(token)
-        ? getNFTBalance(provider as any, token)
-        : getPublicBalance(provider as any, ethereumAddress, token);
-    }),
-  );
-  return balances.filter((token): token is TokenBalance => token !== null);
-};
-
-export const getPublicBalanceByTokenAddress = async (
-  chainId: number,
-  ethereumAddress: string,
-  tokenAddress: string,
-): Promise<bigint | null> => {
-  try {
-    const provider = createProvider(chainId);
-    const contract = new ethers.Contract(tokenAddress, ERC20ABI, provider);
-    let fetchedBalance;
-    if (tokenAddress !== zeroAddress) {
-      fetchedBalance = await contract?.['balanceOf'](ethereumAddress);
-    } else {
-      fetchedBalance = await provider.getBalance(ethereumAddress);
-    }
-    return fetchedBalance.toBigInt();
-  } catch {
-    Logger.error(`Failed to fetch public balance for address ${ethereumAddress}`);
-    return null;
-  }
-};
-
-export const getPublicTransactionCount = async (chainId: number, ethereumAddress: string): Promise<number | null> => {
-  try {
-    const provider = createProvider(chainId);
-    return await provider.getTransactionCount(ethereumAddress);
-  } catch (error) {
-    Logger.error(`Failed to fetch transaction count for address ${ethereumAddress} on chain ${chainId}`, error);
-    return null;
-  }
-};

package/src/functions/utils/reloadPage.ts

@@ -1 +0,0 @@
-export const reloadPage = () => window.location.reload();

package/src/functions/utils/replaceAddressInCalldata.ts

@@ -1,6 +0,0 @@
-export const replaceAddressesInCalldata = (callDataString: string, searchFor: string, replacement: string) => {
-  const searchForWithout0x = searchFor.slice(2);
-  const replacementWithout0x = replacement.slice(2);
-
-  return callDataString.toLowerCase().split(searchForWithout0x.toLowerCase()).join(replacementWithout0x.toLowerCase());
-};

package/src/functions/utils/requireEnv.ts

@@ -1,10 +0,0 @@
-export const requireEnv = (environmentVariableName: string): string => {
-  const envVar = process.env[environmentVariableName];
-  if (envVar === undefined) {
-    console.log(`Error: ${environmentVariableName} environment variable not set`);
-    // TODO: Do not exit here
-    process.exitCode = 1;
-    process.exit();
-  }
-  return envVar;
-};

package/src/functions/utils/resolve-sync.utils.ts

@@ -1,40 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const resolveSync = (promiseFns: (() => Promise<any>)[]): Promise<void> =>
-  promiseFns.reduce((result, promise) => result.then(() => promise()), Promise.resolve());
-
-export const getSequence = (
-  fromBlockNumber: number,
-  lastBlockNumber: number,
-  maxPageSize: number | undefined,
-): { from: number; to: number }[] => {
-  const requestSequence: { from: number; to: number }[] = [];
-  if (maxPageSize) {
-    let nextFromBlockNumber = fromBlockNumber;
-    while (nextFromBlockNumber <= lastBlockNumber) {
-      const to = Math.min(nextFromBlockNumber + maxPageSize - 1, lastBlockNumber);
-      requestSequence.push({
-        from: nextFromBlockNumber,
-        to,
-      });
-      nextFromBlockNumber = to + 1;
-    }
-  } else {
-    requestSequence.push({
-      from: fromBlockNumber,
-      to: lastBlockNumber,
-    });
-  }
-  return requestSequence;
-};
-
-export const promisify = (callback: () => Promise<any>, timeout = 100) =>
-  new Promise((resolve, reject) => {
-    setTimeout(async () => {
-      try {
-        await callback();
-        resolve(0);
-      } catch (err: unknown) {
-        reject(err);
-      }
-    }, timeout);
-  });

package/src/functions/utils/rpc-int-encode.ts

@@ -1,7 +0,0 @@
-import { ethers } from 'ethers';
-
-export const rpcIntEncode = (value: ethers.BigNumberish) => {
-  const bigNumberValue = ethers.BigNumber.from(value);
-
-  return ethers.utils.hexValue(bigNumberValue);
-};

package/src/functions/utils/serialize.utils.ts

@@ -1,12 +0,0 @@
-export const CustomJSONStringify = (args: any) => {
-  return JSON.stringify(args, (_, value) => (typeof value === 'bigint' ? `bigint:${value.toString()}` : value));
-};
-
-export const CustomJSONParse = (stringifiedJSON: string) => {
-  return JSON.parse(stringifiedJSON, (_, value) => {
-    if (typeof value === 'string' && value.startsWith('bigint:')) {
-      return BigInt(value.slice(7));
-    }
-    return value;
-  });
-};

package/src/functions/utils/string.utils.ts

@@ -1,92 +0,0 @@
-import { networkRegistry } from '../../constants/chains.constants';
-
-/** Capitalize the first letter of each word
- * "This is an example" => "This Is An Example"
- */
-export function toTitleCase(str: string) {
-  return str
-    ?.toLowerCase()
-    .split(' ')
-    .map((s) => s.charAt(0).toUpperCase() + s.substring(1))
-    .join(' ');
-}
-
-/** Capitalize the first letter of a string */
-export function capitalizeFirstLetter(str: string) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-/** Returns true if a value is null, undefined, or an empty object, array (length 0), or string (e.g. '') */
-export function isNullOrEmpty(obj: unknown) {
-  if (!obj) {
-    return true;
-  }
-  if (obj === null) {
-    return true;
-  }
-  // Check for an empty array too
-  if (Array.isArray(obj)) {
-    if (obj.length === 0) {
-      return true;
-    }
-  }
-  return Object.keys(obj).length === 0 && obj.constructor === Object;
-}
-
-export const hexToUtf8 = (hex: string): string => {
-  // Remove the '0x' prefix if it exists
-  if (hex.startsWith('0x')) {
-    hex = hex.slice(2);
-  }
-
-  // Convert hex to bytes
-  const bytes = [];
-  for (let i = 0; i < hex.length; i += 2) {
-    const byte = parseInt(hex.slice(i, i + 2), 16);
-    bytes.push(byte);
-  }
-
-  // Convert bytes to a UTF-8 string
-  const utf8String = new TextDecoder('utf-8').decode(new Uint8Array(bytes));
-  return utf8String;
-};
-
-// If you make any changes to the logic in this function,
-// ensure that the getChainIdFromStateKey function is also updated accordingly.
-export const getStateKey = (address: string, chainId: number, withHinkalContractAddress = false): string => {
-  const baseKey = `${address}-${chainId}`;
-  if (withHinkalContractAddress) {
-    const { hinkalAddress } = networkRegistry[chainId].contractData;
-    return `${baseKey}-${hinkalAddress}`.toLowerCase();
-  }
-  return baseKey.toLowerCase();
-};
-
-// This function parses the chainId from the state key generated by getStateKey.
-// Note: Must stay in sync with getStateKey's format.
-export const getChainIdFromStateKey = (stateKey: string): number => {
-  const [, chainId] = stateKey.split('-');
-  return Number(chainId);
-};
-
-export const replaceAllInstances = (text: string, oldPart: string, newPart: string): string => {
-  if (!oldPart || !newPart) {
-    throw Error('oldPart and newPart must be provided');
-  }
-
-  // replaceAll() not available: using split&join
-  return text.toLowerCase().split(oldPart.toLowerCase()).join(newPart.toLowerCase());
-};
-
-export const capitalizeName = (name: string | undefined | null): string | null => {
-  if (!name || name.trim().length === 0) return null;
-
-  return name.toLowerCase().replace(/\b\w/g, (char) => char.toUpperCase());
-};
-
-export const validateEmail = (email: string | undefined | null): boolean => {
-  if (!email) return false;
-
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(email);
-};