@sabaaa1/common 0.0.5 → 0.0.7

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/functions/utils/replaceAddressInCalldata.ts

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

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

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

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

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

@@ -0,0 +1,92 @@
+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);
+};