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

package/dist/types/types/execution.d.ts

@@ -0,0 +1,24 @@
+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';
+//# sourceMappingURL=execution.d.ts.map

package/dist/types/types/execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../../../src/types/execution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,KAAK,EACV,sBAAsB,EACtB,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACV,MAAM,WAAW,CAAA;AAElB,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,aAAa,CAAA;IAC5B,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IACnC,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,gBAAgB,CAAA;IACtB,oBAAoB,EAAE,OAAO,CAAA;IAC7B,WAAW,CAAC,EAAE,sBAAsB,CAAA;CACrC;AAED,MAAM,WAAW,mBAAoB,SAAQ,uBAAuB;IAClE,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,UAAU,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5D,MAAM,EAAE,UAAU,CAAA;IAClB,+FAA+F;IAC/F,OAAO,CAAC,EAAE,QAAQ,CAAA;CACnB;AAED,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,QAAQ,CAAA"}

package/dist/types/utils/waitForResult.d.ts

@@ -1,11 +1,11 @@
 /**
  * Repeatedly calls a given asynchronous function until it resolves with a value
  * @param fn The function that should be repeated
- * @param interval The timeout in milliseconds between retries, defaults to 5000
+ * @param interval The timeout in milliseconds between retries, or a function that receives the current poll count and returns the interval. Defaults to 5000
  * @param maxRetries Maximum number of retries before throwing an error, defaults to 3
  * @param shouldRetry Optional predicate to determine if an error should trigger a retry
  * @returns The result of the fn function
  * @throws Error if maximum retries is reached, if function keeps returning undefined, or if shouldRetry returns false
  */
-export declare const waitForResult: <T>(fn: () => Promise<T | undefined>, interval?: number, maxRetries?: number, shouldRetry?: (count: number, error: unknown) => boolean) => Promise<T>;
+export declare const waitForResult: <T>(fn: () => Promise<T | undefined>, interval?: number | ((poll: number) => number), maxRetries?: number, shouldRetry?: (count: number, error: unknown) => boolean) => Promise<T>;
 //# sourceMappingURL=waitForResult.d.ts.map

