@sabaaa1/common 0.0.1 → 0.0.3

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

@@ -1,243 +0,0 @@
-import { ethers, TypedDataField } from 'ethers';
-import { DecodedTypedMessageValue } from '../../types/message.types';
-
-export const decodeMessage = (
-  message: Record<string, any>,
-  typeDefinition: TypedDataField[],
-  types: Record<string, TypedDataField[]>,
-): Record<string, DecodedTypedMessageValue> => {
-  return typeDefinition.reduce(
-    (result, { name, type }) => {
-      const value = message[name];
-
-      if (type.endsWith('[]')) {
-        const baseType = type.slice(0, -2);
-        if (types[baseType] && Array.isArray(value)) {
-          const arrayResult = value.reduce(
-            (acc, item, index) => ({
-              ...acc,
-              [index]: {
-                value: decodeMessage(item, types[baseType], types),
-                type: baseType,
-              },
-            }),
-            {},
-          );
-          return {
-            ...result,
-            [name]: {
-              value: arrayResult,
-              type,
-            },
-          };
-        }
-        return {
-          ...result,
-          [name]: {
-            value,
-            type,
-          },
-        };
-      }
-
-      if (types[type]) {
-        return {
-          ...result,
-          [name]: {
-            value: decodeMessage(value, types[type], types),
-            type,
-          },
-        };
-      }
-
-      return {
-        ...result,
-        [name]: {
-          value,
-          type,
-        },
-      };
-    },
-    {} as Record<string, DecodedTypedMessageValue>,
-  );
-};
-
-export const getDecodedMessage = (
-  message: Record<string, any>,
-  types: Record<string, TypedDataField[]>,
-  primaryType: string,
-) => {
-  const decodedMessage = decodeMessage(message, types[primaryType], types);
-  return {
-    primaryType: {
-      value: primaryType,
-      type: 'string',
-    },
-    ...decodedMessage,
-  };
-};
-
-enum PrimaryTypePermit {
-  Permit = 'Permit',
-  PermitWithExpiry = 'PermitWithExpiry',
-  PermitBatch = 'PermitBatch',
-  PermitBatchTransferFrom = 'PermitBatchTransferFrom',
-  PermitSingle = 'PermitSingle',
-  PermitTransferFrom = 'PermitTransferFrom',
-  PermitWitnessTransferFrom = 'PermitWitnessTransferFrom',
-}
-
-const permitTypes = [
-  'Permit',
-  'PermitWithExpiry',
-  'PermitBatch',
-  'PermitBatchTransferFrom',
-  'PermitSingle',
-  'PermitTransferFrom',
-  'PermitWitnessTransferFrom',
-];
-
-type TokenDetail = {
-  token: string;
-  amount: string;
-};
-
-const extractTokenDetailsByPrimaryType = (
-  message: Record<string, unknown>,
-  primaryType: string,
-): TokenDetail[] | undefined => {
-  let tokenDetails: TokenDetail | TokenDetail[] | undefined;
-
-  switch (primaryType) {
-    case PrimaryTypePermit.PermitSingle:
-    case PrimaryTypePermit.PermitBatch:
-      tokenDetails = message['details'] as TokenDetail | TokenDetail[];
-      break;
-    case PrimaryTypePermit.PermitBatchTransferFrom:
-    case PrimaryTypePermit.PermitTransferFrom:
-    case PrimaryTypePermit.PermitWitnessTransferFrom:
-      tokenDetails = message['permitted'] as TokenDetail | TokenDetail[];
-      break;
-    default:
-      break;
-  }
-
-  if (!tokenDetails) return undefined;
-
-  if (Array.isArray(tokenDetails)) return tokenDetails;
-
-  return [tokenDetails];
-};
-
-const detectPermitAndGetTokenAddress = (
-  message: Record<string, any>,
-  types: Record<string, TypedDataField[]>,
-  primaryType: string,
-): { isPermit: boolean; tokenDetails: TokenDetail[] } => {
-  // Check if types definition includes Permit-like structure
-  const hasPermitTypeDefinition = Object.keys(types).some((type) => permitTypes.includes(type));
-
-  if (!hasPermitTypeDefinition) return { isPermit: false, tokenDetails: [] };
-
-  const tokenDetails = extractTokenDetailsByPrimaryType(message, primaryType);
-  if (!tokenDetails) return { isPermit: true, tokenDetails: [] };
-
-  return {
-    isPermit: true,
-    tokenDetails,
-  };
-};
-
-export const getPermitInfo = (
-  message: Record<string, any>,
-  types: Record<string, TypedDataField[]>,
-  domain: Record<string, unknown>,
-  primaryType: string,
-) => {
-  const { isPermit, tokenDetails } = detectPermitAndGetTokenAddress(message, types, primaryType);
-  if (!isPermit) return { isPermit: false };
-
-  let spender: string | undefined;
-
-  if (!tokenDetails.length) {
-    const verifyingContract = domain['verifyingContract'] as string | undefined;
-    if (verifyingContract) {
-      tokenDetails.push({
-        token: verifyingContract,
-        amount: ethers.constants.MaxUint256.toString(),
-      });
-    }
-  } else {
-    spender = domain['verifyingContract'] as string | undefined;
-  }
-
-  return {
-    isPermit,
-    tokenDetails,
-    spender,
-  };
-};
-
-// EXAMPLE OF PERMIT MESSAGE:
-
-// {
-//   "types": {
-//     "EIP712Domain": [
-//       { "name": "name",              "type": "string"   },
-//       { "name": "version",           "type": "string"   },
-//       { "name": "chainId",           "type": "uint256"  },
-//       { "name": "verifyingContract", "type": "address"  }
-//     ],
-//     "Condition": [
-//       { "name": "key",     "type": "string"  },
-//       { "name": "allowed", "type": "bool"    }
-//     ],
-//     "Allowance": [
-//       { "name": "token",      "type": "address"      },
-//       { "name": "amounts",    "type": "uint256[]"    },  // array of values
-//       { "name": "conditions", "type": "Condition[]"   }  // nested array of structs
-//     ],
-//     "Permit": [
-//       { "name": "owner",      "type": "address"   },
-//       { "name": "spender",    "type": "address"   },
-//       { "name": "allowances", "type": "Allowance[]" },  // array of structs
-//       { "name": "nonce",      "type": "uint256"   },
-//       { "name": "deadline",   "type": "uint256"   }
-//     ]
-//   },
-//   "domain": {
-//     "name":              "MyComplexToken",
-//     "version":           "1",
-//     "chainId":           1,
-//     "verifyingContract": "0x1a2b3c4d5e6f7890abcdef1234567890abcdef12"
-//   },
-//   "primaryType": "Permit",
-//   "message": {
-//     "owner":   "0xAaBbCcDdEeFf00112233445566778899AaBbCcDd",
-//     "spender": "0xBbCcDdEeFf00112233445566778899AaBbCcDdEe",
-//     "allowances": [
-//       {
-//         "token":   "0x111111111117dC0aa78b770fA6A738034120C302",
-//         "amounts": [
-//           "1000000000000000000",
-//           "500000000000000000"
-//         ],
-//         "conditions": [
-//           { "key": "afterTimestamp", "allowed": true },
-//           { "key": "maxTransfers",    "allowed": false }
-//         ]
-//       },
-//       {
-//         "token":   "0x222222222117dC0bb78b770fA6A738034120C303",
-//         "amounts": [
-//           "2500000000000000000"
-//         ],
-//         "conditions": [
-//           { "key": "whitelistedOnly", "allowed": true }
-//         ]
-//       }
-//     ],
-//     "nonce":    42,
-//     "deadline": 1735689600
-//   }
-// }

