@exodus/activity-txs 5.1.0 → 6.1.0

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [6.1.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@6.0.0...@exodus/activity-txs@6.1.0) (2026-02-05)
+
+### Features
+
+- feat: improve activity calculation (#15119)
+
+## [6.0.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@5.0.2...@exodus/activity-txs@6.0.0) (2026-01-26)
+
+### ⚠ BREAKING CHANGES
+
+- **orders:** use typescript (#14786)
+
+### Features
+
+- feat: update all consumers to use safe strings for error namespaces (#14429)
+
+### Bug Fixes
+
+- fix(activity-txs): fiat order duplicates wallet order (#14959)
+
+- fix: update NFT transaction sent status calculation (#14359)
+
+- refactor(orders)!: use typescript (#14786)
+
 ## [5.1.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@5.0.2...@exodus/activity-txs@5.1.0) (2025-11-19)
 
 ### Features

package/README.md

@@ -4,7 +4,7 @@ This feature generates user-friendly activity from transactions, orders, fiat or
 
 ## How it works
 
-Each asset’s activity consists of a set of transactions transformed using `asset.api.getActivityTxs`, which returns an array of Tx [models](https://github.com/ExodusMovement/exodus-core/blob/cdff25bb962b2301613588c615c5ac09b05f260a/packages/models/src/tx/index.js#L10): `[Tx, Tx, Tx]`.
+Each asset’s activity consists of a set of transactions transformed using `asset.api.getActivityTxs`, which returns an array of Tx [models](https://github.com/ExodusOSS/hydra/blob/7743f4ffcbdb0605deb4943a90ef2e718776c3bf/libraries/models/src/tx/index.ts#L60): `[Tx, Tx, Tx]`.
 
 **Most assets don't have this API and simply return the original transactions.**
 

package/atoms/activity-txs.js

@@ -43,48 +43,6 @@ const createAssetSourceTxsSelector = memoize(
   ({ 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 (!Object.prototype.hasOwnProperty.call(obj2, 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 (
-        !Object.prototype.hasOwnProperty.call(obj2Assets, assetName) ||
-        obj1Assets[assetName] !== obj2Assets[assetName]
-      ) {
-        return false
-      }
-    }
-  }
-
-  return true
-}
-
 const createActivityTxsAtom = ({
   txLogsAtom,
   accountStatesAtom,
@@ -98,85 +56,225 @@ const createActivityTxsAtom = ({
   })
 
   let prevResult = Object.create(null)
+  const perAssetCache = new Map()
+  let cacheEntriesCount = 0
+  let runIdCounter = 0
+
+  const getWalletCache = (walletAccount) => {
+    let walletCache = perAssetCache.get(walletAccount)
+    if (!walletCache) {
+      walletCache = new Map()
+      perAssetCache.set(walletAccount, walletCache)
+    }
 
-  const selector = async ({ txLogs, accountStates }) => {
-    const { value } = txLogs
-    const { value: accountStatesValue } = accountStates
-
-    // Process each wallet account asynchronously
-    const resultEntries = await Promise.all(
-      Object.entries(value).map(async ([walletAccount, accountTxLogs]) => {
-        // Process each asset within the wallet account asynchronously
-        const assetEntries = await Promise.all(
-          Object.entries(accountTxLogs).map(async ([assetName, assetTxSet]) => {
-            const asset = assetsModule.getAsset(assetName)
-            const baseAssetName = asset.baseAsset.name
-
-            if (asset?.api?.getActivityTxs) {
-              let activityOptions
-
-              if (asset?.api?.getActivityOptions) {
-                const baseAssetAccountState = accountStatesValue?.[walletAccount]?.[baseAssetName]
-
-                const getOptionsForAssetSource = createAssetSourceActivityOptionsSelector({
-                  assetName,
-                  walletAccount,
-                })
-
-                activityOptions = await getOptionsForAssetSource({
-                  accountState: baseAssetAccountState,
-                  asset,
-                })
-              }
-
-              const txs = createAssetSourceTxsSelector({ assetName, walletAccount })({
-                txSet: assetTxSet,
-              })
+    return walletCache
+  }
 
-              const getActivityForAssetSource = createAssetSourceActivityTxsSelector({
-                assetName,
-                walletAccount,
+  function processActivityForAsset(
+    walletAccount,
+    assetName,
+    assetTxSet,
+    accountStatesValue,
+    runId
+  ) {
+    const walletCache = getWalletCache(walletAccount)
+    const cached = walletCache.get(assetName)
+    const asset = assetsModule.getAsset(assetName)
+    const baseAssetName = asset.baseAsset.name
+    const baseAssetAccountState = accountStatesValue?.[walletAccount]?.[baseAssetName]
+
+    if (
+      cached &&
+      cached.txSet === assetTxSet &&
+      cached.baseAssetAccountState === baseAssetAccountState
+    ) {
+      cached.lastSeen = runId
+      return cached.output
+    }
+
+    const txs =
+      cached && cached.txSet === assetTxSet
+        ? cached.txs
+        : createAssetSourceTxsSelector({ assetName, walletAccount })({ txSet: assetTxSet })
+
+    if (asset?.api?.getActivityTxs) {
+      let activityOptions
+      if (asset?.api?.getActivityOptions) {
+        activityOptions =
+          cached &&
+          cached.baseAssetAccountState === baseAssetAccountState &&
+          cached.baseAssetName === baseAssetName
+            ? cached.activityOptions
+            : createAssetSourceActivityOptionsSelector({ assetName, walletAccount })({
+                accountState: baseAssetAccountState,
+                asset,
               })
+      }
 
-              try {
-                const activityTxs = await getActivityForAssetSource({
-                  asset,
-                  txs,
-                  activityOptions,
-                })
-
-                return [assetName, activityTxs]
-              } catch (e) {
-                errorTracking.track({
-                  error: e,
-                  context: { assetName },
-                })
-                logger.warn(`failed to get activity txs for asset: ${assetName}`, e)
-                return [assetName, []]
-              }
+      const getActivityForAssetSource = createAssetSourceActivityTxsSelector({
+        assetName,
+        walletAccount,
+      })
+
+      try {
+        const activityTxs = getActivityForAssetSource({
+          asset,
+          txs,
+          activityOptions,
+        })
+
+        if (!cached) cacheEntriesCount += 1
+        walletCache.set(assetName, {
+          baseAssetName,
+          baseAssetAccountState,
+          txSet: assetTxSet,
+          txs,
+          activityOptions,
+          output: activityTxs,
+          lastSeen: runId,
+        })
+
+        return activityTxs
+      } catch (e) {
+        errorTracking?.track({
+          error: e,
+          context: { assetName },
+        })
+        logger?.warn?.(`failed to get activity txs for asset: ${assetName}`, e)
+
+        if (!cached) cacheEntriesCount += 1
+        walletCache.set(assetName, {
+          baseAssetName,
+          baseAssetAccountState,
+          txSet: assetTxSet,
+          txs,
+          activityOptions,
+          output: [],
+          lastSeen: runId,
+        })
+
+        return []
+      }
+    }
+
+    if (!cached) cacheEntriesCount += 1
+    walletCache.set(assetName, {
+      baseAssetName,
+      baseAssetAccountState,
+      txSet: assetTxSet,
+      txs,
+      activityOptions: undefined,
+      output: txs,
+      lastSeen: runId,
+    })
+
+    return txs
+  }
+
+  const selector = ({ txLogs, accountStates }) => {
+    const runId = (runIdCounter += 1)
+    const txLogsValue = txLogs?.value ?? Object.create(null)
+    const accountStatesValue = accountStates?.value ?? Object.create(null)
+
+    let activeCount = 0
+
+    const nextResult = Object.create(null)
+    let reusedAllWalletObjects = true
+    let walletCount = 0
+    let prevWalletCount = 0
+
+    for (const prevWalletAccount in prevResult) {
+      if (Object.prototype.hasOwnProperty.call(prevResult, prevWalletAccount)) prevWalletCount += 1
+    }
+
+    for (const walletAccount in txLogsValue) {
+      if (!Object.prototype.hasOwnProperty.call(txLogsValue, walletAccount)) continue
+      walletCount += 1
+
+      const accountTxLogs = txLogsValue[walletAccount] ?? Object.create(null)
+      const prevWallet = prevResult[walletAccount]
+
+      let canReuseWallet = Boolean(prevWallet)
+      let assetsCount = 0
+
+      if (prevWallet) {
+        for (const assetName in accountTxLogs) {
+          if (!Object.prototype.hasOwnProperty.call(accountTxLogs, assetName)) continue
+          assetsCount += 1
+          activeCount += 1
+
+          const activityTxs = processActivityForAsset(
+            walletAccount,
+            assetName,
+            accountTxLogs[assetName],
+            accountStatesValue,
+            runId
+          )
+
+          if (prevWallet[assetName] !== activityTxs) {
+            canReuseWallet = false
+            break
+          }
+        }
+
+        if (canReuseWallet) {
+          let prevWalletAssetsCount = 0
+          for (const assetName in prevWallet) {
+            if (Object.prototype.hasOwnProperty.call(prevWallet, assetName)) {
+              prevWalletAssetsCount += 1
             }
+          }
 
-            const txs = createAssetSourceTxsSelector({ assetName, walletAccount })({
-              txSet: assetTxSet,
-            })
+          if (prevWalletAssetsCount === assetsCount) {
+            nextResult[walletAccount] = prevWallet
+            continue
+          }
 
-            return [assetName, txs]
-          })
-        )
+          canReuseWallet = false
+        }
+      }
 
-        return [walletAccount, Object.fromEntries(assetEntries)]
-      })
-    )
+      const nextWallet = Object.create(null)
+      for (const assetName in accountTxLogs) {
+        if (!Object.prototype.hasOwnProperty.call(accountTxLogs, assetName)) continue
+        activeCount += 1
+
+        const activityTxs = processActivityForAsset(
+          walletAccount,
+          assetName,
+          accountTxLogs[assetName],
+          accountStatesValue,
+          runId
+        )
+        nextWallet[assetName] = activityTxs
+      }
 
-    const result = Object.fromEntries(resultEntries)
+      nextResult[walletAccount] = nextWallet
+      reusedAllWalletObjects = false
+    }
 
-    if (areActivitiesEqual(result, prevResult)) {
+    if (reusedAllWalletObjects && walletCount === prevWalletCount) {
       return prevResult
     }
 
-    prevResult = result
+    if (activeCount > 0 && cacheEntriesCount > activeCount * 2) {
+      for (const [walletAccount, walletCache] of perAssetCache) {
+        for (const [assetName, cached] of walletCache) {
+          if (cached.lastSeen !== runId) {
+            walletCache.delete(assetName)
+            cacheEntriesCount -= 1
+          }
+        }
+
+        if (walletCache.size === 0) {
+          perAssetCache.delete(walletAccount)
+        }
+      }
+    }
+
+    prevResult = nextResult
 
-    return result
+    return nextResult
   }
 
   return compute({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/activity-txs",
-  "version": "5.1.0",
+  "version": "6.1.0",
   "description": "The activity-txs feature",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -46,15 +46,15 @@
   "devDependencies": {
     "@exodus/assets": "^11.0.0",
     "@exodus/assets-base": "^10.0.0",
-    "@exodus/assets-feature": "^8.7.1",
-    "@exodus/available-assets": "^8.8.0",
+    "@exodus/assets-feature": "^8.8.0",
+    "@exodus/available-assets": "^8.10.1",
     "@exodus/bitcoin-plugin": "^1.4.2",
     "@exodus/connected-origins": "^4.3.0",
     "@exodus/error-tracking": "^3.3.0",
-    "@exodus/fiat-ramp": "^15.6.0",
+    "@exodus/fiat-ramp": "^15.12.0",
     "@exodus/logger": "^1.2.3",
-    "@exodus/nfts": "^9.6.1",
-    "@exodus/orders": "^5.5.2",
+    "@exodus/nfts": "^9.6.2",
+    "@exodus/orders": "^6.0.1",
     "@exodus/personal-notes": "^3.9.0",
     "@exodus/redux-dependency-injection": "^4.1.2",
     "@exodus/wallet-accounts": "^20.2.1",
@@ -65,5 +65,5 @@
     "access": "public",
     "provenance": false
   },
-  "gitHead": "c024e571066175633a8803171c93ed122d6dcc01"
+  "gitHead": "44ef16c9fbb7fa3f5a503b048872145882b54dff"
 }

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

@@ -69,7 +69,7 @@ const noop = () => null
 const createAssetSourceBaseActivitySelectorDefinition = {
   id: 'createAssetSourceBaseActivity',
   selectorFactory: (
-    assetsSelector,
+    getAssetSelector,
     createBatchedAssetSourceSelector,
     createOrdersInAccountSelector,
     getPersonalNoteByTxIdSelector
@@ -85,13 +85,14 @@ const createAssetSourceBaseActivitySelectorDefinition = {
           ? noop
           : createOrdersInAccountSelector(walletAccount)
         return createSelector(
-          assetsSelector,
+          getAssetSelector,
           batchedTxsSelector,
           orderSelector,
           getPersonalNoteByTxIdSelector,
-          (assets, txs = EMPTY, orderSet, getPersonalNoteByTxId) => {
+          (getAsset, txs = EMPTY, orderSet, getPersonalNoteByTxId) => {
             const activityResult = []
-            const isIndexless = assets[assetName]?.baseAsset?.api?.features?.noHistory
+            const isIndexless =
+              assetName && getAsset(assetName)?.baseAsset?.api?.features?.noHistory
             const groupedTxs = groupTxsWithSameOrder({ txs, orderSet, isIndexless })
 
             if (groupedTxs) {
@@ -101,7 +102,7 @@ const createAssetSourceBaseActivitySelectorDefinition = {
                   ? getPersonalNoteByTxId(tx.txId)
                   : undefined
                 const formattedTx = formattersByType.get(formatterType)({
-                  asset: assets[tx.coinName],
+                  asset: getAsset(tx.coinName),
                   order,
                   tx,
                   personalNote,
@@ -131,7 +132,7 @@ const createAssetSourceBaseActivitySelectorDefinition = {
                 if (orderIdsFromActivity.has(order.orderId)) return
 
                 activityResult.push({
-                  ...formatUnindexedOrder({ assetName, assets, order }),
+                  ...formatUnindexedOrder({ assetName, order }),
                   walletAccount,
                 })
               })
@@ -147,7 +148,7 @@ const createAssetSourceBaseActivitySelectorDefinition = {
         `${assetName}_${walletAccount}_${JSON.stringify(rest)}`
     ),
   dependencies: [
-    { module: 'assets', selector: 'all' },
+    { module: 'assets', selector: 'getAsset' },
     { selector: 'createBatchedAssetSourceSelector' },
     { module: 'orders', selector: 'createOrdersInAccount', optional: true },
     { module: 'personalNotes', selector: 'get', optional: true },

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

@@ -11,8 +11,7 @@ const { get, groupBy, merge } = lodash
 // Now, we write the `order.txsIds` array, which contains information about setup, swap transactions, and more.
 // An order can be matched using any transaction ID from this array.
 // Each transaction will match the order, but we can deduplicate them later using `order.id` to display single activity item
-const collapseBatch = ({ batch, assets }) => {
-  const asset = assets[batch[0].coinName]
+const collapseBatch = ({ batch, asset }) => {
   const isToken = asset.baseAsset.name !== asset.name
 
   const totalBatchValue = batch.reduce(
@@ -44,13 +43,14 @@ const collapseBatch = ({ batch, assets }) => {
   )
 }
 
-const groupAndCollapseBatched = ({ txs, personalNotesWithBatchId, assets }) => {
+const groupAndCollapseBatched = ({ txs, personalNotesWithBatchId, getAsset }) => {
   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 })
-  )
+  const batchedTransactions = Object.values(batches).map((batch) => {
+    const asset = getAsset(batch[0].coinName)
+    return collapseBatch({ batch, asset })
+  })
 
   return [...unbatchedTransactions, ...batchedTransactions]
 }
@@ -60,12 +60,12 @@ const createBatchedAssetSourceSelectorDefinition = {
   dependencies: [
     { selector: 'createLimitedAssetSourceSelector' },
     { module: 'personalNotes', selector: 'withBatchId', optional: true },
-    { module: 'assets', selector: 'all' },
+    { module: 'assets', selector: 'getAsset' },
   ],
   selectorFactory: (
     createLimitedAssetSourceSelector,
     personalNotesWithBatchIdSelector,
-    assetsSelector
+    getAssetSelector
   ) =>
     memoize(
       ({ assetName, walletAccount, limit }) =>
@@ -74,10 +74,10 @@ const createBatchedAssetSourceSelectorDefinition = {
           : createSelector(
               createLimitedAssetSourceSelector({ assetName, walletAccount, limit }),
               personalNotesWithBatchIdSelector,
-              assetsSelector,
-              (txs, personalNotesWithBatchId, assets) => {
+              getAssetSelector,
+              (txs, personalNotesWithBatchId, getAsset) => {
                 return personalNotesWithBatchId.size > 0
-                  ? groupAndCollapseBatched({ txs, personalNotesWithBatchId, assets })
+                  ? groupAndCollapseBatched({ txs, personalNotesWithBatchId, getAsset })
                   : txs
               }
             ),

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

@@ -2,10 +2,10 @@ import { memoize } from '@exodus/basic-utils'
 import { createSelector } from 'reselect'
 import assert from 'minimalistic-assert'
 import { TX_TYPES } from '../constants/tx-types.js'
-import { ORDER_STATUS } from '@exodus/models/lib/fiat-order/constants.js'
+import { ORDER_STATUS, ORDER_TYPES } from '@exodus/models/lib/fiat-order/constants.js'
 
 const selectorFactory =
-  (visibleOrdersSelector, assetsSelector) =>
+  (visibleOrdersSelector) =>
   ({ createActivitySelector }) => {
     assert(createActivitySelector, 'please provide activitySelector')
 
@@ -14,66 +14,86 @@ const selectorFactory =
         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
-            }
+        return createSelector(visibleOrdersSelector, activitySelector, (fiatOrders, activity) => {
+          if (!fiatOrders) {
+            return activity
+          }
 
-            let hasChanges = false
+          let hasChanges = false
+          const pendingFiatOrdersWithoutTx = []
+          const fiatOrdersWithoutTx = []
 
-            const resultActivity = []
-            for (const activityItem of activity) {
-              const fiatOrdersByTx = fiatOrders.getAllByTxId(activityItem.txId)
+          if (displayFiatOrdersWithoutTx) {
+            for (const order of fiatOrders) {
+              if (order.txId) continue
 
-              if (fiatOrdersByTx.length > 0) {
-                hasChanges = true
+              const isRelatedBuyOrder =
+                order.toWalletAccount === walletAccount && order.toAsset === assetName
+              const isRelatedSellOrder =
+                order.fromWalletAccount === walletAccount && order.fromAsset === assetName
 
-                for (const fiatOrder of fiatOrdersByTx) {
-                  resultActivity.push({
-                    ...activityItem,
-                    fiatOrder,
-                    id: `${activityItem.id}.${fiatOrder.orderId}`,
-                    type: TX_TYPES.FIAT,
-                  })
+              if (isRelatedBuyOrder || isRelatedSellOrder) {
+                fiatOrdersWithoutTx.push(order)
+                if (order.exodusStatus === ORDER_STATUS.in_progress) {
+                  pendingFiatOrdersWithoutTx.push(order)
                 }
-              } else {
-                resultActivity.push(activityItem)
               }
             }
+          }
+
+          const resultActivity = []
 
-            if (displayFiatOrdersWithoutTx) {
-              for (const fiatOrder of fiatOrders) {
-                const isOrderWithoutTx = !fiatOrder.txId
-                const isRelatedBuyOrder =
-                  fiatOrder.toWalletAccount === walletAccount && fiatOrder.toAsset === assetName
-                const isRelatedSellOrder =
-                  fiatOrder.fromWalletAccount === walletAccount && fiatOrder.fromAsset === assetName
+          for (const activityItem of activity) {
+            const fiatOrdersByTx = fiatOrders.getAllByTxId(activityItem.txId)
+
+            if (fiatOrdersByTx.length > 0) {
+              hasChanges = true
+
+              for (const fiatOrder of fiatOrdersByTx) {
+                resultActivity.push({
+                  ...activityItem,
+                  fiatOrder,
+                  id: `${activityItem.id}.${fiatOrder.orderId}`,
+                  type: TX_TYPES.FIAT,
+                })
+              }
+            } else {
+              if (activityItem.pending && pendingFiatOrdersWithoutTx.length > 0) {
+                const matchingOrderIndex = pendingFiatOrdersWithoutTx.findIndex((order) => {
+                  const orderAmount =
+                    order.orderType === ORDER_TYPES.sell ? order.fromAmount : order.toAmount
 
-                if (isOrderWithoutTx && (isRelatedBuyOrder || isRelatedSellOrder)) {
+                  return activityItem.tx?.coinAmount?.abs().equals(orderAmount)
+                })
+
+                if (matchingOrderIndex !== -1) {
                   hasChanges = true
-                  const activityItem = {
-                    id: `${assetName}.fiat-order-without-tx.${fiatOrder.orderId}`,
-                    assetName,
-                    walletAccount,
-                    fiatOrder,
-                    type: TX_TYPES.FIAT,
-                    pending: fiatOrder.exodusStatus === ORDER_STATUS.in_progress,
-                    date: fiatOrder.date || new Date(),
-                  }
-                  resultActivity.push(activityItem)
+                  pendingFiatOrdersWithoutTx.splice(matchingOrderIndex, 1)
+                  continue
                 }
               }
-            }
 
-            if (!hasChanges) return activity
+              resultActivity.push(activityItem)
+            }
+          }
 
-            return resultActivity
+          for (const fiatOrder of fiatOrdersWithoutTx) {
+            hasChanges = true
+            resultActivity.push({
+              id: `${assetName}.fiat-order-without-tx.${fiatOrder.orderId}`,
+              assetName,
+              walletAccount,
+              fiatOrder,
+              type: TX_TYPES.FIAT,
+              pending: fiatOrder.exodusStatus === ORDER_STATUS.in_progress,
+              date: fiatOrder.date || new Date(),
+            })
           }
-        )
+
+          if (!hasChanges) return activity
+
+          return resultActivity
+        })
       },
       (deps) => JSON.stringify(deps)
     )
@@ -82,10 +102,7 @@ const selectorFactory =
 const createWithFiatActivitySelectorDefinition = {
   id: 'createWithFiatActivity',
   selectorFactory,
-  dependencies: [
-    { module: 'fiatRamp', selector: 'visibleOrders', optional: true },
-    { module: 'assets', selector: 'all' },
-  ],
+  dependencies: [{ module: 'fiatRamp', selector: 'visibleOrders', optional: true }],
 }
 
 export default createWithFiatActivitySelectorDefinition

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

@@ -4,7 +4,7 @@ import assert from 'minimalistic-assert'
 import { formatNftTx, formatUnindexedNftTx } from '../utils/activity-formatters/format-nft.js'
 
 const selectorFactory =
-  (createAssetSourceNftTxsById, activeNftsSelector, assetsSelector) =>
+  (createAssetSourceNftTxsById, activeNftsSelector, getAssetSelector) =>
   ({ createActivitySelector, nftsNetworkNameToAssetName }) => {
     assert(createActivitySelector, 'please provide activitySelector')
     assert(nftsNetworkNameToAssetName, 'please provide nftsNetworkNameToAssetName')
@@ -21,9 +21,9 @@ const selectorFactory =
         return createSelector(
           nftsSelector,
           activeNftsSelector,
-          assetsSelector,
+          getAssetSelector,
           activitySelector,
-          (nftsByTxId, activeNfts, assets, activity) => {
+          (nftsByTxId, activeNfts, getAsset, activity) => {
             const spamNftIdsSet = new Set(
               Object.values(activeNfts)
                 .flat()
@@ -46,7 +46,7 @@ const selectorFactory =
                     formatNftTx({
                       ...activityItem,
                       nft,
-                      asset: assets[activityItem.assetName],
+                      asset: getAsset(activityItem.assetName),
                       assetName: activityItem.assetName,
                     })
                   )
@@ -69,7 +69,7 @@ const selectorFactory =
               .forEach((nftTx) => {
                 hasChanges = true
                 const assetName = nftsNetworkNameToAssetName[nftTx.network]
-                const asset = assets[assetName]
+                const asset = getAsset(assetName)
                 const formatted = formatUnindexedNftTx({ nftTx, assetName: asset.name })
 
                 resultActivity.push(formatted)
@@ -92,7 +92,7 @@ const createWithNftsActivitySelectorDefinition = {
   dependencies: [
     { module: 'nfts', selector: 'createAssetSourceNftTxsById', optional: true },
     { module: 'nfts', selector: 'activeNfts', optional: true },
-    { module: 'assets', selector: 'all' },
+    { module: 'assets', selector: 'getAsset' },
   ],
 }