@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/core/EVM/getAllowance.ts

@@ -1,148 +0,0 @@
-import type { BaseToken, ChainId } from '@lifi/types'
-import type { Address, Client } from 'viem'
-import { multicall, readContract } from 'viem/actions'
-import { isZeroAddress } from '../../utils/isZeroAddress.js'
-import { allowanceAbi } from './abi.js'
-import { getActionWithFallback } from './getActionWithFallback.js'
-import { getPublicClient } from './publicClient.js'
-import type {
-  TokenAllowance,
-  TokenSpender,
-  TokenSpenderAllowance,
-} from './types.js'
-import { getMulticallAddress } from './utils.js'
-
-export const getAllowance = async (
-  client: Client,
-  tokenAddress: Address,
-  ownerAddress: Address,
-  spenderAddress: Address
-): Promise<bigint> => {
-  try {
-    const approved = await getActionWithFallback(
-      client,
-      readContract,
-      'readContract',
-      {
-        address: tokenAddress as Address,
-        abi: allowanceAbi,
-        functionName: 'allowance' as const,
-        args: [ownerAddress, spenderAddress] as const,
-      }
-    )
-    return approved
-  } catch (_e) {
-    return 0n
-  }
-}
-
-export const getAllowanceMulticall = async (
-  client: Client,
-  chainId: ChainId,
-  tokens: TokenSpender[],
-  ownerAddress: Address
-): Promise<TokenSpenderAllowance[]> => {
-  if (!tokens.length) {
-    return []
-  }
-  const multicallAddress = await getMulticallAddress(chainId)
-  if (!multicallAddress) {
-    throw new Error(`No multicall address configured for chainId ${chainId}.`)
-  }
-
-  const contracts = tokens.map((token) => ({
-    address: token.token.address as Address,
-    abi: allowanceAbi,
-    functionName: 'allowance',
-    args: [ownerAddress, token.spenderAddress],
-  }))
-
-  const results = await getActionWithFallback(client, multicall, 'multicall', {
-    contracts,
-    multicallAddress: multicallAddress as Address,
-  })
-
-  if (!results.length) {
-    throw new Error(
-      `Couldn't load allowance from chainId ${chainId} using multicall.`
-    )
-  }
-
-  return tokens.map(({ token, spenderAddress }, i: number) => ({
-    token,
-    spenderAddress,
-    allowance: results[i].result as bigint,
-  }))
-}
-
-/**
- * Get the current allowance for a certain token.
- * @param token - The token that should be checked
- * @param ownerAddress - The owner of the token
- * @param spenderAddress - The spender address that has to be approved
- * @returns Returns allowance
- */
-export const getTokenAllowance = async (
-  token: BaseToken,
-  ownerAddress: Address,
-  spenderAddress: Address
-): Promise<bigint | undefined> => {
-  // native token don't need approval
-  if (isZeroAddress(token.address)) {
-    return
-  }
-
-  const client = await getPublicClient(token.chainId)
-
-  const approved = await getAllowance(
-    client,
-    token.address as Address,
-    ownerAddress,
-    spenderAddress
-  )
-  return approved
-}
-
-/**
- * Get the current allowance for a list of token/spender address pairs.
- * @param ownerAddress - The owner of the tokens
- * @param tokens - A list of token and spender address pairs
- * @returns Returns array of tokens and their allowance
- */
-export const getTokenAllowanceMulticall = async (
-  ownerAddress: Address,
-  tokens: TokenSpender[]
-): Promise<TokenAllowance[]> => {
-  // filter out native tokens
-  const filteredTokens = tokens.filter(
-    ({ token }) => !isZeroAddress(token.address)
-  )
-
-  // group by chain
-  const tokenDataByChain: { [chainId: number]: TokenSpender[] } = {}
-  for (const data of filteredTokens) {
-    if (!tokenDataByChain[data.token.chainId]) {
-      tokenDataByChain[data.token.chainId] = []
-    }
-    tokenDataByChain[data.token.chainId].push(data)
-  }
-
-  const chainKeys = Object.keys(tokenDataByChain).map(Number.parseInt)
-
-  const allowances = (
-    await Promise.all(
-      chainKeys.map(async (chainId) => {
-        const client = await getPublicClient(chainId)
-        // get allowances for current chain and token list
-        return getAllowanceMulticall(
-          client,
-          chainId,
-          tokenDataByChain[chainId],
-          ownerAddress
-        )
-      })
-    )
-  ).flat()
-
-  return allowances
-}

package/src/core/EVM/getEVMBalance.ts

