@lifi/sdk 4.0.0-alpha.8 → 4.0.0-beta.0

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 { ProcessType, SDKClient } from '../types/core.js'
-import { waitForResult } from '../utils/waitForResult.js'
-import { getSubstatusMessage } from './processMessages.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>> = {}
 
@@ -13,7 +13,7 @@ export async function waitForTransactionStatus(
   statusManager: StatusManager,
   txHash: string,
   step: LiFiStep,
-  processType: ProcessType,
+  actionType: ExecutionActionType,
   interval = 5_000
 ): Promise<StatusResponse> {
   const _getStatus = (): Promise<StatusResponse | undefined> => {
@@ -29,7 +29,7 @@ export async function waitForTransactionStatus(
           case 'DONE':
             return statusResponse
           case 'PENDING':
-            statusManager?.updateProcess(step, processType, 'PENDING', {
+            statusManager?.updateAction(step, actionType, 'PENDING', {
               substatus: statusResponse.substatus,
               substatusMessage:
                 statusResponse.substatusMessage ||
@@ -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/SDKError.ts

@@ -1,24 +1,24 @@
 import type { LiFiStep } from '@lifi/types'
-import type { Process } from '../types/core.js'
+import type { ExecutionAction } from '../types/core.js'
 import { version } from '../version.js'
 import type { BaseError } from './baseError.js'
 import type { ErrorCode } from './constants.js'
 
 // Note: SDKError is used to wrapper and present errors at the top level
-// Where opportunity allows we also add the step and the process related to the error
+// Where opportunity allows we also add the step and the action related to the error
 export class SDKError extends Error {
   step?: LiFiStep
-  process?: Process
+  action?: ExecutionAction
   code: ErrorCode
   override name = 'SDKError'
   override cause: BaseError
 
-  constructor(cause: BaseError, step?: LiFiStep, process?: Process) {
+  constructor(cause: BaseError, step?: LiFiStep, action?: ExecutionAction) {
     const errorMessage = `${cause.message ? `[${cause.name}] ${cause.message}` : 'Unknown error occurred'}\nLI.FI SDK version: ${version}`
     super(errorMessage)
     this.name = 'SDKError'
     this.step = step
-    this.process = process
+    this.action = action
     this.cause = cause
     this.stack = this.cause.stack
     this.code = cause.code

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/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,16 +71,17 @@ export type {
   ContractCallParams,
   ContractTool,
   ExchangeRateUpdateParams,
+  ExecuteStepRetryParams,
   Execution,
+  ExecutionAction,
+  ExecutionActionStatus,
+  ExecutionActionType,
   ExecutionOptions,
   ExecutionStatus,
   GetContractCallsHook,
   GetContractCallsResult,
   InteractionSettings,
   LiFiStepExtended,
-  Process,
-  ProcessStatus,
-  ProcessType,
   RequestInterceptor,
   RouteExecutionData,
   RouteExecutionDataDictionary,
@@ -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
    */
@@ -204,7 +212,7 @@ export interface ExecutionOptions {
 
 export type ExecutionStatus = 'ACTION_REQUIRED' | 'PENDING' | 'FAILED' | 'DONE'
 
-export type ProcessStatus =
+export type ExecutionActionStatus =
   | 'STARTED'
   | 'ACTION_REQUIRED'
   | 'MESSAGE_REQUIRED'
@@ -214,43 +222,38 @@ export type ProcessStatus =
   | 'DONE'
   | 'CANCELLED'
 
-export type ProcessType =
-  | 'TOKEN_ALLOWANCE'
+export type ExecutionActionType =
   | 'PERMIT'
+  | 'CHECK_ALLOWANCE'
+  | 'NATIVE_PERMIT'
+  | 'RESET_ALLOWANCE'
+  | 'SET_ALLOWANCE'
   | 'SWAP'
   | 'CROSS_CHAIN'
   | 'RECEIVING_CHAIN'
 
-export type Process = {
-  type: ProcessType
-  status: ProcessStatus
+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
-  actionRequiredAt?: number
-  doneAt?: number
-  failedAt?: number
-  pendingAt?: number
-  startedAt: number
-  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 {
   startedAt: number
-  doneAt?: number
+  signedAt?: number
   status: ExecutionStatus
-  process: Array<Process>
+  actions: Array<ExecutionAction>
+  lastActionType?: ExecutionActionType
   fromAmount?: string
   toAmount?: string
   toToken?: Token
@@ -258,6 +261,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'

package/src/utils/waitForResult.ts

@@ -3,7 +3,7 @@ import { sleep } from './sleep.js'
 /**
  * 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
@@ -11,18 +11,22 @@ import { sleep } from './sleep.js'
  */
 export const waitForResult = async <T>(
   fn: () => Promise<T | undefined>,
-  interval = 5000,
+  interval: number | ((poll: number) => number) = 5000,
   maxRetries = 3,
   shouldRetry: (count: number, error: unknown) => boolean = () => true
 ): Promise<T> => {
   let result: T | undefined
   let attempts = 0
+  let polls = 0
+
+  const getInterval = typeof interval === 'function' ? interval : () => interval
 
   while (!result) {
     try {
       result = await fn()
       if (!result) {
-        await sleep(interval)
+        await sleep(getInterval(polls))
+        polls++
       }
     } catch (error) {
       if (!shouldRetry(attempts, error)) {
@@ -32,7 +36,8 @@ export const waitForResult = async <T>(
       if (attempts === maxRetries) {
         throw error
       }
-      await sleep(interval)
+      await sleep(getInterval(polls))
+      polls++
     }
   }
 

package/src/utils/withDedupe.ts

@@ -3,7 +3,7 @@
  *
  * https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
  */
-class LruMap<value = unknown> extends Map<string, value> {
+export class LruMap<value = unknown> extends Map<string, value> {
   maxSize: number
 
   constructor(size: number) {

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '4.0.0-alpha.8'
+export const version = '4.0.0-beta.0'

package/dist/cjs/core/checkBalance.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"checkBalance.js","sourceRoot":"","sources":["../../../src/core/checkBalance.ts"],"names":[],"mappings":";;;AACA,sEAA+D;AAC/D,mDAAkD;AAElD,4DAAqD;AACrD,gDAAyC;AAElC,MAAM,YAAY,GAAG,KAAK,EAC/B,MAAiB,EACjB,aAAqB,EACrB,IAAc,EACd,KAAK,GAAG,CAAC,EACM,EAAE;IACjB,MAAM,KAAK,GAAG,MAAM,IAAA,oCAAe,EACjC,MAAM,EACN,aAAa,EACb,IAAI,CAAC,MAAM,CAAC,SAAS,CACtB,CAAA;IACD,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,IAAI,EAAE,CAAA;QACzC,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;QAEpD,IAAI,cAAc,GAAG,aAAa,EAAE,CAAC;YACnC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;gBACf,MAAM,IAAA,gBAAK,EAAC,GAAG,CAAC,CAAA;gBAChB,MAAM,IAAA,oBAAY,EAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,KAAK,GAAG,CAAC,CAAC,CAAA;YAC5D,CAAC;iBAAM,IACL,CAAC,aAAa;gBACZ,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC;gBAC1D,WAAc;gBAChB,cAAc,EACd,CAAC;gBAED,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,cAAc,CAAC,QAAQ,EAAE,CAAA;YACpD,CAAC;iBAAM,CAAC;gBACN,MAAM,MAAM,GAAG,IAAA,4BAAW,EAAC,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;gBACzD,MAAM,OAAO,GAAG,IAAA,4BAAW,EAAC,cAAc,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;gBAC3D,IAAI,YAAY,GAAG,QAAQ,KAAK,CAAC,MAAM,4CAA4C,MAAM,IAAI,KAAK,CAAC,MAAM,gCAAgC,OAAO,IAAI,KAAK,CAAC,MAAM,4BAA4B,CAAA;gBAE5L,IAAI,cAAc,KAAK,EAAE,EAAE,CAAC;oBAC1B,YAAY,IAAI,8FAA8F,OAAO,IAAI,KAAK,CAAC,MAAM,GAAG,CAAA;gBAC1I,CAAC;gBAED,MAAM,IAAI,wBAAY,CACpB,yBAAyB,EACzB,IAAI,KAAK,CAAC,YAAY,CAAC,CACxB,CAAA;YACH,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC,CAAA;AA3CY,QAAA,YAAY,gBA2CxB"}

package/dist/cjs/core/processMessages.d.ts

@@ -1,4 +0,0 @@
-import type { StatusMessage, Substatus } from '@lifi/types';
-import type { ProcessStatus, ProcessType } from '../types/core.js';
-export declare function getProcessMessage(type: ProcessType, status: ProcessStatus): string | undefined;
-export declare function getSubstatusMessage(status: StatusMessage, substatus?: Substatus): string | undefined;

package/dist/cjs/core/processMessages.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"processMessages.js","sourceRoot":"","sources":["../../../src/core/processMessages.ts"],"names":[],"mappings":";;AAiEA,8CAMC;AAED,kDASC;AA/ED,MAAM,eAAe,GAGjB;IACF,eAAe,EAAE;QACf,OAAO,EAAE,yBAAyB;QAClC,eAAe,EAAE,qBAAqB;QACtC,cAAc,EAAE,2BAA2B;QAC3C,gBAAgB,EAAE,8BAA8B;QAChD,OAAO,EAAE,6BAA6B;QACtC,IAAI,EAAE,qBAAqB;KAC5B;IACD,IAAI,EAAE;QACJ,OAAO,EAAE,4BAA4B;QACrC,eAAe,EAAE,uBAAuB;QACxC,gBAAgB,EAAE,mBAAmB;QACrC,OAAO,EAAE,8BAA8B;QACvC,IAAI,EAAE,gBAAgB;KACvB;IACD,WAAW,EAAE;QACX,OAAO,EAAE,8BAA8B;QACvC,eAAe,EAAE,yBAAyB;QAC1C,gBAAgB,EAAE,qBAAqB;QACvC,OAAO,EAAE,gCAAgC;QACzC,IAAI,EAAE,8BAA8B;KACrC;IACD,eAAe,EAAE;QACf,OAAO,EAAE,+BAA+B;QACxC,IAAI,EAAE,kBAAkB;KACzB;IACD,MAAM,EAAE;QACN,OAAO,EAAE,uBAAuB;QAChC,eAAe,EAAE,qBAAqB;QACtC,OAAO,EAAE,4BAA4B;QACrC,IAAI,EAAE,uBAAuB;KAC9B;CACF,CAAA;AACD,MAAM,iBAAiB,GAGnB;IACF,OAAO,EAAE;QACP,oBAAoB,EAAE,kDAAkD;QACxE,mBAAmB,EAAE,+CAA+C;QACpE,aAAa,EACX,mFAAmF;QACrF,yBAAyB,EACvB,kHAAkH;QACpH,4BAA4B,EAC1B,4GAA4G;KAC/G;IACD,IAAI,EAAE;QACJ,OAAO,EACL,uEAAuE;QACzE,QAAQ,EAAE,iDAAiD;QAC3D,SAAS,EAAE,2BAA2B;KACvC;IACD,MAAM,EAAE,EAAE;IACV,OAAO,EAAE,EAAE;IACX,SAAS,EAAE,EAAE;CACd,CAAA;AAED,SAAgB,iBAAiB,CAC/B,IAAiB,EACjB,MAAqB;IAErB,MAAM,cAAc,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAA;IACpD,OAAO,cAAc,CAAA;AACvB,CAAC;AAED,SAAgB,mBAAmB,CACjC,MAAqB,EACrB,SAAqB;IAErB,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAM;IACR,CAAC;IACD,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAA;IACpD,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/dist/cjs/core/stepComparison.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stepComparison.js","sourceRoot":"","sources":["../../../src/core/stepComparison.ts"],"names":[],"mappings":";;;AACA,yDAAsD;AACtD,mDAAsD;AAGtD,yCAAuD;AAchD,MAAM,cAAc,GAAG,KAAK,EACjC,aAA4B,EAC5B,OAAiB,EACjB,OAAiB,EACjB,oBAA6B,EAC7B,gBAAmC,EAChB,EAAE;IAErB,IAAI,IAAA,qCAA0B,EAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;QACjD,OAAO,aAAa,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAA;IACjD,CAAC;IAED,IAAI,eAAoC,CAAA;IACxC,IAAI,oBAAoB,EAAE,CAAC;QACzB,eAAe,GAAG,MAAM,gBAAgB,EAAE,4BAA4B,EAAE,CAAC;YACvE,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,QAAQ;YACtC,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,QAAQ;YACtC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO;SAChC,CAAC,CAAA;IACJ,CAAC;IAED,IAAI,CAAC,eAAe,EAAE,CAAC;QAErB,MAAM,IAAI,4BAAgB,CACxB,4BAAa,CAAC,0BAA0B,EACxC,+LAA+L,CAChM,CAAA;IACH,CAAC;IAED,OAAO,aAAa,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAA;AACjD,CAAC,CAAA;AA9BY,QAAA,cAAc,kBA8B1B"}

package/dist/cjs/core/waitForDestinationChainTransaction.d.ts

@@ -1,4 +0,0 @@
-import type { ExtendedChain } from '@lifi/types';
-import type { LiFiStepExtended, Process, SDKClient } from '../types/core.js';
-import type { StatusManager } from './StatusManager.js';
-export declare function waitForDestinationChainTransaction(client: SDKClient, step: LiFiStepExtended, process: Process, fromChain: ExtendedChain, toChain: ExtendedChain, statusManager: StatusManager, pollingInterval?: number): Promise<LiFiStepExtended>;