@lifi/sdk 3.10.1 → 3.11.0

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

@@ -0,0 +1,57 @@
+import type { SignedTypedData, TypedData } from '@lifi/types'
+
+/**
+ * Checks if an existing native permit is valid for the given requirements
+ */
+export const isNativePermitValid = (
+  permit: SignedTypedData,
+  typedData: TypedData
+): boolean => {
+  // Only check native permits (EIP-2612)
+  if (permit.primaryType !== 'Permit') {
+    return false
+  }
+
+  // Check if the permit is for the correct chain
+  if (
+    permit.domain.chainId !== typedData.domain.chainId ||
+    (permit.domain.salt && permit.domain.salt !== typedData.domain.salt)
+  ) {
+    return false
+  }
+
+  // Check if the permit message has the required fields
+  const message = permit.message as any
+  if (!message) {
+    return false
+  }
+
+  // Check spender
+  if (
+    message.spender?.toLowerCase() !== typedData.message.spender?.toLowerCase()
+  ) {
+    return false
+  }
+
+  // Check owner
+  if (message.owner?.toLowerCase() !== typedData.message.owner?.toLowerCase()) {
+    return false
+  }
+
+  // Check amount (value field in native permits)
+  const permitAmount = BigInt(message.value || 0)
+  if (permitAmount < BigInt(typedData.message.value || 0)) {
+    return false
+  }
+
+  // Check deadline (must have at least 5 minutes remaining)
+  const deadlineTimestamp = parseInt(message.deadline || 0, 10)
+  // Add 5 minutes bufferto the current timestamp
+  const allowedTimestamp = Math.floor(Date.now() / 1000) + 5 * 60
+
+  if (deadlineTimestamp <= allowedTimestamp) {
+    return false
+  }
+
+  return true
+}

package/src/core/EVM/switchChain.ts

@@ -4,7 +4,7 @@ import { getAction } from 'viem/utils'
 import { LiFiErrorCode } from '../../errors/constants.js'
 import { ProviderError } from '../../errors/errors.js'
 import type { StatusManager } from '../StatusManager.js'
-import type { LiFiStepExtended, SwitchChainHook } from '../types.js'
+import type { ExecutionOptions, LiFiStepExtended, Process } from '../types.js'
 
 /**
  * This method checks whether the wallet client is configured for the correct chain.
@@ -27,8 +27,10 @@ export const switchChain = async (
   client: Client,
   statusManager: StatusManager,
   step: LiFiStepExtended,
+  process: Process,
+  targetChainId: number,
   allowUserInteraction: boolean,
-  switchChainHook?: SwitchChainHook
+  executionOptions?: ExecutionOptions
 ): Promise<Client | undefined> => {
   // if we are already on the correct chain we can proceed directly
   const currentChainId = (await getAction(
@@ -36,26 +38,22 @@ export const switchChain = async (
     getChainId,
     'getChainId'
   )(undefined)) as GetChainIdReturnType
-  if (currentChainId === step.action.fromChainId) {
+  if (currentChainId === targetChainId) {
     return client
   }
 
-  // -> set status message
-  step.execution = statusManager.initExecutionObject(step)
-  statusManager.updateExecution(step, 'ACTION_REQUIRED')
-
-  let switchProcess = statusManager.findOrCreateProcess({
-    step,
-    type: 'SWITCH_CHAIN',
-    status: 'ACTION_REQUIRED',
-  })
-
   if (!allowUserInteraction) {
     return
   }
 
   try {
-    const updatedClient = await switchChainHook?.(step.action.fromChainId)
+    if (!executionOptions?.switchChainHook) {
+      throw new ProviderError(
+        LiFiErrorCode.ChainSwitchError,
+        'Chain switch hook is not provided.'
+      )
+    }
+    const updatedClient = await executionOptions.switchChainHook(targetChainId)
     let updatedChainId: number | undefined
     if (updatedClient) {
       updatedChainId = (await getAction(
@@ -64,22 +62,16 @@ export const switchChain = async (
         'getChainId'
       )(undefined)) as GetChainIdReturnType
     }
-    if (updatedChainId !== step.action.fromChainId) {
+    if (updatedChainId !== targetChainId) {
       throw new ProviderError(
         LiFiErrorCode.ChainSwitchError,
         'Chain switch required.'
       )
     }
 
-    switchProcess = statusManager.updateProcess(
-      step,
-      switchProcess.type,
-      'DONE'
-    )
-    statusManager.updateExecution(step, 'PENDING')
     return updatedClient
   } catch (error: any) {
-    statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
+    statusManager.updateProcess(step, process.type, 'FAILED', {
       error: {
         message: error.message,
         code: LiFiErrorCode.ChainSwitchError,

package/src/core/EVM/utils.ts

@@ -1,5 +1,6 @@
 import type { ChainId, ExtendedChain } from '@lifi/types'
-import type { Address, Chain, Client, Transaction } from 'viem'
+import type { Address, Chain, Client, Hex, Transaction } from 'viem'
+import { pad, toHex } from 'viem'
 import { getBlock } from 'viem/actions'
 import { config } from '../../config.js'
 import { median } from '../../utils/median.js'
@@ -100,3 +101,18 @@ export const retryDelay = ({ count }: { count: number; error: Error }) =>
   Math.min(~~(1 << count) * 200, 3000)
 
 export const retryCount = 30
+
+/**
+ * Helper function to check if a domain salt matches a chainId.
+ * The salt is a padded hex string representation of the chainId.
+ */
+export const isSaltMatchingChainId = (
+  salt: Hex | undefined,
+  chainId: number
+): boolean => {
+  if (!salt) {
+    return false
+  }
+  const paddedChainId = pad(toHex(chainId), { size: 32 })
+  return salt.toLowerCase() === paddedChainId.toLowerCase()
+}

