@exodus/solana-api 3.29.6 → 3.30.1

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.30.1](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.30.0...@exodus/solana-api@3.30.1) (2026-03-13)
+
+
+### Bug Fixes
+
+
+* fix(solana-api): add RPC concurrency limit and fix historyCursor loss on error (#7550)
+
+* fix(solana-api): improve fetchival error handling in fee payer client (#7570)
+
+
+
+## [3.30.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.29.6...@exodus/solana-api@3.30.0) (2026-03-10)
+
+
+### Features
+
+
+* feat: switch Solana txs to Clarity (#7449)
+
+
+### Bug Fixes
+
+
+* fix: helius vote false param (#7486)
+
+
+
 ## [3.29.6](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.29.5...@exodus/solana-api@3.29.6) (2026-02-23)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.29.6",
+  "version": "3.30.1",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Solana",
   "type": "module",
   "main": "src/index.js",
@@ -45,11 +45,11 @@
     "url-join": "^4.0.0"
   },
   "devDependencies": {
-    "@exodus/asset": "^2.2.0",
+    "@exodus/asset": "^2.3.0",
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "6ac0fce9b0cc8dc2fe3cb5b940f077ec36cfcae3",
+  "gitHead": "51cc10fa866ae472882aa09353e2425bc7d7031f",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/account-state.js

@@ -17,6 +17,7 @@ export const createAccountState = ({ assetList }) => {
   return class SolanaAccountState extends AccountState {
     static defaults = {
       cursor: '',
+      historyCursor: '',
       balance: asset.currency.ZERO,
       tokenBalances: Object.create(null),
       rentExemptAmount: asset.currency.ZERO,

package/src/api.js

@@ -19,6 +19,7 @@ import {
   TOKEN_PROGRAM_ID,
 } from '@exodus/solana-lib'
 import lodash from 'lodash'
+import makeConcurrent from 'make-concurrent'
 import ms from 'ms'
 import urljoin from 'url-join'
 
@@ -41,6 +42,8 @@ const errorMessagesToRetry = [
   'Failed to query long-term storage; please try again',
 ]
 
+const TX_DETAIL_FETCH_CONCURRENCY = 10
+
 // Tokens + SOL api support
 export class Api {
   constructor({ rpcUrl, wsUrl, assets, txsLimit }) {
@@ -230,8 +233,11 @@ export class Api {
       let txsId = txsResultsByAccount.flat() // merge arrays
       txsId = lodash.uniqBy(txsId, 'signature')
 
-      // get txs details in parallel
-      const txsDetails = await Promise.all(txsId.map((tx) => this.getTransactionById(tx.signature)))
+      // get txs details with concurrency limit to avoid overwhelming the RPC server
+      const fetchWithLimit = makeConcurrent((signature) => this.getTransactionById(signature), {
+        concurrency: TX_DETAIL_FETCH_CONCURRENCY,
+      })
+      const txsDetails = await Promise.all(txsId.map((tx) => fetchWithLimit(tx.signature)))
       txsDetails.forEach((txDetail) => {
         if (!txDetail) return
 

package/src/clarity-api.js

@@ -7,7 +7,7 @@ import urljoin from 'url-join'
 
 import { RpcApi } from './rpc-api.js'
 
-const CLARITY_URL = 'https://solana-clarity.a.exodus.io/api/v2/solana'
+const CLARITY_URL = 'https://assets-gateway-clarity-api.a.exodus.io/assets/api/v2/solana'
 
 // Filter out nil and empty string values to prevent API validation errors (e.g., empty cursor)
 const cleanQuery = (obj) => omitBy(obj, (v) => isNil(v) || v === '')
@@ -47,11 +47,15 @@ export class ClarityApi extends RpcApi {
     })
   }
 
-  async getTransactions(address, { cursor, limit, includeUnparsed = false } = Object.create(null)) {
+  async getTransactions(
+    address,
+    { after, before, limit, includeUnparsed = false } = Object.create(null)
+  ) {
     const result = await this.request(`/addresses/${encodeURIComponent(address)}/transactions`)
       .query(
         cleanQuery({
-          cursor,
+          before,
+          after,
           limit,
           includeUnparsed,
         })

package/src/fee-payer.js

@@ -64,14 +64,30 @@ export const feePayerClientFactory = ({
       }
     }
 
-    return fetchival(`${feePayerApiUrl}/transactions/sponsor`, {
-      mode: 'cors',
-      cache: 'no-cache',
-      timeout: ms('10s'),
-      headers,
-    }).post({
-      transaction: encodedTransaction,
-    })
+    try {
+      return await fetchival(`${feePayerApiUrl}/transactions/sponsor`, {
+        mode: 'cors',
+        cache: 'no-cache',
+        timeout: ms('10s'),
+        headers,
+      }).post({
+        transaction: encodedTransaction,
+      })
+    } catch (err) {
+      let nerr = err
+      if (err.response) {
+        try {
+          const data = await err.response.text()
+          nerr = new Error(`${err.response.status}: ${data}`)
+        } catch {}
+      }
+
+      if (err.response?.status) {
+        nerr.status = err.response.status
+      }
+
+      throw nerr
+    }
   }
 
   /**
@@ -84,10 +100,7 @@ export const feePayerClientFactory = ({
     try {
       response = await makeSponsorRequest({ encodedTransaction })
     } catch (error) {
-      if (
-        requireAuthentication &&
-        (error.response?.status === 401 || error.response?.status === 403)
-      ) {
+      if (requireAuthentication && (error.status === 401 || error.status === 403)) {
         console.warn('Authentication failed, retrying...')
         if (authClient) {
           await authClient._authenticate()

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

@@ -18,21 +18,21 @@ const TICKS_BETWEEN_STAKE_FETCHES = 5
 const TX_STALE_AFTER = ms('2m') // mark txs as dropped after N minutes
 
 export class SolanaClarityMonitor extends BaseMonitor {
+  #maxFetchLimitPerTick
+
   constructor({
     clarityApi,
-    rpcApi,
     includeUnparsed = false,
     ticksBetweenHistoryFetches = TICKS_BETWEEN_HISTORY_FETCHES,
     ticksBetweenStakeFetches = TICKS_BETWEEN_STAKE_FETCHES,
     txsLimit,
+    maxFetchLimitPerTick = 5,
     shouldUpdateBalanceBeforeHistory = true,
     ...args
   }) {
     super(args)
     assert(clarityApi, 'clarityApi is required')
     this.clarityApi = clarityApi
-    this.rpcApi = rpcApi
-    this.cursors = Object.create(null)
     this.assets = Object.create(null)
     this.staking = DEFAULT_REMOTE_CONFIG.staking
     this.ticksBetweenStakeFetches = ticksBetweenStakeFetches
@@ -40,6 +40,7 @@ export class SolanaClarityMonitor extends BaseMonitor {
     this.shouldUpdateBalanceBeforeHistory = shouldUpdateBalanceBeforeHistory
     this.includeUnparsed = includeUnparsed
     this.txsLimit = txsLimit
+    this.#maxFetchLimitPerTick = maxFetchLimitPerTick
   }
 
   setServer(config = Object.create(null)) {
@@ -53,11 +54,6 @@ export class SolanaClarityMonitor extends BaseMonitor {
     this.staking = staking
   }
 
-  hasNewCursor({ walletAccount, cursorState }) {
-    const { cursor } = cursorState
-    return this.cursors[walletAccount] !== cursor
-  }
-
   async emitUnknownTokensEvent({ tokenAccounts }) {
     const tokensList = await this.clarityApi.getWalletTokensList({ tokenAccounts })
     const unknownTokensList = tokensList.filter((mintAddress) => {
@@ -101,7 +97,7 @@ export class SolanaClarityMonitor extends BaseMonitor {
       const txSet = await this.aci.getTxLog({ assetName, walletAccount })
       const { stale } = this.getUnconfirmed({ txSet, staleTxAge: TX_STALE_AFTER })
       if (stale.length > 0) {
-        clearedLogItems[assetName] = lodash.unionBy(logItemsByAsset[assetName], stale, 'txId')
+        clearedLogItems[assetName] = lodash.unionBy(logItemsByAsset[assetName] ?? [], stale, 'txId')
       }
     }
 
@@ -137,9 +133,9 @@ export class SolanaClarityMonitor extends BaseMonitor {
     })
     const hasUnconfirmedSentTx = [...baseAssetTxLog].some((tx) => tx.pending && tx.sent)
 
-    const shouldUpdateHistory =
+    const shouldUpdateLatestHistory =
       refresh || isHistoryUpdateTick || balanceChanged || hasUnconfirmedSentTx
-    const shouldUpdateOnlyBalance = balanceChanged && !shouldUpdateHistory
+    const shouldUpdateOnlyBalance = balanceChanged && !shouldUpdateLatestHistory
 
     // start a batch
     const batch = this.aci.createOperationsBatch()
@@ -150,50 +146,147 @@ export class SolanaClarityMonitor extends BaseMonitor {
       await this.emitUnknownTokensEvent({ tokenAccounts })
     }
 
-    if (shouldUpdateHistory) {
-      const { logItemsByAsset, cursorState } = await this.getHistory({
+    const newCursorState = {
+      cursor: accountState.cursor,
+      historyCursor: accountState.historyCursor,
+    }
+
+    const newTransactions = []
+
+    if (shouldUpdateLatestHistory) {
+      const { transactions: latestTransactions, cursorState: latestHistoryCursorState } =
+        await this.getLatestHistory({
+          address,
+          accountState,
+          walletAccount,
+          refresh,
+          tokenAccounts,
+        })
+
+      if (latestHistoryCursorState.cursor) {
+        newCursorState.cursor = latestHistoryCursorState.cursor
+      }
+
+      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)
+    }
+
+    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,
-        accountState,
-        walletAccount,
-        refresh,
-        tokenAccounts,
+        historyCursor: newCursorState.historyCursor,
       })
 
-      const cursorChanged = this.hasNewCursor({ walletAccount, cursorState })
+      newTransactions.push(...historyTransactions)
+      // Always update so we persist historyCursor = undefined when history is exhausted
+      newCursorState.historyCursor = historyCursor
+    }
+
+    await this.emitUnknownTokensEvent({ tokenAccounts })
 
+    if (newTransactions.length > 0) {
       // update all state at once
-      const clearedLogItems = await this.markStaleTransactions({ walletAccount, logItemsByAsset })
+      const clearedLogItems = await this.markStaleTransactions({
+        walletAccount,
+        logItemsByAsset: this.mapTransactionsToLogItems({ transactions: newTransactions, address }),
+      })
+
       this.updateTxLogByAssetBatch({
         logItemsByAsset: clearedLogItems,
         walletAccount,
         refresh,
         batch,
       })
-      this.updateState({ account, cursorState, walletAccount, staking, batch })
-      await this.emitUnknownTokensEvent({ tokenAccounts })
-      if (refresh || cursorChanged) {
-        this.cursors[walletAccount] = cursorState.cursor
-      }
     }
 
+    // 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 getHistory({ address, accountState, refresh, tokenAccounts } = Object.create(null)) {
-    const cursor = refresh ? '' : accountState.cursor
-    const baseAsset = this.asset
+  async fetchOldHistory({ address, historyCursor }) {
+    if (!historyCursor) return { transactions: [], historyCursor: undefined }
 
-    // TODO: switch to this.clarityApi.getTransactions once ready!!
-    // and remove this.rpcApi from constructor and create-asset-utils.js
-    const { transactions, newCursor } = await this.rpcApi.getTransactions(address, {
-      cursor,
-      includeUnparsed: this.includeUnparsed,
-      limit: this.txsLimit,
-      tokenAccounts,
+    try {
+      const { transactions, before } = await this.clarityApi.getTransactions(address, {
+        before: historyCursor,
+        includeUnparsed: this.includeUnparsed,
+        limit: this.txsLimit,
+      })
+
+      if (!transactions || transactions.length === 0 || !before) {
+        // no more transactions to fetch, return undefined to stop fetching old history
+        return { transactions: [], historyCursor: undefined }
+      }
+
+      const transactionsWithSilentSound = transactions.map((tx) => ({
+        ...tx,
+        data: { ...tx.data, silentSound: true },
+      }))
+
+      return { transactions: transactionsWithSilentSound, historyCursor: before }
+    } catch (error) {
+      console.warn('SolanaClarityMonitor fetchOldHistory failed', {
+        address,
+        historyCursor,
+        error,
+      })
+
+      // Preserve cursor on transient errors so fetching retries on the next tick
+      return { transactions: [], historyCursor }
+    }
+  }
+
+  async getLatestHistory({ address, accountState, refresh, tokenAccounts } = Object.create(null)) {
+    if (refresh || !accountState.cursor) {
+      const { transactions, before, after } = await this.clarityApi.getTransactions(address, {
+        after: undefined,
+        includeUnparsed: this.includeUnparsed,
+        limit: this.txsLimit,
+      })
+
+      return {
+        transactions,
+        hasNewTxs: transactions.length > 0,
+        cursorState: {
+          cursor: after,
+          historyCursor: before,
+        },
+      }
+    }
+
+    const { transactions, after: newAfterCursor } = await this.fetchLatestTransactions({
+      address,
+      afterCursor: accountState.cursor,
     })
 
+    return {
+      transactions,
+      hasNewTxs: transactions.length > 0,
+      cursorState: {
+        cursor: newAfterCursor,
+      },
+    }
+  }
+
+  mapTransactionsToLogItems({ transactions, address }) {
+    const baseAsset = this.asset
     const mappedTransactions = []
+
     for (const tx of transactions) {
       // we get the token name using the token.mintAddress
       const assetName = tx.token
@@ -218,6 +311,7 @@ export class SolanaClarityMonitor extends BaseMonitor {
           staking: tx.staking || null,
           unparsed: !!tx.unparsed,
           swapTx: !!(tx.data && tx.data.inner),
+          silentSound: !!tx.data?.silentSound,
         },
         currencies: { [assetName]: asset.currency, [feeAsset.name]: feeAsset.currency },
       }
@@ -262,12 +356,63 @@ export class SolanaClarityMonitor extends BaseMonitor {
       mappedTransactions.push(item)
     }
 
-    const logItemsByAsset = lodash.groupBy(mergeByTxId(mappedTransactions), 'coinName')
-    return {
-      logItemsByAsset,
-      hasNewTxs: transactions.length > 0,
-      cursorState: { cursor: newCursor },
+    return lodash.groupBy(mergeByTxId(mappedTransactions), 'coinName')
+  }
+
+  async fetchLatestTransactions({ address, afterCursor }) {
+    let cursor = afterCursor
+    let allTransactions = []
+    let newAfterCursor = afterCursor
+    let fetchCount = 0
+
+    while (fetchCount < this.#maxFetchLimitPerTick) {
+      try {
+        const { transactions, after } = await this.clarityApi.getTransactions(address, {
+          after: cursor,
+          includeUnparsed: this.includeUnparsed,
+          limit: this.txsLimit,
+        })
+
+        fetchCount += 1
+
+        if (!transactions || transactions.length === 0) {
+          break
+        }
+
+        if (!after) {
+          // guard against missing cursor on non-empty transactions
+          console.warn('SolanaClarityMonitor missing cursor with transactions', {
+            address,
+            cursor,
+            afterCursor,
+            fetchCount,
+            transactionsCount: transactions.length,
+          })
+          break
+        }
+
+        allTransactions = [...allTransactions, ...transactions]
+
+        if (after === cursor) {
+          newAfterCursor = after
+          break
+        }
+
+        cursor = after
+        newAfterCursor = after
+      } catch (error) {
+        console.warn('SolanaClarityMonitor fetchLatestTransactions failed', {
+          address,
+          cursor,
+          afterCursor,
+          fetchCount,
+          error,
+        })
+        break
+      }
     }
+
+    return { transactions: allTransactions, after: newAfterCursor }
   }
 
   async getAccountsAndBalances({ refresh, address, accountState, walletAccount }) {
@@ -367,17 +512,18 @@ export class SolanaClarityMonitor extends BaseMonitor {
       stakingInfo: staking,
       ...cursorState,
     }
+
     return this.updateAccountStateBatch({ assetName, walletAccount, newData, batch })
   }
 
   async getStakingInfo({ address, accountState, walletAccount }) {
     const stakingInfo = await this.clarityApi.getStakeAccountsInfo(address)
-    let earned = accountState.stakingInfo.earned.toBaseString()
+    let earned = accountState.stakingInfo?.earned?.toBaseString() ?? '0'
     try {
       const rewards = await this.clarityApi.getRewards(address)
       earned = rewards
     } catch (error) {
-      console.warn(error)
+      console.warn('SolanaClarityMonitor getStakingInfo failed', { address, error })
     }
 
     return {

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

@@ -26,7 +26,6 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
   async beforeStart() {
     this.assets = await this.aci.getAssetsForNetwork({ baseAssetName: this.asset.name })
     this.clarityApi.setTokens(this.assets)
-    this.rpcApi.setTokens(this.assets)
 
     const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
     await Promise.all(
@@ -50,7 +49,7 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
       useCache: true,
     })
 
-    const { accounts: tokenAccountsByOwner } = await this.rpcApi.getTokensBalancesAndAccounts({
+    const { accounts: tokenAccountsByOwner } = await this.clarityApi.getTokensBalancesAndAccounts({
       address,
     })
     this.tokenAccountsByOwner[walletAccount] = tokenAccountsByOwner

package/src/ws-api.js

@@ -7,7 +7,7 @@ import { parseTransaction } from './tx-parser.js'
 import { isSolAddressPoisoningTx } from './txs-utils.js'
 
 // Triton Whirligig WebSocket
-const TRITON_WS_ENDPOINT = 'wss://solana-triton.a.exodus.io/whirligig' // pointing to: wss://exodus-solanama-6db3.mainnet.rpcpool.com/<token>/whirligig
+// const TRITON_WS_ENDPOINT = 'wss://solana-triton.a.exodus.io/whirligig' // pointing to: wss://exodus-solanama-6db3.mainnet.rpcpool.com/<token>/whirligig
 // Helius Enhanced WebSocket (https://www.helius.dev/docs/enhanced-websockets)
 const HELIUS_WS_URL = 'wss://solana-helius-wss.a.exodus.io/ws'
 
@@ -31,7 +31,7 @@ export class WsApi {
   }
 
   setWsEndpoint(wsUrl) {
-    this.wsUrl = wsUrl || TRITON_WS_ENDPOINT
+    this.wsUrl = wsUrl || HELIUS_WS_URL
   }
 
   /** True when using Helius Enhanced WebSocket (different transactionSubscribe params and notification shape). */
@@ -189,7 +189,7 @@ export class WsApi {
       maxSupportedTransactionVersion: 255,
     }
     const filter = this.#isHelius()
-      ? { accountInclude: difference }
+      ? { vote: false, accountInclude: difference }
       : { vote: false, accounts: { include: difference } }
     conn.send({
       jsonrpc: '2.0',