@exodus/solana-api 3.20.8 → 3.20.10

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.20.10](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.20.8...@exodus/solana-api@3.20.10) (2025-10-14)
+
+
+### Bug Fixes
+
+
+* fix: point SOL clarity to prod (#6672)
+
+
+
+## [3.20.9](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.20.8...@exodus/solana-api@3.20.9) (2025-10-09)
+
+**Note:** Version bump only for package @exodus/solana-api
+
+
+
+
+
 ## [3.20.8](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.20.7...@exodus/solana-api@3.20.8) (2025-09-18)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.20.8",
+  "version": "3.20.10",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Solana",
   "type": "module",
   "main": "src/index.js",
@@ -14,7 +14,8 @@
   "author": "Exodus Movement, Inc.",
   "license": "MIT",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": false
   },
   "scripts": {
     "test": "run -T exodus-test --jest",
@@ -46,7 +47,7 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "b94e40bcbccd75eab27cd08988ea039a597b0c42",
+  "gitHead": "b0f1b6b69b7a6f7e70eee7e03db7bf71ba6be92a",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/clarity-api.js

@@ -0,0 +1,141 @@
+import { memoizeLruCache } from '@exodus/asset-lib'
+import { memoize, omitBy } from '@exodus/basic-utils'
+import wretch from '@exodus/fetch/wretch'
+import { SYSTEM_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@exodus/solana-lib'
+import ms from 'ms'
+import urljoin from 'url-join'
+
+import { RpcApi } from './rpc-api.js'
+
+const CLARITY_URL = 'https://solana-clarity.a.exodus.io/api/v2/solana'
+
+const cleanQuery = (obj) => omitBy(obj, (v) => v === undefined)
+
+// Tokens + SOL api support
+export class ClarityApi extends RpcApi {
+  getSupply = memoize(async (mintAddress) => {
+    // cached getSupply
+    return this.request(`/util/get-token-supply/${encodeURIComponent(mintAddress)}`)
+      .get()
+      .json()
+  })
+
+  getMinimumBalanceForRentExemption = memoize(
+    (accountSize) =>
+      this.request(`/util/min-balance-for-rent-exemption/${encodeURIComponent(accountSize)}`)
+        .get()
+        .json(),
+    (accountSize) => accountSize,
+    ms('15m')
+  )
+
+  constructor({ rpcUrl, clarityUrl, assets, txsLimit }) {
+    super({ rpcUrl, assets, txsLimit })
+    this.setClarityServer(clarityUrl)
+  }
+
+  setClarityServer(clarityUrl) {
+    this.clarityUrl = clarityUrl || CLARITY_URL
+  }
+
+  request(path, contentType = 'application/json') {
+    return wretch(urljoin(this.clarityUrl, path)).headers({
+      'Content-Type': contentType,
+    })
+  }
+
+  async getTransactions(address, { cursor, limit, includeUnparsed = false } = Object.create(null)) {
+    return this.request(`/addresses/${encodeURIComponent(address)}/transactions`)
+      .query(
+        cleanQuery({
+          cursor,
+          limit,
+          includeUnparsed,
+        })
+      )
+      .get()
+      .json()
+  }
+
+  async getTransactionById(txId) {
+    return this.request(`/transaction/${encodeURIComponent(txId)}`)
+      .get()
+      .json()
+  }
+
+  async getTokensBalancesAndAccounts({ address }) {
+    return this.request(`/addresses/${encodeURIComponent(address)}/tokens-balance`)
+      .get()
+      .json()
+  }
+
+  async getTokenAccountsByOwner(address, tokenTicker) {
+    const { accounts } = await this.getTokensBalancesAndAccounts({ address })
+    return accounts
+  }
+
+  async getAccountInfo(address) {
+    return this.request(`/addresses/${encodeURIComponent(address)}/account-info`)
+      .get()
+      .json()
+  }
+
+  async getStakeAccountsInfo(address) {
+    const { stakingBalances } = await this.request(
+      `/addresses/${encodeURIComponent(address)}/base-balance`
+    )
+      .get()
+      .json()
+    return stakingBalances
+  }
+
+  async getRewards(address) {
+    return this.request(`/addresses/${encodeURIComponent(address)}/staking-rewards`)
+      .get()
+      .json()
+  }
+
+  async getBalance(address) {
+    const { balance } = await this.request(`/addresses/${encodeURIComponent(address)}/base-balance`)
+      .get()
+      .json()
+    return balance
+  }
+
+  async getMintAddress(address) {
+    const value = await this.getAccountInfo(address)
+    // token mint
+    return value?.data?.parsed?.info?.mint ?? null
+  }
+
+  async getAddressMint(address) {
+    // alias
+    return this.getMintAddress(address)
+  }
+
+  async ataOwnershipChanged(address, tokenAddress) {
+    // associated token address ownership changed
+    const value = await this.getAccountInfo(tokenAddress)
+    const owner = value?.data?.parsed?.info?.owner
+    return owner && owner !== address
+  }
+
+  async ownerChanged(address, accountInfo) {
+    // method to check if the owner of the account has changed, compared to standard programs.
+    // as there could be malicious dapps that reassign the ownership of the account (see https://github.com/coinspect/solana-assign-test)
+    const value = accountInfo || (await this.getAccountInfo(address))
+    const owner = value?.owner // program owner
+    if (!owner) return false // not initialized account (or purged)
+    return ![
+      SYSTEM_PROGRAM_ID.toBase58(),
+      TOKEN_PROGRAM_ID.toBase58(),
+      TOKEN_2022_PROGRAM_ID.toBase58(),
+    ].includes(owner)
+  }
+
+  ataOwnershipChangedCached = memoizeLruCache(
+    (...args) => this.ataOwnershipChanged(...args),
+    (address, tokenAddress) => `${address}:${tokenAddress}`,
+    { max: 1000 }
+  )
+}

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

@@ -64,7 +64,7 @@ export const createUnsignedTxForSend = async ({
     amount = asset.currency.baseUnit(1)
   }
 
-  const isToken = asset.assetType === api.tokenAssetType
+  const isToken = asset.name !== asset.baseAsset.name
 
   // Check if receiver has address active when sending tokens.
   if (isToken) {

package/src/index.js

@@ -5,6 +5,7 @@ import assetsList from '@exodus/solana-meta'
 import { Api } from './api.js'
 
 export { SolanaMonitor } from './tx-log/index.js'
+export { SolanaClarityMonitor } from './tx-log/index.js'
 export { createAccountState } from './account-state.js'
 export { getStakingInfo } from './staking-utils.js'
 export {
@@ -25,7 +26,8 @@ const assets = connectAssets(keyBy(assetsList, (asset) => asset.name))
 
 // At some point we would like to exclude this export. Default export should be the whole asset "plugin" ready to be injected.
 // Clients should not call an specific server api directly.
-const serverApi = new Api({ assets })
-export default serverApi
+const serverApi = new Api({ assets }) // TODO: remove it, clean every use from platforms
+export default serverApi // TODO: remove it
 
 export { Api } from './api.js'
+export { ClarityApi } from './clarity-api.js'

package/src/rpc-api.js

@@ -0,0 +1,455 @@
+import createApiCJS from '@exodus/asset-json-rpc'
+import { memoize, pickBy } from '@exodus/basic-utils'
+import { retry } from '@exodus/simple-retry'
+import {
+  buildRawTransaction,
+  computeBalance,
+  deserializeMetaplexMetadata,
+  filterAccountsByOwner,
+  getMetadataAccount,
+  getTransactionSimulationParams,
+  SOL_DECIMAL,
+  SYSTEM_PROGRAM_ID as SYSTEM_PROGRAM_ID_KEY,
+  TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRAM_ID_KEY,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID_KEY,
+} from '@exodus/solana-lib'
+import assert from 'minimalistic-assert'
+import ms from 'ms'
+
+import { getStakeActivation } from './get-stake-activation/index.js'
+
+const [SYSTEM_PROGRAM_ID, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID] = [
+  SYSTEM_PROGRAM_ID_KEY.toBase58(),
+  TOKEN_PROGRAM_ID_KEY.toBase58(),
+  TOKEN_2022_PROGRAM_ID_KEY.toBase58(),
+]
+const createApi = createApiCJS.default || createApiCJS
+
+const RPC_URL = 'https://solana-clarity.a.exodus.io/api/v2/solana/rpc' // Clarity proxied
+
+// Doc: https://docs.solana.com/apps/jsonrpc-api
+
+const errorMessagesToRetry = [
+  'Blockhash not found',
+  'Failed to query long-term storage; please try again',
+]
+
+// Tokens + SOL api support
+export class RpcApi {
+  getSupply = memoize(async (mintAddress) => {
+    // cached getSupply
+    const result = await this.rpcCall('getTokenSupply', [mintAddress])
+    return result?.value?.amount
+  })
+
+  getAccountSize = memoize(
+    (address) => this.getAccountInfo(address),
+    (address) => address,
+    ms('3m')
+  )
+
+  constructor({ rpcUrl, assets, txsLimit }) {
+    this.setRpcServer(rpcUrl)
+    this.setTokens(assets)
+    this.tokensToSkip = Object.create(null)
+    this.txsLimit = txsLimit
+  }
+
+  setRpcServer(rpcUrl = RPC_URL) {
+    assert(typeof rpcUrl === 'string' && rpcUrl.startsWith('http'), 'Invalid rpcUrl')
+    this.rpcUrl = rpcUrl
+    this.api = createApi(this.rpcUrl)
+  }
+
+  setTokens(assets) {
+    const solTokens = pickBy(assets, (asset) => asset.name !== asset.baseAsset.name)
+    this.tokens = new Map(Object.values(solTokens).map((v) => [v.mintAddress, v]))
+  }
+
+  async rpcCall(method, params = []) {
+    return this.api.post({ method, params })
+  }
+
+  getTokenByAddress(mint) {
+    return this.tokens.get(mint)
+  }
+
+  isTokenSupported(mint) {
+    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)
+  }
+
+  async getStakeActivation(stakeAddress) {
+    const { status } = await getStakeActivation(this, stakeAddress)
+    return status
+  }
+
+  async getRecentBlockHash(commitment) {
+    const result = await this.rpcCall('getLatestBlockhash', [
+      {
+        commitment: commitment || 'confirmed',
+        encoding: 'jsonParsed',
+      },
+    ])
+    return result?.value?.blockhash
+  }
+
+  async getPriorityFee(transaction) {
+    // https://docs.helius.dev/solana-rpc-nodes/alpha-priority-fee-api
+    const result = await this.rpcCall('getPriorityFeeEstimate', [
+      { transaction, options: { recommended: true } },
+    ])
+    return result.priorityFeeEstimate
+  }
+
+  async getBlockTime(slot) {
+    // might result in error if executed on a validator with partial ledger (https://github.com/solana-labs/solana/issues/12413)
+    return this.rpcCall('getBlockTime', [slot])
+  }
+
+  async waitForTransactionStatus(txIds, status = 'finalized', timeoutMs = ms('1m')) {
+    if (!Array.isArray(txIds)) txIds = [txIds]
+    const startTime = Date.now()
+
+    while (true) {
+      const response = await this.rpcCall('getSignatureStatuses', [
+        txIds,
+        { searchTransactionHistory: true },
+      ])
+      const data = response.value
+      const allTxsAreConfirmed = data.every((elem) => elem?.confirmationStatus === status)
+      if (allTxsAreConfirmed) {
+        return true
+      }
+
+      // Check if the timeout has elapsed
+      if (Date.now() - startTime >= timeoutMs) {
+        // timeout
+        throw new Error('waitForTransactionStatus timeout')
+      }
+
+      // Wait for the specified interval before the next request
+      await new Promise((resolve) => setTimeout(resolve, ms('10s')))
+    }
+  }
+
+  async getWalletTokensList({ tokenAccounts }) {
+    const tokensMint = []
+    for (const account of tokenAccounts) {
+      const mint = account.mintAddress
+
+      // skip cached NFT
+      if (this.tokensToSkip[mint]) continue
+      // skip 0 balance
+      if (account.balance === '0') continue
+      // skip NFT
+      if (!this.tokens.has(mint)) {
+        const supply = await this.getSupply(mint)
+        if (supply === '1') {
+          this.tokensToSkip[mint] = true
+          continue
+        }
+      }
+
+      // OK
+      tokensMint.push(mint)
+    }
+
+    return tokensMint
+  }
+
+  async isSpl(address) {
+    const { owner } = await this.getAccountInfo(address)
+    return [TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID].includes(owner)
+  }
+
+  async getTokenBalance(tokenAddress) {
+    // Returns account balance of a SPL Token account.
+    const result = await this.rpcCall('getTokenAccountBalance', [tokenAddress])
+    return result?.value?.amount
+  }
+
+  async isAssociatedTokenAccountActive(tokenAddress) {
+    try {
+      await this.getTokenBalance(tokenAddress)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async getTokenFeeBasisPoints(address) {
+    // only for token-2022
+    const value = await this.getAccountInfo(address)
+
+    const transferFeeBasisPoints =
+      value?.data?.parsed?.info?.extensions?.[0]?.state?.newerTransferFee?.transferFeeBasisPoints ??
+      0
+    const maximumFee =
+      value?.data?.parsed?.info?.extensions?.[0]?.state?.newerTransferFee?.maximumFee ?? 0
+
+    return { feeBasisPoints: transferFeeBasisPoints, maximumFee }
+  }
+
+  async getMetaplexMetadata(tokenMintAddress) {
+    const metaplexPDA = getMetadataAccount(tokenMintAddress)
+    const res = await this.getAccountInfo(metaplexPDA, 'base64')
+    const data = res?.data?.[0]
+    if (!data) return null
+
+    return deserializeMetaplexMetadata(Buffer.from(data, 'base64'))
+  }
+
+  async getDecimals(tokenMintAddress) {
+    const result = await this.rpcCall('getTokenSupply', [tokenMintAddress])
+    return result?.value?.decimals ?? null
+  }
+
+  async getAddressType(address) {
+    // solana, token or null (unknown), meaning address has never been initialized
+    const value = await this.getAccountInfo(address)
+    if (value === null) return null
+
+    const account = {
+      executable: value.executable,
+      owner: value.owner,
+      lamports: value.lamports,
+    }
+
+    if (account.owner === SYSTEM_PROGRAM_ID) return 'solana'
+    if (account.owner === TOKEN_PROGRAM_ID) return 'token'
+    if (account.owner === TOKEN_2022_PROGRAM_ID) return 'token-2022'
+    return null
+  }
+
+  async getTokenAddressOwner(address) {
+    const value = await this.getAccountInfo(address)
+    return value?.data?.parsed?.info?.owner ?? null
+  }
+
+  async isTokenAddress(address) {
+    const type = await this.getAddressType(address)
+    return ['token', 'token-2022'].includes(type)
+  }
+
+  async isSOLaddress(address) {
+    const type = await this.getAddressType(address)
+    return type === 'solana'
+  }
+
+  async getProgramAccounts(programId, config) {
+    return this.rpcCall('getProgramAccounts', [programId, config])
+  }
+
+  async getMultipleAccounts(pubkeys, config) {
+    const response = await this.rpcCall('getMultipleAccounts', [pubkeys, config])
+    return response && response.value ? response.value : []
+  }
+
+  async getFeeForMessage(message, commitment) {
+    const response = await this.rpcCall('getFeeForMessage', [
+      Buffer.from(message.serialize()).toString('base64'),
+      { commitment },
+    ])
+
+    return response?.value
+  }
+
+  /**
+   * Broadcast a signed transaction
+   */
+  broadcastTransaction = async (signedTx, options) => {
+    console.log('Solana broadcasting TX:', signedTx) // base64
+    const defaultOptions = { encoding: 'base64', preflightCommitment: 'confirmed' }
+
+    const params = [signedTx, { ...defaultOptions, ...options }]
+
+    const broadcastTxWithRetry = retry(
+      async () => {
+        try {
+          const result = await this.rpcCall('sendTransaction', params)
+          console.log(`tx ${JSON.stringify(result)} sent!`)
+
+          return result || null
+        } catch (error) {
+          if (
+            error.message &&
+            !errorMessagesToRetry.some((errorMessage) => error.message.includes(errorMessage))
+          ) {
+            error.finalError = true
+          }
+
+          console.warn(`Error broadcasting tx. Retrying...`, error)
+
+          throw error
+        }
+      },
+      { delayTimesMs: ['6s', '6s', '8s', '10s'] }
+    )
+
+    return broadcastTxWithRetry()
+  }
+
+  simulateTransaction = async (encodedTransaction, options) => {
+    const result = await this.rpcCall('simulateTransaction', [encodedTransaction, options])
+    const {
+      value: { accounts, unitsConsumed, err },
+    } = result
+
+    return { accounts, unitsConsumed, err }
+  }
+
+  resolveSimulationSideEffects = async (solAccounts, tokenAccounts) => {
+    const willReceive = []
+    const willSend = []
+
+    const resolveSols = solAccounts.map(async (account) => {
+      const currentAmount = await this.getBalance(account.address)
+      const balance = computeBalance(account.amount, currentAmount)
+      return {
+        name: 'SOL',
+        symbol: 'SOL',
+        balance,
+        decimal: SOL_DECIMAL,
+        type: 'SOL',
+      }
+    })
+
+    const _wrapAndHandleAccountNotFound = (fn, defaultValue) => {
+      return async (...params) => {
+        try {
+          return await fn.apply(this, params)
+        } catch (error) {
+          if (error.message && error.message.includes('could not find account')) {
+            return defaultValue
+          }
+
+          throw error
+        }
+      }
+    }
+
+    const _getTokenBalance = _wrapAndHandleAccountNotFound(this.getTokenBalance, '0')
+    const _getDecimals = _wrapAndHandleAccountNotFound(this.getDecimals, 0)
+    const _getSupply = _wrapAndHandleAccountNotFound(this.getSupply, '0')
+
+    const resolveTokens = tokenAccounts.map(async (account) => {
+      try {
+        const [_tokenMetaPlex, currentAmount, decimal] = await Promise.all([
+          this.getMetaplexMetadata(account.mint),
+          _getTokenBalance(account.address),
+          _getDecimals(account.mint),
+        ])
+
+        const tokenMetaPlex = _tokenMetaPlex || { name: null, symbol: null }
+        let nft = Object.create(null)
+
+        // Only perform an NFT check (getSupply) if decimal is zero
+        if (decimal === 0 && (await _getSupply(account.mint)) === '1') {
+          const compositeId = account.mint
+          nft = {
+            id: `solana:${compositeId}`,
+            compositeId,
+          }
+        }
+
+        const balance = computeBalance(account.amount, currentAmount)
+        return {
+          balance,
+          decimal,
+          nft,
+          address: account.address,
+          mint: account.mint,
+          name: tokenMetaPlex.name,
+          symbol: tokenMetaPlex.symbol,
+          type: 'TOKEN',
+        }
+      } catch (error) {
+        console.warn(error)
+        return {
+          balance: null,
+        }
+      }
+    })
+
+    const accounts = await Promise.all([...resolveSols, ...resolveTokens])
+    accounts.forEach((account) => {
+      if (account.balance === null) {
+        return
+      }
+
+      if (account.balance > 0) {
+        willReceive.push(account)
+      } else {
+        willSend.push(account)
+      }
+    })
+
+    return {
+      willReceive,
+      willSend,
+    }
+  }
+
+  simulateUnsignedTransaction = async ({ message, transactionMessage }) => {
+    const { config, accountAddresses } = getTransactionSimulationParams(
+      transactionMessage || message
+    )
+    // eslint-disable-next-line unicorn/no-new-array
+    const signatures = new Array(message.header.numRequiredSignatures || 1).fill(null)
+    const encodedTransaction = buildRawTransaction(
+      Buffer.from(message.serialize()),
+      signatures
+    ).toString('base64')
+    const { accounts, unitsConsumed, err } = await this.simulateTransaction(encodedTransaction, {
+      ...config,
+      replaceRecentBlockhash: false,
+      sigVerify: false,
+    })
+    return {
+      accounts,
+      accountAddresses,
+      unitsConsumed,
+      err,
+    }
+  }
+
+  /**
+   * Simulate transaction and return side effects
+   */
+  simulateAndRetrieveSideEffects = async (
+    message,
+    publicKey,
+    transactionMessage // decompiled TransactionMessage
+  ) => {
+    const { accounts, accountAddresses } = await this.simulateUnsignedTransaction({
+      message,
+      transactionMessage,
+    })
+    const { solAccounts, tokenAccounts } = filterAccountsByOwner(
+      accounts,
+      accountAddresses,
+      publicKey
+    )
+
+    return this.resolveSimulationSideEffects(solAccounts, tokenAccounts)
+  }
+}

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

@@ -0,0 +1,362 @@
+import { BaseMonitor } from '@exodus/asset-lib'
+import { omitBy } from '@exodus/basic-utils'
+import lodash from 'lodash'
+import assert from 'minimalistic-assert'
+import ms from 'ms'
+
+import { DEFAULT_POOL_ADDRESS } from '../account-state.js'
+
+const DEFAULT_REMOTE_CONFIG = {
+  clarityUrl: [],
+  rpcUrl: [],
+  staking: { enabled: true, pool: DEFAULT_POOL_ADDRESS },
+}
+
+const TICKS_BETWEEN_HISTORY_FETCHES = 10
+const TICKS_BETWEEN_STAKE_FETCHES = 5
+const TX_STALE_AFTER = ms('2m') // mark txs as dropped after N minutes
+
+export class SolanaClarityMonitor extends BaseMonitor {
+  constructor({
+    api,
+    includeUnparsed = false,
+    ticksBetweenHistoryFetches = TICKS_BETWEEN_HISTORY_FETCHES,
+    ticksBetweenStakeFetches = TICKS_BETWEEN_STAKE_FETCHES,
+    txsLimit,
+    shouldUpdateBalanceBeforeHistory = true,
+    ...args
+  }) {
+    super(args)
+    assert(api, 'api is required')
+    this.api = api
+    this.cursors = Object.create(null)
+    this.assets = Object.create(null)
+    this.staking = DEFAULT_REMOTE_CONFIG.staking
+    this.ticksBetweenStakeFetches = ticksBetweenStakeFetches
+    this.ticksBetweenHistoryFetches = ticksBetweenHistoryFetches
+    this.shouldUpdateBalanceBeforeHistory = shouldUpdateBalanceBeforeHistory
+    this.includeUnparsed = includeUnparsed
+    this.txsLimit = txsLimit
+  }
+
+  setServer(config = Object.create(null)) {
+    const {
+      rpcUrl,
+      clarityUrl,
+      staking = Object.create(null),
+    } = { ...DEFAULT_REMOTE_CONFIG, ...config }
+    this.api.setRpcServer(rpcUrl[0])
+    this.api.setClarityServer(clarityUrl[0])
+    this.staking = staking
+  }
+
+  hasNewCursor({ walletAccount, cursorState }) {
+    const { cursor } = cursorState
+    return this.cursors[walletAccount] !== cursor
+  }
+
+  async emitUnknownTokensEvent({ tokenAccounts }) {
+    const tokensList = await this.api.getWalletTokensList({ tokenAccounts })
+    const unknownTokensList = tokensList.filter((mintAddress) => {
+      return !this.api.tokens.has(mintAddress)
+    })
+    if (unknownTokensList.length > 0) {
+      this.emit('unknown-tokens', unknownTokensList)
+    }
+  }
+
+  async getStakingAddressesFromTxLog({ assetName, walletAccount }) {
+    const txLog = await this.aci.getTxLog({ assetName: this.asset.name, walletAccount })
+    const stakingAddresses = [...txLog]
+      .filter((tx) => tx?.data?.staking?.stakeAddresses)
+      .map((tx) => tx.data.staking.stakeAddresses)
+    return lodash.uniq(stakingAddresses.flat())
+  }
+
+  #balanceChanged({ account, newAccount }) {
+    const solBalanceChanged = !account.balance || !account.balance.equals(newAccount.balance)
+    if (solBalanceChanged) return true
+
+    // token balance changed
+    return (
+      !account.tokenBalances ||
+      Object.entries(newAccount.tokenBalances).some(
+        ([token, balance]) =>
+          !account.tokenBalances[token] || !account.tokenBalances[token].equals(balance)
+      )
+    )
+  }
+
+  async markStaleTransactions({ walletAccount, logItemsByAsset = Object.create(null) }) {
+    // mark stale txs as dropped in logItemsByAsset
+    const clearedLogItems = logItemsByAsset
+    const assetNames = Object.keys(this.assets)
+
+    for (const assetName of assetNames) {
+      const txSet = await this.aci.getTxLog({ assetName, walletAccount })
+      const { stale } = this.getUnconfirmed({ txSet, staleTxAge: TX_STALE_AFTER })
+      if (stale.length > 0) {
+        clearedLogItems[assetName] = lodash.unionBy(logItemsByAsset[assetName], stale, 'txId')
+      }
+    }
+
+    return clearedLogItems
+  }
+
+  isStakingEnabled() {
+    return true
+  }
+
+  async tick({ walletAccount, refresh }) {
+    const assetName = this.asset.name
+    this.assets = await this.aci.getAssetsForNetwork({ baseAssetName: assetName })
+    this.api.setTokens(this.assets)
+
+    const accountState = await this.aci.getAccountState({ assetName, walletAccount })
+    const address = await this.aci.getReceiveAddress({ assetName, walletAccount, useCache: true })
+
+    const { account, tokenAccounts, staking } = await this.getAccountsAndBalances({
+      refresh,
+      address,
+      accountState,
+      walletAccount,
+    })
+    const balanceChanged = this.#balanceChanged({ account: accountState, newAccount: account })
+
+    const isHistoryUpdateTick =
+      this.tickCount[walletAccount] % this.ticksBetweenHistoryFetches === 0
+
+    const shouldUpdateHistory = refresh || isHistoryUpdateTick || balanceChanged
+    const shouldUpdateOnlyBalance = balanceChanged && !shouldUpdateHistory
+
+    // getHistory is more likely to fail/be rate limited, so we want to update users balance only on a lot of ticks
+    if (this.shouldUpdateBalanceBeforeHistory || shouldUpdateOnlyBalance) {
+      // update all state at once
+      await this.updateState({ account, walletAccount, staking })
+      await this.emitUnknownTokensEvent({ tokenAccounts })
+    }
+
+    if (shouldUpdateHistory) {
+      const { logItemsByAsset, cursorState } = await this.getHistory({
+        address,
+        accountState,
+        walletAccount,
+        refresh,
+        tokenAccounts,
+      })
+
+      const cursorChanged = this.hasNewCursor({ walletAccount, cursorState })
+
+      // update all state at once
+      const clearedLogItems = await this.markStaleTransactions({ walletAccount, logItemsByAsset })
+      await this.updateTxLogByAsset({ walletAccount, logItemsByAsset: clearedLogItems, refresh })
+      await this.updateState({ account, cursorState, walletAccount, staking })
+      await this.emitUnknownTokensEvent({ tokenAccounts })
+      if (refresh || cursorChanged) {
+        this.cursors[walletAccount] = cursorState.cursor
+      }
+    }
+  }
+
+  async getHistory({ address, accountState, refresh, tokenAccounts } = Object.create(null)) {
+    const cursor = refresh ? '' : accountState.cursor
+    const baseAsset = this.asset
+
+    const { transactions, newCursor } = await this.api.getTransactions(address, {
+      cursor,
+      includeUnparsed: this.includeUnparsed,
+      limit: this.txsLimit,
+      tokenAccounts,
+    })
+
+    const mappedTransactions = []
+    for (const tx of transactions) {
+      // we get the token name using the token.mintAddress
+      let tokenName = this.api.tokens.get(tx.token?.mintAddress)?.name
+      if (tx.token && !tokenName) {
+        tokenName = 'unknown' // unknown token
+      }
+
+      const assetName = tokenName ?? baseAsset.name
+      const asset = this.assets[assetName]
+      if (assetName === 'unknown' || !asset) continue // skip unknown tokens
+      const feeAsset = asset.feeAsset
+
+      const coinAmount = tx.amount ? asset.currency.baseUnit(tx.amount) : asset.currency.ZERO
+
+      const item = {
+        coinName: assetName,
+        txId: tx.id,
+        from: [tx.from],
+        coinAmount,
+        confirmations: 1, // tx.confirmations, // avoid multiple notifications
+        date: tx.date,
+        error: tx.error,
+        data: {
+          staking: tx.staking || null,
+          unparsed: !!tx.unparsed,
+          swapTx: !!(tx.data && tx.data.inner),
+        },
+        currencies: { [assetName]: asset.currency, [feeAsset.name]: feeAsset.currency },
+      }
+
+      if (tx.owner === address) {
+        // send transaction
+        item.to = Array.isArray(tx.to) ? undefined : tx.to
+        item.feeAmount = baseAsset.currency.baseUnit(tx.fee) // in SOL
+        item.feeCoinName = baseAsset.name
+        item.coinAmount = item.coinAmount.negate()
+
+        if (tx.data?.sent) {
+          item.data.sent = tx.data.sent.map((s) => ({
+            address: s.address,
+            amount: asset.currency.baseUnit(s.amount).toDefaultString({ unit: true }),
+          }))
+        }
+
+        if (tx.to === tx.owner) {
+          item.selfSend = true
+          item.coinAmount = asset.currency.ZERO
+        }
+      } else if (tx.unparsed) {
+        if (tx.fee !== 0) {
+          item.feeAmount = baseAsset.currency.baseUnit(tx.fee) // in SOL
+          item.feeCoinName = baseAsset.name
+        }
+
+        item.data.meta = tx.data.meta
+      }
+
+      if (asset.name !== asset.baseAsset.name && item.feeAmount && item.feeAmount.isPositive) {
+        const feeItem = {
+          ...lodash.clone(item),
+          coinName: feeAsset.name,
+          tokens: [asset.name],
+          coinAmount: feeAsset.currency.ZERO,
+        }
+        mappedTransactions.push(feeItem)
+      }
+
+      mappedTransactions.push(item)
+    }
+
+    const logItemsByAsset = lodash.groupBy(mappedTransactions, (item) => item.coinName)
+    return {
+      logItemsByAsset,
+      hasNewTxs: transactions.length > 0,
+      cursorState: { cursor: newCursor },
+    }
+  }
+
+  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 solBalance = accountInfo?.lamports || 0
+
+    const accountSize = accountInfo?.space || 0
+
+    const rentExemptAmount = this.asset.currency.baseUnit(
+      await this.api.getMinimumBalanceForRentExemption(accountSize)
+    )
+
+    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) => {
+      const tokenName = this.api.tokens.get(mintAddress)?.name
+      return !this.assets[tokenName]
+    })
+    const tokenBalances = Object.fromEntries(
+      Object.entries(clientKnownTokens).map(([mintAddress, balance]) => {
+        const tokenName = this.api.tokens.get(mintAddress)?.name
+        return [tokenName, this.assets[tokenName].currency.baseUnit(balance)]
+      })
+    )
+
+    const solBalanceChanged = this.#balanceChanged({
+      account: accountState,
+      newAccount: {
+        balance: this.asset.currency.baseUnit(solBalance), // balance without staking
+        tokenBalances,
+      },
+    })
+    const fetchStakingInfo =
+      refresh ||
+      solBalanceChanged ||
+      this.tickCount[walletAccount] % this.ticksBetweenStakeFetches === 0
+
+    const staking =
+      this.isStakingEnabled() && fetchStakingInfo
+        ? await this.getStakingInfo({ address, accountState, walletAccount })
+        : { ...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)
+
+    return {
+      account: {
+        balance,
+        tokenBalances,
+        rentExemptAmount,
+        accountSize,
+        ownerChanged,
+      },
+      staking,
+      tokenAccounts,
+    }
+  }
+
+  async updateState({ account, cursorState, walletAccount, staking }) {
+    const { balance, tokenBalances, rentExemptAmount, accountSize, ownerChanged } = account
+    const newData = {
+      balance,
+      rentExemptAmount,
+      accountSize,
+      ownerChanged,
+      tokenBalances,
+      stakingInfo: staking,
+      ...cursorState,
+    }
+    return this.updateAccountState({ newData, walletAccount })
+  }
+
+  async getStakingInfo({ address, accountState, walletAccount }) {
+    const stakingInfo = await this.api.getStakeAccountsInfo(address)
+    let earned = accountState.stakingInfo.earned.toBaseString()
+    try {
+      const rewards = await this.api.getRewards(address)
+      earned = rewards
+    } catch (error) {
+      console.warn(error)
+    }
+
+    return {
+      loaded: true,
+      staking: this.staking,
+      isDelegating: Object.values(stakingInfo.accounts).some(({ state }) =>
+        ['active', 'activating', 'inactive'].includes(state)
+      ), // true if at least 1 account is delegating
+      locked: this.asset.currency.baseUnit(stakingInfo.locked),
+      activating: this.asset.currency.baseUnit(stakingInfo.activating),
+      withdrawable: this.asset.currency.baseUnit(stakingInfo.withdrawable),
+      pending: this.asset.currency.baseUnit(stakingInfo.pending), // still undelegating (not yet available for withdraw)
+      earned: this.asset.currency.baseUnit(earned),
+      accounts: stakingInfo.accounts, // Obj
+    }
+  }
+}

package/src/tx-log/index.js

@@ -1 +1,2 @@
 export * from './solana-monitor.js'
+export * from './clarity-monitor.js'

package/src/tx-send.js

@@ -44,7 +44,7 @@ export const createAndBroadcastTXFactory =
 
     const txId = signedTx.txId
 
-    const isToken = asset.assetType === api.tokenAssetType
+    const isToken = asset.name !== asset.baseAsset.name
 
     await baseAsset.api.broadcastTx(signedTx.rawTx)