@exodus/solana-api 3.30.6 → 3.30.8

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.30.8](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.30.7...@exodus/solana-api@3.30.8) (2026-04-02)
+
+**Note:** Version bump only for package @exodus/solana-api
+
+
+
+
+
+## [3.30.7](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.30.6...@exodus/solana-api@3.30.7) (2026-04-01)
+
+
+### Bug Fixes
+
+
+* fix: addressIsActive users tx history (#7708)
+
+
+
 ## [3.30.6](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.30.5...@exodus/solana-api@3.30.6) (2026-03-30)
 
 **Note:** Version bump only for package @exodus/solana-api

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.30.6",
+  "version": "3.30.8",
   "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": "0d8639ef50e192df1f302f0ac7ff378d919cc536",
+  "gitHead": "c4e253a7ee39a0ee2524ff3c0e528fe3614d15de",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/api.js

@@ -497,14 +497,13 @@ export class Api {
   }
 
   /**
-   * Returns true if the account exists (has not been reclaimed).
-   * Accounts may be reclaimed by the rent collector after their balance dropped below the
-   * rent-exempt reserve. getAccountInfo only returns the current account state; if the
-   * runtime deleted the account, RPC returns null.
+   * Returns true if the address has any transaction history.
+   * Solana system accounts can be reclaimed after staying below rent exemption, so
+   * current account info is not a reliable signal for whether an address was ever used.
    */
   async addressIsActive(address) {
-    const value = await this.getAccountInfo(address)
-    return !!value?.data
+    const signatures = await this.getSignaturesForAddress(address, { limit: 1 })
+    return signatures.length > 0
   }
 
   async isSpl(address) {

package/src/connection.js

@@ -74,17 +74,17 @@ export class Connection {
         if (this.isOpen) {
           if (typeof this.ws.ping === 'function') {
             this.ws.ping()
-          } else {
-            // Some WebSocket implementations (like in browser or Electron renderer) don't have a ping method
-            this.ws.send(
-              JSON.stringify({
-                jsonrpc: '2.0',
-                id: Date.now(),
-                method: 'getVersion',
-                params: [],
-              })
-            )
           }
+
+          // Application-level keepalive (always); native ping is optional per WebSocket impl
+          this.ws.send(
+            JSON.stringify({
+              jsonrpc: '2.0',
+              id: Date.now(),
+              method: 'getVersion',
+              params: [],
+            })
+          )
         }
       }, PING_INTERVAL)
     }

package/src/rpc-api.js

@@ -190,6 +190,32 @@ export class RpcApi {
     }
   }
 
