@sabaaa1/common 0.0.1

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

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

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

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

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

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

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