@exodus/solana-api 3.30.2 → 3.30.3

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.30.3](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.30.2...@exodus/solana-api@3.30.3) (2026-03-20)
+
+
+### Bug Fixes
+
+
+* fix: solana zero balance on restore under transient Clarity/RPC failures (#7628)
+
+
+
 ## [3.30.2](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.30.1...@exodus/solana-api@3.30.2) (2026-03-18)
 
 **Note:** Version bump only for package @exodus/solana-api

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.30.2",
+  "version": "3.30.3",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Solana",
   "type": "module",
   "main": "src/index.js",
@@ -49,7 +49,7 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "e746a88ef78a0e7167587bfa14068ceb494d6fd7",
+  "gitHead": "f1f7c3ad9d55f774c9c6a09434139d46f605e43c",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/api.js

@@ -215,13 +215,23 @@ export class Api {
     try {
       const until = cursor
 
-      const tokenAccountsByOwner = tokenAccounts || (await this.getTokenAccountsByOwner(address)) // Array
+      let tokenAccountsByOwner
+      try {
+        tokenAccountsByOwner = tokenAccounts || (await this.getTokenAccountsByOwner(address))
+      } catch (err) {
+        console.warn('Solana getTokenAccountsByOwner failed, continuing with main address only', {
+          address,
+          error: err,
+        })
+        tokenAccountsByOwner = []
+      }
+
       const tokenAccountAddresses = tokenAccountsByOwner
         .filter(({ tokenName }) => tokenName !== 'unknown')
         .map(({ tokenAccountAddress }) => tokenAccountAddress)
       const accountsToCheck = [address, ...tokenAccountAddresses]
 
-      const txsResultsByAccount = await Promise.all(
+      const signatureSettled = await Promise.allSettled(
         accountsToCheck.map((addr) =>
           this.getSignaturesForAddress(addr, {
             until,
@@ -230,14 +240,32 @@ export class Api {
           })
         )
       )
+      const txsResultsByAccount = signatureSettled.map((result, index) => {
+        if (result.status === 'fulfilled') return result.value
+        console.warn('Solana getSignaturesForAddress failed', {
+          address: accountsToCheck[index],
+          error: result.reason,
+        })
+        return []
+      })
       let txsId = txsResultsByAccount.flat() // merge arrays
       txsId = lodash.uniqBy(txsId, 'signature')
 
-      // get txs details with concurrency limit to avoid overwhelming the RPC server
+      // Per-tx fetch: one failure must not drop the whole page. Concurrency still capped.
       const fetchWithLimit = makeConcurrent((signature) => this.getTransactionById(signature), {
         concurrency: TX_DETAIL_FETCH_CONCURRENCY,
       })
-      const txsDetails = await Promise.all(txsId.map((tx) => fetchWithLimit(tx.signature)))
+      const txsDetails = await Promise.all(
+        txsId.map((tx) =>
+          fetchWithLimit(tx.signature).catch((error) => {
+            console.warn('Solana getTransactionById failed', {
+              signature: tx.signature,
+              error,
+            })
+            return null
+          })
+        )
+      )
       txsDetails.forEach((txDetail) => {
         if (!txDetail) return
 

package/src/tx-log/clarity-monitor.js

@@ -1,5 +1,6 @@
 import { BaseMonitor } from '@exodus/asset-lib'
 import { mapValues, pickBy } from '@exodus/basic-utils'
+import { retry } from '@exodus/simple-retry'
 import lodash from 'lodash'
 import assert from 'minimalistic-assert'
 import ms from 'ms'
@@ -88,6 +89,33 @@ export class SolanaClarityMonitor extends BaseMonitor {
     )
   }
 
+  #normalizeAccountInfoPayload(accountInfo) {
+    if (!accountInfo) return accountInfo
+    const inner = accountInfo.value
+    if (!inner || typeof inner !== 'object') return accountInfo
+    return {
+      ...accountInfo,
+      lamports: accountInfo.lamports ?? inner.lamports,
+      space: accountInfo.space ?? inner.space,
+      owner: accountInfo.owner ?? inner.owner,
+    }
+  }
+
+  async #fetchAccountInfoWithRetry(address) {
+    const fetchRetry = retry(() => this.clarityApi.getAccountInfo(address), {
+      delayTimesMs: ['200ms', '400ms', '800ms'],
+    })
+
+    try {
+      return await fetchRetry()
+    } catch (error) {
+      console.warn('SolanaClarityMonitor getAccountInfo failed after retries', {
+        address,
+        error,
+      })
+    }
+  }
+
   async markStaleTransactions({ walletAccount, logItemsByAsset = Object.create(null) }) {
     // mark stale txs as dropped in logItemsByAsset
     const clearedLogItems = logItemsByAsset
@@ -137,85 +165,81 @@ export class SolanaClarityMonitor extends BaseMonitor {
       refresh || isHistoryUpdateTick || balanceChanged || hasUnconfirmedSentTx
     const shouldUpdateOnlyBalance = balanceChanged && !shouldUpdateLatestHistory
 
-    // start a batch
     const batch = this.aci.createOperationsBatch()
-    // getHistory is more likely to fail/be rate limited, so we want to update users balance only on a lot of ticks
-    if (this.shouldUpdateBalanceBeforeHistory || shouldUpdateOnlyBalance) {
-      // update all state at once
-      this.updateState({ account, walletAccount, staking, batch })
-      await this.emitUnknownTokensEvent({ tokenAccounts })
-    }
+    try {
+      if (this.shouldUpdateBalanceBeforeHistory || shouldUpdateOnlyBalance) {
+        this.updateState({ account, walletAccount, staking, batch })
+        await this.emitUnknownTokensEvent({ tokenAccounts })
+      }
 
-    const newCursorState = {
-      cursor: accountState.cursor,
-      historyCursor: accountState.historyCursor,
-    }
+      const newCursorState = {
+        cursor: accountState.cursor,
+        historyCursor: accountState.historyCursor,
+      }
 
-    const newTransactions = []
+      const newTransactions = []
 
-    if (shouldUpdateLatestHistory) {
-      const { transactions: latestTransactions, cursorState: latestHistoryCursorState } =
-        await this.getLatestHistory({
-          address,
-          accountState,
-          walletAccount,
-          refresh,
-          tokenAccounts,
-        })
+      if (shouldUpdateLatestHistory) {
+        const { transactions: latestTransactions, cursorState: latestHistoryCursorState } =
+          await this.getLatestHistory({
+            address,
+            accountState,
+            walletAccount,
+            refresh,
+            tokenAccounts,
+          })
 
-      if (latestHistoryCursorState.cursor) {
-        newCursorState.cursor = latestHistoryCursorState.cursor
-      }
+        if (latestHistoryCursorState.cursor) {
+          newCursorState.cursor = latestHistoryCursorState.cursor
+        }
+
+        if (latestHistoryCursorState.historyCursor) {
+          newCursorState.historyCursor = latestHistoryCursorState.historyCursor
+        }
 
-      if (latestHistoryCursorState.historyCursor) {
-        // refresh case will have historyCursor available
-        // but if user has 0 txs, it won't be available, therefore need to check
-        newCursorState.historyCursor = latestHistoryCursorState.historyCursor
+        newTransactions.push(...latestTransactions)
       }
 
-      newTransactions.push(...latestTransactions)
-    }
+      const shouldFetchOldHistory = !refresh && newCursorState.historyCursor // on refresh request, wait until next tick to fetch old history
+      if (shouldFetchOldHistory) {
+        const { transactions: historyTransactions, historyCursor } = await this.fetchOldHistory({
+          address,
+          historyCursor: newCursorState.historyCursor,
+        })
 
-    const shouldFetchOldHistory = !refresh && newCursorState.historyCursor // on refresh request, wait until next tick to fetch old history
-    if (shouldFetchOldHistory) {
-      const { transactions: historyTransactions, historyCursor } = await this.fetchOldHistory({
-        address,
-        historyCursor: newCursorState.historyCursor,
-      })
+        newTransactions.push(...historyTransactions)
+        newCursorState.historyCursor = historyCursor
+      }
 
-      newTransactions.push(...historyTransactions)
-      // Always update so we persist historyCursor = undefined when history is exhausted
-      newCursorState.historyCursor = historyCursor
-    }
+      await this.emitUnknownTokensEvent({ tokenAccounts })
 
-    await this.emitUnknownTokensEvent({ tokenAccounts })
+      if (newTransactions.length > 0) {
+        const clearedLogItems = await this.markStaleTransactions({
+          walletAccount,
+          logItemsByAsset: this.mapTransactionsToLogItems({
+            transactions: newTransactions,
+            address,
+          }),
+        })
 
-    if (newTransactions.length > 0) {
-      // update all state at once
-      const clearedLogItems = await this.markStaleTransactions({
-        walletAccount,
-        logItemsByAsset: this.mapTransactionsToLogItems({ transactions: newTransactions, address }),
-      })
+        this.updateTxLogByAssetBatch({
+          logItemsByAsset: clearedLogItems,
+          walletAccount,
+          refresh,
+          batch,
+        })
+      }
 
-      this.updateTxLogByAssetBatch({
-        logItemsByAsset: clearedLogItems,
+      this.updateState({
+        account,
+        cursorState: newCursorState,
         walletAccount,
-        refresh,
+        staking,
         batch,
       })
+    } finally {
+      await this.aci.executeOperationsBatch(batch)
     }
-
-    // Always persist cursor state so historyCursor advances (and is cleared when history exhausted)
-    this.updateState({
-      account,
-      cursorState: newCursorState,
-      walletAccount,
-      staking,
-      batch,
-    })
-
-    // close batch
-    await this.aci.executeOperationsBatch(batch)
   }
 
   async fetchOldHistory({ address, historyCursor }) {
@@ -229,7 +253,6 @@ export class SolanaClarityMonitor extends BaseMonitor {
       })
 
       if (!transactions || transactions.length === 0 || !before) {
-        // no more transactions to fetch, return undefined to stop fetching old history
         return { transactions: [], historyCursor: undefined }
       }
 
@@ -288,7 +311,6 @@ export class SolanaClarityMonitor extends BaseMonitor {
     const mappedTransactions = []
 
     for (const tx of transactions) {
-      // we get the token name using the token.mintAddress
       const assetName = tx.token
         ? this.clarityApi.tokens.get(tx.token.mintAddress)?.name ?? 'unknown'
         : baseAsset.name
@@ -304,7 +326,7 @@ export class SolanaClarityMonitor extends BaseMonitor {
         txId: tx.id,
         from: [tx.from],
         coinAmount,
-        confirmations: 1, // tx.confirmations, // avoid multiple notifications
+        confirmations: 1,
         date: tx.date,
         error: tx.error,
         data: {
@@ -317,7 +339,6 @@ export class SolanaClarityMonitor extends BaseMonitor {
       }
 
       if (tx.owner === address) {
-        // send transaction
         item.to = Array.isArray(tx.to) ? undefined : tx.to
         item.feeAmount = baseAsset.currency.baseUnit(tx.fee) // in SOL
         item.feeCoinName = baseAsset.name
@@ -380,7 +401,6 @@ export class SolanaClarityMonitor extends BaseMonitor {
         }
 
         if (!after) {
-          // guard against missing cursor on non-empty transactions
           console.warn('SolanaClarityMonitor missing cursor with transactions', {
             address,
             cursor,
@@ -417,60 +437,94 @@ export class SolanaClarityMonitor extends BaseMonitor {
 
   async getAccountsAndBalances({ refresh, address, accountState, walletAccount }) {
     const delegatedAccounts = accountState.tokenDelegationInfo?.delegatedAccounts || []
-    const [accountInfo, { balances: splBalances, accounts: tokenAccounts }, delegatedBalances] =
-      await Promise.all([
-        this.clarityApi.getAccountInfo(address).catch(() => {}),
-        this.clarityApi.getTokensBalancesAndAccounts({
-          address,
-        }),
-        this.clarityApi.fetchDelegatedBalances({
-          delegatedAccounts,
+    const [accountInfoRaw, tokensPayload, delegatedBalances] = await Promise.all([
+      this.#fetchAccountInfoWithRetry(address),
+      this.clarityApi.getTokensBalancesAndAccounts({ address }).catch((error) => {
+        console.warn('SolanaClarityMonitor getTokensBalancesAndAccounts failed', { address, error })
+        return null
+      }),
+      this.clarityApi.fetchDelegatedBalances({ delegatedAccounts, address }).catch((error) => {
+        console.warn('SolanaClarityMonitor fetchDelegatedBalances failed', { address, error })
+        return accountState.tokenDelegationInfo?.delegatedBalances ?? Object.create(null)
+      }),
+    ])
+
+    const accountInfo = this.#normalizeAccountInfoPayload(accountInfoRaw)
+    const hasAccountInfo = accountInfo != null
+    const accountSize = hasAccountInfo ? accountInfo.space ?? 0 : accountState.accountSize ?? 0
+    const baseBalanceWithoutStaking = hasAccountInfo
+      ? this.asset.currency.baseUnit(accountInfo.lamports ?? 0)
+      : accountState.balance ?? this.asset.currency.ZERO
+
+    let rentExemptAmount = accountState.rentExemptAmount ?? this.asset.currency.ZERO
+    if (hasAccountInfo) {
+      try {
+        rentExemptAmount = this.asset.currency.baseUnit(
+          await this.clarityApi.getMinimumBalanceForRentExemption(accountSize)
+        )
+      } catch (error) {
+        console.warn('SolanaClarityMonitor getMinimumBalanceForRentExemption failed', {
           address,
-        }),
-      ])
-
-    const solBalance = accountInfo?.lamports || 0
-
-    const accountSize = accountInfo?.space || 0
+          accountSize,
+          error,
+        })
+      }
+    }
 
-    const rentExemptAmount = this.asset.currency.baseUnit(
-      await this.clarityApi.getMinimumBalanceForRentExemption(accountSize)
-    )
+    let ownerChanged = accountState.ownerChanged ?? false
+    if (hasAccountInfo) {
+      try {
+        ownerChanged = await this.clarityApi.ownerChanged(address, accountInfo)
+      } catch (error) {
+        console.warn('SolanaClarityMonitor ownerChanged failed', { address, error })
+      }
+    }
 
-    const ownerChanged = await this.clarityApi.ownerChanged(address, accountInfo)
+    const splBalances =
+      tokensPayload?.balances && typeof tokensPayload.balances === 'object'
+        ? tokensPayload.balances
+        : Object.create(null)
+    const tokenAccounts = Array.isArray(tokensPayload?.accounts) ? tokensPayload.accounts : []
 
-    const tokenBalances = mapValues(
-      pickBy(splBalances, (_balance, name) => this.assets[name]), // filter unknown tokens
-      (balance, name) => this.assets[name].currency.baseUnit(balance)
-    )
+    const tokenBalances = tokensPayload
+      ? mapValues(
+          pickBy(splBalances, (_balance, name) => this.assets[name]), // filter unknown tokens
+          (balance, name) => this.assets[name].currency.baseUnit(balance)
+        )
+      : accountState.tokenBalances ?? Object.create(null)
 
     const solBalanceChanged = this.#balanceChanged({
       account: accountState,
       newAccount: {
-        balance: this.asset.currency.baseUnit(solBalance), // balance without staking
+        balance: baseBalanceWithoutStaking,
         tokenBalances,
       },
     })
     const fetchStakingInfo =
-      refresh ||
-      solBalanceChanged ||
-      this.tickCount[walletAccount] % this.ticksBetweenStakeFetches === 0
+      hasAccountInfo &&
+      (refresh ||
+        solBalanceChanged ||
+        this.tickCount[walletAccount] % this.ticksBetweenStakeFetches === 0)
 
     const staking =
       this.isStakingEnabled() && fetchStakingInfo
-        ? await this.getStakingInfo({ address, accountState, walletAccount })
+        ? await this.getStakingInfo({ address, accountState, walletAccount }).catch((error) => {
+            console.warn('SolanaClarityMonitor getStakingInfo failed', { address, error })
+            return { ...accountState.stakingInfo, staking: this.staking }
+          })
         : { ...accountState.stakingInfo, staking: this.staking }
 
     const stakedBalance = this.asset.currency.baseUnit(staking.locked)
     const activatingBalance = this.asset.currency.baseUnit(staking.activating)
     const withdrawableBalance = this.asset.currency.baseUnit(staking.withdrawable)
     const pendingBalance = this.asset.currency.baseUnit(staking.pending)
-    const balance = this.asset.currency
-      .baseUnit(solBalance)
-      .add(stakedBalance)
-      .add(activatingBalance)
-      .add(withdrawableBalance)
-      .add(pendingBalance)
+    const balance = hasAccountInfo
+      ? baseBalanceWithoutStaking
+          .add(stakedBalance)
+          .add(activatingBalance)
+          .add(withdrawableBalance)
+          .add(pendingBalance)
+      : baseBalanceWithoutStaking
 
     return {
       account: {
@@ -535,9 +589,9 @@ export class SolanaClarityMonitor extends BaseMonitor {
       locked: this.asset.currency.baseUnit(stakingInfo.locked),
       activating: this.asset.currency.baseUnit(stakingInfo.activating),
       withdrawable: this.asset.currency.baseUnit(stakingInfo.withdrawable),
-      pending: this.asset.currency.baseUnit(stakingInfo.pending), // still undelegating (not yet available for withdraw)
+      pending: this.asset.currency.baseUnit(stakingInfo.pending),
       earned: this.asset.currency.baseUnit(earned),
-      accounts: stakingInfo.accounts, // Obj
+      accounts: stakingInfo.accounts,
     }
   }
 }

package/src/tx-log/ws-monitor.js

@@ -12,6 +12,16 @@ const DEFAULT_REMOTE_CONFIG = {
 }
 
 export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
+  #clarityInitialSyncDone = Object.create(null)
+
+  async #hasLoadedStakingInfo(walletAccount) {
+    const accountState = await this.aci.getAccountState({
+      assetName: this.asset.name,
+      walletAccount,
+    })
+    return accountState.stakingInfo?.loaded === true
+  }
+
   constructor({ wsApi, ...args }) {
     assert(wsApi, 'wsApi is required')
     super(args)
@@ -49,9 +59,16 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
       useCache: true,
     })
 
-    const { accounts: tokenAccountsByOwner } = await this.clarityApi.getTokensBalancesAndAccounts({
-      address,
-    })
+    const tokenAccountsByOwner = await this.clarityApi
+      .getTokensBalancesAndAccounts({ address })
+      .then((result) => result.accounts ?? [])
+      .catch((error) => {
+        console.warn('SolanaWebsocketMonitor getTokensBalancesAndAccounts failed', {
+          address,
+          error,
+        })
+        return []
+      })
     this.tokenAccountsByOwner[walletAccount] = tokenAccountsByOwner
     const tokensAddresses = tokenAccountsByOwner.map((acc) => acc.tokenAccountAddress)
 
@@ -81,10 +98,14 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
   }
 
   async tick({ walletAccount, refresh }) {
-    // we tick using Clarity only on startup or explicit refresh; otherwise we rely on WS events
-    // and programSubscribe for new SPL / Token-2022 accounts (no periodic getTokensBalancesAndAccounts).
-    if (refresh || this.tickCount[walletAccount] === 0) {
-      return super.tick({ walletAccount, refresh }) // Clarity refresh or first tick
+    const shouldRunClarityTick = refresh || !this.#clarityInitialSyncDone[walletAccount]
+    if (!shouldRunClarityTick) return
+
+    // BaseMonitor increments tickCount even when tick throws.
+    // Keep retrying full sync until staking info is actually loaded.
+    await super.tick({ walletAccount, refresh })
+    if (await this.#hasLoadedStakingInfo(walletAccount)) {
+      this.#clarityInitialSyncDone[walletAccount] = true
     }
   }
 
@@ -181,7 +202,6 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
           }
 
           const newData = {
-            // ...accountState, // we don't wanna update SOL "balance"
             tokenBalances: {
               ...accountState.tokenBalances,
               [tokenName]: this.assets[tokenName].currency.baseUnit(amount),
@@ -219,7 +239,6 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
           const balance = this.#computeTotalBalance({ amount, address, stakingInfo, walletAccount })
 
           const newData = {
-            // ...accountState, // we don't wanna update "tokenBalances" with old values (after sending an SPL token we have 2 events one updating SOL balance and one updating tokenBalances)
             balance,
           }