@exodus/balances 1.2.0 → 2.0.0

package/index.js

@@ -1,7 +1,9 @@
 import { isNumberUnit } from '@exodus/currency'
+import { TxSet } from '@exodus/models'
 import ExodusModule from '@exodus/module'
 import { cloneDeepWith, difference, isEmpty, merge, set, zipObject } from 'lodash'
 import makeConcurrent from 'make-concurrent'
+import getConfirmedBalance from './confirmed-balance'
 
 const cloneBalances = (balances) =>
   cloneDeepWith(balances, (val) => {
@@ -44,12 +46,13 @@ class Balances extends ExodusModule {
     this.#handleTxLogUpdate = shareQueue(this.#handleTxLogUpdate)
     this.#recompute = shareQueue(this.#recompute)
 
-    blockchainMetadata.on('loaded', () => {
-      walletAccountsAtom.observe((payload) =>
+    blockchainMetadata.once('load-wallet-accounts', () => {
+      walletAccountsAtom.observe((payload) => {
         this.#setWalletAccounts(
           Object.keys(payload).filter((walletAccount) => payload[walletAccount].enabled)
         )
-      )
+      })
+
       blockchainMetadata.on('account-state', this.#handleAccountStateUpdate)
       blockchainMetadata.on('tx-log', this.#handleTxLogUpdate)
     })
@@ -58,6 +61,7 @@ class Balances extends ExodusModule {
   }
 
   #getAsset = (assetName) => this.#assetsModule.getAsset(assetName)
+  #getAssets = () => this.#assetsModule.getAssets()
 
   #handleAccountStateUpdate = async (opts) => {
     if (!this.#ready) {
@@ -76,7 +80,8 @@ class Balances extends ExodusModule {
       })
       return
     }
-    if (this.#isHistoryBasedBalanceAsset(opts.assetName)) return this.#updateAssetSource(opts)
+
+    return this.#updateAssetSource(opts)
   }
 
   #pushIntoSharedQueue = makeConcurrent((fn) => fn(), { concurrency: 1 })
@@ -89,30 +94,47 @@ class Balances extends ExodusModule {
 
   #getBalancesForAssetSource = async ({ walletAccount, assetName }) => {
     const metadata = await this.#loadBlockchainMetadataForBalance({ walletAccount, assetName })
-    return this.#getBalancesFromBlockchainMetadata({ assetName, ...metadata })
+    return this.#getBalancesFromBlockchainMetadata({
+      assetNames: this.#getRelatedAssetNames(assetName),
+      ...metadata,
+    })
   }
 
-  #getBalancesFromBlockchainMetadata = ({ assetName, accountState, txLog }) => {
+  #getBalancesFromBlockchainMetadata = ({ assetNames, accountState, txLogsByAssetName }) => {
     // in the future accountState may have all the balances and we won't need to rely on txLog
     // for now, accountState-based balance has both the baseAsset and token balances while txLog is per asset/token
     const getAssetBalances = (assetName) => {
       const asset = this.#getAsset(assetName)
-      return asset.api.getBalances({ asset, accountState, txLog })
-    }
+      const txLog = txLogsByAssetName[assetName]
+      const balances = asset.api.getBalances({ asset, accountState, txLog })
+      if (!balances || isEmpty(balances)) return null
+
+      if (balances.balance && this.#balanceFields.includes('confirmedBalance')) {
+        balances.confirmedBalance = getConfirmedBalance({
+          assets: this.#getAssets(),
+          asset,
+          txLog,
+          balance: balances.balance,
+        })
+      }
+
+      const negativeBalanceFields = Object.keys(balances).filter(
+        (field) => balances[field]?.isNegative
+      )
+
+      if (negativeBalanceFields.length > 0) {
+        this._logger.warn('unexpected negative balance', {
+          assetName,
+          accountState,
+          txLogsByAssetName,
+          balances,
+          negativeBalanceFields,
+        })
+      }
 
-    if (this.#isHistoryBasedBalanceAsset(assetName)) {
-      const balances = getAssetBalances(assetName)
       return balances
-        ? {
-            [assetName]: balances,
-          }
-        : {}
     }
 
-    const assetNames = [assetName, ...this.#assetsModule.getTokenNames(assetName)].filter(
-      this.#isSupportedAsset
-    )
-
     const balances = assetNames.map(getAssetBalances)
     return zipNonNull(assetNames, balances)
   }
@@ -160,23 +182,41 @@ class Balances extends ExodusModule {
   }
 
   #isSupportedAsset = (assetName) => !this.#getAsset(assetName).isCombined
-  #getSupportedAssetNames = () =>
-    Object.keys(this.#assetsModule.getAssets()).filter(this.#isSupportedAsset)
+  #getSupportedAssetNames = () => Object.keys(this.#getAssets()).filter(this.#isSupportedAsset)
 
-  #isHistoryBasedBalanceAsset = (assetName) => {
-    const asset = this.#getAsset(assetName)
-    return asset.api?.hasFeature('historyBasedBalance')
-  }
+  #getRelatedAssetNames = (assetName) =>
+    [assetName, ...this.#assetsModule.getTokenNames(assetName)].filter(this.#isSupportedAsset)
+
+  #loadBlockchainMetadataForBalance = async ({
+    assetName,
+    walletAccount,
+    accountState: providedAccountState = null,
+    txLogsByAssetName: providedTxLogsByAssetName = {},
+  }) => {
+    const [txLogsByAssetSource, accountState] = await Promise.all([
+      this.#blockchainMetadata.getLoadedTxLogs(),
+      providedAccountState
+        ? Promise.resolve(providedAccountState)
+        : this.#blockchainMetadata.getAccountState({
+            assetName: this.#getAsset(assetName).baseAsset.name,
+            walletAccount,
+          }),
+    ])
+
+    const assetNames = this.#getRelatedAssetNames(assetName)
+    const txLogsByAssetName = zipObject(
+      assetNames,
+      assetNames.map(
+        (assetName) =>
+          providedTxLogsByAssetName[assetName] ||
+          txLogsByAssetSource[walletAccount]?.[assetName] ||
+          TxSet.EMPTY
+      )
+    )
 
