@lifi/sdk 3.6.0-beta.2 → 3.6.0-beta.4

package/src/core/EVM/checkAllowance.ts

@@ -1,8 +1,8 @@
-import type { ExtendedChain, LiFiStep, Process, ProcessType } from '@lifi/types'
+import type { ExtendedChain, LiFiStep } 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 type { ExecutionOptions, Process, ProcessType } from '../types.js'
 import { getAllowance } from './getAllowance.js'
 import { parseEVMErrors } from './parseEVMErrors.js'
 import { setAllowance } from './setAllowance.js'

package/src/core/EVM/getNativePermit.ts

@@ -1,5 +1,14 @@
 import type { ExtendedChain } from '@lifi/types'
-import type { Address, Client } from 'viem'
+import {
+  encodeAbiParameters,
+  keccak256,
+  pad,
+  parseAbiParameters,
+  toBytes,
+  toHex,
+} from 'viem'
+import type { Address, Client, Hex } from 'viem'
+import type { TypedDataDomain } from 'viem'
 import { multicall, readContract } from 'viem/actions'
 import { eip2612Abi } from './abi.js'
 import { getMulticallAddress } from './utils.js'
@@ -9,6 +18,136 @@ export type NativePermitData = {
   version: string
   nonce: bigint
   supported: boolean
+  domain: TypedDataDomain
+}
+
+/**
+ * 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)'
+ * ))
+ */
+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)'
+ * ))
+ */
+const EIP712_DOMAIN_TYPEHASH_WITH_SALT =
+  '0x36c25de3e541d5d970f66e4210d728721220fff5c077cc6cd008b3a0c62adab7' as Hex
+
+function makeDomainSeparator({
+  name,
+  version,
+  chainId,
+  verifyingContract,
+  withSalt = false,
+}: {
+  name: string
+  version: string
+  chainId: bigint
+  verifyingContract: Address
+  withSalt?: boolean
+}): Hex {
+  const nameHash = keccak256(toBytes(name))
+  const versionHash = keccak256(toBytes(version))
+
+  const encoded = withSalt
+    ? encodeAbiParameters(
+        parseAbiParameters('bytes32, bytes32, bytes32, address, bytes32'),
+        [
+          EIP712_DOMAIN_TYPEHASH_WITH_SALT,
+          nameHash,
+          versionHash,
+          verifyingContract,
+          pad(toHex(chainId), { size: 32 }),
+        ]
+      )
+    : encodeAbiParameters(
+        parseAbiParameters('bytes32, bytes32, bytes32, uint256, address'),
+        [
+          EIP712_DOMAIN_TYPEHASH,
+          nameHash,
+          versionHash,
+          chainId,
+          verifyingContract,
+        ]
+      )
+
+  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,
+  chainId,
+  verifyingContract,
+  domainSeparator,
+}: {
+  name: string
+  version: string
+  chainId: bigint
+  verifyingContract: Address
+  domainSeparator: Hex
+}): { isValid: boolean; domain: TypedDataDomain } {
+  if (!name || !domainSeparator) {
+    return {
+      isValid: false,
+      domain: {},
+    }
+  }
+
+  for (const withSalt of [false, true]) {
+    const computedDS = makeDomainSeparator({
+      name,
+      version,
+      chainId,
+      verifyingContract,
+      withSalt,
+    })
+    if (domainSeparator.toLowerCase() === computedDS.toLowerCase()) {
+      return {
+        isValid: true,
+        domain: withSalt
+          ? {
+              name,
+              version,
+              verifyingContract,
+              salt: pad(toHex(chainId), { size: 32 }),
+            }
+          : {
+              name,
+              version,
+              chainId,
+              verifyingContract,
+            },
+      }
+    }
+  }
+
+  return {
+    isValid: false,
+    domain: {},
+  }
+}
+
+const defaultPermit: NativePermitData = {
+  name: '',
+  version: '1',
+  nonce: 0n,
+  supported: false,
+  domain: {},
 }
 
 /**
@@ -27,88 +166,102 @@ export const getNativePermit = async (
   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, {
+    const contractCalls = [
+      {
         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',
-      }),
-    ])
+      },
+    ] as const
+
+    if (multicallAddress) {
+      const [nameResult, domainSeparatorResult, noncesResult, versionResult] =
+        await multicall(client, {
+          contracts: contractCalls,
+          multicallAddress,
+        })
+
+      if (
+        nameResult.status !== 'success' ||
+        domainSeparatorResult.status !== 'success' ||
+        noncesResult.status !== 'success' ||
+        !nameResult.result ||
+        !domainSeparatorResult.result ||
+        noncesResult.result === undefined
+      ) {
+        return defaultPermit
+      }
+
+      const { isValid, domain } = validateDomainSeparator({
+        name: nameResult.result,
+        version: versionResult.result ?? '1',
+        chainId: BigInt(chain.id),
+        verifyingContract: tokenAddress,
+        domainSeparator: domainSeparatorResult.result,
+      })
+
+      return {
+        name: nameResult.result,
+        version: versionResult.result ?? '1',
+        nonce: noncesResult.result,
+        supported: isValid,
+        domain,
+      }
+    }
+
+    const [nameResult, domainSeparatorResult, noncesResult, versionResult] =
+      (await Promise.allSettled(
+        contractCalls.map((call) => readContract(client, call))
+      )) as [
+        PromiseSettledResult<string>,
+        PromiseSettledResult<Hex>,
+        PromiseSettledResult<bigint>,
+        PromiseSettledResult<string>,
+      ]
+
+    if (
+      nameResult.status !== 'fulfilled' ||
+      domainSeparatorResult.status !== 'fulfilled' ||
+      noncesResult.status !== 'fulfilled'
+    ) {
+      return defaultPermit
+    }
+
+    const name = nameResult.value
+    const version =
+      versionResult.status === 'fulfilled' ? versionResult.value : '1'
+    const { isValid, domain } = validateDomainSeparator({
+      name,
+      version,
+      chainId: BigInt(chain.id),
+      verifyingContract: tokenAddress,
+      domainSeparator: domainSeparatorResult.value,
+    })
 
     return {
       name,
-      version: version ?? '1',
-      nonce,
-      supported: !!name && !!domainSeparator && nonce !== undefined,
+      version,
+      nonce: noncesResult.value,
+      supported: isValid,
+      domain,
     }
   } catch {
-    return {
-      name: '',
-      version: '1',
-      nonce: 0n,
-      supported: false,
-    }
+    return defaultPermit
   }
 }

package/src/core/EVM/parseEVMErrors.ts

@@ -1,9 +1,10 @@
-import type { LiFiStep, Process } from '@lifi/types'
+import type { LiFiStep } from '@lifi/types'
 import { SDKError } from '../../errors/SDKError.js'
 import { BaseError } from '../../errors/baseError.js'
 import { ErrorMessage, LiFiErrorCode } from '../../errors/constants.js'
 import { TransactionError, UnknownError } from '../../errors/errors.js'
 import { fetchTxErrorDetails } from '../../utils/fetchTxErrorDetails.js'
+import type { Process } from '../types.js'
 
 export const parseEVMErrors = async (
   e: Error,
@@ -26,7 +27,10 @@ const handleSpecificErrors = async (
   step?: LiFiStep,
   process?: Process
 ) => {
-  if (e.cause?.name === 'UserRejectedRequestError') {
+  if (
+    e.name === 'UserRejectedRequestError' ||
+    e.cause?.name === 'UserRejectedRequestError'
+  ) {
     return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
   }
   // Safe Wallet via WalletConnect returns -32000 code when user rejects the signature

package/src/core/EVM/signPermitMessage.ts

@@ -28,13 +28,6 @@ export const signNativePermitMessage = async (
 ): Promise<PermitSignature> => {
   const deadline = BigInt(Math.floor(Date.now() / 1000) + 30 * 60) // 30 minutes
 
-  const domain = {
-    name: nativePermit.name,
-    version: nativePermit.version,
-    chainId: chain.id,
-    verifyingContract: tokenAddress,
-  }
-
   const message = {
     owner: client.account!.address,
     spender: chain.permit2Proxy as Address,
@@ -49,7 +42,7 @@ export const signNativePermitMessage = async (
     'signTypedData'
   )({
     account: client.account!,
-    domain,
+    domain: nativePermit.domain,
     types: eip2612Types,
     primaryType: 'Permit',
     message,

package/src/core/EVM/typeguards.ts

@@ -1,7 +1,7 @@
 import type { LiFiStepExtended } from '../types.js'
 import type { EVMPermitStep } from './types.js'
 
-export function isEVMPermitStep(step: LiFiStepExtended): step is EVMPermitStep {
+export function isRelayerStep(step: LiFiStepExtended): step is EVMPermitStep {
   const evmStep = step as EVMPermitStep
-  return 'permit' in evmStep || 'permitData' in evmStep || 'witness' in evmStep
+  return 'permit' in evmStep && 'permitData' in evmStep && 'witness' in evmStep
 }

package/src/core/Solana/SolanaStepExecutor.ts

@@ -217,24 +217,10 @@ export class SolanaStepExecutor extends BaseStepExecutor {
       }
     }
 
-    // Wait for the transaction status on the destination chain
-    const transactionHash = process.txHash
-    if (!transactionHash) {
-      throw new Error('Transaction hash is undefined.')
-    }
-    if (isBridgeExecution) {
-      process = this.statusManager.findOrCreateProcess({
-        step,
-        type: 'RECEIVING_CHAIN',
-        status: 'PENDING',
-        chainId: toChain.id,
-      })
-    }
-
     await waitForDestinationChainTransaction(
       step,
-      process.type,
-      transactionHash,
+      process,
+      fromChain,
       toChain,
       this.statusManager
     )

package/src/core/Solana/parseSolanaErrors.ts

@@ -1,8 +1,9 @@
-import type { LiFiStep, Process } from '@lifi/types'
+import type { LiFiStep } from '@lifi/types'
 import { SDKError } from '../../errors/SDKError.js'
 import { BaseError } from '../../errors/baseError.js'
 import { ErrorMessage, LiFiErrorCode } from '../../errors/constants.js'
 import { TransactionError, UnknownError } from '../../errors/errors.js'
+import type { Process } from '../types.js'
 
 export const parseSolanaErrors = async (
   e: Error,

package/src/core/StatusManager.ts

@@ -1,15 +1,14 @@
+import type { ChainId, LiFiStep } from '@lifi/types'
+import { executionState } from './executionState.js'
+import { getProcessMessage } from './processMessages.js'
 import type {
-  ChainId,
   Execution,
   ExecutionStatus,
-  LiFiStep,
+  LiFiStepExtended,
   Process,
   ProcessStatus,
   ProcessType,
-} from '@lifi/types'
-import { executionState } from './executionState.js'
-import { getProcessMessage } from './processMessages.js'
-import type { LiFiStepExtended } from './types.js'
+} from './types.js'
 
 export type FindOrCreateProcessProps = {
   step: LiFiStepExtended
@@ -80,17 +79,38 @@ export class StatusManager {
     return step
   }
 
+  /**
+   * Finds a process of the specified type in the step's execution
+   * @param step The step to search in
+   * @param type The process type to find
+   * @param status Optional status to update the process with if found
+   * @returns The found process or undefined if not found
+   */
+  findProcess(
+    step: LiFiStepExtended,
+    type: ProcessType,
+    status?: ProcessStatus
+  ): Process | undefined {
+    if (!step.execution?.process) {
+      throw new Error("Execution hasn't been initialized.")
+    }
+
+    const process = step.execution.process.find((p) => p.type === type)
+
+    if (process && status && process.status !== status) {
+      process.status = status
+      this.updateStepInRoute(step)
+    }
+
+    return process
+  }
+
   /**
    * Create and push a new process into the execution.
-   * @param step.step The step that should contain the new process.
-   * @param step.type Type of the process. Used to identify already existing processes.
-   * @param step.chainId Chain Id of the process.
-   * @param step.status By default created procces is set to the STARTED status. We can override new process with the needed status.
-   * @param root0
-   * @param root0.step
-   * @param root0.type
-   * @param root0.chainId
-   * @param root0.status
+   * @param step The step that should contain the new process.
+   * @param type Type of the process. Used to identify already existing processes.
+   * @param chainId Chain Id of the process.
+   * @param status By default created procces is set to the STARTED status. We can override new process with the needed status.
    * @returns Returns process.
    */
   findOrCreateProcess = ({
@@ -99,17 +119,9 @@ export class StatusManager {
     chainId,
     status,
   }: FindOrCreateProcessProps): Process => {
-    if (!step.execution?.process) {
-      throw new Error("Execution hasn't been initialized.")
-    }
-
-    const process = step.execution.process.find((p) => p.type === type)
+    const process = this.findProcess(step, type, status)
 
     if (process) {
-      if (status && process.status !== status) {
-        process.status = status
-        this.updateStepInRoute(step)
-      }
       return process
     }
 
@@ -121,7 +133,7 @@ export class StatusManager {
       chainId: chainId,
     }
 
-    step.execution.process.push(newProcess)
+    step.execution!.process.push(newProcess)
     this.updateStepInRoute(step)
     return newProcess
   }
@@ -143,7 +155,7 @@ export class StatusManager {
     if (!step.execution) {
       throw new Error("Can't update an empty step execution.")
     }
-    const currentProcess = step?.execution?.process.find((p) => p.type === type)
+    const currentProcess = this.findProcess(step, type)
 
     if (!currentProcess) {
       throw new Error("Can't find a process for the given type.")

package/src/core/UTXO/UTXOStepExecutor.ts

@@ -263,24 +263,10 @@ export class UTXOStepExecutor extends BaseStepExecutor {
       }
     }
 
-    // Wait for the transaction status on the destination chain
-    const transactionHash = process.txHash
-    if (!transactionHash) {
-      throw new Error('Transaction hash is undefined.')
-    }
-    if (isBridgeExecution) {
-      process = this.statusManager.findOrCreateProcess({
-        step,
-        type: 'RECEIVING_CHAIN',
-        status: 'PENDING',
-        chainId: toChain.id,
-      })
-    }
-
     await waitForDestinationChainTransaction(
       step,
-      process.type,
-      transactionHash,
+      process,
+      fromChain,
       toChain,
       this.statusManager,
       10_000

package/src/core/UTXO/getUTXOAPIPublicClient.ts

@@ -49,15 +49,15 @@ export const getUTXOAPIPublicClient = async (chainId: number) => {
           key: 'blockchair',
           includeChainToURL: true,
         }),
-        utxo('https://rpc.ankr.com/http/btc_blockbook/api/v2', {
-          key: 'ankr',
-        }),
         utxo('https://api.blockcypher.com/v1/btc/main', {
           key: 'blockcypher',
         }),
         utxo('https://mempool.space/api', {
           key: 'mempool',
         }),
+        utxo('https://rpc.ankr.com/http/btc_blockbook/api/v2', {
+          key: 'ankr',
+        }),
       ]),
     }).extend(UTXOAPIActions)
     publicAPIClients[chainId] = client

