@exodus/solana-api 3.25.1 → 3.25.2

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.25.2](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.25.1...@exodus/solana-api@3.25.2) (2025-11-04)
+
+**Note:** Version bump only for package @exodus/solana-api
+
+
+
+
+
 ## [3.25.1](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.25.0...@exodus/solana-api@3.25.1) (2025-11-03)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.25.1",
+  "version": "3.25.2",
   "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.15.0",
+    "@exodus/solana-lib": "^3.15.2",
     "@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": "a87798a8db1f3ffceb94684a842f22b35025d549",
+  "gitHead": "c327da082bf6b55c270d4ab754c2abdc73e0a8de",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/account-state.js

@@ -19,11 +19,9 @@ 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,69 +962,6 @@ 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,79 +117,17 @@ export const createTxFactory = ({ assetClientInterface, api, feePayerClient }) =
         throw err
       }
 
-      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 [destinationAddressType, isAssociatedTokenAccountActive, fromTokenAccountAddresses] =
+        await Promise.all([
+          api.getAddressType(toAddress),
+          api.isAssociatedTokenAccountActive(tokenAddress),
+          api.getTokenAccountsByOwner(fromAddress),
+        ])
+
+      const fromTokenAddresses = fromTokenAccountAddresses.filter(
+        ({ mintAddress }) => mintAddress === tokenMintAddress
       )
 
-      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,96 +250,13 @@ export class SolanaClarityMonitor extends BaseMonitor {
 
   async getAccountsAndBalances({ refresh, address, accountState, walletAccount }) {
     const tokens = Object.keys(this.assets).filter((name) => name !== this.asset.name)
-
-    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
-          }
-
-          const delegatedAmountCurrency = this.assets[tokenName].currency.baseUnit(delegatedAmount)
-          if (!delegatedAmountCurrency.equals(this.assets[tokenName].currency.ZERO)) {
-            if (!delegatedTokenAmounts[tokenName]) {
-              delegatedTokenAmounts[tokenName] = {}
-            }
-
-            delegatedTokenAmounts[tokenName][delegatedAddress] = delegatedAmountCurrency
-          }
-        }
-      } catch (error) {
-        console.error(`Failed to fetch delegated account ${delegatedAddress}:`, error)
-      }
-    }
-
-    const combinedBalances = {}
-
-    const tokenNameToMintAddress = {}
-    for (const account of ownedTokenAccounts || []) {
-      if (account.tokenName && account.mintAddress) {
-        tokenNameToMintAddress[account.tokenName] = account.mintAddress
-      }
-    }
-
-    for (const [tokenName, balance] of Object.entries(splBalances)) {
-      const mintAddress = tokenNameToMintAddress[tokenName]
-
-      if (mintAddress) {
-        combinedBalances[mintAddress] = balance
-      }
-    }
-
-    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 [accountInfo, { balances: splBalances, accounts: tokenAccounts }] = await Promise.all([
+      this.api.getAccountInfo(address).catch(() => {}),
+      this.api.getTokensBalancesAndAccounts({
+        address,
+        filterByTokens: tokens,
+      }),
+    ])
 
     const solBalance = accountInfo?.lamports || 0
 
@@ -351,8 +268,8 @@ export class SolanaClarityMonitor extends BaseMonitor {
 
     const ownerChanged = await this.api.ownerChanged(address, accountInfo)
 
-    // we can have balances for tokens that are not in our asset list
-    const clientKnownTokens = omitBy(combinedBalances, (v, mintAddress) => {
+    // we can have splBalances for tokens that are not in our asset list
+    const clientKnownTokens = omitBy(splBalances, (v, mintAddress) => {
       const tokenName = this.api.tokens.get(mintAddress)?.name
       return !this.assets[tokenName]
     })
@@ -363,9 +280,6 @@ export class SolanaClarityMonitor extends BaseMonitor {
       })
     )
 
-    // Use owned token accounts for transaction tracking
-    const tokenAccounts = ownedTokenAccounts
-
     const solBalanceChanged = this.#balanceChanged({
       account: accountState,
       newAccount: {
@@ -398,7 +312,6 @@ export class SolanaClarityMonitor extends BaseMonitor {
       account: {
         balance,
         tokenBalances,
-        delegatedTokenAmounts,
         rentExemptAmount,
         accountSize,
         ownerChanged,
@@ -409,21 +322,13 @@ export class SolanaClarityMonitor extends BaseMonitor {
   }
 
   async updateState({ account, cursorState, walletAccount, staking }) {
-    const {
-      balance,
-      tokenBalances,
-      delegatedTokenAmounts,
-      rentExemptAmount,
-      accountSize,
-      ownerChanged,
-    } = account
+    const { balance, tokenBalances, rentExemptAmount, accountSize, ownerChanged } = account
     const newData = {
       balance,
       rentExemptAmount,
       accountSize,
       ownerChanged,
       tokenBalances,
-      delegatedTokenAmounts,
       stakingInfo: staking,
       ...cursorState,
     }