@exodus/solana-api 3.29.3 → 3.29.5

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.29.5](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.29.4...@exodus/solana-api@3.29.5) (2026-02-14)
+
+**Note:** Version bump only for package @exodus/solana-api
+
+
+
+
+
+## [3.29.4](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.29.3...@exodus/solana-api@3.29.4) (2026-02-13)
+
+**Note:** Version bump only for package @exodus/solana-api
+
+
+
+
+
 ## [3.29.3](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.29.2...@exodus/solana-api@3.29.3) (2026-02-12)
 
 **Note:** Version bump only for package @exodus/solana-api

package/package.json

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

package/src/clarity-api.js

@@ -1,5 +1,5 @@
 import { memoizeLruCache } from '@exodus/asset-lib'
-import { memoize, omitBy } from '@exodus/basic-utils'
+import { isNil, memoize, omitBy } from '@exodus/basic-utils'
 import wretch from '@exodus/fetch/wretch'
 import { SYSTEM_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@exodus/solana-lib'
 import ms from 'ms'
@@ -9,7 +9,8 @@ import { RpcApi } from './rpc-api.js'
 
 const CLARITY_URL = 'https://solana-clarity.a.exodus.io/api/v2/solana'
 
-const cleanQuery = (obj) => omitBy(obj, (v) => v === undefined)
+// 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 === '')
 
 // Tokens + SOL api support
 export class ClarityApi extends RpcApi {

package/src/connection.js

@@ -10,17 +10,8 @@ const PING_INTERVAL = ms('25s')
 const debug = debugLogger('exodus:solana-api')
 
 export class Connection {
-  constructor({
-    endpoint,
-    address,
-    tokensAddresses = [],
-    onConnectionReady,
-    onConnectionClose,
-    onMsg,
-  }) {
+  constructor({ endpoint, onConnectionReady, onConnectionClose, onMsg }) {
     assert(endpoint, 'endpoint is required')
-    this.address = address
-    this.tokensAddresses = tokensAddresses
     this.endpoint = endpoint
     this.onConnectionReady = onConnectionReady
     this.onConnectionClose = onConnectionClose

package/src/staking/index.js

@@ -5,7 +5,7 @@ import { stakingProviderClientFactory } from './staking-provider-client.js'
 
 export { getStakingInfo } from '../staking-utils.js'
 
-export const stakingApiFactory = ({ asset, createTx, sendTx, stakingProviderClient }) => {
+export const stakingApiFactory = ({ assetName, assetClientInterface, stakingProviderClient }) => {
   const stakingProvider = stakingProviderClient ?? stakingProviderClientFactory()
 
   async function sendStake({
@@ -20,9 +20,12 @@ export const stakingApiFactory = ({ asset, createTx, sendTx, stakingProviderClie
   }) {
     let error
     let result
+    const { [assetName]: asset } = await assetClientInterface.getAssetsForNetwork({
+      baseAssetName: assetName,
+    })
 
     try {
-      const { unsignedTx } = await createTx({
+      const { unsignedTx } = await asset.api.createTx({
         asset,
         walletAccount,
         fromAddress: address,
@@ -35,7 +38,7 @@ export const stakingApiFactory = ({ asset, createTx, sendTx, stakingProviderClie
         pool,
       })
 
-      const sendResult = await sendTx({
+      const sendResult = await asset.api.sendTx({
         asset,
         walletAccount,
         unsignedTx,
@@ -68,6 +71,9 @@ export const stakingApiFactory = ({ asset, createTx, sendTx, stakingProviderClie
   }
 
   async function createAndSendStake({ method, address, amount, stakingInfo, walletAccount }) {
+    const { [assetName]: asset } = await assetClientInterface.getAssetsForNetwork({
+      baseAssetName: assetName,
+    })
     const txs = []
     switch (method) {
       case 'delegate': {

package/src/token-delegation.js

@@ -1,27 +1,6 @@
-import {
-  createApproveDelegationTx,
-  createRevokeDelegationTx,
-  TOKEN_2022_PROGRAM_ID,
-  TOKEN_PROGRAM_ID,
-} from '@exodus/solana-lib'
+import { createApproveDelegationTx, createRevokeDelegationTx } from '@exodus/solana-lib'
 import assert from 'minimalistic-assert'
 
-// SPL Token account layout offsets
-const MINT_OFFSET = 0
-const DELEGATE_OFFSET = 76 // mint (32) + owner (32) + amount (8) + delegateOption (4)
-
-async function fetchDelegatedAccountsForMint({ api, programId, mintAddress, delegateAddress }) {
-  const config = {
-    filters: [
-      { memcmp: { offset: MINT_OFFSET, bytes: mintAddress } },
-      { memcmp: { offset: DELEGATE_OFFSET, bytes: delegateAddress } },
-    ],
-    encoding: 'jsonParsed',
-  }
-
-  return api.getProgramAccounts(programId, config)
-}
-
 export const createTokenDelegationFactory = ({ api, assetClientInterface }) => {
   assert(api, 'api is required')
   assert(assetClientInterface, 'assetClientInterface is required')
@@ -97,33 +76,5 @@ export const createTokenDelegationFactory = ({ api, assetClientInterface }) => {
     }
   }
 
-  const getDelegatedAddresses = async ({ address, mintAddress }) => {
-    assert(address, 'address is required')
-    assert(mintAddress, 'mintAddress is required')
-
-    const token = api.tokens.get(mintAddress)
-    if (!token) return []
-
-    const [tokenAccounts, token2022Accounts] = await Promise.all([
-      fetchDelegatedAccountsForMint({
-        api,
-        programId: TOKEN_PROGRAM_ID.toBase58(),
-        mintAddress,
-        delegateAddress: address,
-      }),
-      fetchDelegatedAccountsForMint({
-        api,
-        programId: TOKEN_2022_PROGRAM_ID.toBase58(),
-        mintAddress,
-        delegateAddress: address,
-      }),
-    ])
-
-    return [...tokenAccounts, ...token2022Accounts].map((account) => ({
-      delegatedAddress: account.pubkey,
-      assetName: token.name,
-    }))
-  }
-
-  return { approveDelegation, revokeDelegation, getDelegatedAddresses }
+  return { approveDelegation, revokeDelegation }
 }

package/src/ws-api.js

@@ -14,39 +14,122 @@ const WS_ENDPOINT = 'wss://solana-triton.a.exodus.io/whirligig' // pointing to:
 export class WsApi {
   constructor({ rpcUrl, wsUrl, assets }) {
     this.setWsEndpoint(wsUrl)
-    this.connections = Object.create(null)
+    this.connection = null
+    this.watchedAddresses = Object.create(null) // address -> { tokensAddresses, onMessage }
+    this.#resetSubscriptionState()
+  }
+
+  /** Reset subscription maps (used on init and when the WS connection closes). */
+  #resetSubscriptionState() {
     this.accountSubscriptions = Object.create(null)
     this.transactionSubscriptions = 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)
   }
 
   setWsEndpoint(wsUrl) {
     this.wsUrl = wsUrl || WS_ENDPOINT
   }
 
-  async watchAddress({ address, tokensAddresses = [], onMessage }) {
-    if (this.connections[address]) return // already subscribed
-    const conn = new Connection({
-      endpoint: this.wsUrl,
-      address,
-      tokensAddresses,
-      onConnectionReady: (evt) => {
-        // ws connected, can send subscribe requests (this is called on every re-connect as well)
-        console.log('SOL WS connected.')
-        this.sendSubscriptions({ address, tokensAddresses })
-      },
-      onConnectionClose: (evt) => {
-        this.accountSubscriptions = Object.create(null) // clear subs
-      },
-      onMsg: (json) => onMessage(json),
-    })
+  /**
+   * Resolve which watched address(es) a message is for; only dispatch to those.
+   */
+  #getAddressesForMessage(json) {
+    const method = json?.method
+    const params = json?.params
+    const result = params?.result
+
+    // Subscription confirmation: store subscription id -> owner and type, do not dispatch
+    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 }
+        delete this.pendingSubscriptionRequests[json.id]
+      }
+
+      return []
+    }
+
+    if (method === 'accountNotification' || method === 'transactionNotification') {
+      const subId = params?.subscription
+      if (subId !== null) {
+        const owner = this.subscriptionIdToMeta[subId]?.owner
+        return owner && this.watchedAddresses[owner] ? [owner] : []
+      }
+    }
+
+    if (method === 'programNotification' && result) {
+      const owner = this.#getOwnerFromProgramNotificationResult(result)
+      return owner && this.watchedAddresses[owner] ? [owner] : []
+    }
+
+    // Ping response, unknown method, etc. – no address to dispatch to
+    return []
+  }
+
+  /** Extract owner address from programNotification result (Token/Token-2022 account). */
+  #getOwnerFromProgramNotificationResult(result) {
+    const { value } = result
+    if (!value?.account) return null
+    const account = value.account
+    const parsed = account?.data?.parsed?.info
+    if (parsed?.owner) return parsed.owner
+    if (Array.isArray(account.data) && account.data[1] === 'base64') {
+      try {
+        const decoded = Token.decode(Buffer.from(account.data[0], 'base64'))
+        return new PublicKey(decoded.owner).toBase58()
+      } catch {
+        return null
+      }
+    }
+
+    return null
+  }
+
+  #dispatchMessage(json) {
+    const addresses = this.#getAddressesForMessage(json)
+    for (const addr of addresses) {
+      this.watchedAddresses[addr].onMessage(json)
+    }
+  }
 
-    this.connections[address] = conn
-    return this.connections[address].start()
+  async #sendAllSubscriptions() {
+    for (const address of Object.keys(this.watchedAddresses)) {
+      const { tokensAddresses } = this.watchedAddresses[address]
+      await this.sendSubscriptions({ address, tokensAddresses })
+    }
+  }
+
+  async watchAddress({ address, tokensAddresses = [], onMessage }) {
+    if (this.watchedAddresses[address]) return // already subscribed
+
+    this.watchedAddresses[address] = { tokensAddresses, onMessage }
+
+    if (!this.connection) {
+      this.connection = new Connection({
+        endpoint: this.wsUrl,
+        onConnectionReady: () => {
+          console.log('SOL WS connected.')
+          this.#sendAllSubscriptions().catch((err) => {
+            console.error('SOL WS: failed to re-subscribe after connect:', err)
+          })
+        },
+        onConnectionClose: () => {
+          this.#resetSubscriptionState()
+        },
+        onMsg: (json) => this.#dispatchMessage(json),
+      })
+      await this.connection.start()
+    } else if (this.connection.isOpen) {
+      await this.sendSubscriptions({ address, tokensAddresses })
+    }
   }
 
   async accountSubscribe({ owner, account }) {
     // could be SOL address or token account address
-    const conn = this.connections[owner]
+    const conn = this.connection
     if (!conn || !conn.isOpen) {
       console.warn('SOL Connection is not open, cannot subscribe to', owner)
       return
@@ -55,6 +138,8 @@ export class WsApi {
     const subscriptions = this.accountSubscriptions[owner] || []
     if (subscriptions?.includes(account)) return // already subscribed
 
+    const id = ++conn.seq
+    this.pendingSubscriptionRequests[id] = { owner, type: 'account' }
     conn.send({
       jsonrpc: '2.0',
       method: 'accountSubscribe',
@@ -65,7 +150,7 @@ export class WsApi {
           commitment: 'confirmed',
         },
       ],
-      id: ++conn.seq,
+      id,
     })
 
     this.accountSubscriptions[owner] = [...subscriptions, account]
@@ -76,7 +161,7 @@ export class WsApi {
       accounts = [accounts]
     }
 
-    const conn = this.connections[owner]
+    const conn = this.connection
     if (!conn || !conn.isOpen) {
       console.warn('SOL Connection is not open, cannot subscribe to', owner)
       return
@@ -87,9 +172,11 @@ export class WsApi {
     const difference = accounts.filter((account) => !subscriptions.includes(account))
     if (difference.length === 0) return // already subscribed
 
+    const id = ++conn.seq
+    this.pendingSubscriptionRequests[id] = { owner, type: 'transaction' }
     conn.send({
       jsonrpc: '2.0',
-      id: ++conn.seq,
+      id,
       method: 'transactionSubscribe',
       params: [
         {
@@ -111,7 +198,7 @@ export class WsApi {
   }
 
   async sendSubscriptions({ address, tokensAddresses = [] }) {
-    const conn = this.connections[address]
+    const conn = this.connection
 
     const addresses = [address, ...tokensAddresses]
 
@@ -129,11 +216,13 @@ export class WsApi {
     const token2022ProgramId = TOKEN_2022_PROGRAM_ID.toBase58()
     const tokenAccountDataSize = 165
 
-    if (conn) {
+    if (conn?.isOpen) {
       // SPL Token: fixed 165-byte account size
+      const id1 = ++conn.seq
+      this.pendingSubscriptionRequests[id1] = { owner: address, type: 'program' }
       conn.send({
         jsonrpc: '2.0',
-        id: ++conn.seq,
+        id: id1,
         method: 'programSubscribe',
         params: [
           splTokenProgramId,
@@ -149,9 +238,11 @@ export class WsApi {
       })
 
       // Token-2022: no dataSize filter (accounts can have extensions and be larger than 165 bytes)
+      const id2 = ++conn.seq
+      this.pendingSubscriptionRequests[id2] = { owner: address, type: 'program' }
       conn.send({
         jsonrpc: '2.0',
-        id: ++conn.seq,
+        id: id2,
         method: 'programSubscribe',
         params: [
           token2022ProgramId,
@@ -166,9 +257,36 @@ export class WsApi {
   }
 
   async unwatchAddress({ address }) {
-    if (this.connections[address]) {
-      await this.connections[address].stop()
-      delete this.connections[address]
+    if (!this.watchedAddresses[address]) return
+
+    const conn = this.connection
+    const unsubMethods = {
+      account: 'accountUnsubscribe',
+      transaction: 'transactionUnsubscribe',
+      program: 'programUnsubscribe',
+    }
+    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)],
+        })
+      }
+
+      delete this.subscriptionIdToMeta[subId]
+    }
+
+    delete this.watchedAddresses[address]
+    delete this.accountSubscriptions[address]
+    delete this.transactionSubscriptions[address]
+
+    if (Object.keys(this.watchedAddresses).length === 0 && conn) {
+      await conn.stop()
+      this.connection = null
     }
   }