package/src/functions/web3/etherFunctions.test.ts

@@ -1,129 +0,0 @@
-import {
-  calculateDollarValue,
-  getAmountInWei,
-  getAmountWithPrecisionOrZero,
-  toBigIntWithDecimals,
-} from './etherFunctions';
-import { ERC20Token } from 'src/types';
-import { getERC20Token } from '../utils';
-import { zeroAddress } from 'src/constants';
-import { transactionErrorCodes } from 'src/error-handling';
-// import { toBigIntWithDecimals, getAmountInWei, getAmountWithPrecision } from './etherFunctions';
-// import { getERC20Token } from '../utils';
-// import { zeroAddress } from 'src/constants';
-// import { transactionErrorCodes } from 'src/error-handling';
-
-const ethToken: ERC20Token = getERC20Token(zeroAddress, 1) as ERC20Token;
-
-describe('toBigIntWithDecimals', () => {
-  it('should convert decimal number to bigint with decimal places', () => {
-    const decimal = 123.456;
-    const [bigintEquivalent, decimalPlaces] = toBigIntWithDecimals(decimal);
-
-    expect(bigintEquivalent.toString()).toBe('123456');
-    expect(decimalPlaces).toBe(3);
-  });
-
-  it('should convert integer number to bigint with zero decimal places', () => {
-    const decimal = 789;
-    const [bigintEquivalent, decimalPlaces] = toBigIntWithDecimals(decimal);
-
-    expect(bigintEquivalent.toString()).toBe('789');
-    expect(decimalPlaces).toBe(0);
-  });
-
-  it('should convert decimal number with no decimal places to bigint with zero decimal places', () => {
-    const decimal = 987.0;
-    const [bigintEquivalent, decimalPlaces] = toBigIntWithDecimals(decimal);
-
-    expect(bigintEquivalent.toString()).toBe('987');
-    expect(decimalPlaces).toBe(0);
-  });
-});
-
-describe('getAmountInWei', () => {
-  it('should convert amount to wei with correct decimal places', () => {
-    const amount = '123456.789';
-    const result = getAmountInWei(ethToken, amount);
-
-    expect(result.toString()).toEqual('123456789000000000000000');
-  });
-
-  it('should throw an error if amount is not a valid number', () => {
-    const amount = 'invalid';
-
-    expect(() => {
-      getAmountInWei(ethToken, amount);
-    }).toThrowError(transactionErrorCodes.DECIMALS_LIMIT);
-  });
-});
-
-describe('getAmountWithPrecision', () => {
-  // const token: ERC20Token = getERC20Token(zeroAddress, 1) as ERC20Token;
-  // it('should throw an error if the precision is greater than the token decimals', () => {
-  //   const balance = BigInt('123456789000000000000000');
-  //   const precision = 20;
-  //   expect(() => {
-  //     getAmountWithPrecision(balance, token, precision);
-  //   }).toThrowError(transactionErrorCodes.DECIMALS_LIMIT);
-  // });
-});
-
-describe('calculateDollarValue', () => {
-  it('should calculate the dollar value correctly', () => {
-    const tokenAmount = BigInt('1000000000000000000');
-    const tokenPriceDollar = 10;
-    const precision = 6;
-    const result = calculateDollarValue(ethToken, tokenAmount, tokenPriceDollar, precision);
-
-    expect(result.totalValueDollarsBigInt.toString()).toEqual(BigInt('10000000').toString());
-    expect(result.precision).toBe(6);
-  });
-
-  // it('should handle token decimals less than precision', () => {
-  //   const token = { decimals: 6 };
-  //   const tokenAmount = BigInt('1000000');
-  //   const tokenPriceDollar = 10;
-  //   const precision = 10;
-
-  //   const result = calculateDollarValue(ethToken, tokenAmount, tokenPriceDollar, precision);
-
-  //   expect(result.totalValueDollarsBigInt).toBe(BigInt('1000'));
-  //   expect(result.precision).toBe(10);
-  // });
-});
-
-describe('getAmountWithPrecisionOrZero', () => {
-  it('should return "0" if token or amount is undefined', () => {
-    const token: ERC20Token | undefined = undefined;
-    const amount: bigint | undefined = undefined;
-    const result = getAmountWithPrecisionOrZero(token, amount);
-    expect(result).toBe('0');
-  });
-
-  it('should return "0" if token is undefined', () => {
-    const token: ERC20Token | undefined = undefined;
-    const amount: bigint | undefined = 100n;
-    const result = getAmountWithPrecisionOrZero(token, amount);
-    expect(result).toBe('0');
-  });
-
-  it('should return "0" if amount is undefined', () => {
-    const amount: bigint | undefined = undefined;
-    const result = getAmountWithPrecisionOrZero(ethToken, amount);
-    expect(result).toBe('0');
-  });
-
-  it('should return the amount with the specified precision - 6 digits', () => {
-    const token: ERC20Token = {
-      decimals: 6,
-      chainId: 1,
-      symbol: 'abc',
-      name: 'abc token',
-      erc20TokenAddress: zeroAddress,
-    };
-    const amount = 123456789n;
-    const result = getAmountWithPrecisionOrZero(token, amount);
-    expect(result).toBe('123.456789');
-  });
-});

