@sabaaa1/common 0.0.7 → 0.0.8

package/src/functions/web3/functionCalls/approveToken.ts

@@ -1,180 +0,0 @@
-/* eslint-disable @typescript-eslint/dot-notation */
-import { ethers } from 'ethers';
-
-import { chainIds, getNonLocalhostChainId } from '../../../constants/chains.constants';
-import { permitSignatureValidFor } from '../../../constants/protocol.constants';
-
-import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-
-import { ApprovalType, ERC20Token } from '../../../types/token.types';
-import { ContractType } from '../../../types/ethereum-network.types';
-
-const skipApprovalIfAlreadyHave = async (
-  amount: bigint,
-  contractToApprove: ethers.Contract,
-  tokenContract: ethers.Contract,
-) => {
-  const allowance = BigInt(
-    await tokenContract['allowance'](await tokenContract.signer.getAddress(), contractToApprove.address),
-  );
-  return amount === allowance;
-};
-
-const clearAllowanceIfNecessary = async (
-  hinkal: IHinkal,
-  contractToApprove: ethers.Contract,
-  token: ERC20Token,
-  tokenContract: ethers.Contract,
-) => {
-  if (getNonLocalhostChainId(hinkal.getCurrentChainId()) !== chainIds.ethMainnet) return;
-  if (token.symbol.toLowerCase() !== 'usdt') return;
-  const allowance = BigInt(
-    await tokenContract['allowance'](await tokenContract.signer.getAddress(), contractToApprove.address),
-  );
-  if (allowance === 0n) return;
-  const tx = await tokenContract['approve'](contractToApprove.address, 0n);
-  if (tx && 'hash' in tx) await hinkal.waitForTransaction(tx.hash);
-};
-
-export const approveTokenToHinkal = async (
-  hinkal: IHinkal,
-  contractToApprove: ethers.Contract,
-  amount: bigint,
-  token: ERC20Token,
-): Promise<Uint8Array | undefined> => {
-  const tokenContract = hinkal.getContractWithSigner(ContractType.ERC20Contract, token.erc20TokenAddress); // as IERC20;
-
-  const approvalType = token.approvalType ?? ApprovalType.Classic;
-
-  if (approvalType === ApprovalType.Classic || !hinkal.isPermitterAvailable()) {
-    const skipApproval = await skipApprovalIfAlreadyHave(amount, contractToApprove, tokenContract);
-    if (skipApproval) return undefined;
-
-    await clearAllowanceIfNecessary(hinkal, contractToApprove, token, tokenContract);
-
-    const tx = await tokenContract['approve'](
-      contractToApprove.address,
-      amount,
-      // { gasLimit: 10000000 }
-    );
-    if (tx && 'hash' in tx) await hinkal.waitForTransaction(tx.hash);
-
-    return undefined;
-  }
-
-  const userAddress = await hinkal.getEthereumAddress();
-
-  const permitterContract = hinkal.getContract(ContractType.PermitterContract);
-
-  const nonceContract = hinkal.getContractWithFetcher(ContractType.ContractWithNonces, token.erc20TokenAddress);
-  const nonce: ethers.BigNumberish = await nonceContract['nonces'](userAddress);
-
-  const deadline = BigInt(Date.now() + permitSignatureValidFor) / 1000n; // we need to convert it into seconds
-
-  const dataToSign = {
-    owner: userAddress,
-    holder: userAddress,
-    spender: permitterContract.address,
-    value: amount,
-    nonce,
-    deadline,
-    expiry: deadline,
-    allowed: true,
-  };
-  const { v, r, s } = ethers.utils.splitSignature(
-    await hinkal.signTypedData(
-      {
-        name: await tokenContract['name'](),
-        chainId: hinkal.getCurrentChainId(),
-        version: '1',
-        verifyingContract: token.erc20TokenAddress,
-      },
-      {
-        Permit:
-          approvalType === ApprovalType.ERC20Permit
-            ? [
-                {
-                  name: 'owner',
-                  type: 'address',
-                },
-                {
-                  name: 'spender',
-                  type: 'address',
-                },
-                {
-                  name: 'value',
-                  type: 'uint256',
-                },
-                {
-                  name: 'nonce',
-                  type: 'uint256',
-                },
-                {
-                  name: 'deadline',
-                  type: 'uint256',
-                },
-              ]
-            : [
-                {
-                  name: 'holder',
-                  type: 'address',
-                },
-                {
-                  name: 'spender',
-                  type: 'address',
-                },
-                {
-                  name: 'nonce',
-                  type: 'uint256',
-                },
-                {
-                  name: 'expiry',
-                  type: 'uint256',
-                },
-                {
-                  name: 'allowed',
-                  type: 'bool',
-                },
-              ],
-      },
-      dataToSign,
-    ),
-  );
-
-  if (approvalType === ApprovalType.ERC20Permit) {
-    const permitInterface = new ethers.utils.Interface([
-      'function permit(address owner,address spender,uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) external',
-    ]);
-    return ethers.utils
-      .arrayify(
-        permitInterface.encodeFunctionData('permit', [
-          dataToSign.owner,
-          dataToSign.spender,
-          dataToSign.value,
-          dataToSign.deadline,
-          v,
-          ethers.utils.arrayify(r),
-          ethers.utils.arrayify(s),
-        ]),
-      )
-      .slice(4);
-  }
-
-  const permitInterface = new ethers.utils.Interface([
-    'function permit(address holder,address spender,uint256 nonce,uint256 expiry,bool allowed,uint8 v,bytes32 r,bytes32 s) external',
-  ]);
-  return ethers.utils
-    .arrayify(
-      permitInterface.encodeFunctionData('permit', [
-        dataToSign.holder,
-        dataToSign.spender,
-        dataToSign.nonce,
-        dataToSign.expiry,
-        dataToSign.allowed,
-        v,
-        ethers.utils.arrayify(r),
-        ethers.utils.arrayify(s),
-      ]),
-    )
-    .slice(4);
-};