package/src/core/execution.ts

@@ -66,7 +66,7 @@ export const resumeRoute = async (
     }
   }
 
-  await prepareRestart(route)
+  prepareRestart(route)
 
   return executeRoute(route, executionOptions)
 }

package/src/core/prepareRestart.ts

@@ -1,13 +1,16 @@
 import type { RouteExtended } from './types.js'
 
-export const prepareRestart = async (route: RouteExtended) => {
+export const prepareRestart = (route: RouteExtended) => {
   for (let index = 0; index < route.steps.length; index++) {
     const step = route.steps[index]
     if (step.execution) {
-      // Find the index of the last process that has tx hash
+      // Find the index of the last process that has tx hash, taskId, or signed messages
       const lastValidIndex = step.execution.process.findLastIndex(
         (process) =>
-          (!!process.txHash || !!process.taskId) && process.status !== 'FAILED'
+          (!!process.txHash ||
+            !!process.taskId ||
+            !!process.signedTypedData?.length) &&
+          process.status !== 'FAILED'
       )
 
       // Keep all processes up to the one with tx hash

package/src/core/processMessages.ts

@@ -10,20 +10,17 @@ const processMessages: Record<
     PENDING: 'Waiting for token allowance',
     DONE: 'Token allowance set',
   },
-  SWITCH_CHAIN: {
-    ACTION_REQUIRED: 'Chain switch required',
-    PENDING: 'Waiting for chain switch',
-    DONE: 'Chain switched',
-  },
   SWAP: {
     STARTED: 'Preparing swap transaction',
-    ACTION_REQUIRED: 'Please sign the transaction',
+    ACTION_REQUIRED: 'Sign swap transaction',
+    MESSAGE_REQUIRED: 'Sign swap message',
     PENDING: 'Waiting for swap transaction',
     DONE: 'Swap completed',
   },
   CROSS_CHAIN: {
     STARTED: 'Preparing bridge transaction',
-    ACTION_REQUIRED: 'Please sign the transaction',
+    ACTION_REQUIRED: 'Sign bridge transaction',
+    MESSAGE_REQUIRED: 'Sign bridge message',
     PENDING: 'Waiting for bridge transaction',
     DONE: 'Bridge transaction confirmed',
   },
@@ -37,7 +34,6 @@ const processMessages: Record<
     PENDING: 'Waiting for permit message',
     DONE: 'Permit message signed',
   },
-  TRANSACTION: {},
 }
 const substatusMessages: Record<
   StatusMessage,

package/src/core/types.ts

@@ -132,6 +132,7 @@ export type ExecutionStatus = 'ACTION_REQUIRED' | 'PENDING' | 'FAILED' | 'DONE'
 export type ProcessStatus =
   | 'STARTED'
   | 'ACTION_REQUIRED'
+  | 'MESSAGE_REQUIRED'
   | 'PENDING'
   | 'FAILED'
   | 'DONE'
@@ -140,11 +141,9 @@ export type ProcessStatus =
 export type ProcessType =
   | 'TOKEN_ALLOWANCE'
   | 'PERMIT'
-  | 'SWITCH_CHAIN'
   | 'SWAP'
   | 'CROSS_CHAIN'
   | 'RECEIVING_CHAIN'
-  | 'TRANSACTION'
 
 export type Process = {
   type: ProcessType

package/src/services/api.ts

@@ -26,6 +26,7 @@ import {
   type SignedLiFiStep,
   type StatusResponse,
   type TokenExtended,
+  type TokensExtendedResponse,
   type TokensRequest,
   type TokensResponse,
   type ToolsRequest,
@@ -450,10 +451,18 @@ export const getChains = async (
  * @param options - Request options
  * @returns The tokens that are available on the requested chains
  */
-export const getTokens = async (
+export async function getTokens(
+  params?: TokensRequest & { extended?: false | undefined },
+  options?: RequestOptions
+): Promise<TokensResponse>
+export async function getTokens(
+  params: TokensRequest & { extended: true },
+  options?: RequestOptions
+): Promise<TokensExtendedResponse>
+export async function getTokens(
   params?: TokensRequest,
   options?: RequestOptions
-): Promise<TokensResponse> => {
+): Promise<TokensResponse> {
   if (params) {
     for (const key of Object.keys(params)) {
       if (!params[key as keyof TokensRequest]) {
@@ -464,14 +473,14 @@ export const getTokens = async (
   const urlSearchParams = new URLSearchParams(
     params as Record<string, string>
   ).toString()
+  const isExtended = params?.extended === true
   const response = await withDedupe(
     () =>
-      request<TokensResponse>(
-        `${config.get().apiUrl}/tokens?${urlSearchParams}`,
-        {
-          signal: options?.signal,
-        }
-      ),
+      request<
+        typeof isExtended extends true ? TokensExtendedResponse : TokensResponse
+      >(`${config.get().apiUrl}/tokens?${urlSearchParams}`, {
+        signal: options?.signal,
+      }),
     { id: `${getTokens.name}.${urlSearchParams}` }
   )
   return response

package/src/services/balance.ts

@@ -3,6 +3,8 @@ import type {
   RequestOptions,
   Token,
   TokenAmount,
+  TokenAmountExtended,
+  TokenExtended,
   WalletTokenExtended,
 } from '@lifi/types'
 import { config } from '../config.js'
@@ -26,16 +28,20 @@ export const getTokenBalance = async (
 }
 
 /**
- * Returns the balances for a list tokens a wallet holds  across all aggregated chains.
+ * Returns the balances for a list tokens a wallet holds across all aggregated chains.
  * @param walletAddress - A wallet address.
- * @param tokens - A list of Token objects.
+ * @param tokens - A list of Token (or TokenExtended) objects.
  * @returns A list of objects containing the tokens and the amounts on different chains.
  * @throws {BaseError} Throws a ValidationError if parameters are invalid.
  */
-export const getTokenBalances = async (
+export async function getTokenBalances(
   walletAddress: string,
   tokens: Token[]
-): Promise<TokenAmount[]> => {
+): Promise<TokenAmount[]>
+export async function getTokenBalances(
+  walletAddress: string,
+  tokens: TokenExtended[]
+): Promise<TokenAmountExtended[]> {
   // split by chain
   const tokensByChain = tokens.reduce(
     (tokens, token) => {
@@ -45,7 +51,7 @@ export const getTokenBalances = async (
       tokens[token.chainId].push(token)
       return tokens
     },
-    {} as { [chainId: number]: Token[] }
+    {} as { [chainId: number]: Token[] | TokenExtended[] }
   )
 
   const tokenAmountsByChain = await getTokenBalancesByChain(
@@ -62,10 +68,14 @@ export const getTokenBalances = async (
  * @returns A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
  * @throws {BaseError} Throws a ValidationError if parameters are invalid.
  */
-export const getTokenBalancesByChain = async (
+export async function getTokenBalancesByChain(
   walletAddress: string,
   tokensByChain: { [chainId: number]: Token[] }
-): Promise<{ [chainId: number]: TokenAmount[] }> => {
+): Promise<{ [chainId: number]: TokenAmount[] }>
+export async function getTokenBalancesByChain(
+  walletAddress: string,
+  tokensByChain: { [chainId: number]: TokenExtended[] }
+): Promise<{ [chainId: number]: TokenAmountExtended[] }> {
   if (!walletAddress) {
     throw new ValidationError('Missing walletAddress.')
   }
@@ -83,7 +93,9 @@ export const getTokenBalancesByChain = async (
     throw new Error(`SDK Token Provider for ${walletAddress} is not found.`)
   }
 
-  const tokenAmountsByChain: { [chainId: number]: TokenAmount[] } = {}
+  const tokenAmountsByChain: {
+    [chainId: number]: TokenAmount[] | TokenAmountExtended[]
+  } = {}
   const tokenAmountsSettled = await Promise.allSettled(
     Object.keys(tokensByChain).map(async (chainIdStr) => {
       const chainId = Number.parseInt(chainIdStr, 10)

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.10.1'
+export const version = '3.11.0'