@exodus/solana-api 3.29.2 → 3.29.4

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.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
+
+
+
+
+
 ## [3.29.2](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.29.1...@exodus/solana-api@3.29.2) (2026-02-11)
 
 

package/package.json

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

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/index.js

@@ -8,7 +8,6 @@ export { SolanaMonitor } from './tx-log/index.js'
 export { SolanaClarityMonitor } from './tx-log/index.js'
 export { SolanaWebsocketMonitor } from './tx-log/index.js'
 export { createAccountState } from './account-state.js'
-export { getStakingInfo } from './staking-utils.js'
 export {
   isSolanaStaking,
   isSolanaUnstaking,
@@ -18,7 +17,7 @@ export {
 export { createAndBroadcastTXFactory } from './tx-send.js'
 export { getBalancesFactory } from './get-balances.js'
 export { getFeeAsyncFactory } from './get-fees.js'
-export { stakingProviderClientFactory } from './staking-provider-client.js'
+export { stakingApiFactory, getStakingInfo } from './staking/index.js'
 export { createTxFactory } from './create-unsigned-tx-for-send.js'
 export { feePayerClientFactory } from './fee-payer.js'
 export { createInitAgentWalletFactory } from './init-agent-wallet.js'

package/src/staking/index.js

@@ -0,0 +1,173 @@
+import chunk from 'lodash/chunk.js'
+
+import { getStakingInfo } from '../staking-utils.js'
+import { stakingProviderClientFactory } from './staking-provider-client.js'
+
+export { getStakingInfo } from '../staking-utils.js'
+
+export const stakingApiFactory = ({ assetName, assetClientInterface, stakingProviderClient }) => {
+  const stakingProvider = stakingProviderClient ?? stakingProviderClientFactory()
+
+  async function sendStake({
+    address,
+    walletAccount,
+    method,
+    amount,
+    stakeAddresses,
+    accounts,
+    seed,
+    pool,
+  }) {
+    let error
+    let result
+    const { [assetName]: asset } = await assetClientInterface.getAssetsForNetwork({
+      baseAssetName: assetName,
+    })
+
+    try {
+      const { unsignedTx } = await asset.api.createTx({
+        asset,
+        walletAccount,
+        fromAddress: address,
+        address,
+        amount: amount ?? asset.currency.ZERO,
+        method,
+        stakeAddresses,
+        accounts,
+        seed,
+        pool,
+      })
+
+      const sendResult = await asset.api.sendTx({
+        asset,
+        walletAccount,
+        unsignedTx,
+      })
+
+      result = { txId: sendResult.txId }
+    } catch (err) {
+      error = err
+    }
+
+    try {
+      const notifyMethod = {
+        delegate: 'notifyStaking',
+        withdraw: 'notifyWithdraw',
+      }
+      if (notifyMethod[method] && (error || result?.txId)) {
+        await stakingProvider[notifyMethod[method]]({
+          asset: asset.name,
+          txId: result?.txId ?? null,
+          delegator: address,
+          amount: amount?.toBaseString?.({ unit: false }) ?? '0',
+          error,
+        })
+      }
+    } catch (e) {
+      console.error('Failed to notify staking service:', e)
+    }
+
+    return { error, result }
+  }
+
+  async function createAndSendStake({ method, address, amount, stakingInfo, walletAccount }) {
+    const { [assetName]: asset } = await assetClientInterface.getAssetsForNetwork({
+      baseAssetName: assetName,
+    })
+    const txs = []
+    switch (method) {
+      case 'delegate': {
+        const seed = `exodus:${Date.now()}`
+        txs.push({
+          method: 'delegate',
+          address,
+          amount,
+          seed,
+          pool: stakingInfo.staking.pool,
+        })
+
+        break
+      }
+
+      case 'undelegate': {
+        const addresses = []
+        for (const [addr, info] of Object.entries(stakingInfo.accounts)) {
+          if (info.state === 'active' || info.state === 'activating') addresses.push(addr)
+        }
+
+        const N_UNDELEGATE_ADDR = 10
+        chunk(addresses, N_UNDELEGATE_ADDR).forEach((stakeAddresses) => {
+          txs.push({
+            method,
+            address,
+            amount: asset.currency.ZERO,
+            stakeAddresses,
+          })
+        })
+
+        break
+      }
+
+      case 'withdraw': {
+        const accounts = {}
+        for (const [addr, info] of Object.entries(stakingInfo.accounts)) {
+          if (info.state === 'inactive') accounts[addr] = info
+        }
+
+        const N_WITHDRAW_ACCOUNTS = 10
+        chunk(Object.entries(accounts), N_WITHDRAW_ACCOUNTS).forEach((entries) => {
+          txs.push({
+            method,
+            address,
+            amount: asset.currency.ZERO,
+            accounts: Object.fromEntries(entries),
+          })
+        })
+        if (txs.length === 0) throw new Error('no funds to withdraw')
+        break
+      }
+
+      default: {
+        throw new Error('Unknown method')
+      }
+    }
+
+    const txIds = []
+    for (const tx of txs) {
+      const { error, result } = await sendStake({
+        address,
+        walletAccount,
+        ...tx,
+      })
+      if (error) throw error
+
+      txIds.push(result.txId)
+    }
+
+    return txIds
+  }
+
+  async function delegate({ address, amount, stakingInfo, walletAccount }) {
+    return createAndSendStake({ method: 'delegate', address, amount, stakingInfo, walletAccount })
+  }
+
+  async function undelegate({ address, amount, stakingInfo, walletAccount }) {
+    return createAndSendStake({ method: 'undelegate', address, amount, stakingInfo, walletAccount })
+  }
+
+  async function withdraw({ address, amount, stakingInfo, walletAccount }) {
+    return createAndSendStake({ method: 'withdraw', address, amount, stakingInfo, walletAccount })
+  }
+
+  return {
+    stake: delegate,
+    unstake: undelegate,
+    claimUnstaked: withdraw,
+    getStakingInfo,
+    // Legacy names
+    createAndSendStake,
+    delegate,
+    undelegate,
+    withdraw,
+  }
+}

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
     }
   }