@exodus/activity-txs 1.0.0

package/README.md

@@ -0,0 +1,5 @@
+# @exodus/activity-txs
+
+## Usage
+
+ioc.use(activityTxs())

package/atoms/activity-txs.js

@@ -0,0 +1,126 @@
+import { combine, compute } from '@exodus/atoms'
+import { createSelector } from 'reselect'
+import { memoize } from 'lodash'
+import { mapValues } from '@exodus/basic-utils'
+import { createDeepEqualOutputSelector } from '@exodus/core-selectors/utils/deep-equal'
+
+const createAssetSourceActivityTxsSelector = memoize(
+  ({ assetName, walletAccount }) =>
+    createDeepEqualOutputSelector(
+      (args) => args.txSet,
+      (args) => args.baseAssetAccountState,
+      (args) => args.asset,
+      (txSet, baseAssetAccountState, asset) =>
+        asset.api.getActivityTxs({
+          txs: [...txSet],
+          asset,
+          accountState: baseAssetAccountState,
+        })
+    ),
+  ({ assetName, walletAccount }) => `${assetName}_${walletAccount}`
+)
+
+const createAssetSourceTxsSelector = memoize(
+  ({ assetName, walletAccount }) =>
+    createSelector(
+      (args) => args.txSet,
+      (txSet) => {
+        return [...txSet]
+      }
+    ),
+  ({ assetName, walletAccount }) => `${assetName}_${walletAccount}`
+)
+
+const areActivitiesEqual = (obj1 = {}, obj2 = {}) => {
+  // Get wallet account keys from both objects
+  const obj1WalletAccounts = Object.keys(obj1)
+  const obj2WalletAccounts = Object.keys(obj2)
+
+  // Check if both objects have the same number of wallet accounts
+  if (obj1WalletAccounts.length !== obj2WalletAccounts.length) {
+    return false
+  }
+
+  // Iterate over each wallet account in obj1
+  for (const walletAccount of obj1WalletAccounts) {
+    // Check if obj2 has the same wallet account
+    if (!obj2.hasOwnProperty(walletAccount)) {
+      return false
+    }
+
+    const obj1Assets = obj1[walletAccount] || {}
+    const obj2Assets = obj2[walletAccount] || {}
+
+    const obj1AssetNames = Object.keys(obj1Assets)
+    const obj2AssetNames = Object.keys(obj2Assets)
+
+    if (obj1AssetNames.length !== obj2AssetNames.length) {
+      return false
+    }
+
+    // Iterate over each asset in obj1Assets
+    for (const assetName of obj1AssetNames) {
+      // Check if obj2Assets has the same asset name and the data matches
+      if (
+        !obj2Assets.hasOwnProperty(assetName) ||
+        obj1Assets[assetName] !== obj2Assets[assetName]
+      ) {
+        return false
+      }
+    }
+  }
+
+  return true
+}
+
+const createActivityTxsAtom = ({ txLogsAtom, accountStatesAtom, assetsModule }) => {
+  const inputAtom = combine({
+    txLogs: txLogsAtom,
+    accountStates: accountStatesAtom,
+  })
+
+  let prevResult
+
+  const selector = ({ txLogs, accountStates }) => {
+    const { value } = txLogs
+    const { value: accountStatesValue } = accountStates
+    const result = mapValues(value, (accountTxLogs, walletAccount) =>
+      mapValues(accountTxLogs, (assetTxSet, assetName) => {
+        const asset = assetsModule.getAsset(assetName)
+        const baseAssetName = asset.baseAsset.name
+        if (asset?.api?.getActivityTxs) {
+          return createAssetSourceActivityTxsSelector(assetName)({
+            asset,
+            txSet: assetTxSet,
+            baseAssetAccountState: accountStatesValue?.[walletAccount]?.[baseAssetName],
+          })
+        } else {
+          return createAssetSourceTxsSelector(assetName)({
+            txSet: assetTxSet,
+          })
+        }
+      })
+    )
+    if (areActivitiesEqual(result, prevResult)) {
+      return prevResult
+    }
+
+    prevResult = result
+
+    return result
+  }
+
+  return compute({
+    atom: inputAtom,
+    selector,
+  })
+}
+
+const activityTxsAtomDefinition = {
+  id: 'activityTxsAtom',
+  type: 'atom',
+  factory: createActivityTxsAtom,
+  dependencies: ['txLogsAtom', 'accountStatesAtom', 'assetsModule'],
+}
+
+export default activityTxsAtomDefinition

