@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/core/EVM/types.ts

@@ -1,72 +0,0 @@
-import { type BaseToken, ChainType } from '@lifi/types'
-import type {
-  WalletCallReceipt as _WalletCallReceipt,
-  Address,
-  Client,
-  FallbackTransportConfig,
-  Hex,
-} from 'viem'
-import type { SDKProvider, SwitchChainHook } from '../types.js'
-
-export interface EVMProviderOptions {
-  getWalletClient?: () => Promise<Client>
-  switchChain?: SwitchChainHook
-  fallbackTransportConfig?: FallbackTransportConfig
-}
-
-export interface EVMProvider extends SDKProvider {
-  options: EVMProviderOptions
-  setOptions(options: EVMProviderOptions): void
-  getWalletClient?(): Promise<Client>
-}
-
-export function isEVM(provider: SDKProvider): provider is EVMProvider {
-  return provider.type === ChainType.EVM
-}
-
-export type TokenSpender = {
-  token: BaseToken
-  spenderAddress: string
-}
-
-export type TokenAllowance = {
-  token: BaseToken
-  allowance?: bigint
-}
-
-export type TokenSpenderAllowance = {
-  token: BaseToken
-  spenderAddress: string
-  allowance?: bigint
-}
-
-export interface ApproveTokenRequest {
-  walletClient: Client
-  token: BaseToken
-  spenderAddress: string
-  amount: bigint
-  /**
-   * @deprecated
-   */
-  infiniteApproval?: boolean
-}
-
-export interface RevokeApprovalRequest {
-  walletClient: Client
-  token: BaseToken
-  spenderAddress: string
-}
-
-export type Call = {
-  to: Address
-  data?: Hex
-  value?: bigint
-  chainId?: number
-}
-
-export type WalletCallReceipt = _WalletCallReceipt<
-  bigint,
-  'success' | 'reverted'
-> & {
-  transactionLink?: string
-}

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

@@ -1,83 +0,0 @@
-import { ChainId, ChainType } from '@lifi/types'
-import type { Address } from 'viem'
-
-export const UNS_PROXY_READER_ADDRESSES: Record<number, Address> = {
-  [ChainId.ETH]: '0x578853aa776Eef10CeE6c4dd2B5862bdcE767A8B',
-  [ChainId.POL]: '0x91EDd8708062bd4233f4Dd0FCE15A7cb4d500091',
-} as const
-
-export const getUNSProxyAddress = (chainId: number): Address | undefined =>
-  UNS_PROXY_READER_ADDRESSES[chainId]
-
-export const UNSProxyReaderABI = [
-  {
-    constant: true,
-    inputs: [
-      {
-        internalType: 'string[]',
-        name: 'keys',
-        type: 'string[]',
-      },
-      {
-        internalType: 'uint256',
-        name: 'tokenId',
-        type: 'uint256',
-      },
-    ],
-    name: 'getData',
-    outputs: [
-      {
-        internalType: 'address',
-        name: 'resolver',
-        type: 'address',
-      },
-      {
-        internalType: 'address',
-        name: 'owner',
-        type: 'address',
-      },
-      {
-        internalType: 'string[]',
-        name: 'values',
-        type: 'string[]',
-      },
-    ],
-    payable: false,
-    stateMutability: 'view',
-    type: 'function',
-  },
-  {
-    inputs: [{ internalType: 'uint256', name: 'tokenId', type: 'uint256' }],
-    name: 'exists',
-    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
-    stateMutability: 'view',
-    type: 'function',
-  },
-] as const
-
-export const CHAIN_TYPE_UNS_CHAIN_MAP: Record<ChainType, string> = {
-  [ChainType.EVM]: 'ETH',
-  [ChainType.MVM]: 'SUI',
-  [ChainType.SVM]: 'SOL',
-  [ChainType.UTXO]: 'BTC',
-  [ChainType.TVM]: 'TRON',
-}
-
-export const CHAIN_ID_UNS_CHAIN_MAP: Partial<Record<ChainId, string>> = {
-  [ChainId.ETH]: 'ETH',
-  [ChainId.BTC]: 'BTC',
-  [ChainId.SUI]: 'SUI',
-  [ChainId.SOL]: 'SOL',
-  [ChainId.BAS]: 'BASE',
-  [ChainId.POL]: 'MATIC',
-  [ChainId.ARB]: 'ARB1',
-  [ChainId.AVA]: 'AVAX',
-}
-
-export const CHAIN_TYPE_FAMILY_MAP: Record<ChainType, string> = {
-  [ChainType.EVM]: 'EVM',
-  [ChainType.UTXO]: 'BTC',
-  [ChainType.SVM]: 'SOL',
-  [ChainType.MVM]: 'SUI',
-  [ChainType.TVM]: 'TRON',
-}

