@sabaaa1/common 0.0.1

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,53 @@
+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/index.ts

@@ -0,0 +1,9 @@
+export * from './etherFunctions';
+export * from './events';
+export * from './uniswapAPI';
+export * from './odosAPI';
+export * from './oneInchAPI';
+export * from './lifiAPI';
+export * from './runContractFunction';
+export * from './getTokenHolder';
+export * from './EIP-712';

package/src/functions/web3/lifiAPI.ts

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

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