@exodus/activity-txs 4.0.1 → 4.1.0

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.1.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@4.0.1...@exodus/activity-txs@4.1.0) (2024-05-13)
+
+### Features
+
+- activity base selector ([#6712](https://github.com/ExodusMovement/exodus-hydra/issues/6712)) ([929a87c](https://github.com/ExodusMovement/exodus-hydra/commit/929a87ce359195aafb177248eed3f0c4fe544452))
+- add withFiat selector ([#6766](https://github.com/ExodusMovement/exodus-hydra/issues/6766)) ([10c9aaf](https://github.com/ExodusMovement/exodus-hydra/commit/10c9aaf8e28c2ad13885e4f1c5d8ff6f345d6508))
+- connections activity selector ([#6855](https://github.com/ExodusMovement/exodus-hydra/issues/6855)) ([37bc022](https://github.com/ExodusMovement/exodus-hydra/commit/37bc0221be3a6c536b0fbf5f6ee22b06e084667d))
+- full activity selector ([#6861](https://github.com/ExodusMovement/exodus-hydra/issues/6861)) ([7d0d168](https://github.com/ExodusMovement/exodus-hydra/commit/7d0d1689c37e14169a24fd73670183c282f0ad41))
+- multi activity ([#6870](https://github.com/ExodusMovement/exodus-hydra/issues/6870)) ([7d72596](https://github.com/ExodusMovement/exodus-hydra/commit/7d72596b9718511f5e3ca43f4b36a5890a7b6b76))
+- withNfts selectors ([#6765](https://github.com/ExodusMovement/exodus-hydra/issues/6765)) ([1f6d3d6](https://github.com/ExodusMovement/exodus-hydra/commit/1f6d3d668c32b184ca26cdbbb47c418c007ea7a1))
+
+### Bug Fixes
+
+- missing dependencies ([#5322](https://github.com/ExodusMovement/exodus-hydra/issues/5322)) ([01efedc](https://github.com/ExodusMovement/exodus-hydra/commit/01efedc7508fb14925277fdcd388afb721ac3dd1))
+
 ## [4.0.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@4.0.0...@exodus/activity-txs@4.0.1) (2023-12-20)
 
 ### Bug Fixes

package/README.md

@@ -1,5 +1,18 @@
 # @exodus/activity-txs
 
+Activity consists of a set of asset transactions that are transformed using `asset.api.getActivityTxs`
+which returns Array of Tx [models](https://github.com/ExodusMovement/exodus-core/blob/cdff25bb962b2301613588c615c5ac09b05f260a/packages/models/src/tx/index.js#L10): `[Tx, Tx, Tx]`
+Most of the assets don't have this api and simply return original txs.
+An example of this transformation is combining bitcoin batched transactions into a single activity item, instead of multiple Txs you get single Tx with adjusted `coinAmount`.
+These are utilized in the UI to display transaction history.
+
+This feature introduces atoms with activity items generated from txLog and accountState.
+It provides an efficient way to store them by wallet accounts and to update this extensive object while avoiding unnecessary re-computations.
+Additionally, it offers extra redux selectors to retrieve activity limited by size or batched activity items.
+
 ## Usage
 
-ioc.use(activityTxs())
+`ioc.use(activityTxs())`
+
+selector example to get batched activity for specific asset from specific account:
+`selectors.activityTxs.createBatchedAssetSourceSelector({ assetName, walletAccount })` return array of txs `[Tx, Tx, ...]`

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@exodus/activity-txs",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "The activity-txs feature",
-  "author": "Exodus Movement Inc.",
+  "author": "Exodus Movement, Inc.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
@@ -25,35 +25,40 @@
     "!**/*.test.js"
   ],
   "scripts": {
-    "lint": "eslint . --ignore-path ../../.gitignore",
+    "lint": "run -T eslint . --ignore-path ../../.gitignore",
     "lint:fix": "yarn lint --fix",
-    "test": "jest"
+    "test": "run -T jest"
   },
   "dependencies": {
-    "@exodus/atoms": "^7.0.0",
-    "@exodus/basic-utils": "^2.1.0",
+    "@exodus/atoms": "^7.0.5",
+    "@exodus/basic-utils": "^2.3.0",
     "@exodus/core-selectors": "^1.5.0",
+    "@exodus/models": "^10.1.0",
     "@exodus/module": "^1.2.2",
     "@exodus/multi-account-redux": "^2.0.1",
     "lodash": "^4.17.21",
+    "minimalistic-assert": "^1.0.1",
     "reselect": "^3.0.1"
   },
   "devDependencies": {
     "@exodus/assets": "^8.0.95",
     "@exodus/assets-base": "^8.1.10",
-    "@exodus/assets-feature": "^4.0.1",
+    "@exodus/assets-feature": "^5.3.1",
+    "@exodus/available-assets": "^8.2.0",
     "@exodus/bitcoin-plugin": "^1.4.2",
-    "@exodus/blockchain-metadata": "^15.0.0",
-    "@exodus/dependency-injection": "^2.1.0",
-    "@exodus/dependency-preprocessors": "^4.1.0",
-    "@exodus/models": "^10.1.0",
+    "@exodus/blockchain-metadata": "^15.3.0",
+    "@exodus/connected-origins": "^3.3.1",
+    "@exodus/dependency-injection": "^2.2.0",
+    "@exodus/dependency-preprocessors": "^5.2.0",
+    "@exodus/fiat-ramp": "^10.5.0",
+    "@exodus/nfts": "^9.2.1",
+    "@exodus/orders": "^4.8.1",
     "@exodus/personal-notes": "^3.6.0",
-    "@exodus/redux-dependency-injection": "^3.0.0",
+    "@exodus/redux-dependency-injection": "^3.1.0",
     "@exodus/storage-memory": "^2.1.1",
-    "@exodus/wallet-accounts": "^15.0.0",
-    "eslint": "^8.44.0",
-    "jest": "^29.1.2",
+    "@exodus/wallet-accounts": "^16.4.0",
+    "@types/minimalistic-assert": "^1.0.1",
     "redux": "^4.2.1"
   },
-  "gitHead": "f9da7e1a0be705cb2faace4af6ea2b4a69b4fd0f"
+  "gitHead": "345159fcb1012fc873ba5ecc24880d5c54700d0b"
 }

package/redux/constants/tx-types.js

@@ -0,0 +1,9 @@
+export const TX_TYPES = {
+  EXCHANGE: 'exchange',
+  FIAT: 'fiat',
+  RECEIVED: 'rx',
+  SENT: 'tx',
+  APPROVAL: 'approval',
+  CLEANUP: 'cleanup',
+  NFT: 'nft',
+}

package/redux/selectors/create-asset-source-base-activity.js

@@ -0,0 +1,126 @@
+import { createSelector } from 'reselect'
+import { memoize } from '@exodus/basic-utils'
+import { TX_TYPES } from '../constants/tx-types'
+import { formatGroupedExchangeTxs, formattersByType } from '../utils/formatters'
+
+const EMPTY = Object.freeze([])
+
+const generateActivityId = ({ activityItem }) => {
+  const sentIndex = activityItem.data?.sentIndex
+  return sentIndex
+    ? `${activityItem.assetName}.${activityItem.txId}_${sentIndex}`
+    : `${activityItem.assetName}.${activityItem.txId}`
+}
+
+const groupTxsWithSameOrder = ({ txs, orderSet }) => {
+  const getOrder = (tx) => orderSet.getByTxId(tx.txId)
+  const exchangeByOrderId = {}
+  const result = []
+  for (const tx of txs) {
+    const order = getOrder(tx)
+    if (order) {
+      ;(exchangeByOrderId[order.orderId] ?? (exchangeByOrderId[order.orderId] = [])).push(tx)
+    } else {
+      result.push({ tx, type: 'tx' })
+    }
+  }
+
+  Object.values(exchangeByOrderId).forEach((txsGroup) => {
+    const tx = txsGroup.sort((a, b) => b.date.getTime() - a.date.getTime())[0]
+    const order = getOrder(tx)
+    result.push({ tx, type: 'exchange', order })
+  })
+  return result
+}
+
+const createAssetSourceBaseActivitySelectorDefinition = {
+  id: 'createAssetSourceBaseActivity',
+  selectorFactory: (
+    assetsSelector,
+    createBatchedAssetSourceSelector,
+    createOrdersInAccountSelector,
+    getPersonalNoteByTxIdSelector
+  ) =>
+    memoize(
+      ({ assetName, walletAccount }) =>
+        createSelector(
+          assetsSelector,
+          createBatchedAssetSourceSelector({ assetName, walletAccount }),
+          createOrdersInAccountSelector(walletAccount),
+          getPersonalNoteByTxIdSelector,
+          (assets, txs = EMPTY, orderSet, getPersonalNoteByTxId) => {
+            const activityResult = []
+
+            const groupedTxs = groupTxsWithSameOrder({ txs, orderSet })
+
+            for (const group of groupedTxs) {
+              const { tx, order, type: formatterType } = group
+              const personalNote = getPersonalNoteByTxId(tx.txId)
+              const formattedTx = formattersByType[formatterType]({
+                assets,
+                order,
+                tx,
+                personalNote,
+              })
+              formattedTx.id = generateActivityId({ activityItem: formattedTx })
+
+              activityResult.push(formattedTx)
+            }
+
+            const isIndexless = assets[assetName]?.baseAsset?.api?.features?.noHistory
+            if (isIndexless) {
+              const orderIdsFromActivity = new Set(activityResult.map((tx) => tx.orderId))
+              const ordersForIndexlessAssets = [...orderSet].filter(
+                (order) =>
+                  [order.fromAsset, order.toAsset].includes(assetName) &&
+                  order.exodusStatus !== 'syncing'
+              )
+
+              ordersForIndexlessAssets.forEach((order) => {
+                // Prevent dups by checking if this order already exists.
+                if (orderIdsFromActivity.has(order.orderId)) return
+
+                const isFromIndexlessAsset = order.fromAsset === assetName
+                const formattedItem = formatGroupedExchangeTxs({
+                  tx: {
+                    type: TX_TYPES.EXCHANGE,
+                    date: order.date,
+                    order,
+                    pending: !['failed-final', 'complete-verified'].includes(order.status),
+                    failed: order.status === 'failed-final',
+                    data: { swapTx: true },
+                    selfSend: false,
+                    token: null, // TBD
+                    bumpType: {},
+                    coinName: isFromIndexlessAsset ? order.fromAsset : order.toAsset,
+                    value: isFromIndexlessAsset ? order.fromAmount : order.toAmount,
+                    coinAmount: isFromIndexlessAsset ? order.fromAmount : order.toAmount,
+                    txId: isFromIndexlessAsset ? order.fromTxId : order.toTxId,
+                    sent: isFromIndexlessAsset,
+                    received: !isFromIndexlessAsset,
+                  },
+                  assets,
+                  order,
+                })
+
+                formattedItem.id = generateActivityId({ activityItem: formattedItem })
+                activityResult.push(formattedItem)
+              })
+            }
+
+            if (activityResult.length === 0) return EMPTY
+
+            return activityResult.sort((a, b) => b.date.getTime() - a.date.getTime())
+          }
+        ),
+      ({ assetName, walletAccount }) => `${assetName}_${walletAccount}`
+    ),
+  dependencies: [
+    { module: 'assets', selector: 'all' },
+    { selector: 'createBatchedAssetSourceSelector' },
+    { module: 'orders', selector: 'createOrdersInAccount' },
+    { module: 'personalNotes', selector: 'get' },
+  ],
+}
+
+export default createAssetSourceBaseActivitySelectorDefinition

package/redux/selectors/create-full-activity.js

@@ -0,0 +1,34 @@
+const selectorFactory =
+  (
+    createAssetSourceBaseActivity,
+    createWithFiatActivity,
+    createWithNftsActivity,
+    createWithConnectionsActivity
+  ) =>
+  // call this once on client-side
+  (options = {}) => {
+    let createFullSelector = createAssetSourceBaseActivity
+    createFullSelector = createWithNftsActivity({
+      createActivitySelector: createFullSelector,
+      nftsNetworkNameToAssetName: options.nftsNetworkNameToAssetName || {},
+    })
+    createFullSelector = createWithFiatActivity({ createActivitySelector: createFullSelector })
+    createFullSelector = createWithConnectionsActivity({
+      createActivitySelector: createFullSelector,
+    })
+
+    return createFullSelector
+  }
+
+const createFullActivitySelectorDefinition = {
+  id: 'createFullActivity',
+  selectorFactory,
+  dependencies: [
+    { selector: 'createAssetSourceBaseActivity' },
+    { selector: 'createWithFiatActivity' },
+    { selector: 'createWithNftsActivity' },
+    { selector: 'createWithConnectionsActivity' },
+  ],
+}
+
+export default createFullActivitySelectorDefinition

package/redux/selectors/create-multi-activity.js

@@ -0,0 +1,56 @@
+import { memoize } from '@exodus/basic-utils'
+import { createSelector } from 'reselect'
+import assert from 'minimalistic-assert'
+
+const selectorFactory =
+  () =>
+  ({ createAssetSourceActivitySelector, dedupExchange = true }) => {
+    assert(
+      createAssetSourceActivitySelector,
+      'please provide createAssetSourceActivitySelector selector factory'
+    )
+
+    return memoize(
+      ({ assetNames, walletAccounts, ...rest }) => {
+        const selectors = []
+        for (const assetName of assetNames) {
+          for (const walletAccount of walletAccounts) {
+            selectors.push(
+              createAssetSourceActivitySelector({
+                assetName,
+                walletAccount,
+                ...rest,
+              })
+            )
+          }
+        }
+
+        return createSelector(...selectors, (...activities) => {
+          const ordersIncluded = new Set()
+          let result = activities.flat()
+          if (dedupExchange) {
+            result = result.filter((activityItem) => {
+              if (activityItem.orderId && !ordersIncluded.has(activityItem.orderId)) {
+                ordersIncluded.add(activityItem.orderId)
+                return true
+              }
+
+              return !ordersIncluded.has(activityItem.orderId)
+            })
+          }
+
+          return result.sort((a, b) => (b.date === a.date ? 0 : b.date > a.date ? 1 : -1))
+        })
+      },
+      ({ assetNames, walletAccounts, ...rest }) =>
+        `${assetNames.join(',')}_${walletAccounts.join(',')}_${JSON.stringify(rest)}`
+    )
+  }
+
+const createMultiActivitySelectorDefinition = {
+  id: 'createMultiActivity',
+  selectorFactory,
+  dependencies: [],
+}
+
+export default createMultiActivitySelectorDefinition

package/redux/selectors/create-with-connections-activity.js

@@ -0,0 +1,54 @@
+import { memoize } from '@exodus/basic-utils'
+import { createSelector } from 'reselect'
+import assert from 'minimalistic-assert'
+
+const selectorFactory =
+  (getConnectedOriginsSelector) =>
+  ({ createActivitySelector }) => {
+    assert(createActivitySelector, 'please provide activitySelector')
+
+    return memoize(
+      ({ assetName, walletAccount, ...rest }) => {
+        const activitySelector = createActivitySelector({ assetName, walletAccount, ...rest })
+        assert(activitySelector, 'createActivitySelector must return selector')
+        if (getConnectedOriginsSelector.isFallback) return activitySelector
+        return createSelector(
+          getConnectedOriginsSelector,
+          activitySelector,
+          (getConnectedOrigins, activity) => {
+            if (!getConnectedOrigins) return activity
+            let hasChanges = false
+
+            const resultActivity = []
+            for (const activityItem of activity) {
+              const personalNote = activityItem.personalNote
+              const origin = personalNote?.providerData?.origin
+              const connection = origin ? getConnectedOrigins(origin) : null
+              if (connection) {
+                hasChanges = true
+                resultActivity.push({
+                  ...activityItem,
+                  connection,
+                })
+              } else {
+                resultActivity.push(activityItem)
+              }
+            }
+
+            if (!hasChanges) return activity
+
+            return resultActivity
+          }
+        )
+      },
+      (deps) => JSON.stringify(deps)
+    )
+  }
+
+const createWithConnectionsActivitySelectorDefinition = {
+  id: 'createWithConnectionsActivity',
+  selectorFactory,
+  dependencies: [{ module: 'connectedOrigins', selector: 'get', optional: true }],
+}
+
+export default createWithConnectionsActivitySelectorDefinition

package/redux/selectors/create-with-fiat-activity.js

@@ -0,0 +1,62 @@
+import { memoize } from '@exodus/basic-utils'
+import { createSelector } from 'reselect'
+import assert from 'minimalistic-assert'
+import { TX_TYPES } from '../constants/tx-types'
+
+const selectorFactory =
+  (visibleOrdersSelector, assetsSelector) =>
+  ({ createActivitySelector }) => {
+    assert(createActivitySelector, 'please provide activitySelector')
+
+    return memoize(
+      ({ assetName, walletAccount, ...rest }) => {
+        const activitySelector = createActivitySelector({ assetName, walletAccount, ...rest })
+        assert(activitySelector, 'createActivitySelector must return selector')
+        if (visibleOrdersSelector.isFallback) return activitySelector
+        return createSelector(
+          visibleOrdersSelector,
+          assetsSelector,
+          activitySelector,
+          (fiatOrders, assets, activity) => {
+            if (!fiatOrders) {
+              return activity
+            }
+
+            let hasChanges = false
+
+            const resultActivity = []
+            for (const activityItem of activity) {
+              const fiatOrder = fiatOrders.getByTxId(activityItem.txId)
+
+              if (fiatOrder) {
+                hasChanges = true
+                resultActivity.push({
+                  ...activityItem,
+                  fiatOrder,
+                  type: TX_TYPES.FIAT,
+                })
+              } else {
+                resultActivity.push(activityItem)
+              }
+            }
+
+            if (!hasChanges) return activity
+
+            return resultActivity
+          }
+        )
+      },
+      (deps) => JSON.stringify(deps)
+    )
+  }
+
+const createWithFiatActivitySelectorDefinition = {
+  id: 'createWithFiatActivity',
+  selectorFactory,
+  dependencies: [
+    { module: 'fiatRamp', selector: 'visibleOrders', optional: true },
+    { module: 'assets', selector: 'all' },
+  ],
+}
+
+export default createWithFiatActivitySelectorDefinition

package/redux/selectors/create-with-nfts-activity.js

@@ -0,0 +1,81 @@
+import { memoize } from '@exodus/basic-utils'
+import { createSelector } from 'reselect'
+import { formatUnindexedNftTx } from '../utils/formatters'
+import assert from 'minimalistic-assert'
+import { TX_TYPES } from '../constants/tx-types'
+
+const selectorFactory =
+  (createAssetSourceNftTxsById, assetsSelector) =>
+  ({ createActivitySelector, nftsNetworkNameToAssetName }) => {
+    assert(createActivitySelector, 'please provide activitySelector')
+    assert(nftsNetworkNameToAssetName, 'please provide nftsNetworkNameToAssetName')
+
+    return memoize(
+      ({ assetName, walletAccount, ...rest }) => {
+        const activitySelector = createActivitySelector({ assetName, walletAccount, ...rest })
+        if (createAssetSourceNftTxsById.isFallback) {
+          return activitySelector
+        }
+
+        const nftsSelector = createAssetSourceNftTxsById({ assetName, walletAccount })
+        assert(nftsSelector, 'nfts redux feature must be installed to use this selector')
+        return createSelector(
+          nftsSelector,
+          assetsSelector,
+          activitySelector,
+          (nftsByTxId, assets, activity) => {
+            const indexedNftTxIds = new Set()
+            const resultActivity = []
+            let hasChanges = false
+            for (const activityItem of activity) {
+              const nft = nftsByTxId.get(activityItem.txId)
+
+              if (nft) {
+                hasChanges = true
+                indexedNftTxIds.add(nft.txId)
+                resultActivity.push({
+                  ...activityItem,
+                  nft,
+                  type: TX_TYPES.NFT,
+                  sent: nft.sent === undefined ? activityItem.sent : nft.sent, // rely on nft metadata for nft txs
+                })
+              } else {
+                resultActivity.push(activityItem)
+              }
+            }
+
+            ;[...nftsByTxId.values()]
+              .filter(
+                (nftTx) =>
+                  assetName === nftsNetworkNameToAssetName[nftTx.network] &&
+                  !indexedNftTxIds.has(nftTx.txId)
+              )
+              .forEach((nftTx) => {
+                hasChanges = true
+                const assetName = nftsNetworkNameToAssetName[nftTx.network]
+                const asset = assets[assetName]
+                const formatted = formatUnindexedNftTx({ nftTx, asset })
+
+                resultActivity.push(formatted)
+              })
+
+            if (!hasChanges) return activity
+
+            return resultActivity
+          }
+        )
+      },
+      ({ assetName, walletAccount, ...rest }) => `${assetName}_${walletAccount}_${rest}`
+    )
+  }
+
+const createWithNftsActivitySelectorDefinition = {
+  id: 'createWithNftsActivity',
+  selectorFactory,
+  dependencies: [
+    { module: 'nfts', selector: 'createAssetSourceNftTxsById', optional: true },
+    { module: 'assets', selector: 'all' },
+  ],
+}
+
+export default createWithNftsActivitySelectorDefinition

package/redux/selectors/index.js

@@ -1,9 +1,21 @@
 import createLimitedAssetSourceSelectorDefinition from './create-limited-asset-source'
 import createBatchedAssetSourceSelector from './create-batched-asset-source'
 import createBatchedAssetSourceActivityByIdSelector from './create-batched-asset-source-by-id'
+import createAssetSourceBaseActivitySelectorDefinition from './create-asset-source-base-activity'
+import createWithNftsActivitySelectorDefinition from './create-with-nfts-activity'
+import createWithFiatActivitySelectorDefinition from './create-with-fiat-activity'
+import createWithConnectionsActivitySelectorDefinition from './create-with-connections-activity'
+import createFullActivitySelectorDefinition from './create-full-activity'
+import createMultiActivitySelectorDefinition from './create-multi-activity'
 
 export default [
   createLimitedAssetSourceSelectorDefinition,
   createBatchedAssetSourceSelector,
   createBatchedAssetSourceActivityByIdSelector,
+  createAssetSourceBaseActivitySelectorDefinition,
+  createWithNftsActivitySelectorDefinition,
+  createWithFiatActivitySelectorDefinition,
+  createWithConnectionsActivitySelectorDefinition,
+  createFullActivitySelectorDefinition,
+  createMultiActivitySelectorDefinition,
 ]

package/redux/utils/formatters.js

@@ -0,0 +1,107 @@
+import { TX_TYPES } from '../constants/tx-types'
+
+const FINAL_ORDER_STATUS = {
+  inProgress: 'in-progress',
+  failed: 'failed',
+  success: 'complete',
+}
+
+const EXODEX_TX_TYPES = {
+  PRE_SETUP: 'preSetupTransaction',
+  SETUP: 'setupTransaction',
+  SWAP: 'swapTransaction',
+  CLEANUP: 'cleanupTransaction',
+}
+
+const UI_TX_TYPE_FROM_EXODEX = {
+  [EXODEX_TX_TYPES.PRE_SETUP]: TX_TYPES.APPROVAL,
+  [EXODEX_TX_TYPES.SETUP]: TX_TYPES.APPROVAL,
+  [EXODEX_TX_TYPES.SWAP]: TX_TYPES.EXCHANGE,
+  [EXODEX_TX_TYPES.CLEANUP]: TX_TYPES.CLEANUP,
+}
+
+function getTxType({ tx, order }) {
+  if (order) {
+    const txInfoFromOrder = order.txIds?.find((txFromOrder) => txFromOrder.txId === tx.txId)
+    return UI_TX_TYPE_FROM_EXODEX[txInfoFromOrder?.txType] || TX_TYPES.EXCHANGE
+  }
+
+  return tx.sent ? TX_TYPES.SENT : TX_TYPES.RECEIVED
+}
+
+const getMinConfirmations = (asset) => asset.baseAsset.minConfirmations || 1
+
+export function isPending(tx, asset) {
+  return (
+    tx.confirmations < getMinConfirmations(asset) &&
+    !tx.dropped && // dropped txs are not pending anymore
+    !tx.error // errored txs are not pending anymore
+  )
+}
+
+const formatBase = ({ tx, asset, order, personalNote }) => ({
+  ...tx,
+  assetName: asset.name,
+  displayTicker: asset.displayTicker,
+  type: getTxType({ tx, asset, order }),
+  time: tx.date,
+  amount: tx.coinAmount.abs().toDefaultNumber(),
+  pending: isPending(tx, asset),
+  isOrderInProgress: !!order && order.exodusStatus === FINAL_ORDER_STATUS.inProgress,
+  confirmations: tx.confirmations,
+  failed: tx.failed,
+  received: tx.received,
+  personalNote,
+})
+
+export const formatGroupedExchangeTxs = ({ tx, assets, order, personalNote }) => {
+  const toAsset = assets[order.toAsset]
+
+  return {
+    ...formatBase({ tx, asset: toAsset, order, personalNote }),
+    failed: tx.failed || order.error,
+    pending: order.exodusStatus === FINAL_ORDER_STATUS.inProgress,
+    assetName: toAsset.name,
+    txId: tx.txId,
+    type: TX_TYPES.EXCHANGE,
+    time: tx.date,
+    fromAsset: order.fromAsset,
+    toAsset: order.toAsset,
+    amount: order.toAmount,
+    orderId: order.orderId,
+    data: {
+      swapTx: true,
+    },
+  }
+}
+
+const formatGroupedTx = ({ tx, assets, personalNote }) =>
+  formatBase({
+    tx,
+    asset: assets[tx.coinName],
+    personalNote,
+  })
+
+export const formattersByType = {
+  exchange: formatGroupedExchangeTxs,
+  tx: formatGroupedTx,
+}
+
+export const formatUnindexedNftTx = ({ asset, nftTx }) => {
+  return {
+    id: `${asset.name}.${nftTx.txId}`,
+    coinName: asset.name,
+    assetName: asset.name,
+    displayTicker: asset.displayTicker,
+    type: TX_TYPES.NFT,
+    time: new Date(nftTx.date),
+    from: nftTx.from,
+    to: nftTx.to,
+    sent: Boolean(nftTx.sent),
+    received: !nftTx.sent,
+    date: new Date(nftTx.date),
+    nft: nftTx,
+    txId: nftTx.txId,
+    selfSend: false,
+  }
+}