package/src/core/EVM/uns/resolveUNSAddress.ts

@@ -1,123 +0,0 @@
-import { ChainId, type ChainType, type CoinKey } from '@lifi/types'
-import type { Address, Client } from 'viem'
-import { readContract } from 'viem/actions'
-import { namehash } from 'viem/ens'
-import { getAction, trim } from 'viem/utils'
-import { getPublicClient } from '../publicClient.js'
-
-import {
-  CHAIN_ID_UNS_CHAIN_MAP,
-  CHAIN_TYPE_FAMILY_MAP,
-  CHAIN_TYPE_UNS_CHAIN_MAP,
-  getUNSProxyAddress,
-  UNSProxyReaderABI,
-} from './constants.js'
-
-export const resolveUNSAddress = async (
-  name: string,
-  chainType: ChainType,
-  chain?: ChainId,
-  token?: CoinKey
-): Promise<string | undefined> => {
-  try {
-    const L1Client = await getPublicClient(ChainId.ETH)
-    const L2Client = await getPublicClient(ChainId.POL)
-
-    const nameHash = namehash(name)
-    const keys: string[] = []
-
-    // handle token based resolution
-    if (chain) {
-      const family = CHAIN_TYPE_FAMILY_MAP[chainType]
-      const unsChain = CHAIN_ID_UNS_CHAIN_MAP[chain]
-
-      if (family) {
-        if (token) {
-          keys.push(`token.${family}.${unsChain}.${token}.address`)
-        }
-        if (unsChain) {
-          keys.push(`token.${family}.${unsChain}.address`)
-        }
-
-        keys.push(`token.${family}.address`)
-      }
-    }
-
-    // fallback to chain based resolution
-    const unsChainType = CHAIN_TYPE_UNS_CHAIN_MAP[chainType]
-    keys.push(`crypto.${unsChainType}.address`)
-
-    for (const key of keys) {
-      const address =
-        (await getUnsAddress(L2Client, { name: nameHash, key })) ||
-        (await getUnsAddress(L1Client, { name: nameHash, key }))
-      if (address) {
-        return address
-      }
-    }
-    return undefined
-  } catch {
-    return undefined
-  }
-}
-
-type GetUnsAddressParameters = {
-  key: string
-  name: string
-}
-
-type GetUnsAddressReturnType = Address | undefined
-
-async function getUnsAddress(
-  client: Client,
-  params: GetUnsAddressParameters
-): Promise<GetUnsAddressReturnType> {
-  const { name, key } = params
-
-  const chainId = client.chain?.id
-  if (!chainId) {
-    throw new Error('Chain ID not available')
-  }
-
-  const proxyAddress = getUNSProxyAddress(chainId)
-  if (!proxyAddress) {
-    throw new Error(`UNS contracts are not deployed on chain ${chainId}`)
-  }
-
-  const readContractAction = getAction(client, readContract, 'readContract')
-
-  const existsReadContractParameters = {
-    abi: UNSProxyReaderABI,
-    address: proxyAddress,
-    functionName: 'exists',
-    args: [BigInt(name)],
-  } as const
-
-  const exists = await readContractAction(existsReadContractParameters)
-
-  if (!exists) {
-    return undefined
-  }
-
-  const readContractParameters = {
-    abi: UNSProxyReaderABI,
-    address: proxyAddress,
-    functionName: 'getData',
-    args: [[key], BigInt(name)],
-  } as const
-
-  const res = await readContractAction(readContractParameters)
-  const [, , addresses] = res
-
-  const address = addresses[0]
-
-  if (
-    address === '0x' ||
-    address === '' ||
-    trim(address as Address) === '0x00'
-  ) {
-    return undefined
-  }
-
-  return address as Address
-}

