@exodus/solana-api 3.30.7 → 3.30.9

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.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
+
+
+
+
+
 ## [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.9",
   "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": "3a8c58c8457a1d096ee5d3ecb2eea9e82b69ecb7",
+  "gitHead": "a2cd3fbc02d07f1c3dc127be4d7896292d2dc967",
   "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/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/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)