package/atoms/index.js

@@ -0,0 +1 @@
+export { default as activityTxsAtomDefinition } from './activity-txs'

package/index.js

@@ -0,0 +1,14 @@
+import { activityTxsAtomDefinition } from './atoms'
+import activityTxsPluginDefinition from './plugin'
+
+const activityTxs = () => ({
+  id: 'activityTxs',
+  definitions: [
+    {
+      definition: activityTxsAtomDefinition,
+    },
+    { definition: activityTxsPluginDefinition },
+  ],
+})
+
+export default activityTxs

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@exodus/activity-txs",
+  "version": "1.0.0",
+  "description": "The activity-txs feature",
+  "author": "Exodus Movement Inc.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
+  },
+  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/features/activity-txs",
+  "license": "UNLICENSED",
+  "bugs": {
+    "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Aactivity-txs"
+  },
+  "main": "index.js",
+  "files": [
+    "module",
+    "atoms",
+    "api",
+    "plugin",
+    "redux",
+    "README.md",
+    "CHANGELOG.md",
+    "!**/__tests__/**",
+    "!**/*.test.js"
+  ],
+  "scripts": {
+    "lint": "eslint . --ignore-path ../../.gitignore",
+    "lint:fix": "yarn lint --fix",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@exodus/atoms": "^5.7.1",
+    "@exodus/basic-utils": "^2.1.0",
+    "@exodus/core-selectors": "^1.5.0",
+    "@exodus/module": "^1.2.0",
+    "@exodus/multi-account-redux": "^2.0.0",
+    "lodash": "^4.17.21",
+    "reselect": "^3.0.1"
+  },
+  "devDependencies": {
+    "@exodus/assets": "^8.0.95",
+    "@exodus/assets-base": "^8.1.10",
+    "@exodus/assets-feature": "^3.1.1",
+    "@exodus/blockchain-metadata": "^14.0.0",
+    "@exodus/dependency-injection": "^2.0.1",
+    "@exodus/dependency-preprocessors": "^3.1.1",
+    "@exodus/models": "^10.1.0",
+    "@exodus/personal-notes": "^3.6.0",
+    "@exodus/redux-dependency-injection": "^3.0.0",
+    "@exodus/storage-memory": "^2.1.1",
+    "@exodus/wallet-accounts": "^14.1.0",
+    "eslint": "^8.44.0",
+    "jest": "^29.1.2",
+    "redux": "^4.2.1"
+  },
+  "gitHead": "12b0a2c583d69e2262471f70e6ac64ed7d7f5553"
+}

package/plugin/index.js

@@ -0,0 +1,23 @@
+import createAtomObserver from '@exodus/atoms/src/factories/observer'
+
+const createActivityTxsPlugin = ({ activityTxsAtom, port }) => {
+  const observer = createAtomObserver({ atom: activityTxsAtom, port, event: 'activityTxs' })
+  const onLoad = () => {
+    observer.start()
+  }
+
+  const onStop = () => {
+    observer.unregister()
+  }
+
+  return { onLoad, onStop }
+}
+
+const activityTxsPluginDefinition = {
+  id: 'activityTxsPlugin',
+  type: 'plugin',
+  factory: createActivityTxsPlugin,
+  dependencies: ['activityTxsAtom', 'port'],
+}
+
+export default activityTxsPluginDefinition

package/redux/id.js

@@ -0,0 +1 @@
+export default 'activityTxs'

package/redux/index.js

@@ -0,0 +1,19 @@
+import id from './id'
+import initialState from './initial-state'
+import selectorDefinitions from './selectors'
+import helper from './multi-account-helper'
+import { setAccounts } from '@exodus/multi-account-redux/src/common'
+
+const activityTxsReduxDefinition = {
+  id,
+  type: 'redux-module',
+  initialState,
+  eventReducers: {
+    activityTxs: (state, data) => {
+      return setAccounts(state, data)
+    },
+  },
+  selectorDefinitions: [...helper.selectorDefinitions, ...selectorDefinitions],
+}
+
+export default activityTxsReduxDefinition

package/redux/initial-state.js

@@ -0,0 +1,5 @@
+import helper from './multi-account-helper'
+
+const initialState = helper.createInitialState()
+
+export default initialState

