@exodus/solana-api 3.18.2 → 3.20.0

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.20.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.19.0...@exodus/solana-api@3.20.0) (2025-06-11)
+
+
+### Features
+
+
+* feat(solana): implement unconfirmedSent/unconfirmedReceived in solana balances (#5802)
+
+
+
+## [3.19.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.18.2...@exodus/solana-api@3.19.0) (2025-06-10)
+
+
+### Features
+
+
+* feat: support SPL batch send monitoring (#5848)
+
+
+### Bug Fixes
+
+
+* fix: SOL amount NaN case (#5713)
+
+* fix: SOL check fot NFT rent (#5792)
+
+* fix: SOL from/to addresses for token txs (#5751)
+
+
+
 ## [3.18.2](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.18.1...@exodus/solana-api@3.18.2) (2025-05-07)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.18.2",
+  "version": "3.20.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,6 @@
     "@exodus/solana-lib": "^3.11.1",
     "@exodus/solana-meta": "^2.0.2",
     "@exodus/timer": "^1.1.1",
-    "bn.js": "^4.11.0",
     "debug": "^4.1.1",
     "delay": "^4.0.1",
     "lodash": "^4.17.11",
@@ -47,7 +46,7 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "dcfc8ac65a86aad50baf92955a8cf18c0e641c4d",
+  "gitHead": "a11096f37c71032ca704876059c11b2e55cc592a",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/api.js

@@ -1,6 +1,6 @@
 import createApiCJS from '@exodus/asset-json-rpc'
 import { memoizeLruCache } from '@exodus/asset-lib'
-import { memoize } from '@exodus/basic-utils'
+import { memoize, pickBy } from '@exodus/basic-utils'
 import wretch from '@exodus/fetch/wretch'
 import { retry } from '@exodus/simple-retry'
 import {
@@ -16,7 +16,6 @@ import {
   TOKEN_2022_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
 } from '@exodus/solana-lib'
-import BN from 'bn.js'
 import lodash from 'lodash'
 import ms from 'ms'
 import urljoin from 'url-join'
@@ -32,6 +31,7 @@ const createApi = createApiCJS.default || createApiCJS
 const RPC_URL = 'https://solana.a.exodus.io' // https://vip-api.mainnet-beta.solana.com/, https://api.mainnet-beta.solana.com
 const WS_ENDPOINT = 'wss://solana.a.exodus.io/ws' // not standard across all node providers (we're compatible only with Quicknode)
 const FORCE_HTTP = true // use https over ws
+const ZERO = BigInt(0)
 
 const errorMessagesToRetry = [
   'Blockhash not found',
@@ -77,7 +77,7 @@ export class Api {
   }
 
   setTokens(assets = {}) {
-    const solTokens = lodash.pickBy(assets, (asset) => asset.assetType === this.tokenAssetType)
+    const solTokens = pickBy(assets, (asset) => asset.assetType === this.tokenAssetType)
     this.tokens = new Map(Object.values(solTokens).map((v) => [v.mintAddress, v]))
   }
 
@@ -399,18 +399,18 @@ export class Api {
             (balance) => balance.accountIndex === postBalance.accountIndex
           )
 
-          const preAmount = new BN(lodash.get(preBalance, 'uiTokenAmount.amount', '0'), 10)
-          const postAmount = new BN(lodash.get(postBalance, 'uiTokenAmount.amount', '0'), 10)
+          const preAmount = BigInt(preBalance?.uiTokenAmount?.amount ?? '0')
+          const postAmount = BigInt(postBalance?.uiTokenAmount?.amount ?? '0')
 
-          const amount = postAmount.sub(preAmount)
+          const amount = postAmount - preAmount
 
-          if (!tokenAccount || amount.isZero()) return null
+          if (!tokenAccount || amount === ZERO) return null
 
           // This is not perfect as there could be multiple same-token transfers in single
           // transaction, but our wallet only supports one transaction with single txId
           // so we are picking first that matches (correct token + type - send or receive)
           const match = innerInstructions.find((inner) => {
-            const targetOwner = amount.isNeg() ? ownerAddress : null
+            const targetOwner = amount < ZERO ? ownerAddress : null
             return (
               inner.token.mintAddress === tokenAccount.mintAddress && targetOwner === inner.owner
             )
@@ -433,7 +433,7 @@ export class Api {
             owner,
             from,
             to,
-            amount: amount.abs().toString(), // inconsistent with the rest, but it can and did overflow
+            amount: (amount < ZERO ? -amount : amount).toString(), // inconsistent with the rest, but it can and did overflow
             fee: 0,
             token: tokenAccount,
             data: {
@@ -563,6 +563,38 @@ export class Api {
       })
       .filter((ix) => !!ix)
 
+    // Collect inner instructions into batch sends
+    for (let i = 0; i < innerInstructions.length - 1; i++) {
+      const tx = innerInstructions[i]
+
+      for (let j = i + 1; j < innerInstructions.length; j++) {
+        const next = innerInstructions[j]
+        if (
+          tx.id === next.id &&
+          tx.token === next.token &&
+          tx.owner === ownerAddress &&
+          tx.from === next.from
+        ) {
+          if (!tx.data) {
+            tx.data = { sent: [{ address: tx.to, amount: tx.amount }] }
+            tx.to = [tx.to]
+            tx.fee = 0
+          }
+
+          tx.data.sent.push({
+            address: next.to,
+            amount: next.amount,
+          })
+          tx.to.push(next.to)
+
+          tx.amount += next.amount
+
+          innerInstructions.splice(j, 1)
+          j--
+        }
+      }
+    }
+
     // program:type tells us if it's a SOL or Token transfer
 
     const stakeTx = lodash.find(instructions, { program: 'system', type: 'createAccountWithSeed' })
@@ -631,12 +663,26 @@ export class Api {
         }
       }
 
+      const accountIndexes = accountKeys.reduce((acc, key, i) => {
+        const hasKnownOwner = tokenAccountsByOwner.some(
+          (tokenAccount) => tokenAccount.tokenAccountAddress === key.pubkey
+        )
+
+        acc[i] = {
+          ...key,
+          owner: hasKnownOwner ? ownerAddress : null, // not know (like in an outgoing tx)
+        }
+
+        return acc
+      }, Object.create(null)) // { 0: { pubkey, owner }, 1: { ... }, ... }
+
       // Parse Token txs
       const tokenTxs = this._parseTokenTransfers({
         instructions,
         tokenAccountsByOwner,
         ownerAddress,
         fee,
+        accountIndexes,
         preTokenBalances,
         postTokenBalances,
       })
@@ -650,20 +696,6 @@ export class Api {
         }))
       } else if (preTokenBalances && postTokenBalances) {
         // probably a DEX program is involved (multiple instructions), compute balance changes
-
-        const accountIndexes = accountKeys.reduce((acc, key, i) => {
-          const hasKnownOwner = tokenAccountsByOwner.some(
-            (tokenAccount) => tokenAccount.tokenAccountAddress === key.pubkey
-          )
-
-          acc[i] = {
-            ...key,
-            owner: hasKnownOwner ? ownerAddress : null,
-          }
-
-          return acc
-        }, Object.create(null))
-
         // group by owner and supported token
         const preBalances = preTokenBalances.filter((t) => {
           return (
@@ -740,6 +772,7 @@ export class Api {
     tokenAccountsByOwner,
     ownerAddress,
     fee,
+    accountIndexes = {},
     preTokenBalances,
     postTokenBalances,
   }) {
@@ -769,11 +802,27 @@ export class Api {
         delete tokenAccount.balance
         delete tokenAccount.owner
 
+        // If it's a sending tx we want to have the destination's owner as "to" address
+        let to = ownerAddress
+        let from = ownerAddress
+        if (isSending) {
+          to = destination // token account address (trying to get the owner below, we don't always have postTokenBalances...)
+          postTokenBalances.forEach((t) => {
+            if (accountIndexes[t.accountIndex].pubkey === destination) to = t.owner
+          })
+        } else {
+          // is receiving tx
+          from = source // token account address
+          preTokenBalances.forEach((t) => {
+            if (accountIndexes[t.accountIndex].pubkey === source) from = t.owner
+          })
+        }
+
         tokenTxs.push({
           owner,
           token: tokenAccount,
-          from: isSending ? ownerAddress : source,
-          to: isSending ? destination : ownerAddress,
+          from,
+          to,
           amount: Number(amount || tokenAmount?.amount || 0), // supporting types: transfer, transferChecked, transferCheckedWithFee
           fee: isSending ? fee : 0, // in lamports
         })
@@ -1034,7 +1083,7 @@ export class Api {
       accounts[addr].canWithdraw = state === 'inactive'
       accounts[addr].stake = Number(accounts[addr].stake) || 0 // active staked amount
       totalStake += accounts[addr].stake
-      locked += ['active', 'activating'].includes(accounts[addr].state) ? lamports : 0
+      locked += accounts[addr].state === 'active' ? lamports : 0
       activating += accounts[addr].state === 'activating' ? lamports : 0
       withdrawable += accounts[addr].canWithdraw ? lamports : 0
       pending += accounts[addr].isDeactivating ? lamports : 0

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

@@ -210,7 +210,7 @@ export const createUnsignedTxForSend = async ({
 
   // differentiate between SOL and Solana token
   let isEnoughForRent = false
-  if (asset.name === baseAsset.name) {
+  if (asset.name === baseAsset.name && !nft) {
     // sending SOL
     isEnoughForRent = amount.gte(rentExemptAmount)
   } else {

package/src/get-balances.js

@@ -8,7 +8,15 @@ export const getBalancesFactory =
   ({ asset, accountState, txLog }) => {
     const zero = asset.currency.ZERO
 
-    const { balance, locked, activating, withdrawable, pending } = fixBalances({
+    const {
+      balance,
+      locked,
+      activating,
+      withdrawable,
+      pending,
+      unconfirmedSent,
+      unconfirmedReceived,
+    } = fixBalances({
       txLog,
       balance: getBalanceFromAccountState({ asset, accountState }),
       locked: accountState.stakingInfo?.locked || zero,
@@ -16,6 +24,8 @@ export const getBalancesFactory =
       activating: accountState.stakingInfo?.activating || zero,
       pending: accountState.stakingInfo?.pending || zero,
       asset,
+      unconfirmedSent: zero,
+      unconfirmedReceived: zero,
     })
     if (asset.baseAsset.name !== asset.name) {
       return {
@@ -30,6 +40,7 @@ export const getBalancesFactory =
 
     const balanceWithoutStaking = balance
       .sub(locked)
+      .sub(activating)
       .sub(withdrawable)
       .sub(pending)
       .clampLowerZero()
@@ -50,6 +61,7 @@ export const getBalancesFactory =
     const stakeable = spendable
 
     const staked = locked
+    const unstaked = withdrawable
     const unstaking = pending
 
     const staking = activating || zero
@@ -63,10 +75,13 @@ export const getBalancesFactory =
       spendable,
       stakeable,
       staked,
+      unstaked,
       staking,
       unstaking,
       networkReserve,
       walletReserve: zero,
+      unconfirmedSent,
+      unconfirmedReceived,
     }
   }
 
@@ -78,40 +93,56 @@ const fixBalances = ({
   activating,
   pending,
   asset,
+  unconfirmedSent,
+  unconfirmedReceived,
 }) => {
   for (const tx of txLog) {
-    if ((tx.sent || tx.data.staking) && tx.pending && !tx.error) {
+    if (!tx.pending || tx.error) {
+      continue
+    }
+
+    if (tx.data.staking) {
+      if (tx.coinAmount.unitType.equals(tx.feeAmount.unitType)) {
+        unconfirmedSent = unconfirmedSent.add(tx.feeAmount)
+      }
+
+      // staking tx
+      switch (tx.data.staking?.method) {
+        case 'delegate':
+          activating = activating.add(tx.coinAmount.abs())
+          break
+        case 'withdraw':
+          withdrawable = asset.currency.ZERO
+          break
+        case 'undelegate':
+          pending = pending.add(locked).add(activating)
+          locked = asset.currency.ZERO
+          activating = asset.currency.ZERO
+          break
+      }
+    } else if (tx.sent) {
       if (tx.coinAmount.unitType.equals(tx.feeAmount.unitType)) {
-        balance = balance.sub(tx.feeAmount)
+        unconfirmedSent = unconfirmedSent.add(tx.feeAmount)
       }
 
-      if (tx.data.staking) {
-        // staking tx
-        switch (tx.data.staking?.method) {
-          case 'delegate':
-            locked = locked.add(tx.coinAmount.abs())
-            break
-          case 'withdraw':
-            withdrawable = asset.currency.ZERO
-            break
-          case 'undelegate':
-            pending = pending.add(locked)
-            locked = asset.currency.ZERO
-            break
-        }
-      } else {
-        // coinAmount is negative for sent tx
-        balance = balance.sub(tx.coinAmount.abs())
+      unconfirmedSent = unconfirmedSent.add(tx.coinAmount.abs())
+    } else if (tx.received) {
+      if (tx.coinAmount.unitType.equals(tx.feeAmount.unitType)) {
+        unconfirmedReceived = unconfirmedReceived.sub(tx.feeAmount)
       }
+
+      unconfirmedReceived = unconfirmedReceived.add(tx.coinAmount.abs())
     }
   }
 
   return {
-    balance: balance.clampLowerZero(),
+    balance: balance.sub(unconfirmedSent).clampLowerZero(),
     locked: locked.clampLowerZero(),
     withdrawable: withdrawable.clampLowerZero(),
     activating: activating.clampLowerZero(),
     pending: pending.clampLowerZero(),
+    unconfirmedSent,
+    unconfirmedReceived,
   }
 }
 

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

@@ -217,7 +217,7 @@ export class SolanaMonitor extends BaseMonitor {
       if (assetName === 'unknown' || !asset) continue // skip unknown tokens
       const feeAsset = asset.feeAsset
 
-      const coinAmount = asset.currency.baseUnit(tx.amount)
+      const coinAmount = tx.amount ? asset.currency.baseUnit(tx.amount) : asset.currency.ZERO
 
       const item = {
         coinName: assetName,
@@ -245,7 +245,7 @@ export class SolanaMonitor extends BaseMonitor {
         if (tx.data?.sent) {
           item.data.sent = tx.data.sent.map((s) => ({
             address: s.address,
-            amount: baseAsset.currency.baseUnit(s.amount).toDefaultString({ unit: true }),
+            amount: asset.currency.baseUnit(s.amount).toDefaultString({ unit: true }),
           }))
         }
 
@@ -279,10 +279,9 @@ export class SolanaMonitor extends BaseMonitor {
       mappedTransactions.push(item)
     }
 
-    // logItemsByAsset = { 'solana:': [...], 'serum': [...] }
-
+    const logItemsByAsset = _.groupBy(mappedTransactions, (item) => item.coinName)
     return {
-      logItemsByAsset: _.groupBy(mappedTransactions, (item) => item.coinName),
+      logItemsByAsset,
       hasNewTxs: transactions.length > 0,
       cursorState: { cursor: newCursor },
     }
@@ -328,11 +327,13 @@ export class SolanaMonitor extends BaseMonitor {
         : { ...accountState.stakingInfo, staking: this.staking }
 
     const stakedBalance = this.asset.currency.baseUnit(staking.locked)
+    const activatingBalance = this.asset.currency.baseUnit(staking.activating)
     const withdrawableBalance = this.asset.currency.baseUnit(staking.withdrawable)
     const pendingBalance = this.asset.currency.baseUnit(staking.pending)
     const balance = this.asset.currency
       .baseUnit(solBalance)
       .add(stakedBalance)
+      .add(activatingBalance)
       .add(withdrawableBalance)
       .add(pendingBalance)