@exodus/solana-api 3.30.7 → 3.30.8

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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)
 
 

package/package.json

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

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/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)