@lifi/sdk 4.0.1-alpha.0 → 4.0.1

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

@@ -0,0 +1,218 @@
+import type { LiFiStep, Token, TokenAmount } from '@lifi/types'
+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 { withTimeout } from '../../../utils/withTimeout.js'
+
+const MAX_ATTEMPTS = 6
+// Exponential backoff: 150, 300, 600, 1200, 2400 → ≈4.65s of sleep total.
+const BACKOFF_BASE_MS = 150
+const OVERALL_TIMEOUT_MS = 10_000
+const SLIPPAGE_PRECISION = 1_000_000_000n
+
+type Bucket = 'source' | 'gas' | 'fee'
+
+type Requirement = {
+  token: Token
+  sourcePart: bigint // step.action.fromAmount
+  gasPart: bigint // step.estimate.gasCosts in this token
+  feePart: bigint // non-included step.estimate.feeCosts in this token
+}
+
+export type CheckBalanceOptions = {
+  /**
+   * Set to `false` when outer-tx gas is paid by something other than
+   * `walletAddress` (SCA executor, 4337 bundler / paymaster, relayer):
+   * `gasPart` is excluded from the sufficiency check and slippage rescue.
+   * Source amount and non-included fees (e.g. LZ `msg.value`) are still
+   * verified. Defaults to `true` (strict, today's behavior).
+   */
+  walletPaysGas?: boolean
+}
+
+/**
+ * Verifies that the wallet holds enough of every token required to execute
+ * the step on its source chain — the source-token amount, any gas costs, and
+ * any non-included fee costs. Reads all balances in one batched provider
+ * call, retries within a bounded budget to absorb transient RPC failures and
+ * post-confirmation propagation lag, and applies slippage to the source-token
+ * portion only as a last resort (overhead is never trimmed).
+ *
+ * Throws BalanceError("The balance is too low.") on a genuine shortfall, or
+ * BalanceError("Could not read wallet balance.") if the balance can't be read
+ * after retries.
+ */
+export const checkBalance = async (
+  client: SDKClient,
+  walletAddress: string,
+  step: LiFiStep,
+  options: CheckBalanceOptions = {}
+): Promise<void> => {
+  const fromChainId = step.action.fromChainId
+  // Chains with non-standard native decimals (e.g. Tempo, Stable) report
+  // gas costs in units that don't align with wallet balances — drop the
+  // gas portion of the check on those chains.
+  const fromChain = await client.getChainById(fromChainId)
+  const walletPaysGas =
+    (options.walletPaysGas ?? true) && !fromChain.nonStandardNativeDecimals
+  const requirements = new Map<string, Requirement>()
+  const add = (token: Token, amount: bigint, bucket: Bucket): void => {
+    if (token.chainId !== fromChainId || amount === 0n) {
+      return
+    }
+    const key = token.address.toLowerCase()
+    const req = requirements.get(key) ?? {
+      token,
+      sourcePart: 0n,
+      gasPart: 0n,
+      feePart: 0n,
+    }
+    if (bucket === 'source') {
+      req.sourcePart += amount
+    } else if (bucket === 'gas') {
+      req.gasPart += amount
+    } else {
+      req.feePart += amount
+    }
+    requirements.set(key, req)
+  }
+  add(step.action.fromToken, BigInt(step.action.fromAmount), 'source')
+  for (const gas of step.estimate?.gasCosts ?? []) {
+    add(gas.token, BigInt(gas.amount), 'gas')
+  }
+  for (const fee of step.estimate?.feeCosts ?? []) {
+    // Included fees are already part of fromAmount — don't count twice.
+    if (!fee.included) {
+      add(fee.token, BigInt(fee.amount), 'fee')
+    }
+  }
+
+  const reservedOverhead = (r: Requirement): bigint =>
+    r.feePart + (walletPaysGas ? r.gasPart : 0n)
+  const need = (r: Requirement): bigint => r.sourcePart + reservedOverhead(r)
+
+  // Drop pure-gas entries when `walletPaysGas` is false (e.g. native ETH
+  // on Safe Apps with only `gasPart`) — saves one balance read each.
+  for (const [key, req] of requirements) {
+    if (need(req) === 0n) {
+      requirements.delete(key)
+    }
+  }
+
+  if (requirements.size === 0) {
+    return
+  }
+
+  // Provider is dispatched by wallet address; all requirements share the
+  // source chain, which matches this provider by virtue of the address.
+  const provider = client.providers.find((p) => p.isAddress(walletAddress))
+  if (!provider) {
+    throw new Error(`SDK Token Provider for ${walletAddress} is not found.`)
+  }
+
+  const reqs = Array.from(requirements.values())
+  const tokens = reqs.map((r) => r.token)
+  const slippage = step.action.slippage ?? 0
+  const slippageScaled = BigInt(
+    Math.floor((1 - slippage) * Number(SLIPPAGE_PRECISION))
+  )
+
+  await withTimeout(
+    async () => {
+      for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        const isFinal = attempt === MAX_ATTEMPTS - 1
+
+        let balances: TokenAmount[]
+        try {
+          balances = await provider.getBalance(client, walletAddress, tokens)
+        } catch (error) {
+          if (isFinal) {
+            throw new BalanceError(
+              'Could not read wallet balance.',
+              error as Error
+            )
+          }
+          await sleep(BACKOFF_BASE_MS * 2 ** attempt)
+          continue
+        }
+
+        const balanceByAddress = new Map(
+          balances.map((b) => [b.address.toLowerCase(), b.amount] as const)
+        )
+
+        const unknown: Token[] = []
+        const insufficient: { req: Requirement; have: bigint }[] = []
+        for (const req of reqs) {
+          const have = balanceByAddress.get(req.token.address.toLowerCase())
+          if (have === undefined) {
+            unknown.push(req.token)
+          } else if (have < need(req)) {
+            insufficient.push({ req, have })
+          }
+        }
+
+        if (unknown.length === 0 && insufficient.length === 0) {
+          return
+        }
+
+        // Final-attempt slippage rescue: only when the sole shortfall is
+        // the source-token portion. Trim source to (balance − reserved
+        // overhead) so the overhead reserve is preserved.
+        if (
+          isFinal &&
+          unknown.length === 0 &&
+          insufficient.length === 1 &&
+          insufficient[0].req.sourcePart > 0n
+        ) {
+          const { req, have } = insufficient[0]
+          const reserved = reservedOverhead(req)
+          const minAcceptable =
+            (req.sourcePart * slippageScaled) / SLIPPAGE_PRECISION + reserved
+          if (have >= minAcceptable) {
+            const newFromAmount = (have - reserved).toString()
+            step.action.fromAmount = newFromAmount
+            if (step.includedSteps?.length) {
+              step.includedSteps[0].action.fromAmount = newFromAmount
+            }
+            return
+          }
+        }
+
+        if (isFinal) {
+          if (unknown.length > 0) {
+            throw new BalanceError(
+              'Could not read wallet balance.',
+              new Error(
+                `Could not read balance for: ${unknown
+                  .map((t) => t.symbol || t.address)
+                  .join(', ')}.`
+              )
+            )
+          }
+          const lines = insufficient.map(({ req, have }) => {
+            const needed = formatUnits(need(req), req.token.decimals)
+            const current = formatUnits(have, req.token.decimals)
+            const symbol = req.token.symbol
+            // The "fees" branch covers pure-overhead tokens; with
+            // walletPaysGas=false, gas is excluded from `need(req)` so it
+            // only fires for genuine fee shortfalls.
+            return req.sourcePart > 0n
+              ? `Your ${symbol} balance is too low, you try to transfer ${needed} ${symbol}, but your wallet only holds ${current} ${symbol}.`
+              : `Insufficient ${symbol} for fees: need ${needed} ${symbol}, have ${current} ${symbol}.`
+          })
+          throw new BalanceError(
+            'The balance is too low.',
+            new Error(`${lines.join(' ')} No funds have been sent.`)
+          )
+        }
+
+        await sleep(BACKOFF_BASE_MS * 2 ** attempt)
+      }
+    },
+    {
+      timeout: OVERALL_TIMEOUT_MS,
+      errorInstance: new BalanceError('Could not read wallet balance.'),
+    }
+  )
+}

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>> = {}
 
