@exodus/solana-api 2.5.31-alpha.1 → 2.5.31-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.5.31-alpha.1",
+  "version": "2.5.31-alpha.2",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -14,6 +14,11 @@
   "publishConfig": {
     "access": "restricted"
   },
+  "scripts": {
+    "test": "run -T jest",
+    "lint": "run -T eslint ./src",
+    "lint:fix": "yarn lint --fix"
+  },
   "dependencies": {
     "@exodus/asset-json-rpc": "^1.0.0",
     "@exodus/asset-lib": "^4.0.0",
@@ -32,7 +37,7 @@
     "wretch": "^1.5.2"
   },
   "devDependencies": {
-    "@exodus/assets-testing": "file:../../../__testing__"
+    "@exodus/assets-testing": "^1.0.0"
   },
   "gitHead": "9ec7084bcdfe14f1c6f11df393351885773046a6"
 }

package/src/account-state.js

@@ -27,6 +27,7 @@ export class SolanaAccountState extends AccountState {
       accounts: {}, // stake accounts
     },
   }
+
   static _tokens = [asset, ...tokens] // deprecated - will be removed
 
   static _postParse(data) {

package/src/api.js

@@ -25,6 +25,7 @@ import { Connection } from './connection'
 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 TXS_LIMIT = 100
 
 // Tokens + SOL api support
 export class Api {
@@ -59,18 +60,16 @@ export class Api {
   async watchAddress({
     address,
     tokensAddresses = [],
-    onMessage,
     handleAccounts,
     handleTransfers,
     handleReconnect,
     reconnectDelay,
   }) {
-    if (this.connections[address]) return // already subscribed
+    if (FORCE_HTTP) return false
     const conn = new Connection({
       endpoint: this.wsUrl,
       address,
       tokensAddresses,
-      onMsg: (json) => onMessage(json),
       callback: (updates) =>
         this.handleUpdates({ updates, address, handleAccounts, handleTransfers }),
       reconnectCallback: handleReconnect,
@@ -99,6 +98,7 @@ export class Api {
     if (lodash.get(connection, 'isOpen') && !lodash.get(connection, 'shutdown') && !forceHttp) {
       return connection.sendMessage(method, params)
     }
+
     // http fallback
     return this.api.post({ method, params })
   }
@@ -121,7 +121,7 @@ export class Api {
     return state
   }
 
-  async getRecentBlockHash(commitment?) {
+  async getRecentBlockHash(commitment) {
     const result = await this.rpcCall(
       'getLatestBlockhash',
       [{ commitment: commitment || 'finalized', encoding: 'jsonParsed' }],
@@ -170,7 +170,7 @@ export class Api {
     // cursor is a txHash
 
     try {
-      let until = cursor
+      const until = cursor
 
       const tokenAccountsByOwner = await this.getTokenAccountsByOwner(address) // Array
       const tokenAccountAddresses = tokenAccountsByOwner
@@ -187,7 +187,7 @@ export class Api {
           })
         )
       )
-      let txsId = txsResultsByAccount.reduce((arr, row) => arr.concat(row), []) // merge arrays
+      let txsId = txsResultsByAccount.flat().slice(0, TXS_LIMIT) // merge arrays
       txsId = lodash.uniqBy(txsId, 'signature')
 
       // get txs details in parallel
@@ -237,14 +237,8 @@ export class Api {
     tokenAccountsByOwner,
     { includeUnparsed = false } = {}
   ) {
-    let {
-      fee,
-      preBalances,
-      postBalances,
-      preTokenBalances,
-      postTokenBalances,
-      innerInstructions,
-    } = txDetails.meta
+    let { fee, preBalances, postBalances, preTokenBalances, postTokenBalances, innerInstructions } =
+      txDetails.meta
     preBalances = preBalances || []
     postBalances = postBalances || []
     preTokenBalances = preTokenBalances || []
@@ -383,7 +377,7 @@ export class Api {
     const stakeTx = lodash.find(instructions, { program: 'system', type: 'createAccountWithSeed' })
     const stakeWithdraw = lodash.find(instructions, { program: 'stake', type: 'withdraw' })
     const stakeUndelegate = lodash.find(instructions, { program: 'stake', type: 'deactivate' })
-    const hasSolanaTx = solanaTx && !preTokenBalances.length && !postTokenBalances.length // only SOL moved and no tokens movements
+    const hasSolanaTx = solanaTx && preTokenBalances.length === 0 && postTokenBalances.length === 0 // only SOL moved and no tokens movements
 
     let tx = {}
     if (hasSolanaTx) {
@@ -450,7 +444,7 @@ export class Api {
         Array.isArray(tokenAccountsByOwner),
         'tokenAccountsByOwner is required when parsing token tx'
       )
-      let tokenTxs = lodash
+      const tokenTxs = lodash
         .filter(instructions, ({ program, type }) => {
           return program === 'spl-token' && ['transfer', 'transferChecked'].includes(type)
         }) // get Token transfer: could have more than 1 instructions
@@ -477,7 +471,7 @@ export class Api {
           }
         })
 
-      if (tokenTxs.length) {
+      if (tokenTxs.length > 0) {
         // found spl-token simple transfer/transferChecked instruction
         // .reduce to sum/sub (based on isSending) all the same tokens amount (From instructions -> 1 single tx)
         tx = tokenTxs.reduce((finalTx, ix) => {
@@ -510,10 +504,10 @@ export class Api {
           )
         })
 
-        if (preBalances.length || postBalances.length) {
+        if (preBalances.length > 0 || postBalances.length > 0) {
           tx = {}
 
-          if (includeUnparsed && innerInstructions.length) {
+          if (includeUnparsed && innerInstructions.length > 0) {
             // when using includeUnparsed for DEX tx we want to keep SOL tx as "unparsed"
             // 1. we want to treat all SOL dex transactions as "Contract transaction", not "Sent SOL"
             // 2. default behavior is not perfect. For example it doesn't see SOL-side tx in
@@ -533,7 +527,7 @@ export class Api {
             }
 
             // If it has inner instructions then it's a DEX tx that moved SPL -> SPL
-            if (innerInstructions.length) {
+            if (innerInstructions.length > 0) {
               tx.dexTxs = innerInstructions
               // if tx involves only SPL swaps. Expand DEX ix (first element as tx base and the other kept there)
               if (!tx.from && !solanaTx) {
@@ -573,7 +567,7 @@ export class Api {
 
   async getWalletTokensList({ tokenAccounts }) {
     const tokensMint = []
-    for (let account of tokenAccounts) {
+    for (const account of tokenAccounts) {
       const mint = account.mintAddress
 
       // skip cached NFT
@@ -586,6 +580,7 @@ export class Api {
         this.tokensToSkip[mint] = true
         continue
       }
+
       // OK
       tokensMint.push(mint)
     }
@@ -601,7 +596,7 @@ export class Api {
     )
 
     const tokenAccounts = []
-    for (let entry of accountsList) {
+    for (const entry of accountsList) {
       const { pubkey, account } = entry
 
       const mint = lodash.get(account, 'data.parsed.info.mint')
@@ -619,6 +614,7 @@ export class Api {
         mintAddress: mint,
       })
     }
+
     // eventually filter by token
     return tokenTicker
       ? tokenAccounts.filter(({ ticker }) => ticker === tokenTicker)
@@ -626,18 +622,24 @@ export class Api {
   }
 
   async getTokensBalance({ address, filterByTokens = [], tokenAccounts }) {
-    let accounts = tokenAccounts || (await this.getTokenAccountsByOwner(address))
+    const accounts = tokenAccounts || (await this.getTokenAccountsByOwner(address))
 
-    const tokensBalance = accounts.reduce((acc, { tokenName, balance }) => {
-      if (tokenName === 'unknown' || (filterByTokens.length && !filterByTokens.includes(tokenName)))
+    return accounts.reduce((acc, { tokenName, balance }) => {
+      if (
+        tokenName === 'unknown' ||
+        (filterByTokens.length > 0 && !filterByTokens.includes(tokenName))
+      )
         return acc // filter by supported tokens only
-      if (!acc[tokenName]) acc[tokenName] = Number(balance)
+      if (acc[tokenName]) {
+        acc[tokenName] += Number(balance)
+      }
       // e.g { 'serum': 123 }
-      else acc[tokenName] += Number(balance) // merge same token account balance
+      else {
+        acc[tokenName] = Number(balance)
+      } // merge same token account balance
+
       return acc
     }, {})
-
-    return tokensBalance
   }
 
   async isAssociatedTokenAccountActive(tokenAddress) {
@@ -645,7 +647,7 @@ export class Api {
     try {
       await this.rpcCall('getTokenAccountBalance', [tokenAddress])
       return true
-    } catch (e) {
+    } catch {
       return false
     }
   }
@@ -698,20 +700,19 @@ export class Api {
     return account.owner === SYSTEM_PROGRAM_ID.toBase58()
       ? 'solana'
       : account.owner === TOKEN_PROGRAM_ID.toBase58()
-      ? 'token'
-      : null
+        ? 'token'
+        : null
   }
 
   async getTokenAddressOwner(address) {
     const value = await this.getAccountInfo(address)
-    const owner = lodash.get(value, 'data.parsed.info.owner', null)
-    return owner
+    return lodash.get(value, 'data.parsed.info.owner', null)
   }
 
   async getAddressMint(address) {
     const value = await this.getAccountInfo(address)
-    const mintAddress = lodash.get(value, 'data.parsed.info.mint', null) // token mint
-    return mintAddress
+    // token mint
+    return lodash.get(value, 'data.parsed.info.mint', null)
   }
 
   async isTokenAddress(address) {
@@ -746,7 +747,7 @@ export class Api {
     let locked = 0
     let withdrawable = 0
     let pending = 0
-    for (let entry of res) {
+    for (const entry of res) {
       const addr = entry.pubkey
       const lamports = lodash.get(entry, 'account.lamports', 0)
       const delegation = lodash.get(entry, 'account.data.parsed.info.stake.delegation', {})
@@ -767,11 +768,12 @@ export class Api {
       withdrawable += accounts[addr].canWithdraw ? lamports : 0
       pending += accounts[addr].isDeactivating ? lamports : 0
     }
+
     return { accounts, totalStake, locked, withdrawable, pending }
   }
 
   async getRewards(stakingAddresses = []) {
-    if (!stakingAddresses.length) return 0
+    if (stakingAddresses.length === 0) return 0
 
     // custom endpoint!
     const rewards = await this.request('rewards')
@@ -781,11 +783,9 @@ export class Api {
       .json()
 
     // sum rewards for all addresses
-    const earnings = Object.values(rewards).reduce((total, x) => {
+    return Object.values(rewards).reduce((total, x) => {
       return total + x
     }, 0)
-
-    return earnings
   }
 
   async getMinimumBalanceForRentExemption(size) {
@@ -869,6 +869,7 @@ export class Api {
           if (error.message && error.message.includes('could not find account')) {
             return defaultValue
           }
+
           throw error
         }
       }
@@ -960,7 +961,7 @@ export class Api {
   simulateAndRetrieveSideEffects = async (
     message,
     publicKey,
-    transactionMessage? // decompiled TransactionMessage
+    transactionMessage // decompiled TransactionMessage
   ) => {
     const { config, accountAddresses } = getTransactionSimulationParams(
       transactionMessage || message

package/src/connection.js

@@ -20,7 +20,6 @@ export class Connection {
     address,
     tokensAddresses = [],
     callback,
-    onMsg,
     reconnectCallback = () => {},
     reconnectDelay = DEFAULT_RECONNECT_DELAY,
   }) {
@@ -28,7 +27,6 @@ export class Connection {
     this.tokensAddresses = tokensAddresses
     this.endpoint = endpoint
     this.callback = callback
-    this.onMsg = onMsg
     this.reconnectCallback = reconnectCallback
     this.reconnectDelay = reconnectDelay
 
@@ -69,8 +67,8 @@ export class Connection {
     debug('Opening WS to:', reqUrl)
     const ws = new WebSocket(`${reqUrl}`)
     ws.onmessage = this.onMessage.bind(this)
-    ws.onopen = this.onOpen.bind(this)
-    ws.onclose = this.onClose.bind(this)
+    ws.addEventListener('open', this.onOpen.bind(this))
+    ws.addEventListener('close', this.onClose.bind(this))
     ws.onerror = this.onError.bind(this)
     return ws
   }
@@ -92,14 +90,14 @@ export class Connection {
   }
 
   get running() {
-    return !!(!this.isClosed || this.inProcessMessages || this.messageQueue.length)
+    return !!(!this.isClosed || this.inProcessMessages || this.messageQueue.length > 0)
   }
 
   get connectionState() {
     if (this.isConnecting) return 'CONNECTING'
-    else if (this.isOpen) return 'OPEN'
-    else if (this.isClosing) return 'CLOSING'
-    else if (this.isClosed) return 'CLOSED'
+    if (this.isOpen) return 'OPEN'
+    if (this.isClosing) return 'CLOSING'
+    if (this.isClosed) return 'CLOSED'
     return 'NONE'
   }
 
@@ -127,7 +125,13 @@ export class Connection {
     try {
       const json = JSON.parse(evt.data)
       debug('new ws msg:', json)
-      if (!json.error) {
+      if (json.error) {
+        if (lodash.get(this.rpcQueue, json.id)) {
+          this.rpcQueue[json.id].reject(new Error(json.error.message))
+          clearTimeout(this.rpcQueue[json.id].timeout)
+          delete this.rpcQueue[json.id]
+        } else debug('Unsupported WS message:', json.error.message)
+      } else {
         if (lodash.get(this.rpcQueue, json.id)) {
           // json-rpc reply
           clearTimeout(this.rpcQueue[json.id].timeout)
@@ -138,13 +142,8 @@ export class Connection {
           debug('pushing msg to queue', msg)
           this.messageQueue.push(msg) // sub results
         }
-        this.processMessages(json)
-      } else {
-        if (lodash.get(this.rpcQueue, json.id)) {
-          this.rpcQueue[json.id].reject(new Error(json.error.message))
-          clearTimeout(this.rpcQueue[json.id].timeout)
-          delete this.rpcQueue[json.id]
-        } else debug('Unsupported WS message:', json.error.message)
+
+        this.processMessages()
       }
     } catch (e) {
       debug(e)
@@ -197,12 +196,11 @@ export class Connection {
     }
   }
 
-  async processMessages(json) {
-    if (this.onMsg) await this.onMsg(json)
+  async processMessages() {
     if (this.inProcessMessages) return null
     this.inProcessMessages = true
     try {
-      while (this.messageQueue.length) {
+      while (this.messageQueue.length > 0) {
         const items = this.messageQueue.splice(0, this.messageQueue.length)
         await this.callback(items)
       }

package/src/get-balances.js

@@ -3,35 +3,33 @@ import { TxSet } from '@exodus/models'
 // staking may be a feature that may not be available for a given wallet.
 // In this case, The wallet should exclude the staking balance from the general balance
 
-export const getBalancesFactory = ({ stakingFeatureAvailable }) => ({
-  asset,
-  accountState,
-  txLog,
-}) => {
-  const zero = asset.currency.ZERO
-  const { balance, locked, withdrawable, pending } = fixBalances({
-    txLog,
-    balance: getBalanceFromAccountState({ asset, accountState }),
-    locked: accountState.mem?.locked || zero,
-    withdrawable: accountState.mem?.withdrawable || zero,
-    pending: accountState.mem?.pending || zero,
-    asset,
-  })
-  if (asset.baseAsset.name !== asset.name) {
-    return { balance, spendableBalance: balance }
-  }
+export const getBalancesFactory =
+  ({ stakingFeatureAvailable }) =>
+  ({ asset, accountState, txLog }) => {
+    const zero = asset.currency.ZERO
+    const { balance, locked, withdrawable, pending } = fixBalances({
+      txLog,
+      balance: getBalanceFromAccountState({ asset, accountState }),
+      locked: accountState.mem?.locked || zero,
+      withdrawable: accountState.mem?.withdrawable || zero,
+      pending: accountState.mem?.pending || zero,
+      asset,
+    })
+    if (asset.baseAsset.name !== asset.name) {
+      return { balance, spendableBalance: balance }
+    }
 
-  const balanceWithoutStaking = balance
-    .sub(locked)
-    .sub(withdrawable)
-    .sub(pending)
-    .clampLowerZero()
+    const balanceWithoutStaking = balance
+      .sub(locked)
+      .sub(withdrawable)
+      .sub(pending)
+      .clampLowerZero()
 
-  return {
-    balance: stakingFeatureAvailable ? balance : balanceWithoutStaking,
-    spendableBalance: balanceWithoutStaking.sub(asset.accountReserve || zero).clampLowerZero(),
+    return {
+      balance: stakingFeatureAvailable ? balance : balanceWithoutStaking,
+      spendableBalance: balanceWithoutStaking.sub(asset.accountReserve || zero).clampLowerZero(),
+    }
   }
-}
 
 const fixBalances = ({ txLog = TxSet.EMPTY, balance, locked, withdrawable, pending, asset }) => {
   for (const tx of txLog) {
@@ -40,10 +38,7 @@ const fixBalances = ({ txLog = TxSet.EMPTY, balance, locked, withdrawable, pendi
         balance = balance.sub(tx.feeAmount)
       }
 
-      if (!tx.data.staking) {
-        // coinAmount is negative for sent tx
-        balance = balance.sub(tx.coinAmount.abs())
-      } else {
+      if (tx.data.staking) {
         // staking tx
         switch (tx.data.staking?.method) {
           case 'delegate':
@@ -57,9 +52,13 @@ const fixBalances = ({ txLog = TxSet.EMPTY, balance, locked, withdrawable, pendi
             locked = asset.currency.ZERO
             break
         }
+      } else {
+        // coinAmount is negative for sent tx
+        balance = balance.sub(tx.coinAmount.abs())
       }
     }
   }
+
   return {
     balance: balance.clampLowerZero(),
     locked: locked.clampLowerZero(),

package/src/index.js

@@ -4,7 +4,6 @@ import assetsList from '@exodus/solana-meta'
 
 import { Api } from './api'
 
-export { Api }
 export { default as SolanaFeeMonitor } from './fee-monitor'
 export { SolanaMonitor } from './tx-log'
 export { SolanaAccountState } from './account-state'
@@ -26,3 +25,5 @@ const assets = connectAssets(keyBy(assetsList, (asset) => asset.name))
 // Clients should not call an specific server api directly.
 const serverApi = new Api({ assets })
 export default serverApi
+
+export { Api } from './api'

package/src/staking-utils.js

@@ -9,9 +9,7 @@ export const getSolStakedFee = ({ asset, stakingInfo, fee }) => {
   const { accounts } = stakingInfo
 
   const allPending = Object.entries(accounts).length
-  const pendingFee = allPending > 0 ? fee.mul(allPending) : currency.ZERO
-
-  return pendingFee
+  return allPending > 0 ? fee.mul(allPending) : currency.ZERO
 }
 
 export const getStakingInfo = (accountMem) => {

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

@@ -10,14 +10,25 @@ const DEFAULT_REMOTE_CONFIG = {
   staking: { enabled: true, pool: DEFAULT_POOL_ADDRESS },
 }
 
+const TICKS_BETWEEN_HISTORY_FETCHES = 10
+const TICKS_BETWEEN_STAKE_FETCHES = 5
+
 export class SolanaMonitor extends BaseMonitor {
-  constructor({ api, includeUnparsed = false, ...args }) {
+  constructor({
+    api,
+    includeUnparsed = false,
+    ticksBetweenHistoryFetches = TICKS_BETWEEN_HISTORY_FETCHES,
+    ticksBetweenStakeFetches = TICKS_BETWEEN_STAKE_FETCHES,
+    ...args
+  }) {
     super(args)
     assert(api, 'api is required')
     this.api = api
     this.cursors = {}
     this.assets = {}
     this.staking = DEFAULT_REMOTE_CONFIG.staking
+    this.ticksBetweenStakeFetches = ticksBetweenStakeFetches
+    this.ticksBetweenHistoryFetches = ticksBetweenHistoryFetches
     this.includeUnparsed = includeUnparsed
     this.addHook('before-stop', (...args) => this.beforeStop(...args))
   }
@@ -41,10 +52,15 @@ export class SolanaMonitor extends BaseMonitor {
     })
     return this.api.watchAddress({
       address,
-      onMessage: (json) => {
-        // new SOL tx event, tick monitor with 15 sec delay (to avoid hitting delayed nodes)
-        setTimeout(() => this.tick({ walletAccount }), 15_000)
+      /*
+      // OPTIONAL. Relying on polling through ws
+      tokensAddresses: [], // needed for ASA subs
+      handleAccounts: (updates) => this.accountsCallback({ updates, walletAccount }),
+      handleTransfers: (txs) => {
+        // new SOL tx, ticking monitor
+        this.tick({ walletAccount }) // it will cause refresh for both sender/receiver. Without necessarily fetching the tx if it's not finalized in the node.
       },
+      */
     })
   }
 
@@ -81,10 +97,24 @@ export class SolanaMonitor extends BaseMonitor {
 
   async getStakingAddressesFromTxLog({ assetName, walletAccount }) {
     const txLog = await this.aci.getTxLog({ assetName: this.asset.name, walletAccount })
-    const stakingAddresses = Array.from(txLog)
+    const stakingAddresses = [...txLog]
       .filter((tx) => _.get(tx, 'data.staking.stakeAddresses'))
       .map((tx) => tx.data.staking.stakeAddresses)
-    return _.uniq(_.flatten(stakingAddresses))
+    return _.uniq(stakingAddresses.flat())
+  }
+
+  balanceChanged({ account, newAccount }) {
+    const solBalanceChanged = !account.balance || !account.balance.equals(newAccount.balance)
+    if (solBalanceChanged) return true
+
+    const tokenBalanceChanged =
+      !account.tokenBalances ||
+      Object.entries(newAccount.tokenBalances).some(
+        ([token, balance]) =>
+          !account.tokenBalances[token] || !account.tokenBalances[token].equals(balance)
+      )
+
+    return tokenBalanceChanged
   }
 
   async tick({ walletAccount, refresh }) {
@@ -99,28 +129,43 @@ export class SolanaMonitor extends BaseMonitor {
     const address = await this.aci.getReceiveAddress({ assetName, walletAccount, useCache: true })
     const stakingAddresses = await this.getStakingAddressesFromTxLog({ assetName, walletAccount })
 
-    const { logItemsByAsset, hasNewTxs, cursorState } = await this.getHistory({
-      address,
-      accountState,
-      walletAccount,
-      refresh,
-    })
+    const fetchStakingInfo = this.tickCount[walletAccount] % this.ticksBetweenStakeFetches === 0
+    const staking = fetchStakingInfo
+      ? await this.getStakingInfo({ address, stakingAddresses })
+      : accountState.mem
 
-    const cursorChanged = this.hasNewCursor({ walletAccount, cursorState })
+    const tokenAccounts = await this.api.getTokenAccountsByOwner(address)
+    const account = await this.getAccount({ address, staking, tokenAccounts })
 
-    if (refresh || hasNewTxs || cursorChanged) {
-      const staking =
-        refresh || cursorChanged
-          ? await this.getStakingInfo({ address, stakingAddresses })
-          : accountState.mem
+    const balanceChanged = this.balanceChanged({ account: accountState, newAccount: account })
 
-      const tokenAccounts = await this.api.getTokenAccountsByOwner(address)
-      const account = await this.getAccount({ address, staking, tokenAccounts })
+    const isHistoryUpdateTick =
+      this.tickCount[walletAccount] % this.ticksBetweenHistoryFetches === 0
 
+    const shouldUpdateHistory = refresh || isHistoryUpdateTick || balanceChanged
+    const shouldUpdateOnlyBalance = balanceChanged && !shouldUpdateHistory
+    const shouldUpdateBalanceBeforeHistory = true
+
+    // getHistory is more likely to fail/be rate limited, so we want to update users balance only on a lot of ticks
+    if (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,
+      })
+
+      const cursorChanged = this.hasNewCursor({ walletAccount, cursorState })
+
+      // update all state at once
       await this.updateTxLogByAsset({ walletAccount, logItemsByAsset, refresh })
       await this.updateState({ account, cursorState, walletAccount, staking })
+      await this.emitUnknownTokensEvent({ tokenAccounts })
       if (refresh || cursorChanged) {
         this.cursors[walletAccount] = cursorState.cursor
       }
@@ -128,7 +173,7 @@ export class SolanaMonitor extends BaseMonitor {
   }
 
   async getHistory({ address, accountState, refresh } = {}) {
-    let cursor = refresh ? '' : accountState.cursor
+    const cursor = refresh ? '' : accountState.cursor
     const baseAsset = this.asset
 
     const { transactions, newCursor } = await this.api.getTransactions(address, {
@@ -181,6 +226,7 @@ export class SolanaMonitor extends BaseMonitor {
 
         item.data.meta = tx.data.meta
       }
+
       if (asset.assetType === 'SOLANA_TOKEN' && item.feeAmount && item.feeAmount.isPositive) {
         const feeItem = {
           ..._.clone(item),
@@ -190,6 +236,7 @@ export class SolanaMonitor extends BaseMonitor {
         }
         mappedTransactions.push(feeItem)
       }
+
       mappedTransactions.push(item)
     }
 

package/src/tx-send.js

@@ -1,183 +1,179 @@
 import { createUnsignedTx, findAssociatedTokenAddress } from '@exodus/solana-lib'
 import assert from 'minimalistic-assert'
 
-export const createAndBroadcastTXFactory = (api) => async (
-  { asset, walletAccount, address, amount, options = {} },
-  { assetClientInterface }
-) => {
-  const assetName = asset.name
-  assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${assetName}`)
-
-  const {
-    feeAmount,
-    method,
-    stakeAddresses,
-    seed,
-    pool,
-    customMintAddress,
-    tokenStandard,
-    // <MagicEden>
-    initializerAddress,
-    initializerDepositTokenAddress,
-    takerAmount,
-    escrowAddress,
-    escrowBump,
-    pdaAddress,
-    takerAddress,
-    expectedTakerAmount,
-    expectedMintAddress,
-    metadataAddress,
-    creators,
-    // </MagicEden>
-    reference,
-    memo,
-  } = options
-  const { baseAsset } = asset
-  const from = await assetClientInterface.getReceiveAddress({
-    assetName: baseAsset.name,
-    walletAccount,
-  })
-
-  const isToken = asset.assetType === 'SOLANA_TOKEN'
-
-  // 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
+export const createAndBroadcastTXFactory =
+  (api) =>
+  async ({ asset, walletAccount, address, amount, options = {} }, { assetClientInterface }) => {
+    const assetName = asset.name
+    assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${assetName}`)
+
+    const {
+      feeAmount,
+      method,
+      stakeAddresses,
+      seed,
+      pool,
+      customMintAddress,
+      tokenStandard,
+      // <MagicEden>
+      initializerAddress,
+      initializerDepositTokenAddress,
+      takerAmount,
+      escrowAddress,
+      escrowBump,
+      pdaAddress,
+      takerAddress,
+      expectedTakerAmount,
+      expectedMintAddress,
+      metadataAddress,
+      creators,
+      // </MagicEden>
+      reference,
+      memo,
+    } = options
+    const { baseAsset } = asset
+    const from = await assetClientInterface.getReceiveAddress({
+      assetName: baseAsset.name,
+      walletAccount,
+    })
+
+    const isToken = asset.assetType === 'SOLANA_TOKEN'
+
+    // 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
+      }
     }
-  } 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 recentBlockhash = options.recentBlockhash || (await api.getRecentBlockHash())
+
+    let tokenParams = Object.create(null)
+    if (isToken || customMintAddress) {
+      const tokenMintAddress = customMintAddress || asset.mintAddress
+      const tokenAddress = findAssociatedTokenAddress(address, tokenMintAddress)
+      const [destinationAddressType, isAssociatedTokenAccountActive, fromTokenAccountAddresses] =
+        await Promise.all([
+          api.getAddressType(address),
+          api.isAssociatedTokenAccountActive(tokenAddress),
+          api.getTokenAccountsByOwner(from),
+        ])
+
+      const fromTokenAddresses = fromTokenAccountAddresses.filter(
+        ({ mintAddress }) => mintAddress === tokenMintAddress
+      )
+
+      tokenParams = {
+        tokenMintAddress,
+        destinationAddressType,
+        isAssociatedTokenAccountActive,
+        fromTokenAddresses,
+        tokenStandard,
+      }
     }
-  }
 
-  const recentBlockhash = options.recentBlockhash || (await api.getRecentBlockHash())
-
-  let tokenParams = Object.create(null)
-  if (isToken || customMintAddress) {
-    const tokenMintAddress = customMintAddress || asset.mintAddress
-    const tokenAddress = findAssociatedTokenAddress(address, tokenMintAddress)
-    const [
-      destinationAddressType,
-      isAssociatedTokenAccountActive,
-      fromTokenAccountAddresses,
-    ] = await Promise.all([
-      api.getAddressType(address),
-      api.isAssociatedTokenAccountActive(tokenAddress),
-      api.getTokenAccountsByOwner(from),
-    ])
-
-    const fromTokenAddresses = fromTokenAccountAddresses.filter(
-      ({ mintAddress }) => mintAddress === tokenMintAddress
-    )
-
-    tokenParams = {
-      tokenMintAddress,
-      destinationAddressType,
-      isAssociatedTokenAccountActive,
-      fromTokenAddresses,
-      tokenStandard,
+    const stakingParams = {
+      method,
+      stakeAddresses,
+      seed,
+      pool,
     }
-  }
 
-  const stakingParams = {
-    method,
-    stakeAddresses,
-    seed,
-    pool,
-  }
+    const magicEdenParams = {
+      method,
+      initializerAddress,
+      initializerDepositTokenAddress,
+      takerAmount,
+      escrowAddress,
+      escrowBump,
+      pdaAddress,
+      takerAddress,
+      expectedTakerAmount,
+      expectedMintAddress,
+      metadataAddress,
+      creators,
+    }
 
-  const magicEdenParams = {
-    method,
-    initializerAddress,
-    initializerDepositTokenAddress,
-    takerAmount,
-    escrowAddress,
-    escrowBump,
-    pdaAddress,
-    takerAddress,
-    expectedTakerAmount,
-    expectedMintAddress,
-    metadataAddress,
-    creators,
-  }
+    const unsignedTransaction = createUnsignedTx({
+      asset,
+      from,
+      to: address,
+      amount,
+      fee: feeAmount,
+      recentBlockhash,
+      reference,
+      memo,
+      ...tokenParams,
+      ...stakingParams,
+      ...magicEdenParams,
+    })
 
-  const unsignedTransaction = createUnsignedTx({
-    asset,
-    from,
-    to: address,
-    amount,
-    fee: feeAmount,
-    recentBlockhash,
-    reference,
-    memo,
-    ...tokenParams,
-    ...stakingParams,
-    ...magicEdenParams,
-  })
-
-  const { txId, rawTx } = await assetClientInterface.signTransaction({
-    assetName: baseAsset.name,
-    unsignedTx: unsignedTransaction,
-    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 } : 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, rawTx } = await assetClientInterface.signTransaction({
+      assetName: baseAsset.name,
+      unsignedTx: unsignedTransaction,
+      walletAccount,
+    })
+
+    await baseAsset.api.broadcastTx(rawTx)
 
-  if (isToken) {
-    // write tx entry in solana for token fee
-    const txForFee = {
+    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 } : 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: address,
+      data,
+      currencies: { [assetName]: asset.currency, [asset.feeAsset.name]: asset.feeAsset.currency },
+    }
+    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: address,
+        selfSend,
+        currencies: {
+          [baseAsset.name]: baseAsset.currency,
+          [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
+        },
+      }
+      await assetClientInterface.updateTxLogAndNotify({
+        assetName: baseAsset.name,
+        walletAccount,
+        txs: [txForFee],
+      })
     }
-    await assetClientInterface.updateTxLogAndNotify({
-      assetName: baseAsset.name,
-      walletAccount,
-      txs: [txForFee],
-    })
-  }
 
-  return { txId }
-}
+    return { txId }
+  }