@exodus/balances 1.0.0

package/index.js

@@ -0,0 +1,232 @@
+import { isNumberUnit } from '@exodus/currency'
+import ExodusModule from '@exodus/module'
+import { cloneDeepWith, difference, isEmpty, merge, set, zipObject } from 'lodash'
+import makeConcurrent from 'make-concurrent'
+
+const cloneBalances = (balances) =>
+  cloneDeepWith(balances, (val) => {
+    if (isNumberUnit(val)) return val
+  })
+
+const zipNonNull = (keys, values) =>
+  zipObject(
+    keys.filter((key, i) => values[i] != null),
+    values.filter((value) => value != null)
+  )
+
+class Balances extends ExodusModule {
+  #assetsModule
+  #blockchainMetadata
+  #balanceFields
+  #walletAccounts = null // string[]
+  #ready = false
+
+  #oldBalances = {}
+  #balances = {}
+
+  constructor({ assetsModule, blockchainMetadata, walletAccountsAtom, balanceFields, logger }) {
+    super({ name: 'Balances', logger })
+
+    this.#assetsModule = assetsModule
+    this.#blockchainMetadata = blockchainMetadata
+    this.#balanceFields = balanceFields
+
+    const shareQueue =
+      (fn) =>
+      (...args) => {
+        if (!this.#ready) return
+
+        this.#pushIntoSharedQueue(() => fn.apply(this, args))
+      }
+
+    // these share a queue
+    this.#updateAssetSource = shareQueue(this.#updateAssetSource)
+    this.#recompute = shareQueue(this.#recompute)
+
+    blockchainMetadata.on('account-state', async (opts) => {
+      return this.#updateAssetSource(opts)
+    })
+
+    blockchainMetadata.on('tx-log', async (opts) => {
+      if (this.#isHistoryBasedBalanceAsset(opts.assetName)) return this.#updateAssetSource(opts)
+    })
+
+    walletAccountsAtom.observe((payload) =>
+      this.#setWalletAccounts(
+        Object.keys(payload).filter((walletAccount) => payload[walletAccount].enabled)
+      )
+    )
+
+    assetsModule.on('assets-add', this.#onAssetsChanged)
+  }
+
+  #getAsset = (assetName) => this.#assetsModule.getAsset(assetName)
+
+  #pushIntoSharedQueue = makeConcurrent((fn) => fn(), { concurrency: 1 })
+
+  #reset = ({ walletAccounts = this.#walletAccounts } = {}) => {
+    walletAccounts.forEach((walletAccount) => {
+      this.#balances[walletAccount] = {}
+    })
+  }
+
+  #getBalancesForAssetSource = async ({ walletAccount, assetName }) => {
+    const metadata = await this.#loadBlockchainMetadataForBalance({ walletAccount, assetName })
+    return this.#getBalancesFromBlockchainMetadata({ assetName, ...metadata })
+  }
+
+  #getBalancesFromBlockchainMetadata = ({ assetName, accountState, txLog }) => {
+    // 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 })
+    }
+
+    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)
+  }
+
+  #getBalancesForWalletAccount = async ({ walletAccount }) => {
+    const assetNames = this.#assetsModule.getBaseAssetNames()
+    const balances = await Promise.all(
+      assetNames.map((assetName) => this.#getBalancesForAssetSource({ assetName, walletAccount }))
+    )
+
+    return merge({}, ...balances)
+  }
+
+  #load = async ({ walletAccount }) => {
+    this._logger.log(`loading walletAccount ${walletAccount}`)
+    this.#balances[walletAccount] = await this.#getBalancesForWalletAccount({ walletAccount })
+  }
+
+  #setWalletAccounts = (walletAccounts) => {
+    const added = difference(walletAccounts, this.#walletAccounts)
+    const removed = difference(this.#walletAccounts, walletAccounts)
+    if (added.length === 0 && removed.length === 0) return
+
+    this.#walletAccounts = walletAccounts
+    this.#ready = true
+    if (removed.length > 0) {
+      this._logger.log('recomputing after removing walletAccounts', removed)
+      removed.forEach((walletAccount) => {
+        delete this.#balances[walletAccount]
+      })
+    }
+
+    if (added.length > 0) {
+      this._logger.log('recomputing after adding walletAccounts', added)
+      this.#recompute({ walletAccounts: added })
+    } else {
+      this.sync()
+    }
+  }
+
+  #onAssetsChanged = async () => {
+    // TODO: make this more efficient
+    this._logger.log('recomputing based on new assets list')
+    this.#recompute()
+  }
+
+  #isSupportedAsset = (assetName) => !this.#getAsset(assetName).isCombined
+
+  #isHistoryBasedBalanceAsset = (assetName) => {
+    const asset = this.#getAsset(assetName)
+    return asset.api?.hasFeature('historyBasedBalance')
+  }
+
+  #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 })),
+    }
+  }
+
+  #updateAssetSource = async ({
+    assetName,
+    walletAccount,
+    accountState: providedAccountState,
+    txLog: providedTxLog,
+  }) => {
+    if (!this.#isSupportedAsset(assetName)) return
+
+    if (!this.#walletAccounts.includes(walletAccount)) {
+      this._logger.warn(`unexpected update for disabled walletAccount ${walletAccount}`)
+      return
+    }
+
+    const { accountState, txLog } = await this.#loadBlockchainMetadataForBalance({
+      assetName,
+      walletAccount,
+      accountState: providedAccountState,
+      txLog: providedTxLog,
+    })
+
+    const accountBalances = this.#balances[walletAccount]
+    const newBalances = this.#getBalancesFromBlockchainMetadata({ assetName, accountState, txLog })
+    const changes = {}
+    for (let subAssetName in newBalances) {
+      const { currency } = this.#getAsset(subAssetName)
+      const newAssetBalances = newBalances?.[subAssetName]
+      // e.g. totalBalance or spendableBalance
+      for (const field of this.#balanceFields) {
+        const oldBalance = accountBalances?.[subAssetName]?.[field]
+        const newBalance = newAssetBalances?.[field]
+        if (!newBalance) continue
+        if ((oldBalance || currency.ZERO).equals(newBalance)) continue
+
+        this._logger.log(`updating assetSource ${walletAccount}:${assetName}`)
+        set(changes, [walletAccount, subAssetName, field], {
+          from: oldBalance ?? currency.ZERO,
+          to: newBalance,
+        })
+
+        set(accountBalances, [subAssetName, field], newBalance)
+      }
+    }
+
+    if (!isEmpty(changes)) this.sync({ changes })
+  }
+
+  #recompute = async ({ walletAccounts = this.#walletAccounts } = {}) => {
+    this.#reset({ walletAccounts })
+    await Promise.all(walletAccounts.map((walletAccount) => this.#load({ walletAccount })))
+    this.sync()
+  }
+
+  sync = ({ changes } = {}) => {
+    this._logger.log('balances updated')
+
+    const oldBalances = this.#oldBalances
+    this.emit('balances', {
+      balances: this.#balances,
+      oldBalances,
+      changes,
+    })
+
+    this.#oldBalances = cloneBalances(this.#balances)
+  }
+}
+
+const createBalances = (opts) => new Balances(opts)
+
+export default createBalances

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@exodus/balances",
+  "version": "1.0.0",
+  "description": "balances",
+  "author": "Exodus Movement Inc",
+  "license": "UNLICENSED",
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint .",
+    "lint:fix": "yarn lint --fix"
+  },
+  "files": [
+    "index.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
+  },
+  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/modules/balances",
+  "bugs": {
+    "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Abalances"
+  },
+  "dependencies": {
+    "@exodus/currency": "^2.1.2",
+    "@exodus/module": "^1.0.0",
+    "lodash": "^4.17.21",
+    "make-concurrent": "^4.0.0"
+  },
+  "devDependencies": {
+    "@exodus/atoms": "^1.0.0",
+    "@exodus/basic-utils": "^0.7.0",
+    "@exodus/models": "^8.9.0"
+  }
+}