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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.5.31-alpha.2",
+  "version": "2.5.31",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -24,6 +24,7 @@
     "@exodus/asset-lib": "^4.0.0",
     "@exodus/assets": "^9.0.1",
     "@exodus/basic-utils": "^2.1.0",
+    "@exodus/currency": "^2.3.2",
     "@exodus/fetch": "^1.2.0",
     "@exodus/models": "^10.1.0",
     "@exodus/nfts-core": "^0.5.0",
@@ -32,7 +33,11 @@
     "@exodus/solana-meta": "^1.0.7",
     "bn.js": "^4.11.0",
     "debug": "^4.1.1",
+    "delay": "^4.0.1",
     "lodash": "^4.17.11",
+    "make-concurrent": "^4.0.0",
+    "minimalistic-assert": "^1.0.1",
+    "ms": "^2.1.3",
     "url-join": "4.0.0",
     "wretch": "^1.5.2"
   },

package/src/api.js

@@ -25,7 +25,6 @@ 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 {
@@ -60,16 +59,18 @@ export class Api {
   async watchAddress({
     address,
     tokensAddresses = [],
+    onMessage,
     handleAccounts,
     handleTransfers,
     handleReconnect,
     reconnectDelay,
   }) {
-    if (FORCE_HTTP) return false
+    if (this.connections[address]) return // already subscribed
     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 +188,7 @@ export class Api {
           })
         )
       )
-      let txsId = txsResultsByAccount.flat().slice(0, TXS_LIMIT) // merge arrays
+      let txsId = txsResultsByAccount.flat() // merge arrays
       txsId = lodash.uniqBy(txsId, 'signature')
 
       // get txs details in parallel