package/redux/multi-account-helper.js

@@ -0,0 +1,9 @@
+import { createReduxModuleHelper } from '@exodus/multi-account-redux'
+import id from './id'
+
+const helper = createReduxModuleHelper({
+  slice: id,
+  createInitialPerAssetData: () => [],
+})
+
+export default helper

package/redux/selectors/create-batched-asset-source.js

@@ -0,0 +1,74 @@
+import { memoize, get, groupBy, merge } from 'lodash'
+import { createSelector } from 'reselect'
+import { Tx } from '@exodus/models'
+
+const collapseBatch = ({ batch, assets }) => {
+  const asset = assets[batch[0].coinName]
+  const isToken = asset.baseAsset.name !== asset.name
+
+  const totalBatchValue = batch.reduce(
+    (sum, otherTx) => sum.add(otherTx.coinAmount),
+    asset.currency.ZERO
+  )
+  const totalBatchFee = batch.reduce(
+    (sum, otherTx) => (otherTx.feeAmount ? sum.add(otherTx.feeAmount) : sum),
+    (isToken ? asset.baseAsset : asset).currency.ZERO
+  )
+  const baseData = batch[0].data || {}
+  const batchedIds = batch.map((tx) => tx.txId)
+
+  const txJSON = batch[0].toJSON()
+
+  return Tx.fromJSON(
+    merge({}, txJSON, {
+      coinAmount: totalBatchValue,
+      feeAmount: totalBatchFee,
+      ...(batchedIds.length > 1 && {
+        data: {
+          ...baseData,
+          batchedIds,
+        },
+      }),
+    }),
+    { assets }
+  )
+}
+
+const groupAndCollapseBatched = ({ txs, personalNotesWithBatchId, assets }) => {
+  const { NO_BATCH: unbatchedTransactions = [], ...batches } = groupBy(txs, (tx) =>
+    get(personalNotesWithBatchId.get(tx.txId), 'dapp.batch.id', 'NO_BATCH')
+  )
+  const batchedTransactions = Object.values(batches).map((batch) =>
+    collapseBatch({ batch, assets })
+  )
+
+  return [...unbatchedTransactions, ...batchedTransactions]
+}
+
+const createBatchedAssetSourceSelectorDefinition = {
+  id: 'createBatchedAssetSourceSelector',
+  dependencies: [
+    { selector: 'createLimitedAssetSourceSelector' },
+    { module: 'personalNotes', selector: 'withBatchId' },
+    { module: 'assets', selector: 'all' },
+  ],
+  selectorFactory: (
+    createLimitedAssetSourceSelector,
+    personalNotesWithBatchIdSelector,
+    assetsSelector
+  ) =>
+    memoize(({ assetName, walletAccount, limit }) =>
+      createSelector(
+        createLimitedAssetSourceSelector({ assetName, walletAccount }),
+        personalNotesWithBatchIdSelector,
+        assetsSelector,
+        (txs, personalNotesWithBatchId, assets) => {
+          return personalNotesWithBatchId.size > 0
+            ? groupAndCollapseBatched({ txs, personalNotesWithBatchId, assets })
+            : txs
+        }
+      )
+    ),
+}
+
+export default createBatchedAssetSourceSelectorDefinition

package/redux/selectors/create-limited-asset-source.js

@@ -0,0 +1,15 @@
+import { memoize } from 'lodash'
+import { createSelector } from 'reselect'
+
+const createLimitedAssetSourceSelectorDefinition = {
+  id: 'createLimitedAssetSourceSelector',
+  dependencies: [{ selector: 'createAssetSourceSelector' }],
+  selectorFactory: (createAssetSourceSelector) =>
+    memoize(({ assetName, walletAccount, limit }) =>
+      createSelector(createAssetSourceSelector({ assetName, walletAccount }), (txs) =>
+        limit ? txs.slice(-limit) : txs
+      )
+    ),
+}
+
+export default createLimitedAssetSourceSelectorDefinition

package/redux/selectors/index.js

@@ -0,0 +1,4 @@
+import createLimitedAssetSourceSelectorDefinition from './create-limited-asset-source'
+import createBatchedAssetSourceSelector from './create-batched-asset-source'
+
+export default [createLimitedAssetSourceSelectorDefinition, createBatchedAssetSourceSelector]