@sabaaa1/common 0.0.4 → 0.0.7

package/src/functions/utils/time.utils.ts

@@ -0,0 +1,80 @@
+export const waitLittle = (time = 1000) =>
+  new Promise((res) => {
+    setTimeout(() => {
+      res(undefined);
+    }, time);
+  });
+
+export const getCurrentTimeInSeconds = (): number => Math.floor(Date.now() / 1000);
+
+export const msToISOString = (ms: number) => new Date(ms).toISOString();
+
+export const getEffectiveToday = (): Date => {
+  const now = new Date();
+  const today6Utc = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), 6, 0, 0, 0));
+  const effectiveToday = now < today6Utc ? new Date(today6Utc.setUTCDate(today6Utc.getUTCDate() - 1)) : today6Utc;
+  return effectiveToday;
+};
+
+export const getEffectiveSevenDaysAgo = (): Date => {
+  const effectiveToday = getEffectiveToday();
+  const sevenDaysAgo = new Date(effectiveToday);
+  sevenDaysAgo.setUTCDate(sevenDaysAgo.getUTCDate() - 6);
+  return sevenDaysAgo;
+};
+
+export const getEffectiveMonthStart = (): Date => {
+  const effectiveToday = getEffectiveToday();
+  const monthStart = new Date(Date.UTC(effectiveToday.getUTCFullYear(), effectiveToday.getUTCMonth(), 1, 6, 0, 0, 0));
+  return monthStart;
+};
+
+export const getCurrentWeekStart = (): Date => {
+  const effectiveDate = getEffectiveToday();
+  const day = effectiveDate.getUTCDay();
+  const diff = (day + 6) % 7;
+  const monday = new Date(effectiveDate);
+  monday.setUTCDate(effectiveDate.getUTCDate() - diff);
+  monday.setUTCHours(6, 0, 0, 0);
+  return monday;
+};
+
+export const getPreviousWeekStart = (): Date => {
+  const currentWeekStart = getCurrentWeekStart();
+  currentWeekStart.setUTCDate(currentWeekStart.getUTCDate() - 7);
+  return currentWeekStart;
+};
+
+export const getNextDayDelay = () => {
+  const now = new Date();
+  const next = new Date(now);
+  next.setUTCHours(6, 0, 0, 0);
+  if (next <= now) next.setUTCDate(next.getUTCDate() + 1);
+  return next.getTime() - now.getTime();
+};
+
+export const getCurrentDayStart = (): Date => {
+  const now = new Date();
+  const today6Utc = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), 6, 0, 0, 0));
+  if (now < today6Utc) today6Utc.setUTCDate(today6Utc.getUTCDate() - 1);
+  return today6Utc;
+};
+
+export const getNextDayISO = (): string => {
+  const now = new Date();
+  const next = new Date(now);
+  next.setUTCHours(6, 0, 0, 0);
+  if (next <= now) next.setUTCDate(next.getUTCDate() + 1);
+  return next.toISOString();
+};
+
+export const formatDate = (date: Date): string => {
+  const now = new Date();
+  const isSameYear = now.getFullYear() === date.getFullYear();
+
+  const options: Intl.DateTimeFormatOptions = isSameYear
+    ? { month: 'long', day: 'numeric' }
+    : { month: 'long', day: 'numeric', year: 'numeric' };
+
+  return date.toLocaleDateString(undefined, options);
+};

package/src/functions/utils/token-check.utils.ts

@@ -0,0 +1,12 @@
+import { API } from '../../API/API';
+
+export const checkTokensForShielding = async (chainId: number, erc20Addresses: string[]) => {
+  const tokens = await API.tokensInfoCall(chainId, erc20Addresses);
+  const nonEligibleTokens: string[] = [];
+  tokens.forEach((token, index) => {
+    if (!token || !token.balanceStorageOffset || !token.allowanceStorageOffset) {
+      nonEligibleTokens.push(erc20Addresses[index]);
+    }
+  });
+  return nonEligibleTokens;
+};

package/src/functions/utils/trimFieldValues.ts

