@exodus/solana-api 3.29.1 → 3.29.2

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [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.2",
   "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": "167b72157b276c512c14870fe16792cba83ea5e2",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

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