@exodus/solana-api 3.27.8 → 3.28.0

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.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.28.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.0",
     "@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": "3cea3bc89ff5c4aaa461ac148e384ea24dbe2d38",
   "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

@@ -21,6 +21,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 +71,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 +426,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}`,

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

@@ -17,6 +17,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 +66,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 = []) {
@@ -406,6 +412,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,80 @@
+import { createApproveDelegationTx, createRevokeDelegationTx } from '@exodus/solana-lib'
+import assert from 'minimalistic-assert'
+
+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 },
+      },
+    }
+  }
+
+  return { approveDelegation, revokeDelegation }
+}

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