@@ -0,0 +1,24 @@
+const demarcationsDefaultValue = [
+  { value: 1000000000, unit: 'b' },
+  { value: 1000000, unit: 'm' },
+  { value: 1000, unit: 'k' },
+];
+export const trimFieldValues = (
+  value: number,
+  demarcations: { value: number; unit: string }[] = demarcationsDefaultValue,
+  showDollarSign = true,
+): string => {
+  demarcations.sort((d1, d2) => d2.value - d1.value);
+
+  const prefix = showDollarSign ? '$' : '';
+
+  if (value < demarcations[demarcations.length - 1].value) return `$${value.toFixed(2)}`;
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const dem of demarcations) {
+    if (value >= dem.value) {
+      return `${prefix}${(Math.round((100 * value) / dem.value) / 100).toFixed(2) + dem.unit}`;
+    }
+  }
+  return `${prefix}${value}`;
+};

package/src/functions/utils/upToDateState.ts

@@ -0,0 +1,12 @@
+import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+import { caseInsensitiveEqual } from './caseInsensitive.utils';
+
+export const checkChainOrAddressNotUpdated = async (hinkal: IHinkal, oldChainId: number, oldEthAddress: string) => {
+  const newEthAddress = await hinkal.getEthereumAddress();
+  const newChainId = hinkal.getCurrentChainId();
+  if (newChainId !== oldChainId || !caseInsensitiveEqual(newEthAddress, oldEthAddress)) {
+    throw Error(transactionErrorCodes.ERROR_MESSAGE_CHAIN_ADDRESS_CHANGED);
+  }
+  return true;
+};

package/src/functions/utils/userAgent.ts

@@ -0,0 +1,26 @@
+import { UNSUPPORTED_WALLET_IDS, UNSUPPORTED_WALLETS_WALLETCONNECT_NAMES } from '../../constants';
+import { UAParser } from 'ua-parser-js';
+import { Connector } from 'wagmi';
+
+const parser = new UAParser();
+
+const SUPPORTED_SAFARI_VERSIONS = 17; // Supported 17 and up
+
+export const browserSupported = (): boolean => {
+  const { name, version } = parser.getBrowser();
+  const majorVersion = parseInt(version?.split('.')[0] ?? '0', 10);
+
+  if (name === 'Safari' && majorVersion && SUPPORTED_SAFARI_VERSIONS > majorVersion) {
+    return false;
+  }
+  return true;
+};
+
+export const walletSupported = (provider: any, connector: Connector): boolean => {
+  const isWalletConnect = connector?.type === 'walletConnect';
+  const providerName = provider?.session?.peer?.metadata?.name;
+  if (isWalletConnect && Object.values(UNSUPPORTED_WALLETS_WALLETCONNECT_NAMES).includes(providerName)) return false;
+  if (Object.values(UNSUPPORTED_WALLET_IDS).includes(connector?.id)) return false;
+
+  return true;
+};

package/src/functions/utils/walletBalances.utils.ts

