@lifi/sdk 4.0.1-alpha.0 → 4.1.0

package/src/core/StatusManager.ts

@@ -4,23 +4,20 @@ import type {
   ExecutionAction,
   ExecutionActionStatus,
   ExecutionActionType,
-  ExecutionStatus,
   LiFiStepExtended,
 } from '../types/core.js'
 import { getActionMessage } from './actionMessages.js'
 import { executionState } from './executionState.js'
 
-type FindOrCreateActionProps = {
+type ActionProps = {
   step: LiFiStepExtended
   type: ExecutionActionType
-  chainId?: ChainId
-  status?: ExecutionActionStatus
+  chainId: ChainId
+  status: ExecutionActionStatus
 }
 
 /**
- * Manages status updates of a route and provides various functions for tracking actions
- * @param {string} routeId The route dd this StatusManger belongs to.
- * @returns {StatusManager} An instance of StatusManager.
+ * Manages status updates of a route and provides various functions for tracking actions.
  */
 export class StatusManager {
   private readonly routeId: string
@@ -32,10 +29,10 @@ export class StatusManager {
 
   /**
    * Initializes the execution object of a Step.
-   * @param step  The current step in execution
-   * @returns The initialized execution object for this step and a function to update this step
+   * @param step The current step in execution
+   * @returns The initialized execution object for this step
    */
-  initExecutionObject = (step: LiFiStepExtended): Execution => {
+  initializeExecution = (step: LiFiStepExtended): Execution => {
     if (!step.execution) {
       step.execution = {
         startedAt: Date.now(),
@@ -50,6 +47,7 @@ export class StatusManager {
       step.execution.startedAt = Date.now()
       step.execution.status = 'PENDING'
       step.execution.signedAt = undefined
+      step.execution.error = undefined
       this.updateStepInRoute(step)
     }
 
@@ -58,25 +56,20 @@ export class StatusManager {
 
   /**
    * Updates the execution object of a Step.
-   * @param step  The current step in execution
-   * @param status  The status for the execution
-   * @param execution Optional. Information about received tokens
+   * @param step The current step in execution
+   * @param execution Partial execution data to merge
    * @returns The step with the updated execution object
    */
   updateExecution(
     step: LiFiStepExtended,
-    status: ExecutionStatus,
-    execution?: Partial<Execution>
+    execution: Partial<Execution>
   ): LiFiStep {
     if (!step.execution) {
       throw Error("Can't update empty execution.")
     }
-    step.execution.status = status
-    if (execution) {
-      step.execution = {
-        ...step.execution,
-        ...execution,
-      }
+    step.execution = {
+      ...step.execution,
+      ...execution,
     }
     this.updateStepInRoute(step)
     return step
@@ -86,13 +79,11 @@ export class StatusManager {
    * Finds an action of the specified type in the step's execution
    * @param step The step to search in
    * @param type The action type to find
-   * @param status Optional status to update the action with if found
    * @returns The found action or undefined if not found
    */
   findAction(
     step: LiFiStepExtended,
-    type: ExecutionActionType,
-    status?: ExecutionActionStatus
+    type: ExecutionActionType
   ): ExecutionAction | undefined {
     if (!step.execution?.actions) {
       throw new Error("Execution hasn't been initialized.")
@@ -100,46 +91,65 @@ export class StatusManager {
 
     const action = step.execution.actions.find((p) => p.type === type)
 
-    if (action && status && action.status !== status) {
-      action.status = status
-      this.updateStepInRoute(step)
-    }
-
     return action
   }
 
   /**
    * Create and push a new action into the execution.
+   * Caller is responsible for ensuring an action of this type does not already exist.
    * @param step The step that should contain the new action.
-   * @param type Type of the action. Used to identify already existing actions.
+   * @param type Type of the action.
    * @param chainId Chain Id of the action.
-   * @param status By default created action is set to the STARTED status. We can override new action with the needed status.
-   * @returns Returns action.
+   * @param status The initial status for the new action.
+   * @returns The created action.
    */
-  findOrCreateAction = ({
+  createAction = ({
     step,
     type,
     chainId,
     status,
-  }: FindOrCreateActionProps): ExecutionAction => {
-    const action = this.findAction(step, type, status)
-
-    if (action) {
-      return action
+  }: ActionProps): ExecutionAction => {
+    if (!step.execution) {
+      throw new Error("Execution hasn't been initialized.")
     }
 
     const newAction: ExecutionAction = {
-      type: type,
-      message: getActionMessage(type, status ?? 'STARTED'),
-      status: status ?? 'STARTED',
-      chainId: chainId,
+      type,
+      message: getActionMessage(type, status),
+      status,
+      chainId,
     }
 
-    step.execution!.actions.push(newAction)
+    step.execution.actions.push(newAction)
     this.updateStepInRoute(step)
     return newAction
   }
 
+  /**
+   * Find an existing action by type and update it, or create a new one if none exists.
+   * @param step The step that should contain the action.
+   * @param type Type of the action. Used to identify already existing actions.
+   * @param chainId Chain Id of the action (used when creating).
+   * @param status The status to set on the found or newly created action.
+   * @returns The updated or newly created action.
+   */
+  initializeAction = ({
+    step,
+    type,
+    chainId,
+    status,
+  }: ActionProps): ExecutionAction => {
+    const action = this.findAction(step, type)
+
+    if (action) {
+      return this.updateAction(step, type, status, {
+        error: undefined,
+      })
+    }
+
+    return this.createAction({ step, type, chainId, status })
+  }
+
   /**
    * Update an action object.
    * @param step The step where the action should be updated
@@ -152,7 +162,7 @@ export class StatusManager {
     step: LiFiStepExtended,
     type: ExecutionActionType,
     status: ExecutionActionStatus,
-    params?: Partial<ExecutionAction>
+    params?: Partial<ExecutionAction & { signedAt?: number }>
   ): ExecutionAction => {
     if (!step.execution) {
       throw new Error("Can't update an empty step execution.")
@@ -168,11 +178,17 @@ export class StatusManager {
         break
       case 'FAILED':
         step.execution.status = 'FAILED'
+        if (params?.error) {
+          step.execution.error = params.error
+        }
         break
       case 'DONE':
         break
       case 'PENDING':
         step.execution.status = 'PENDING'
+        if (params?.signedAt) {
+          step.execution.signedAt = params.signedAt
+        }
         break
       case 'RESET_REQUIRED':
       case 'MESSAGE_REQUIRED':
@@ -187,9 +203,8 @@ export class StatusManager {
     currentAction.message = getActionMessage(type, status)
     // set extra parameters or overwrite the standard params set in the switch statement
     if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        currentAction[key] = value
-      }
+      const { signedAt: _signedAt, ...rest } = params
+      Object.assign(currentAction, rest)
     }
     // Sort actions, the ones with DONE status go first
     step.execution.actions = [
@@ -200,20 +215,6 @@ export class StatusManager {
     return currentAction
   }
 
-  /**
-   * Remove an action from the execution
-   * @param step The step where the action should be removed from
-   * @param type  The action type to remove
-   */
-  removeAction = (step: LiFiStepExtended, type: ExecutionActionType): void => {
-    if (!step.execution) {
-      throw new Error("Execution hasn't been initialized.")
-    }
-    const index = step.execution.actions.findIndex((p) => p.type === type)
-    step.execution.actions.splice(index, 1)
-    this.updateStepInRoute(step)
-  }
-
   updateStepInRoute = (step: LiFiStep): LiFiStep => {
     if (!this.shouldUpdate) {
       return step

package/src/core/TaskPipeline.ts

@@ -0,0 +1,28 @@
+import type { StepExecutorContext, TaskResult } from '../types/execution.js'
+import type { BaseStepExecutionTask } from './BaseStepExecutionTask.js'
+
+export class TaskPipeline {
+  private readonly tasks: BaseStepExecutionTask[]
+
+  constructor(tasks: BaseStepExecutionTask[]) {
+    this.tasks = tasks
+  }
+
+  async run(context: StepExecutorContext): Promise<TaskResult> {
+    for (const task of this.tasks) {
+      const shouldRun = await task.shouldRun(context)
+      if (!shouldRun) {
+        continue
+      }
+      const result = await task.run(context)
+      if (result.status === 'PAUSED') {
+        return { status: 'PAUSED' }
+      }
+      if (result.context && typeof result.context === 'object') {
+        Object.assign(context, result.context)
+      }
+    }
+
+    return { status: 'COMPLETED' }
+  }
+}

package/src/core/actionMessages.ts

@@ -8,11 +8,20 @@ const actionMessages: Record<
   ExecutionActionType,
   Partial<Record<ExecutionActionStatus, string>>
 > = {
-  TOKEN_ALLOWANCE: {
+  CHECK_ALLOWANCE: {
+    STARTED: 'Checking token allowance',
+    PENDING: 'Waiting for token allowance check',
+    DONE: 'Token allowance checked',
+  },
+  RESET_ALLOWANCE: {
+    STARTED: 'Resetting token allowance',
+    RESET_REQUIRED: 'Resetting token allowance',
+    PENDING: 'Waiting for token allowance reset',
+    DONE: 'Token allowance reset',
+  },
+  SET_ALLOWANCE: {
     STARTED: 'Setting token allowance',
     ACTION_REQUIRED: 'Set token allowance',
-    RESET_REQUIRED: 'Resetting token allowance',
-    MESSAGE_REQUIRED: 'Sign token allowance message',
     PENDING: 'Waiting for token allowance',
     DONE: 'Token allowance set',
   },
@@ -31,6 +40,7 @@ const actionMessages: Record<
     DONE: 'Bridge transaction confirmed',
   },
   RECEIVING_CHAIN: {
+    STARTED: 'Waiting for destination chain',
     PENDING: 'Waiting for destination chain',
     DONE: 'Bridge completed',
   },
@@ -40,7 +50,14 @@ const actionMessages: Record<
     PENDING: 'Waiting for permit message',
     DONE: 'Permit message signed',
   },
+  NATIVE_PERMIT: {
+    STARTED: 'Preparing transaction',
+    ACTION_REQUIRED: 'Sign permit message',
+    PENDING: 'Waiting for permit message',
+    DONE: 'Permit message signed',
+  },
 }
+
 const substatusMessages: Record<
   StatusMessage,
   Partial<Record<Substatus, string>>

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

@@ -1,15 +1,14 @@
 import type { RouteExtended } from '../types/core.js'
 
-export const prepareRestart = (route: RouteExtended) => {
+export const prepareRestart = (route: RouteExtended): void => {
   for (let index = 0; index < route.steps.length; index++) {
     const step = route.steps[index]
     if (step.execution) {
       // 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,46 @@
+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 {
+  type CheckBalanceOptions,
+  checkBalance,
+} from './helpers/checkBalance.js'
+
+export class CheckBalanceTask extends BaseStepExecutionTask {
+  /**
+   * Per-step options hook for chain-specific subclasses (e.g. skip the
+   * gas check for smart-contract wallets or relayed steps). Default `{}`
+   * keeps behavior unchanged for every provider that doesn't override.
+   * Resolved lazily inside `run()` — pipelines that resume past
+   * `CheckBalance` pay no cost.
+   */
+  protected getCheckBalanceOptions(
+    _context: StepExecutorContext
+  ): Promise<CheckBalanceOptions> {
+    return Promise.resolve({})
+  }
+
+  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.'
+      )
+    }
+
+    const options = await this.getCheckBalanceOptions(context)
+    await checkBalance(client, walletAddress, step, options)
+    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
+      )
+    }
+  }
+}