@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/core/EVM/abi.ts

@@ -1,35 +0,0 @@
-import { parseAbi } from 'viem'
-
-export const permit2ProxyAbi = parseAbi([
-  'function callDiamondWithPermit2(bytes, ((address, uint256), uint256, uint256), bytes) external',
-  'function callDiamondWithEIP2612Signature(address, uint256, uint256, uint8, bytes32, bytes32, bytes) external payable',
-  'function nextNonce(address) external view returns (uint256)',
-  'function callDiamondWithPermit2Witness(bytes, address, ((address, uint256), uint256, uint256), bytes) external payable',
-])
-
-export const eip2612Abi = parseAbi([
-  'function permit(address, address, uint256, uint256, uint8, bytes32, bytes32) external',
-  'function DOMAIN_SEPARATOR() external view returns (bytes32)',
-  'function nonces(address) external view returns (uint256)',
-  'function name() external view returns (string)',
-  'function version() external view returns (string)',
-  'function PERMIT_TYPEHASH() external view returns (bytes32)',
-  // EIP-5267
-  'function eip712Domain() external view returns (bytes1, string, string, uint256, address, bytes32, uint256[])',
-])
-
-export const approveAbi = parseAbi([
-  'function approve(address, uint256) external returns (bool)',
-])
-
-export const allowanceAbi = parseAbi([
-  'function allowance(address, address) external view returns (uint256)',
-])
-
-export const getEthBalanceAbi = parseAbi([
-  'function getEthBalance(address) external view returns (uint256)',
-])
-
-export const balanceOfAbi = parseAbi([
-  'function balanceOf(address) external view returns (uint256)',
-])

package/src/core/EVM/checkAllowance.ts

