@lifi/sdk 3.4.2 → 3.5.0-beta.0

package/src/core/EVM/checkAllowance.ts

@@ -1,5 +1,6 @@
-import type { Chain, LiFiStep, Process, ProcessType } from '@lifi/types'
+import type { ExtendedChain, LiFiStep, Process, ProcessType } from '@lifi/types'
 import type { Address, Client, Hash } from 'viem'
+import { MaxUint256 } from '../../constants.js'
 import type { StatusManager } from '../StatusManager.js'
 import type { ExecutionOptions } from '../types.js'
 import { getAllowance } from './getAllowance.js'
@@ -7,108 +8,107 @@ import { parseEVMErrors } from './parseEVMErrors.js'
 import { setAllowance } from './setAllowance.js'
 import { waitForTransactionReceipt } from './waitForTransactionReceipt.js'
 
-export const checkAllowance = async (
-  client: Client,
-  chain: Chain,
-  step: LiFiStep,
-  statusManager: StatusManager,
-  settings?: ExecutionOptions,
+export type CheckAllowanceParams = {
+  client: Client
+  chain: ExtendedChain
+  step: LiFiStep
+  statusManager: StatusManager
+  executionOptions?: ExecutionOptions
+  allowUserInteraction?: boolean
+  atomicBatchSupported?: boolean
+  permit2Supported?: boolean
+}
+
+export const checkAllowance = async ({
+  client,
+  chain,
+  step,
+  statusManager,
+  executionOptions,
   allowUserInteraction = false,
-  shouldBatchTransactions = false
-): Promise<Hash | void> => {
-  // Ask the user to set an allowance
-  let allowanceProcess: Process = statusManager.findOrCreateProcess({
+  atomicBatchSupported = false,
+  permit2Supported = false,
+}: CheckAllowanceParams): Promise<Hash | void> => {
+  // Find existing or create new allowance process
+  const allowanceProcess: Process = statusManager.findOrCreateProcess({
     step,
     type: 'TOKEN_ALLOWANCE',
     chainId: step.action.fromChainId,
   })
 
-  // Check allowance
   try {
+    // Handle existing pending transaction
     if (allowanceProcess.txHash && allowanceProcess.status !== 'DONE') {
       await waitForApprovalTransaction(
         client,
-        allowanceProcess.txHash! as Address,
+        allowanceProcess.txHash as Address,
         allowanceProcess.type,
         step,
         chain,
         statusManager
       )
-    } else {
-      allowanceProcess = statusManager.updateProcess(
-        step,
-        allowanceProcess.type,
-        'STARTED'
-      )
+      return
+    }
 
-      const approved = await getAllowance(
-        chain.id,
-        step.action.fromToken.address,
-        client.account!.address,
-        step.estimate.approvalAddress
-      )
+    // Start new allowance check
+    statusManager.updateProcess(step, allowanceProcess.type, 'STARTED')
 
-      const fromAmount = BigInt(step.action.fromAmount)
-
-      if (fromAmount > approved) {
-        if (!allowUserInteraction) {
-          return
-        }
-
-        if (shouldBatchTransactions) {
-          const approveTxHash = await setAllowance(
-            client,
-            step.action.fromToken.address,
-            step.estimate.approvalAddress,
-            fromAmount,
-            settings,
-            true
-          )
-
-          allowanceProcess = statusManager.updateProcess(
-            step,
-            allowanceProcess.type,
-            'DONE'
-          )
-
-          return approveTxHash
-        }
-
-        const approveTxHash = await setAllowance(
-          client,
-          step.action.fromToken.address,
-          step.estimate.approvalAddress,
-          fromAmount
-        )
-        await waitForApprovalTransaction(
-          client,
-          approveTxHash,
-          allowanceProcess.type,
-          step,
-          chain,
-          statusManager
-        )
-      } else {
-        allowanceProcess = statusManager.updateProcess(
-          step,
-          allowanceProcess.type,
-          'DONE'
-        )
-      }
+    const spenderAddress = permit2Supported
+      ? chain.permit2
+      : step.estimate.approvalAddress
+    const fromAmount = BigInt(step.action.fromAmount)
+
+    const approved = await getAllowance(
+      chain.id,
+      step.action.fromToken.address as Address,
+      client.account!.address,
+      spenderAddress as Address
+    )
+
+    // Return early if already approved
+    if (fromAmount <= approved) {
+      statusManager.updateProcess(step, allowanceProcess.type, 'DONE')
+      return
     }
-  } catch (e: any) {
-    const error = await parseEVMErrors(e, step, allowanceProcess)
-    allowanceProcess = statusManager.updateProcess(
-      step,
+
+    if (!allowUserInteraction) {
+      return
+    }
+
+    statusManager.updateProcess(step, allowanceProcess.type, 'ACTION_REQUIRED')
+
+    // Set new allowance
+    const approveAmount = permit2Supported ? MaxUint256 : fromAmount
+    const approveTxHash = await setAllowance(
+      client,
+      step.action.fromToken.address as Address,
+      spenderAddress as Address,
+      approveAmount,
+      executionOptions,
+      atomicBatchSupported
+    )
+
+    if (atomicBatchSupported) {
+      statusManager.updateProcess(step, allowanceProcess.type, 'DONE')
+      return approveTxHash
+    }
+
+    await waitForApprovalTransaction(
+      client,
+      approveTxHash,
       allowanceProcess.type,
-      'FAILED',
-      {
-        error: {
-          message: error.cause.message,
-          code: error.code,
-        },
-      }
+      step,
+      chain,
+      statusManager
     )
+  } catch (e: any) {
+    const error = await parseEVMErrors(e, step, allowanceProcess)
+    statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
+      error: {
+        message: error.cause.message,
+        code: error.code,
+      },
+    })
     statusManager.updateExecution(step, 'FAILED')
     throw error
   }
@@ -119,29 +119,33 @@ const waitForApprovalTransaction = async (
   txHash: Hash,
   processType: ProcessType,
   step: LiFiStep,
-  chain: Chain,
+  chain: ExtendedChain,
   statusManager: StatusManager
 ) => {
+  const baseExplorerUrl = chain.metamask.blockExplorerUrls[0]
+  const getTxLink = (hash: Hash) => `${baseExplorerUrl}tx/${hash}`
+
   statusManager.updateProcess(step, processType, 'PENDING', {
     txHash,
-    txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+    txLink: getTxLink(txHash),
   })
 
   const transactionReceipt = await waitForTransactionReceipt({
-    client: client,
+    client,
     chainId: chain.id,
-    txHash: txHash,
+    txHash,
     onReplaced(response) {
+      const newHash = response.transaction.hash
       statusManager.updateProcess(step, processType, 'PENDING', {
-        txHash: response.transaction.hash,
-        txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+        txHash: newHash,
+        txLink: getTxLink(newHash),
       })
     },
   })
 
-  const transactionHash = transactionReceipt?.transactionHash || txHash
+  const finalHash = transactionReceipt?.transactionHash || txHash
   statusManager.updateProcess(step, processType, 'DONE', {
-    txHash: transactionHash,
-    txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${transactionHash}`,
+    txHash: finalHash,
+    txLink: getTxLink(finalHash),
   })
 }

package/src/core/EVM/getAllowance.ts

@@ -13,9 +13,9 @@ import { getMulticallAddress } from './utils.js'
 
 export const getAllowance = async (
   chainId: ChainId,
-  tokenAddress: string,
-  ownerAddress: string,
-  spenderAddress: string
+  tokenAddress: Address,
+  ownerAddress: Address,
+  spenderAddress: Address
 ): Promise<bigint> => {
   const client = await getPublicClient(chainId)
   try {
@@ -34,7 +34,7 @@ export const getAllowance = async (
 export const getAllowanceMulticall = async (
   chainId: ChainId,
   tokens: TokenSpender[],
-  ownerAddress: string
+  ownerAddress: Address
 ): Promise<TokenSpenderAllowance[]> => {
   if (!tokens.length) {
     return []
@@ -80,8 +80,8 @@ export const getAllowanceMulticall = async (
  */
 export const getTokenAllowance = async (
   token: BaseToken,
-  ownerAddress: string,
-  spenderAddress: string
+  ownerAddress: Address,
+  spenderAddress: Address
 ): Promise<bigint | undefined> => {
   // native token don't need approval
   if (isNativeTokenAddress(token.address)) {
@@ -90,7 +90,7 @@ export const getTokenAllowance = async (
 
   const approved = await getAllowance(
     token.chainId,
-    token.address,
+    token.address as Address,
     ownerAddress,
     spenderAddress
   )
@@ -104,7 +104,7 @@ export const getTokenAllowance = async (
  * @returns Returns array of tokens and their allowance
  */
 export const getTokenAllowanceMulticall = async (
-  ownerAddress: string,
+  ownerAddress: Address,
   tokens: TokenSpender[]
 ): Promise<TokenAllowance[]> => {
   // filter out native tokens

package/src/core/EVM/getEVMBalance.ts

@@ -12,7 +12,7 @@ import { getPublicClient } from './publicClient.js'
 import { getMulticallAddress } from './utils.js'
 
 export const getEVMBalance = async (
-  walletAddress: string,
+  walletAddress: Address,
   tokens: Token[]
 ): Promise<TokenAmount[]> => {
   if (tokens.length === 0) {
@@ -85,7 +85,7 @@ const getEVMBalanceMulticall = async (
 const getEVMBalanceDefault = async (
   chainId: ChainId,
   tokens: Token[],
-  walletAddress: string
+  walletAddress: Address
 ): Promise<TokenAmount[]> => {
   const client = await getPublicClient(chainId)
   const blockNumber = await getBlockNumber(client)

package/src/core/EVM/getNativePermit.ts

@@ -0,0 +1,113 @@
+import type { ExtendedChain } from '@lifi/types'
+import type { Address, Client } from 'viem'
+import { multicall, readContract } from 'viem/actions'
+import { eip2612Abi } from './abi.js'
+import { getMulticallAddress } from './utils.js'
+
+export type NativePermitData = {
+  name: string
+  version: string
+  nonce: bigint
+  supported: boolean
+}
+/**
+ * Retrieves native permit data (EIP-2612) for a token on a specific chain
+ * @link https://eips.ethereum.org/EIPS/eip-2612
+ * @param client - The Viem client instance
+ * @param chain - The extended chain object containing chain details
+ * @param tokenAddress - The address of the token to check for permit support
+ * @returns {Promise<NativePermitData>} Object containing permit data including name, version, nonce and support status
+ */
+export const getNativePermit = async (
+  client: Client,
+  chain: ExtendedChain,
+  tokenAddress: Address
+): Promise<NativePermitData> => {
+  try {
+    const multicallAddress = await getMulticallAddress(chain.id)
+
+    if (multicallAddress) {
+      const [nameResult, domainSeparatorResult, noncesResult, versionResult] =
+        await multicall(client, {
+          contracts: [
+            {
+              address: tokenAddress,
+              abi: eip2612Abi,
+              functionName: 'name',
+            },
+            {
+              address: tokenAddress,
+              abi: eip2612Abi,
+              functionName: 'DOMAIN_SEPARATOR',
+            },
+            {
+              address: tokenAddress,
+              abi: eip2612Abi,
+              functionName: 'nonces',
+              args: [client.account!.address],
+            },
+            {
+              address: tokenAddress,
+              abi: eip2612Abi,
+              functionName: 'version',
+            },
+          ],
+          multicallAddress,
+        })
+
+      const supported =
+        nameResult.status === 'success' &&
+        domainSeparatorResult.status === 'success' &&
+        noncesResult.status === 'success' &&
+        !!nameResult.result &&
+        !!domainSeparatorResult.result &&
+        noncesResult.result !== undefined
+
+      return {
+        name: nameResult.result!,
+        version: versionResult.result ?? '1',
+        nonce: noncesResult.result!,
+        supported,
+      }
+    }
+
+    // Fallback to individual calls
+    const [name, domainSeparator, nonce, version] = await Promise.all([
+      readContract(client, {
+        address: tokenAddress,
+        abi: eip2612Abi,
+        functionName: 'name',
+      }),
+      readContract(client, {
+        address: tokenAddress,
+        abi: eip2612Abi,
+        functionName: 'DOMAIN_SEPARATOR',
+      }),
+      readContract(client, {
+        address: tokenAddress,
+        abi: eip2612Abi,
+        functionName: 'nonces',
+        args: [client.account!.address],
+      }),
+      readContract(client, {
+        address: tokenAddress,
+        abi: eip2612Abi,
+        functionName: 'version',
+      }),
+    ])
+
+    return {
+      name,
+      version: version ?? '1',
+      nonce,
+      supported: !!name && !!domainSeparator && nonce !== undefined,
+    }
+  } catch {
+    return {
+      name: '',
+      version: '1',
+      nonce: 0n,
+      supported: false,
+    }
+  }
+}

package/src/core/EVM/parseEVMErrors.ts

@@ -29,6 +29,14 @@ const handleSpecificErrors = async (
   if (e.cause?.name === 'UserRejectedRequestError') {
     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) {
+    return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
+  }
 
   if (
     step &&

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

@@ -0,0 +1,168 @@
+import {
+  type Address,
+  type TypedData,
+  type TypedDataDomain,
+  hashTypedData,
+} 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
+  values: PermitSingle
+}
+
+export type PermitBatchData = {
+  domain: TypedDataDomain
+  types: TypedData
+  values: 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,
+    values: 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,
+    values: 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,
+      values: permit,
+    }
+  }
+  permit.details.forEach(validatePermitDetails)
+  return {
+    domain,
+    types: PERMIT_BATCH_TYPES,
+    values: permit,
+  }
+}
+
+export function hash(
+  permit: PermitSingle | PermitBatch,
+  permit2Address: Address,
+  chainId: number
+): string {
+  if (isPermit(permit)) {
+    const { domain, values } = getPermitSingleData(
+      permit,
+      permit2Address,
+      chainId
+    )
+
+    return hashTypedData({
+      domain,
+      types: PERMIT_TYPES,
+      primaryType: 'PermitSingle',
+      message: values,
+    })
+  }
+  const { domain, values } = getPermitBatchData(permit, permit2Address, chainId)
+
+  return hashTypedData({
+    domain,
+    types: PERMIT_BATCH_TYPES,
+    primaryType: 'PermitBatch',
+    message: values,
+  })
+}
+
+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/permit2/constants.ts

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

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

@@ -0,0 +1,20 @@
+import type { Address, TypedData, TypedDataDomain } from 'viem'
+
+const PERMIT2_DOMAIN_NAME = 'Permit2'
+
+export function permit2Domain(
+  permit2Address: Address,
+  chainId: number
+): TypedDataDomain {
+  return {
+    name: PERMIT2_DOMAIN_NAME,
+    chainId,
+    verifyingContract: permit2Address,
+  }
+}
+
+export type PermitData = {
+  domain: TypedDataDomain
+  types: TypedData
+  values: any
+}