@lifi/sdk 4.0.0-beta.1 → 4.0.0-beta.10

package/dist/esm/utils/withTimeout.js

@@ -0,0 +1,34 @@
+//#region src/utils/withTimeout.ts
+/**
+* Wraps a function in a timeout.
+* Based on viem's withTimeout implementation.
+* @param fn - The function to wrap.
+* @param timeout - The timeout in milliseconds.
+* @param errorInstance - The error instance to throw when the timeout is reached.
+* @param signal - Whether or not the timeout should use an abort signal.
+* @returns The result of the function.
+*/
+function withTimeout(fn, { errorInstance = /* @__PURE__ */ new Error("Timed out after waiting for too long."), timeout, signal }) {
+	return new Promise((resolve, reject) => {
+		(async () => {
+			let timeoutId;
+			try {
+				const controller = new AbortController();
+				if (timeout > 0) timeoutId = setTimeout(() => {
+					if (signal) controller.abort();
+					else reject(errorInstance);
+				}, timeout);
+				resolve(await fn({ signal: controller?.signal || null }));
+			} catch (err) {
+				if (err?.name === "AbortError") reject(errorInstance);
+				reject(err);
+			} finally {
+				clearTimeout(timeoutId);
+			}
+		})();
+	});
+}
+//#endregion
+export { withTimeout };
+
+//# sourceMappingURL=withTimeout.js.map