@@ -0,0 +1,117 @@
+import { zeroAddress } from '../../constants/protocol.constants';
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+import { ERC20Token, TokenBalance, TokenChanges } from '../../types/token.types';
+import { absBigInt } from './amounts.utils';
+import { caseInsensitiveEqual } from './caseInsensitive.utils';
+import { getPublicBalancesOfTokens } from './publicBalance.utils';
+import { getAmountInWei } from '../web3/etherFunctions';
+
+export const getNecessaryAssetsForFundingFromBalance = (
+  tokenChanges: TokenChanges<bigint>[],
+  subAccountBalances: TokenBalance[],
+): {
+  fundAmounts: bigint[];
+  tokensToFund: ERC20Token[];
+} => {
+  if (!tokenChanges?.length) return { fundAmounts: [], tokensToFund: [] };
+
+  const changes = tokenChanges.reduce<{
+    fundAmounts: bigint[];
+    tokensToFund: ERC20Token[];
+  }>(
+    (acc, { amount, token }) => {
+      if (amount >= 0n) return acc;
+      const requiredAmount = -amount;
+      const availableAmount =
+        subAccountBalances.find((balance) =>
+          caseInsensitiveEqual(balance.token.erc20TokenAddress, token.erc20TokenAddress),
+        )?.balance ?? 0n;
+
+      if (availableAmount < requiredAmount) {
+        acc.tokensToFund.push(token);
+        acc.fundAmounts.push(requiredAmount - availableAmount);
+      }
+
+      return acc;
+    },
+    { fundAmounts: [], tokensToFund: [] },
+  );
+  return changes;
+};
+
+export const getNecessaryAssetsForFunding = async (
+  hinkal: IHinkal,
+  walletAddress: string,
+  tokenChanges: TokenChanges<bigint>[],
+) => {
+  if (!tokenChanges?.length)
+    return { fundAmounts: [], tokensToFund: [], approveTokenAddresses: [], approvedTokenAmounts: [] };
+
+  const chainId = hinkal.getCurrentChainId();
+  const subAccountBalances = await getPublicBalancesOfTokens(
+    chainId,
+    walletAddress,
+    tokenChanges.map(({ token }) => token),
+  );
+
+  const { fundAmounts, tokensToFund } = getNecessaryAssetsForFundingFromBalance(tokenChanges, subAccountBalances);
+
+  const approveTokenAddresses = tokenChanges.length
+    ? tokenChanges
+        .filter(({ amount, token }) => amount < 0n && token.erc20TokenAddress !== zeroAddress)
+        .map(({ token }) => token.erc20TokenAddress)
+    : [];
+
+  const approvedTokenAmounts = approveTokenAddresses.map(() => 2n ** 256n - 1n);
+
+  return { fundAmounts, tokensToFund, approveTokenAddresses, approvedTokenAmounts };
+};
+
+export const getNecessaryApprovalChangesData = (hinkal: IHinkal, tokenChanges: TokenChanges<bigint>[], to: string) => {
+  const myApprovedAmounts = tokenChanges.map((erc20Token) => {
+    if (erc20Token.amount < 0n) {
+      const myApproval = hinkal.getMyApprovalAmountForInteraction(to, erc20Token.token.erc20TokenAddress);
+      return myApproval;
+    }
+    return 0n;
+  });
+
+  // approvalChanges is essentially the min(myApprovedAmounts,amount)
+  const approvalChanges = tokenChanges.map((_token, index) => {
+    if (_token.amount < 0n) {
+      if (myApprovedAmounts[index] > 0n) {
+        // if my approval is more than is required -> put only what required
+        // if my approval is less than is required -> put approval
+        return absBigInt(_token.amount) < absBigInt(myApprovedAmounts[index])
+          ? _token.amount
+          : -myApprovedAmounts[index];
+      }
+      return 0n;
+    }
+    return 0n;
+  });
+
+  return { approvalChanges };
+};
+
+export function hasEnoughBalance(
+  tokenAmount: string,
+  maxPossibleAmount: string,
+  token?: ERC20Token,
+  isDollarMode?: boolean,
+  tokenPriceDollar?: number,
+): boolean {
+  try {
+    if (!token || !tokenAmount) return true;
+
+    if (isDollarMode) {
+      if (!tokenPriceDollar) return true;
+
+      return +tokenAmount * tokenPriceDollar <= +maxPossibleAmount;
+    }
+
+    return getAmountInWei(token, tokenAmount) <= getAmountInWei(token, maxPossibleAmount);
+  } catch (err) {
+    return true;
+  }
+}

package/src/functions/web3/EIP-712.test.ts

