@lifi/sdk 3.10.1 → 3.11.0

package/src/core/EVM/checkAllowance.ts

@@ -4,19 +4,28 @@ import { signTypedData } from 'viem/actions'
 import { getAction } from 'viem/utils'
 import { MaxUint256 } from '../../constants.js'
 import type { StatusManager } from '../StatusManager.js'
-import type { ExecutionOptions, Process, ProcessType } from '../types.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 { isRelayerStep } from './typeguards.js'
 import type { Call } from './types.js'
 import { waitForTransactionReceipt } from './waitForTransactionReceipt.js'
 
 export type CheckAllowanceParams = {
-  client: Client
+  checkClient(
+    step: LiFiStepExtended,
+    process: Process,
+    targetChainId?: number
+  ): Promise<Client | undefined>
   chain: ExtendedChain
   step: LiFiStep
   statusManager: StatusManager
@@ -29,19 +38,19 @@ export type CheckAllowanceParams = {
 
 export type AllowanceResult =
   | {
-      status: 'ACTION_REQUIRED' | 'DONE'
+      status: 'ACTION_REQUIRED'
     }
   | {
       status: 'BATCH_APPROVAL'
-      data: Call
+      data: { call: Call; signedTypedData: SignedTypedData[] }
     }
   | {
-      status: 'NATIVE_PERMIT'
-      data: SignedTypedData
+      status: 'NATIVE_PERMIT' | 'DONE'
+      data: SignedTypedData[]
     }
 
 export const checkAllowance = async ({
-  client,
+  checkClient,
   chain,
   step,
   statusManager,
@@ -51,29 +60,123 @@ export const checkAllowance = async ({
   permit2Supported = false,
   disableMessageSigning = false,
 }: CheckAllowanceParams): Promise<AllowanceResult> => {
-  // Find existing or create new allowance process
-  const allowanceProcess: Process = statusManager.findOrCreateProcess({
-    step,
-    type: 'TOKEN_ALLOWANCE',
-    chainId: step.action.fromChainId,
-  })
-
+  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) {
+        const permitChainId = typedData.domain.chainId as number
+
+        // Check if we already have a valid permit for this chain and requirements
+        const signedTypedDataForChain = signedTypedData.find(
+          (signedTypedData) => signedTypedData.domain.chainId === permitChainId
+        )
+        const existingValidPermit =
+          signedTypedDataForChain &&
+          isNativePermitValid(signedTypedDataForChain, typedData)
+
+        if (existingValidPermit) {
+          // Skip signing if we already have a valid permit
+          continue
+        }
+
+        sharedProcess = statusManager.updateProcess(
+          step,
+          sharedProcess.type,
+          'ACTION_REQUIRED'
+        )
+        if (!allowUserInteraction) {
+          return { status: 'ACTION_REQUIRED' }
+        }
+
+        // Switch to the permit's chain if needed
+        const permitClient = await checkClient(
+          step,
+          sharedProcess,
+          permitChainId
+        )
+        if (!permitClient) {
+          return { status: 'ACTION_REQUIRED' }
+        }
+
+        const signature = await getAction(
+          permitClient,
+          signTypedData,
+          'signTypedData'
+        )({
+          account: permitClient.account!,
+          domain: typedData.domain,
+          types: typedData.types,
+          primaryType: 'Permit',
+          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) => signedTypedData.domain.chainId === chain.id
+      )
+      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 (allowanceProcess.txHash && allowanceProcess.status !== 'DONE') {
+    if (sharedProcess.txHash && sharedProcess.status !== 'DONE') {
       await waitForApprovalTransaction(
-        client,
-        allowanceProcess.txHash as Address,
-        allowanceProcess.type,
+        updatedClient,
+        sharedProcess.txHash as Address,
+        sharedProcess.type,
         step,
         chain,
         statusManager
       )
-      return { status: 'DONE' }
+      return { status: 'DONE', data: signedTypedData }
     }
 
     // Start new allowance check
-    statusManager.updateProcess(step, allowanceProcess.type, 'STARTED')
+    statusManager.updateProcess(step, sharedProcess.type, 'STARTED')
 
     const spenderAddress = permit2Supported
       ? chain.permit2
@@ -82,32 +185,26 @@ export const checkAllowance = async ({
     const fromAmount = BigInt(step.action.fromAmount)
 
     const approved = await getAllowance(
-      client,
+      updatedClient,
       step.action.fromToken.address as Address,
-      client.account!.address,
+      updatedClient.account!.address,
       spenderAddress as Address
     )
 
     // Return early if already approved
     if (fromAmount <= approved) {
-      statusManager.updateProcess(step, allowanceProcess.type, 'DONE')
-      return { status: 'DONE' }
+      statusManager.updateProcess(step, sharedProcess.type, 'DONE')
+      return { status: 'DONE', data: signedTypedData }
     }
 
-    const isRelayerTransaction = isRelayerStep(step)
-
     // 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 (isRelayerTransaction) {
-      nativePermitData = step.typedData.find(
-        (p) => p.primaryType === 'Permit'
-      ) as NativePermitData
-    } else if (isNativePermitAvailable) {
+    if (isNativePermitAvailable) {
       nativePermitData = await getActionWithFallback(
-        client,
+        updatedClient,
         getNativePermit,
         'getNativePermit',
         {
@@ -119,70 +216,116 @@ export const checkAllowance = async ({
       )
     }
 
-    statusManager.updateProcess(step, allowanceProcess.type, 'ACTION_REQUIRED')
+    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) =>
+          signedTypedData.domain.chainId === nativePermitData.domain.chainId
+      )
+      const existingValidPermit =
+        signedTypedDataForChain &&
+        isNativePermitValid(signedTypedDataForChain, nativePermitData)
 
-    if (!allowUserInteraction) {
-      return { status: 'ACTION_REQUIRED' }
-    }
+      if (!existingValidPermit) {
+        statusManager.updateProcess(step, sharedProcess.type, 'ACTION_REQUIRED')
 
-    if (isNativePermitAvailable && nativePermitData) {
-      const signature = await getAction(
-        client,
-        signTypedData,
-        'signTypedData'
-      )({
-        account: client.account!,
-        domain: nativePermitData.domain,
-        types: nativePermitData.types,
-        primaryType: 'Permit',
-        message: nativePermitData.message,
+        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: 'Permit',
+          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,
       })
-      statusManager.updateProcess(step, allowanceProcess.type, 'DONE')
       return {
         status: 'NATIVE_PERMIT',
-        data: {
-          ...nativePermitData,
-          signature,
-        },
+        data: signedTypedData,
       }
     }
 
+    // Clear the txHash and txLink from potential previous approval transaction
+    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(
-      client,
+      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, allowanceProcess.type, 'DONE')
+      statusManager.updateProcess(step, sharedProcess.type, 'DONE')
       return {
         status: 'BATCH_APPROVAL',
         data: {
-          to: step.action.fromToken.address as Address,
-          data: approveTxHash,
-          chainId: step.action.fromToken.chainId,
+          call: {
+            to: step.action.fromToken.address as Address,
+            data: approveTxHash,
+            chainId: step.action.fromToken.chainId,
+          },
+          signedTypedData,
         },
       }
     }
 
     await waitForApprovalTransaction(
-      client,
+      updatedClient,
       approveTxHash,
-      allowanceProcess.type,
+      sharedProcess.type,
       step,
       chain,
       statusManager
     )
 
-    return { status: 'DONE' }
+    return { status: 'DONE', data: signedTypedData }
   } catch (e: any) {
-    const error = await parseEVMErrors(e, step, allowanceProcess)
-    statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
+    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,

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

@@ -6,6 +6,7 @@ import {
   parseAbiParameters,
   toBytes,
   toHex,
+  zeroHash,
 } from 'viem'
 import { multicall, readContract } from 'viem/actions'
 import { eip2612Abi } from '../abi.js'
@@ -67,10 +68,6 @@ function makeDomainSeparator({
   return keccak256(encoded)
 }
 
-// TODO: Add support for EIP-5267 when adoption increases
-// This EIP provides a standard way to query domain separator and permit type hash
-// via eip712Domain() function, which would simplify permit validation
-// https://eips.ethereum.org/EIPS/eip-5267
 function validateDomainSeparator({
   name,
   version,
@@ -125,12 +122,168 @@ function validateDomainSeparator({
   }
 }
 
+/**
+ * Attempts to retrieve contract data using EIP-5267 eip712Domain() function
+ * @link https://eips.ethereum.org/EIPS/eip-5267
+ * @param client - The Viem client instance
+ * @param chainId - The chain ID
+ * @param tokenAddress - The token contract address
+ * @returns Contract data if EIP-5267 is supported, undefined otherwise
+ */
+const getEIP712DomainData = async (
+  client: Client,
+  chainId: number,
+  tokenAddress: Address
+) => {
+  try {
+    const multicallAddress = await getMulticallAddress(chainId)
+
+    const contractCalls = [
+      {
+        address: tokenAddress,
+        abi: eip2612Abi,
+        functionName: 'eip712Domain',
+      },
+      {
+        address: tokenAddress,
+        abi: eip2612Abi,
+        functionName: 'nonces',
+        args: [client.account!.address],
+      },
+    ] as const
+
+    if (multicallAddress) {
+      try {
+        const [eip712DomainResult, noncesResult] = await getActionWithFallback(
+          client,
+          multicall,
+          'multicall',
+          {
+            contracts: contractCalls,
+            multicallAddress,
+          }
+        )
+
+        if (
+          eip712DomainResult.status !== 'success' ||
+          noncesResult.status !== 'success' ||
+          !eip712DomainResult.result ||
+          noncesResult.result === undefined
+        ) {
+          // Fall back to individual calls if multicall fails
+          throw new Error('EIP-5267 multicall failed')
+        }
+
+        const [, name, version, tokenChainId, verifyingContract, salt] =
+          eip712DomainResult.result
+
+        if (
+          Number(tokenChainId) !== chainId ||
+          verifyingContract.toLowerCase() !== tokenAddress.toLowerCase()
+        ) {
+          return undefined
+        }
+
+        // Build domain object directly from EIP-5267 data
+        // Use the actual salt value returned by EIP-5267 - this is the canonical salt that the contract uses
+        const hasSalt = salt !== zeroHash
+        const domain = hasSalt
+          ? {
+              name,
+              version,
+              verifyingContract: tokenAddress,
+              salt,
+            }
+          : {
+              name,
+              version,
+              chainId,
+              verifyingContract: tokenAddress,
+            }
+
+        return {
+          name,
+          version,
+          domain,
+          permitTypehash: undefined, // EIP-5267 doesn't provide permit typehash directly
+          nonce: noncesResult.result,
+        }
+      } catch {
+        // Fall through to individual calls
+      }
+    }
+
+    // Fallback to individual contract calls
+    const [eip712DomainResult, noncesResult] = (await Promise.allSettled(
+      contractCalls.map((call) =>
+        getActionWithFallback(client, readContract, 'readContract', call)
+      )
+    )) as [
+      PromiseSettledResult<
+        [Hex, string, string, bigint, Address, Hex, bigint[]]
+      >,
+      PromiseSettledResult<bigint>,
+    ]
+
+    if (
+      eip712DomainResult.status !== 'fulfilled' ||
+      noncesResult.status !== 'fulfilled'
+    ) {
+      return undefined
+    }
+
+    const [, name, version, tokenChainId, verifyingContract, salt] =
+      eip712DomainResult.value
+
+    if (
+      Number(tokenChainId) !== chainId ||
+      verifyingContract.toLowerCase() !== tokenAddress.toLowerCase()
+    ) {
+      return undefined
+    }
+
+    // Build domain object directly from EIP-5267 data
+    // Use the actual salt value returned by EIP-5267 - this is the canonical salt that the contract uses
+    const hasSalt = salt !== zeroHash
+    const domain = hasSalt
+      ? {
+          name,
+          version,
+          verifyingContract: tokenAddress,
+          salt,
+        }
+      : {
+          name,
+          version,
+          chainId,
+          verifyingContract: tokenAddress,
+        }
+
+    return {
+      name,
+      version,
+      domain,
+      permitTypehash: undefined, // EIP-5267 doesn't provide permit typehash directly
+      nonce: noncesResult.value,
+    }
+  } catch {
+    return undefined
+  }
+}
+
 export const getContractData = async (
   client: Client,
   chainId: number,
   tokenAddress: Address
 ) => {
   try {
+    // First try EIP-5267 approach - returns domain object directly
+    const eip5267Data = await getEIP712DomainData(client, chainId, tokenAddress)
+    if (eip5267Data) {
+      return eip5267Data
+    }
+
+    // Fallback to legacy approach - validates and returns domain object
     const multicallAddress = await getMulticallAddress(chainId)
 
     const contractCalls = [
@@ -187,9 +340,22 @@ export const getContractData = async (
           throw new Error('Multicall failed')
         }
 
-        return {
+        // Validate domain separator and create domain object
+        const { isValid, domain } = validateDomainSeparator({
           name: nameResult.result,
+          version: versionResult.result ?? '1',
+          chainId,
+          verifyingContract: tokenAddress,
           domainSeparator: domainSeparatorResult.result,
+        })
+
+        if (!isValid) {
+          return undefined
+        }
+
+        return {
+          name: nameResult.result,
+          domain,
           permitTypehash: permitTypehashResult.result,
           nonce: noncesResult.result,
           version: versionResult.result ?? '1',
@@ -229,9 +395,22 @@ export const getContractData = async (
     const version =
       versionResult.status === 'fulfilled' ? versionResult.value : '1'
 
-    return {
+    // Validate domain separator and create domain object
+    const { isValid, domain } = validateDomainSeparator({
       name,
+      version,
+      chainId,
+      verifyingContract: tokenAddress,
       domainSeparator: domainSeparatorResult.value,
+    })
+
+    if (!isValid) {
+      return undefined
+    }
+
+    return {
+      name,
+      domain,
       permitTypehash:
         permitTypehashResult.status === 'fulfilled'
           ? permitTypehashResult.value
@@ -260,22 +439,10 @@ export const getNativePermit = async (
   if (!contractData) {
     return undefined
   }
-  const { name, domainSeparator, permitTypehash, nonce, version } = contractData
 
   // We don't support DAI-like permits yet (e.g. DAI on Ethereum)
-  if (permitTypehash === DAI_LIKE_PERMIT_TYPEHASH) {
-    return undefined
-  }
-
-  const { isValid, domain } = validateDomainSeparator({
-    name,
-    version,
-    chainId,
-    verifyingContract: tokenAddress,
-    domainSeparator,
-  })
-
-  if (!isValid) {
+  // https://eips.ethereum.org/EIPS/eip-2612#backwards-compatibility
+  if (contractData.permitTypehash === DAI_LIKE_PERMIT_TYPEHASH) {
     return undefined
   }
 
@@ -285,13 +452,13 @@ export const getNativePermit = async (
     owner: client.account!.address,
     spender: spenderAddress,
     value: amount.toString(),
-    nonce: nonce.toString(),
+    nonce: contractData.nonce.toString(),
     deadline,
   }
 
   return {
     primaryType: 'Permit',
-    domain,
+    domain: contractData.domain,
     types: eip2612Types,
     message,
   }