-  #loadBlockchainMetadataForBalance = async ({ assetName, walletAccount, accountState, txLog }) => {
     return {
-      accountState:
-        accountState ||
-        (await this.#blockchainMetadata.getAccountState({
-          assetName: this.#getAsset(assetName).baseAsset.name,
-          walletAccount,
-        })),
-      txLog: txLog || (await this.#blockchainMetadata.getTxLog({ assetName, walletAccount })),
+      accountState,
+      txLogsByAssetName,
     }
   }
 
@@ -193,15 +233,22 @@ class Balances extends ExodusModule {
       return
     }
 
-    const { accountState, txLog } = await this.#loadBlockchainMetadataForBalance({
+    const { accountState, txLogsByAssetName } = await this.#loadBlockchainMetadataForBalance({
       assetName,
       walletAccount,
       accountState: providedAccountState,
-      txLog: providedTxLog,
+      txLogsByAssetName: {
+        [assetName]: providedTxLog,
+      },
     })
 
     const accountBalances = this.#balances[walletAccount]
-    const newBalances = this.#getBalancesFromBlockchainMetadata({ assetName, accountState, txLog })
+    const newBalances = this.#getBalancesFromBlockchainMetadata({
+      assetNames: this.#getRelatedAssetNames(assetName),
+      accountState,
+      txLogsByAssetName,
+    })
+
     const changes = Object.create(null)
     for (let subAssetName in newBalances) {
       const { currency } = this.#getAsset(subAssetName)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/balances",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "balances",
   "author": "Exodus Movement Inc",
   "license": "UNLICENSED",
@@ -26,10 +26,15 @@
     "lodash": "^4.17.21",
     "make-concurrent": "^4.0.0"
   },
+  "peerDependencies": {
+    "@exodus/blockchain-metadata": "^3.0.0"
+  },
   "devDependencies": {
-    "@exodus/atoms": "^1.0.0",
+    "@exodus/atoms": "^2.3.0",
     "@exodus/basic-utils": "^1.0.0",
-    "@exodus/models": "^8.9.0"
+    "@exodus/blockchain-metadata": "*",
+    "@exodus/models": "^8.9.0",
+    "@exodus/storage-memory": "*"
   },
-  "gitHead": "e99b34358ce40fe70ce2a9cb09c622582d0503c9"
+  "gitHead": "d03a2b5e5e85e7ffdd3720b22eee00e49f591824"
 }