package/src/functions/web3/etherFunctions.ts

@@ -1,84 +0,0 @@
-import { BigNumber, ethers } from 'ethers';
-import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
-import { ERC20Token } from '../../types/token.types';
-
-export const ethToWei = (amount: string): bigint => ethers.utils.parseEther(amount).toBigInt();
-
-export const randomBigInt = (numberfOfBytes: number) =>
-  ethers.BigNumber.from(ethers.utils.randomBytes(numberfOfBytes)).toBigInt();
-
-export const getAmountInToken = (token: ERC20Token, amount: bigint): string =>
-  ethers.utils.formatUnits(amount, token.decimals);
-
-export const getAmountInWei = (token: ERC20Token, amount: string): bigint => {
-  const decimalsToRemove = 10 ** (18 - token.decimals);
-  try {
-    return ethers.utils.parseUnits(amount).div(BigNumber.from(decimalsToRemove.toString())).toBigInt();
-  } catch (err) {
-    throw new Error(transactionErrorCodes.DECIMALS_LIMIT);
-  }
-};
-
-/**
- * Convert a decimal number into bigint through string method and return a bigint and number of decimal places.
- * @param decimal
- * @returns a tuple of [ theBigInt, numberOfDecimalPlaces]
- */
-export const toBigIntWithDecimals = (decimal: number): [bigint, number] => {
-  // toFixed used here over toString
-  // since toString returns scientific notation when decimal < 10 ** -6
-  const decimalString = decimal.toFixed(30);
-
-  const [integerPart, decimalPart] = decimalString.split('.');
-  const decimalPlaces = decimalPart ? decimalPart.length : 0;
-
-  // Remove the decimal point so we get a string of integer equivalent;
-  // This method is used instead of multiplying by 10^decimalPlaces so we don't run into
-  // problem with very large number
-  const integerEquivalent = `${integerPart}${decimalPart || ''}`;
-
-  const bigintEquivalent = BigInt(integerEquivalent);
-
-  return [bigintEquivalent, decimalPlaces];
-};
-
-/** Return getAmountInWei or 0 if error */
-export const getAmountInWeiOrZero = (token: ERC20Token, amount: string): bigint => {
-  try {
-    return getAmountInWei(token, amount);
-  } catch (err) {
-    return BigInt(0);
-  }
-};
-
-// Function below solves next problem if I have 12345678 USDC units and I want precision of 2, then it gives me 12.34 instead of 12.345678
-export const getAmountWithPrecision = (balance: bigint, token: ERC20Token, precision: number): string => {
-  const amount = ethers.utils.formatUnits(balance, token.decimals);
-  const decimalsToRemove = BigInt(10 ** (18 - precision));
-  try {
-    const preciseBigInt = ethers.utils.parseUnits(amount).div(BigNumber.from(decimalsToRemove.toString())).toBigInt();
-    return ethers.utils.formatUnits(preciseBigInt, precision);
-  } catch (err) {
-    throw new Error(transactionErrorCodes.DECIMALS_LIMIT);
-  }
-};
-
-export const calculateDollarValue = (
-  token: ERC20Token,
-  tokenAmount: bigint,
-  tokenPriceDollar: number,
-  precision: number,
-) => {
-  const [tokenPriceBigInt, tokenPriceDecimalPlaces] = toBigIntWithDecimals(tokenPriceDollar);
-  const totalValuePreDiv = (tokenAmount * tokenPriceBigInt) / BigInt(10 ** (token.decimals - precision));
-  const totalValueDollarsBigInt = totalValuePreDiv / BigInt(10 ** tokenPriceDecimalPlaces);
-
-  return { totalValueDollarsBigInt, precision };
-};
-
-/** Returns same as getAmountWithPrecision but '0' if empty */
-export const getAmountWithPrecisionOrZero = (token: ERC20Token | undefined, amount: bigint | undefined) => {
-  if (!token || !amount) return '0';
-  const amountString = getAmountWithPrecision(amount ?? 0n, token, token.decimals).toString();
-  return amountString ?? '0';
-};