@@ -1,128 +0,0 @@
-import type { ChainId, Token, TokenAmount } from '@lifi/types'
-import type { Address } from 'viem'
-import {
-  getBalance,
-  getBlockNumber,
-  multicall,
-  readContract,
-} from 'viem/actions'
-import { isZeroAddress } from '../../utils/isZeroAddress.js'
-import { balanceOfAbi, getEthBalanceAbi } from './abi.js'
-import { getPublicClient } from './publicClient.js'
-import { getMulticallAddress } from './utils.js'
-
-export const getEVMBalance = async (
-  walletAddress: Address,
-  tokens: Token[]
-): Promise<TokenAmount[]> => {
-  if (tokens.length === 0) {
-    return []
-  }
-  const { chainId } = tokens[0]
-  for (const token of tokens) {
-    if (token.chainId !== chainId) {
-      console.warn('Requested tokens have to be on the same chain.')
-    }
-  }
-
-  const multicallAddress = await getMulticallAddress(chainId)
-
-  if (multicallAddress && tokens.length > 1) {
-    return getEVMBalanceMulticall(
-      chainId,
-      tokens,
-      walletAddress,
-      multicallAddress
-    )
-  }
-  return getEVMBalanceDefault(chainId, tokens, walletAddress)
-}
-
-const getEVMBalanceMulticall = async (
-  chainId: ChainId,
-  tokens: Token[],
-  walletAddress: string,
-  multicallAddress: string
-): Promise<TokenAmount[]> => {
-  const client = await getPublicClient(chainId)
-
-  const contracts = tokens.map((token) => {
-    if (isZeroAddress(token.address)) {
-      return {
-        address: multicallAddress as Address,
-        abi: getEthBalanceAbi,
-        functionName: 'getEthBalance',
-        args: [walletAddress],
-      }
-    }
-    return {
-      address: token.address as Address,
-      abi: balanceOfAbi,
-      functionName: 'balanceOf',
-      args: [walletAddress],
-    }
-  })
-
-  const [blockNumber, results] = await Promise.all([
-    getBlockNumber(client),
-    multicall(client, {
-      contracts,
-      multicallAddress: multicallAddress as Address,
-    }),
-  ])
-
-  if (!results.length) {
-    return []
-  }
-
-  return tokens.map((token, i: number) => {
-    return {
-      ...token,
-      amount: results[i].result as bigint,
-      blockNumber,
-    }
-  })
-}
-
-const getEVMBalanceDefault = async (
-  chainId: ChainId,
-  tokens: Token[],
-  walletAddress: Address
-): Promise<TokenAmount[]> => {
-  const client = await getPublicClient(chainId)
-
-  const queue: Promise<bigint>[] = tokens.map((token) => {
-    if (isZeroAddress(token.address)) {
-      return getBalance(client, {
-        address: walletAddress as Address,
-      })
-    }
-    return readContract(client, {
-      address: token.address as Address,
-      abi: balanceOfAbi,
-      functionName: 'balanceOf',
-      args: [walletAddress],
-    }) as Promise<bigint>
-  })
-
-  const [blockNumber, results] = await Promise.all([
-    getBlockNumber(client),
-    Promise.allSettled(queue),
-  ])
-
-  const tokenAmounts: TokenAmount[] = tokens.map((token, index) => {
-    const result = results[index]
-    if (result.status === 'rejected') {
-      return {
-        ...token,
-        blockNumber,
-      }
-    }
-    return {
-      ...token,
-      amount: result.value,
-      blockNumber,
-    }
-  })
-  return tokenAmounts
-}

package/src/core/EVM/isBatchingSupported.ts

@@ -1,44 +0,0 @@
-import { ChainType } from '@lifi/types'
-import type { Client } from 'viem'
-import { getCapabilities } from 'viem/actions'
-import { getAction } from 'viem/utils'
-import { config } from '../../config.js'
-import { sleep } from '../../utils/sleep.js'
-import type { EVMProvider } from './types.js'
-
-export async function isBatchingSupported({
-  client,
-  chainId,
-  skipReady = false,
-}: {
-  client?: Client
-  chainId: number
-  skipReady?: boolean
-}): Promise<boolean> {
-  const _client =
-    client ??
-    (await (
-      config.getProvider(ChainType.EVM) as EVMProvider
-    )?.getWalletClient?.())
-
-  if (!_client) {
-    throw new Error('WalletClient is not provided.')
-  }
-
-  try {
-    const capabilities = await Promise.race([
-      getAction(_client, getCapabilities, 'getCapabilities')({ chainId }),
-      sleep(2_000),
-    ])
-    return (
-      capabilities?.atomicBatch?.supported ||
-      capabilities?.atomic?.status === 'supported' ||
-      (!skipReady && capabilities?.atomic?.status === 'ready') ||
-      false
-    )
-  } catch {
-    // If the wallet does not support getCapabilities or the call fails,
-    // we assume that atomic batch is not supported
-    return false
-  }
-}