package/src/core/EVM/utils.ts

@@ -1,148 +0,0 @@
-import type { ChainId, ExtendedChain } from '@lifi/types'
-import type { Address, Chain, Client, Transaction, TypedDataDomain } from 'viem'
-import { getBlock } from 'viem/actions'
-import { config } from '../../config.js'
-import { median } from '../../utils/median.js'
-import { getActionWithFallback } from './getActionWithFallback.js'
-
-type ChainBlockExplorer = {
-  name: string
-  url: string
-}
-
-type ChainBlockExplorers = {
-  [key: string]: ChainBlockExplorer
-  default: ChainBlockExplorer
-}
-
-export const convertExtendedChain = (chain: ExtendedChain): Chain => ({
-  ...chain,
-  ...chain.metamask,
-  blockExplorers: chain.metamask.blockExplorerUrls.reduce(
-    (blockExplorers, blockExplorer, index) => {
-      blockExplorers[index === 0 ? 'default' : `${index}`] = {
-        name: blockExplorer,
-        url: blockExplorer,
-      }
-      return blockExplorers
-    },
-    {} as ChainBlockExplorers
-  ),
-  name: chain.metamask.chainName,
-  rpcUrls: {
-    default: { http: chain.metamask.rpcUrls },
-    public: { http: chain.metamask.rpcUrls },
-  },
-  contracts: {
-    ...(chain.multicallAddress
-      ? { multicall3: { address: chain.multicallAddress as Address } }
-      : undefined),
-  },
-})
-
-export function isExtendedChain(chain: any): chain is ExtendedChain {
-  return (
-    typeof chain === 'object' &&
-    chain !== null &&
-    'key' in chain &&
-    'chainType' in chain &&
-    'coin' in chain &&
-    'mainnet' in chain &&
-    'logoURI' in chain &&
-    typeof chain.metamask === 'object' &&
-    chain.metamask !== null &&
-    typeof chain.nativeToken === 'object' &&
-    chain.nativeToken !== null
-  )
-}
-
-export const getMaxPriorityFeePerGas = async (
-  client: Client
-): Promise<bigint | undefined> => {
-  const block = await getActionWithFallback(client, getBlock, 'getBlock', {
-    includeTransactions: true,
-  })
-
-  const maxPriorityFeePerGasList = (block.transactions as Transaction[])
-    .filter((tx) => tx.maxPriorityFeePerGas)
-    .map((tx) => tx.maxPriorityFeePerGas) as bigint[]
-
-  if (!maxPriorityFeePerGasList.length) {
-    return
-  }
-
-  let maxPriorityFeePerGasSum = 0n
-  for (const value of maxPriorityFeePerGasList) {
-    maxPriorityFeePerGasSum += value
-  }
-
-  const maxPriorityFeePerGasMedian = median(maxPriorityFeePerGasList) ?? 0n
-
-  const maxPriorityFeePerGasAvg =
-    maxPriorityFeePerGasSum / BigInt(maxPriorityFeePerGasList.length)
-
-  return maxPriorityFeePerGasMedian > maxPriorityFeePerGasAvg
-    ? maxPriorityFeePerGasAvg
-    : maxPriorityFeePerGasMedian
-}
-
-// Multicall
-export const getMulticallAddress = async (
-  chainId: ChainId
-): Promise<Address | undefined> => {
-  const chains = await config.getChains()
-  return chains.find((chain) => chain.id === chainId)
-    ?.multicallAddress as Address
-}
-
-// Modified viem retryDelay exponential backoff function.
-export const retryDelay = ({ count }: { count: number; error: Error }) =>
-  Math.min(~~(1 << count) * 200, 3000)
-
-export const retryCount = 30
-
-/**
- * Helper function to get the chain ID from a TypedDataDomain.
- * Extracts the chain ID from either the chainId field or the salt field.
- * The salt is expected to be a padded hex string representation of the chainId.
- */
-export const getDomainChainId = (domain: TypedDataDomain): number | null => {
-  if (domain.chainId) {
-    return Number(domain.chainId)
-  }
-  if (!domain.salt) {
-    return null
-  }
-  try {
-    // Convert the hex salt to a number
-    // The salt should be a padded 32-byte hex representation of the chainId
-    const saltChainId = Number(domain.salt)
-    return !Number.isNaN(saltChainId) ? saltChainId : null
-  } catch {
-    return null
-  }
-}
-
-/**
- * EIP-7702 introduces delegation designators that allow EOAs to delegate execution to other contracts.
- * A delegation designator starts with 0xef0100 followed by the target contract address.
- *
- * When an EOA has this code, it means:
- * - The EOA can still send transactions (unlike other contract accounts)
- * - All contract calls are delegated to the target address
- * - The code itself remains as the delegation designator (0xef0100 || address)
- *
- * Delegation Designator Structure:
- *
- * ─────┬───┬──┬───────────────────────────────────────┐
- *      │   │  │                                       │
- *  0x ef 0100 a94f5374fce5edbc8e2a8697c15331677e6ebf0b
- *      │   │  └───────────────────────────────────────┘
- *      │   │                         Target Address
- *      │   └── 7702
- *      └── 3541
- *
- * @see https://eips.ethereum.org/EIPS/eip-7702
- */
-export const isDelegationDesignatorCode = (code?: string) =>
-  code?.startsWith('0xef0100')

