@lifi/sdk 3.16.2 → 3.17.0-beta.0

package/src/core/checkBalance.ts

@@ -1,45 +1,177 @@
-import type { LiFiStep } from '@lifi/types'
-import { formatUnits } from 'viem'
+import type { LiFiStep, Token, TokenAmount } from '@lifi/types'
+import { formatUnits, withTimeout } from 'viem'
+import { config } from '../config.js'
 import { BalanceError } from '../errors/errors.js'
-import { getTokenBalance } from '../services/balance.js'
 import { sleep } from '../utils/sleep.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 Requirement = {
+  token: Token
+  sourcePart: bigint // 0n for pure overhead tokens
+  overheadPart: bigint // gas + non-included fees in this token
+}
+
+/**
+ * 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 (
   walletAddress: string,
-  step: LiFiStep,
-  depth = 0
+  step: LiFiStep
 ): Promise<void> => {
-  const token = await getTokenBalance(walletAddress, step.action.fromToken)
-  if (token) {
-    const currentBalance = token.amount ?? 0n
-    const neededBalance = BigInt(step.action.fromAmount)
-
-    if (currentBalance < neededBalance) {
-      if (depth <= 3) {
-        await sleep(200)
-        await checkBalance(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}.`
+  const fromChainId = step.action.fromChainId
+  const requirements = new Map<string, Requirement>()
+  const add = (token: Token, amount: bigint, source: boolean): void => {
+    if (token.chainId !== fromChainId || amount === 0n) {
+      return
+    }
+    const key = token.address.toLowerCase()
+    const req = requirements.get(key) ?? {
+      token,
+      sourcePart: 0n,
+      overheadPart: 0n,
+    }
+    if (source) {
+      req.sourcePart += amount
+    } else {
+      req.overheadPart += amount
+    }
+    requirements.set(key, req)
+  }
+  add(step.action.fromToken, BigInt(step.action.fromAmount), true)
+  for (const gas of step.estimate?.gasCosts ?? []) {
+    add(gas.token, BigInt(gas.amount), false)
+  }
+  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), false)
+    }
+  }
+  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 = config
+    .get()
+    .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(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 < req.sourcePart + req.overheadPart) {
+            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 down to (balance − 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 minAcceptable =
+            (req.sourcePart * slippageScaled) / SLIPPAGE_PRECISION +
+            req.overheadPart
+          if (have >= minAcceptable) {
+            step.action.fromAmount = (have - req.overheadPart).toString()
+            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(
+              req.sourcePart + req.overheadPart,
+              req.token.decimals
+            )
+            const current = formatUnits(have, req.token.decimals)
+            const symbol = req.token.symbol
+            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/services/api.ts

@@ -503,7 +503,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]
       }
     }
@@ -544,7 +545,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]
       }
     }
@@ -611,7 +613,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/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.16.2'
+export const version = '3.17.0-beta.0'