@@ -23,6 +23,7 @@ export async function waitForTransactionStatus(
       toChain: step.action.toChainId,
       txHash,
       ...(step.tool !== 'custom' && { bridge: step.tool }),
+      ...(step.transactionId && { transactionId: step.transactionId }),
     })
       .then((statusResponse) => {
         switch (statusResponse.status) {
@@ -57,7 +58,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/core/utils.ts

@@ -34,7 +34,7 @@ export function getRpcUrlsFromChains(
   existingRpcUrls: RPCUrls,
   chains: ExtendedChain[],
   skipChains?: ChainId[]
-) {
+): RPCUrls {
   const rpcUrlsFromChains = chains.reduce((rpcUrls, chain) => {
     if (chain.metamask?.rpcUrls?.length) {
       rpcUrls[chain.id as ChainId] = chain.metamask.rpcUrls

package/src/errors/constants.ts

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

package/src/errors/errors.ts

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

package/src/errors/httpError.ts

@@ -74,7 +74,7 @@ export class HTTPError extends BaseError {
     this.fetchOptions = options
   }
 
-  async buildAdditionalDetails() {
+  async buildAdditionalDetails(): Promise<void> {
     if (this.type) {
       this.message = `[${this.type}] ${this.message}`
     }
@@ -82,13 +82,11 @@ export class HTTPError extends BaseError {
     try {
       this.responseBody = await this.response.json()
 
-      if (this.responseBody) {
+      if (this.responseBody?.message) {
         this.message += this.message.endsWith('.')
-          ? ` ${this.responseBody?.message.toString()}`
-          : `. ${this.responseBody?.message.toString()}`
+          ? ` ${this.responseBody.message.toString()}`
+          : `. ${this.responseBody.message.toString()}`
       }
     } catch {}
-
-    return this
   }
 }

package/src/errors/utils/baseErrorRootCause.ts

@@ -1,7 +1,7 @@
 import { BaseError } from '../baseError.js'
 import { HTTPError } from '../httpError.js'
 
-export const getRootCauseBaseError = (e: Error) => {
+export const getRootCauseBaseError = (e: Error): BaseError => {
   let rootCause = e
   while (rootCause.cause && rootCause.cause instanceof BaseError) {
     rootCause = rootCause.cause as BaseError
@@ -9,7 +9,7 @@ export const getRootCauseBaseError = (e: Error) => {
   return rootCause as BaseError
 }
 
-export const getRootCauseBaseErrorMessage = (e: Error) => {
+export const getRootCauseBaseErrorMessage = (e: Error): string => {
   const rootCause = getRootCauseBaseError(e)
 
   return rootCause instanceof HTTPError

package/src/errors/utils/rootCause.ts

@@ -1,4 +1,4 @@
-export const getRootCause = (e: Error | undefined) => {
+export const getRootCause = (e: Error | undefined): Error | undefined => {
   let rootCause = e
   while (rootCause?.cause) {
     rootCause = rootCause.cause as Error

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,28 @@ 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 {
+  type CheckBalanceOptions,
+  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 +74,7 @@ export type {
   ContractCallParams,
   ContractTool,
   ExchangeRateUpdateParams,
+  ExecuteStepRetryParams,
   Execution,
   ExecutionAction,
   ExecutionActionStatus,
@@ -87,6 +104,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 +118,5 @@ 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'
+export { withTimeout } from './utils/withTimeout.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,10 +35,12 @@ export interface SDKBaseConfig {
   preloadChains?: boolean
   chainsRefetchInterval?: number
   requestInterceptor?: RequestInterceptor
+  storage?: SDKStorage
 }
 
 export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {
   integrator: string
+  providers?: SDKProvider[]
 }
 
 export type RPCUrls = Partial<Record<ChainId, string[]>>
@@ -82,13 +85,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,11 +205,6 @@ export interface ExecutionOptions {
   getContractCalls?: GetContractCallsHook
   adjustZeroOutputFromPreviousStep?: boolean
   executeInBackground?: boolean
-  disableMessageSigning?: boolean
-  /**
-   * @deprecated
-   */
-  infiniteApproval?: boolean
 }
 
 export type ExecutionStatus = 'ACTION_REQUIRED' | 'PENDING' | 'FAILED' | 'DONE'
@@ -215,8 +220,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 +232,17 @@ export type ExecutionActionType =
 export type ExecutionAction = {
   type: ExecutionActionType
   status: ExecutionActionStatus
+  message?: string
   substatus?: Substatus
+  substatusMessage?: string
   chainId?: number
   txHash?: string
-  taskId?: string
   txLink?: string
+  taskId?: string
   txType?: TransactionMethodType
-  message?: string
-  error?: {
-    code: string | number
-    message: string
-    htmlMessage?: string
-  }
-
-  // additional information
-  [key: string]: any
+  txHex?: string
+  // Errors occured during the action execution (within tasks)
+  error?: { code: string | number; message: string; htmlMessage?: string }
 }
 
 export interface Execution {
@@ -253,6 +257,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/checkPackageUpdates.ts

@@ -3,7 +3,7 @@ import { name, version } from '../version.js'
 export const checkPackageUpdates = async (
   packageName?: string,
   packageVersion?: string
-) => {
+): Promise<void> => {
   try {
     const pkgName = packageName ?? name
     const response = await fetch(`https://registry.npmjs.org/${pkgName}/latest`)

package/src/utils/convertQuoteToRoute.ts

@@ -64,7 +64,7 @@ export function formatTokenPrice(
   amount?: string | bigint,
   price?: string,
   decimals?: number
-) {
+): number {
   if (!amount || !price) {
     return 0
   }

package/src/utils/decode.ts

@@ -1,4 +1,4 @@
-export const decodeTaskId = (taskId: string) => {
+export const decodeTaskId = (taskId: string): string[] => {
   const decoded = new TextDecoder()
     .decode(
       new Uint8Array(

package/src/utils/fetchTxErrorDetails.ts

@@ -1,4 +1,7 @@
-export const fetchTxErrorDetails = async (txHash: string, chainId: number) => {
+export const fetchTxErrorDetails = async (
+  txHash: string,
+  chainId: number
+): Promise<unknown> => {
   try {
     const response = await fetch(
       `https://api.tenderly.co/api/v1/public-contract/${chainId}/tx/${txHash}`
@@ -6,5 +9,7 @@ export const fetchTxErrorDetails = async (txHash: string, chainId: number) => {
     const reponseBody = await response.json()
 
     return reponseBody
-  } catch (_) {}
+  } catch (_) {
+    return undefined
+  }
 }