package/src/core/EVM/parseEVMErrors.ts

@@ -1,123 +0,0 @@
-import type { LiFiStep } from '@lifi/types'
-import { AtomicReadyWalletRejectedUpgradeError } from 'viem'
-import { BaseError } from '../../errors/baseError.js'
-import { ErrorMessage, LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError, UnknownError } from '../../errors/errors.js'
-import { SDKError } from '../../errors/SDKError.js'
-import { fetchTxErrorDetails } from '../../utils/fetchTxErrorDetails.js'
-import type { Process } from '../types.js'
-
-export const parseEVMErrors = async (
-  e: Error,
-  step?: LiFiStep,
-  process?: Process
-): Promise<SDKError> => {
-  if (e instanceof SDKError) {
-    e.step = e.step ?? step
-    e.process = e.process ?? process
-    return e
-  }
-
-  const baseError = await handleSpecificErrors(e, step, process)
-
-  return new SDKError(baseError, step, process)
-}
-
-const handleSpecificErrors = async (
-  e: any,
-  step?: LiFiStep,
-  process?: Process
-) => {
-  if (
-    e.name === 'UserRejectedRequestError' ||
-    e.cause?.name === 'UserRejectedRequestError' ||
-    /**
-     * This error is specific to MetaMask and thrown when the user rejects the signature of the native token transfer, at that point, the bundle id is unknown.
-     * @see https://github.com/MetaMask/metamask-extension/blob/main/app/scripts/lib/transaction/eip5792.ts#L141-L146
-     */
-    e.name === 'UnknownBundleIdError'
-  ) {
-    return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
-  }
-  /**
-   * Safe Wallet via WalletConnect returns -32000 code when user rejects the signature
-   * {
-   *   code: -32000,
-   *   message: 'User rejected transaction',
-   * }
-   */
-  if (
-    e.cause?.code === -32000 ||
-    // Safe doesn't return proper code, but the error details includes 'rejected'
-    (e.name === 'TransactionExecutionError' &&
-      e.cause?.details?.includes('rejected'))
-  ) {
-    return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
-  }
-  /**
-   * Some wallets reject transactions sometimes with this code because of internal and JSON-RPC errors, e.g.:
-   * {
-   *     "code": -32603,
-   *     "message": "Pop up window failed to open",
-   *     "docUrl": "https://docs.cloud.coinbase.com/wallet-sdk/docs/errors"
-   * }
-   */
-  if (e.cause?.code === -32603) {
-    return new TransactionError(LiFiErrorCode.TransactionRejected, e.message, e)
-  }
-
-  /**
-   * This error is specific to Smart Accounts and thrown when the user doesn't have enough gas to pay for the transaction.
-   */
-  if (
-    e.name === 'InsufficientPrefundError' ||
-    e.cause?.name === 'InsufficientPrefundError' ||
-    e.cause?.cause?.name === 'InsufficientPrefundError'
-  ) {
-    return new TransactionError(LiFiErrorCode.InsufficientGas, e.message, e)
-  }
-
-  if (
-    step &&
-    process?.txHash &&
-    e.code === LiFiErrorCode.TransactionFailed &&
-    e.message === ErrorMessage.TransactionReverted
-  ) {
-    const response = await fetchTxErrorDetails(
-      process.txHash,
-      step.action.fromChainId
-    )
-
-    const errorMessage = response?.error_message
-
-    if (errorMessage?.toLowerCase().includes('out of gas')) {
-      return new TransactionError(
-        LiFiErrorCode.GasLimitError,
-        ErrorMessage.GasLimitLow,
-        e
-      )
-    }
-  }
-
-  if (e instanceof BaseError) {
-    return e
-  }
-
-  return new UnknownError(e.message || ErrorMessage.UnknownError, e)
-}
-
-export const isAtomicReadyWalletRejectedUpgradeError = (e: any) => {
-  if (e.cause?.code === AtomicReadyWalletRejectedUpgradeError.code) {
-    return true
-  }
-
-  const details = e.cause?.details?.toLowerCase()
-  const isTransactionError =
-    e.name === 'TransactionExecutionError' ||
-    e.cause?.name === 'TransactionExecutionError'
-  const hasRejectedUpgrade =
-    details?.includes('rejected') && details?.includes('upgrade')
-  const has7702ErrorCode = details?.includes('7702')
-
-  return isTransactionError && (hasRejectedUpgrade || has7702ErrorCode)
-}