@@ -1,429 +0,0 @@
-import type { ExtendedChain, LiFiStep, SignedTypedData } from '@lifi/types'
-import type { Address, Client, Hash } from 'viem'
-import { signTypedData } from 'viem/actions'
-import { getAction } from 'viem/utils'
-import { MaxUint256 } from '../../constants.js'
-import type { StatusManager } from '../StatusManager.js'
-import type {
-  ExecutionOptions,
-  LiFiStepExtended,
-  Process,
-  ProcessType,
-} from '../types.js'
-import { getActionWithFallback } from './getActionWithFallback.js'
-import { getAllowance } from './getAllowance.js'
-import { parseEVMErrors } from './parseEVMErrors.js'
-import { getNativePermit } from './permits/getNativePermit.js'
-import { isNativePermitValid } from './permits/isNativePermitValid.js'
-import type { NativePermitData } from './permits/types.js'
-import { setAllowance } from './setAllowance.js'
-import type { Call } from './types.js'
-import { getDomainChainId } from './utils.js'
-import { waitForTransactionReceipt } from './waitForTransactionReceipt.js'
-
-type CheckAllowanceParams = {
-  checkClient(
-    step: LiFiStepExtended,
-    process: Process,
-    targetChainId?: number
-  ): Promise<Client | undefined>
-  chain: ExtendedChain
-  step: LiFiStep
-  statusManager: StatusManager
-  executionOptions?: ExecutionOptions
-  allowUserInteraction?: boolean
-  batchingSupported?: boolean
-  permit2Supported?: boolean
-  disableMessageSigning?: boolean
-}
-
-type AllowanceResult =
-  | {
-      status: 'ACTION_REQUIRED'
-    }
-  | {
-      status: 'BATCH_APPROVAL'
-      data: { calls: Call[]; signedTypedData: SignedTypedData[] }
-    }
-  | {
-      status: 'NATIVE_PERMIT' | 'DONE'
-      data: SignedTypedData[]
-    }
-
-export const checkAllowance = async ({
-  checkClient,
-  chain,
-  step,
-  statusManager,
-  executionOptions,
-  allowUserInteraction = false,
-  batchingSupported = false,
-  permit2Supported = false,
-  disableMessageSigning = false,
-}: CheckAllowanceParams): Promise<AllowanceResult> => {
-  let sharedProcess: Process | undefined
-  let signedTypedData: SignedTypedData[] = []
-  try {
-    // First, try to sign all permits in step.typedData
-    const permitTypedData = step.typedData?.filter(
-      (typedData) => typedData.primaryType === 'Permit'
-    )
-    if (!disableMessageSigning && permitTypedData?.length) {
-      sharedProcess = statusManager.findOrCreateProcess({
-        step,
-        type: 'PERMIT',
-        chainId: step.action.fromChainId,
-      })
-      signedTypedData = sharedProcess.signedTypedData ?? signedTypedData
-      for (const typedData of permitTypedData) {
-        // Check if we already have a valid permit for this chain and requirements
-        const signedTypedDataForChain = signedTypedData.find(
-          (signedTypedData) => isNativePermitValid(signedTypedData, typedData)
-        )
-
-        if (signedTypedDataForChain) {
-          // Skip signing if we already have a valid permit
-          continue
-        }
-
-        sharedProcess = statusManager.updateProcess(
-          step,
-          sharedProcess.type,
-          'ACTION_REQUIRED'
-        )
-        if (!allowUserInteraction) {
-          return { status: 'ACTION_REQUIRED' }
-        }
-
-        const typedDataChainId =
-          getDomainChainId(typedData.domain) || step.action.fromChainId
-        // Switch to the permit's chain if needed
-        const permitClient = await checkClient(
-          step,
-          sharedProcess,
-          typedDataChainId
-        )
-        if (!permitClient) {
-          return { status: 'ACTION_REQUIRED' }
-        }
-
-        const signature = await getAction(
-          permitClient,
-          signTypedData,
-          'signTypedData'
-        )({
-          account: permitClient.account!,
-          domain: typedData.domain,
-          types: typedData.types,
-          primaryType: typedData.primaryType,
-          message: typedData.message,
-        })
-        const signedPermit: SignedTypedData = {
-          ...typedData,
-          signature,
-        }
-        signedTypedData.push(signedPermit)
-        sharedProcess = statusManager.updateProcess(
-          step,
-          sharedProcess.type,
-          'ACTION_REQUIRED',
-          {
-            signedTypedData,
-          }
-        )
-      }
-
-      statusManager.updateProcess(step, sharedProcess.type, 'DONE', {
-        signedTypedData,
-      })
-      // Check if there's a signed permit for the source transaction chain
-      const matchingPermit = signedTypedData.find(
-        (signedTypedData) =>
-          getDomainChainId(signedTypedData.domain) === step.action.fromChainId
-      )
-      if (matchingPermit) {
-        return {
-          status: 'NATIVE_PERMIT',
-          data: signedTypedData,
-        }
-      }
-    }
-
-    // Find existing or create new allowance process
-    sharedProcess = statusManager.findOrCreateProcess({
-      step,
-      type: 'TOKEN_ALLOWANCE',
-      chainId: step.action.fromChainId,
-    })
-
-    const updatedClient = await checkClient(step, sharedProcess)
-    if (!updatedClient) {
-      return { status: 'ACTION_REQUIRED' }
-    }
-
-    // Handle existing pending transaction
-    if (sharedProcess.txHash && sharedProcess.status !== 'DONE') {
-      await waitForApprovalTransaction(
-        updatedClient,
-        sharedProcess.txHash as Address,
-        sharedProcess.type,
-        step,
-        chain,
-        statusManager
-      )
-      return { status: 'DONE', data: signedTypedData }
-    }
-
-    // Start new allowance check
-    statusManager.updateProcess(step, sharedProcess.type, 'STARTED')
-
-    const spenderAddress = permit2Supported
-      ? chain.permit2
-      : step.estimate.approvalAddress
-
-    const fromAmount = BigInt(step.action.fromAmount)
-
-    const approved = await getAllowance(
-      updatedClient,
-      step.action.fromToken.address as Address,
-      updatedClient.account!.address,
-      spenderAddress as Address
-    )
-
-    // Return early if already approved
-    if (fromAmount <= approved) {
-      statusManager.updateProcess(step, sharedProcess.type, 'DONE')
-      return { status: 'DONE', data: signedTypedData }
-    }
-
-    // Check if proxy contract is available and message signing is not disabled, also not available for atomic batch
-    const isNativePermitAvailable =
-      !!chain.permit2Proxy && !batchingSupported && !disableMessageSigning
-
-    let nativePermitData: NativePermitData | undefined
-    if (isNativePermitAvailable) {
-      nativePermitData = await getActionWithFallback(
-        updatedClient,
-        getNativePermit,
-        'getNativePermit',
-        {
-          chainId: chain.id,
-          tokenAddress: step.action.fromToken.address as Address,
-          spenderAddress: chain.permit2Proxy as Address,
-          amount: fromAmount,
-        }
-      )
-    }
-
-    if (isNativePermitAvailable && nativePermitData) {
-      signedTypedData = signedTypedData.length
-        ? signedTypedData
-        : sharedProcess.signedTypedData || []
-      // Check if we already have a valid permit for this chain and requirements
-      const signedTypedDataForChain = signedTypedData.find((signedTypedData) =>
-        isNativePermitValid(signedTypedData, nativePermitData)
-      )
-
-      if (!signedTypedDataForChain) {
-        statusManager.updateProcess(step, sharedProcess.type, 'ACTION_REQUIRED')
-
-        if (!allowUserInteraction) {
-          return { status: 'ACTION_REQUIRED' }
-        }
-
-        // Sign the permit
-        const signature = await getAction(
-          updatedClient,
-          signTypedData,
-          'signTypedData'
-        )({
-          account: updatedClient.account!,
-          domain: nativePermitData.domain,
-          types: nativePermitData.types,
-          primaryType: nativePermitData.primaryType,
-          message: nativePermitData.message,
-        })
-
-        // Add the new permit to the signed permits array
-        const signedPermit: SignedTypedData = {
-          ...nativePermitData,
-          signature,
-        }
-        signedTypedData.push(signedPermit)
-      }
-
-      statusManager.updateProcess(step, sharedProcess.type, 'DONE', {
-        signedTypedData,
-      })
-      return {
-        status: 'NATIVE_PERMIT',
-        data: signedTypedData,
-      }
-    }
-
-    const shouldResetApproval = step.estimate.approvalReset && approved > 0n
-    const resetApprovalStatus = shouldResetApproval
-      ? 'RESET_REQUIRED'
-      : 'ACTION_REQUIRED'
-
-    // Clear the txHash and txLink from potential previous approval transaction
-    statusManager.updateProcess(step, sharedProcess.type, resetApprovalStatus, {
-      txHash: undefined,
-      txLink: undefined,
-    })
-
-    if (!allowUserInteraction) {
-      return { status: 'ACTION_REQUIRED' }
-    }
-
-    // Reset allowance to 0 if required
-    let approvalResetTxHash: Hash | undefined
-    if (shouldResetApproval) {
-      approvalResetTxHash = await setAllowance(
-        updatedClient,
-        step.action.fromToken.address as Address,
-        spenderAddress as Address,
-        0n,
-        executionOptions,
-        batchingSupported
-      )
-
-      // If batching is NOT supported, wait for the reset transaction
-      if (!batchingSupported) {
-        await waitForApprovalTransaction(
-          updatedClient,
-          approvalResetTxHash,
-          sharedProcess.type,
-          step,
-          chain,
-          statusManager
-        )
-
-        statusManager.updateProcess(
-          step,
-          sharedProcess.type,
-          'ACTION_REQUIRED',
-          {
-            txHash: undefined,
-            txLink: undefined,
-          }
-        )
-
-        if (!allowUserInteraction) {
-          return { status: 'ACTION_REQUIRED' }
-        }
-      }
-    }
-
-    // Set new allowance
-    const approveAmount = permit2Supported ? MaxUint256 : fromAmount
-    const approveTxHash = await setAllowance(
-      updatedClient,
-      step.action.fromToken.address as Address,
-      spenderAddress as Address,
-      approveAmount,
-      executionOptions,
-      // We need to return the populated transaction is batching is supported
-      // instead of executing transaction on-chain
-      batchingSupported
-    )
-
-    // If batching is supported, we need to return the batch approval data
-    // because allowance was't set by standard approval transaction
-    if (batchingSupported) {
-      statusManager.updateProcess(step, sharedProcess.type, 'DONE')
-      const calls: Call[] = []
-
-      // Add reset call first if approval reset is required
-      if (shouldResetApproval && approvalResetTxHash) {
-        calls.push({
-          to: step.action.fromToken.address as Address,
-          data: approvalResetTxHash,
-          chainId: step.action.fromToken.chainId,
-        })
-      }
-
-      // Add approval call
-      calls.push({
-        to: step.action.fromToken.address as Address,
-        data: approveTxHash,
-        chainId: step.action.fromToken.chainId,
-      })
-
-      return {
-        status: 'BATCH_APPROVAL',
-        data: {
-          calls,
-          signedTypedData,
-        },
-      }
-    }
-
-    await waitForApprovalTransaction(
-      updatedClient,
-      approveTxHash,
-      sharedProcess.type,
-      step,
-      chain,
-      statusManager
-    )
-
-    return { status: 'DONE', data: signedTypedData }
-  } catch (e: any) {
-    if (!sharedProcess) {
-      sharedProcess = statusManager.findOrCreateProcess({
-        step,
-        type: 'TOKEN_ALLOWANCE',
-        chainId: step.action.fromChainId,
-      })
-    }
-    const error = await parseEVMErrors(e, step, sharedProcess)
-    statusManager.updateProcess(step, sharedProcess.type, 'FAILED', {
-      error: {
-        message: error.cause.message,
-        code: error.code,
-      },
-    })
-    statusManager.updateExecution(step, 'FAILED')
-    throw error
-  }
-}
-
-const waitForApprovalTransaction = async (
-  client: Client,
-  txHash: Hash,
-  processType: ProcessType,
-  step: LiFiStep,
-  chain: ExtendedChain,
-  statusManager: StatusManager,
-  approvalReset: boolean = false
-) => {
-  const baseExplorerUrl = chain.metamask.blockExplorerUrls[0]
-  const getTxLink = (hash: Hash) => `${baseExplorerUrl}tx/${hash}`
-
-  statusManager.updateProcess(step, processType, 'PENDING', {
-    txHash,
-    txLink: getTxLink(txHash),
-  })
-
-  const transactionReceipt = await waitForTransactionReceipt({
-    client,
-    chainId: chain.id,
-    txHash,
-    onReplaced(response) {
-      const newHash = response.transaction.hash
-      statusManager.updateProcess(step, processType, 'PENDING', {
-        txHash: newHash,
-        txLink: getTxLink(newHash),
-      })
-    },
-  })
-
-  const finalHash = transactionReceipt?.transactionHash || txHash
-  if (!approvalReset) {
-    statusManager.updateProcess(step, processType, 'DONE', {
-      txHash: finalHash,
-      txLink: getTxLink(finalHash),
-    })
-  }
-}

