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

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/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 {
@@ -246,6 +253,7 @@ export interface Execution {
   signedAt?: number
   status: ExecutionStatus
   actions: Array<ExecutionAction>
+  lastActionType?: ExecutionActionType
   fromAmount?: string
   toAmount?: string
   toToken?: Token
@@ -253,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.9'
+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/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 { ExecutionAction, LiFiStepExtended, SDKClient } from '../types/core.js';
-import type { StatusManager } from './StatusManager.js';
-export declare function waitForDestinationChainTransaction(client: SDKClient, step: LiFiStepExtended, action: ExecutionAction, fromChain: ExtendedChain, toChain: ExtendedChain, statusManager: StatusManager, pollingInterval?: number): Promise<LiFiStepExtended>;

package/dist/cjs/core/waitForDestinationChainTransaction.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForDestinationChainTransaction = waitForDestinationChainTransaction;
-const constants_js_1 = require("../errors/constants.js");
-const getTransactionMessage_js_1 = require("../utils/getTransactionMessage.js");
-const waitForTransactionStatus_js_1 = require("./waitForTransactionStatus.js");
-async function waitForDestinationChainTransaction(client, step, action, fromChain, toChain, statusManager, pollingInterval) {
-    const transactionHash = action.txHash || action.taskId;
-    let actionType = action.type;
-    try {
-        if (!transactionHash) {
-            throw new Error('Transaction hash is undefined.');
-        }
-        const isBridgeExecution = fromChain.id !== toChain.id;
-        if (isBridgeExecution) {
-            const receivingChainAction = statusManager.findOrCreateAction({
-                step,
-                type: 'RECEIVING_CHAIN',
-                status: 'PENDING',
-                chainId: toChain.id,
-            });
-            actionType = receivingChainAction.type;
-        }
-        step = statusManager.updateExecution(step, 'PENDING', {
-            signedAt: Date.now(),
-        });
-        const statusResponse = (await (0, waitForTransactionStatus_js_1.waitForTransactionStatus)(client, statusManager, transactionHash, step, actionType, pollingInterval));
-        const statusReceiving = statusResponse.receiving;
-        statusManager.updateAction(step, actionType, '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}`,
-        });
-        statusManager.updateExecution(step, '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 step;
-    }
-    catch (e) {
-        const htmlMessage = await (0, getTransactionMessage_js_1.getTransactionFailedMessage)(client, step, `${toChain.metamask.blockExplorerUrls[0]}tx/${transactionHash}`);
-        statusManager.updateAction(step, actionType, 'FAILED', {
-            error: {
-                code: constants_js_1.LiFiErrorCode.TransactionFailed,
-                message: 'Failed while waiting for status of destination chain transaction.',
-                htmlMessage,
-            },
-        });
-        throw e;
-    }
-}
-//# sourceMappingURL=waitForDestinationChainTransaction.js.map