@exodus/solana-api 3.27.8 → 3.29.0

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.29.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.28.0...@exodus/solana-api@3.29.0) (2026-02-03)
+
+
+### Features
+
+
+* feat(solana): add getDelegatedAddresses to full asset (#7377)
+
+
+
+## [3.28.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.27.8...@exodus/solana-api@3.28.0) (2026-02-02)
+
+
+### Features
+
+
+* feat(solana): reintroduce solana SPL delegation (#7353)
+
+
+
 ## [3.27.8](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.27.7...@exodus/solana-api@3.27.8) (2026-01-27)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.27.8",
+  "version": "3.29.0",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Solana",
   "type": "module",
   "main": "src/index.js",
@@ -33,7 +33,7 @@
     "@exodus/fetch": "^1.7.3",
     "@exodus/models": "^12.0.1",
     "@exodus/simple-retry": "^0.0.6",
-    "@exodus/solana-lib": "^3.19.2",
+    "@exodus/solana-lib": "^3.20.1",
     "@exodus/solana-meta": "^2.0.2",
     "@exodus/timer": "^1.1.1",
     "debug": "^4.1.1",
@@ -49,7 +49,7 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "8975d39bf67554be2555effb3d3cd9d9e0b2d84b",
+  "gitHead": "d844d6fa5e5eec3c7b279ee5317f676357eb82b2",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/account-state.js

@@ -37,6 +37,11 @@ export const createAccountState = ({ assetList }) => {
         earned: asset.currency.defaultUnit(0),
         accounts: Object.create(null), // stake accounts
       },
+      tokenDelegationInfo: {
+        loaded: false,
+        delegatedAccounts: [],
+        delegatedBalances: Object.create(null),
+      },
     }
 
     static _tokens = [asset, ...tokens] // deprecated - will be removed

package/src/api.js

@@ -7,7 +7,9 @@ import {
   buildRawTransaction,
   computeBalance,
   deserializeMetaplexMetadata,
+  EXOD_SHARES_MINT_ADDRESS,
   filterAccountsByOwner,
+  findAssociatedTokenAddress,
   getMetadataAccount,
   getTransactionSimulationParams,
   SOL_DECIMAL,
@@ -21,6 +23,10 @@ import ms from 'ms'
 import urljoin from 'url-join'
 
 import { getStakeActivation } from './get-stake-activation/index.js'
+import {
+  fetchDelegatedBalances as _fetchDelegatedBalances,
+  fetchValidatedDelegation as _fetchValidatedDelegation,
+} from './tx-log/delegation-utils.js'
 import { parseTransaction } from './tx-parser.js'
 import { isSolAddressPoisoningTx } from './txs-utils.js'
 
@@ -67,8 +73,10 @@ export class Api {
   }
 
   setTokens(assets = {}) {
-    const solTokens = pickBy(assets, (asset) => asset.name !== asset.baseAsset.name)
-    this.tokens = new Map(Object.values(solTokens).map((v) => [v.mintAddress, v]))
+    this.tokensByName = pickBy(assets, (asset) => asset.name !== asset.baseAsset.name)
+    this.tokens = new Map(
+      Object.values(this.tokensByName).map((token) => [token.mintAddress, token])
+    )
   }
 
   request(path, contentType = 'application/json') {
@@ -420,6 +428,23 @@ export class Api {
     ].includes(owner)
   }
 
+  async fetchValidatedDelegation({ delegatedAddress, expectedDelegate }) {
+    return _fetchValidatedDelegation({
+      rpcCall: (method, params) => this.rpcCall(method, params),
+      delegatedAddress,
+      expectedDelegate,
+    })
+  }
+
+  async fetchDelegatedBalances({ delegatedAccounts, address }) {
+    return _fetchDelegatedBalances({
+      rpcCall: (method, params) => this.rpcCall(method, params),
+      delegatedAccounts,
+      address,
+      assets: this.tokensByName,
+    })
+  }
+
   ataOwnershipChangedCached = memoizeLruCache(
     (...args) => this.ataOwnershipChanged(...args),
     (address, tokenAddress) => `${address}:${tokenAddress}`,
@@ -504,6 +529,45 @@ export class Api {
     return lodash.get(value, 'data.parsed.info.mint', null)
   }
 
+  async isWhitelisted({ address, tokenMintAddress = EXOD_SHARES_MINT_ADDRESS }) {
+    // check if address is whitelisted for a specific token (e.g. EXOD shares)
+    // Returns true if the ATA exists, is not frozen, and can receive the token
+    try {
+      // Derive the associated token account address for the given owner and mint
+      // EXOD is a Token-2022, so we use TOKEN_2022_PROGRAM_ID
+      const associatedTokenAddress = findAssociatedTokenAddress(
+        address,
+        tokenMintAddress,
+        TOKEN_2022_PROGRAM_ID.toBase58()
+      )
+
+      // Get the token account info to check if it exists and its state
+      const accountInfo = await this.getAccountInfo(associatedTokenAddress)
+
+      // If account doesn't exist, it's not whitelisted
+      if (!accountInfo || !accountInfo.data) {
+        return false
+      }
+
+      const parsedInfo = accountInfo.data?.parsed?.info
+
+      // Check if the mint matches
+      if (parsedInfo?.mint !== tokenMintAddress) {
+        return false
+      }
+
+      // Check if the account is frozen
+      // State can be "initialized" (not frozen) or "frozen"
+      const state = parsedInfo?.state
+
+      // Account exists, mint matches, and is not frozen - whitelisted
+      return state !== 'frozen'
+    } catch (error) {
+      console.warn('isWhitelisted error:', error)
+      return false
+    }
+  }
+
   async isTokenAddress(address) {
     const type = await this.getAddressType(address)
     return ['token', 'token-2022'].includes(type)

package/src/create-unsigned-tx-for-send.js

@@ -119,17 +119,54 @@ export const createTxFactory = ({ assetClientInterface, api, feePayerClient }) =
         throw err
       }
 
-      const [destinationAddressType, isAssociatedTokenAccountActive, fromTokenAccountAddresses] =
-        await Promise.all([
-          api.getAddressType(toAddress),
-          api.isAssociatedTokenAccountActive(tokenAddress),
-          api.getTokenAccountsByOwner(fromAddress),
-        ])
-
-      const fromTokenAddresses = fromTokenAccountAddresses.filter(
+      const [
+        destinationAddressType,
+        isAssociatedTokenAccountActive,
+        fromTokenAccountAddresses,
+        accountState,
+      ] = await Promise.all([
+        api.getAddressType(toAddress),
+        api.isAssociatedTokenAccountActive(tokenAddress),
+        api.getTokenAccountsByOwner(fromAddress),
+        assetClientInterface.getAccountState({ walletAccount, assetName: baseAssetName }),
+      ])
+
+      const ownedForMint = fromTokenAccountAddresses.filter(
         ({ mintAddress }) => mintAddress === tokenMintAddress
       )
 
+      const delegatedAccounts = accountState.tokenDelegationInfo?.delegatedAccounts || []
+      const delegatedAccountsResults = await Promise.all(
+        delegatedAccounts
+          .filter(({ assetName }) => assetName === asset.name)
+          .map(async ({ delegatedAddress }) => {
+            try {
+              const delegation = await api.fetchValidatedDelegation({
+                delegatedAddress,
+                expectedDelegate: fromAddress,
+              })
+
+              if (!delegation) return null
+
+              return {
+                tokenAccountAddress: delegatedAddress,
+                mintAddress: tokenMintAddress,
+                balance: delegation.balance,
+                decimals: delegation.decimals,
+                tokenProgram: delegation.tokenProgram,
+                isDelegated: true,
+                delegatedAmount: delegation.delegatedAmount,
+              }
+            } catch (error) {
+              console.warn(`Failed to fetch delegated account ${delegatedAddress}:`, error)
+              return null
+            }
+          })
+      )
+      const validDelegatedAccounts = delegatedAccountsResults.filter(Boolean)
+
+      const fromTokenAddresses = [...ownedForMint, ...validDelegatedAccounts]
+
       tokenParams = {
         tokenMintAddress,
         destinationAddressType,

package/src/get-balances.js

@@ -149,11 +149,15 @@ const fixBalances = ({
 }
 
 const getBalanceFromAccountState = ({ asset, accountState }) => {
-  const isBase = asset.name === asset.baseAsset.name
-  return (
-    (isBase ? accountState?.balance : accountState?.tokenBalances?.[asset.name]) ||
-    asset.currency.ZERO
-  )
+  if (asset.name === asset.baseAsset.name) {
+    return accountState.balance || asset.currency.ZERO
+  }
+
+  const ownedBalance = accountState.tokenBalances?.[asset.name] || asset.currency.ZERO
+  const delegatedBalance =
+    accountState.tokenDelegationInfo?.delegatedBalances?.[asset.name] || asset.currency.ZERO
+
+  return ownedBalance.add(delegatedBalance)
 }
 
 const hasStakedFunds = ({ locked, activating, withdrawable, pending }) =>

package/src/index.js

@@ -22,6 +22,7 @@ export { stakingProviderClientFactory } from './staking-provider-client.js'
 export { createTxFactory } from './create-unsigned-tx-for-send.js'
 export { feePayerClientFactory } from './fee-payer.js'
 export { createInitAgentWalletFactory } from './init-agent-wallet.js'
+export { createTokenDelegationFactory } from './token-delegation.js'
 
 // These are not the same asset objects as the wallet creates, so they should never be returned to the wallet.
 // Initially this may be violated by the Solana code until the first monitor tick updates assets with setTokens()

package/src/rpc-api.js

@@ -5,7 +5,9 @@ import {
   buildRawTransaction,
   computeBalance,
   deserializeMetaplexMetadata,
+  EXOD_SHARES_MINT_ADDRESS,
   filterAccountsByOwner,
+  findAssociatedTokenAddress,
   getMetadataAccount,
   getTransactionSimulationParams,
   SOL_DECIMAL,
@@ -17,6 +19,10 @@ import assert from 'minimalistic-assert'
 import ms from 'ms'
 
 import { getStakeActivation } from './get-stake-activation/index.js'
+import {
+  fetchDelegatedBalances as _fetchDelegatedBalances,
+  fetchValidatedDelegation as _fetchValidatedDelegation,
+} from './tx-log/delegation-utils.js'
 
 const [SYSTEM_PROGRAM_ID, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID] = [
   SYSTEM_PROGRAM_ID_KEY.toBase58(),
@@ -62,8 +68,10 @@ export class RpcApi {
   }
 
   setTokens(assets) {
-    const solTokens = pickBy(assets, (asset) => asset.name !== asset.baseAsset.name)
-    this.tokens = new Map(Object.values(solTokens).map((v) => [v.mintAddress, v]))
+    this.tokensByName = pickBy(assets, (asset) => asset.name !== asset.baseAsset.name)
+    this.tokens = new Map(
+      Object.values(this.tokensByName).map((token) => [token.mintAddress, token])
+    )
   }
 
   async rpcCall(method, params = []) {
@@ -117,6 +125,45 @@ export class RpcApi {
     return this.rpcCall('getBlockTime', [slot])
   }
 
+  async isWhitelisted({ address, tokenMintAddress = EXOD_SHARES_MINT_ADDRESS }) {
+    // check if address is whitelisted for a specific token (e.g. EXOD shares)
+    // Returns true if the ATA exists, is not frozen, and can receive the token
+    try {
+      // Derive the associated token account address for the given owner and mint
+      // EXOD is a Token-2022, so we use TOKEN_2022_PROGRAM_ID
+      const associatedTokenAddress = findAssociatedTokenAddress(
+        address,
+        tokenMintAddress,
+        TOKEN_2022_PROGRAM_ID
+      )
+
+      // Get the token account info to check if it exists and its state
+      const accountInfo = await this.getRawAccountInfo({ address: associatedTokenAddress })
+
+      // If account doesn't exist, it's not whitelisted
+      if (!accountInfo || !accountInfo.data) {
+        return false
+      }
+
+      const parsedInfo = accountInfo.data?.parsed?.info
+
+      // Check if the mint matches
+      if (parsedInfo?.mint !== tokenMintAddress) {
+        return false
+      }
+
+      // Check if the account is frozen
+      // State can be "initialized" (not frozen) or "frozen"
+      const state = parsedInfo?.state
+
+      // Account exists, mint matches, and is not frozen - whitelisted
+      return state !== 'frozen'
+    } catch (error) {
+      console.warn('isWhitelisted error:', error)
+      return false
+    }
+  }
+
   async waitForTransactionStatus(txIds, status = 'finalized', timeoutMs = ms('1m')) {
     if (!Array.isArray(txIds)) txIds = [txIds]
     const startTime = Date.now()
@@ -173,6 +220,14 @@ export class RpcApi {
     return [TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID].includes(owner)
   }
 
+  async getRawAccountInfo({ address, encoding = 'jsonParsed' }) {
+    const { value } = await this.rpcCall('getAccountInfo', [
+      address,
+      { encoding, commitment: 'confirmed' },
+    ])
+    return value
+  }
+
   async getTokenBalance(tokenAddress) {
     // Returns account balance of a SPL Token account.
     const result = await this.rpcCall('getTokenAccountBalance', [tokenAddress])
@@ -406,6 +461,23 @@ export class RpcApi {
     }
   }
 
+  async fetchValidatedDelegation({ delegatedAddress, expectedDelegate }) {
+    return _fetchValidatedDelegation({
+      rpcCall: (method, params) => this.rpcCall(method, params),
+      delegatedAddress,
+      expectedDelegate,
+    })
+  }
+
+  async fetchDelegatedBalances({ delegatedAccounts, address }) {
+    return _fetchDelegatedBalances({
+      rpcCall: (method, params) => this.rpcCall(method, params),
+      delegatedAccounts,
+      address,
+      assets: this.tokensByName,
+    })
+  }
+
   simulateUnsignedTransaction = async ({ message, transactionMessage }) => {
     const { config, accountAddresses } = getTransactionSimulationParams(
       transactionMessage || message

package/src/token-delegation.js

@@ -0,0 +1,129 @@
+import {
+  createApproveDelegationTx,
+  createRevokeDelegationTx,
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+} 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')
+
+  const approveDelegation = async ({
+    asset,
+    walletAccount,
+    delegateAddress,
+    amount,
+    tokenProgram,
+  }) => {
+    assert(asset, 'asset is required')
+    assert(walletAccount, 'walletAccount is required')
+    assert(delegateAddress, 'delegateAddress is required')
+
+    const baseAssetName = asset.baseAsset.name
+    const assetName = asset.name
+    const tokenMintAddress = asset.mintAddress
+    assert(tokenMintAddress, 'asset must be a token with mintAddress')
+
+    const ownerAddress = await assetClientInterface.getReceiveAddress({
+      assetName: baseAssetName,
+      walletAccount,
+    })
+
+    const recentBlockhash = await api.getRecentBlockHash()
+
+    const transaction = createApproveDelegationTx({
+      ownerAddress,
+      tokenMintAddress,
+      delegateAddress,
+      amount,
+      recentBlockhash,
+      tokenProgram,
+    })
+
+    return {
+      unsignedTx: {
+        txData: { transaction },
+        txMeta: { assetName },
+      },
+    }
+  }
+
+  const revokeDelegation = async ({ asset, walletAccount, tokenProgram }) => {
+    assert(asset, 'asset is required')
+    assert(walletAccount, 'walletAccount is required')
+
+    const baseAssetName = asset.baseAsset.name
+    const assetName = asset.name
+    const tokenMintAddress = asset.mintAddress
+    assert(tokenMintAddress, 'asset must be a token with mintAddress')
+
+    const ownerAddress = await assetClientInterface.getReceiveAddress({
+      assetName: baseAssetName,
+      walletAccount,
+    })
+
+    const recentBlockhash = await api.getRecentBlockHash()
+
+    const transaction = createRevokeDelegationTx({
+      ownerAddress,
+      tokenMintAddress,
+      recentBlockhash,
+      tokenProgram,
+    })
+
+    return {
+      unsignedTx: {
+        txData: { transaction },
+        txMeta: { assetName },
+      },
+    }
+  }
+
+  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 }
+}

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

@@ -271,12 +271,18 @@ export class SolanaClarityMonitor extends BaseMonitor {
   }
 
   async getAccountsAndBalances({ refresh, address, accountState, walletAccount }) {
-    const [accountInfo, { balances: splBalances, accounts: tokenAccounts }] = await Promise.all([
-      this.clarityApi.getAccountInfo(address).catch(() => {}),
-      this.clarityApi.getTokensBalancesAndAccounts({
-        address,
-      }),
-    ])
+    const delegatedAccounts = accountState.tokenDelegationInfo?.delegatedAccounts || []
+    const [accountInfo, { balances: splBalances, accounts: tokenAccounts }, delegatedBalances] =
+      await Promise.all([
+        this.clarityApi.getAccountInfo(address).catch(() => {}),
+        this.clarityApi.getTokensBalancesAndAccounts({
+          address,
+        }),
+        this.clarityApi.fetchDelegatedBalances({
+          delegatedAccounts,
+          address,
+        }),
+      ])
 
     const solBalance = accountInfo?.lamports || 0
 
@@ -332,6 +338,8 @@ export class SolanaClarityMonitor extends BaseMonitor {
       account: {
         balance,
         tokenBalances,
+        delegatedAccounts,
+        delegatedBalances,
         rentExemptAmount,
         accountSize,
         ownerChanged,
@@ -343,13 +351,26 @@ export class SolanaClarityMonitor extends BaseMonitor {
 
   updateState({ account, cursorState = {}, walletAccount, staking, batch }) {
     const assetName = this.asset.name
-    const { balance, tokenBalances, rentExemptAmount, accountSize, ownerChanged } = account
+    const {
+      balance,
+      tokenBalances,
+      delegatedAccounts,
+      delegatedBalances,
+      rentExemptAmount,
+      accountSize,
+      ownerChanged,
+    } = account
     const newData = {
       balance,
       rentExemptAmount,
       accountSize,
       ownerChanged,
       tokenBalances,
+      tokenDelegationInfo: {
+        loaded: true,
+        delegatedAccounts: delegatedAccounts || [],
+        delegatedBalances: delegatedBalances || Object.create(null),
+      },
       stakingInfo: staking,
       ...cursorState,
     }

package/src/tx-log/delegation-utils.js

@@ -0,0 +1,63 @@
+async function fetchDelegatedAccountInfo({ rpcCall, delegatedAddress }) {
+  return rpcCall('getAccountInfo', [delegatedAddress, { encoding: 'jsonParsed' }], {
+    address: delegatedAddress,
+  })
+}
+
+function parseDelegationInfo({ accountInfo, expectedDelegate }) {
+  if (!accountInfo?.value?.data?.parsed) return null
+
+  const info = accountInfo.value.data.parsed.info
+  if (info.delegate !== expectedDelegate) return null
+
+  return {
+    balance: info.tokenAmount?.amount || '0',
+    decimals: info.tokenAmount?.decimals || 0,
+    delegatedAmount: info.delegatedAmount?.amount || '0',
+    tokenProgram: accountInfo.value.owner,
+  }
+}
+
+function calculateSpendableAmount({ balance, delegatedAmount }) {
+  return BigInt(balance) < BigInt(delegatedAmount) ? balance : delegatedAmount
+}
+
+export async function fetchValidatedDelegation({ rpcCall, delegatedAddress, expectedDelegate }) {
+  const accountInfo = await fetchDelegatedAccountInfo({ rpcCall, delegatedAddress })
+  return parseDelegationInfo({ accountInfo, expectedDelegate })
+}
+
+export async function fetchDelegatedBalances({ delegatedAccounts, address, assets, rpcCall }) {
+  const delegatedBalances = Object.create(null)
+
+  if (delegatedAccounts.length === 0) return delegatedBalances
+
+  for (const { delegatedAddress, assetName } of delegatedAccounts) {
+    try {
+      const delegation = await fetchValidatedDelegation({
+        rpcCall,
+        delegatedAddress,
+        expectedDelegate: address,
+      })
+
+      if (!delegation) continue
+      if (!assets[assetName]) continue
+
+      const spendable = calculateSpendableAmount({
+        balance: delegation.balance,
+        delegatedAmount: delegation.delegatedAmount,
+      })
+      const amount = assets[assetName].currency.baseUnit(spendable)
+
+      if (delegatedBalances[assetName]) {
+        delegatedBalances[assetName] = delegatedBalances[assetName].add(amount)
+      } else {
+        delegatedBalances[assetName] = amount
+      }
+    } catch (error) {
+      console.warn(`Failed to fetch delegated account ${delegatedAddress}:`, error)
+    }
+  }
+
+  return delegatedBalances
+}

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

@@ -254,14 +254,20 @@ export class SolanaMonitor extends BaseMonitor {
   }
 
   async getAccountsAndBalances({ refresh, address, accountState, walletAccount }) {
+    const delegatedAccounts = accountState.tokenDelegationInfo?.delegatedAccounts || []
     const tokens = Object.keys(this.assets).filter((name) => name !== this.asset.name)
-    const [accountInfo, { balances: splBalances, accounts: tokenAccounts }] = await Promise.all([
-      this.rpcApi.getAccountInfo(address).catch(() => {}),
-      this.rpcApi.getTokensBalancesAndAccounts({
-        address,
-        filterByTokens: tokens,
-      }),
-    ])
+    const [accountInfo, { balances: splBalances, accounts: tokenAccounts }, delegatedBalances] =
+      await Promise.all([
+        this.rpcApi.getAccountInfo(address).catch(() => {}),
+        this.rpcApi.getTokensBalancesAndAccounts({
+          address,
+          filterByTokens: tokens,
+        }),
+        this.rpcApi.fetchDelegatedBalances({
+          delegatedAccounts,
+          address,
+        }),
+      ])
 
     const solBalance = accountInfo?.lamports || 0
 
@@ -309,6 +315,8 @@ export class SolanaMonitor extends BaseMonitor {
       account: {
         balance,
         tokenBalances,
+        delegatedAccounts,
+        delegatedBalances,
         rentExemptAmount,
         accountSize,
         ownerChanged,
@@ -320,13 +328,26 @@ export class SolanaMonitor extends BaseMonitor {
 
   updateState({ account, cursorState = {}, walletAccount, staking, batch }) {
     const assetName = this.asset.name
-    const { balance, tokenBalances, rentExemptAmount, accountSize, ownerChanged } = account
+    const {
+      balance,
+      tokenBalances,
+      delegatedAccounts,
+      delegatedBalances,
+      rentExemptAmount,
+      accountSize,
+      ownerChanged,
+    } = account
     const newData = {
       balance,
       rentExemptAmount,
       accountSize,
       ownerChanged,
       tokenBalances,
+      tokenDelegationInfo: {
+        loaded: true,
+        delegatedAccounts: delegatedAccounts || [],
+        delegatedBalances: delegatedBalances || Object.create(null),
+      },
       stakingInfo: staking,
       ...cursorState,
     }