package/dist/esm/utils/withTimeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withTimeout.js","names":[],"sources":["../../../src/utils/withTimeout.ts"],"sourcesContent":["/**\n * Wraps a function in a timeout.\n * Based on viem's withTimeout implementation.\n * @param fn - The function to wrap.\n * @param timeout - The timeout in milliseconds.\n * @param errorInstance - The error instance to throw when the timeout is reached.\n * @param signal - Whether or not the timeout should use an abort signal.\n * @returns The result of the function.\n */\nexport function withTimeout<T>(\n  fn: ({ signal }: { signal: AbortController['signal'] | null }) => Promise<T>,\n  {\n    errorInstance = new Error('Timed out after waiting for too long.'),\n    timeout,\n    signal,\n  }: {\n    // The error instance to throw when the timeout is reached.\n    errorInstance?: Error | undefined\n    // The timeout (in ms).\n    timeout: number\n    // Whether or not the timeout should use an abort signal.\n    signal?: boolean | undefined\n  }\n): Promise<T> {\n  return new Promise((resolve, reject) => {\n    ;(async () => {\n      let timeoutId!: NodeJS.Timeout\n      try {\n        const controller = new AbortController()\n        if (timeout > 0) {\n          timeoutId = setTimeout(() => {\n            if (signal) {\n              controller.abort()\n            } else {\n              reject(errorInstance)\n            }\n          }, timeout) as NodeJS.Timeout // need to cast because bun globals.d.ts overrides @types/node\n        }\n        resolve(await fn({ signal: controller?.signal || null }))\n      } catch (err) {\n        if ((err as Error)?.name === 'AbortError') {\n          reject(errorInstance)\n        }\n        reject(err)\n      } finally {\n        clearTimeout(timeoutId)\n      }\n    })()\n  })\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,YACd,IACA,EACE,gCAAgB,IAAI,MAAM,wCAAwC,EAClE,SACA,UASU;CACZ,OAAO,IAAI,SAAS,SAAS,WAAW;EACrC,CAAC,YAAY;GACZ,IAAI;GACJ,IAAI;IACF,MAAM,aAAa,IAAI,iBAAiB;IACxC,IAAI,UAAU,GACZ,YAAY,iBAAiB;KAC3B,IAAI,QACF,WAAW,OAAO;UAElB,OAAO,cAAc;OAEtB,QAAQ;IAEb,QAAQ,MAAM,GAAG,EAAE,QAAQ,YAAY,UAAU,MAAM,CAAC,CAAC;YAClD,KAAK;IACZ,IAAK,KAAe,SAAS,cAC3B,OAAO,cAAc;IAEvB,OAAO,IAAI;aACH;IACR,aAAa,UAAU;;MAEvB;GACJ"}

package/dist/esm/version.d.ts

@@ -1,2 +1,6 @@
-export declare const name = "@lifi/sdk";
-export declare const version = "4.0.0-beta.1";
+//#region src/version.d.ts
+declare const name = "@lifi/sdk";
+declare const version = "4.0.0-beta.10";
+//#endregion
+export { name, version };
+//# sourceMappingURL=version.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","names":[],"sources":["../../src/version.ts"],"mappings":";cAAa,IAAA;AAAA,cACA,OAAA"}

package/dist/esm/version.js

@@ -1,3 +1,7 @@
-export const name = '@lifi/sdk';
-export const version = '4.0.0-beta.1';
+//#region src/version.ts
+const name = "@lifi/sdk";
+const version = "4.0.0-beta.10";
+//#endregion
+export { name, version };
+
 //# sourceMappingURL=version.js.map

package/dist/esm/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,IAAI,GAAG,WAAW,CAAA;AAC/B,MAAM,CAAC,MAAM,OAAO,GAAG,cAAc,CAAA"}
+{"version":3,"file":"version.js","names":[],"sources":["../../src/version.ts"],"sourcesContent":["export const name = '@lifi/sdk'\nexport const version = '4.0.0-beta.10'\n"],"mappings":";AAAA,MAAa,OAAO;AACpB,MAAa,UAAU"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/sdk",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.10",
   "description": "LI.FI SDK for Any-to-Any Cross-Chain-Swap",
   "homepage": "https://github.com/lifinance/sdk",
   "bugs": {
@@ -17,18 +17,18 @@
   "sideEffects": false,
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
-  "types": "./dist/types/index.d.ts",
-  "typings": "./dist/types/index.d.ts",
+  "types": "./dist/esm/index.d.ts",
+  "typings": "./dist/esm/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
+      "types": "./dist/esm/index.d.ts",
       "import": "./dist/esm/index.js",
       "default": "./dist/cjs/index.js"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@lifi/types": "^17.67.1"
+    "@lifi/types": "17.80.0"
   },
   "publishConfig": {
     "access": "public"

package/src/actions/getChains.ts

@@ -31,7 +31,8 @@ export const _getChains = async (
 ): Promise<ExtendedChain[]> => {
   if (params) {
     for (const key of Object.keys(params)) {
-      if (!params[key as keyof ChainsRequest]) {
+      const value = params[key as keyof ChainsRequest]
+      if (value === undefined || value === null) {
         delete params[key as keyof ChainsRequest]
       }
     }

package/src/actions/getTokens.ts

@@ -32,7 +32,8 @@ export async function getTokens(
 ): Promise<TokensResponse> {
   if (params) {
     for (const key of Object.keys(params)) {
-      if (!params[key as keyof TokensRequest]) {
+      const value = params[key as keyof TokensRequest]
+      if (value === undefined || value === null) {
         delete params[key as keyof TokensRequest]
       }
     }

package/src/actions/getTools.ts

@@ -16,7 +16,8 @@ export const getTools = async (
 ): Promise<ToolsResponse> => {
   if (params) {
     for (const key of Object.keys(params)) {
-      if (!params[key as keyof ToolsRequest]) {
+      const value = params[key as keyof ToolsRequest]
+      if (value === undefined || value === null) {
         delete params[key as keyof ToolsRequest]
       }
     }

package/src/client/createClient.ts

@@ -20,16 +20,18 @@ export function createClient(options: SDKConfig): SDKClient {
     checkPackageUpdates(name, version)
   }
 
+  const { providers, ...configOptions } = options
+
   const _config: SDKBaseConfig = {
-    ...options,
-    apiUrl: options?.apiUrl ?? 'https://li.quest/v1',
-    rpcUrls: options?.rpcUrls ?? {},
-    debug: options?.debug ?? false,
-    preloadChains: options?.preloadChains ?? true,
-    integrator: options?.integrator ?? 'lifi-sdk',
+    ...configOptions,
+    apiUrl: configOptions?.apiUrl ?? 'https://li.quest/v1',
+    rpcUrls: configOptions?.rpcUrls ?? {},
+    debug: configOptions?.debug ?? false,
+    preloadChains: configOptions?.preloadChains ?? true,
+    integrator: configOptions?.integrator ?? 'lifi-sdk',
   }
 
-  let _providers: SDKProvider[] = []
+  let _providers: SDKProvider[] = providers ?? []
   const _storage = getClientStorage(_config)
 
   const client: SDKClient = {

package/src/client/getClientStorage.ts

@@ -6,7 +6,14 @@ import type { RPCUrls, SDKBaseConfig } from '../types/core.js'
 // 6 hours in milliseconds
 const chainsRefreshInterval = 1000 * 60 * 60 * 6
 
-export const getClientStorage = (config: SDKBaseConfig) => {
+export interface ClientStorage {
+  readonly needReset: boolean
+  setChains(chains: ExtendedChain[]): void
+  getChains(): Promise<ExtendedChain[]>
+  getRpcUrls(): Promise<RPCUrls>
+}
+
+export const getClientStorage = (config: SDKBaseConfig): ClientStorage => {
   let _chains = [] as ExtendedChain[]
   let _rpcUrls = { ...config.rpcUrls } as RPCUrls
   let _chainsUpdatedAt: number | undefined
@@ -42,6 +49,7 @@ export const getClientStorage = (config: SDKBaseConfig) => {
             ChainType.SVM,
             ChainType.UTXO,
             ChainType.MVM,
+            ChainType.TVM,
           ],
         })
         _chainsUpdatedAt = Date.now()

package/src/core/prepareRestart.ts

@@ -1,6 +1,6 @@
 import type { RouteExtended } from '../types/core.js'
 
-export const prepareRestart = (route: RouteExtended) => {
+export const prepareRestart = (route: RouteExtended): void => {
   for (let index = 0; index < route.steps.length; index++) {
     const step = route.steps[index]
     if (step.execution) {

package/src/core/tasks/CheckBalanceTask.ts

@@ -2,9 +2,25 @@ 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 { checkBalance } from './helpers/checkBalance.js'
+import {
+  type CheckBalanceOptions,
+  checkBalance,
+} from './helpers/checkBalance.js'
 
 export class CheckBalanceTask extends BaseStepExecutionTask {
+  /**
+   * Per-step options hook for chain-specific subclasses (e.g. skip the
+   * gas check for smart-contract wallets or relayed steps). Default `{}`
+   * keeps behavior unchanged for every provider that doesn't override.
+   * Resolved lazily inside `run()` — pipelines that resume past
+   * `CheckBalance` pay no cost.
+   */
+  protected getCheckBalanceOptions(
+    _context: StepExecutorContext
+  ): Promise<CheckBalanceOptions> {
+    return Promise.resolve({})
+  }
+
   async run(context: StepExecutorContext): Promise<TaskResult> {
     const { client, step, statusManager, isBridgeExecution } = context
 
@@ -23,7 +39,8 @@ export class CheckBalanceTask extends BaseStepExecutionTask {
       )
     }
 
-    await checkBalance(client, walletAddress, step)
+    const options = await this.getCheckBalanceOptions(context)
+    await checkBalance(client, walletAddress, step, options)
     return { status: 'COMPLETED' }
   }
 }

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

@@ -1,51 +1,213 @@
-import type { LiFiStep } from '@lifi/types'
-import { getTokenBalance } from '../../../actions/getTokenBalance.js'
+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,
-  depth = 0
+  options: CheckBalanceOptions = {}
 ): Promise<void> => {
-  const token = await getTokenBalance(
-    client,
-    walletAddress,
-    step.action.fromToken
+  const walletPaysGas = options.walletPaysGas ?? true
+  const fromChainId = step.action.fromChainId
+  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))
   )
-  if (token) {
-    const currentBalance = token.amount ?? 0n
-    const neededBalance = BigInt(step.action.fromAmount)
-
-    if (currentBalance < neededBalance) {
-      if (depth <= 3) {
-        await sleep(200)
-        await checkBalance(client, walletAddress, step, depth + 1)
-      } else if (
-        (neededBalance *
-          BigInt((1 - (step.action.slippage ?? 0)) * 1_000_000_000)) /
-          1_000_000_000n <=
-        currentBalance
-      ) {
-        // adjust amount in slippage limits
-        step.action.fromAmount = currentBalance.toString()
-      } else {
-        const needed = formatUnits(neededBalance, token.decimals)
-        const current = formatUnits(currentBalance, token.decimals)
-        let errorMessage = `Your ${token.symbol} balance is too low, you try to transfer ${needed} ${token.symbol}, but your wallet only holds ${current} ${token.symbol}. No funds have been sent.`
-
-        if (currentBalance !== 0n) {
-          errorMessage += `If the problem consists, please delete this transfer and start a new one with a maximum of ${current} ${token.symbol}.`
+
+  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
         }
 
-        throw new BalanceError(
-          'The balance is too low.',
-          new Error(errorMessage)
+        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/waitForTransactionStatus.ts

@@ -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) {

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/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}`
     }
@@ -88,7 +88,5 @@ export class HTTPError extends BaseError {
           : `. ${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

@@ -44,7 +44,10 @@ export {
 } 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 {
+  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'
@@ -116,3 +119,4 @@ export { parseUnits } from './utils/parseUnits.js'
 export { sleep } from './utils/sleep.js'
 export { waitForResult } from './utils/waitForResult.js'
 export { LruMap, withDedupe } from './utils/withDedupe.js'
+export { withTimeout } from './utils/withTimeout.js'

package/src/types/core.ts

@@ -40,6 +40,7 @@ export interface SDKBaseConfig {
 
 export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {
   integrator: string
+  providers?: SDKProvider[]
 }
 
 export type RPCUrls = Partial<Record<ChainId, string[]>>
@@ -204,10 +205,6 @@ export interface ExecutionOptions {
   getContractCalls?: GetContractCallsHook
   adjustZeroOutputFromPreviousStep?: boolean
   executeInBackground?: boolean
-  /**
-   * @deprecated
-   */
-  infiniteApproval?: boolean
 }
 
 export type ExecutionStatus = 'ACTION_REQUIRED' | 'PENDING' | 'FAILED' | 'DONE'

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

package/src/utils/formatUnits.ts

@@ -1,7 +1,7 @@
 /**
  *  Divides a number by a given exponent of base 10 (10exponent), and formats it into a string representation of the number.
  */
-export function formatUnits(value: bigint, decimals: number) {
+export function formatUnits(value: bigint, decimals: number): string {
   let display = value.toString()
 
   const negative = display.startsWith('-')

package/src/utils/parseUnits.ts

@@ -1,7 +1,7 @@
 /**
  * Multiplies a string representation of a number by a given exponent of base 10 (10exponent).
  */
-export function parseUnits(value: string, decimals: number) {
+export function parseUnits(value: string, decimals: number): bigint {
   if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value)) {
     throw new Error(`Number \`${value}\` is not a valid decimal number.`)
   }

package/src/utils/withDedupe.ts

@@ -11,7 +11,7 @@ export class LruMap<value = unknown> extends Map<string, value> {
     this.maxSize = size
   }
 
-  override set(key: string, value: value) {
+  override set(key: string, value: value): this {
     super.set(key, value)
     if (this.maxSize && this.size > this.maxSize) {
       this.delete(this.keys().next().value!)