package/src/functions/web3/functionCalls/approveTokensToHinkal.ts

@@ -1,21 +0,0 @@
-import { ethers } from 'ethers';
-import { zeroAddress } from '../../../constants/protocol.constants';
-import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-import { ERC20Token } from '../../../types/token.types';
-import { approveTokenToHinkal } from './approveToken';
-
-export const approveTokensToHinkal = async (
-  hinkal: IHinkal,
-  contractForApproval: ethers.Contract,
-  tokensToApprove: ERC20Token[],
-  amounts: bigint[],
-) => {
-  for (let i = 0; i < amounts.length; i += 1) {
-    const currentAmount = amounts[i];
-    const currentToken = tokensToApprove[i];
-    if (currentAmount > 0n && currentToken.erc20TokenAddress !== zeroAddress) {
-      // eslint-disable-next-line no-await-in-loop
-      await approveTokenToHinkal(hinkal, contractForApproval, currentAmount, currentToken);
-    }
-  }
-};

package/src/functions/web3/functionCalls/estimateGasRelayer.ts

@@ -1,40 +0,0 @@
-import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-import { CircomDataBaseType, DimDataType } from '../../../types/circom-data.types';
-import { NewZkCallDataType } from '../../../types/snark.types';
-import { type AuthorizationData } from '../../../types/hinkal.types';
-import { ethers as ethersV6, InterfaceAbi } from 'ethers-v6h';
-import { recoverAuthorizationData } from '../../private-wallet/emporium.helpers';
-import { networkRegistry } from '../../../constants/chains.constants';
-
-export const estimateGasRelayer = async (
-  hinkal: IHinkal,
-  newZkCallData: NewZkCallDataType,
-  dimData: DimDataType,
-  circomData: CircomDataBaseType,
-  authorizationData?: AuthorizationData,
-): Promise<bigint> => {
-  const { hinkalAddress, hinkalABI } = networkRegistry[hinkal.getCurrentChainId()].contractData;
-  const provider = new ethersV6.JsonRpcProvider(networkRegistry[hinkal.getCurrentChainId()].fetchRpcUrl);
-  const hinkalContract = new ethersV6.Contract(hinkalAddress, hinkalABI as InterfaceAbi, provider);
-
-  const callFunctionForGas = 'transact';
-
-  let overrides: ethersV6.TransactionRequest = { from: circomData.relay };
-  if (authorizationData) {
-    const authData = recoverAuthorizationData(authorizationData);
-    if (authData) {
-      overrides = { ...overrides, authorizationList: [authData], type: 4 };
-    }
-  }
-
-  const gasEstimate = await hinkalContract[callFunctionForGas].estimateGas(
-    newZkCallData[0],
-    newZkCallData[1],
-    newZkCallData[2],
-    dimData,
-    circomData,
-    overrides,
-  );
-
-  return gasEstimate;
-};