+  async getSignaturesForAddress(address, { until, before, limit } = {}) {
+    until = until || undefined
+
+    const fetchRetry = retry(
+      async () => {
+        try {
+          return await this.rpcCall('getSignaturesForAddress', [address, { until, before, limit }])
+        } catch (error) {
+          if (
+            error.message &&
+            !errorMessagesToRetry.some((errorMessage) => error.message.includes(errorMessage))
+          ) {
+            error.finalError = true
+          }
+
+          console.warn(`Error getting signatures. Retrying...`, error)
+
+          throw error
+        }
+      },
+      { delayTimesMs: ['8s', '10s', '15s'] }
+    )
+
+    return fetchRetry()
+  }
+
   async getWalletTokensList({ tokenAccounts }) {
     const tokensMint = []
     for (const account of tokenAccounts) {
@@ -244,14 +270,13 @@ export class RpcApi {
   }
 
   /**
-   * Returns true if the account exists (has not been reclaimed).
-   * Accounts may be reclaimed by the rent collector after their balance dropped below the
-   * rent-exempt reserve. getAccountInfo only returns the current account state; if the
-   * runtime deleted the account, RPC returns null.
+   * Returns true if the address has any transaction history.
+   * Solana system accounts can be reclaimed after staying below rent exemption, so
+   * current account info is not a reliable signal for whether an address was ever used.
    */
   async addressIsActive(address) {
-    const value = await this.getAccountInfo(address)
-    return !!value?.data
+    const signatures = await this.getSignaturesForAddress(address, { limit: 1 })
+    return signatures.length > 0
   }
 
   async getTokenFeeBasisPoints(address) {

package/src/tx-log/token-balance-patch.js

@@ -0,0 +1,49 @@
+/**
+ * Builds `newData` for a token-balance patch applied after `executeOperationsBatch`.
+ * `AccountState.merge` is shallow at the top level: keys omitted from `newData` are left unchanged
+ * on the existing state, so an empty `extraNewData` (e.g. account/program WS) does not clear
+ * `cursor`, `historyCursor`, etc. set by an earlier patch in the same flush queue.
+ *
+ * @param {{ tokenBalances?: Record<string, unknown> } & Record<string, unknown>} current - Latest account state from `getAccountState`
+ * @param {{ tokenPatch: Record<string, unknown>, extraNewData: Record<string, unknown> }} patch
+ */
+export function buildTokenBalancePatchNewData(current, { tokenPatch, extraNewData }) {
+  return {
+    ...extraNewData,
+    tokenBalances: { ...(current.tokenBalances ?? Object.create(null)), ...tokenPatch },
+  }
+}
+
+/**
+ * Applies a queue of token balance patches sequentially. After each `updateAccountState`, the next
+ * patch reads fresh state via `getAccountState` so multiple SPL mints in one tx (and mixed WS events)
+ * merge correctly.
+ *
+ * On failure, throws an `Error` with `cause` set to the underlying error, `remainingPatches` set to
+ * patches not yet applied (including the one that failed), and `appliedPatchCount` set to how many
+ * completed successfully. Callers can re-queue `remainingPatches` for retry.
+ *
+ * @param {object} aci - Asset client interface with `getAccountState` and `updateAccountState`
+ * @param {{ assetName: string, walletAccount: string, patches: Array<{ tokenPatch: Record<string, unknown>, extraNewData: Record<string, unknown> }> }} params
+ */
+export async function flushTokenBalancePatchesQueue(aci, { assetName, walletAccount, patches }) {
+  if (!patches?.length) return
+
+  let i = 0
+  try {
+    for (; i < patches.length; i++) {
+      const { tokenPatch, extraNewData } = patches[i]
+      const current = await aci.getAccountState({ assetName, walletAccount })
+      await aci.updateAccountState({
+        assetName,
+        walletAccount,
+        newData: buildTokenBalancePatchNewData(current, { tokenPatch, extraNewData }),
+      })
+    }
+  } catch (cause) {
+    const err = new Error('Token balance patch flush failed', { cause })
+    err.remainingPatches = patches.slice(i)
+    err.appliedPatchCount = i
+    throw err
+  }
+}

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

@@ -4,6 +4,7 @@ import assert from 'minimalistic-assert'
 import { DEFAULT_POOL_ADDRESS } from '../account-state.js'
 import { normalizeTransactionNotificationResult } from '../ws-api.js'
 import { SolanaClarityMonitor } from './clarity-monitor.js'
+import { flushTokenBalancePatchesQueue } from './token-balance-patch.js'
 
 const DEFAULT_REMOTE_CONFIG = {
   clarityUrl: [],
@@ -14,6 +15,8 @@ const DEFAULT_REMOTE_CONFIG = {
 
 export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
   #clarityInitialSyncDone = Object.create(null)
+  /** Queued after each `executeOperationsBatch` so token deltas merge onto latest state (fluent batch has no `push`). */
+  #pendingTokenBalancePatches = Object.create(null)
 
   async #hasLoadedStakingInfo(walletAccount) {
     const accountState = await this.aci.getAccountState({
@@ -171,13 +174,13 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
           tokenAccounts: this.tokenAccountsByOwner[walletAccount],
         })
         if (!unknownTokensList.includes(parsed.mintAddress) && tokenName) {
-          const newData = {
-            tokenBalances: {
-              ...accountState.tokenBalances,
+          this.#queueTokenBalancePatchAfterBatch({
+            tokenPatch: {
               [tokenName]: this.assets[tokenName].currency.baseUnit(parsed.amount),
             },
-          }
-          await this.#updateStateBatch({ newData, walletAccount })
+            extraNewData: {},
+            walletAccount,
+          })
         }
 
         return
@@ -202,13 +205,13 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
             return
           }
 
-          const newData = {
-            tokenBalances: {
-              ...accountState.tokenBalances,
+          this.#queueTokenBalancePatchAfterBatch({
+            tokenPatch: {
               [tokenName]: this.assets[tokenName].currency.baseUnit(amount),
             },
-          }
-          await this.#updateStateBatch({ newData, walletAccount })
+            extraNewData: {},
+            walletAccount,
+          })
         } else {
           // SOL balance changed
 
@@ -332,16 +335,7 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
           tokenBalancesFromTx[tokenName] = this.assets[tokenName].currency.baseUnit(amount)
         }
 
-        const newData =
-          Object.keys(tokenBalancesFromTx).length > 0
-            ? {
-                ...cursorState,
-                tokenBalances: {
-                  ...accountState.tokenBalances,
-                  ...tokenBalancesFromTx,
-                },
-              }
-            : { ...cursorState }
+        const hasTokenBalancePatch = Object.keys(tokenBalancesFromTx).length > 0
 
         if (stakingTx) {
           // for staking the balance is not updated by the balance handler
@@ -369,10 +363,18 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
               break
           }
 
-          newData.stakingInfo = temporaryStakingInfo
+          const stakingStateUpdate = { ...cursorState, stakingInfo: temporaryStakingInfo }
 
           // we update only stakingInfo, so that in this 12sec window, the spendable balance is valid. In the meanwhile we can fetch the complete one from RPC and update it in background (this one has the "staking accounts" references).
-          await this.#updateStateBatch({ newData, walletAccount })
+          if (hasTokenBalancePatch) {
+            this.#queueTokenBalancePatchAfterBatch({
+              tokenPatch: tokenBalancesFromTx,
+              extraNewData: stakingStateUpdate,
+              walletAccount,
+            })
+          } else {
+            await this.#updateStateBatch({ newData: stakingStateUpdate, walletAccount })
+          }
 
           await delay(12_000) // we introduce a delay to make sure the getStakingInfo RPC returns updated data
           // because we NEED at a certain point to have an updated stakingInfo in the state to know what's the new solana stake account address.