package/dist/types/utils/waitForResult.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"waitForResult.d.ts","sourceRoot":"","sources":["../../../src/utils/waitForResult.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAU,CAAC,EACnC,IAAI,MAAM,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,EAChC,iBAAe,EACf,mBAAc,EACd,cAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAoB,KACnE,OAAO,CAAC,CAAC,CAuBX,CAAA"}
+{"version":3,"file":"waitForResult.d.ts","sourceRoot":"","sources":["../../../src/utils/waitForResult.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAU,CAAC,EACnC,IAAI,MAAM,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,EAChC,WAAU,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAQ,EACpD,mBAAc,EACd,cAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAoB,KACnE,OAAO,CAAC,CAAC,CA4BX,CAAA"}

package/dist/types/utils/withDedupe.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Map with a LRU (Least recently used) policy.
+ *
+ * https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+export declare class LruMap<value = unknown> extends Map<string, value> {
+    maxSize: number;
+    constructor(size: number);
+    set(key: string, value: value): this;
+}
 type WithDedupeOptions = {
     enabled?: boolean | undefined;
     id?: string | undefined;

package/dist/types/utils/withDedupe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withDedupe.d.ts","sourceRoot":"","sources":["../../../src/utils/withDedupe.ts"],"names":[],"mappings":"AAyBA,KAAK,iBAAiB,GAAG;IACvB,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACxB,CAAA;AAED,uCAAuC;AACvC,wBAAgB,UAAU,CAAC,CAAC,EAC1B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,EAAE,OAAc,EAAE,EAAE,EAAE,EAAE,iBAAiB,GACxC,OAAO,CAAC,CAAC,CAAC,CAUZ"}
+{"version":3,"file":"withDedupe.d.ts","sourceRoot":"","sources":["../../../src/utils/withDedupe.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,MAAM,CAAC,KAAK,GAAG,OAAO,CAAE,SAAQ,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC;IAC7D,OAAO,EAAE,MAAM,CAAA;gBAEH,IAAI,EAAE,MAAM;IAKf,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAOvC;AAKD,KAAK,iBAAiB,GAAG;IACvB,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACxB,CAAA;AAED,uCAAuC;AACvC,wBAAgB,UAAU,CAAC,CAAC,EAC1B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,EAAE,OAAc,EAAE,EAAE,EAAE,EAAE,iBAAiB,GACxC,OAAO,CAAC,CAAC,CAAC,CAUZ"}

package/dist/types/version.d.ts

@@ -1,3 +1,3 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "4.0.0-alpha.9";
+export declare const version = "4.0.0-beta.1";
 //# sourceMappingURL=version.d.ts.map

package/dist/types/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,cAAc,CAAA;AAC/B,eAAO,MAAM,OAAO,kBAAkB,CAAA"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,cAAc,CAAA;AAC/B,eAAO,MAAM,OAAO,iBAAiB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/sdk",
-  "version": "4.0.0-alpha.9",
+  "version": "4.0.0-beta.1",
   "description": "LI.FI SDK for Any-to-Any Cross-Chain-Swap",
   "homepage": "https://github.com/lifinance/sdk",
   "bugs": {
@@ -28,7 +28,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@lifi/types": "^17.58.0"
+    "@lifi/types": "^17.67.1"
   },
   "publishConfig": {
     "access": "public"

package/src/actions/getQuote.ts

@@ -85,7 +85,10 @@ export async function getQuote(
   params.preferExchanges ??= client.config.routeOptions?.exchanges?.prefer
 
   for (const key of Object.keys(params)) {
-    if (!params[key as keyof QuoteRequest]) {
+    if (
+      params[key as keyof QuoteRequest] === undefined ||
+      params[key as keyof QuoteRequest] === null
+    ) {
       delete params[key as keyof QuoteRequest]
     }
   }

package/src/actions/getRelayedTransactionStatus.ts

@@ -39,7 +39,7 @@ export const getRelayedTransactionStatus = async (
 
   const decodedTaskId = decodeTaskId(taskId)
   // Temporary solution during the transition between status endpoints
-  if (decodedTaskId.length === 3) {
+  if (decodedTaskId.length >= 3) {
     return (await getStatus(
       client,
       params,

package/src/actions/getRelayerQuote.ts

@@ -56,7 +56,10 @@ export const getRelayerQuote = async (
   params.preferExchanges ??= client.config.routeOptions?.exchanges?.prefer
 
   for (const key of Object.keys(params)) {
-    if (!params[key as keyof QuoteRequest]) {
+    if (
+      params[key as keyof QuoteRequest] === undefined ||
+      params[key as keyof QuoteRequest] === null
+    ) {
       delete params[key as keyof QuoteRequest]
     }
   }

package/src/actions/getStepTransaction.ts

@@ -1,4 +1,5 @@
 import type { LiFiStep, RequestOptions, SignedLiFiStep } from '@lifi/types'
+import { ChainId } from '@lifi/types'
 import type { SDKClient } from '../types/core.js'
 import { isStep } from '../utils/isStep.js'
 import { request } from '../utils/request.js'
@@ -21,16 +22,31 @@ export const getStepTransaction = async (
     console.warn('SDK Validation: Invalid Step', step)
   }
 
-  return await request<LiFiStep>(
-    client.config,
-    `${client.config.apiUrl}/advanced/stepTransaction`,
-    {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(step),
-      signal: options?.signal,
+  const { config } = client
+
+  let requestUrl = `${config.apiUrl}/advanced/stepTransaction`
+  const jitoBundle = config.routeOptions?.jitoBundle
+  const svmSponsor = config.routeOptions?.svmSponsor
+
+  if (step.action.fromChainId === ChainId.SOL) {
+    const queryParams = new URLSearchParams()
+    if (jitoBundle) {
+      queryParams.set('jitoBundle', jitoBundle.toString())
+    }
+    if (svmSponsor) {
+      queryParams.set('svmSponsor', svmSponsor)
     }
-  )
+    if (queryParams.size > 0) {
+      requestUrl = `${requestUrl}?${queryParams}`
+    }
+  }
+
+  return await request<LiFiStep>(config, requestUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(step),
+    signal: options?.signal,
+  })
 }

package/src/actions/getTokens.ts

@@ -40,11 +40,13 @@ export async function getTokens(
   const urlSearchParams = new URLSearchParams(
     params as Record<string, string>
   ).toString()
-  const isExtended = params?.extended === true
+  const _isExtended = params?.extended === true
   const response = await withDedupe(
     () =>
       request<
-        typeof isExtended extends true ? TokensExtendedResponse : TokensResponse
+        typeof _isExtended extends true
+          ? TokensExtendedResponse
+          : TokensResponse
       >(client.config, `${client.config.apiUrl}/tokens?${urlSearchParams}`, {
         signal: options?.signal,
       }),

package/src/core/BaseStepExecutionTask.ts

@@ -0,0 +1,9 @@
+import type { StepExecutorContext, TaskResult } from '../types/execution.js'
+
+export abstract class BaseStepExecutionTask {
+  shouldRun(_context: StepExecutorContext): Promise<boolean> {
+    return Promise.resolve(true)
+  }
+
+  abstract run(context: StepExecutorContext): Promise<TaskResult>
+}

package/src/core/BaseStepExecutor.ts

@@ -1,12 +1,21 @@
-import type { LiFiStep } from '@lifi/types'
+import { ExecuteStepRetryError } from '../errors/errors.js'
+import type { SDKError } from '../errors/SDKError.js'
 import type {
+  ExecuteStepRetryParams,
+  ExecutionAction,
   ExecutionOptions,
   InteractionSettings,
+  LiFiStepExtended,
   SDKClient,
   StepExecutor,
   StepExecutorOptions,
 } from '../types/core.js'
+import type {
+  StepExecutorBaseContext,
+  StepExecutorContext,
+} from '../types/execution.js'
 import { StatusManager } from './StatusManager.js'
+import type { TaskPipeline } from './TaskPipeline.js'
 
 // Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
 const defaultInteractionSettings = {
@@ -37,5 +46,84 @@ export abstract class BaseStepExecutor implements StepExecutor {
     this.allowExecution = interactionSettings.allowExecution
   }
 
-  abstract executeStep(client: SDKClient, step: LiFiStep): Promise<LiFiStep>
+  private createBaseContext = async (
+    client: SDKClient,
+    step: LiFiStepExtended,
+    retryParams?: ExecuteStepRetryParams
+  ): Promise<StepExecutorBaseContext> => {
+    const fromChain = await client.getChainById(step.action.fromChainId)
+    const toChain = await client.getChainById(step.action.toChainId)
+
+    const isBridgeExecution = fromChain.id !== toChain.id
+
+    return {
+      client,
+      step,
+      fromChain,
+      toChain,
+      isBridgeExecution,
+      retryParams,
+      statusManager: this.statusManager,
+      executionOptions: this.executionOptions,
+      allowUserInteraction: this.allowUserInteraction,
+    }
+  }
+
+  abstract createContext(
+    baseContext: StepExecutorBaseContext
+  ): Promise<StepExecutorContext>
+
+  abstract createPipeline(context: StepExecutorContext): TaskPipeline
+
+  abstract parseErrors(
+    error: Error,
+    step?: LiFiStepExtended,
+    action?: ExecutionAction,
+    retryParams?: ExecuteStepRetryParams
+  ): Promise<SDKError | ExecuteStepRetryError>
+
+  executeStep = async (
+    client: SDKClient,
+    step: LiFiStepExtended,
+    retryParams?: ExecuteStepRetryParams
+  ): Promise<LiFiStepExtended> => {
+    try {
+      step.execution = this.statusManager.initializeExecution(step)
+
+      const baseContext = await this.createBaseContext(
+        client,
+        step,
+        retryParams
+      )
+      const context = await this.createContext(baseContext)
+      const pipeline = this.createPipeline(context)
+
+      await pipeline.run(context)
+
+      return step
+    } catch (error: any) {
+      // Derive failing action from last in execution.actions
+      const action = step.execution?.actions?.at(-1)
+      const parsed = await this.parseErrors(error, step, action, retryParams)
+      if (!(parsed instanceof ExecuteStepRetryError)) {
+        if (action) {
+          this.statusManager.updateAction(step, action.type, 'FAILED', {
+            error: {
+              message: parsed.cause?.message,
+              code: parsed.code,
+            },
+          })
+        } else {
+          this.statusManager.updateExecution(step, {
+            status: 'FAILED',
+            error: {
+              message: parsed.cause?.message,
+              code: parsed.code,
+            },
+          })
+        }
+      }
+      throw parsed
+    }
+  }
 }

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>>