@@ -334,7 +335,7 @@ export class Api {
       }))
     innerInstructions = innerInstructions
       .reduce((acc, val) => {
-        return acc.concat(val.instructions)
+        return [...acc, ...val.instructions]
       }, [])
       .map((ix) => {
         const type = lodash.get(ix, 'parsed.type')
@@ -350,7 +351,7 @@ export class Api {
         const tokenAccount = tokenAccountsByOwner.find(({ tokenAccountAddress }) => {
           return [source, destination].includes(tokenAccountAddress)
         })
-        const isSending = !!tokenAccountsByOwner.find(({ tokenAccountAddress }) => {
+        const isSending = tokenAccountsByOwner.some(({ tokenAccountAddress }) => {
           return [source].includes(tokenAccountAddress)
         })
 
@@ -486,9 +487,11 @@ export class Api {
         const accountIndexes = lodash.mapKeys(accountKeys, (x, i) => i)
         Object.values(accountIndexes).forEach((acc) => {
           // filter by ownerAddress
+          // eslint-disable-next-line unicorn/prefer-array-some
           const hasKnownOwner = !!lodash.find(tokenAccountsByOwner, {
             tokenAccountAddress: acc.pubkey,
           })
+          // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
           acc.owner = hasKnownOwner ? ownerAddress : null
         })
 
@@ -512,7 +515,7 @@ export class Api {
             // 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
             //    SOL->SPL swaps on Raydium and Orca.
-            tx = getUnparsedTx(tx)
+            tx = getUnparsedTx()
             tx.dexTxs = getInnerTxsFromBalanceChanges()
           } else {
             if (solanaTx) {
@@ -543,7 +546,7 @@ export class Api {
     const unparsed = Object.keys(tx).length === 0
 
     if (unparsed && includeUnparsed) {
-      tx = getUnparsedTx(tx)
+      tx = getUnparsedTx()
     }
 
     // How tokens tx are parsed:
@@ -821,7 +824,7 @@ export class Api {
         } catch (error) {
           if (
             error.message &&
-            !errorMessagesToRetry.find((errorMessage) => error.message.includes(errorMessage))
+            !errorMessagesToRetry.some((errorMessage) => error.message.includes(errorMessage))
           ) {
             error.finalError = true
           }
@@ -966,6 +969,7 @@ export class Api {
     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()),

package/src/connection.js

@@ -20,6 +20,7 @@ export class Connection {
     address,
     tokensAddresses = [],
     callback,
+    onMsg,
     reconnectCallback = () => {},
     reconnectDelay = DEFAULT_RECONNECT_DELAY,
   }) {
@@ -27,6 +28,7 @@ export class Connection {
     this.tokensAddresses = tokensAddresses
     this.endpoint = endpoint
     this.callback = callback
+    this.onMsg = onMsg
     this.reconnectCallback = reconnectCallback
     this.reconnectDelay = reconnectDelay
 
@@ -66,10 +68,10 @@ export class Connection {
     reqUrl = `${obj}`
     debug('Opening WS to:', reqUrl)
     const ws = new WebSocket(`${reqUrl}`)
-    ws.onmessage = this.onMessage.bind(this)
+    ws.addEventListener('message', this.onMessage.bind(this))
     ws.addEventListener('open', this.onOpen.bind(this))
     ws.addEventListener('close', this.onClose.bind(this))
-    ws.onerror = this.onError.bind(this)
+    ws.addEventListener('error', this.onError.bind(this))
     return ws
   }
 
@@ -143,7 +145,7 @@ export class Connection {
           this.messageQueue.push(msg) // sub results
         }
 
-        this.processMessages()
+        this.processMessages(json)
       }
     } catch (e) {
       debug(e)
@@ -154,8 +156,8 @@ export class Connection {
   onOpen(evt) {
     debug('Opened WS')
     // subscribe to each addresses (SOL and ASA addr)
-
-    this.tokensAddresses.concat(this.address).forEach((address) => {
+    const addresses = [...this.tokensAddresses, this.address]
+    addresses.forEach((address) => {
       // sub for account state changes
       this.ws.send(
         JSON.stringify({
@@ -196,7 +198,8 @@ export class Connection {
     }
   }
 
-  async processMessages() {
+  async processMessages(json) {
+    if (this.onMsg) await this.onMsg(json)
     if (this.inProcessMessages) return null
     this.inProcessMessages = true
     try {

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

@@ -10,25 +10,14 @@ 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,
-    ticksBetweenHistoryFetches = TICKS_BETWEEN_HISTORY_FETCHES,
-    ticksBetweenStakeFetches = TICKS_BETWEEN_STAKE_FETCHES,
-    ...args
-  }) {
+  constructor({ api, includeUnparsed = false, ...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))
   }
@@ -52,15 +41,10 @@ export class SolanaMonitor extends BaseMonitor {
     })
     return this.api.watchAddress({
       address,
-      /*
-      // 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.
+      onMessage: (json) => {
+        // new SOL tx event, tick monitor with 15 sec delay (to avoid hitting delayed nodes)
+        setTimeout(() => this.tick({ walletAccount }), 15_000)
       },
-      */
     })
   }
 
@@ -103,20 +87,6 @@ export class SolanaMonitor extends BaseMonitor {
     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 }) {
     // Check for new wallet account
     await this.initWalletAccount({ walletAccount })
@@ -129,43 +99,28 @@ export class SolanaMonitor extends BaseMonitor {
     const address = await this.aci.getReceiveAddress({ assetName, walletAccount, useCache: true })
     const stakingAddresses = await this.getStakingAddressesFromTxLog({ assetName, walletAccount })
 
-    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 { logItemsByAsset, hasNewTxs, cursorState } = await this.getHistory({
+      address,
+      accountState,
+      walletAccount,
+      refresh,
+    })
 
-    const balanceChanged = this.balanceChanged({ account: accountState, newAccount: account })
+    const cursorChanged = this.hasNewCursor({ walletAccount, cursorState })
 
-    const isHistoryUpdateTick =
-      this.tickCount[walletAccount] % this.ticksBetweenHistoryFetches === 0
+    if (refresh || hasNewTxs || cursorChanged) {
+      const staking =
+        refresh || cursorChanged
+          ? await this.getStakingInfo({ address, stakingAddresses })
+          : accountState.mem
 
-    const shouldUpdateHistory = refresh || isHistoryUpdateTick || balanceChanged
-    const shouldUpdateOnlyBalance = balanceChanged && !shouldUpdateHistory
-    const shouldUpdateBalanceBeforeHistory = true
+      const tokenAccounts = await this.api.getTokenAccountsByOwner(address)
+      const account = await this.getAccount({ address, staking, tokenAccounts })
 
-    // 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
       }