package/src/core/EVM/permits/allowanceTransfer.ts

@@ -1,172 +0,0 @@
-import {
-  type Address,
-  hashTypedData,
-  type TypedData,
-  type TypedDataDomain,
-} from 'viem'
-import { MaxUint48, MaxUint160 } from '../../../constants.js'
-import { invariant } from '../../../utils/invariant.js'
-import { MaxSigDeadline } from './constants.js'
-import { permit2Domain } from './domain.js'
-
-export const MaxAllowanceTransferAmount = MaxUint160
-export const MaxAllowanceExpiration = MaxUint48
-export const MaxOrderedNonce = MaxUint48
-
-export interface PermitDetails {
-  token: Address
-  amount: bigint
-  expiration: number
-  nonce: number
-}
-
-export interface PermitSingle {
-  details: PermitDetails
-  spender: Address
-  sigDeadline: bigint
-}
-
-export interface PermitBatch {
-  details: PermitDetails[]
-  spender: Address
-  sigDeadline: bigint
-}
-
-export type PermitSingleData = {
-  domain: TypedDataDomain
-  types: TypedData
-  message: PermitSingle
-}
-
-export type PermitBatchData = {
-  domain: TypedDataDomain
-  types: TypedData
-  message: PermitBatch
-}
-
-const PERMIT_DETAILS = [
-  { name: 'token', type: 'address' },
-  { name: 'amount', type: 'uint160' },
-  { name: 'expiration', type: 'uint48' },
-  { name: 'nonce', type: 'uint48' },
-] as const
-
-const PERMIT_TYPES = {
-  PermitDetails: PERMIT_DETAILS,
-  PermitSingle: [
-    { name: 'details', type: 'PermitDetails' },
-    { name: 'spender', type: 'address' },
-    { name: 'sigDeadline', type: 'uint256' },
-  ],
-} as const
-
-const PERMIT_BATCH_TYPES = {
-  PermitDetails: PERMIT_DETAILS,
-  PermitBatch: [
-    { name: 'details', type: 'PermitDetails[]' },
-    { name: 'spender', type: 'address' },
-    { name: 'sigDeadline', type: 'uint256' },
-  ],
-} as const
-
-function isPermit(permit: PermitSingle | PermitBatch): permit is PermitSingle {
-  return !Array.isArray(permit.details)
-}
-
-export function getPermitSingleData(
-  permit: PermitSingle,
-  permit2Address: Address,
-  chainId: number
-) {
-  invariant(MaxSigDeadline >= permit.sigDeadline, 'SIG_DEADLINE_OUT_OF_RANGE')
-
-  const domain = permit2Domain(permit2Address, chainId)
-  validatePermitDetails(permit.details)
-
-  return {
-    domain,
-    message: permit,
-  }
-}
-
-export function getPermitBatchData(
-  permit: PermitBatch,
-  permit2Address: Address,
-  chainId: number
-) {
-  invariant(MaxSigDeadline >= permit.sigDeadline, 'SIG_DEADLINE_OUT_OF_RANGE')
-
-  const domain = permit2Domain(permit2Address, chainId)
-  permit.details.forEach(validatePermitDetails)
-
-  return {
-    domain,
-    message: permit,
-  }
-}
-
-export function getPermitData(
-  permit: PermitSingle | PermitBatch,
-  permit2Address: Address,
-  chainId: number
-): PermitSingleData | PermitBatchData {
-  invariant(MaxSigDeadline >= permit.sigDeadline, 'SIG_DEADLINE_OUT_OF_RANGE')
-
-  const domain = permit2Domain(permit2Address, chainId)
-  if (isPermit(permit)) {
-    validatePermitDetails(permit.details)
-    return {
-      domain,
-      types: PERMIT_TYPES,
-      message: permit,
-    }
-  }
-  permit.details.forEach(validatePermitDetails)
-  return {
-    domain,
-    types: PERMIT_BATCH_TYPES,
-    message: permit,
-  }
-}
-
-export function hash(
-  permit: PermitSingle | PermitBatch,
-  permit2Address: Address,
-  chainId: number
-): string {
-  if (isPermit(permit)) {
-    const { domain, message } = getPermitSingleData(
-      permit,
-      permit2Address,
-      chainId
-    )
-
-    return hashTypedData({
-      domain,
-      types: PERMIT_TYPES,
-      primaryType: 'PermitSingle',
-      message: message,
-    })
-  }
-  const { domain, message } = getPermitBatchData(
-    permit,
-    permit2Address,
-    chainId
-  )
-
-  return hashTypedData({
-    domain,
-    types: PERMIT_BATCH_TYPES,
-    primaryType: 'PermitBatch',
-    message: message,
-  })
-}
-
-function validatePermitDetails(details: PermitDetails) {
-  invariant(MaxOrderedNonce >= details.nonce, 'NONCE_OUT_OF_RANGE')
-  invariant(MaxAllowanceTransferAmount >= details.amount, 'AMOUNT_OUT_OF_RANGE')
-  invariant(
-    MaxAllowanceExpiration >= details.expiration,
-    'EXPIRATION_OUT_OF_RANGE'
-  )
-}

