@exodus/solana-api 2.5.30 → 2.5.31-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.5.30",
+  "version": "2.5.31-alpha.0",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -34,5 +34,5 @@
   "devDependencies": {
     "@exodus/assets-testing": "file:../../../__testing__"
   },
-  "gitHead": "5270d4cf5f0a0ae9486533f237e6abe6f026ed16"
+  "gitHead": "659340c999fa86c132293643a7fb96f33963e6cd"
 }

package/src/api.js

@@ -52,7 +52,7 @@ export class Api {
 
   request(path, contentType = 'application/json') {
     return wretch(urljoin(this.rpcUrl, path)).headers({
-      'Content-type': contentType,
+      'Content-Type': contentType,
     })
   }
 
@@ -772,8 +772,8 @@ export class Api {
     if (!stakingAddresses.length) return 0
 
     // custom endpoint!
-    const rewards = await this.request(`rewards?addresses=${stakingAddresses.join(',')}`)
-      .get()
+    const rewards = await this.request('rewards')
+      .post({ addresses: stakingAddresses })
       .error(500, () => ({})) // addresses not found
       .error(400, () => ({}))
       .json()

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))
   }
@@ -92,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 })
@@ -104,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
       }