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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.5.31-alpha.1",
+  "version": "2.5.31-alpha.3",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [

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,
@@ -187,7 +186,7 @@ export class Api {
           })
         )
       )
-      let txsId = txsResultsByAccount.reduce((arr, row) => arr.concat(row), []) // merge arrays
+      let txsId = txsResultsByAccount.reduce((arr, row) => arr.concat(row), []).slice(0, TXS_LIMIT) // merge arrays
       txsId = lodash.uniqBy(txsId, 'signature')
 
       // get txs details in parallel

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
 
@@ -138,7 +136,7 @@ export class Connection {
           debug('pushing msg to queue', msg)
           this.messageQueue.push(msg) // sub results
         }
-        this.processMessages(json)
+        this.processMessages()
       } else {
         if (lodash.get(this.rpcQueue, json.id)) {
           this.rpcQueue[json.id].reject(new Error(json.error.message))
@@ -197,8 +195,7 @@ export class Connection {
     }
   }
 
-  async processMessages(json) {
-    if (this.onMsg) await this.onMsg(json)
+  async processMessages() {
     if (this.inProcessMessages) return null
     this.inProcessMessages = true
     try {

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.
       },
+      */
     })
   }
 
@@ -87,6 +103,20 @@ export class SolanaMonitor extends BaseMonitor {
     return _.uniq(_.flatten(stakingAddresses))
   }
 
+  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 }) {
     // Check for new wallet account
     await this.initWalletAccount({ walletAccount })
@@ -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 tokenAccounts = await this.api.getTokenAccountsByOwner(address)
+    const account = await this.getAccount({ address, staking, tokenAccounts })
 
-    const cursorChanged = this.hasNewCursor({ walletAccount, cursorState })
+    const balanceChanged = this.balanceChanged({ account: accountState, newAccount: account })
 
-    if (refresh || hasNewTxs || cursorChanged) {
-      const staking =
-        refresh || cursorChanged
-          ? await this.getStakingInfo({ address, stakingAddresses })
-          : accountState.mem
+    const isHistoryUpdateTick =
+      this.tickCount[walletAccount] % this.ticksBetweenHistoryFetches === 0
 
-      const tokenAccounts = await this.api.getTokenAccountsByOwner(address)
-      const account = await this.getAccount({ address, staking, tokenAccounts })
+    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
       }