@@ -395,8 +397,16 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
           return
         }
 
-        // NB. we don't update any balances here to avoid race conditions with the accountNotification event above
-        await this.#updateStateBatch({ newData, walletAccount })
+        // Token deltas are applied after `executeOperationsBatch` so we merge onto latest state (swap race).
+        if (hasTokenBalancePatch) {
+          this.#queueTokenBalancePatchAfterBatch({
+            tokenPatch: tokenBalancesFromTx,
+            extraNewData: cursorState,
+            walletAccount,
+          })
+        } else if (Object.keys(cursorState).length > 0) {
+          await this.#updateStateBatch({ newData: cursorState, walletAccount })
+        }
 
         return
       }
@@ -425,10 +435,46 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
       const batch = this.batch[walletAccount]
       this.batch[walletAccount] = null
       await this.aci.executeOperationsBatch(batch)
+      await this.#flushPendingTokenBalancePatches(walletAccount)
     }, 2000)
     return this.batch[walletAccount]
   }
 
+  /**
+   * Production `createOperationsBatch()` returns a fluent batch (`updateAccountState` / `commit`), not
+   * `{ push, exec }` from tests. Token balance deltas are queued here and applied after `executeOperationsBatch`
+   * so each patch merges `{ ...current.tokenBalances, ...tokenPatch }` against up-to-date state.
+   */
+  #queueTokenBalancePatchAfterBatch({ tokenPatch, extraNewData, walletAccount }) {
+    if (!this.#pendingTokenBalancePatches[walletAccount]) {
+      this.#pendingTokenBalancePatches[walletAccount] = []
+    }
+
+    this.#pendingTokenBalancePatches[walletAccount].push({ tokenPatch, extraNewData })
+    this.#ensureBatch(walletAccount)
+  }
+
+  async #flushPendingTokenBalancePatches(walletAccount) {
+    const queue = this.#pendingTokenBalancePatches[walletAccount]
+    if (!queue?.length) return
+
+    const snapshot = [...queue]
+    try {
+      await flushTokenBalancePatchesQueue(this.aci, {
+        assetName: this.asset.name,
+        walletAccount,
+        patches: snapshot,
+      })
+      this.#pendingTokenBalancePatches[walletAccount] = []
+    } catch (e) {
+      const remaining = e.remainingPatches
+      this.#pendingTokenBalancePatches[walletAccount] = Array.isArray(remaining)
+        ? remaining
+        : snapshot
+      throw e
+    }
+  }
+
   async #updateStateBatch({ newData, walletAccount }) {
     const assetName = this.asset.name
     const batch = this.#ensureBatch(walletAccount)