package/src/core/EVM/checkPermitSupport.ts

@@ -1,77 +0,0 @@
-import type { ExtendedChain } from '@lifi/types'
-import { ChainType } from '@lifi/types'
-import type { Address } from 'viem'
-import { config } from '../../config.js'
-import { getActionWithFallback } from './getActionWithFallback.js'
-import { getAllowance } from './getAllowance.js'
-import { getNativePermit } from './permits/getNativePermit.js'
-import { getPublicClient } from './publicClient.js'
-import type { EVMProvider } from './types.js'
-
-type PermitSupport = {
-  /** Whether the token supports EIP-2612 native permits */
-  nativePermitSupported: boolean
-  /** Whether Permit2 is available and has sufficient allowance */
-  permit2AllowanceSufficient: boolean
-}
-
-/**
- * Checks what permit types are supported for a token on a specific chain.
- * Checks in order:
- * 1. Native permit (EIP-2612) support
- * 2. Permit2 availability and allowance
- *
- * @param chain - The chain to check permit support on
- * @param tokenAddress - The token address to check
- * @param ownerAddress - The address that would sign the permit
- * @param amount - The amount to check allowance against for Permit2
- * @returns Object indicating which permit types are supported
- */
-export const checkPermitSupport = async ({
-  chain,
-  tokenAddress,
-  ownerAddress,
-  amount,
-}: {
-  chain: ExtendedChain
-  tokenAddress: Address
-  ownerAddress: Address
-  amount: bigint
-}): Promise<PermitSupport> => {
-  const provider = config.getProvider(ChainType.EVM) as EVMProvider | undefined
-
-  let client = await provider?.getWalletClient?.()
-
-  if (!client) {
-    client = await getPublicClient(chain.id)
-  }
-
-  const nativePermit = await getActionWithFallback(
-    client,
-    getNativePermit,
-    'getNativePermit',
-    {
-      chainId: chain.id,
-      tokenAddress,
-      spenderAddress: chain.permit2Proxy as Address,
-      amount,
-    }
-  )
-
-  let permit2Allowance: bigint | undefined
-  // Check Permit2 allowance if available on chain
-  if (chain.permit2) {
-    permit2Allowance = await getAllowance(
-      client,
-      tokenAddress,
-      ownerAddress,
-      chain.permit2 as Address
-    )
-  }
-
-  return {
-    nativePermitSupported: !!nativePermit,
-    permit2AllowanceSufficient:
-      !!permit2Allowance && permit2Allowance >= amount,
-  }
-}

