@exodus/solana-api 3.30.8 → 3.30.10

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.30.10](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.30.9...@exodus/solana-api@3.30.10) (2026-04-13)
+
+
+### Bug Fixes
+
+
+* fix: SOL ws single subscription and reconnect backoff (#7727)
+
+
+
+## [3.30.9](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.30.8...@exodus/solana-api@3.30.9) (2026-04-04)
+
+
+### Bug Fixes
+
+
+* fix: sponsored Solana token sends when CU simulation fails (#7707)
+
+
+
 ## [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.30.8",
+  "version": "3.30.10",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Solana",
   "type": "module",
   "main": "src/index.js",
@@ -33,8 +33,8 @@
     "@exodus/fetch": "^1.7.3",
     "@exodus/models": "^13.0.0",
     "@exodus/simple-retry": "^0.0.6",
-    "@exodus/solana-lib": "^3.22.3",
-    "@exodus/solana-meta": "^2.0.2",
+    "@exodus/solana-lib": "^3.22.5",
+    "@exodus/solana-meta": "^2.9.0",
     "@exodus/timer": "^1.1.1",
     "debug": "^4.1.1",
     "delay": "^4.0.1",
@@ -49,7 +49,7 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "c4e253a7ee39a0ee2524ff3c0e528fe3614d15de",
+  "gitHead": "786b5cff109a9a2a3c385e8e3140be4c72120577",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/connection.js

@@ -4,7 +4,8 @@ import delay from 'delay'
 import assert from 'minimalistic-assert'
 import ms from 'ms'
 
-const DEFAULT_RECONNECT_DELAY = ms('15s')
+const BASE_RECONNECT_DELAY = ms('15s')
+const MAX_RECONNECT_DELAY = ms('5m')
 const PING_INTERVAL = ms('25s')
 
 const debug = debugLogger('exodus:solana-api')
@@ -19,12 +20,10 @@ export class Connection {
 
     this.shutdown = false
     this.ws = null
-    this.messageQueue = []
-    this.inProcessMessages = false
     this.pingTimeout = null
     this.reconnectTimeout = null
-    this.txCache = {}
     this.seq = 0
+    this.reconnectAttempt = 0
   }
 
   newSocket(reqUrl) {
@@ -57,19 +56,12 @@ export class Connection {
   }
 
   get running() {
-    return !!(!this.isClosed || this.inProcessMessages || this.messageQueue.length > 0)
-  }
-
-  get connectionState() {
-    if (this.isConnecting) return 'CONNECTING'
-    if (this.isOpen) return 'OPEN'
-    if (this.isClosing) return 'CLOSING'
-    if (this.isClosed) return 'CLOSED'
-    return 'NONE'
+    return !this.isClosed
   }
 
   startPing() {
     if (this.ws) {
+      clearInterval(this.pingTimeout)
       this.pingTimeout = setInterval(() => {
         if (this.isOpen) {
           if (typeof this.ws.ping === 'function') {
@@ -90,16 +82,27 @@ export class Connection {
     }
   }
 
+  #nextReconnectDelayMs() {
+    const exp = Math.min(MAX_RECONNECT_DELAY, BASE_RECONNECT_DELAY * 2 ** this.reconnectAttempt)
+    const jitter = Math.floor(Math.random() * Math.min(exp, BASE_RECONNECT_DELAY))
+    return exp + jitter
+  }
+
   doRestart() {
-    // debug('Restarting WS:')
+    if (this.shutdown || this.reconnectTimeout) return
+
+    const delayMs = this.#nextReconnectDelayMs()
+    this.reconnectAttempt += 1
+    console.log(`SOL scheduling ws reconnect in ${delayMs}ms (attempt ${this.reconnectAttempt})`)
     this.reconnectTimeout = setTimeout(async () => {
+      this.reconnectTimeout = null
       try {
         console.log('SOL reconnecting ws...')
         this.start()
       } catch (e) {
         console.log(`Error in reconnect callback: ${e.message}`)
       }
-    }, DEFAULT_RECONNECT_DELAY)
+    }, delayMs)
   }
 
   onMessage(evt) {
@@ -115,6 +118,9 @@ export class Connection {
 
   onOpen(evt) {
     debug('Opened WS')
+    clearTimeout(this.reconnectTimeout)
+    this.reconnectTimeout = null
+    this.reconnectAttempt = 0
     this.onConnectionReady(evt)
     this.startPing()
   }
@@ -132,7 +138,10 @@ export class Connection {
   onClose(evt) {
     debug('Closing WS', evt)
     clearInterval(this.pingTimeout)
+    this.pingTimeout = null
     clearTimeout(this.reconnectTimeout)
+    this.reconnectTimeout = null
+    this.ws = null
     this.onConnectionClose(evt)
     if (!this.shutdown) {
       this.doRestart()
@@ -141,7 +150,9 @@ export class Connection {
 
   async close() {
     clearTimeout(this.reconnectTimeout)
+    this.reconnectTimeout = null
     clearInterval(this.pingTimeout)
+    this.pingTimeout = null
     if (this.ws && (this.isConnecting || this.isOpen)) {
       // this.ws.send(JSON.stringify({ method: 'close' }))
       // Not sending the method above so just no need to wait below

package/src/create-unsigned-tx-for-send.js

@@ -10,7 +10,9 @@ import assert from 'minimalistic-assert'
 
 import { maybeAddFeePayerWithAuth } from './fee-payer.js'
 
-const CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS = 300
+const COMPUTE_BUDGET_INSTRUCTIONS_CU = 300
+const SOL_TRANSFER_CU = 150 + COMPUTE_BUDGET_INSTRUCTIONS_CU
+const DEFAULT_COMPUTE_UNIT_LIMIT = 200_000
 const TOKEN_ACCOUNT_CREATION_SIZE = 165 // size of the token account
 
 export const createTxFactory = ({ assetClientInterface, api, feePayerClient }) => {
@@ -65,6 +67,7 @@ export const createTxFactory = ({ assetClientInterface, api, feePayerClient }) =
 
     const feeData =
       providedFeeData ?? (await assetClientInterface.getFeeConfig({ assetName: baseAssetName }))
+    const shouldTryFeePayer = feeData.enableFeePayer && useFeePayer
 
     const fromAddress =
       providedFromAddress ??
@@ -211,18 +214,22 @@ export const createTxFactory = ({ assetClientInterface, api, feePayerClient }) =
       reference,
       memo,
       // Effective: platform enable AND per-tx intent
-      useFeePayer,
+      useFeePayer: shouldTryFeePayer,
       ...tokenParams,
       ...stakingParams,
       ...magicEdenParams,
     })
 
     unsignedTx.txMeta.stakingParams = stakingParams
+    const isFeeSponsoredTokenTransfer = isToken && unsignedTx.txMeta.useFeePayer && !nft && !method
+    const shouldUseSafeComputeUnitLimit =
+      isFeeSponsoredTokenTransfer &&
+      (!unsignedTx.txData.isAssociatedTokenAccountActive || isExchange)
 
     const resolveUnitConsumed = async () => {
       // this avoids unnecessary simulations. Also the simulation fails with InsufficientFundsForRent when sending all.
       if (asset.name === asset.baseAsset.name && amount && !nft && !method) {
-        return 150 + CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS
+        return SOL_TRANSFER_CU
       }
 
       // Simulate with unsigned transaction. The fee payer service is deterministic -
@@ -237,10 +244,31 @@ export const createTxFactory = ({ assetClientInterface, api, feePayerClient }) =
         // we use this method to compute unitsConsumed
         // we can throw error here and fallback to ~0.025 SOL or estimate fee based on the method
         console.log('error getting units consumed:', err)
+        const serializedError = typeof err === 'string' ? err : JSON.stringify(err)
+        const isRentOrBalanceError = /insufficientfunds|rent/i.test(serializedError)
+        const isAccountNotFoundError = /accountnotfound/i.test(serializedError)
+
+        // Fee sponsorship is injected after this simulation step. Overestimate CU to
+        // avoid on-chain failures; the fee payer absorbs the cost.
+        if (!unitsConsumed && isFeeSponsoredTokenTransfer && isRentOrBalanceError) {
+          return DEFAULT_COMPUTE_UNIT_LIMIT
+        }
+
+        if (!unitsConsumed && isFeeSponsoredTokenTransfer && isAccountNotFoundError) {
+          const senderBaseBalanceLamports = BigInt(await api.getBalance(fromAddress))
+          if (senderBaseBalanceLamports === BigInt(0)) return DEFAULT_COMPUTE_UNIT_LIMIT
+        }
+
         if (!unitsConsumed) throw new Error(err)
       }
 
-      return unitsConsumed + CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS
+      const estimatedComputeUnitLimit = unitsConsumed + COMPUTE_BUDGET_INSTRUCTIONS_CU
+
+      if (shouldUseSafeComputeUnitLimit && estimatedComputeUnitLimit < DEFAULT_COMPUTE_UNIT_LIMIT) {
+        return DEFAULT_COMPUTE_UNIT_LIMIT
+      }
+
+      return estimatedComputeUnitLimit
     }
 
     const priorityFee = feeData.priorityFee
@@ -272,7 +300,6 @@ export const createTxFactory = ({ assetClientInterface, api, feePayerClient }) =
     const tx = await maybeAddFeePayerWithAuth({
       unsignedTx,
       feePayerClient,
-      enableFeePayer: feeData.enableFeePayer,
     })
 
     const fee = tx.txMeta.usedFeePayer ? asset.feeAsset.currency.ZERO : calculatedFee

package/src/fee-payer.js

@@ -145,11 +145,11 @@ export const feePayerClientFactory = ({
  * @param {Object} params.unsignedTx - The unsigned transaction
  * @param {Object} params.feePayerClient - The fee payer client instance
  */
-export const maybeAddFeePayerWithAuth = async ({ unsignedTx, feePayerClient, enableFeePayer }) => {
+export const maybeAddFeePayerWithAuth = async ({ unsignedTx, feePayerClient }) => {
   let unsignedTxWithFeePayer = unsignedTx
 
-  // Skip if no client or explicitly disabled
-  if (!feePayerClient || !enableFeePayer || !unsignedTx.txMeta.useFeePayer) {
+  // `txMeta.useFeePayer` already combines platform-level and per-tx intent.
+  if (!feePayerClient || !unsignedTx.txMeta.useFeePayer) {
     unsignedTxWithFeePayer.txMeta.usedFeePayer = false
     return unsignedTxWithFeePayer
   }

package/src/index.js

@@ -33,5 +33,10 @@ const serverApi = new Api({ assets }) // TODO: remove it, clean every use from p
 export default serverApi // TODO: remove it
 
 export { Api } from './api.js'
-export { WsApi, normalizeTransactionNotificationResult } from './ws-api.js'
+export {
+  mergeUniqueWatchAddresses,
+  normalizeTransactionNotificationResult,
+  sameWatchAddressSet,
+  WsApi,
+} from './ws-api.js'
 export { ClarityApi } from './clarity-api.js'

package/src/tx-log/README.md

@@ -22,17 +22,19 @@ This monitor will use a Mix of Clarity RPC calls and WS events (using Helius Enh
 
 - Both Laserstream gRPC and Geyser enhanced websockets are serviced by Laserstream under the hood.
 
-For `Richat`:
-If you have 10 ATA you will have
+For **Helius Enhanced WSS** (`WsApi` when the endpoint URL matches Helius — see [transactionSubscribe](https://www.helius.dev/docs/enhanced-websockets/transaction-subscribe)):
 
-- 11 `accountSubscribe` - 1 for wallet and 10 for ATA
-- 1 `transactionSubscribe` - all 11 addresses in account.include
-- 1 `tokenInitSubscribe` - 1 with wallet address
+- Filter uses `accountInclude`: transactions match if **any** listed account appears in the tx (OR). Up to 50,000 addresses per docs.
 
-For `transactionSubscribe`, once you have new ATA unfortunately you need to send new `transactionSubscribe`, once you receive messages that subscription is set you need to unsubscribe the old subscription, at that moment you will be able to receive duplicated transactions for a short period of time.
-(But this way you will not miss any transaction and will be easy to filter out duplicates on client side by txId)
+For **Triton / standard-style** RPC WebSockets (non-Helius URL), the same logical filter is sent as `accounts: { include: [...] }` (Whirligig / pool-specific docs mirror Solana’s JSON-RPC shape).
 
-Note that `tokenInitSubscribe` is a Richat-only method (in development). It doesn't exist in Laserstream/Geyser. It's used to check for new token accounts. For that we still need to rely on the `getTokenAccountsByOwner` RPC (or clarity call).
+If you have 10 ATAs you will have:
+
+- 11 `accountSubscribe` — 1 for the SOL owner and 10 for ATAs
+- **1 active** `transactionSubscribe` at a time — the merged list of all 11 addresses in `accountInclude` / `accounts.include`
+- 2 `programSubscribe` — SPL Token + Token-2022 (memcmp on owner), for new ATA discovery
+
+When new ATAs appear, `WsApi` sends a **new** `transactionSubscribe` with the **full** merged address list, waits for the subscription id, then `transactionUnsubscribe`s the **previous** tx subscription. You may see duplicate `transactionNotification`s for a short window; dedupe by tx id (same as before).
 
 ## WS RPC
 

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

@@ -256,12 +256,7 @@ export class SolanaClarityMonitor extends BaseMonitor {
         return { transactions: [], historyCursor: undefined }
       }
 
-      const transactionsWithSilentSound = transactions.map((tx) => ({
-        ...tx,
-        data: { ...tx.data, silentSound: true },
-      }))
-
-      return { transactions: transactionsWithSilentSound, historyCursor: before }
+      return { transactions, historyCursor: before }
     } catch (error) {
       console.warn('SolanaClarityMonitor fetchOldHistory failed', {
         address,
@@ -333,7 +328,6 @@ 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 },
       }

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

@@ -113,13 +113,65 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
     }
   }
 
-  async #handleMessage({ address, walletAccount, data }) {
-    const accountState = await this.aci.getAccountState({
-      assetName: this.asset.name,
-      walletAccount,
-    })
-    const tokenAccountsByOwner = this.tokenAccountsByOwner[walletAccount]
+  #buildTrackedTokenAccount({
+    tokenAccountAddress,
+    owner,
+    mintAddress,
+    balance = '0',
+    tokenProgram,
+  }) {
+    const tokenMeta = this.clarityApi.tokens.get(mintAddress)
+    return {
+      tokenAccountAddress,
+      owner,
+      tokenName: tokenMeta?.name ?? 'unknown',
+      ticker: tokenMeta?.ticker ?? 'UNKNOWN',
+      balance,
+      mintAddress,
+      tokenProgram,
+      decimals: tokenMeta?.decimals ?? 0,
+      feeBasisPoints: 0,
+      maximumFee: 0,
+    }
+  }
+
+  async #subscribeTokenAccountsForOwner({ address, tokenAccountAddresses }) {
+    if (tokenAccountAddresses.length === 0) return
+
+    for (const tokenAccountAddress of tokenAccountAddresses) {
+      await this.wsApi.accountSubscribe({ owner: address, account: tokenAccountAddress })
+    }
+
+    // Do not await `transactionSubscribe`: confirmation can take up to 30s and would stall
+    // programNotification / transactionNotification handling after we've already extended
+    // `tokenAccountsByOwner` (tx-log parse + postTokenBalances patch must run immediately).
+    this.wsApi
+      .transactionSubscribe({
+        owner: address,
+        accounts: tokenAccountAddresses,
+      })
+      .catch((err) => {
+        this.logger.error(
+          `SOL WS transactionSubscribe failed for ${this.asset.name} owner ${address}`,
+          err
+        )
+      })
+  }
+
+  async #flushBatch(walletAccount) {
+    const batch = this.batch[walletAccount]
+    this.batch[walletAccount] = null
+    if (!batch) return
+
+    try {
+      await this.aci.executeOperationsBatch(batch)
+      await this.#flushPendingTokenBalancePatches(walletAccount)
+    } catch (error) {
+      this.logger.error(`SOL ws batch flush failed for ${this.asset.name}:${walletAccount}`, error)
+    }
+  }
 
+  async #handleMessage({ address, walletAccount, data }) {
     /*
       1.	A new event arrives.
       2.	Open a 2-second batch window.
@@ -152,31 +204,28 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
           return
         }
 
-        const tokenMeta = this.clarityApi.tokens.get(parsed.mintAddress)
-        const tokenName = tokenMeta?.name
-        const newAccount = {
+        const newAccount = this.#buildTrackedTokenAccount({
           tokenAccountAddress: parsed.tokenAccountAddress,
           owner: parsed.owner,
-          tokenName: tokenName ?? 'unknown',
-          ticker: tokenMeta?.ticker ?? 'UNKNOWN',
-          balance: parsed.amount,
           mintAddress: parsed.mintAddress,
+          balance: parsed.amount,
           tokenProgram: parsed.tokenProgram,
-          decimals: tokenMeta?.decimals ?? 0,
-          feeBasisPoints: 0,
-          maximumFee: 0,
-        }
+        })
         this.tokenAccountsByOwner[walletAccount] = [...tokenAccountsByOwnerList, newAccount]
 
-        await this.wsApi.accountSubscribe({ owner: address, account: parsed.tokenAccountAddress })
+        await this.#subscribeTokenAccountsForOwner({
+          address,
+          tokenAccountAddresses: [parsed.tokenAccountAddress],
+        })
 
         const unknownTokensList = await this.emitUnknownTokensEvent({
           tokenAccounts: this.tokenAccountsByOwner[walletAccount],
         })
-        if (!unknownTokensList.includes(parsed.mintAddress) && tokenName) {
+        const tokenAsset = newAccount.tokenName && this.assets[newAccount.tokenName]
+        if (!unknownTokensList.includes(parsed.mintAddress) && tokenAsset) {
           this.#queueTokenBalancePatchAfterBatch({
             tokenPatch: {
-              [tokenName]: this.assets[tokenName].currency.baseUnit(parsed.amount),
+              [newAccount.tokenName]: tokenAsset.currency.baseUnit(parsed.amount),
             },
             extraNewData: {},
             walletAccount,
@@ -188,26 +237,29 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
 
       case 'accountNotification':
         // balance changed events for known tokens or SOL address
-
-        const { amount, tokenMintAddress } = this.wsApi.parseAccountNotification({
+        const parsedAccountNotification = this.wsApi.parseAccountNotification({
           address,
           walletAccount,
-          tokenAccountsByOwner,
+          tokenAccountsByOwner: this.tokenAccountsByOwner[walletAccount],
           result: data.params.result,
         })
+        if (!parsedAccountNotification) return
+
+        const { amount, tokenMintAddress } = parsedAccountNotification
 
         // update account state balance for SOL or Token
         if (tokenMintAddress) {
           // token balance changed
           const tokenName = this.clarityApi.tokens.get(tokenMintAddress)?.name
-          if (!tokenName) {
+          const tokenAsset = tokenName && this.assets[tokenName]
+          if (!tokenAsset) {
             console.log(`Unknown token mint address: ${tokenMintAddress}`)
             return
           }
 
           this.#queueTokenBalancePatchAfterBatch({
             tokenPatch: {
-              [tokenName]: this.assets[tokenName].currency.baseUnit(amount),
+              [tokenName]: tokenAsset.currency.baseUnit(amount),
             },
             extraNewData: {},
             walletAccount,
@@ -235,10 +287,14 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
               }
             }
 
-            await new Promise((resolve) => setTimeout(resolve, watchDelay))
+            await delay(watchDelay)
           }
 
           // otherwise regular SOL update:
+          const accountState = await this.aci.getAccountState({
+            assetName: this.asset.name,
+            walletAccount,
+          })
           const stakingInfo = accountState.stakingInfo // NB. we cannot call this.getStakingInfo(...) since it's not in sync with the ws event! we must wait a lot of seconds.
           const balance = this.#computeTotalBalance({ amount, address, stakingInfo, walletAccount })
 
@@ -258,6 +314,7 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
         const txDetails = normalizeTransactionNotificationResult(data.params.result)
         const txTokenAccounts = this.wsApi.getTokenAccountsFromTxMeta(txDetails, address)
         let tokenAccountsByOwnerList = this.tokenAccountsByOwner[walletAccount] || []
+        const newTokenAccountPubkeys = []
         for (const txAcc of txTokenAccounts) {
           if (
             tokenAccountsByOwnerList.some(
@@ -267,30 +324,24 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
             continue
           }
 
-          const tokenMeta = this.clarityApi.tokens.get(txAcc.mintAddress)
-          const newAccount = {
+          const newAccount = this.#buildTrackedTokenAccount({
             tokenAccountAddress: txAcc.tokenAccountAddress,
             owner: txAcc.owner,
-            tokenName: tokenMeta?.name ?? 'unknown',
-            ticker: tokenMeta?.ticker ?? 'UNKNOWN',
-            balance: '0',
             mintAddress: txAcc.mintAddress,
+            balance: '0',
             tokenProgram: null,
-            decimals: tokenMeta?.decimals ?? 0,
-            feeBasisPoints: 0,
-            maximumFee: 0,
-          }
-          tokenAccountsByOwnerList = [...tokenAccountsByOwnerList, newAccount]
-          await this.wsApi.accountSubscribe({ owner: address, account: txAcc.tokenAccountAddress })
-          // we need also to perform a transactionSubscribe to the new token account address
-          await this.wsApi.transactionSubscribe({
-            owner: address,
-            accounts: txAcc.tokenAccountAddress,
           })
+          tokenAccountsByOwnerList = [...tokenAccountsByOwnerList, newAccount]
+          newTokenAccountPubkeys.push(txAcc.tokenAccountAddress)
         }
 
         this.tokenAccountsByOwner[walletAccount] = tokenAccountsByOwnerList
 
+        await this.#subscribeTokenAccountsForOwner({
+          address,
+          tokenAccountAddresses: newTokenAccountPubkeys,
+        })
+
         const { logItemsByAsset, cursorState = {} } = this.wsApi.parseTransactionNotification({
           address,
           walletAccount,
@@ -340,6 +391,10 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
         if (stakingTx) {
           // for staking the balance is not updated by the balance handler
           // staking operations won't spend or modify the "total" wallet balance.
+          const accountState = await this.aci.getAccountState({
+            assetName: this.asset.name,
+            walletAccount,
+          })
 
           // we update stakingInfo (before fetching the new one)
           const temporaryStakingInfo = { ...accountState.stakingInfo }
@@ -431,11 +486,8 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
     // open a new operations batch window if it's not opened already
     if (this.batch[walletAccount]) return this.batch[walletAccount]
     this.batch[walletAccount] = this.aci.createOperationsBatch()
-    setTimeout(async () => {
-      const batch = this.batch[walletAccount]
-      this.batch[walletAccount] = null
-      await this.aci.executeOperationsBatch(batch)
-      await this.#flushPendingTokenBalancePatches(walletAccount)
+    setTimeout(() => {
+      this.#flushBatch(walletAccount)
     }, 2000)
     return this.batch[walletAccount]
   }

package/src/ws-api.js

@@ -19,6 +19,26 @@ import { isSolAddressPoisoningTx } from './txs-utils.js'
 // Helius Enhanced WebSocket (https://www.helius.dev/docs/enhanced-websockets)
 const HELIUS_WS_URL = 'wss://solana-helius-wss.a.exodus.io/ws'
 
+/** Merge `extra` addresses onto `base` without duplicates (order preserved). */
+export function mergeUniqueWatchAddresses(base, extra) {
+  const seen = new Set(base)
+  const out = [...base]
+  for (const addr of extra) {
+    if (seen.has(addr)) continue
+    seen.add(addr)
+    out.push(addr)
+  }
+
+  return out
+}
+
+/** True if both arrays contain the same set of addresses (order-independent). */
+export function sameWatchAddressSet(a, b) {
+  if (a.length !== b.length) return false
+  const set = new Set(a)
+  return b.every((addr) => set.has(addr))
+}
+
 /**
  * Normalize `transactionSubscribe` / JSON-RPC `params.result` into `getTransaction`-shaped txDetails:
  * `{ slot?, transaction: { message, signatures }, meta }`.
@@ -56,6 +76,10 @@ export function normalizeTransactionNotificationResult(result) {
 }
 
 export class WsApi {
+  #cancelledSubscriptionRequests = Object.create(null)
+  #ownerStates = Object.create(null)
+  #subscriptionConfirmHandlers = Object.create(null)
+
   constructor({ rpcUrl, wsUrl, assets }) {
     this.setWsEndpoint(wsUrl)
     this.connection = null
@@ -65,20 +89,69 @@ export class WsApi {
 
   /** Reset subscription maps (used on init and when the WS connection closes). */
   #resetSubscriptionState() {
-    this.accountSubscriptions = Object.create(null)
-    this.transactionSubscriptions = Object.create(null)
-    this.programSubscriptions = Object.create(null)
+    for (const entry of Object.values(this.#subscriptionConfirmHandlers)) {
+      clearTimeout(entry.timeout)
+      entry.reject(new Error('SOL WS connection reset'))
+    }
+
+    this.#cancelledSubscriptionRequests = Object.create(null)
+    this.#subscriptionConfirmHandlers = Object.create(null)
+    this.#ownerStates = Object.create(null)
     // subscription id (from RPC response) -> { owner, type: 'account'|'transaction'|'program' }
     this.subscriptionIdToMeta = Object.create(null)
     // request id (our conn.seq) -> { owner, type }, until we receive the subscription id
     this.pendingSubscriptionRequests = Object.create(null)
   }
 
+  get accountSubscriptions() {
+    const out = Object.create(null)
+    for (const [owner, state] of Object.entries(this.#ownerStates)) {
+      if (state.accountSubscriptions.length > 0) out[owner] = [...state.accountSubscriptions]
+    }
+
+    return out
+  }
+
+  get transactionSubscriptions() {
+    const out = Object.create(null)
+    for (const [owner, state] of Object.entries(this.#ownerStates)) {
+      if (state.transactionSubscriptions.length > 0) {
+        out[owner] = [...state.transactionSubscriptions]
+      }
+    }
+
+    return out
+  }
+
+  get programSubscriptions() {
+    const out = Object.create(null)
+    for (const [owner, state] of Object.entries(this.#ownerStates)) {
+      if (state.programSubscribed) out[owner] = true
+    }
+
+    return out
+  }
+
+  get activeTransactionSubscriptionId() {
+    const out = Object.create(null)
+    for (const [owner, state] of Object.entries(this.#ownerStates)) {
+      if (state.activeTransactionSubscriptionId != null) {
+        out[owner] = state.activeTransactionSubscriptionId
+      }
+    }
+
+    return out
+  }
+
   setWsEndpoint(wsUrl) {
     this.wsUrl = wsUrl || HELIUS_WS_URL
   }
 
-  /** True when using Helius Enhanced WebSocket (different transactionSubscribe params and notification shape). */
+  /**
+   * True when using Helius Enhanced WebSocket (`accountInclude` filter).
+   * Triton / standard Solana-style RPC uses `accounts.include` in the filter object.
+   * @see https://www.helius.dev/docs/enhanced-websockets/transaction-subscribe
+   */
   #isHelius() {
     if (!this.wsUrl) return false
     return this.wsUrl.includes('helius') || this.wsUrl === HELIUS_WS_URL
@@ -96,16 +169,29 @@ export class WsApi {
     if (json?.id != null && typeof json?.result === 'number') {
       const pending = this.pendingSubscriptionRequests[json.id]
       if (pending != null) {
-        this.subscriptionIdToMeta[json.result] = { owner: pending.owner, type: pending.type }
+        if (this.#cancelledSubscriptionRequests[json.id]) {
+          delete this.#cancelledSubscriptionRequests[json.id]
+          this.#sendRpcUnsubscribe({ subId: json.result, type: pending.type })
+        } else {
+          this.subscriptionIdToMeta[json.result] = { owner: pending.owner, type: pending.type }
+        }
+
         delete this.pendingSubscriptionRequests[json.id]
       }
 
+      const confirm = this.#subscriptionConfirmHandlers[json.id]
+      if (confirm != null) {
+        clearTimeout(confirm.timeout)
+        delete this.#subscriptionConfirmHandlers[json.id]
+        confirm.resolve(json.result)
+      }
+
       return []
     }
 
     if (method === 'accountNotification' || method === 'transactionNotification') {
       const subId = params?.subscription
-      if (subId !== null) {
+      if (subId != null) {
         const owner = this.subscriptionIdToMeta[subId]?.owner
         return owner && this.watchedAddresses[owner] ? [owner] : []
       }
@@ -140,9 +226,24 @@ export class WsApi {
   }
 
   #dispatchMessage(json) {
+    if (json?.id != null && json.error) {
+      const confirm = this.#subscriptionConfirmHandlers[json.id]
+      if (confirm != null) {
+        clearTimeout(confirm.timeout)
+        delete this.#subscriptionConfirmHandlers[json.id]
+        delete this.pendingSubscriptionRequests[json.id]
+        const msg = json.error?.message || 'SOL WS subscription RPC error'
+        confirm.reject(new Error(msg))
+      }
+
+      delete this.#cancelledSubscriptionRequests[json.id]
+
+      return
+    }
+
     const addresses = this.#getAddressesForMessage(json)
     for (const addr of addresses) {
-      this.watchedAddresses[addr].onMessage(json)
+      this.watchedAddresses[addr]?.onMessage?.(json)
     }
   }
 
@@ -153,8 +254,74 @@ export class WsApi {
     }
   }
 
+  #sendRpcUnsubscribe({ subId, type }) {
+    const methodByType = {
+      account: 'accountUnsubscribe',
+      transaction: 'transactionUnsubscribe',
+      program: 'programUnsubscribe',
+    }
+    const method = type && methodByType[type]
+    if (!method || !this.connection?.isOpen) return
+
+    this.connection.send({
+      jsonrpc: '2.0',
+      id: ++this.connection.seq,
+      method,
+      params: [Number(subId)],
+    })
+  }
+
+  #getOwnerState(owner) {
+    let state = this.#ownerStates[owner]
+    if (state) return state
+
+    state = {
+      accountSubscriptions: [],
+      transactionSubscriptions: [],
+      programSubscribed: false,
+      activeTransactionSubscriptionId: undefined,
+      transactionSubscribeChain: Promise.resolve(),
+    }
+    this.#ownerStates[owner] = state
+    return state
+  }
+
+  #cancelPendingSubscriptionsForOwner(owner) {
+    for (const [requestId, meta] of Object.entries(this.pendingSubscriptionRequests)) {
+      if (meta.owner !== owner) continue
+
+      this.#cancelledSubscriptionRequests[requestId] = true
+      const confirm = this.#subscriptionConfirmHandlers[requestId]
+      if (confirm != null) {
+        clearTimeout(confirm.timeout)
+        delete this.#subscriptionConfirmHandlers[requestId]
+        confirm.reject(new Error(`SOL WS ${meta.type} subscription cancelled for ${owner}`))
+      }
+    }
+  }
+
   async watchAddress({ address, tokensAddresses = [], onMessage }) {
-    if (this.watchedAddresses[address]) return // already subscribed
+    if (this.watchedAddresses[address]) {
+      const w = this.watchedAddresses[address]
+      if (onMessage) w.onMessage = onMessage
+
+      const prev = new Set(w.tokensAddresses)
+      const added = tokensAddresses.filter((t) => !prev.has(t))
+      w.tokensAddresses = mergeUniqueWatchAddresses(w.tokensAddresses, tokensAddresses)
+
+      if (added.length > 0 && this.connection?.isOpen) {
+        for (const addr of added) {
+          await this.accountSubscribe({ owner: address, account: addr })
+        }
+
+        await this.transactionSubscribe({
+          owner: address,
+          accounts: mergeUniqueWatchAddresses([address], w.tokensAddresses),
+        })
+      }
+
+      return
+    }
 
     this.watchedAddresses[address] = { tokensAddresses, onMessage }
 
@@ -189,8 +356,8 @@ export class WsApi {
       return
     }
 
-    const subscriptions = this.accountSubscriptions[owner] || []
-    if (subscriptions?.includes(account)) return // already subscribed
+    const ownerState = this.#getOwnerState(owner)
+    if (ownerState.accountSubscriptions.includes(account)) return // already subscribed
 
     const id = ++conn.seq
     this.pendingSubscriptionRequests[id] = { owner, type: 'account' }
@@ -207,44 +374,106 @@ export class WsApi {
       id,
     })
 
-    this.accountSubscriptions[owner] = [...subscriptions, account]
+    ownerState.accountSubscriptions = [...ownerState.accountSubscriptions, account]
   }
 
+  /**
+   * Subscribe to transactions touching any of the owner's watched accounts (OR semantics).
+   * Merges `accounts` into the existing set, sends **one** `transactionSubscribe` with the full
+   * merged `accountInclude` / `accounts.include` list, then unsubscribes the previous tx
+   * subscription (Helius + Triton safe; brief duplicate notifications possible — dedupe by tx id).
+   */
   async transactionSubscribe({ owner, accounts }) {
-    if (!Array.isArray(accounts)) {
-      accounts = [accounts]
+    const conn = this.connection
+    if (!conn || !conn.isOpen) {
+      console.warn('SOL Connection is not open, cannot subscribe to', owner)
+      return
     }
 
+    const ownerState = this.#getOwnerState(owner)
+    const normalized = Array.isArray(accounts) ? accounts : [accounts]
+    const prevChain = ownerState.transactionSubscribeChain
+    const done = prevChain.then(() =>
+      this.#transactionSubscribeStep({ owner, accounts: normalized })
+    )
+    ownerState.transactionSubscribeChain = done.catch((err) => {
+      console.error('SOL WS transactionSubscribe failed:', err)
+    })
+
+    return done
+  }
+
+  async #transactionSubscribeStep({ owner, accounts }) {
     const conn = this.connection
     if (!conn || !conn.isOpen) {
       console.warn('SOL Connection is not open, cannot subscribe to', owner)
       return
     }
 
-    const subscriptions = this.transactionSubscriptions[owner] || []
-    // compute the difference between subscriptions and accounts
-    const difference = accounts.filter((account) => !subscriptions.includes(account))
-    if (difference.length === 0) return // already subscribed
+    const ownerState = this.#getOwnerState(owner)
+    const prevList = ownerState.transactionSubscriptions
+    const merged = mergeUniqueWatchAddresses(prevList, accounts)
+    const activeId = ownerState.activeTransactionSubscriptionId
+    const sameSet = sameWatchAddressSet(merged, prevList)
 
+    if (sameSet && activeId != null) {
+      return
+    }
+
+    if (sameSet && activeId == null && merged.length === 0) {
+      return
+    }
+
+    const oldTxSubId = activeId
     const id = ++conn.seq
-    this.pendingSubscriptionRequests[id] = { owner, type: 'transaction' }
-    const options = {
-      commitment: 'confirmed',
-      encoding: 'jsonParsed',
-      transactionDetails: 'full',
-      showRewards: false,
-      maxSupportedTransactionVersion: 255,
-    }
-    const filter = this.#isHelius()
-      ? { vote: false, accountInclude: difference }
-      : { vote: false, accounts: { include: difference } }
-    conn.send({
-      jsonrpc: '2.0',
-      id,
-      method: 'transactionSubscribe',
-      params: [filter, options],
-    })
-    this.transactionSubscriptions[owner] = [...subscriptions, ...difference]
+
+    let subId
+    try {
+      subId = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          delete this.#subscriptionConfirmHandlers[id]
+          delete this.pendingSubscriptionRequests[id]
+          reject(new Error(`transactionSubscribe confirmation timeout for ${owner}`))
+        }, 30_000)
+
+        this.#subscriptionConfirmHandlers[id] = { resolve, reject, timeout }
+        this.pendingSubscriptionRequests[id] = { owner, type: 'transaction' }
+
+        const options = {
+          commitment: 'confirmed',
+          encoding: 'jsonParsed',
+          transactionDetails: 'full',
+          showRewards: false,
+          // Helius docs use 0 for legacy + v0; 255 keeps prior Exodus behavior on all providers.
+          maxSupportedTransactionVersion: 255,
+        }
+        const filter = this.#isHelius()
+          ? { vote: false, accountInclude: merged }
+          : { vote: false, accounts: { include: merged } }
+        conn.send({
+          jsonrpc: '2.0',
+          id,
+          method: 'transactionSubscribe',
+          params: [filter, options],
+        })
+      })
+    } catch (e) {
+      console.error('SOL WS transactionSubscribe:', e)
+      throw e
+    }
+
+    if (oldTxSubId != null && conn.isOpen) {
+      conn.send({
+        jsonrpc: '2.0',
+        id: ++conn.seq,
+        method: 'transactionUnsubscribe',
+        params: [Number(oldTxSubId)],
+      })
+      delete this.subscriptionIdToMeta[String(oldTxSubId)]
+    }
+
+    ownerState.transactionSubscriptions = merged
+    ownerState.activeTransactionSubscriptionId = subId
   }
 
   async programSubscribe({ owner }) {
@@ -254,7 +483,8 @@ export class WsApi {
       return
     }
 
-    if (this.programSubscriptions[owner]) return // already subscribed (SPL + Token-2022)
+    const ownerState = this.#getOwnerState(owner)
+    if (ownerState.programSubscribed) return // already subscribed (SPL + Token-2022)
 
     const splTokenProgramId = TOKEN_PROGRAM_ID.toBase58()
     const token2022ProgramId = TOKEN_2022_PROGRAM_ID.toBase58()
@@ -294,7 +524,7 @@ export class WsApi {
       ],
     })
 
-    this.programSubscriptions[owner] = true
+    ownerState.programSubscribed = true
   }
 
   async sendSubscriptions({ address, tokensAddresses = [] }) {
@@ -316,30 +546,17 @@ export class WsApi {
     if (!this.watchedAddresses[address]) return
 
     const conn = this.connection
-    const unsubMethods = {
-      account: 'accountUnsubscribe',
-      transaction: 'transactionUnsubscribe',
-      program: 'programUnsubscribe',
-    }
+    this.#cancelPendingSubscriptionsForOwner(address)
+
     for (const [subId, meta] of Object.entries(this.subscriptionIdToMeta)) {
       if (meta.owner !== address) continue
-      const method = meta.type && unsubMethods[meta.type]
-      if (method && conn?.isOpen) {
-        conn.send({
-          jsonrpc: '2.0',
-          id: ++conn.seq,
-          method,
-          params: [Number(subId)],
-        })
-      }
+      this.#sendRpcUnsubscribe({ subId, type: meta.type })
 
       delete this.subscriptionIdToMeta[subId]
     }
 
     delete this.watchedAddresses[address]
-    delete this.accountSubscriptions[address]
-    delete this.transactionSubscriptions[address]
-    delete this.programSubscriptions[address]
+    delete this.#ownerStates[address]
 
     if (Object.keys(this.watchedAddresses).length === 0 && conn) {
       await conn.stop()