package/src/core/EVM/waitForBatchTransactionReceipt.ts

@@ -1,49 +0,0 @@
-import type { Client, Hash } from 'viem'
-import { type GetCallsStatusReturnType, waitForCallsStatus } from 'viem/actions'
-import { getAction } from 'viem/utils'
-import { LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError } from '../../errors/errors.js'
-import type { WalletCallReceipt } from './types.js'
-
-export const waitForBatchTransactionReceipt = async (
-  client: Client,
-  batchHash: Hash,
-  onFailed?: (result: GetCallsStatusReturnType) => void
-): Promise<WalletCallReceipt> => {
-  const result = await getAction(
-    client,
-    waitForCallsStatus,
-    'waitForCallsStatus'
-  )({
-    id: batchHash,
-    timeout: 3_600_000 * 24,
-  })
-
-  if (result.status === 'success') {
-    if (
-      !result.receipts?.length ||
-      !result.receipts.every((receipt) => receipt.transactionHash) ||
-      result.receipts.some((receipt) => receipt.status === 'reverted')
-    ) {
-      onFailed?.(result)
-      throw new TransactionError(
-        LiFiErrorCode.TransactionFailed,
-        'Transaction was reverted.'
-      )
-    }
-    const transactionReceipt = result.receipts.at(-1)!
-    return transactionReceipt
-  }
-  if (result.statusCode >= 400 && result.statusCode < 500) {
-    onFailed?.(result)
-    throw new TransactionError(
-      LiFiErrorCode.TransactionCanceled,
-      'Transaction was canceled.'
-    )
-  }
-  onFailed?.(result)
-  throw new TransactionError(
-    LiFiErrorCode.TransactionFailed,
-    'Transaction failed.'
-  )
-}

package/src/core/EVM/waitForRelayedTransactionReceipt.ts