package/src/core/UTXO/parseUTXOErrors.ts

@@ -1,8 +1,9 @@
-import type { LiFiStep, Process } from '@lifi/types'
+import type { LiFiStep } from '@lifi/types'
 import { SDKError } from '../../errors/SDKError.js'
 import { BaseError } from '../../errors/baseError.js'
 import { ErrorMessage, LiFiErrorCode } from '../../errors/constants.js'
 import { TransactionError, UnknownError } from '../../errors/errors.js'
+import type { Process } from '../types.js'
 
 export const parseUTXOErrors = async (
   e: Error,

package/src/core/processMessages.ts

@@ -1,38 +1,42 @@
-import type {
-  ProcessStatus,
-  ProcessType,
-  StatusMessage,
-  Substatus,
-} from '@lifi/types'
+import type { StatusMessage, Substatus } from '@lifi/types'
+import type { ProcessStatus } from './types.js'
+import type { ProcessType } from './types.js'
 
 const processMessages: Record<
   ProcessType,
   Partial<Record<ProcessStatus, string>>
 > = {
   TOKEN_ALLOWANCE: {
-    STARTED: 'Setting token allowance.',
-    PENDING: 'Waiting for token allowance.',
-    DONE: 'Token allowance set.',
+    STARTED: 'Setting token allowance',
+    PENDING: 'Waiting for token allowance',
+    DONE: 'Token allowance set',
   },
   SWITCH_CHAIN: {
-    PENDING: 'Chain switch required.',
-    DONE: 'Chain switched successfully.',
+    ACTION_REQUIRED: 'Chain switch required',
+    PENDING: 'Waiting for chain switch',
+    DONE: 'Chain switched',
   },
   SWAP: {
-    STARTED: 'Preparing swap transaction.',
-    ACTION_REQUIRED: 'Please sign the transaction.',
-    PENDING: 'Waiting for swap transaction.',
-    DONE: 'Swap completed.',
+    STARTED: 'Preparing swap transaction',
+    ACTION_REQUIRED: 'Please sign the transaction',
+    PENDING: 'Waiting for swap transaction',
+    DONE: 'Swap completed',
   },
   CROSS_CHAIN: {
-    STARTED: 'Preparing bridge transaction.',
-    ACTION_REQUIRED: 'Please sign the transaction.',
-    PENDING: 'Waiting for bridge transaction.',
-    DONE: 'Bridge transaction confirmed.',
+    STARTED: 'Preparing bridge transaction',
+    ACTION_REQUIRED: 'Please sign the transaction',
+    PENDING: 'Waiting for bridge transaction',
+    DONE: 'Bridge transaction confirmed',
   },
   RECEIVING_CHAIN: {
-    PENDING: 'Waiting for destination chain.',
-    DONE: 'Bridge completed.',
+    PENDING: 'Waiting for destination chain',
+    DONE: 'Bridge completed',
+  },
+  PERMIT: {
+    STARTED: 'Preparing transaction',
+    ACTION_REQUIRED: 'Sign permit message',
+    PENDING: 'Waiting for permit message',
+    DONE: 'Permit message signed',
   },
   TRANSACTION: {},
 }