@exodus/solana-api 3.14.4 → 3.14.6

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.14.6](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.14.5...@exodus/solana-api@3.14.6) (2025-04-01)
+
+
+### Bug Fixes
+
+
+* fix: SOL staking method param (#5362)
+
+
+
+## [3.14.5](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.14.4...@exodus/solana-api@3.14.5) (2025-03-25)
+
+
+### Bug Fixes
+
+
+* fix: SOL insufficient funds for rent (#5308)
+
+
+
 ## [3.14.4](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.14.3...@exodus/solana-api@3.14.4) (2025-03-20)
 
 **Note:** Version bump only for package @exodus/solana-api

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.14.4",
+  "version": "3.14.6",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Solana",
   "type": "module",
   "main": "src/index.js",
@@ -46,7 +46,7 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "ece04a00d01566ab21cd4b4af57501fb7e50d1af",
+  "gitHead": "310d0d34a574d1da978f862e42c481de1e57bade",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/api.js

@@ -1,4 +1,5 @@
 import createApiCJS from '@exodus/asset-json-rpc'
+import { memoizeLruCache } from '@exodus/asset-lib'
 import { memoize } from '@exodus/basic-utils'
 import wretch from '@exodus/fetch/wretch'
 import { retry } from '@exodus/simple-retry'
@@ -58,6 +59,12 @@ export class Api {
       (accountSize) => accountSize,
       ms('15m')
     )
+
+    this.getAccountSize = memoize(
+      (address) => this.getAccountInfo(address),
+      (address) => address,
+      ms('3m')
+    )
   }
 
   setServer(rpcUrl) {
@@ -136,6 +143,20 @@ export class Api {
     return this.tokens.has(mint)
   }
 
+  async getRentExemptionMinAmount(address) {
+    // minimum amount required for the destination account to be rent-exempt
+    const accountInfo = await this.getAccountSize(address).catch(() => {})
+    if (accountInfo?.space === 0) {
+      // no rent required
+      return 0
+    }
+
+    const accountSize = accountInfo?.space || 0
+
+    // Lamports number
+    return this.getMinimumBalanceForRentExemption(accountSize)
+  }
+
   async getEpochInfo() {
     const { epoch } = await this.rpcCall('getEpochInfo')
     return Number(epoch)
@@ -881,6 +902,12 @@ export class Api {
     return owner && owner !== address
   }
 
+  ataOwnershipChangedCached = memoizeLruCache(
+    (...args) => this.ataOwnershipChanged(...args),
+    (address, tokenAddress) => `${address}:${tokenAddress}`,
+    { max: 1000 }
+  )
+
   // Returns account balance of a SPL Token account.
   async getTokenBalance(tokenAddress) {
     const result = await this.rpcCall('getTokenAccountBalance', [tokenAddress])

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

@@ -0,0 +1,209 @@
+import {
+  createUnsignedTx,
+  findAssociatedTokenAddress,
+  prepareForSigning,
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+} from '@exodus/solana-lib'
+
+const CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS = 300
+
+export const createUnsignedTxForSend = async ({
+  api,
+  asset,
+  feeData,
+  toAddress,
+  fromAddress,
+  amount,
+  reference,
+  memo,
+  nft,
+  // token related
+  tokenStandard,
+  customMintAddress,
+  // staking
+  method,
+  stakeAddresses,
+  seed,
+  pool,
+  // <MagicEden>
+  initializerAddress,
+  initializerDepositTokenAddress,
+  takerAmount,
+  escrowAddress,
+  escrowBump,
+  pdaAddress,
+  takerAddress,
+  expectedTakerAmount,
+  expectedMintAddress,
+  metadataAddress,
+  creators,
+  // </MagicEden>
+}) => {
+  let tokenParams = Object.create(null)
+  const baseAsset = asset.baseAsset
+
+  if (nft) {
+    const [, nftAddress] = nft.id.split(':')
+    customMintAddress = nftAddress
+    tokenStandard = nft.tokenStandard
+    method = tokenStandard === 4 ? 'metaplexTransfer' : undefined
+    amount = asset.currency.baseUnit(1)
+  }
+
+  const isToken = asset.assetType === api.tokenAssetType
+
+  // Check if receiver has address active when sending tokens.
+  if (isToken) {
+    // check address mint is the same
+    const targetMint = await api.getAddressMint(toAddress) // null if it's a SOL address
+    if (targetMint && targetMint !== asset.mintAddress) {
+      const err = new Error('Wrong Destination Wallet')
+      err.mintAddressMismatch = true
+      throw err
+    }
+  } else {
+    // sending SOL
+    const addressType = await api.getAddressType(toAddress)
+    if (addressType === 'token') {
+      const err = new Error('Destination Wallet is a Token address')
+      err.wrongAddressType = true
+      throw err
+    }
+  }
+
+  if (isToken || customMintAddress) {
+    const tokenMintAddress = customMintAddress || asset.mintAddress
+    const tokenProgramPublicKey =
+      (await api.getAddressType(tokenMintAddress)) === 'token-2022'
+        ? TOKEN_2022_PROGRAM_ID
+        : TOKEN_PROGRAM_ID
+
+    const tokenProgram = tokenProgramPublicKey.toBase58()
+    const tokenAddress = findAssociatedTokenAddress(toAddress, tokenMintAddress, tokenProgram)
+
+    const [destinationAddressType, isAssociatedTokenAccountActive, fromTokenAccountAddresses] =
+      await Promise.all([
+        api.getAddressType(toAddress),
+        api.isAssociatedTokenAccountActive(tokenAddress),
+        api.getTokenAccountsByOwner(fromAddress),
+      ])
+
+    const changedOwnership = await api.ataOwnershipChangedCached(toAddress, tokenAddress)
+    if (changedOwnership) {
+      const err = new Error('Destination ATA changed ownership')
+      err.ownershipChanged = true
+      throw err
+    }
+
+    const fromTokenAddresses = fromTokenAccountAddresses.filter(
+      ({ mintAddress }) => mintAddress === tokenMintAddress
+    )
+
+    tokenParams = {
+      tokenMintAddress,
+      destinationAddressType,
+      isAssociatedTokenAccountActive,
+      fromTokenAddresses,
+      tokenStandard,
+      tokenProgram,
+    }
+  }
+
+  const stakingParams = {
+    method,
+    stakeAddresses,
+    seed,
+    pool,
+  }
+
+  const recentBlockhash = await api.getRecentBlockHash()
+
+  const magicEdenParams = {
+    method,
+    initializerAddress,
+    initializerDepositTokenAddress,
+    takerAmount,
+    escrowAddress,
+    escrowBump,
+    pdaAddress,
+    takerAddress,
+    expectedTakerAmount,
+    expectedMintAddress,
+    metadataAddress,
+    creators,
+  }
+
+  const unsignedTx = createUnsignedTx({
+    asset,
+    from: fromAddress,
+    to: toAddress,
+    amount,
+    recentBlockhash,
+    reference,
+    memo,
+    ...tokenParams,
+    ...stakingParams,
+    ...magicEdenParams,
+  })
+
+  const resolveUnitConsumed = async () => {
+    // this avoids unnecessary simulations. Also the simulation fails with InsufficientFundsForRent when sending all.
+    if (asset.name === asset.baseAsset.name && amount && !nft && !method) {
+      return 150 + CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS
+    }
+
+    const transactionForFeeEstimation = prepareForSigning(unsignedTx)
+    const { unitsConsumed, err } = await api.simulateUnsignedTransaction({
+      message: transactionForFeeEstimation.message,
+    })
+    if (err) throw new Error(JSON.stringify(err))
+    return unitsConsumed + CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS
+  }
+
+  const priorityFee = feeData.priorityFee
+  let computeUnits
+  if (priorityFee) {
+    const unitsConsumed = await resolveUnitConsumed()
+    computeUnits = unitsConsumed * feeData.computeUnitsMultiplier
+    unsignedTx.txData.priorityFee = priorityFee
+    unsignedTx.txData.computeUnits = computeUnits
+  }
+
+  unsignedTx.txMeta.stakingParams = stakingParams
+
+  const fee = feeData.baseFee.add(
+    asset.feeAsset.currency
+      .baseUnit(unsignedTx.txData.priorityFee ?? 0)
+      .mul(unsignedTx.txData.computeUnits ?? 0)
+      .div(1_000_000) // micro lamports to lamports
+  )
+
+  // serialization friendlier
+  unsignedTx.txMeta.fee = fee.toBaseNumber()
+
+  const rentExemptValue = await api.getRentExemptionMinAmount(toAddress)
+  const rentExemptAmount = baseAsset.currency.baseUnit(rentExemptValue)
+
+  // differentiate between SOL and Solana token
+  let isEnoughForRent = false
+  if (asset.name === baseAsset.name) {
+    // sending SOL
+    isEnoughForRent = amount.gte(rentExemptAmount)
+  } else {
+    // sending token/nft
+    const baseAssetBalance = await api.getBalance(fromAddress)
+    isEnoughForRent = baseAsset.currency
+      .baseUnit(baseAssetBalance)
+      .sub(fee || asset.feeAsset.currency.ZERO)
+      .gte(rentExemptAmount)
+  }
+
+  if (!isEnoughForRent) {
+    const err = new Error('Sending SOL amount is too low to cover the rent exemption fee.')
+    err.rentExemptAmount = true
+    throw err
+  }
+
+  return unsignedTx
+}

package/src/get-balances.js

@@ -4,7 +4,7 @@ import { TxSet } from '@exodus/models'
 // In this case, The wallet should exclude the staking balance from the general balance
 
 export const getBalancesFactory =
-  ({ stakingFeatureAvailable }) =>
+  ({ stakingFeatureAvailable, allowSendingAll }) =>
   ({ asset, accountState, txLog }) => {
     const zero = asset.currency.ZERO
     const { balance, locked, withdrawable, pending } = fixBalances({
@@ -34,15 +34,16 @@ export const getBalancesFactory =
 
     const total = stakingFeatureAvailable ? balance : balanceWithoutStaking
 
-    const networkReserve = accountState.rentExemptAmount || zero
+    // there is no wallet reserve when there are no tokens nor staking actions. Just network reserve for the rent exempt amount.
+    const needsReserve =
+      hasStakedFunds({ locked, withdrawable, pending }) || hasTokensBalance({ accountState })
+
+    const networkReserve =
+      allowSendingAll && !needsReserve ? zero : accountState.rentExemptAmount || zero
 
     const accountReserve = asset.accountReserve || zero
 
-    // there is no wallet reserve when there are no tokens nor staking actions. Just network reserve for the rent exempt amount.
-    const walletReserve =
-      hasStakedFunds({ locked, withdrawable, pending }) || hasTokensBalance({ accountState })
-        ? accountReserve.sub(networkReserve).clampLowerZero()
-        : zero
+    const walletReserve = needsReserve ? accountReserve.sub(networkReserve).clampLowerZero() : zero
 
     const spendable = balanceWithoutStaking.sub(walletReserve).sub(networkReserve).clampLowerZero()
 

package/src/get-fees.js

@@ -0,0 +1,27 @@
+import assert from 'minimalistic-assert'
+
+import { createUnsignedTxForSend } from './create-unsigned-tx-for-send.js'
+
+export const getFeeAsyncFactory = ({ api }) => {
+  assert(api, 'api is required')
+  return async ({ asset, feeData, unsignedTx: providedUnsignedTx, amount, toAddress, ...rest }) => {
+    const unsignedTx =
+      providedUnsignedTx ||
+      (await createUnsignedTxForSend({
+        asset,
+        feeData,
+        api,
+        amount: amount ?? asset.currency.baseUnit(1),
+        toAddress: toAddress ?? rest.fromAddress,
+        ...rest,
+      }))
+
+    return { fee: asset.feeAsset.currency.baseUnit(unsignedTx.txMeta.fee), unsignedTx }
+  }
+}
+
+export const getFeeFactory =
+  ({ asset }) =>
+  ({ feeData }) => {
+    return { fee: feeData.fee }
+  }

package/src/index.js

@@ -15,6 +15,7 @@ export {
 } from './txs-utils.js'
 export { createAndBroadcastTXFactory } from './tx-send.js'
 export { getBalancesFactory } from './get-balances.js'
+export { getFeeAsyncFactory } from './get-fees.js'
 export { stakingProviderClientFactory } from './staking-provider-client.js'
 
 // These are not the same asset objects as the wallet creates, so they should never be returned to the wallet.

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

@@ -297,10 +297,9 @@ export class SolanaMonitor extends BaseMonitor {
       }),
     ])
 
-    const accountSize = accountInfo?.space || 0
     const solBalance = accountInfo?.lamports || 0
 
-    const rentExemptValue = await this.api.getMinimumBalanceForRentExemption(accountSize)
+    const rentExemptValue = await this.api.getRentExemptionMinAmount(address)
     const rentExemptAmount = this.asset.currency.baseUnit(rentExemptValue)
 
     const tokenBalances = _.mapValues(splBalances, (balance, name) =>

package/src/tx-send.js

@@ -1,222 +1,112 @@
-import {
-  createUnsignedTx,
-  findAssociatedTokenAddress,
-  prepareForSigning,
-  TOKEN_2022_PROGRAM_ID,
-  TOKEN_PROGRAM_ID,
-} from '@exodus/solana-lib'
 import assert from 'minimalistic-assert'
 
+import { createUnsignedTxForSend } from './create-unsigned-tx-for-send.js'
+
 export const createAndBroadcastTXFactory =
   ({ api, assetClientInterface }) =>
-  async ({ asset, walletAccount, address, amount, options = {} }) => {
+  async ({ asset, walletAccount, unsignedTx: predefinedUnsignedTx, ...legacyParams }) => {
     const assetName = asset.name
     assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${assetName}`)
 
-    const {
-      feeAmount,
-      stakeAddresses,
-      seed,
-      pool,
-      nft,
-      // <MagicEden>
-      initializerAddress,
-      initializerDepositTokenAddress,
-      takerAmount,
-      escrowAddress,
-      escrowBump,
-      pdaAddress,
-      takerAddress,
-      expectedTakerAmount,
-      expectedMintAddress,
-      metadataAddress,
-      creators,
-      priorityFee,
-      // </MagicEden>
-      reference,
-      memo,
-    } = options
-
-    let { method, customMintAddress, tokenStandard } = options
-
-    const { baseAsset } = asset
-    const from = await assetClientInterface.getReceiveAddress({
-      assetName: baseAsset.name,
-      walletAccount,
-    })
+    const baseAsset = asset.baseAsset
 
-    if (nft) {
-      customMintAddress = nft.mintAddress
-      tokenStandard = nft.tokenStandard
-      method = tokenStandard === 4 ? 'metaplexTransfer' : undefined
-      amount = asset.currency.baseUnit(1)
-    }
-
-    const isToken = asset.assetType === api.tokenAssetType
-
-    // Check if receiver has address active when sending tokens.
-    if (isToken) {
-      // check address mint is the same
-      const targetMint = await api.getAddressMint(address) // null if it's a SOL address
-      if (targetMint && targetMint !== asset.mintAddress) {
-        const err = new Error('Wrong Destination Wallet')
-        err.reason = { mintAddressMismatch: true }
-        throw err
-      }
-    } else {
-      // sending SOL
-      const addressType = await api.getAddressType(address)
-      if (addressType === 'token') {
-        const err = new Error('Destination Wallet is a Token address')
-        err.reason = { wrongAddressType: true }
-        throw err
+    const resolveTxs = async () => {
+      if (predefinedUnsignedTx) {
+        return predefinedUnsignedTx
       }
-    }
-
-    const recentBlockhash = options.recentBlockhash || (await api.getRecentBlockHash())
-
-    const feeData = await assetClientInterface.getFeeData({ assetName })
-
-    let tokenParams = Object.create(null)
-    if (isToken || customMintAddress) {
-      const tokenMintAddress = customMintAddress || asset.mintAddress
-      const tokenProgramPublicKey =
-        (await api.getAddressType(tokenMintAddress)) === 'token-2022'
-          ? TOKEN_2022_PROGRAM_ID
-          : TOKEN_PROGRAM_ID
-
-      const tokenProgram = tokenProgramPublicKey.toBase58()
-      const tokenAddress = findAssociatedTokenAddress(address, tokenMintAddress, tokenProgram)
-      const [destinationAddressType, isAssociatedTokenAccountActive, fromTokenAccountAddresses] =
-        await Promise.all([
-          api.getAddressType(address),
-          api.isAssociatedTokenAccountActive(tokenAddress),
-          api.getTokenAccountsByOwner(from),
-        ])
-
-      const changedOwnership = await api.ataOwnershipChanged(address, tokenAddress)
-      if (changedOwnership) {
-        const err = new Error('Destination ATA changed ownership')
-        err.reason = { ownershipChanged: true }
-        throw err
-      }
-
-      const fromTokenAddresses = fromTokenAccountAddresses.filter(
-        ({ mintAddress }) => mintAddress === tokenMintAddress
-      )
-
-      tokenParams = {
-        tokenMintAddress,
-        destinationAddressType,
-        isAssociatedTokenAccountActive,
-        fromTokenAddresses,
-        tokenStandard,
-        tokenProgram,
-      }
-    }
 
-    const stakingParams = {
-      method,
-      stakeAddresses,
-      seed,
-      pool,
-    }
+      const feeData = await assetClientInterface.getFeeData({ assetName })
+      const fromAddress = await assetClientInterface.getReceiveAddress({
+        assetName: baseAsset.name,
+        walletAccount,
+      })
 
-    const magicEdenParams = {
-      method,
-      initializerAddress,
-      initializerDepositTokenAddress,
-      takerAmount,
-      escrowAddress,
-      escrowBump,
-      pdaAddress,
-      takerAddress,
-      expectedTakerAmount,
-      expectedMintAddress,
-      metadataAddress,
-      creators,
+      return createUnsignedTxForSend({
+        api,
+        asset,
+        feeData,
+        fromAddress,
+        amount: legacyParams.amount,
+        toAddress: legacyParams.address,
+        ...legacyParams.options,
+      })
     }
 
-    const unsignedTransaction = createUnsignedTx({
-      asset,
-      from,
-      to: address,
-      amount,
-      fee: feeData.fee, // feeAmount includes the priortyFee
-      recentBlockhash,
-      feeData,
-      reference,
-      memo,
-      ...tokenParams,
-      ...stakingParams,
-      ...magicEdenParams,
-    })
-
-    const transactionForFeeEstimation = prepareForSigning(unsignedTransaction)
+    const unsignedTx = await resolveTxs()
 
-    const { unitsConsumed: computeUnits, err } = await api.simulateUnsignedTransaction({
-      message: transactionForFeeEstimation.message,
-    })
-    if (err) throw new Error(JSON.stringify(err))
-
-    unsignedTransaction.txData.priorityFee = priorityFee ?? 0
-    unsignedTransaction.txData.computeUnits = computeUnits * feeData.computeUnitsMultiplier
-
-    const { txId, rawTx } = await assetClientInterface.signTransaction({
+    const signedTx = await assetClientInterface.signTransaction({
       assetName: baseAsset.name,
-      unsignedTx: unsignedTransaction,
+      unsignedTx,
       walletAccount,
     })
 
-    await baseAsset.api.broadcastTx(rawTx)
-
-    const selfSend = from === address
-    const isStakingTx = ['delegate', 'undelegate', 'withdraw'].includes(method)
-    const coinAmount = isStakingTx
-      ? amount.abs()
-      : selfSend
-        ? asset.currency.ZERO
-        : amount.abs().negate()
-
-    const data = isStakingTx
-      ? { staking: { ...stakingParams, stake: coinAmount.toBaseNumber() } }
-      : Object.create(null)
-    const tx = {
-      txId,
-      confirmations: 0,
-      coinName: assetName,
-      coinAmount,
-      feeAmount,
-      feeCoinName: asset.feeAsset.name,
-      selfSend,
-      to: address,
-      data,
-      currencies: { [assetName]: asset.currency, [asset.feeAsset.name]: asset.feeAsset.currency },
-    }
-    await assetClientInterface.updateTxLogAndNotify({ assetName, walletAccount, txs: [tx] })
+    const txId = signedTx.txId
 
-    if (isToken) {
-      // write tx entry in solana for token fee
-      const txForFee = {
+    const isToken = asset.assetType === api.tokenAssetType
+
+    await baseAsset.api.broadcastTx(signedTx.rawTx)
+
+    try {
+      // collecting data from unsignedTx, it should be sufficient
+      const method = unsignedTx.txData.method
+      const fromAddress = unsignedTx.txData.from
+      const toAddress = unsignedTx.txData.to
+      const selfSend = fromAddress === toAddress
+      const amount = asset.currency.baseUnit(unsignedTx.txData.amount)
+      const feeAmount = asset.feeAsset.currency.baseUnit(unsignedTx.txMeta.fee)
+
+      const isStakingTx = ['delegate', 'undelegate', 'withdraw'].includes(method)
+      const coinAmount =
+        (isStakingTx ? amount?.abs() : selfSend ? asset.currency.ZERO : amount?.abs().negate()) ||
+        asset.currency.ZERO
+
+      let data
+      if (isStakingTx) {
+        data = { ...unsignedTx?.txMeta.stakingParams, stake: coinAmount.toBaseNumber() }
+      } else {
+        data = Object.create(null)
+      }
+
+      const tx = {
         txId,
         confirmations: 0,
-        coinName: baseAsset.name,
-        coinAmount: baseAsset.currency.ZERO,
-        tokens: [assetName],
+        coinName: assetName,
+        coinAmount,
         feeAmount,
-        feeCoinName: baseAsset.feeAsset.name,
-        to: address,
+        feeCoinName: asset.feeAsset.name,
         selfSend,
-        currencies: {
-          [baseAsset.name]: baseAsset.currency,
-          [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
-        },
+        to: toAddress,
+        data,
+        currencies: { [assetName]: asset.currency, [asset.feeAsset.name]: asset.feeAsset.currency },
       }
-      await assetClientInterface.updateTxLogAndNotify({
-        assetName: baseAsset.name,
-        walletAccount,
-        txs: [txForFee],
-      })
+      await assetClientInterface.updateTxLogAndNotify({ assetName, walletAccount, txs: [tx] })
+
+      if (isToken) {
+        // write tx entry in solana for token fee
+        const txForFee = {
+          txId,
+          confirmations: 0,
+          coinName: baseAsset.name,
+          coinAmount: baseAsset.currency.ZERO,
+          tokens: [assetName],
+          feeAmount,
+          feeCoinName: baseAsset.feeAsset.name,
+          to: toAddress,
+          selfSend,
+          currencies: {
+            [baseAsset.name]: baseAsset.currency,
+            [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
+          },
+        }
+        await assetClientInterface.updateTxLogAndNotify({
+          assetName: baseAsset.name,
+          walletAccount,
+          txs: [txForFee],
+        })
+      }
+    } catch (err) {
+      console.log('error writing SOL txLog', err)
+      return { txId, txLogError: true }
     }
 
     return { txId }