@exodus/balances 12.6.1 → 13.0.0-alpha.0

package/default-config.js

@@ -0,0 +1,25 @@
+const balanceFieldsConfig = [
+  { name: 'total', legacyName: 'balance', default: 'zero' },
+  { name: 'spendable', legacyName: 'spendableBalance', default: 'total' },
+  { name: 'unconfirmedSent' },
+  { name: 'unconfirmedReceived' },
+  { name: 'unspendable' },
+  { name: 'walletReserve' },
+  { name: 'networkReserve' },
+  { name: 'staking' },
+  { name: 'staked' },
+  { name: 'stakable' },
+  { name: 'unstaking' },
+  { name: 'unstaked' },
+  { name: 'rewards' },
+  { name: 'frozen' },
+]
+
+const config = {
+  balanceFieldsConfig,
+  balanceFields: balanceFieldsConfig
+    .flatMap((fieldConfig) => [fieldConfig.name, fieldConfig.legacyName])
+    .filter(Boolean), // wallets can reduce the number of exposed fields
+}
+
+export default config

package/index.js

@@ -8,9 +8,21 @@ import {
 import balancesReportDefinition from './report'
 import { balancesLifecyclePluginDefinition, balancesAnalyticsPluginDefinition } from './plugins'
 import typeforce from '@exodus/typeforce'
+import defaultConfig from './default-config'
 
-const balances = (config) => {
-  typeforce({ balanceFields: typeforce.arrayOf('String') }, config, true)
+const balances = (walletConfig) => {
+  const config = {
+    ...defaultConfig,
+    balanceFields: walletConfig?.balanceFields || defaultConfig.balanceFields,
+  }
+  typeforce(
+    {
+      balanceFields: typeforce.arrayOf('String'),
+      balanceFieldsConfig: typeforce.arrayOf('Object'),
+    },
+    config,
+    true
+  )
 
   return {
     id: 'balances',

package/module/balances-utils.js

@@ -0,0 +1,86 @@
+import { mapValues } from '@exodus/basic-utils'
+
+function resolveFieldBalance({ balances, fieldConfig, zero, processedBalances }) {
+  if (balances[fieldConfig.name]) {
+    return balances[fieldConfig.name]
+  }
+
+  if (fieldConfig.legacyName && balances[fieldConfig.legacyName]) {
+    return balances[fieldConfig.legacyName]
+  }
+
+  if (fieldConfig.default && fieldConfig.default === 'zero') {
+    return zero
+  }
+
+  if (fieldConfig.default && processedBalances[fieldConfig.default] !== null) {
+    if (processedBalances[fieldConfig.default] === undefined) {
+      throw new Error(
+        `Field config "${fieldConfig.default}" must be defined before "${fieldConfig.name}"`
+      )
+    }
+
+    return processedBalances[fieldConfig.default]
+  }
+
+  return null
+}
+
+export const processAssetBalances = ({ balances, zero, balanceFieldsConfig }) => {
+  return balanceFieldsConfig.reduce((processedBalances, fieldConfig) => {
+    const balance = resolveFieldBalance({
+      balances,
+      fieldConfig,
+      zero,
+      processedBalances,
+    })
+    if (balance !== null) {
+      processedBalances[fieldConfig.name] = balance
+      if (fieldConfig.legacyName) {
+        processedBalances[fieldConfig.legacyName] = balance
+      }
+    }
+
+    return processedBalances
+  }, {})
+}
+
+export const validateBalances = ({ balances, asset, logger }) => {
+  const assetName = asset.name
+  const zero = asset.currency.ZERO
+
+  const log = (error) => {
+    logger.warn(error.fn, error.error, error.args)
+  }
+
+  return mapValues(balances, (balance, field) => {
+    if (!balance) {
+      return balance
+    }
+
+    if (!balance.unitType.equals(asset.currency)) {
+      log({
+        fn: 'getAssetBalances',
+        error: `asset.api.getBalances ${assetName} returns different ${field} currency`,
+        args: {
+          balanceUnit: balance.unitType.defaultUnit.unitName,
+          assetUnit: asset.currency.defaultUnit.unitName,
+        },
+      })
+      return zero
+    }
+
+    if (balance.isNegative) {
+      log({
+        fn: 'getAssetBalances',
+        error: `asset.api.getBalances ${assetName} returns negative ${field}`,
+        args: {
+          amount: balance.toDefaultString({ unit: true }),
+        },
+      })
+      return zero
+    }
+
+    return balance
+  })
+}

package/module/index.js

@@ -2,9 +2,10 @@ import { isNumberUnit } from '@exodus/currency'
 import { TxSet } from '@exodus/models'
 import ExodusModule from '@exodus/module'
 import { cloneDeepWith, isEmpty, merge, set, zipObject } from 'lodash'
-import { difference, flattenToPaths } from '@exodus/basic-utils'
+import { difference, flattenToPaths, pick } from '@exodus/basic-utils'
 import makeConcurrent from 'make-concurrent'
-import getConfirmedBalance from './confirmed-balance'
+import { processAssetBalances, validateBalances } from './balances-utils'
+import defaultConfig from '../default-config'
 
 const cloneBalances = (balances) =>
   cloneDeepWith(balances, (val) => {
@@ -22,6 +23,7 @@ export const MODULE_ID = 'balances'
 class Balances extends ExodusModule {
   #assetsModule
   #assetsAtom
+  #balanceFieldsConfig
   #balanceFields
   #walletAccounts = [] // string[]
   #ready = false
@@ -38,7 +40,7 @@ class Balances extends ExodusModule {
     assetsModule,
     assetsAtom,
     enabledWalletAccountsAtom,
-    config: { balanceFields },
+    config,
     logger,
     balancesAtom,
     txLogsAtom,
@@ -48,7 +50,8 @@ class Balances extends ExodusModule {
 
     this.#assetsModule = assetsModule
     this.#assetsAtom = assetsAtom
-    this.#balanceFields = balanceFields
+    this.#balanceFieldsConfig = config?.balanceFieldsConfig || defaultConfig.balanceFieldsConfig
+    this.#balanceFields = config?.balanceFields || defaultConfig.balanceFields
     this.#balancesAtom = balancesAtom
     this.#accountStatesAtom = accountStatesAtom
     this.#txLogsAtom = txLogsAtom
@@ -160,59 +163,31 @@ class Balances extends ExodusModule {
     })
   }
 
+  // It adds both old and new balances to the response.
+  // Ideally, selectors should start using the new ones (total, spendable, etc)
+
   #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)
       const txLog = txLogsByAssetName[assetName]
-      const balances = asset.api.getBalances({ asset, accountState, txLog })
-      if (!balances || isEmpty(balances) || !balances.balance)
-        return Object.fromEntries(this.#balanceFields.map((field) => [field, asset.currency.ZERO]))
-      if (!balances.balance.unitType.equals(asset.currency)) {
-        this.emit('error', {
-          fn: 'getAssetBalances',
-          error: 'asset.api.getBalances returns different currency',
-          args: {
-            balanceUnit: balances.balance.unitType.defaultUnit.unitName,
-            assetUnit: asset.currency.defaultUnit.unitName,
-          },
-        })
-
-        this._logger.warn(
-          'asset.api.getBalances returns different currency, asset currency:',
-          asset.currency.defaultUnit.unitName,
-          'balance currency',
-          balances.balance.unitType.defaultUnit.unitName,
-          'return zero balance for it'
-        )
 
-        return Object.fromEntries(this.#balanceFields.map((field) => [field, asset.currency.ZERO]))
-      }
-
-      if (balances.balance && this.#balanceFields.includes('confirmedBalance')) {
-        balances.confirmedBalance = getConfirmedBalance({
-          asset,
-          txLog,
-          balance: balances.balance,
-        })
-      }
+      const zero = asset.currency.ZERO
 
-      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,
-        })
-      }
-
-      return balances
+      const apiBalances = asset.api.getBalances({ asset, accountState, txLog })
+      const balances = processAssetBalances({
+        balanceFieldsConfig: this.#balanceFieldsConfig,
+        balances: apiBalances || {},
+        zero,
+      })
+      return validateBalances({
+        balances: pick(balances, this.#balanceFields),
+        asset,
+        zero,
+        logger: this._logger,
+        emitter: this,
+      })
     }
 
     const balances = assetNames.map(getAssetBalances)

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@exodus/balances",
-  "version": "12.6.1",
+  "version": "13.0.0-alpha.0",
   "description": "Tracks crypto balances across enabled wallet accounts.",
   "author": "Exodus Movement Inc.",
   "license": "UNLICENSED",
   "scripts": {
-    "test": "jest",
-    "lint": "eslint . --ignore-path ../../.gitignore",
+    "test": "run -T jest",
+    "lint": "run -T eslint . --ignore-path ../../.gitignore",
     "lint:fix": "yarn lint --fix"
   },
   "main": "index.js",
   "files": [
     "module",
     "atoms",
+    "default-config.js",
     "report",
     "plugins",
     "redux",
@@ -29,12 +30,13 @@
     "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Abalances"
   },
   "dependencies": {
-    "@exodus/atoms": "^7.0.1",
+    "@exodus/atoms": "workspace:^",
     "@exodus/basic-utils": "^2.1.0",
     "@exodus/currency": "^2.1.2",
     "@exodus/models": "^10.1.0",
     "@exodus/module": "^1.1.0",
-    "@exodus/multi-account-redux": "^2.0.1",
+    "@exodus/multi-account-redux": "workspace:^",
+    "@exodus/redux-dependency-injection": "workspace:^",
     "@exodus/typeforce": "^1.18.0",
     "lodash": "^4.17.21",
     "make-concurrent": "^4.0.0",
@@ -46,17 +48,14 @@
   "devDependencies": {
     "@exodus/assets": "^8.0.94",
     "@exodus/assets-base": "^8.1.10",
-    "@exodus/assets-feature": "^4.1.0",
+    "@exodus/assets-feature": "workspace:^",
     "@exodus/bitcoin-meta": "^1.0.1",
     "@exodus/blockchain-metadata": "^9.0.1",
     "@exodus/ethereum-meta": "^1.0.30",
-    "@exodus/redux-dependency-injection": "^3.0.0",
+    "@exodus/redux-dependency-injection": "workspace:^",
     "@exodus/storage-memory": "*",
-    "@exodus/wallet-accounts": "^15.1.0",
-    "eslint": "^8.44.0",
+    "@exodus/wallet-accounts": "workspace:^",
     "events": "^3.3.0",
-    "jest": "^29.1.2",
     "redux": "^4.2.1"
-  },
-  "gitHead": "e3f89304d9ac03902bd4b6a7b1cd8cbcd1242067"
+  }
 }

package/redux/multi-account-helper.js

@@ -6,7 +6,7 @@ const helper = createReduxModuleHelper({
   createInitialPerAssetData: ({ asset }) => {
     return { balance: asset.currency.ZERO }
   },
-  assetSourceDataSelectors: [{ name: 'balance', selector: (assetData) => assetData.balance }],
+  assetSourceDataSelectors: [{ name: 'balance', selector: (assetData) => assetData.total }],
 })
 
 export default helper

package/redux/selectors/create-balance-selectors.js

@@ -0,0 +1,43 @@
+import { memoize } from 'lodash'
+import { MY_STATE } from '@exodus/redux-dependency-injection'
+import { createSelector } from 'reselect'
+
+const createBalanceSelectorFactory = ({ field, id }) => {
+  const selectorFactory = (selfSelector) =>
+    memoize(
+      ({ assetName, walletAccount }) =>
+        createSelector(
+          selfSelector,
+          (balances) => balances[walletAccount]?.data[assetName]?.[field]
+        ),
+      ({ assetName, walletAccount, field }) => [assetName, walletAccount, field].join('-')
+    )
+
+  return {
+    id,
+    selectorFactory,
+    dependencies: [{ selector: MY_STATE }],
+  }
+}
+
+const createBalanceSelectors = [
+  // regenerate if there is a new balance field!!
+  { id: 'createTotal', field: 'total' },
+  { id: 'createBalance', field: 'balance' },
+  { id: 'createSpendable', field: 'spendable' },
+  { id: 'createSpendableBalance', field: 'spendableBalance' },
+  { id: 'createUnconfirmedSent', field: 'unconfirmedSent' },
+  { id: 'createUnconfirmedReceived', field: 'unconfirmedReceived' },
+  { id: 'createUnspendable', field: 'unspendable' },
+  { id: 'createWalletReserve', field: 'walletReserve' },
+  { id: 'createNetworkReserve', field: 'networkReserve' },
+  { id: 'createStaking', field: 'staking' },
+  { id: 'createStaked', field: 'staked' },
+  { id: 'createStakable', field: 'stakable' },
+  { id: 'createUnstaking', field: 'unstaking' },
+  { id: 'createUnstaked', field: 'unstaked' },
+  { id: 'createRewards', field: 'rewards' },
+  { id: 'createFrozen', field: 'frozen' },
+].map(createBalanceSelectorFactory)
+
+export default createBalanceSelectors

package/redux/selectors/get-balance-for-field.js

@@ -0,0 +1,26 @@
+import { memoize } from 'lodash'
+import defaultConfig from '../../default-config'
+
+const { balanceFields } = defaultConfig
+
+const resultFunction = (getBalances) =>
+  memoize(
+    ({ assetName, walletAccount, field }) => {
+      if (!balanceFields.includes(field)) {
+        throw new Error(
+          `Value '${field}' is not one of the valid fields '${balanceFields.join(', ')}'`
+        )
+      }
+
+      return getBalances({ assetName, walletAccount })?.[field]
+    },
+    ({ assetName, walletAccount, field }) => [assetName, walletAccount, field].join('-')
+  )
+
+const getBalanceForFieldSelectorDefinition = {
+  id: 'getBalanceForField',
+  resultFunction,
+  dependencies: [{ module: 'balances', selector: 'getBalances' }],
+}
+
+export default getBalanceForFieldSelectorDefinition

package/redux/selectors/get-balance-selectors.js

@@ -0,0 +1,39 @@
+import { memoize } from 'lodash'
+
+const createResultFunction = (field) => (getBalanceForField) =>
+  memoize(
+    ({ assetName, walletAccount }) => {
+      return getBalanceForField({ assetName, walletAccount, field })
+    },
+    ({ assetName, walletAccount }) => [assetName, walletAccount].join('-')
+  )
+
+const getBalanceSelectorFactory = ({ field, id }) => {
+  return {
+    id,
+    resultFunction: createResultFunction(field),
+    dependencies: [{ module: 'balances', selector: 'getBalanceForField' }],
+  }
+}
+
+const getBalanceSelectors = [
+  // regenerate if there is a new balance field!!
+  { id: 'getTotal', field: 'total' },
+  { id: 'getBalance', field: 'balance' },
+  { id: 'getSpendable', field: 'spendable' },
+  { id: 'getSpendableBalance', field: 'spendableBalance' },
+  { id: 'getUnconfirmedSent', field: 'unconfirmedSent' },
+  { id: 'getUnconfirmedReceived', field: 'unconfirmedReceived' },
+  { id: 'getUnspendable', field: 'unspendable' },
+  { id: 'getWalletReserve', field: 'walletReserve' },
+  { id: 'getNetworkReserve', field: 'networkReserve' },
+  { id: 'getStaking', field: 'staking' },
+  { id: 'getStaked', field: 'staked' },
+  { id: 'getStakable', field: 'stakable' },
+  { id: 'getUnstaking', field: 'unstaking' },
+  { id: 'getUnstaked', field: 'unstaked' },
+  { id: 'getRewards', field: 'rewards' },
+  { id: 'getFrozen', field: 'frozen' },
+].map(getBalanceSelectorFactory)
+
+export default getBalanceSelectors

package/redux/selectors/get-balances.js

@@ -0,0 +1,21 @@
+import { memoize } from 'lodash'
+import { createSelector } from 'reselect'
+import { MY_STATE } from '@exodus/redux-dependency-injection'
+
+const selectorFactory = (selfSelector) =>
+  createSelector(selfSelector, (balances) =>
+    memoize(
+      ({ assetName, walletAccount }) => {
+        return balances[walletAccount]?.data[assetName]
+      },
+      ({ assetName, walletAccount }) => [assetName, walletAccount].join('-')
+    )
+  )
+
+const getBalancesSelectorDefinition = {
+  id: 'getBalances',
+  selectorFactory,
+  dependencies: [{ selector: MY_STATE }],
+}
+
+export default getBalancesSelectorDefinition

package/redux/selectors/index.js

@@ -1,9 +1,17 @@
 import byAssetSelectorDefinition from './by-asset'
 import createUnconfirmedBalanceSelectorDefinition from './create-unconfirmed-balance'
+import getBalanceForFieldSelectorDefinition from './get-balance-for-field'
+import getBalanceSelectors from './get-balance-selectors'
+import getBalancesSelectorDefinition from './get-balances'
+import createBalancesSelectors from './create-balance-selectors'
 import getUnconfirmedBalanceSelectorDefinition from './get-unconfirmed-balance'
 
 export default [
   byAssetSelectorDefinition,
   createUnconfirmedBalanceSelectorDefinition,
+  getBalanceForFieldSelectorDefinition,
+  ...getBalanceSelectors,
+  ...createBalancesSelectors,
+  getBalancesSelectorDefinition,
   getUnconfirmedBalanceSelectorDefinition,
 ]

package/module/confirmed-balance.js

@@ -1,19 +0,0 @@
-import { TxSet } from '@exodus/models'
-
-const isUnconfirmedTx = (tx) => tx.pending && !tx.error
-
-const getTxSetBalance = (txSet) => txSet.getMutations().slice(-1)[0].balance
-
-const getUnconfirmedTotal = ({ asset, txLog }) => {
-  const unconfirmedTxs = [...txLog].filter(isUnconfirmedTx)
-  return unconfirmedTxs.length === 0
-    ? asset.currency.ZERO
-    : getTxSetBalance(TxSet.fromArray(unconfirmedTxs))
-}
-
-const getConfirmedBalance = ({ asset, txLog, balance }) => {
-  const unconfirmedTotal = getUnconfirmedTotal({ asset, txLog })
-  return balance.sub(unconfirmedTotal)
-}
-
-export default getConfirmedBalance