@@ -1,67 +0,0 @@
-import type {
-  ExtendedTransactionInfo,
-  FullStatusData,
-  LiFiStep,
-} from '@lifi/types'
-import type { Hash } from 'viem'
-import { LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError } from '../../errors/errors.js'
-import { getRelayedTransactionStatus } from '../../services/api.js'
-import { waitForResult } from '../../utils/waitForResult.js'
-import type { WalletCallReceipt } from './types.js'
-
-export const waitForRelayedTransactionReceipt = async (
-  taskId: Hash,
-  step: LiFiStep
-): Promise<WalletCallReceipt> => {
-  return waitForResult(
-    async () => {
-      const result = await getRelayedTransactionStatus({
-        taskId,
-        fromChain: step.action.fromChainId,
-        toChain: step.action.toChainId,
-        ...(step.tool !== 'custom' && { bridge: step.tool }),
-      }).catch((e) => {
-        if (process.env.NODE_ENV === 'development') {
-          console.debug('Fetching status from relayer failed.', e)
-        }
-        return undefined
-      })
-
-      switch (result?.status) {
-        case 'PENDING':
-          return undefined
-        case 'DONE': {
-          const sending: ExtendedTransactionInfo | undefined =
-            (result?.transactionStatus?.sending as ExtendedTransactionInfo) ||
-            ((result as unknown as FullStatusData)
-              ?.sending as ExtendedTransactionInfo)
-          return {
-            status: 'success',
-            gasUsed: sending?.gasUsed,
-            transactionHash: result?.metadata.txHash || sending?.txHash,
-            transactionLink: sending?.txLink,
-          } as unknown as WalletCallReceipt
-        }
-        case 'FAILED':
-          throw new TransactionError(
-            LiFiErrorCode.TransactionFailed,
-            'Transaction was reverted.'
-          )
-        default:
-          throw new TransactionError(
-            LiFiErrorCode.TransactionNotFound,
-            'Transaction not found.'
-          )
-      }
-    },
-    5000,
-    3,
-    (_, error) => {
-      return !(
-        error instanceof TransactionError &&
-        error.code === LiFiErrorCode.TransactionFailed
-      )
-    }
-  )
-}

package/src/core/EVM/waitForTransactionReceipt.ts

@@ -1,83 +0,0 @@
-import type { ChainId } from '@lifi/types'
-import type {
-  Chain,
-  Client,
-  Hash,
-  ReplacementReason,
-  ReplacementReturnType,
-  TransactionReceipt,
-} from 'viem'
-import { waitForTransactionReceipt as waitForTransactionReceiptInternal } from 'viem/actions'
-import { LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError } from '../../errors/errors.js'
-import { getPublicClient } from './publicClient.js'
-
-interface WaitForTransactionReceiptProps {
-  client: Client
-  chainId: ChainId
-  txHash: Hash
-  onReplaced?: (response: ReplacementReturnType<Chain | undefined>) => void
-}
-
-export async function waitForTransactionReceipt({
-  client,
-  chainId,
-  txHash,
-  onReplaced,
-}: WaitForTransactionReceiptProps): Promise<TransactionReceipt | undefined> {
-  let { transactionReceipt, replacementReason } = await waitForReceipt(
-    client,
-    txHash,
-    onReplaced
-  )
-
-  if (!transactionReceipt?.status) {
-    const publicClient = await getPublicClient(chainId)
-    const result = await waitForReceipt(publicClient, txHash, onReplaced)
-    transactionReceipt = result.transactionReceipt
-    replacementReason = result.replacementReason
-  }
-
-  if (transactionReceipt?.status === 'reverted') {
-    throw new TransactionError(
-      LiFiErrorCode.TransactionFailed,
-      'Transaction was reverted.'
-    )
-  }
-  // We should only allow repriced transaction to continue the execution.
-  // Cancelled and replaced transactions should be treated as failed.
-  if (replacementReason === 'cancelled' || replacementReason === 'replaced') {
-    throw new TransactionError(
-      LiFiErrorCode.TransactionCanceled,
-      'Transaction was canceled or replaced.'
-    )
-  }
-
-  return transactionReceipt
-}
-
-async function waitForReceipt(
-  client: Client,
-  txHash: Hash,
-  onReplaced?: (response: ReplacementReturnType<Chain | undefined>) => void
-): Promise<{
-  transactionReceipt?: TransactionReceipt
-  replacementReason?: ReplacementReason
-}> {
-  let replacementReason: ReplacementReason | undefined
-  let transactionReceipt: TransactionReceipt | undefined
-
-  try {
-    transactionReceipt = await waitForTransactionReceiptInternal(client, {
-      hash: txHash,
-      onReplaced: (response) => {
-        replacementReason = response.reason
-        onReplaced?.(response)
-      },
-    })
-  } catch {
-    // We can ignore errors from waitForTransactionReceipt as we have a status check fallback
-  }
-
-  return { transactionReceipt, replacementReason }
-}