@exodus/solana-api 3.29.5 → 3.30.0

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.30.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.29.6...@exodus/solana-api@3.30.0) (2026-03-10)
+
+
+### Features
+
+
+* feat: switch Solana txs to Clarity (#7449)
+
+
+### Bug Fixes
+
+
+* fix: helius vote false param (#7486)
+
+
+
+## [3.29.6](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.29.5...@exodus/solana-api@3.29.6) (2026-02-23)
+
+
+### Bug Fixes
+
+
+* fix: remove staking provider param (#7440)
+
+
+
 ## [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.29.5",
+  "version": "3.30.0",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Solana",
   "type": "module",
   "main": "src/index.js",
@@ -45,11 +45,11 @@
     "url-join": "^4.0.0"
   },
   "devDependencies": {
-    "@exodus/asset": "^2.2.0",
+    "@exodus/asset": "^2.3.0",
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "01daedc61270d2ef4e7b03f984c130346d06922f",
+  "gitHead": "0076335abe2f542d07cc23704104c106ed38d5f3",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/account-state.js

@@ -17,6 +17,7 @@ export const createAccountState = ({ assetList }) => {
   return class SolanaAccountState extends AccountState {
     static defaults = {
       cursor: '',
+      historyCursor: '',
       balance: asset.currency.ZERO,
       tokenBalances: Object.create(null),
       rentExemptAmount: asset.currency.ZERO,

package/src/clarity-api.js

@@ -7,7 +7,7 @@ import urljoin from 'url-join'
 
 import { RpcApi } from './rpc-api.js'
 
-const CLARITY_URL = 'https://solana-clarity.a.exodus.io/api/v2/solana'
+const CLARITY_URL = 'https://assets-gateway-clarity-api.a.exodus.io/assets/api/v2/solana'
 
 // 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 === '')
@@ -47,11 +47,15 @@ export class ClarityApi extends RpcApi {
     })
   }
 
-  async getTransactions(address, { cursor, limit, includeUnparsed = false } = Object.create(null)) {
+  async getTransactions(
+    address,
+    { after, before, limit, includeUnparsed = false } = Object.create(null)
+  ) {
     const result = await this.request(`/addresses/${encodeURIComponent(address)}/transactions`)
       .query(
         cleanQuery({
-          cursor,
+          before,
+          after,
           limit,
           includeUnparsed,
         })

package/src/staking/index.js

@@ -5,8 +5,8 @@ import { stakingProviderClientFactory } from './staking-provider-client.js'
 
 export { getStakingInfo } from '../staking-utils.js'
 
-export const stakingApiFactory = ({ assetName, assetClientInterface, stakingProviderClient }) => {
-  const stakingProvider = stakingProviderClient ?? stakingProviderClientFactory()
+export const stakingApiFactory = ({ assetName, assetClientInterface }) => {
+  const stakingProvider = stakingProviderClientFactory()
 
   async function sendStake({
     address,

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

@@ -18,21 +18,21 @@ const TICKS_BETWEEN_STAKE_FETCHES = 5
 const TX_STALE_AFTER = ms('2m') // mark txs as dropped after N minutes
 
 export class SolanaClarityMonitor extends BaseMonitor {
+  #maxFetchLimitPerTick
+
   constructor({
     clarityApi,
-    rpcApi,
     includeUnparsed = false,
     ticksBetweenHistoryFetches = TICKS_BETWEEN_HISTORY_FETCHES,
     ticksBetweenStakeFetches = TICKS_BETWEEN_STAKE_FETCHES,
     txsLimit,
+    maxFetchLimitPerTick = 5,
     shouldUpdateBalanceBeforeHistory = true,
     ...args
   }) {
     super(args)
     assert(clarityApi, 'clarityApi is required')
     this.clarityApi = clarityApi
-    this.rpcApi = rpcApi
-    this.cursors = Object.create(null)
     this.assets = Object.create(null)
     this.staking = DEFAULT_REMOTE_CONFIG.staking
     this.ticksBetweenStakeFetches = ticksBetweenStakeFetches
@@ -40,6 +40,7 @@ export class SolanaClarityMonitor extends BaseMonitor {
     this.shouldUpdateBalanceBeforeHistory = shouldUpdateBalanceBeforeHistory
     this.includeUnparsed = includeUnparsed
     this.txsLimit = txsLimit
+    this.#maxFetchLimitPerTick = maxFetchLimitPerTick
   }
 
   setServer(config = Object.create(null)) {
@@ -53,11 +54,6 @@ export class SolanaClarityMonitor extends BaseMonitor {
     this.staking = staking
   }
 
-  hasNewCursor({ walletAccount, cursorState }) {
-    const { cursor } = cursorState
-    return this.cursors[walletAccount] !== cursor
-  }
-
   async emitUnknownTokensEvent({ tokenAccounts }) {
     const tokensList = await this.clarityApi.getWalletTokensList({ tokenAccounts })
     const unknownTokensList = tokensList.filter((mintAddress) => {
@@ -101,7 +97,7 @@ export class SolanaClarityMonitor extends BaseMonitor {
       const txSet = await this.aci.getTxLog({ assetName, walletAccount })
       const { stale } = this.getUnconfirmed({ txSet, staleTxAge: TX_STALE_AFTER })
       if (stale.length > 0) {
-        clearedLogItems[assetName] = lodash.unionBy(logItemsByAsset[assetName], stale, 'txId')
+        clearedLogItems[assetName] = lodash.unionBy(logItemsByAsset[assetName] ?? [], stale, 'txId')
       }
     }
 
@@ -137,9 +133,9 @@ export class SolanaClarityMonitor extends BaseMonitor {
     })
     const hasUnconfirmedSentTx = [...baseAssetTxLog].some((tx) => tx.pending && tx.sent)
 
-    const shouldUpdateHistory =
+    const shouldUpdateLatestHistory =
       refresh || isHistoryUpdateTick || balanceChanged || hasUnconfirmedSentTx
-    const shouldUpdateOnlyBalance = balanceChanged && !shouldUpdateHistory
+    const shouldUpdateOnlyBalance = balanceChanged && !shouldUpdateLatestHistory
 
     // start a batch
     const batch = this.aci.createOperationsBatch()
@@ -150,50 +146,146 @@ export class SolanaClarityMonitor extends BaseMonitor {
       await this.emitUnknownTokensEvent({ tokenAccounts })
     }
 
-    if (shouldUpdateHistory) {
-      const { logItemsByAsset, cursorState } = await this.getHistory({
+    const newCursorState = {
+      cursor: accountState.cursor,
+      historyCursor: accountState.historyCursor,
+    }
+
+    const newTransactions = []
+
+    if (shouldUpdateLatestHistory) {
+      const { transactions: latestTransactions, cursorState: latestHistoryCursorState } =
+        await this.getLatestHistory({
+          address,
+          accountState,
+          walletAccount,
+          refresh,
+          tokenAccounts,
+        })
+
+      if (latestHistoryCursorState.cursor) {
+        newCursorState.cursor = latestHistoryCursorState.cursor
+      }
+
+      if (latestHistoryCursorState.historyCursor) {
+        // refresh case will have historyCursor available
+        // but if user has 0 txs, it won't be available, therefore need to check
+        newCursorState.historyCursor = latestHistoryCursorState.historyCursor
+      }
+
+      newTransactions.push(...latestTransactions)
+    }
+
+    const shouldFetchOldHistory = !refresh && newCursorState.historyCursor // on refresh request, wait until next tick to fetch old history
+    if (shouldFetchOldHistory) {
+      const { transactions: historyTransactions, historyCursor } = await this.fetchOldHistory({
         address,
-        accountState,
-        walletAccount,
-        refresh,
-        tokenAccounts,
+        historyCursor: newCursorState.historyCursor,
       })
 
-      const cursorChanged = this.hasNewCursor({ walletAccount, cursorState })
+      newTransactions.push(...historyTransactions)
+      // Always update so we persist historyCursor = undefined when history is exhausted
+      newCursorState.historyCursor = historyCursor
+    }
+
+    await this.emitUnknownTokensEvent({ tokenAccounts })
 
+    if (newTransactions.length > 0) {
       // update all state at once
-      const clearedLogItems = await this.markStaleTransactions({ walletAccount, logItemsByAsset })
+      const clearedLogItems = await this.markStaleTransactions({
+        walletAccount,
+        logItemsByAsset: this.mapTransactionsToLogItems({ transactions: newTransactions, address }),
+      })
+
       this.updateTxLogByAssetBatch({
         logItemsByAsset: clearedLogItems,
         walletAccount,
         refresh,
         batch,
       })
-      this.updateState({ account, cursorState, walletAccount, staking, batch })
-      await this.emitUnknownTokensEvent({ tokenAccounts })
-      if (refresh || cursorChanged) {
-        this.cursors[walletAccount] = cursorState.cursor
-      }
     }
 
+    // Always persist cursor state so historyCursor advances (and is cleared when history exhausted)
+    this.updateState({
+      account,
+      cursorState: newCursorState,
+      walletAccount,
+      staking,
+      batch,
+    })
+
     // close batch
     await this.aci.executeOperationsBatch(batch)
   }
 
-  async getHistory({ address, accountState, refresh, tokenAccounts } = Object.create(null)) {
-    const cursor = refresh ? '' : accountState.cursor
-    const baseAsset = this.asset
+  async fetchOldHistory({ address, historyCursor }) {
+    if (!historyCursor) return { transactions: [], historyCursor: undefined }
 
-    // TODO: switch to this.clarityApi.getTransactions once ready!!
-    // and remove this.rpcApi from constructor and create-asset-utils.js
-    const { transactions, newCursor } = await this.rpcApi.getTransactions(address, {
-      cursor,
-      includeUnparsed: this.includeUnparsed,
-      limit: this.txsLimit,
-      tokenAccounts,
+    try {
+      const { transactions, before } = await this.clarityApi.getTransactions(address, {
+        before: historyCursor,
+        includeUnparsed: this.includeUnparsed,
+        limit: this.txsLimit,
+      })
+
+      if (!transactions || transactions.length === 0 || !before) {
+        // no more transactions to fetch, return undefined to stop fetching old history
+        return { transactions: [], historyCursor: undefined }
+      }
+
+      const transactionsWithSilentSound = transactions.map((tx) => ({
+        ...tx,
+        data: { ...tx.data, silentSound: true },
+      }))
+
+      return { transactions: transactionsWithSilentSound, historyCursor: before }
+    } catch (error) {
+      console.warn('SolanaClarityMonitor fetchOldHistory failed', {
+        address,
+        historyCursor,
+        error,
+      })
+
+      return { transactions: [], historyCursor: undefined }
+    }
+  }
+
+  async getLatestHistory({ address, accountState, refresh, tokenAccounts } = Object.create(null)) {
+    if (refresh || !accountState.cursor) {
+      const { transactions, before, after } = await this.clarityApi.getTransactions(address, {
+        after: undefined,
+        includeUnparsed: this.includeUnparsed,
+        limit: this.txsLimit,
+      })
+
+      return {
+        transactions,
+        hasNewTxs: transactions.length > 0,
+        cursorState: {
+          cursor: after,
+          historyCursor: before,
+        },
+      }
+    }
+
+    const { transactions, after: newAfterCursor } = await this.fetchLatestTransactions({
+      address,
+      afterCursor: accountState.cursor,
     })
 
+    return {
+      transactions,
+      hasNewTxs: transactions.length > 0,
+      cursorState: {
+        cursor: newAfterCursor,
+      },
+    }
+  }
+
+  mapTransactionsToLogItems({ transactions, address }) {
+    const baseAsset = this.asset
     const mappedTransactions = []
+
     for (const tx of transactions) {
       // we get the token name using the token.mintAddress
       const assetName = tx.token
@@ -218,6 +310,7 @@ 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 },
       }
@@ -262,12 +355,63 @@ export class SolanaClarityMonitor extends BaseMonitor {
       mappedTransactions.push(item)
     }
 
-    const logItemsByAsset = lodash.groupBy(mergeByTxId(mappedTransactions), 'coinName')
-    return {
-      logItemsByAsset,
-      hasNewTxs: transactions.length > 0,
-      cursorState: { cursor: newCursor },
+    return lodash.groupBy(mergeByTxId(mappedTransactions), 'coinName')
+  }
+
+  async fetchLatestTransactions({ address, afterCursor }) {
+    let cursor = afterCursor
+    let allTransactions = []
+    let newAfterCursor = afterCursor
+    let fetchCount = 0
+
+    while (fetchCount < this.#maxFetchLimitPerTick) {
+      try {
+        const { transactions, after } = await this.clarityApi.getTransactions(address, {
+          after: cursor,
+          includeUnparsed: this.includeUnparsed,
+          limit: this.txsLimit,
+        })
+
+        fetchCount += 1
+
+        if (!transactions || transactions.length === 0) {
+          break
+        }
+
+        if (!after) {
+          // guard against missing cursor on non-empty transactions
+          console.warn('SolanaClarityMonitor missing cursor with transactions', {
+            address,
+            cursor,
+            afterCursor,
+            fetchCount,
+            transactionsCount: transactions.length,
+          })
+          break
+        }
+
+        allTransactions = [...allTransactions, ...transactions]
+
+        if (after === cursor) {
+          newAfterCursor = after
+          break
+        }
+
+        cursor = after
+        newAfterCursor = after
+      } catch (error) {
+        console.warn('SolanaClarityMonitor fetchLatestTransactions failed', {
+          address,
+          cursor,
+          afterCursor,
+          fetchCount,
+          error,
+        })
+        break
+      }
     }
+
+    return { transactions: allTransactions, after: newAfterCursor }
   }
 
   async getAccountsAndBalances({ refresh, address, accountState, walletAccount }) {
@@ -367,17 +511,18 @@ export class SolanaClarityMonitor extends BaseMonitor {
       stakingInfo: staking,
       ...cursorState,
     }
+
     return this.updateAccountStateBatch({ assetName, walletAccount, newData, batch })
   }
 
   async getStakingInfo({ address, accountState, walletAccount }) {
     const stakingInfo = await this.clarityApi.getStakeAccountsInfo(address)
-    let earned = accountState.stakingInfo.earned.toBaseString()
+    let earned = accountState.stakingInfo?.earned?.toBaseString() ?? '0'
     try {
       const rewards = await this.clarityApi.getRewards(address)
       earned = rewards
     } catch (error) {
-      console.warn(error)
+      console.warn('SolanaClarityMonitor getStakingInfo failed', { address, error })
     }
 
     return {

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

@@ -26,7 +26,6 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
   async beforeStart() {
     this.assets = await this.aci.getAssetsForNetwork({ baseAssetName: this.asset.name })
     this.clarityApi.setTokens(this.assets)
-    this.rpcApi.setTokens(this.assets)
 
     const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
     await Promise.all(
@@ -50,7 +49,7 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
       useCache: true,
     })
 
-    const { accounts: tokenAccountsByOwner } = await this.rpcApi.getTokensBalancesAndAccounts({
+    const { accounts: tokenAccountsByOwner } = await this.clarityApi.getTokensBalancesAndAccounts({
       address,
     })
     this.tokenAccountsByOwner[walletAccount] = tokenAccountsByOwner

package/src/ws-api.js

@@ -7,9 +7,9 @@ import { parseTransaction } from './tx-parser.js'
 import { isSolAddressPoisoningTx } from './txs-utils.js'
 
 // Triton Whirligig WebSocket
-const WS_ENDPOINT = 'wss://solana-triton.a.exodus.io/whirligig' // pointing to: wss://exodus-solanama-6db3.mainnet.rpcpool.com/<token>/whirligig
-// Helius Advanced WebSocket
-// const WS_ENDPOINT = 'wss://solana-helius-wss.a.exodus.io/ws' // pointing to: wss://atlas-mainnet.helius-rpc.com/?api-key=<API_KEY>
+// const TRITON_WS_ENDPOINT = 'wss://solana-triton.a.exodus.io/whirligig' // pointing to: wss://exodus-solanama-6db3.mainnet.rpcpool.com/<token>/whirligig
+// Helius Enhanced WebSocket (https://www.helius.dev/docs/enhanced-websockets)
+const HELIUS_WS_URL = 'wss://solana-helius-wss.a.exodus.io/ws'
 
 export class WsApi {
   constructor({ rpcUrl, wsUrl, assets }) {
@@ -23,6 +23,7 @@ export class WsApi {
   #resetSubscriptionState() {
     this.accountSubscriptions = Object.create(null)
     this.transactionSubscriptions = Object.create(null)
+    this.programSubscriptions = 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
@@ -30,7 +31,13 @@ export class WsApi {
   }
 
   setWsEndpoint(wsUrl) {
-    this.wsUrl = wsUrl || WS_ENDPOINT
+    this.wsUrl = wsUrl || HELIUS_WS_URL
+  }
+
+  /** True when using Helius Enhanced WebSocket (different transactionSubscribe params and notification shape). */
+  #isHelius() {
+    if (!this.wsUrl) return false
+    return this.wsUrl.includes('helius') || this.wsUrl === HELIUS_WS_URL
   }
 
   /**
@@ -174,36 +181,79 @@ export class WsApi {
 
     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]
+  }
+
+  async programSubscribe({ owner }) {
+    const conn = this.connection
+    if (!conn || !conn.isOpen) {
+      console.warn('SOL Connection is not open, cannot programSubscribe for', owner)
+      return
+    }
+
+    if (this.programSubscriptions[owner]) return // already subscribed (SPL + Token-2022)
+
+    const splTokenProgramId = TOKEN_PROGRAM_ID.toBase58()
+    const token2022ProgramId = TOKEN_2022_PROGRAM_ID.toBase58()
+    const tokenAccountDataSize = 165
+
+    // SPL Token: fixed 165-byte account size
+    const id1 = ++conn.seq
+    this.pendingSubscriptionRequests[id1] = { owner, type: 'program' }
+    conn.send({
+      jsonrpc: '2.0',
+      id: id1,
+      method: 'programSubscribe',
       params: [
+        splTokenProgramId,
         {
-          vote: false,
-          accounts: {
-            include: difference,
-          },
+          encoding: 'jsonParsed',
+          commitment: 'confirmed',
+          filters: [{ dataSize: tokenAccountDataSize }, { memcmp: { offset: 32, bytes: owner } }],
         },
+      ],
+    })
+
+    // Token-2022: no dataSize filter (accounts can have extensions and be larger than 165 bytes)
+    const id2 = ++conn.seq
+    this.pendingSubscriptionRequests[id2] = { owner, type: 'program' }
+    conn.send({
+      jsonrpc: '2.0',
+      id: id2,
+      method: 'programSubscribe',
+      params: [
+        token2022ProgramId,
         {
-          commitment: 'confirmed',
           encoding: 'jsonParsed',
-          transactionDetails: 'full',
-          showRewards: false,
-          maxSupportedTransactionVersion: 255,
+          commitment: 'confirmed',
+          filters: [{ memcmp: { offset: 32, bytes: owner } }],
         },
       ],
     })
-    this.transactionSubscriptions[owner] = [...subscriptions, ...difference]
+
+    this.programSubscriptions[owner] = true
   }
 
   async sendSubscriptions({ address, tokensAddresses = [] }) {
-    const conn = this.connection
-
     const addresses = [address, ...tokensAddresses]
 
     // 1. subscribe to each addresses (SOL and Token addresses) balance events
-    // transform this forEach in a for of to await each subscription:
     for (const addr of addresses) {
       await this.accountSubscribe({ owner: address, account: addr })
     }
@@ -212,48 +262,7 @@ export class WsApi {
     await this.transactionSubscribe({ owner: address, accounts: addresses })
 
     // 3. subscribe to SPL Token and Token-2022 program account changes to detect new token accounts for this wallet
-    const splTokenProgramId = TOKEN_PROGRAM_ID.toBase58()
-    const token2022ProgramId = TOKEN_2022_PROGRAM_ID.toBase58()
-    const tokenAccountDataSize = 165
-
-    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: id1,
-        method: 'programSubscribe',
-        params: [
-          splTokenProgramId,
-          {
-            encoding: 'jsonParsed',
-            commitment: 'confirmed',
-            filters: [
-              { dataSize: tokenAccountDataSize },
-              { memcmp: { offset: 32, bytes: address } },
-            ],
-          },
-        ],
-      })
-
-      // 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: id2,
-        method: 'programSubscribe',
-        params: [
-          token2022ProgramId,
-          {
-            encoding: 'jsonParsed',
-            commitment: 'confirmed',
-            filters: [{ memcmp: { offset: 32, bytes: address } }],
-          },
-        ],
-      })
-    }
+    await this.programSubscribe({ owner: address })
   }
 
   async unwatchAddress({ address }) {
@@ -283,6 +292,7 @@ export class WsApi {
     delete this.watchedAddresses[address]
     delete this.accountSubscriptions[address]
     delete this.transactionSubscriptions[address]
+    delete this.programSubscriptions[address]
 
     if (Object.keys(this.watchedAddresses).length === 0 && conn) {
       await conn.stop()
@@ -333,22 +343,27 @@ export class WsApi {
     }
   }
 
+  /**
+   * Parse accountNotification from Triton or Helius.
+   * Triton: params.result = { context, value }. Helius: same shape (result.value = account).
+   */
   parseAccountNotification({ address, walletAccount, tokenAccountsByOwner, result }) {
-    const isSolAccount = result.value.owner === '11111111111111111111111111111111' // System Program
+    const value = result?.value ?? result // support both { context, value } and flat result
+    const isSolAccount = value.owner === '11111111111111111111111111111111' // System Program
     if (isSolAccount) {
       // SOL balance changed
-      const amount = result.value.lamports
+      const amount = value.lamports
       return { solAddress: address, amount }
     }
 
-    const isSplTokenAccount = result.value.owner === TOKEN_PROGRAM_ID.toBase58()
-    const isSpl2022TokenAccount = result.value.owner === TOKEN_2022_PROGRAM_ID.toBase58()
+    const isSplTokenAccount = value.owner === TOKEN_PROGRAM_ID.toBase58()
+    const isSpl2022TokenAccount = value.owner === TOKEN_2022_PROGRAM_ID.toBase58()
 
     // SPL Token balance changed (both spl-token and spl-2022 have the first 165 bytes the same)
     if (isSplTokenAccount || isSpl2022TokenAccount) {
       // Handle jsonParsed encoding (data is an object with parsed info)
-      if (result.value.data?.parsed?.info) {
-        const parsed = result.value.data.parsed.info
+      if (value.data?.parsed?.info) {
+        const parsed = value.data.parsed.info
         return {
           solAddress: parsed.owner,
           amount: parsed.tokenAmount.amount,
@@ -357,7 +372,7 @@ export class WsApi {
       }
 
       // Handle base64 encoding (data is an array: [base64_string, "base64"])
-      const decoded = Token.decode(Buffer.from(result.value.data[0], 'base64'))
+      const decoded = Token.decode(Buffer.from(value.data[0], 'base64'))
       const tokenMintAddress = new PublicKey(decoded.mint).toBase58()
       const solAddress = new PublicKey(decoded.owner).toBase58()
       const amount = U64.fromBuffer(decoded.amount).toString()
@@ -407,7 +422,12 @@ export class WsApi {
     tokenAccountsByOwner,
     result,
   }) {
-    const rawTransaction = result?.value ? result.value.transaction : result.transaction // for Triton Whirligig OR Helius Advanced WS
+    // Triton: result = { context, value: { transaction } }. Helius: result = { slot, signature, transaction, transactionIndex }.
+    const rawTransaction = result?.value?.transaction ?? result?.transaction
+    if (rawTransaction && result?.slot != null && rawTransaction.slot == null) {
+      rawTransaction.slot = result.slot // Helius puts slot on result, parser expects it on tx
+    }
+
     const parsedTx = parseTransaction(address, rawTransaction, tokenAccountsByOwner || [])
     const timestamp = Date.now() // the notification event has no blockTime