package/src/core/EVM/permits/constants.ts

@@ -1,82 +0,0 @@
-import type { Hex } from 'viem'
-import { MaxUint48, MaxUint160, MaxUint256 } from '../../../constants.js'
-
-export const MaxAllowanceTransferAmount = MaxUint160
-export const MaxAllowanceExpiration = MaxUint48
-export const MaxOrderedNonce = MaxUint48
-
-export const MaxSignatureTransferAmount = MaxUint256
-export const MaxUnorderedNonce = MaxUint256
-export const MaxSigDeadline = MaxUint256
-
-export const InstantExpiration = 0n
-
-export const EIP_2612_PERMIT_SELECTOR = '0xd505accf'
-export const DAI_PERMIT_SELECTOR = '0x8fcbaf0c'
-
-/**
- * EIP-712 domain typehash with chainId
- * @link https://eips.ethereum.org/EIPS/eip-712#specification
- *
- * keccak256(toBytes(
- *   'EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'
- * ))
- */
-export const EIP712_DOMAIN_TYPEHASH =
-  '0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f' as Hex
-
-/**
- * EIP-712 domain typehash with salt (e.g. USDC.e on Polygon)
- * @link https://eips.ethereum.org/EIPS/eip-712#specification
- *
- * keccak256(toBytes(
- *   'EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)'
- * ))
- */
-export const EIP712_DOMAIN_TYPEHASH_WITH_SALT =
-  '0x36c25de3e541d5d970f66e4210d728721220fff5c077cc6cd008b3a0c62adab7' as Hex
-
-export const EIP712_DOMAINS_WITHOUT_VERSION = [
-  /** @signature 'EIP712Domain(string name,uint chainId,address verifyingContract)' */
-  '0x797cfab58fcb15f590eb8e4252d5c228ff88f94f907e119e80c4393a946e8f35' as Hex,
-  /** @signature 'EIP712Domain(string name,uint256 chainId,address verifyingContract)' */
-  '0x8cad95687ba82c2ce50e74f7b754645e5117c3a5bec8151c0726d5857980a866' as Hex,
-]
-
-/**
- * @signature Permit(address holder,address spender,uint256 nonce,uint256 expiry,bool allowed)
- * */
-export const DAI_LIKE_PERMIT_TYPEHASH =
-  '0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb' as Hex
-
-/**
- * @example `${tokenAddress}:${chainId}.toLowerCase()`
- * @warning Only toLowerCase string
- * */
-export const TOKEN_ADDRESSES_WITH_SALT = [
-  '0x2791bca1f2de4661ed88a30c99a7a9449aa84174:137', // USDC Proxy Polygon
-  '0x8f3cf7ad23cd3cadbd9735aff958023239c6a063:137', // DAI Proxy Polygon
-]
-
-// EIP-2612 types
-// https://eips.ethereum.org/EIPS/eip-2612
-export const eip2612Types = {
-  Permit: [
-    { name: 'owner', type: 'address' },
-    { name: 'spender', type: 'address' },
-    { name: 'value', type: 'uint256' },
-    { name: 'nonce', type: 'uint256' },
-    { name: 'deadline', type: 'uint256' },
-  ],
-} as const
-
-// DAI on Ethereum
-export const daiPermitTypes = {
-  Permit: [
-    { name: 'holder', type: 'address' },
-    { name: 'spender', type: 'address' },
-    { name: 'nonce', type: 'uint256' },
-    { name: 'expiry', type: 'uint256' },
-    { name: 'allowed', type: 'bool' },
-  ],
-} as const

package/src/core/EVM/permits/domain.ts

@@ -1,14 +0,0 @@
-import type { Address, TypedDataDomain } from 'viem'
-
-const PERMIT2_DOMAIN_NAME = 'Permit2'
-
-export function permit2Domain(
-  permit2Address: Address,
-  chainId: number
-): TypedDataDomain {
-  return {
-    name: PERMIT2_DOMAIN_NAME,
-    chainId,
-    verifyingContract: permit2Address,
-  }
-}