@exodus/solana-api 3.23.0 → 3.24.1

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.24.1](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.24.0...@exodus/solana-api@3.24.1) (2025-10-29)
+
+
+### Bug Fixes
+
+
+* fix: add missing walletAccount (#6807)
+
+
+
+## [3.24.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.23.0...@exodus/solana-api@3.24.0) (2025-10-29)
+
+
+### Features
+
+
+* feat: track delegated addresses for solana (#6796)
+
+
+
 ## [3.23.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.22.1...@exodus/solana-api@3.23.0) (2025-10-27)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.23.0",
+  "version": "3.24.1",
   "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.14.0",
+    "@exodus/solana-lib": "^3.15.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": "a5882a43d39ef9455f25523d20ed3060b40eb1a8",
+  "gitHead": "c1a2011b20de8b35640f9b0031b2afbd1abb1605",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/account-state.js

@@ -19,9 +19,11 @@ export const createAccountState = ({ assetList }) => {
       cursor: '',
       balance: asset.currency.ZERO,
       tokenBalances: Object.create(null),
+      delegatedTokenAmounts: Object.create(null),
       rentExemptAmount: asset.currency.ZERO,
       accountSize: 0,
       ownerChanged: false,
+      delegatedTokenAccounts: [],
       stakingInfo: {
         loaded: false,
         staking: {

package/src/api.js

@@ -962,6 +962,69 @@ export class Api {
       : tokenAccounts
   }
 
+  /**
+   * Get token account states for both owned and delegated accounts
+   * @param {string} address - The wallet address (potential delegate)
+   * @param {Array} delegatedAccounts - Array of delegated account objects from wallet-accounts
+   * @returns {Promise<Array>} Combined list of owned and delegated token accounts
+   */
+  async getTokenAccountsIncludingDelegated(address, delegatedAccounts = []) {
+    // Get owned accounts (existing functionality)
+    const ownedAccounts = await this.getTokenAccountsByOwner(address)
+
+    // Fetch delegated account states
+    const delegatedAccountPromises = delegatedAccounts.map(async ({ delegatedAddress }) => {
+      try {
+        // Fetch the account info to get current balance and delegate status
+        const accountInfo = await this.getAccountInfo(delegatedAddress)
+
+        if (!accountInfo?.data?.parsed) return null
+
+        const parsedData = accountInfo.data.parsed
+        const info = parsedData.info
+
+        // Verify this account is actually delegated to us
+        if (info.delegate !== address) {
+          console.warn(`Delegated account ${delegatedAddress} is not delegated to ${address}`)
+          return null
+        }
+
+        const mintAddress = info.mint
+        const token = this.getTokenByAddress(mintAddress)
+        if (!token) return null
+
+        // Get token fee info if it's a Token2022 token
+        const { feeBasisPoints = 0, maximumFee = 0 } =
+          accountInfo.owner === TOKEN_2022_PROGRAM_ID.toBase58()
+            ? await this.getTokenFeeBasisPoints(mintAddress)
+            : {}
+
+        return {
+          tokenAccountAddress: delegatedAddress,
+          owner: info.owner, // External owner from on-chain data
+          delegate: address, // You are the delegate
+          isDelegated: true,
+          delegatedAmount: info.delegatedAmount?.amount || '0',
+          tokenName: token.name,
+          ticker: token.ticker,
+          balance: info.tokenAmount?.amount || '0',
+          mintAddress,
+          tokenProgram: accountInfo.owner, // TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID
+          decimals: info.tokenAmount?.decimals || token.decimals,
+          feeBasisPoints,
+          maximumFee,
+        }
+      } catch (error) {
+        console.error(`Failed to fetch delegated account ${delegatedAddress}:`, error)
+        return null
+      }
+    })
+
+    const delegatedAccountStates = await Promise.all(delegatedAccountPromises)
+
+    return [...ownedAccounts, ...delegatedAccountStates.filter(Boolean)]
+  }
+
   async getTokensBalancesAndAccounts({ address, filterByTokens = [] }) {
     const accounts = await this.getTokenAccountsByOwner(address)
 

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

@@ -117,17 +117,79 @@ 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(
-        ({ mintAddress }) => mintAddress === tokenMintAddress
+      const [
+        destinationAddressType,
+        isAssociatedTokenAccountActive,
+        fromTokenAccountAddresses,
+        accountState,
+      ] = await Promise.all([
+        api.getAddressType(toAddress),
+        api.isAssociatedTokenAccountActive(tokenAddress),
+        api.getTokenAccountsByOwner(fromAddress),
+        assetClientInterface.getAccountState({
+          walletAccount,
+          assetName: baseAssetName,
+        }),
+      ])
+
+      const delegatedAccounts = accountState?.delegatedTokenAccounts || []
+
+      // Fetch on-chain state for delegated accounts to get current balance and delegation info
+      const delegatedTokenAccountsForMint = await Promise.all(
+        delegatedAccounts
+          .filter(({ assetName: delegatedAssetName }) => {
+            // Get asset from assetClientInterface
+            const delegatedAsset = asset.name === delegatedAssetName ? asset : null
+            if (!delegatedAsset) return false
+            return delegatedAsset.mintAddress === tokenMintAddress
+          })
+          .map(async (delegatedAccount) => {
+            try {
+              const accountInfo = await api.rpcCall(
+                'getAccountInfo',
+                [delegatedAccount.delegatedAddress, { encoding: 'jsonParsed' }],
+                { address: delegatedAccount.delegatedAddress }
+              )
+
+              if (!accountInfo?.value?.data?.parsed) return null
+
+              const info = accountInfo.value.data.parsed.info
+
+              // Verify delegation is still active
+              if (info.delegate !== fromAddress) {
+                console.warn(
+                  `Delegated account ${delegatedAccount.delegatedAddress} is no longer delegated to ${fromAddress}`
+                )
+                return null
+              }
+
+              return {
+                tokenAccountAddress: delegatedAccount.delegatedAddress,
+                mintAddress: tokenMintAddress,
+                balance: info.tokenAmount?.amount || '0',
+                decimals: info.tokenAmount?.decimals || 0,
+                tokenProgram: accountInfo.value.owner,
+                isDelegated: true,
+                delegatedAmount: info.delegatedAmount?.amount || '0',
+              }
+            } catch (error) {
+              console.error(
+                `Failed to fetch delegated account ${delegatedAccount.delegatedAddress}:`,
+                error
+              )
+              return null
+            }
+          })
       )
 
+      const validDelegatedAccounts = delegatedTokenAccountsForMint.filter(Boolean)
+
+      // Combine owned and delegated accounts
+      const fromTokenAddresses = [
+        ...fromTokenAccountAddresses.filter(({ mintAddress }) => mintAddress === tokenMintAddress),
+        ...validDelegatedAccounts,
+      ]
+
       tokenParams = {
         tokenMintAddress,
         destinationAddressType,

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

@@ -250,13 +250,84 @@ export class SolanaClarityMonitor extends BaseMonitor {
 
   async getAccountsAndBalances({ refresh, address, accountState, walletAccount }) {
     const tokens = Object.keys(this.assets).filter((name) => name !== this.asset.name)
-    const [accountInfo, { balances: splBalances, accounts: tokenAccounts }] = await Promise.all([
-      this.api.getAccountInfo(address).catch(() => {}),
-      this.api.getTokensBalancesAndAccounts({
-        address,
-        filterByTokens: tokens,
-      }),
-    ])
+
+    const delegatedAccounts = accountState.delegatedTokenAccounts || []
+
+    const [accountInfo, { balances: splBalances, accounts: ownedTokenAccounts }] =
+      await Promise.all([
+        this.api.getAccountInfo(address).catch(() => {}),
+        this.api.getTokensBalancesAndAccounts({
+          address,
+          filterByTokens: tokens,
+        }),
+      ])
+
+    // Fetch delegated account balances - get full balances first, then delegated amounts
+    const delegatedBalances = {}
+    const delegatedTokenAmounts = {}
+
+    for (const { delegatedAddress } of delegatedAccounts) {
+      try {
+        const accountInfo = await this.api.rpcCall(
+          'getAccountInfo',
+          [delegatedAddress, { encoding: 'jsonParsed' }],
+          { address: delegatedAddress }
+        )
+
+        if (!accountInfo?.value?.data?.parsed) continue
+
+        const info = accountInfo.value.data.parsed.info
+
+        // Verify this account is actually delegated to us
+        if (info.delegate !== address) {
+          console.warn(`Delegated account ${delegatedAddress} is not delegated to ${address}`)
+          continue
+        }
+
+        const mintAddress = info.mint
+        const fullBalance = info.tokenAmount?.amount || '0'
+        const delegatedAmount = info.delegatedAmount?.amount || '0'
+
+        // Store full balance for combining with owned balances
+        const tokenName = this.api.tokens.get(mintAddress)?.name
+        if (!tokenName) continue
+        if (this.assets[tokenName]) {
+          const fullBalanceCurrency = this.assets[tokenName].currency.baseUnit(fullBalance)
+          if (delegatedBalances[mintAddress]) {
+            delegatedBalances[mintAddress] = delegatedBalances[mintAddress].add(fullBalanceCurrency)
+          } else {
+            delegatedBalances[mintAddress] = fullBalanceCurrency
+          }
+        }
+
+        // Store delegated amounts separately for the account state
+        if (this.assets[tokenName]) {
+          const delegatedAmountCurrency = this.assets[tokenName].currency.baseUnit(delegatedAmount)
+          if (!delegatedAmountCurrency.isZero()) {
+            if (!delegatedTokenAmounts[tokenName]) {
+              delegatedTokenAmounts[tokenName] = {}
+            }
+
+            delegatedTokenAmounts[tokenName][delegatedAddress] = delegatedAmountCurrency
+          }
+        }
+      } catch (error) {
+        console.error(`Failed to fetch delegated account ${delegatedAddress}:`, error)
+      }
+    }
+
+    // Combine owned and delegated balances
+    const combinedBalances = { ...splBalances }
+    for (const [mintAddress, delegatedBalanceCurrency] of Object.entries(delegatedBalances)) {
+      const tokenName = this.api.tokens.get(mintAddress)?.name
+      if (tokenName && this.assets[tokenName]) {
+        const ownedBalance = this.assets[tokenName].currency.baseUnit(
+          combinedBalances[mintAddress] || 0
+        )
+        const totalBalance = ownedBalance.add(delegatedBalanceCurrency)
+        combinedBalances[mintAddress] = Number(totalBalance.toBaseString())
+      }
+    }
 
     const solBalance = accountInfo?.lamports || 0
 
@@ -268,8 +339,8 @@ export class SolanaClarityMonitor extends BaseMonitor {
 
     const ownerChanged = await this.api.ownerChanged(address, accountInfo)
 
-    // we can have splBalances for tokens that are not in our asset list
-    const clientKnownTokens = omitBy(splBalances, (v, mintAddress) => {
+    // we can have balances for tokens that are not in our asset list
+    const clientKnownTokens = omitBy(combinedBalances, (v, mintAddress) => {
       const tokenName = this.api.tokens.get(mintAddress)?.name
       return !this.assets[tokenName]
     })
@@ -280,6 +351,9 @@ export class SolanaClarityMonitor extends BaseMonitor {
       })
     )
 
+    // Use owned token accounts for transaction tracking
+    const tokenAccounts = ownedTokenAccounts
+
     const solBalanceChanged = this.#balanceChanged({
       account: accountState,
       newAccount: {
@@ -312,6 +386,7 @@ export class SolanaClarityMonitor extends BaseMonitor {
       account: {
         balance,
         tokenBalances,
+        delegatedTokenAmounts,
         rentExemptAmount,
         accountSize,
         ownerChanged,
@@ -322,13 +397,21 @@ export class SolanaClarityMonitor extends BaseMonitor {
   }
 
   async updateState({ account, cursorState, walletAccount, staking }) {
-    const { balance, tokenBalances, rentExemptAmount, accountSize, ownerChanged } = account
+    const {
+      balance,
+      tokenBalances,
+      delegatedTokenAmounts,
+      rentExemptAmount,
+      accountSize,
+      ownerChanged,
+    } = account
     const newData = {
       balance,
       rentExemptAmount,
       accountSize,
       ownerChanged,
       tokenBalances,
+      delegatedTokenAmounts,
       stakingInfo: staking,
       ...cursorState,
     }

package/src/tx-send.js

@@ -17,6 +17,7 @@ export const createAndBroadcastTXFactory = ({ api, assetClientInterface }) => {
 
       return baseAsset.api.createTx({
         asset,
+        walletAccount,
         amount: legacyParams.amount,
         toAddress: legacyParams.address,
         ...legacyParams,