@lifi/sdk 4.0.0-alpha.9 → 4.0.0-beta.1

package/src/core/execution.ts

@@ -1,8 +1,9 @@
 import type { Route } from '@lifi/types'
 import { LiFiErrorCode } from '../errors/constants.js'
-import { ProviderError } from '../errors/errors.js'
+import { ExecuteStepRetryError, ProviderError } from '../errors/errors.js'
 import type {
   ExecutionOptions,
+  LiFiStepExtended,
   RouteExtended,
   SDKClient,
   SDKProvider,
@@ -94,7 +95,6 @@ const executeSteps = async (
     const step = route.steps[index]
     const previousStep = route.steps[index - 1]
     // Check if the step is already done
-    //
     if (step.execution?.status === 'DONE') {
       continue
     }
@@ -136,7 +136,21 @@ const executeSteps = async (
         updateRouteExecution(route, execution.executionOptions)
       }
 
-      const executedStep = await stepExecutor.executeStep(client, step)
+      let executedStep: LiFiStepExtended
+      try {
+        executedStep = await stepExecutor.executeStep(client, step)
+      } catch (e) {
+        if (e instanceof ExecuteStepRetryError) {
+          step.execution = undefined
+          executedStep = await stepExecutor.executeStep(
+            client,
+            step,
+            e.retryParams
+          )
+        } else {
+          throw e
+        }
+      }
 
       // We may reach this point if user interaction isn't allowed. We want to stop execution until we resume it
       if (executedStep.execution?.status !== 'DONE') {

package/src/core/prepareRestart.ts

@@ -7,9 +7,8 @@ export const prepareRestart = (route: RouteExtended) => {
       // Find the index of the last action that has tx hash, taskId, or signed messages
       const lastValidIndex = step.execution.actions.findLastIndex(
         (action) =>
-          (!!action.txHash ||
-            !!action.taskId ||
-            !!action.signedTypedData?.length) &&
+          ['SWAP', 'CROSS_CHAIN', 'RECEIVING_CHAIN'].includes(action.type) &&
+          (!!action.txHash || !!action.taskId) &&
           action.status !== 'FAILED'
       )
 

package/src/core/storage.ts

@@ -0,0 +1,42 @@
+export interface SDKStorage {
+  get(key: string): string | null | Promise<string | null>
+  set(key: string, value: string): void | Promise<void>
+  remove(key: string): void | Promise<void>
+}
+
+export class LocalStorageAdapter implements SDKStorage {
+  get(key: string): string | null {
+    return window.localStorage.getItem(key)
+  }
+
+  set(key: string, value: string): void {
+    window.localStorage.setItem(key, value)
+  }
+
+  remove(key: string): void {
+    window.localStorage.removeItem(key)
+  }
+}
+
+export class InMemoryStorage implements SDKStorage {
+  private store = new Map<string, string>()
+
+  get(key: string): string | null {
+    return this.store.get(key) ?? null
+  }
+
+  set(key: string, value: string): void {
+    this.store.set(key, value)
+  }
+
+  remove(key: string): void {
+    this.store.delete(key)
+  }
+}
+
+export function createDefaultStorage(): SDKStorage {
+  if (typeof window !== 'undefined' && window.localStorage) {
+    return new LocalStorageAdapter()
+  }
+  return new InMemoryStorage()
+}

package/src/core/tasks/CheckBalanceTask.ts

@@ -0,0 +1,29 @@
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
+import type { StepExecutorContext, TaskResult } from '../../types/execution.js'
+import { BaseStepExecutionTask } from '../BaseStepExecutionTask.js'
+import { checkBalance } from './helpers/checkBalance.js'
+
+export class CheckBalanceTask extends BaseStepExecutionTask {
+  async run(context: StepExecutorContext): Promise<TaskResult> {
+    const { client, step, statusManager, isBridgeExecution } = context
+
+    statusManager.initializeAction({
+      step,
+      type: isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP',
+      chainId: step.action.fromChainId,
+      status: 'STARTED',
+    })
+
+    const walletAddress = step.action.fromAddress
+    if (!walletAddress) {
+      throw new TransactionError(
+        LiFiErrorCode.InternalError,
+        'The wallet address is undefined.'
+      )
+    }
+
+    await checkBalance(client, walletAddress, step)
+    return { status: 'COMPLETED' }
+  }
+}

package/src/core/tasks/PrepareTransactionTask.ts

@@ -0,0 +1,62 @@
+import { getStepTransaction } from '../../actions/getStepTransaction.js'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
+import type { StepExecutorContext, TaskResult } from '../../types/execution.js'
+import { BaseStepExecutionTask } from '../BaseStepExecutionTask.js'
+import { stepComparison } from './helpers/stepComparison.js'
+
+export class PrepareTransactionTask extends BaseStepExecutionTask {
+  async run(context: StepExecutorContext): Promise<TaskResult> {
+    const {
+      client,
+      step,
+      statusManager,
+      allowUserInteraction,
+      executionOptions,
+      isBridgeExecution,
+    } = context
+
+    const action = statusManager.findAction(
+      step,
+      isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
+    )
+
+    if (!action) {
+      throw new TransactionError(
+        LiFiErrorCode.TransactionUnprepared,
+        'Unable to prepare transaction. Action not found.'
+      )
+    }
+
+    if (!step.transactionRequest) {
+      const { execution, ...stepBase } = step
+      const updatedStep = await getStepTransaction(client, stepBase)
+      const comparedStep = await stepComparison(
+        statusManager,
+        step,
+        updatedStep,
+        allowUserInteraction,
+        executionOptions
+      )
+      Object.assign(step, {
+        ...comparedStep,
+        execution: step.execution,
+      })
+    }
+
+    if (!step.transactionRequest?.data) {
+      throw new TransactionError(
+        LiFiErrorCode.TransactionUnprepared,
+        'Unable to prepare transaction. Transaction request data is not found.'
+      )
+    }
+
+    statusManager.updateAction(step, action.type, 'ACTION_REQUIRED')
+
+    if (!allowUserInteraction) {
+      return { status: 'PAUSED' }
+    }
+
+    return { status: 'COMPLETED' }
+  }
+}

package/src/core/tasks/WaitForTransactionStatusTask.ts

@@ -0,0 +1,114 @@
+import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
+import type { ExecutionActionType } from '../../types/core.js'
+import type { StepExecutorContext, TaskResult } from '../../types/execution.js'
+import { getTransactionFailedMessage } from '../../utils/getTransactionMessage.js'
+import { BaseStepExecutionTask } from '../BaseStepExecutionTask.js'
+import { waitForTransactionStatus } from './helpers/waitForTransactionStatus.js'
+
+export class WaitForTransactionStatusTask extends BaseStepExecutionTask {
+  readonly actionType: ExecutionActionType
+
+  constructor(actionType: ExecutionActionType) {
+    super()
+    this.actionType = actionType
+  }
+
+  async run(context: StepExecutorContext): Promise<TaskResult> {
+    const {
+      client,
+      step,
+      statusManager,
+      pollingIntervalMs,
+      toChain,
+      isBridgeExecution,
+    } = context
+
+    // At this point, we should have a txHash or taskId
+    // taskId is used for custom integrations that don't use the standard transaction hash
+    let transactionHash: string | undefined
+    try {
+      const swapOrBridgeAction = statusManager.findAction(
+        step,
+        isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
+      )
+      transactionHash = swapOrBridgeAction?.txHash || swapOrBridgeAction?.taskId
+
+      // Wait for the transaction status on the destination chain
+      if (!transactionHash) {
+        throw new Error('Transaction hash is undefined.')
+      }
+
+      const action = statusManager.initializeAction({
+        step,
+        type: this.actionType,
+        chainId:
+          this.actionType === 'RECEIVING_CHAIN'
+            ? step.action.toChainId
+            : step.action.fromChainId,
+        status: 'PENDING',
+      })
+
+      const statusResponse = (await waitForTransactionStatus(
+        client,
+        statusManager,
+        transactionHash,
+        step,
+        action.type,
+        pollingIntervalMs
+      )) as FullStatusData
+
+      const statusReceiving =
+        statusResponse.receiving as ExtendedTransactionInfo
+
+      // Update action status
+      statusManager.updateAction(step, action.type, 'DONE', {
+        chainId: statusReceiving?.chainId || toChain.id,
+        substatus: statusResponse.substatus,
+        substatusMessage: statusResponse.substatusMessage,
+        txHash: statusReceiving?.txHash,
+        txLink:
+          statusReceiving?.txLink ||
+          `${toChain.metamask.blockExplorerUrls[0]}tx/${statusReceiving?.txHash}`,
+      })
+
+      // Update execution status
+      statusManager.updateExecution(step, {
+        status: 'DONE',
+        ...(statusResponse.sending.amount && {
+          fromAmount: statusResponse.sending.amount,
+        }),
+        ...(statusReceiving?.amount && { toAmount: statusReceiving.amount }),
+        ...(statusReceiving?.token && { toToken: statusReceiving.token }),
+        internalTxLink: statusResponse?.lifiExplorerLink,
+        externalTxLink: statusResponse?.bridgeExplorerLink,
+        gasCosts: [
+          {
+            amount: statusResponse.sending.gasAmount,
+            amountUSD: statusResponse.sending.gasAmountUSD,
+            token: statusResponse.sending.gasToken,
+            estimate: statusResponse.sending.gasUsed,
+            limit: statusResponse.sending.gasUsed,
+            price: statusResponse.sending.gasPrice,
+            type: 'SEND',
+          },
+        ],
+      })
+
+      return { status: 'COMPLETED' }
+    } catch (e: any) {
+      const htmlMessage = await getTransactionFailedMessage(
+        client,
+        step,
+        `${toChain.metamask.blockExplorerUrls[0]}tx/${transactionHash}`
+      )
+      throw new TransactionError(
+        LiFiErrorCode.TransactionFailed,
+        htmlMessage ??
+          'Failed while waiting for status of destination chain transaction.',
+        e
+      )
+    }
+  }
+}

package/src/core/{checkBalance.ts → tasks/helpers/checkBalance.ts}

@@ -1,9 +1,9 @@
 import type { LiFiStep } from '@lifi/types'
-import { getTokenBalance } from '../actions/getTokenBalance.js'
-import { BalanceError } from '../errors/errors.js'
-import type { SDKClient } from '../types/core.js'
-import { formatUnits } from '../utils/formatUnits.js'
-import { sleep } from '../utils/sleep.js'
+import { getTokenBalance } from '../../../actions/getTokenBalance.js'
+import { BalanceError } from '../../../errors/errors.js'
+import type { SDKClient } from '../../../types/core.js'
+import { formatUnits } from '../../../utils/formatUnits.js'
+import { sleep } from '../../../utils/sleep.js'
 
 export const checkBalance = async (
   client: SDKClient,

package/src/core/tasks/helpers/getTransactionRequestData.ts

@@ -0,0 +1,47 @@
+import { LiFiErrorCode } from '../../../errors/constants.js'
+import { TransactionError } from '../../../errors/errors.js'
+import type {
+  ExecutionOptions,
+  LiFiStepExtended,
+  TransactionParameters,
+} from '../../../types/core.js'
+
+export const getTransactionRequestData = async (
+  step: LiFiStepExtended,
+  executionOptions?: ExecutionOptions
+): Promise<string> => {
+  if (!step.transactionRequest?.data) {
+    throw new TransactionError(
+      LiFiErrorCode.TransactionUnprepared,
+      'Unable to prepare transaction. Transaction request data is not found.'
+    )
+  }
+
+  let transactionRequest: TransactionParameters = {
+    data: step.transactionRequest.data,
+  }
+
+  if (executionOptions?.updateTransactionRequestHook) {
+    const customizedTransactionRequest: TransactionParameters =
+      await executionOptions.updateTransactionRequestHook({
+        requestType: 'transaction',
+        ...transactionRequest,
+      })
+
+    transactionRequest = {
+      ...transactionRequest,
+      ...customizedTransactionRequest,
+    }
+  }
+
+  const transactionRequestData = transactionRequest.data
+
+  if (!transactionRequestData) {
+    throw new TransactionError(
+      LiFiErrorCode.TransactionUnprepared,
+      'Unable to prepare transaction. Transaction request data is not found.'
+    )
+  }
+
+  return transactionRequestData
+}

package/src/core/{stepComparison.ts → tasks/helpers/stepComparison.ts}

@@ -1,9 +1,9 @@
 import type { LiFiStep } from '@lifi/types'
-import { LiFiErrorCode } from '../errors/constants.js'
-import { TransactionError } from '../errors/errors.js'
-import type { ExecutionOptions } from '../types/core.js'
-import type { StatusManager } from './StatusManager.js'
-import { checkStepSlippageThreshold } from './utils.js'
+import type { StatusManager } from '../../../core/StatusManager.js'
+import { checkStepSlippageThreshold } from '../../../core/utils.js'
+import { LiFiErrorCode } from '../../../errors/constants.js'
+import { TransactionError } from '../../../errors/errors.js'
+import type { ExecutionOptions } from '../../../types/core.js'
 
 /**
  * This method checks whether the new and updated Step meets the required exchange rate conditions.

package/src/core/{waitForTransactionStatus.ts → tasks/helpers/waitForTransactionStatus.ts}

@@ -1,10 +1,10 @@
 import type { FullStatusData, LiFiStep, StatusResponse } from '@lifi/types'
-import { getStatus } from '../actions/getStatus.js'
-import { ServerError } from '../errors/errors.js'
-import type { ExecutionActionType, SDKClient } from '../types/core.js'
-import { waitForResult } from '../utils/waitForResult.js'
-import { getSubstatusMessage } from './actionMessages.js'
-import type { StatusManager } from './StatusManager.js'
+import { getStatus } from '../../../actions/getStatus.js'
+import { ServerError } from '../../../errors/errors.js'
+import type { ExecutionActionType, SDKClient } from '../../../types/core.js'
+import { waitForResult } from '../../../utils/waitForResult.js'
+import { getSubstatusMessage } from '../../actionMessages.js'
+import type { StatusManager } from '../../StatusManager.js'
 
 const TRANSACTION_HASH_OBSERVERS: Record<string, Promise<StatusResponse>> = {}
 
@@ -57,7 +57,9 @@ export async function waitForTransactionStatus(
   let status = TRANSACTION_HASH_OBSERVERS[txHash]
 
   if (!status) {
-    status = waitForResult(_getStatus, interval)
+    status = waitForResult(_getStatus, interval).finally(() => {
+      delete TRANSACTION_HASH_OBSERVERS[txHash]
+    })
     TRANSACTION_HASH_OBSERVERS[txHash] = status
   }
 

package/src/errors/constants.ts

@@ -10,6 +10,7 @@ export enum ErrorName {
   SlippageError = 'SlippageError',
   HTTPError = 'HTTPError',
   ConfigError = 'ConfigError',
+  ExecuteStepRetryError = 'ExecuteStepRetryError',
 }
 
 export type ErrorCode = LiFiErrorCode

package/src/errors/errors.ts

@@ -1,3 +1,4 @@
+import type { ExecuteStepRetryParams } from '../types/core.js'
 import { BaseError } from './baseError.js'
 import { ErrorName, LiFiErrorCode } from './constants.js'
 
@@ -42,3 +43,26 @@ export class ValidationError extends BaseError {
     super(ErrorName.ValidationError, LiFiErrorCode.ValidationError, message)
   }
 }
+
+/**
+ * Thrown by a step executor when executeStep should be retried with the given params
+ * (e.g. wallet rejected 7702 upgrade → retry with atomicityNotReady).
+ * The execution layer catches this and retries executeStep(client, step, retryParams).
+ */
+export class ExecuteStepRetryError extends BaseError {
+  readonly retryParams: ExecuteStepRetryParams
+
+  constructor(
+    message: string,
+    retryParams: ExecuteStepRetryParams,
+    cause?: Error
+  ) {
+    super(
+      ErrorName.ExecuteStepRetryError,
+      LiFiErrorCode.InternalError,
+      message,
+      cause
+    )
+    this.retryParams = retryParams
+  }
+}

package/src/errors/httpError.ts

@@ -82,10 +82,10 @@ export class HTTPError extends BaseError {
     try {
       this.responseBody = await this.response.json()
 
-      if (this.responseBody) {
+      if (this.responseBody?.message) {
         this.message += this.message.endsWith('.')
-          ? ` ${this.responseBody?.message.toString()}`
-          : `. ${this.responseBody?.message.toString()}`
+          ? ` ${this.responseBody.message.toString()}`
+          : `. ${this.responseBody.message.toString()}`
       }
     } catch {}
 

package/src/index.ts

@@ -24,8 +24,9 @@ export { actions } from './actions/index.js'
 export { patchContractCalls } from './actions/patchContractCalls.js'
 export { relayTransaction } from './actions/relayTransaction.js'
 export { createClient } from './client/createClient.js'
+export { getActionMessage, getSubstatusMessage } from './core/actionMessages.js'
+export { BaseStepExecutionTask } from './core/BaseStepExecutionTask.js'
 export { BaseStepExecutor } from './core/BaseStepExecutor.js'
-export { checkBalance } from './core/checkBalance.js'
 export {
   executeRoute,
   getActiveRoute,
@@ -35,13 +36,25 @@ export {
   updateRouteExecution,
 } from './core/execution.js'
 export { StatusManager } from './core/StatusManager.js'
-export { stepComparison } from './core/stepComparison.js'
-export { waitForDestinationChainTransaction } from './core/waitForDestinationChainTransaction.js'
+export type { SDKStorage } from './core/storage.js'
+export {
+  createDefaultStorage,
+  InMemoryStorage,
+  LocalStorageAdapter,
+} from './core/storage.js'
+export { TaskPipeline } from './core/TaskPipeline.js'
+export { CheckBalanceTask } from './core/tasks/CheckBalanceTask.js'
+export { checkBalance } from './core/tasks/helpers/checkBalance.js'
+export { getTransactionRequestData } from './core/tasks/helpers/getTransactionRequestData.js'
+export { stepComparison } from './core/tasks/helpers/stepComparison.js'
+export { PrepareTransactionTask } from './core/tasks/PrepareTransactionTask.js'
+export { WaitForTransactionStatusTask } from './core/tasks/WaitForTransactionStatusTask.js'
 export { BaseError } from './errors/baseError.js'
 export type { ErrorCode } from './errors/constants.js'
 export { ErrorMessage, ErrorName, LiFiErrorCode } from './errors/constants.js'
 export {
   BalanceError,
+  ExecuteStepRetryError,
   ProviderError,
   RPCError,
   ServerError,
@@ -58,6 +71,7 @@ export type {
   ContractCallParams,
   ContractTool,
   ExchangeRateUpdateParams,
+  ExecuteStepRetryParams,
   Execution,
   ExecutionAction,
   ExecutionActionStatus,
@@ -87,6 +101,12 @@ export type {
   TransactionRequestUpdateHook,
   UpdateRouteHook,
 } from './types/core.js'
+export type {
+  StepExecutorBaseContext,
+  StepExecutorContext,
+  TaskResult,
+  TaskStatus,
+} from './types/execution.js'
 export { checkPackageUpdates } from './utils/checkPackageUpdates.js'
 export { convertQuoteToRoute } from './utils/convertQuoteToRoute.js'
 export { fetchTxErrorDetails } from './utils/fetchTxErrorDetails.js'
@@ -95,4 +115,4 @@ export { isHex } from './utils/isHex.js'
 export { parseUnits } from './utils/parseUnits.js'
 export { sleep } from './utils/sleep.js'
 export { waitForResult } from './utils/waitForResult.js'
-export { withDedupe } from './utils/withDedupe.js'
+export { LruMap, withDedupe } from './utils/withDedupe.js'

package/src/types/core.ts

@@ -14,6 +14,7 @@ import type {
   Token,
   TokenAmount,
 } from '@lifi/types'
+import type { SDKStorage } from '../core/storage.js'
 import type { ExtendedRequestInit } from './request.js'
 
 export type RequestInterceptor = (
@@ -34,6 +35,7 @@ export interface SDKBaseConfig {
   preloadChains?: boolean
   chainsRefetchInterval?: number
   requestInterceptor?: RequestInterceptor
+  storage?: SDKStorage
 }
 
 export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {
@@ -82,13 +84,20 @@ export interface InteractionSettings {
   allowExecution?: boolean
 }
 
+/**
+ * Params passed when retrying executeStep after an ExecuteStepRetryError.
+ * Providers can use this to pass strategy-specific retry options (e.g. atomicityNotReady for Ethereum 7702).
+ */
+export type ExecuteStepRetryParams = Record<string, unknown>
+
 export interface StepExecutor {
   allowUserInteraction: boolean
   allowExecution: boolean
   setInteraction(settings?: InteractionSettings): void
   executeStep(
     client: SDKClient,
-    step: LiFiStepExtended
+    step: LiFiStepExtended,
+    retryParams?: ExecuteStepRetryParams
   ): Promise<LiFiStepExtended>
 }
 
@@ -195,7 +204,6 @@ export interface ExecutionOptions {
   getContractCalls?: GetContractCallsHook
   adjustZeroOutputFromPreviousStep?: boolean
   executeInBackground?: boolean
-  disableMessageSigning?: boolean
   /**
    * @deprecated
    */
@@ -215,8 +223,11 @@ export type ExecutionActionStatus =
   | 'CANCELLED'
 
 export type ExecutionActionType =
-  | 'TOKEN_ALLOWANCE'
   | 'PERMIT'
+  | 'CHECK_ALLOWANCE'
+  | 'NATIVE_PERMIT'
+  | 'RESET_ALLOWANCE'
+  | 'SET_ALLOWANCE'
   | 'SWAP'
   | 'CROSS_CHAIN'
   | 'RECEIVING_CHAIN'
@@ -224,21 +235,17 @@ export type ExecutionActionType =
 export type ExecutionAction = {
   type: ExecutionActionType
   status: ExecutionActionStatus
+  message?: string
   substatus?: Substatus
+  substatusMessage?: string
   chainId?: number
   txHash?: string
-  taskId?: string
   txLink?: string
+  taskId?: string
   txType?: TransactionMethodType
-  message?: string
-  error?: {
-    code: string | number
-    message: string
-    htmlMessage?: string
-  }
-
-  // additional information
-  [key: string]: any
+  txHex?: string
+  // Errors occured during the action execution (within tasks)
+  error?: { code: string | number; message: string; htmlMessage?: string }
 }
 
 export interface Execution {
@@ -253,6 +260,8 @@ export interface Execution {
   gasCosts?: GasCost[]
   internalTxLink?: string
   externalTxLink?: string
+  // Errors occured outside of actions (e.g. during context creation)
+  error?: { code: string | number; message: string; htmlMessage?: string }
 }
 
 export type TransactionMethodType = 'standard' | 'relayed' | 'batched'

package/src/types/execution.ts

@@ -0,0 +1,32 @@
+import type { ExtendedChain } from '@lifi/types'
+import type { StatusManager } from '../core/StatusManager.js'
+import type {
+  ExecuteStepRetryParams,
+  ExecutionOptions,
+  LiFiStepExtended,
+  SDKClient,
+} from './core.js'
+
+export interface StepExecutorBaseContext {
+  statusManager: StatusManager
+  executionOptions?: ExecutionOptions
+  fromChain: ExtendedChain
+  toChain: ExtendedChain
+  isBridgeExecution: boolean
+  client: SDKClient
+  step: LiFiStepExtended
+  allowUserInteraction: boolean
+  retryParams?: ExecuteStepRetryParams
+}
+
+export interface StepExecutorContext extends StepExecutorBaseContext {
+  pollingIntervalMs?: number
+}
+
+export interface TaskResult<TContext = Record<string, unknown>> {
+  status: TaskStatus
+  /** Optional: data produced for downstream tasks. Pipeline merges into the executor context. */
+  context?: TContext
+}
+
+export type TaskStatus = 'COMPLETED' | 'PAUSED'