@exodus/solana-api 3.29.1 → 3.29.3

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.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)
+
+
+### Bug Fixes
+
+
+* fix: getAccountInfo 3rd param (#7396)
+
+
+
 ## [3.29.1](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.29.0...@exodus/solana-api@3.29.1) (2026-02-03)
 
 

package/package.json

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

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,167 @@
+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 = ({ asset, createTx, sendTx, stakingProviderClient }) => {
+  const stakingProvider = stakingProviderClient ?? stakingProviderClientFactory()
+
+  async function sendStake({
+    address,
+    walletAccount,
+    method,
+    amount,
+    stakeAddresses,
+    accounts,
+    seed,
+    pool,
+  }) {
+    let error
+    let result
+
+    try {
+      const { unsignedTx } = await createTx({
+        asset,
+        walletAccount,
+        fromAddress: address,
+        address,
+        amount: amount ?? asset.currency.ZERO,
+        method,
+        stakeAddresses,
+        accounts,
+        seed,
+        pool,
+      })
+
+      const sendResult = await 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 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/tx-log/delegation-utils.js

@@ -1,7 +1,5 @@
 async function fetchDelegatedAccountInfo({ rpcCall, delegatedAddress }) {
-  return rpcCall('getAccountInfo', [delegatedAddress, { encoding: 'jsonParsed' }], {
-    address: delegatedAddress,
-  })
+  return rpcCall('getAccountInfo', [delegatedAddress, { encoding: 'jsonParsed' }])
 }
 
 function parseDelegationInfo({ accountInfo, expectedDelegate }) {

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

@@ -26,6 +26,7 @@ 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(
@@ -49,7 +50,7 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
       useCache: true,
     })
 
-    const { accounts: tokenAccountsByOwner } = await this.clarityApi.getTokensBalancesAndAccounts({
+    const { accounts: tokenAccountsByOwner } = await this.rpcApi.getTokensBalancesAndAccounts({
       address,
     })
     this.tokenAccountsByOwner[walletAccount] = tokenAccountsByOwner
@@ -81,62 +82,11 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
   }
 
   async tick({ walletAccount, refresh }) {
-    // we tick using Clarity only on startup, then we rely only on WS events and we periodically check for new tokens only.
+    // we tick using Clarity only on startup or explicit refresh; otherwise we rely on WS events
+    // and programSubscribe for new SPL / Token-2022 accounts (no periodic getTokensBalancesAndAccounts).
     if (refresh || this.tickCount[walletAccount] === 0) {
       return super.tick({ walletAccount, refresh }) // Clarity refresh or first tick
     }
-
-    const assetName = this.asset.name
-    this.assets = await this.aci.getAssetsForNetwork({ baseAssetName: assetName })
-    this.clarityApi.setTokens(this.assets)
-    const address = await this.aci.getReceiveAddress({
-      assetName,
-      walletAccount,
-      useCache: true,
-    })
-
-    // we only update balance of the tokens we just subcribed to:
-    const accountState = await this.aci.getAccountState({
-      assetName: this.asset.name,
-      walletAccount,
-    })
-
-    // we call this periodically to detect new token accounts created (there's not a WS event for this in Helius yet, we need programSubscribe)
-    const { accounts: tokenAccounts, balances: splBalances } =
-      await this.clarityApi.getTokensBalancesAndAccounts({
-        address,
-      })
-    this.tokenAccountsByOwner[walletAccount] = tokenAccounts
-
-    const unknownTokensList = await this.emitUnknownTokensEvent({
-      tokenAccounts,
-    })
-
-    // subscribe to new tokenAccounts
-    for (const mintAddress of unknownTokensList) {
-      const tokenName = this.clarityApi.tokens.get(mintAddress)?.name
-      if (!tokenName) {
-        console.log(`Unknown token mint address: ${mintAddress}`)
-        continue
-      }
-
-      const tokenAccountAddress = tokenAccounts.find(
-        (acc) => acc.mintAddress === mintAddress
-      )?.tokenAccountAddress
-      await this.wsApi.accountSubscribe({ owner: address, account: tokenAccountAddress })
-
-      // update only token balances for known tokens
-      const amount = splBalances[mintAddress]
-      const newData = {
-        tokenBalances: {
-          ...accountState.tokenBalances,
-          [tokenName]: this.assets[tokenName].currency.baseUnit(amount),
-        },
-      }
-      await this.#updateStateBatch({ newData, walletAccount })
-    }
-
-    // await this.updateState({ account, walletAccount, staking }) // we could update tokenBalances but we gotta test for race-conditions
   }
 
   async #handleMessage({ address, walletAccount, data }) {
@@ -153,11 +103,65 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
       4.	After 2 seconds, close the window and execute the batch.
     */
 
-    if (['accountNotification', 'transactionNotification'].includes(data?.method)) {
+    if (
+      ['accountNotification', 'transactionNotification', 'programNotification'].includes(
+        data?.method
+      )
+    ) {
       this.#ensureBatch(walletAccount)
     }
 
     switch (data?.method) {
+      case 'programNotification': {
+        // new or updated SPL / Token-2022 account for our wallet (from programSubscribe)
+        const parsed = this.wsApi.parseProgramNotification({
+          result: data.params?.result,
+          ownerAddress: address,
+        })
+        if (!parsed) return
+        const tokenAccountsByOwnerList = this.tokenAccountsByOwner[walletAccount] || []
+        const existing = tokenAccountsByOwnerList.find(
+          (acc) => acc.tokenAccountAddress === parsed.tokenAccountAddress
+        )
+        if (existing) {
+          // balance update only; accountNotification will also fire for this account
+          return
+        }
+
+        const tokenMeta = this.clarityApi.tokens.get(parsed.mintAddress)
+        const tokenName = tokenMeta?.name
+        const newAccount = {
+          tokenAccountAddress: parsed.tokenAccountAddress,
+          owner: parsed.owner,
+          tokenName: tokenName ?? 'unknown',
+          ticker: tokenMeta?.ticker ?? 'UNKNOWN',
+          balance: parsed.amount,
+          mintAddress: parsed.mintAddress,
+          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 })
+
+        const unknownTokensList = await this.emitUnknownTokensEvent({
+          tokenAccounts: this.tokenAccountsByOwner[walletAccount],
+        })
+        if (!unknownTokensList.includes(parsed.mintAddress) && tokenName) {
+          const newData = {
+            tokenBalances: {
+              ...accountState.tokenBalances,
+              [tokenName]: this.assets[tokenName].currency.baseUnit(parsed.amount),
+            },
+          }
+          await this.#updateStateBatch({ newData, walletAccount })
+        }
+
+        return
+      }
+
       case 'accountNotification':
         // balance changed events for known tokens or SOL address
 
@@ -224,13 +228,47 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
         }
 
         return
-      case 'transactionNotification':
+      case 'transactionNotification': {
         // update tx-log with new txs and state with cursor
 
-        // NB. if we receive a tx with a new "token", never received before,
-        // this.clarityApi.tokens will be populated with new tokens only after we ran a monitor tick
-        // since the unknown-tokens event is captured and processed in other places.
-        // hence what happens is we skip the txLog update for that new token.
+        // Populate tokenAccountsByOwner from this tx first (e.g. new ATA created in same tx)
+        // so we can parse and update history; otherwise "cannot parse tx" would trigger for new receives
+        const rawTransaction =
+          data.params.result?.value?.transaction ?? data.params.result?.transaction
+        const txTokenAccounts = this.wsApi.getTokenAccountsFromTxMeta(rawTransaction, address)
+        let tokenAccountsByOwnerList = this.tokenAccountsByOwner[walletAccount] || []
+        for (const txAcc of txTokenAccounts) {
+          if (
+            tokenAccountsByOwnerList.some(
+              (a) => a.tokenAccountAddress === txAcc.tokenAccountAddress
+            )
+          ) {
+            continue
+          }
+
+          const tokenMeta = this.clarityApi.tokens.get(txAcc.mintAddress)
+          const newAccount = {
+            tokenAccountAddress: txAcc.tokenAccountAddress,
+            owner: txAcc.owner,
+            tokenName: tokenMeta?.name ?? 'unknown',
+            ticker: tokenMeta?.ticker ?? 'UNKNOWN',
+            balance: '0',
+            mintAddress: txAcc.mintAddress,
+            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,
+          })
+        }
+
+        this.tokenAccountsByOwner[walletAccount] = tokenAccountsByOwnerList
 
         const { logItemsByAsset, cursorState = {} } = this.wsApi.parseTransactionNotification({
           address,
@@ -238,7 +276,7 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
           baseAsset: this.asset,
           assets: this.assets,
           tokens: this.clarityApi.tokens,
-          tokenAccountsByOwner,
+          tokenAccountsByOwner: tokenAccountsByOwnerList,
           result: data.params.result, // raw tx
         })
 
@@ -262,10 +300,30 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
           refresh: false,
         })
 
-        const newData = {
-          ...cursorState,
+        // Update token balances from this tx's postTokenBalances so the first receive shows the
+        // correct balance even when accountNotification was missed (we subscribe after the tx is
+        // processed, so the balance-change notification can already have been sent).
+        const postTokenBalances = rawTransaction?.meta?.postTokenBalances ?? []
+        const tokenBalancesFromTx = {}
+        for (const b of postTokenBalances) {
+          if (b.owner !== address) continue
+          const tokenName = this.clarityApi.tokens.get(b.mint)?.name
+          if (!tokenName || !this.assets[tokenName]) continue
+          const amount = b.uiTokenAmount?.amount ?? b.amount ?? '0'
+          tokenBalancesFromTx[tokenName] = this.assets[tokenName].currency.baseUnit(amount)
         }
 
+        const newData =
+          Object.keys(tokenBalancesFromTx).length > 0
+            ? {
+                ...cursorState,
+                tokenBalances: {
+                  ...accountState.tokenBalances,
+                  ...tokenBalancesFromTx,
+                },
+              }
+            : { ...cursorState }
+
         if (stakingTx) {
           // for staking the balance is not updated by the balance handler
           // staking operations won't spend or modify the "total" wallet balance.
@@ -322,6 +380,8 @@ export class SolanaWebsocketMonitor extends SolanaClarityMonitor {
         await this.#updateStateBatch({ newData, walletAccount })
 
         return
+      }
+
       default:
         if (data?.result && typeof data.result === 'number') {
           // subscription confirmation, skip

package/src/ws-api.js

@@ -16,6 +16,7 @@ export class WsApi {
     this.setWsEndpoint(wsUrl)
     this.connections = Object.create(null)
     this.accountSubscriptions = Object.create(null)
+    this.transactionSubscriptions = Object.create(null)
   }
 
   setWsEndpoint(wsUrl) {
@@ -70,6 +71,45 @@ export class WsApi {
     this.accountSubscriptions[owner] = [...subscriptions, account]
   }
 
+  async transactionSubscribe({ owner, accounts }) {
+    if (!Array.isArray(accounts)) {
+      accounts = [accounts]
+    }
+
+    const conn = this.connections[owner]
+    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
+
+    conn.send({
+      jsonrpc: '2.0',
+      id: ++conn.seq,
+      method: 'transactionSubscribe',
+      params: [
+        {
+          vote: false,
+          accounts: {
+            include: difference,
+          },
+        },
+        {
+          commitment: 'confirmed',
+          encoding: 'jsonParsed',
+          transactionDetails: 'full',
+          showRewards: false,
+          maxSupportedTransactionVersion: 255,
+        },
+      ],
+    })
+    this.transactionSubscriptions[owner] = [...subscriptions, ...difference]
+  }
+
   async sendSubscriptions({ address, tokensAddresses = [] }) {
     const conn = this.connections[address]
 
@@ -82,33 +122,47 @@ export class WsApi {
     }
 
     // 2. subscribe to transactions involving the addresses
+    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) {
+      // SPL Token: fixed 165-byte account size
       conn.send({
         jsonrpc: '2.0',
         id: ++conn.seq,
-        method: 'transactionSubscribe',
+        method: 'programSubscribe',
         params: [
+          splTokenProgramId,
           {
-            vote: false,
-            // failed: true,
-            accounts: {
-              include: addresses,
-            },
-            // accountInclude: addresses, // Helius
+            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)
+      conn.send({
+        jsonrpc: '2.0',
+        id: ++conn.seq,
+        method: 'programSubscribe',
+        params: [
+          token2022ProgramId,
           {
-            commitment: 'confirmed',
             encoding: 'jsonParsed',
-            transactionDetails: 'full',
-            showRewards: false,
-            maxSupportedTransactionVersion: 255,
+            commitment: 'confirmed',
+            filters: [{ memcmp: { offset: 32, bytes: address } }],
           },
         ],
       })
     }
-
-    // 3. subscribe to other events, for example use programSubscribe once Helius implements it into the Advanced WebSocket
-    // to get the new token accounts events and remove the need for the RPC call in the monitor tick
   }
 
   async unwatchAddress({ address }) {
@@ -118,6 +172,49 @@ export class WsApi {
     }
   }
 
+  /**
+   * Parse programNotification (from programSubscribe to Token / Token-2022).
+   * Returns token account info if the account belongs to the given owner address, else null.
+   * @param result - data.params.result from programNotification (has context + value with pubkey, account)
+   */
+  parseProgramNotification({ result, ownerAddress }) {
+    const { value } = result || {}
+    if (!value) return null
+    const { pubkey, account } = value
+    if (!account || !pubkey) return null
+    const isTokenProgram =
+      account.owner === TOKEN_PROGRAM_ID.toBase58() ||
+      account.owner === TOKEN_2022_PROGRAM_ID.toBase58()
+    if (!isTokenProgram) return null
+
+    let owner
+    let mintAddress
+    let amount
+
+    const parsed = account?.data?.parsed?.info
+    if (parsed) {
+      owner = parsed.owner
+      mintAddress = parsed.mint
+      amount = parsed.tokenAmount?.amount ?? '0'
+    } else if (Array.isArray(account.data) && account.data[1] === 'base64') {
+      const decoded = Token.decode(Buffer.from(account.data[0], 'base64'))
+      owner = new PublicKey(decoded.owner).toBase58()
+      mintAddress = new PublicKey(decoded.mint).toBase58()
+      amount = U64.fromBuffer(decoded.amount).toString()
+    } else {
+      return null
+    }
+
+    if (owner !== ownerAddress) return null
+    return {
+      tokenAccountAddress: pubkey,
+      mintAddress,
+      amount,
+      owner,
+      tokenProgram: account.owner,
+    }
+  }
+
   parseAccountNotification({ address, walletAccount, tokenAccountsByOwner, result }) {
     const isSolAccount = result.value.owner === '11111111111111111111111111111111' // System Program
     if (isSolAccount) {
@@ -155,6 +252,34 @@ export class WsApi {
     }
   }
 
+  /**
+   * Derive token account entries from a transaction's meta (postTokenBalances / preTokenBalances)
+   * for the given owner address. Use this to augment tokenAccountsByOwner when the wallet
+   * receives a new ATA in the same tx (transactionNotification often arrives before programNotification).
+   */
+  getTokenAccountsFromTxMeta(transaction, ownerAddress) {
+    const meta = transaction?.meta
+    const accountKeys = transaction?.transaction?.message?.accountKeys ?? []
+    const getPubkey = (key) =>
+      key && typeof key === 'object' && 'pubkey' in key ? key.pubkey : key
+    const balances = [...(meta?.postTokenBalances ?? []), ...(meta?.preTokenBalances ?? [])]
+    const byAddress = new Map()
+    for (const b of balances) {
+      if (b.owner !== ownerAddress) continue
+      const key = accountKeys[b.accountIndex]
+      const pubkey = key == null ? null : getPubkey(key)
+      if (!pubkey) continue
+      if (byAddress.has(pubkey)) continue
+      byAddress.set(pubkey, {
+        tokenAccountAddress: pubkey,
+        mintAddress: b.mint,
+        owner: b.owner,
+      })
+    }
+
+    return [...byAddress.values()]
+  }
+
   parseTransactionNotification({
     address,
     walletAccount,
@@ -165,7 +290,7 @@ export class WsApi {
     result,
   }) {
     const rawTransaction = result?.value ? result.value.transaction : result.transaction // for Triton Whirligig OR Helius Advanced WS
-    const parsedTx = parseTransaction(address, rawTransaction, tokenAccountsByOwner)
+    const parsedTx = parseTransaction(address, rawTransaction, tokenAccountsByOwner || [])
     const timestamp = Date.now() // the notification event has no blockTime
 
     if (!parsedTx.from && parsedTx.tokenTxs?.length === 0) return { logItemsByAsset: {} } // cannot parse it