@exodus/activity-txs 4.1.1 → 4.1.3

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.1.3](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@4.1.2...@exodus/activity-txs@4.1.3) (2024-05-27)
+
+**Note:** Version bump only for package @exodus/activity-txs
+
+## [4.1.2](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@4.1.1...@exodus/activity-txs@4.1.2) (2024-05-15)
+
+### Bug Fixes
+
+- address security feedback ([#6963](https://github.com/ExodusMovement/exodus-hydra/issues/6963)) ([155bdfe](https://github.com/ExodusMovement/exodus-hydra/commit/155bdfed531685108d828be60c9d1a8be9e785ee))
+- indexless order should be ignored in first loop ([#6965](https://github.com/ExodusMovement/exodus-hydra/issues/6965)) ([83766cd](https://github.com/ExodusMovement/exodus-hydra/commit/83766cd69533d81317ea52ab770541a7ccfde274))
+
 ## [4.1.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/activity-txs@4.1.0...@exodus/activity-txs@4.1.1) (2024-05-15)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/activity-txs",
-  "version": "4.1.1",
+  "version": "4.1.3",
   "description": "The activity-txs feature",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -36,6 +36,7 @@
     "@exodus/models": "^10.1.0",
     "@exodus/module": "^1.2.2",
     "@exodus/multi-account-redux": "^2.0.1",
+    "@exodus/typeforce": "^1.19.0",
     "lodash": "^4.17.21",
     "minimalistic-assert": "^1.0.1",
     "reselect": "^3.0.1"
@@ -44,21 +45,21 @@
     "@exodus/assets": "^8.0.95",
     "@exodus/assets-base": "^8.1.10",
     "@exodus/assets-feature": "^5.3.1",
-    "@exodus/available-assets": "^8.2.0",
+    "@exodus/available-assets": "^8.2.1",
     "@exodus/bitcoin-plugin": "^1.4.2",
     "@exodus/blockchain-metadata": "^15.3.1",
     "@exodus/connected-origins": "^3.3.1",
     "@exodus/dependency-injection": "^2.2.0",
     "@exodus/dependency-preprocessors": "^5.2.0",
-    "@exodus/fiat-ramp": "^10.5.1",
-    "@exodus/nfts": "^9.2.1",
-    "@exodus/orders": "^4.8.1",
+    "@exodus/fiat-ramp": "^10.6.0",
+    "@exodus/nfts": "^9.3.0",
+    "@exodus/orders": "^4.9.0",
     "@exodus/personal-notes": "^3.6.0",
     "@exodus/redux-dependency-injection": "^3.1.0",
     "@exodus/storage-memory": "^2.1.1",
-    "@exodus/wallet-accounts": "^16.5.0",
+    "@exodus/wallet-accounts": "^16.5.1",
     "@types/minimalistic-assert": "^1.0.1",
     "redux": "^4.2.1"
   },
-  "gitHead": "268f3e822c0d1aadc8a42391b9770b435021e230"
+  "gitHead": "5f3e666315d60ebef4051ebffa1518a193a7ec43"
 }

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

@@ -1,35 +1,40 @@
 import { createSelector } from 'reselect'
 import { memoize } from '@exodus/basic-utils'
-import { TX_TYPES } from '../constants/tx-types'
-import { formatGroupedExchangeTxs, formattersByType } from '../utils/formatters'
+import { formattersByType } from '../utils/activity-formatters'
+import { formatUnindexedOrder } from '../utils/activity-formatters/format-swap-activity'
 
 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 groupTxsWithSameOrder = ({ txs, orderSet, isIndexless }) => {
   const getOrder = (tx) => orderSet.getByTxId(tx.txId)
-  const exchangeByOrderId = {}
+  const exchangeByOrderId = new Map()
   const result = []
+
   for (const tx of txs) {
     const order = getOrder(tx)
+    if (isIndexless && order) {
+      // Orders are the source of truth for indexless swaps.
+      // Skip this tx and add it later as exchanged.
+      continue
+    }
+
     if (order) {
-      ;(exchangeByOrderId[order.orderId] ?? (exchangeByOrderId[order.orderId] = [])).push(tx)
+      if (!exchangeByOrderId.has(order.orderId)) {
+        exchangeByOrderId.set(order.orderId, [])
+      }
+
+      exchangeByOrderId.get(order.orderId).push(tx)
     } else {
       result.push({ tx, type: 'tx' })
     }
   }
 
-  Object.values(exchangeByOrderId).forEach((txsGroup) => {
+  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
 }
 
@@ -50,24 +55,22 @@ const createAssetSourceBaseActivitySelectorDefinition = {
           getPersonalNoteByTxIdSelector,
           (assets, txs = EMPTY, orderSet, getPersonalNoteByTxId) => {
             const activityResult = []
-
-            const groupedTxs = groupTxsWithSameOrder({ txs, orderSet })
+            const isIndexless = assets[assetName]?.baseAsset?.api?.features?.noHistory
+            const groupedTxs = groupTxsWithSameOrder({ txs, orderSet, isIndexless })
 
             for (const group of groupedTxs) {
               const { tx, order, type: formatterType } = group
               const personalNote = getPersonalNoteByTxId(tx.txId)
-              const formattedTx = formattersByType[formatterType]({
-                assets,
+              const formattedTx = formattersByType.get(formatterType)({
+                asset: assets[tx.coinName],
                 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(
@@ -80,30 +83,8 @@ const createAssetSourceBaseActivitySelectorDefinition = {
                 // 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 })
+                const formattedItem = formatUnindexedOrder({ assetName, assets, order })
+
                 activityResult.push(formattedItem)
               })
             }

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

@@ -6,11 +6,14 @@ const selectorFactory =
     createWithConnectionsActivity
   ) =>
   // call this once on client-side
-  (options = {}) => {
+  (options = Object.create(null)) => {
     let createFullSelector = createAssetSourceBaseActivity
     createFullSelector = createWithNftsActivity({
       createActivitySelector: createFullSelector,
-      nftsNetworkNameToAssetName: options.nftsNetworkNameToAssetName || {},
+      nftsNetworkNameToAssetName:
+        (Object.hasOwn(options, 'nftsNetworkNameToAssetName') &&
+          options.nftsNetworkNameToAssetName) ||
+        Object.create(null),
     })
     createFullSelector = createWithFiatActivity({ createActivitySelector: createFullSelector })
     createFullSelector = createWithConnectionsActivity({

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

@@ -1,8 +1,7 @@
 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'
+import { formatNftTx, formatUnindexedNftTx } from '../utils/activity-formatters/format-nft'
 
 const selectorFactory =
   (createAssetSourceNftTxsById, assetsSelector) =>
@@ -33,12 +32,9 @@ const selectorFactory =
               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
-                })
+                resultActivity.push(
+                  formatNftTx({ ...activityItem, nft, assetName: activityItem.assetName })
+                )
               } else {
                 resultActivity.push(activityItem)
               }
@@ -47,6 +43,7 @@ const selectorFactory =
             ;[...nftsByTxId.values()]
               .filter(
                 (nftTx) =>
+                  Object.hasOwn(nftsNetworkNameToAssetName, nftTx.network) &&
                   assetName === nftsNetworkNameToAssetName[nftTx.network] &&
                   !indexedNftTxIds.has(nftTx.txId)
               )
@@ -54,7 +51,7 @@ const selectorFactory =
                 hasChanges = true
                 const assetName = nftsNetworkNameToAssetName[nftTx.network]
                 const asset = assets[assetName]
-                const formatted = formatUnindexedNftTx({ nftTx, asset })
+                const formatted = formatUnindexedNftTx({ nftTx, assetName: asset.name })
 
                 resultActivity.push(formatted)
               })

package/redux/utils/activity-formatters/format-nft.js

@@ -0,0 +1,38 @@
+import { getSharedProps } from './get-shared-props'
+import { TX_TYPES } from '../../constants/tx-types'
+
+export const formatUnindexedNftTx = ({ assetName, nftTx }) => {
+  return {
+    ...getSharedProps({
+      txId: nftTx.txId,
+      date: new Date(nftTx.date),
+      assetName,
+      type: TX_TYPES.NFT,
+      id: `nft_${assetName}.${nftTx.txId}`,
+      pending: false,
+      failed: false,
+      sent: nftTx.sent,
+      received: !nftTx.sent,
+    }),
+    nft: nftTx,
+  }
+}
+
+export const formatNftTx = ({ tx, nft, assetName, ...rest }) => {
+  return {
+    ...rest,
+    ...getSharedProps({
+      txId: nft.txId,
+      date: tx.date,
+      assetName,
+      type: TX_TYPES.NFT,
+      id: `nft_${assetName}.${tx.txId}`,
+      pending: false,
+      failed: tx.failed,
+      sent: nft.sent,
+      received: !nft.sent,
+    }),
+    nft,
+    tx,
+  }
+}

package/redux/utils/activity-formatters/format-swap-activity.js

@@ -0,0 +1,93 @@
+import { getSharedProps } from './get-shared-props'
+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 = new Map([
+  [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 getOrderType({ order, tx }) {
+  const txInfoFromOrder = tx
+    ? order.txIds?.find((txFromOrder) => txFromOrder.txId === tx.txId)
+    : null
+  return UI_TX_TYPE_FROM_EXODEX.get(txInfoFromOrder?.txType) || TX_TYPES.EXCHANGE
+}
+
+const getSwapSharedProps = ({
+  date,
+  assetName,
+  txId,
+  tx,
+  order,
+  failed,
+  displayAmount,
+  personalNote,
+  pending,
+}) => {
+  return {
+    ...getSharedProps({
+      txId,
+      date,
+      id: `swap_${assetName}.${txId}`,
+      assetName,
+      type: getOrderType({ tx, order }),
+      pending,
+      failed,
+      sent: order.fromAsset === assetName,
+      received: order.toAsset === assetName,
+    }),
+    tx,
+    fromAsset: order.fromAsset,
+    toAsset: order.toAsset,
+    orderId: order.orderId,
+    displayAmount,
+    personalNote,
+  }
+}
+
+export const formatSwapActivity = ({ tx, order, personalNote }) =>
+  getSwapSharedProps({
+    date: tx.date,
+    assetName: order.toAsset,
+    txId: tx.txId,
+    tx,
+    order,
+    failed: tx.failed || order.error,
+    displayAmount: order.toAmount.abs(),
+    personalNote,
+    pending: order.exodusStatus === FINAL_ORDER_STATUS.inProgress,
+  })
+
+export const formatUnindexedOrder = ({ order, assetName: _assetName, personalNote }) => {
+  const isFromIndexlessAsset = order.fromAsset === _assetName
+  const assetName = isFromIndexlessAsset ? order.fromAsset : order.toAsset
+  let displayAmount = isFromIndexlessAsset ? order.fromAmount : order.toAmount
+  displayAmount = displayAmount.abs()
+  const txId = isFromIndexlessAsset ? order.fromTxId : order.toTxId
+
+  return getSwapSharedProps({
+    date: order.date,
+    assetName,
+    txId,
+    order,
+    failed: order.error,
+    displayAmount,
+    personalNote,
+    pending: order.exodusStatus === FINAL_ORDER_STATUS.inProgress,
+  })
+}

package/redux/utils/activity-formatters/format-tx-activity.js

@@ -0,0 +1,39 @@
+import { TX_TYPES } from '../../constants/tx-types'
+import { getSharedProps } from './get-shared-props'
+
+function getTxType({ tx }) {
+  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 generateTxActivityId = ({ tx, asset }) => {
+  const sentIndex = tx.data?.sentIndex
+  return sentIndex ? `${asset.name}.${tx.txId}_${sentIndex}` : `${asset.name}.${tx.txId}`
+}
+
+export const formatTxActivity = ({ tx, asset, personalNote }) => {
+  return {
+    ...getSharedProps({
+      txId: tx.txId,
+      date: tx.date,
+      id: generateTxActivityId({ tx, asset }),
+      assetName: asset.name,
+      type: getTxType({ tx }),
+      pending: isPending(tx, asset),
+      failed: tx.failed,
+      sent: tx.sent,
+      received: tx.received,
+    }),
+    tx,
+    personalNote,
+  }
+}

package/redux/utils/activity-formatters/get-shared-props.js

@@ -0,0 +1,25 @@
+import typeforce from '@exodus/typeforce'
+
+export const getSharedProps = (opts) => {
+  try {
+    typeforce(
+      opts,
+      {
+        txId: 'String',
+        date: 'Date',
+        id: 'String',
+        assetName: 'String', // used to filter by asset on client side
+        type: 'String',
+        pending: 'Boolean', // tx uses tx.pending, order checks order status
+        failed: 'Boolean', // tx uses tx.failed, order uses status
+        sent: 'Boolean', // tx.uses tx.sent, nft uses nft.sent
+        received: 'Boolean', // tx.uses tx.receive, nft uses !nft.sent
+      },
+      true // no extra props allowed
+    )
+  } catch {
+    console.warn('activity item props dont pass validation', opts)
+  }
+
+  return opts
+}

package/redux/utils/activity-formatters/index.js

@@ -0,0 +1,7 @@
+import { formatSwapActivity } from './format-swap-activity'
+import { formatTxActivity } from './format-tx-activity'
+
+export const formattersByType = new Map([
+  ['exchange', formatSwapActivity],
+  ['tx', formatTxActivity],
+])

package/redux/utils/formatters.js

@@ -1,107 +0,0 @@
-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,
-  }
-}