package/src/core/EVM/getActionWithFallback.ts

@@ -1,58 +0,0 @@
-import type {
-  Account,
-  Chain,
-  Client,
-  PublicActions,
-  RpcSchema,
-  Transport,
-  WalletActions,
-} from 'viem'
-import { getAction } from 'viem/utils'
-import { getPublicClient } from './publicClient.js'
-
-/**
- * Executes an action with a fallback to public client if the wallet client fails due to rate limiting
- * or similar recoverable errors.
- *
- * Note: Only falls back to public client if the initial client was a wallet client (has an account address).
- * If the initial client was already a public client, no fallback will occur.
- *
- * @param walletClient - The wallet client to use primarily
- * @param action - The function or method to execute
- * @param actionName - The name of the action (used for error handling)
- * @param params - The parameters for the action
- * @returns The result of the action
- */
-export const getActionWithFallback = async <
-  transport extends Transport,
-  chain extends Chain | undefined,
-  account extends Account | undefined,
-  rpcSchema extends RpcSchema | undefined,
-  extended extends { [key: string]: unknown },
-  client extends Client<transport, chain, account, rpcSchema, extended>,
-  parameters,
-  returnType,
->(
-  walletClient: client,
-  actionFn: (_: client, parameters: parameters) => returnType,
-  name: keyof PublicActions | keyof WalletActions | (string & {}),
-  params: parameters
-): Promise<Awaited<returnType>> => {
-  try {
-    return await getAction(walletClient, actionFn, name)(params)
-  } catch (error: unknown) {
-    // Only fall back if this was a wallet client (has an account address)
-    // If it was already a public client, we don't want to fall back
-    if (!walletClient.account?.address) {
-      throw error
-    }
-
-    const chainId = walletClient.chain?.id
-    if (!chainId) {
-      throw error
-    }
-
-    const publicClient = await getPublicClient(chainId)
-    return await getAction(publicClient, actionFn, name)(params)
-  }
-}