@exodus/activity-txs 6.1.3 → 6.1.4

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [6.1.4](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@6.1.3...@exodus/activity-txs@6.1.4) (2026-06-24)
+
+### Bug Fixes
+
+- **activity-txs:** collapse chained swap bridge legs into one row ([#17326](https://github.com/ExodusMovement/exodus-hydra/issues/17326)) ([befd253](https://github.com/ExodusMovement/exodus-hydra/commit/befd253a6853bcc15ddf64ba8212adde1ad53c33))
+
 ## [6.1.3](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@6.1.2...@exodus/activity-txs@6.1.3) (2026-05-13)
 
 **Note:** Version bump only for package @exodus/activity-txs

package/atoms/activity-txs.js

@@ -46,13 +46,14 @@ const createAssetSourceTxsSelector = memoize(
 const createActivityTxsAtom = ({
   txLogsAtom,
   accountStatesAtom,
-  assetsModule,
+  assetsAtom,
   logger,
   errorTracking,
 }) => {
   const inputAtom = combine({
     txLogs: txLogsAtom,
     accountStates: accountStatesAtom,
+    assetsAtomValue: assetsAtom,
   })
 
   let prevResult = Object.create(null)
@@ -70,16 +71,10 @@ const createActivityTxsAtom = ({
     return walletCache
   }
 
-  function processActivityForAsset(
-    walletAccount,
-    assetName,
-    assetTxSet,
-    accountStatesValue,
-    runId
-  ) {
+  function processActivityForAsset(walletAccount, asset, assetTxSet, accountStatesValue, runId) {
+    const assetName = asset.name
     const walletCache = getWalletCache(walletAccount)
     const cached = walletCache.get(assetName)
-    const asset = assetsModule.getAsset(assetName)
     const baseAssetName = asset.baseAsset.name
     const baseAssetAccountState = accountStatesValue?.[walletAccount]?.[baseAssetName]
 
@@ -171,10 +166,11 @@ const createActivityTxsAtom = ({
     return txs
   }
 
-  const selector = ({ txLogs, accountStates }) => {
+  const selector = ({ txLogs, accountStates, assetsAtomValue }) => {
     const runId = (runIdCounter += 1)
     const txLogsValue = txLogs?.value ?? Object.create(null)
     const accountStatesValue = accountStates?.value ?? Object.create(null)
+    const assets = assetsAtomValue?.value ?? Object.create(null)
 
     let activeCount = 0
 
@@ -199,13 +195,14 @@ const createActivityTxsAtom = ({
 
       if (prevWallet) {
         for (const assetName in accountTxLogs) {
+          if (!Object.prototype.hasOwnProperty.call(assets, assetName)) continue
           if (!Object.prototype.hasOwnProperty.call(accountTxLogs, assetName)) continue
           assetsCount += 1
           activeCount += 1
 
           const activityTxs = processActivityForAsset(
             walletAccount,
-            assetName,
+            assets[assetName],
             accountTxLogs[assetName],
             accountStatesValue,
             runId
@@ -236,12 +233,13 @@ const createActivityTxsAtom = ({
 
       const nextWallet = Object.create(null)
       for (const assetName in accountTxLogs) {
+        if (!Object.prototype.hasOwnProperty.call(assets, assetName)) continue
         if (!Object.prototype.hasOwnProperty.call(accountTxLogs, assetName)) continue
         activeCount += 1
 
         const activityTxs = processActivityForAsset(
           walletAccount,
-          assetName,
+          assets[assetName],
           accountTxLogs[assetName],
           accountStatesValue,
           runId
@@ -287,7 +285,7 @@ const activityTxsAtomDefinition = {
   id: 'activityTxsAtom',
   type: 'atom',
   factory: createActivityTxsAtom,
-  dependencies: ['txLogsAtom', 'accountStatesAtom', 'assetsModule', 'logger', 'errorTracking'],
+  dependencies: ['txLogsAtom', 'accountStatesAtom', 'assetsAtom', 'logger', 'errorTracking'],
   public: true,
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/activity-txs",
-  "version": "6.1.3",
+  "version": "6.1.4",
   "description": "The activity-txs feature",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -27,9 +27,10 @@
     "!**/*.test.js"
   ],
   "scripts": {
-    "lint": "run -T eslint -c ../../eslint.config.mjs",
-    "lint:fix": "yarn lint --fix",
-    "test": "run -T exodus-test --jest"
+    "lint": "pnpm exec eslint -c ../../eslint.config.mjs",
+    "lint:fix": "pnpm run lint --fix",
+    "test": "pnpm exec exodus-test --jest",
+    "typecheck": "pnpm exec tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
     "@exodus/atoms": "^10.3.3",
@@ -46,18 +47,18 @@
   "devDependencies": {
     "@exodus/assets": "^11.0.0",
     "@exodus/assets-base": "^12.0.0",
-    "@exodus/assets-feature": "^9.2.2",
+    "@exodus/assets-feature": "^9.2.3",
     "@exodus/available-assets": "^8.11.0",
     "@exodus/bitcoin-plugin": "^2.0.0",
     "@exodus/connected-origins": "^4.3.0",
-    "@exodus/error-tracking": "^3.5.0",
-    "@exodus/fiat-ramp": "^15.21.1",
+    "@exodus/error-tracking": "^3.6.0",
+    "@exodus/fiat-ramp": "^15.21.2",
     "@exodus/logger": "^1.2.3",
     "@exodus/nfts": "^9.6.2",
-    "@exodus/orders": "^6.1.3",
+    "@exodus/orders": "^6.2.2",
     "@exodus/personal-notes": "^3.9.0",
-    "@exodus/redux-dependency-injection": "^4.5.0",
-    "@exodus/wallet-accounts": "^20.4.4",
+    "@exodus/redux-dependency-injection": "^5.0.0",
+    "@exodus/wallet-accounts": "^20.4.7",
     "@types/minimalistic-assert": "^1.0.1",
     "redux": "^4.2.1"
   },
@@ -65,5 +66,5 @@
     "access": "public",
     "provenance": false
   },
-  "gitHead": "26c6093fc4c0d572e6575b307f492acab9c978e1"
+  "gitHead": "18b49ce03aa47d805068bce4b76bf834be314747"
 }

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

@@ -5,38 +5,69 @@ import { formatUnindexedOrder } from '../utils/activity-formatters/format-swap-a
 
 const EMPTY = Object.freeze([])
 
-const groupTxsWithSameOrder = ({ txs, orderSet, isIndexless }) => {
-  if (!orderSet) return txs.map((tx) => ({ tx, type: 'tx' }))
-
-  const getOrder = (tx) => {
-    const foundOrder = orderSet.getByTxId(tx.txId)
+const CHAINED_SVC = 'chained'
+
+// Outcomes of classifying a tx against the order set:
+// - 'exchange': tx belongs to a swap and should be grouped into an exchange row
+// - 'tx': tx is a plain send/receive (or a base-asset fee tx) and shows on its own
+// - 'suppress': tx is the intermediate (bridge) leg of a chained swap and is hidden
+const classifyTx = ({ tx, orderSet }) => {
+  const foundOrder = orderSet.getByTxId(tx.txId)
+  if (!foundOrder) return { type: 'tx' }
+
+  const isFromAsset = tx.coinName === foundOrder.fromAsset
+  const isToAsset = tx.coinName === foundOrder.toAsset
+
+  // The tx is linked to an order but moves an asset that is neither the
+  // swap's source nor destination.
+  if (!isFromAsset && !isToAsset) {
+    // Chained swaps (e.g. XO -> USDC -> Ondo) route through a bridge asset that
+    // briefly lands in the user's wallet on the same on-chain txs as the first
+    // and last legs. Those bridge-side rows (e.g. USDC received then sent) are
+    // noise: the swap already appears end-to-end as fromAsset -> toAsset. Hide
+    // them so users don't think they received an unrelated asset.
+    //
+    // Only suppress an actual bridge *movement* (non-zero principal). A
+    // base-asset fee-only tx (e.g. ETH/SOL gas debit) is also "neither from nor
+    // to asset", but it is a real one-way balance change, so it must stay
+    // visible — hiding it would drop the base-asset balance with no activity row.
+    const isBridgeMovement = Boolean(tx.coinAmount) && !tx.coinAmount.isZero
+
+    // Only hide bridge legs once the chained swap has completed. The "noise"
+    // justification relies on the bridge being a round-trip that nets to zero
+    // (received on leg 1, sent on leg 2). While the order is in progress or has
+    // failed/refunded, the user may genuinely be holding the bridge asset, so
+    // the movement must stay visible — otherwise the balance changes with no
+    // activity row explaining where the asset came from.
+    const isCompleted = foundOrder.exodusStatus === 'complete'
+    if (foundOrder.svc === CHAINED_SVC && isBridgeMovement && isCompleted) {
+      return { type: 'suppress' }
+    }
 
-    // If this is a base asset (fee-only tx), don't attach the order
-    // Base asset is not involved in the swap itself (not fromAsset or toAsset)
-    if (foundOrder) {
-      const isFromAsset = tx.coinName === foundOrder.fromAsset
-      const isToAsset = tx.coinName === foundOrder.toAsset
+    // Otherwise this is a base-asset (fee-only) tx, shown as a normal tx.
+    return { type: 'tx' }
+  }
 
-      // Base asset transactions should be treated as normal txs, not swaps
-      if (!isFromAsset && !isToAsset) {
-        return
-      }
-    }
+  const isBatchedTx = tx.coinName === 'bitcoin' && tx.data.sent?.[tx.data.sentIndex]
+  const isValidTx =
+    isBatchedTx && foundOrder?.fromAmount ? tx.coinAmount.abs().equals(foundOrder.fromAmount) : true
 
-    const isBatchedTx = tx.coinName === 'bitcoin' && tx.data.sent?.[tx.data.sentIndex]
-    const isValidTx =
-      isBatchedTx && foundOrder?.fromAmount
-        ? tx.coinAmount.abs().equals(foundOrder.fromAmount)
-        : true
+  return isValidTx ? { type: 'exchange', order: foundOrder } : { type: 'tx' }
+}
 
-    return isValidTx ? foundOrder : undefined
-  }
+const groupTxsWithSameOrder = ({ txs, orderSet, isIndexless }) => {
+  if (!orderSet) return txs.map((tx) => ({ tx, type: 'tx' }))
 
   const exchangeByOrderId = new Map()
   const result = []
 
   for (const tx of txs) {
-    const order = getOrder(tx)
+    const { type, order } = classifyTx({ tx, orderSet })
+
+    if (type === 'suppress') {
+      // Bridge leg of a chained swap, intentionally omitted from activity.
+      continue
+    }
 
     if (isIndexless && order) {
       // Orders are the source of truth for indexless swaps.
@@ -46,18 +77,17 @@ const groupTxsWithSameOrder = ({ txs, orderSet, isIndexless }) => {
 
     if (order) {
       if (!exchangeByOrderId.has(order.orderId)) {
-        exchangeByOrderId.set(order.orderId, [])
+        exchangeByOrderId.set(order.orderId, { order, txs: [] })
       }
 
-      exchangeByOrderId.get(order.orderId).push(tx)
+      exchangeByOrderId.get(order.orderId).txs.push(tx)
     } else {
       result.push({ tx, type: 'tx' })
     }
   }
 
-  exchangeByOrderId.forEach((txsGroup) => {
+  exchangeByOrderId.forEach(({ order, txs: txsGroup }) => {
     const tx = txsGroup.sort((a, b) => b.date.getTime() - a.date.getTime())[0]
-    const order = getOrder(tx)
     result.push({ tx, type: 'exchange', order })
   })
 

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

@@ -2,7 +2,9 @@ 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, ORDER_TYPES } from '@exodus/models/lib/fiat-order/constants.js'
+import { FIAT_ORDER } from '@exodus/models'
+
+const { ORDER_STATUS, ORDER_TYPES } = FIAT_ORDER
 
 const ORDER_TX_MATCH_WINDOW_MS = 3 * 24 * 60 * 60 * 1000