package/src/functions/web3/functionCalls/getRootHash.ts

@@ -1,7 +0,0 @@
-import { Contract } from 'ethers';
-
-export const getRootHash = async (merkleTreeContract: Contract): Promise<bigint> => {
-  // eslint-disable-next-line @typescript-eslint/dot-notation
-  const rootHash = await merkleTreeContract['getRootHash']();
-  return rootHash.toBigInt();
-};

package/src/functions/web3/functionCalls/inHinkalApprovalCalls.ts

@@ -1,60 +0,0 @@
-/* eslint-disable @typescript-eslint/dot-notation */
-import { BigNumber } from 'ethers';
-import { type IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-import { type ApprovedUtxo } from '../../../types';
-import { ContractType } from '../../../types/ethereum-network.types';
-
-export const getInteractionApprovals = async (hinkal: IHinkal, interactionAddress: string) => {
-  const hinkalContract = hinkal.getContractWithFetcher(ContractType.HinkalContract);
-
-  const plainApprovedUtxos: unknown[] = await hinkalContract.callStatic['getInteractionApprovals'](interactionAddress);
-
-  if (!plainApprovedUtxos) {
-    throw Error('getInteractionApprovals fail: no approved utxos fetched');
-  }
-  const approvedUtxos: ApprovedUtxo[] = plainApprovedUtxos.map((entry) => {
-    const element = entry as ApprovedUtxo<BigNumber>;
-    return {
-      amount: element['amount'].toBigInt(),
-      inHinkalAddress: element['inHinkalAddress'].toBigInt(),
-      tokenAddress: element['tokenAddress'],
-    };
-  });
-  return approvedUtxos;
-};
-
-export const checkExistingApprovalFromHinkal = async (
-  hinkal: IHinkal,
-  erc20Address: string,
-  interactionAddress: string,
-): Promise<bigint> => {
-  const hinkalContract = hinkal.getContractWithFetcher(ContractType.HinkalContract);
-  const erc20Token = hinkal.getContractWithFetcher(ContractType.ERC20Contract, erc20Address);
-
-  const approvalAmountBG: BigNumber = await erc20Token.callStatic['allowance'](
-    hinkalContract.address,
-    interactionAddress,
-  );
-
-  if (approvalAmountBG === undefined) {
-    throw Error('checkExistingApprovalFromHinkal Error, no allowance fetched');
-  }
-  return approvalAmountBG.toBigInt();
-};
-
-export const getBufferEntry = async (
-  hinkal: IHinkal,
-  approveTo: string,
-  tokenAddress: string,
-  inHinkalAddress: bigint,
-) => {
-  const hinkalContract = hinkal.getContractWithFetcher(ContractType.HinkalContract);
-
-  const amount: BigNumber = await hinkalContract.callStatic['getBufferEntry'](approveTo, tokenAddress, inHinkalAddress);
-
-  if (amount === undefined) {
-    throw Error('getBufferEntry Fail: No amount fatched');
-  }
-
-  return amount.toBigInt();
-};

package/src/functions/web3/functionCalls/relayFunctions.ts

@@ -1,12 +0,0 @@
-/* eslint-disable @typescript-eslint/dot-notation */
-import { ethers } from 'ethers';
-
-export const getRelayPercentage = async (contract: ethers.Contract): Promise<bigint> => {
-  const relayPercentage = await contract['relayPercentage']();
-  return BigInt(relayPercentage);
-};
-
-export const getRelay = async (hinkalHelperContract: ethers.Contract): Promise<string> => {
-  const relayList: string[] = await hinkalHelperContract['getRelayStore']();
-  return relayList[0];
-};

package/src/functions/web3/functionCalls/transactCallDirect.ts

@@ -1,71 +0,0 @@
-/* eslint-disable no-console */
-/* eslint-disable no-undef-init */
-/* eslint-disable @typescript-eslint/dot-notation */
-import { ethers } from 'ethers';
-import { zeroAddress } from '../../../constants/protocol.constants';
-import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-
-import { CircomDataBaseType, DimDataType } from '../../../types/circom-data.types';
-import { ContractType } from '../../../types/ethereum-network.types';
-import { ERC20Token } from '../../../types/token.types';
-import { NewZkCallDataType } from '../../../types/snark.types';
-import { waitLittle } from '../../utils/time.utils';
-import { approveTokensToHinkal } from './approveTokensToHinkal';
-
-export const transactCallDirect = async (
-  hinkal: IHinkal,
-  amount: bigint | bigint[],
-  tokenToApprove: ERC20Token | ERC20Token[],
-  newZkCallData: NewZkCallDataType,
-  circomData: CircomDataBaseType,
-  dimData: DimDataType,
-  contractApproval?: ethers.Contract,
-  contractTransaction?: ethers.Contract,
-) => {
-  const amounts = Array.isArray(amount) ? amount : [amount];
-  const tokensToApprove = Array.isArray(tokenToApprove) ? tokenToApprove : [tokenToApprove];
-  if (amounts.length !== tokensToApprove.length) throw new Error('token and amount length mismatch');
-  const hinkalContract = hinkal.getContractWithSigner(ContractType.HinkalContract);
-  const ethereumAddress = await hinkal.getEthereumAddress();
-
-  const contractForApproval = contractApproval ?? hinkalContract;
-  const contractForTransaction = contractTransaction ?? hinkalContract;
-
-  const method = 'transact';
-  await approveTokensToHinkal(hinkal, contractForApproval, tokensToApprove, amounts);
-
-  const ethIndex = tokensToApprove.findIndex(({ erc20TokenAddress }) => erc20TokenAddress === zeroAddress);
-  const ethAmount = ethIndex === -1 ? 0n : amounts[ethIndex];
-
-  const overrides: { value?: string; gasLimit?: number } = {
-    value: ethAmount > 0n ? BigInt(ethAmount).toString() : undefined,
-  };
-  let gasCosts: number | undefined = undefined;
-
-  const callData = [
-    newZkCallData[0],
-    newZkCallData[1],
-    newZkCallData[2],
-    dimData,
-    circomData,
-    { ...overrides, from: ethereumAddress },
-  ];
-
-  try {
-    gasCosts = (await contractForTransaction.estimateGas[method](...callData)).toNumber();
-    console.log({ gasCosts });
-    console.log({
-      signerAddress: await contractForTransaction.signer.getAddress(),
-      chainIdHinkal: hinkal.getCurrentChainId(),
-      ethersNetwork: await contractForTransaction.provider.getNetwork(),
-    });
-  } catch (err: any) {
-    console.log('hinkalDeposit: gas estimation error', { err });
-  }
-
-  const extendedGasCosts = gasCosts && gasCosts >= 0 ? Math.ceil((gasCosts * 12) / 10) : undefined;
-  overrides.gasLimit = extendedGasCosts;
-  await waitLittle(); // because public rpc link gives 429
-  const tx = await contractForTransaction[method](...callData);
-  return tx;
-};

package/src/functions/web3/functionCalls/transactCallRelayer.ts

@@ -1,57 +0,0 @@
-import { ErrorWithRelayerTransaction } from '../../../error-handling';
-import { callRelayerTransactAPI } from '../../../API/callRelayer';
-import {
-  AdminDataType,
-  AuthorizationData,
-  CircomDataBaseJsonType,
-  CircomDataBaseType,
-  CircomDataV1,
-  CircomDataV1x1,
-  DimDataType,
-  NewZkCallDataType,
-  RelayerTransaction,
-} from '../../../types';
-import { serializeCircomData } from '../../snarkjs';
-
-export interface RelayerResponseInterface {
-  status: string;
-  message: RelayerTransaction;
-  error?: string;
-}
-
-export const transactCallRelayer = async (
-  chainId: number,
-  newZkCallData: NewZkCallDataType,
-  dimData: DimDataType,
-  circomData: CircomDataBaseType,
-  withPrivateMempool?: boolean,
-  // use workaround for uniswap's dapp not properly recongnizing approval transaction
-  // this should not be used within our own dapp
-  withUniswapWorkAround?: boolean,
-  authorizationData?: AuthorizationData,
-  adminData?: AdminDataType,
-): Promise<RelayerTransaction> => {
-  const circomDataJson: CircomDataBaseJsonType = serializeCircomData(circomData as CircomDataV1 | CircomDataV1x1);
-  const relayerResponse: RelayerResponseInterface = await callRelayerTransactAPI(chainId, {
-    a: newZkCallData[0],
-    b: newZkCallData[1],
-    c: newZkCallData[2],
-    dimData,
-    circomData: circomDataJson,
-    withPrivateMempool,
-    withUniswapWorkAround,
-    authorizationData,
-    adminData,
-  });
-
-  if (relayerResponse.status === 'success') {
-    return relayerResponse.message;
-  }
-
-  if (relayerResponse.message && relayerResponse.error) {
-    const error = new ErrorWithRelayerTransaction(relayerResponse.error, relayerResponse.message);
-    throw error;
-  }
-  const error = new Error(relayerResponse.error);
-  throw error;
-};

package/src/functions/web3/getContractMetadata.ts

@@ -1,43 +0,0 @@
-import { contractMetadataMapping } from '../../constants/contracts.constants';
-import { networkRegistry } from '../../constants/chains.constants';
-import { ContractMetadata, ContractType } from '../../types/ethereum-network.types';
-import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
-import { ethers } from 'ethers';
-import { createTorRpcProvider } from '../utils';
-
-export const getContractMetadata = (contractType: ContractType, chainId: number): ContractMetadata => {
-  const network = networkRegistry[chainId];
-  if (!network) {
-    throw new Error(transactionErrorCodes.UNSUPPORTED_NETWORK);
-  }
-  const getContractMetadataFn = contractMetadataMapping[contractType];
-  if (!getContractMetadataFn) {
-    throw new Error(`Unsupported contractType: ${contractType}`);
-  }
-  return getContractMetadataFn(network.contractData);
-};
-
-export const getContract = (contractType: ContractType, chainId: number, contractAddress?: string) => {
-  const contractMetadata: ContractMetadata = getContractMetadata(contractType, chainId);
-  if (!contractMetadata.abi) {
-    throw new Error(`No ABI configured for contractType: ${contractType}`);
-  }
-  if (contractMetadata.address && contractAddress) {
-    throw new Error(`Overriding address is not supported for contractType: ${contractType}`);
-  }
-  const resultContractAddress = contractMetadata.address ?? contractAddress;
-  if (!resultContractAddress) {
-    throw new Error(`No contractAddress configured for contractType: ${contractType}`);
-  }
-  return new ethers.Contract(resultContractAddress, contractMetadata.abi);
-};
-
-export const getContractWithFetcherByChainId = (
-  chainId: number,
-  contractType: ContractType,
-  contractAddress = undefined,
-): ethers.Contract => {
-  const { fetchRpcUrl } = networkRegistry[chainId];
-  if (!fetchRpcUrl) throw new Error('RPC URL not found for the specified chain ID');
-  return getContract(contractType, chainId, contractAddress).connect(createTorRpcProvider(fetchRpcUrl));
-};

package/src/functions/web3/getPublicAddressBalance.ts

@@ -1,17 +0,0 @@
-import { type IHinkal } from '../../data-structures/Hinkal/IHinkal';
-import { zeroAddress } from '../../constants/protocol.constants';
-import { ContractType } from '../../types/ethereum-network.types';
-
-export const getPublicAddressBalance = async (
-  hinkal: IHinkal,
-  tokenAddress: string,
-  ethereumAddress: string,
-): Promise<bigint> => {
-  const tokenContract = hinkal.getContractWithFetcher(ContractType.ERC20Contract, tokenAddress);
-
-  if (tokenAddress === zeroAddress) {
-    return (await tokenContract.provider.getBalance(ethereumAddress)).toBigInt();
-  }
-
-  return (await tokenContract['balanceOf'](ethereumAddress)).toBigInt();
-};

package/src/functions/web3/getTokenHolder.ts

@@ -1,53 +0,0 @@
-import { ethers } from 'ethers';
-import { chainIds, networkRegistry } from '../../constants/chains.constants';
-import { ERC20ABI } from '../../externalABIs';
-import { httpClient } from '../../data-structures/tor';
-import { createTorRpcProvider } from '../utils';
-
-// avalanche and arcTestnet are not supported by blockscout
-const chainNameMapping = {
-  [chainIds.base]: 'base',
-  [chainIds.optimism]: 'optimism',
-  [chainIds.arbMainnet]: 'arbitrum',
-  [chainIds.polygon]: 'polygon',
-  [chainIds.ethMainnet]: 'eth',
-};
-
-const getTokenHolderFromBlockscout = async (chainId: number, tokenAddress: string) => {
-  const chainName = chainNameMapping[chainId];
-  const url = `https://${chainName}.blockscout.com/api?module=token&action=getTokenHolders&contractaddress=${tokenAddress}&page=0&offset=10`;
-  const { result } = await httpClient.get<{ result: { address: string; value: string }[] }>(url);
-  const { fetchRpcUrl } = networkRegistry[chainId];
-  if (!fetchRpcUrl) throw new Error('RPC URL not found for the specified chain ID');
-  const provider = createTorRpcProvider(fetchRpcUrl);
-  const tokenContract = new ethers.Contract(tokenAddress, ERC20ABI, provider);
-  // eslint-disable-next-line no-restricted-syntax
-  for (const { address } of result) {
-    // eslint-disable-next-line no-await-in-loop
-    const balance: ethers.BigNumber = await tokenContract['balanceOf'](address);
-    if (balance.toBigInt() !== 0n) return address;
-  }
-  return undefined;
-};
-
-const getTokenHolderFromRoutescan = async (chainId: number, tokenAddress: string) => {
-  const url = `https://api.routescan.io/v2/network/mainnet/evm/${chainId}/etherscan/api?module=token&action=tokenholderlist&contractaddress=${tokenAddress}&page=1&offset=10&apikey=YourApiKeyToken`;
-  const { result } = await httpClient.get<{ result: { TokenHolderAddress: string; TokenHolderQuantity: string }[] }>(
-    url,
-  );
-  return result.at(0)?.TokenHolderAddress;
-};
-
-export const getTokenHolder = async (chainId: number, tokenAddress: string) => {
-  try {
-    if (!(chainId in chainNameMapping)) throw new Error('Chain is not supported by blockscout');
-
-    const tokenHolderFromBlockScout = await getTokenHolderFromBlockscout(chainId, tokenAddress);
-    if (!tokenHolderFromBlockScout || !ethers.utils.isAddress(tokenHolderFromBlockScout)) {
-      throw new Error('Token holder not found in blockscout');
-    }
-    return tokenHolderFromBlockScout;
-  } catch {
-    return await getTokenHolderFromRoutescan(chainId, tokenAddress);
-  }
-};

package/src/functions/web3/lifiAPI.ts

@@ -1,41 +0,0 @@
-import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
-import { ERC20Token } from '../../types/token.types';
-import { callLifiAPI, LifiRequestData } from '../../API/callLifiAPI';
-import { getAmountInWei } from './etherFunctions';
-import { zeroAddress } from '../../constants/protocol.constants';
-
-export const getLifiPrice = async (
-  chainId: number,
-  inSwapToken: ERC20Token,
-  outSwapToken: ERC20Token,
-  inSwapAmount: string,
-  bridgingSlippage: number,
-  fromAddress: string,
-  toAddress?: string,
-) => {
-  try {
-    const fromAmount = getAmountInWei(inSwapToken, inSwapAmount);
-    const request: LifiRequestData = {
-      fromChain: inSwapToken.chainId,
-      toChain: outSwapToken.chainId,
-      fromToken: inSwapToken.erc20TokenAddress,
-      toToken: outSwapToken.erc20TokenAddress,
-      fromAddress,
-      fromAmount: fromAmount.toString(),
-      order: 'FASTEST', // TO BE DECIDED
-      slippage: bridgingSlippage,
-      ...(toAddress && { toAddress }),
-    };
-    const { lifiResponse } = await callLifiAPI(chainId, request);
-    return {
-      lifiDataValue: lifiResponse.transactionRequest.data,
-      outSwapAmountValue: BigInt(lifiResponse.estimate.toAmount),
-      extraNativeTokenFee:
-        inSwapToken.erc20TokenAddress === zeroAddress
-          ? BigInt(lifiResponse.transactionRequest.value) - fromAmount
-          : BigInt(lifiResponse.transactionRequest.value),
-    };
-  } catch (error: unknown) {
-    throw Error(transactionErrorCodes.NO_LIFI_PRICE);
-  }
-};

package/src/functions/web3/odosAPI.ts

@@ -1,50 +0,0 @@
-import { callOdosAPI, OdosSwapData, OdosSwapRequest } from '../../API/callOdosAPI';
-import { localhostNetwork, networkRegistry, zeroAddress } from '../../constants';
-import { transactionErrorCodes } from '../../error-handling';
-import { ERC20Token } from '../../types';
-import { getAmountInWei } from './etherFunctions';
-
-export const getOdosPrice = async (
-  chainId: number,
-  inSwapToken: ERC20Token,
-  outSwapToken: ERC20Token,
-  inSwapAmount: string,
-  slippagePercentage = 0.7,
-) => {
-  try {
-    const raw: OdosSwapRequest = {
-      chainId: chainId !== 31337 ? chainId : localhostNetwork,
-      inputTokens: [
-        {
-          tokenAddress: inSwapToken?.wrappedErc20TokenAddress ?? inSwapToken.erc20TokenAddress,
-          amount: getAmountInWei(inSwapToken, inSwapAmount).toString(),
-        },
-      ],
-      outputTokens: [
-        {
-          tokenAddress: outSwapToken?.wrappedErc20TokenAddress ?? outSwapToken.erc20TokenAddress,
-          proportion: 1,
-        },
-      ],
-      userAddr: networkRegistry[chainId].contractData.odosExternalActionInstanceAddress || zeroAddress,
-      slippageLimitPercent: slippagePercentage,
-      disableRFQs: true, // sometimes swap fails because of RFQs
-    };
-    const { odosResponse, status }: { odosResponse: OdosSwapData; status: string; message: string } = await callOdosAPI(
-      chainId,
-      raw,
-    );
-
-    if (status !== 'success') {
-      throw Error('Odos API Fetch Error');
-    }
-
-    return {
-      outSwapAmountValue: BigInt(odosResponse.outputTokens[0].amount),
-      odosDataValue: odosResponse.transaction.data,
-    };
-  } catch (error: unknown) {
-    console.log({ error });
-    throw Error(transactionErrorCodes.NO_ODOS_PRICE);
-  }
-};