@@ -0,0 +1,302 @@
+import { getPermitInfo } from './EIP-712';
+
+describe('getPermitInfo', () => {
+  describe('Different types of permit', () => {
+    it('Permit', () => {
+      const requestMessage = {
+        types: {
+          Permit: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' },
+            { name: 'value', type: 'uint256' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' },
+          ],
+        },
+        primaryType: 'Permit',
+        domain: {
+          name: 'USD Coin',
+          version: '2',
+          chainId: 1,
+          verifyingContract: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3',
+        },
+        message: {
+          owner: '0x1234...5678',
+          spender: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+          value: '1000000000',
+          nonce: 0,
+          deadline: 1703980800,
+        },
+      };
+      const result = getPermitInfo(
+        requestMessage.message,
+        requestMessage.types,
+        requestMessage.domain,
+        requestMessage.primaryType,
+      );
+
+      expect(result.isPermit).toBe(true);
+      expect(result.tokenDetails).toEqual([
+        {
+          token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3',
+          amount: '115792089237316195423570985008687907853269984665640564039457584007913129639935',
+        },
+      ]);
+      expect(result.spender).toBeUndefined();
+    });
+
+    it('PermitBatch', () => {
+      const requestMessage = {
+        types: {
+          PermitBatch: [
+            { name: 'details', type: 'PermitDetails[]' },
+            { name: 'spender', type: 'address' },
+            { name: 'sigDeadline', type: 'uint256' },
+          ],
+          PermitDetails: [
+            { name: 'token', type: 'address' },
+            { name: 'amount', type: 'uint160' },
+            { name: 'expiration', type: 'uint48' },
+            { name: 'nonce', type: 'uint48' },
+          ],
+        },
+        primaryType: 'PermitBatch',
+        domain: {
+          name: 'Permit2',
+          chainId: 1,
+          verifyingContract: '0x000000000022D473030F116dDEE9F6B43aC78BA3',
+        },
+        message: {
+          details: [
+            {
+              token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3',
+              amount: '1000000000',
+              expiration: 1703980800,
+              nonce: 0,
+            },
+            {
+              token: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+              amount: '500000000',
+              expiration: 1703980800,
+              nonce: 1,
+            },
+          ],
+          spender: '0x1111111254EEB25477B68fb85Ed929f73A960582',
+          sigDeadline: 1703980800,
+        },
+      };
+      const result = getPermitInfo(
+        requestMessage.message,
+        requestMessage.types,
+        requestMessage.domain,
+        requestMessage.primaryType,
+      );
+      expect(result.isPermit).toBe(true);
+      const tokenChanges = result.tokenDetails?.map((token) => ({
+        token: token.token,
+        amount: token.amount,
+      }));
+      expect(tokenChanges).toEqual([
+        { token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3', amount: '1000000000' },
+        { token: '0xdAC17F958D2ee523a2206206994597C13D831ec7', amount: '500000000' },
+      ]);
+      expect(result.spender).toBe('0x000000000022D473030F116dDEE9F6B43aC78BA3');
+    });
+
+    it('PermitSingle', () => {
+      const requestMessage = {
+        types: {
+          PermitSingle: [
+            { name: 'details', type: 'PermitDetails' },
+            { name: 'spender', type: 'address' },
+            { name: 'sigDeadline', type: 'uint256' },
+          ],
+          PermitDetails: [
+            { name: 'token', type: 'address' },
+            { name: 'amount', type: 'uint160' },
+            { name: 'expiration', type: 'uint48' },
+            { name: 'nonce', type: 'uint48' },
+          ],
+        },
+        primaryType: 'PermitSingle',
+        domain: {
+          name: 'Permit2',
+          chainId: 1,
+          verifyingContract: '0x000000000022D473030F116dDEE9F6B43aC78BA3',
+        },
+        message: {
+          details: {
+            token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3',
+            amount: '1000000000',
+            expiration: 1703980800,
+            nonce: 0,
+          },
+          spender: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+          sigDeadline: 1703980800,
+        },
+      };
+      const result = getPermitInfo(
+        requestMessage.message,
+        requestMessage.types,
+        requestMessage.domain,
+        requestMessage.primaryType,
+      );
+      expect(result.isPermit).toBe(true);
+      const tokenChanges = result.tokenDetails?.map((token) => ({
+        token: token.token,
+        amount: token.amount,
+      }));
+      expect(tokenChanges).toEqual([{ token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3', amount: '1000000000' }]);
+      expect(result.spender).toBe('0x000000000022D473030F116dDEE9F6B43aC78BA3');
+    });
+
+    it('PermitTransferFrom', () => {
+      const requestMessage = {
+        types: {
+          PermitTransferFrom: [
+            { name: 'permitted', type: 'TokenPermissions' },
+            { name: 'spender', type: 'address' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' },
+          ],
+          TokenPermissions: [
+            { name: 'token', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+          ],
+        },
+        primaryType: 'PermitTransferFrom',
+        domain: {
+          name: 'Permit2',
+          chainId: 1,
+          verifyingContract: '0x000000000022D473030F116dDEE9F6B43aC78BA3',
+        },
+        message: {
+          permitted: {
+            token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3',
+            amount: '1000000000',
+          },
+          spender: '0x1234...5678',
+          nonce: 0,
+          deadline: 1703980800,
+        },
+      };
+      const result = getPermitInfo(
+        requestMessage.message,
+        requestMessage.types,
+        requestMessage.domain,
+        requestMessage.primaryType,
+      );
+      expect(result.isPermit).toBe(true);
+      expect(result.tokenDetails).toEqual([
+        { token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3', amount: '1000000000' },
+      ]);
+      expect(result.spender).toBe('0x000000000022D473030F116dDEE9F6B43aC78BA3');
+    });
+
+    it('PermitBatchTransferFrom', () => {
+      const requestMessage = {
+        types: {
+          PermitBatchTransferFrom: [
+            { name: 'permitted', type: 'TokenPermissions[]' },
+            { name: 'spender', type: 'address' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' },
+          ],
+          TokenPermissions: [
+            { name: 'token', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+          ],
+        },
+        primaryType: 'PermitBatchTransferFrom',
+        domain: {
+          name: 'Permit2',
+          chainId: 1,
+          verifyingContract: '0x000000000022D473030F116dDEE9F6B43aC78BA3',
+        },
+        message: {
+          permitted: [
+            {
+              token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3',
+              amount: '1000000000',
+            },
+            {
+              token: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+              amount: '500000000',
+            },
+          ],
+          spender: '0x1234...5678',
+          nonce: 0,
+          deadline: 1703980800,
+        },
+      };
+      const result = getPermitInfo(
+        requestMessage.message,
+        requestMessage.types,
+        requestMessage.domain,
+        requestMessage.primaryType,
+      );
+      expect(result.isPermit).toBe(true);
+      expect(result.tokenDetails).toEqual([
+        { token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3', amount: '1000000000' },
+        { token: '0xdAC17F958D2ee523a2206206994597C13D831ec7', amount: '500000000' },
+      ]);
+      expect(result.spender).toBe('0x000000000022D473030F116dDEE9F6B43aC78BA3');
+    });
+
+    it('PermitWitnessTransferFrom', () => {
+      const requestMessage = {
+        types: {
+          PermitWitnessTransferFrom: [
+            { name: 'permitted', type: 'TokenPermissions' },
+            { name: 'spender', type: 'address' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' },
+            { name: 'witness', type: 'OrderWitness' },
+          ],
+          TokenPermissions: [
+            { name: 'token', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+          ],
+          OrderWitness: [
+            { name: 'buyer', type: 'address' },
+            { name: 'seller', type: 'address' },
+            { name: 'orderHash', type: 'bytes32' },
+            { name: 'price', type: 'uint256' },
+          ],
+        },
+        primaryType: 'PermitWitnessTransferFrom',
+        domain: {
+          name: 'Permit2',
+          chainId: 1,
+          verifyingContract: '0x000000000022D473030F116dDEE9F6B43aC78BA3',
+        },
+        message: {
+          permitted: {
+            token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3',
+            amount: '1000000000',
+          },
+          spender: '0x1234...5678',
+          nonce: 0,
+          deadline: 1703980800,
+          witness: {
+            buyer: '0x1234...5678',
+            seller: '0x8765...4321',
+            orderHash: '0xabcd...ef01',
+            price: '1000000000',
+          },
+        },
+      };
+      const result = getPermitInfo(
+        requestMessage.message,
+        requestMessage.types,
+        requestMessage.domain,
+        requestMessage.primaryType,
+      );
+      expect(result.isPermit).toBe(true);
+      expect(result.tokenDetails).toEqual([
+        { token: '0xA0b86a33E6441c60c6A5b3c01c3De85A3c9Cb4F3', amount: '1000000000' },
+      ]);
+      expect(result.spender).toBe('0x000000000022D473030F116dDEE9F6B43aC78BA3');
+    });
+  });
+});