package/src/functions/web3/events/balanceChangedCustomHandler.ts

@@ -1,13 +0,0 @@
-import { EventType, PrivateBalanceUpdateEventType } from '../../../types';
-
-export const balanceChangedCustomHandler = (detail: PrivateBalanceUpdateEventType) => {
-  const eventType = EventType.BalanceChange;
-  const balanceEvent = new CustomEvent<PrivateBalanceUpdateEventType>(eventType, {
-    detail,
-  });
-  if (typeof document !== 'undefined') {
-    document.dispatchEvent(balanceEvent);
-  } else {
-    process?.emit('message', balanceEvent, undefined);
-  }
-};

package/src/functions/web3/events/balanceChangedHandler.ts

@@ -1,10 +0,0 @@
-import { EventType } from '../../../types';
-
-export const balanceChangedHandler = () => {
-  const eventType = EventType.BalanceChange;
-  if (typeof document !== 'undefined') {
-    document.dispatchEvent(new Event(eventType));
-  } else {
-    process?.emit('message', eventType, undefined);
-  }
-};

package/src/functions/web3/events/getApprovedBalance.ts

@@ -1,154 +0,0 @@
-import type { ApprovedUtxoWithInteractionAddress } from '../../../types/hinkal.types';
-import { type IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-import type { TokenBalance } from '../../../types/token.types';
-import { caseInsensitiveEqual } from '../../utils/caseInsensitive.utils';
-import {
-  getInHinkalAddressesCache,
-  resetInHinkalAddressesCache,
-  setInHinkalAddressesCache,
-} from '../../utils/cacheFunctions';
-import { Mutex } from 'async-mutex';
-import { ethers } from 'ethers';
-import { getErc20TokensForChain } from '../../utils/erc20tokenFunctions';
-import { privateTokensDB } from '../../../data-structures/TokenDBs/PrivateTokensDB';
-import { isExtension } from '../../../constants/vite.constants';
-
-const mutex = new Mutex();
-
-const filterMyApprovedUtxos = (
-  approvedUtxos: ApprovedUtxoWithInteractionAddress[],
-  myApprovals: ApprovedUtxoWithInteractionAddress[],
-  inHinkalAddress: bigint,
-) => {
-  approvedUtxos.forEach((approvedUtxo) => {
-    if (approvedUtxo.inHinkalAddress === inHinkalAddress) {
-      myApprovals.push(approvedUtxo);
-    }
-  });
-  return myApprovals;
-};
-
-// this function gives all individual approved utxos
-export const getApprovedUtxos = (hinkal: IHinkal, resetCacheBefore = false): ApprovedUtxoWithInteractionAddress[] => {
-  const { userKeys } = hinkal;
-  const chainId = hinkal.getCurrentChainId();
-
-  if (resetCacheBefore) {
-    resetInHinkalAddressesCache(hinkal, chainId, userKeys.getShieldedPublicKey());
-  }
-
-  const { approvals } = hinkal;
-
-  // we use cache, because deriving inHinkalAddress requires Poseidon Hash
-  const approvalsCache = getInHinkalAddressesCache(hinkal, chainId, userKeys.getShieldedPublicKey());
-
-  let myApprovals: ApprovedUtxoWithInteractionAddress[] = [];
-
-  approvals.forEach((approvedUtxos, interactionAddress) => {
-    const cacheValue = approvalsCache[interactionAddress];
-    let inHinkalAddress: bigint | undefined;
-    if (!cacheValue) {
-      inHinkalAddress = userKeys.getInHinkalAddress(interactionAddress);
-      approvalsCache[interactionAddress] = inHinkalAddress.toString();
-    } else {
-      inHinkalAddress = BigInt(cacheValue);
-    }
-
-    myApprovals = filterMyApprovedUtxos(
-      approvedUtxos.map(
-        (approvedUtxo): ApprovedUtxoWithInteractionAddress => ({ ...approvedUtxo, interactionAddress }),
-      ),
-      myApprovals,
-      inHinkalAddress,
-    );
-  });
-
-  // saving cache
-  setInHinkalAddressesCache(approvalsCache, hinkal, chainId, userKeys.getShieldedPublicKey());
-
-  return myApprovals;
-};
-
-export const getApprovedUtxosForToken = (
-  hinkal: IHinkal,
-  erc20Address: string,
-  resetCacheBefore: boolean,
-): ApprovedUtxoWithInteractionAddress[] => {
-  const allApprovedUtxos = getApprovedUtxos(hinkal, resetCacheBefore);
-  return allApprovedUtxos
-    .filter((utxo) => caseInsensitiveEqual(utxo.tokenAddress, erc20Address))
-    .sort((a, b) => {
-      if (a.amount === b.amount) return 0;
-      return a.amount > b.amount ? -1 : 1;
-    });
-};
-
-// get approved balances for all tokens
-export const getApprovedBalance = async (
-  hinkal: IHinkal,
-  resetCacheBefore: boolean,
-  updateTokensListBefore: boolean,
-): Promise<Map<string, TokenBalance>> => {
-  const chainId = hinkal.getCurrentChainId();
-  const ethereumAddress = await hinkal.getEthereumAddress();
-  let approvedBalances: TokenBalance[] = [];
-  const approvedBalancesMap = new Map<string, TokenBalance>();
-
-  await mutex.runExclusive(async () => {
-    const myApprovals = getApprovedUtxos(hinkal, resetCacheBefore);
-
-    if (updateTokensListBefore && isExtension) {
-      await privateTokensDB.fetchAndUpdatePrivateTokens(
-        myApprovals.map((utxo) => utxo.tokenAddress),
-        chainId,
-        ethereumAddress,
-      );
-    }
-
-    const tokenRegistry = isExtension
-      ? await privateTokensDB.getPrivateTokens(chainId, ethereumAddress)
-      : getErc20TokensForChain(chainId);
-
-    approvedBalances = tokenRegistry.map((token) => ({
-      token,
-      balance: myApprovals.reduce((prev, currentUtxo) => {
-        if (caseInsensitiveEqual(token.erc20TokenAddress, currentUtxo.tokenAddress)) {
-          return prev + currentUtxo.amount;
-        }
-        return prev;
-      }, 0n),
-      timestamp: '0',
-      nfts: [],
-    }));
-
-    // Create a map of token address to token balance for easier lookup
-
-    approvedBalances.forEach((balance) => {
-      approvedBalancesMap.set(balance.token.erc20TokenAddress.toLowerCase(), balance);
-    });
-  });
-
-  return approvedBalancesMap;
-};
-
-// this function gives individual approval amount to specific interaction address
-export const getMyApprovalAmountForInteraction = (
-  hinkal: IHinkal,
-  interactionAddress: string,
-  tokenAddress: string,
-): bigint => {
-  const { userKeys, approvals } = hinkal;
-  const normalizedInteractionAddress = ethers.utils.getAddress(interactionAddress);
-
-  const addressApprovals = approvals.get(normalizedInteractionAddress) ?? [];
-
-  const inHinkalAddress = userKeys.getInHinkalAddress(normalizedInteractionAddress);
-
-  const myApprovedAmount = addressApprovals.reduce((prev, cur) => {
-    return caseInsensitiveEqual(cur.tokenAddress, tokenAddress) && cur.inHinkalAddress === inHinkalAddress
-      ? prev + cur.amount
-      : prev;
-  }, 0n);
-
-  return myApprovedAmount;
-};