@exodus/ethereum-api 9.0.0-alpha.3 → 9.0.0

package/src/tx-log/monitor-utils/get-current-eip7702-delegation.js

@@ -0,0 +1,79 @@
+import { getEIP7702Delegation } from '../../eth-like-util.js'
+
+const NOT_DELEGATED = {
+  isDelegated: false,
+  delegatedAddress: null,
+  delegatedName: null,
+  isWhitelisted: null,
+}
+
+function hasDelegationChanged(currentDelegation, newDelegation) {
+  return (
+    currentDelegation?.isDelegated !== newDelegation.isDelegated ||
+    currentDelegation?.delegatedAddress !== newDelegation.delegatedAddress ||
+    currentDelegation?.delegatedName !== newDelegation.delegatedName ||
+    currentDelegation?.isWhitelisted !== newDelegation.isWhitelisted
+  )
+}
+
+/**
+ * Checks if the address has an EIP-7702 delegation and returns the delegation state.
+ * Returns the new state if changed, or undefined if unchanged (monitors treat undefined as "no write").
+ * On error, conservatively returns NOT_DELEGATED to avoid showing stale isDelegated: true,
+ * but only if the current state actually needs clearing.
+ *
+ * @param {Object} params
+ * @param {Object} params.server - The server instance to use for getCode
+ * @param {string} params.address - The wallet address to check
+ * @param {Array<{address: string, name: string}>} [params.eip7702Supported] - Whitelist of trusted delegation targets.
+ *   If not an array, the check is skipped entirely (chain does not support EIP-7702).
+ *   An empty array means the check runs but every delegation will be isWhitelisted: false.
+ * @param {Object} [params.currentDelegation] - The current delegation state from accountState
+ * @param {Object} [params.logger] - Optional logger for warnings
+ * @returns {Promise<Object|undefined>} The new delegation state, or undefined if unchanged
+ */
+export async function getCurrentEIP7702Delegation({
+  server,
+  address,
+  eip7702Supported,
+  currentDelegation,
+  logger,
+}) {
+  // Non-array (undefined, false, etc.) → chain doesn't support EIP-7702, skip entirely
+  if (!Array.isArray(eip7702Supported)) {
+    return hasDelegationChanged(currentDelegation, NOT_DELEGATED) ? NOT_DELEGATED : undefined
+  }
+
+  try {
+    const result = await getEIP7702Delegation({ address, server })
+
+    if (!result.isDelegated) {
+      return hasDelegationChanged(currentDelegation, NOT_DELEGATED) ? NOT_DELEGATED : undefined
+    }
+
+    // [] → check runs but nothing is trusted; populated array → whitelist check
+    const matchedDelegation = eip7702Supported.find(
+      ({ address }) => address.toLowerCase() === result.delegatedAddress.toLowerCase()
+    )
+    const isWhitelisted = Boolean(matchedDelegation)
+
+    const newDelegation = {
+      isDelegated: true,
+      delegatedAddress: result.delegatedAddress,
+      delegatedName: matchedDelegation?.name ?? null,
+      isWhitelisted,
+    }
+
+    return hasDelegationChanged(currentDelegation, newDelegation) ? newDelegation : undefined
+  } catch (error) {
+    if (logger) {
+      logger.warn('Failed to check EIP-7702 delegation:', error)
+    }
+
+    // On error, conservatively clear delegation state — only hard RPC confirmation
+    // should result in isDelegated: true being shown to the user.
+    return hasDelegationChanged(currentDelegation, NOT_DELEGATED) ? NOT_DELEGATED : undefined
+  }
+}
+
+export default getCurrentEIP7702Delegation

package/src/tx-log/monitor-utils/get-derive-transactions-to-check.js

@@ -1,6 +1,7 @@
-import ms from 'ms'
-import getSenderNonceKey from './get-sender-nonce-key'
 import { SynchronizedTime } from '@exodus/basic-utils'
+import ms from 'ms'
+
+import getSenderNonceKey from './get-sender-nonce-key.js'
 
 export const UNCONFIRMED_TX_LIMIT = ms('5m')
 
@@ -9,6 +10,7 @@ const mapToObject = (map) => Object.fromEntries(map.entries()) // only for strin
 export default function getDeriveTransactionsToCheck({ getTxLog }) {
   return async ({ assetName: _assetName, walletAccount, tokens, ourWalletAddress }) => {
     const pendingTransactionsToCheck = new Map()
+    const recentPendingTransactions = new Map()
     const pendingTransactionsGroupedByAddressAndNonce = new Map()
     const simulatedTransactions = new Map()
     const now = SynchronizedTime.now()
@@ -18,11 +20,13 @@ export default function getDeriveTransactionsToCheck({ getTxLog }) {
       for (const tx of txSet) {
         // ERC20 sends have an entry in ETH and one in the ERC20 log so we just want the ETH one
         if (
-          !pendingTransactionsToCheck.has(tx.txId) &&
           tx.pending &&
-          now - tx.date.getTime() > UNCONFIRMED_TX_LIMIT
+          !pendingTransactionsToCheck.has(tx.txId) &&
+          !recentPendingTransactions.has(tx.txId)
         ) {
-          pendingTransactionsToCheck.set(tx.txId, { tx, assetName })
+          const isRecent = now - tx.date.getTime() <= UNCONFIRMED_TX_LIMIT
+          const map = isRecent ? recentPendingTransactions : pendingTransactionsToCheck
+          map.set(tx.txId, { tx, assetName })
         }
 
         if (tx.meta.simulated) simulatedTransactions.set(tx.txId, tx)
@@ -44,6 +48,7 @@ export default function getDeriveTransactionsToCheck({ getTxLog }) {
 
     return {
       pendingTransactionsToCheck: mapToObject(pendingTransactionsToCheck),
+      recentPendingTransactions: mapToObject(recentPendingTransactions),
       pendingTransactionsGroupedByAddressAndNonce: mapToObject(
         pendingTransactionsGroupedByAddressAndNonce
       ),

package/src/tx-log/monitor-utils/get-fee-amount.js

@@ -10,5 +10,5 @@ export default function getFeeAmount(asset, serverTx) {
   return asset.currency
     .baseUnit(gasUsed || gasLimit)
     .mul(gasPrice)
-    .toDefault()
+    .add(asset.currency.baseUnit(serverTx.extraData?.l1Fee || 0))
 }

package/src/tx-log/monitor-utils/get-history-from-server.js

@@ -1,4 +1,4 @@
-import isConfirmedServerTx from './is-confirmed-server-tx'
+import isConfirmedServerTx from './is-confirmed-server-tx.js'
 
 // Fetches JSON transaction history from the given Ethereum server
 // object (from @exodus/ethereum-api). Starts fetching from the given

package/src/tx-log/monitor-utils/get-log-items-from-server-tx.js

@@ -1,14 +1,38 @@
-import getValueOfTransfers from './get-value-of-transfers'
-import getTransfersByTokenName from './get-transfers-by-token-name'
-import getNamesOfTokensTransferredByServerTx from './get-names-of-tokens-transferred-by-server-tx'
-import getFeeAmount from './get-fee-amount'
-import isConsideredSentTokenTx from './is-considered-sent-token-tx'
-import isConfirmedServerTx from './is-confirmed-server-tx'
 import lodash from 'lodash'
 
+import getFeeAmount from './get-fee-amount.js'
+import getNamesOfTokensTransferredByServerTx from './get-names-of-tokens-transferred-by-server-tx.js'
+import getRawTransferAmount from './get-raw-transfer-amount.js'
+import getTransfersByTokenName from './get-transfers-by-token-name.js'
+import getValueOfTransfers from './get-value-of-transfers.js'
+import isConfirmedServerTx from './is-confirmed-server-tx.js'
+import isConsideredSentTokenTx from './is-considered-sent-token-tx.js'
+
 // This function takes a server transaction object fetched from magnifier,
 // and transforms it into Tx models to update the exodus state.
 
+const tryFindExternalRecipient = (transfers, ourWalletAddress) =>
+  transfers.find(({ to }) => to !== ourWalletAddress)?.to || ourWalletAddress
+
+function isSelfSendTx({
+  coinAmount,
+  ourWalletWasSender,
+  sendingTransferPresent,
+  receivingTransferPresent,
+}) {
+  return (
+    coinAmount.isZero && sendingTransferPresent && receivingTransferPresent && ourWalletWasSender
+  )
+}
+
+function isNftTransfer({ serverTx, ourWalletAddress }) {
+  if (!Array.isArray(serverTx.erc721) || serverTx.erc721.length === 0) return false
+
+  return serverTx.erc721.some(
+    (transfer) => transfer.to === ourWalletAddress || transfer.from === ourWalletAddress
+  )
+}
+
 export default function getLogItemsFromServerTx({
   serverTx,
   asset,
@@ -49,12 +73,36 @@ export default function getLogItemsFromServerTx({
 
     if (sendingTransferPresent || receivingTransferPresent || nftTransferPresent) {
       const coinAmount = getValueOfTransfers(ourWalletAddress, asset, ethereumTransfers)
+      // `rawCoinAmount` mirrors the field written by `getOptimisticTxLogEffects`
+      // and is consumed by the bump path (`tx-create.js`) to recover the
+      // user-signed on-chain `value` when accelerating a self-send (where
+      // `coinAmount` is zero). For the base-asset entry the raw amount is the
+      // top-level `value` field of the tx itself, not the sum of internal
+      // transfers — that's what the user signed and what we must restore on
+      // bump.
+      const rawCoinAmount = getRawTransferAmount({
+        ourWalletAddress,
+        asset,
+        transfers: [serverTx],
+      }).toBaseString()
       const selfSend = isSelfSendTx({
         coinAmount,
         ourWalletWasSender,
         sendingTransferPresent,
         receivingTransferPresent,
       })
+      let sent
+      if (sendingTransferPresent) {
+        sent = serverTx.internal
+          .map(({ from, to, value }) => {
+            if (from === ourWalletAddress) {
+              const amount = asset.currency.baseUnit(value).toDefaultString({ unit: true })
+              return { address: to, amount }
+            }
+          })
+          .filter(Boolean)
+      }
+
       logItemsForServerTxEntries.push([
         asset.name,
         {
@@ -65,7 +113,9 @@ export default function getLogItemsFromServerTx({
             data,
             nonce,
             gasLimit,
+            rawCoinAmount,
             ...methodId,
+            ...(sent?.length > 0 ? { sent } : undefined),
           },
           ...(ourWalletWasSender
             ? { from: [], to: toAddress, feeAmount, feeCoinName: asset.feeAsset.name }
@@ -94,11 +144,25 @@ export default function getLogItemsFromServerTx({
 
     const token = assets[tokenName]
     const tokenTransferToAddress = tryFindExternalRecipient(tokenTransfers, ourWalletAddress)
-    const coinAmount = getValueOfTransfers(
+    // Transfers from this reader's server source are tagged with
+    // `events: true` once the tx is included in a block (event-log derived)
+    // and `events: false` while still pending (tx-data derived). Only one
+    // flavor is real for a given lifecycle state; filtering avoids
+    // double-counting if both ever coexist for the same transfer. Both
+    // `coinAmount` and `rawCoinAmount` must see the same set so they stay
+    // consistent.
+    const filteredTokenTransfers = lodash.filter(tokenTransfers, {
+      events: confirmations > 0,
+    })
+    const coinAmount = getValueOfTransfers(ourWalletAddress, token, filteredTokenTransfers)
+    // See base-entry comment above; for token entries the raw amount is the
+    // absolute total tokens our wallet moved in this tx (sum of outgoing, or
+    // incoming for receive-only entries).
+    const rawCoinAmount = getRawTransferAmount({
       ourWalletAddress,
-      token,
-      lodash.filter(tokenTransfers, { events: confirmations > 0 })
-    )
+      asset: token,
+      transfers: filteredTokenTransfers,
+    }).toBaseString()
     const tokenFromAddresses = lodash.uniq(
       tokenTransfers.filter(({ to }) => to === ourWalletAddress).map(({ from }) => from)
     )
@@ -122,7 +186,7 @@ export default function getLogItemsFromServerTx({
         ...logItemCommonProperties,
         coinAmount,
         coinName: tokenName,
-        data: { data, nonce, gasLimit, ...methodId },
+        data: { data, nonce, gasLimit, rawCoinAmount, ...methodId },
         ...(isConsideredSent
           ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: asset.feeAsset.name }
           : { from: tokenFromAddresses }),
@@ -137,25 +201,3 @@ export default function getLogItemsFromServerTx({
 
   return Object.fromEntries(logItemsForServerTxEntries)
 }
-
-const tryFindExternalRecipient = (transfers, ourWalletAddress) =>
-  transfers.find(({ to }) => to !== ourWalletAddress)?.to || ourWalletAddress
-
-function isSelfSendTx({
-  coinAmount,
-  ourWalletWasSender,
-  sendingTransferPresent,
-  receivingTransferPresent,
-}) {
-  return (
-    coinAmount.isZero && sendingTransferPresent && receivingTransferPresent && ourWalletWasSender
-  )
-}
-
-function isNftTransfer({ serverTx, ourWalletAddress }) {
-  if (!Array.isArray(serverTx.erc721) || serverTx.erc721.length === 0) return false
-
-  return serverTx.erc721.some(
-    (transfer) => transfer.to === ourWalletAddress || transfer.from === ourWalletAddress
-  )
-}

package/src/tx-log/monitor-utils/get-names-of-tokens-transferred-by-server-tx.js

@@ -1,6 +1,7 @@
-import lodash from 'lodash'
-import getValueOfTransfers from './get-value-of-transfers'
 import { FEE_PAYMENT_PREFIX } from '@exodus/ethereum-lib'
+import lodash from 'lodash'
+
+import getValueOfTransfers from './get-value-of-transfers.js'
 
 // For ETH transactions, we store an array of token names inside
 // the TX model. This array is used to display text in the UI for

package/src/tx-log/monitor-utils/get-raw-transfer-amount.js

@@ -0,0 +1,29 @@
+// Returns the absolute raw transferred amount for `ourWalletAddress`, in
+// `asset` base units, as a NumberUnit. Unlike `getValueOfTransfers` (which
+// returns the signed net delta), this preserves the raw transfer value even
+// when sender and receiver net to zero — e.g. self-sends. Used by tx-log
+// writers to persist `data.rawCoinAmount` so the bump path can reconstruct
+// the original on-chain value when accelerating a self-send.
+//
+// Each transfer is expected to have the shape `{ from, to, value }`. For the
+// base-asset entry, pass `[serverTx]` (the tx itself has the same shape at
+// its top level); for token entries, pass the array of token transfers for
+// that token.
+//
+// Outgoing transfers (from === ourWalletAddress) take precedence: when our
+// wallet sent anything, the raw amount is the sum of what we sent. We fall
+// back to incoming so receiver-only entries still report a non-zero raw
+// amount for consistency, even though the bump path only consults it on the
+// sender side.
+
+export default function getRawTransferAmount({ ourWalletAddress, asset, transfers }) {
+  const outgoing = transfers
+    .filter(({ from }) => from === ourWalletAddress)
+    .reduce((sum, { value }) => sum.add(asset.currency.baseUnit(value)), asset.currency.ZERO)
+
+  if (!outgoing.isZero) return outgoing
+
+  return transfers
+    .filter(({ to }) => to === ourWalletAddress)
+    .reduce((sum, { value }) => sum.add(asset.currency.baseUnit(value)), asset.currency.ZERO)
+}

package/src/tx-log/monitor-utils/get-transfers-by-token-name.js

@@ -1,4 +1,5 @@
-import lodash from 'lodash'
+import { omit } from '@exodus/basic-utils'
+import lodash from 'lodash' // oxlint-disable-line @exodus/oxlint-plugin-restricted-imports/prefer-basic-utils -- groupBy not in basic-utils
 
 // Sorts an array of token transfer events into an object of transfer event arrays,
 // whose keys are the names of the tokens which are being transferred in the corresponding array.
@@ -12,5 +13,5 @@ export default function getTransfersByTokenName(transfers, tokensByAddress) {
     transfers,
     (transfer) => tokensByAddress.get(transfer.address.toLowerCase())?.name || 'UNKNOWN'
   )
-  return lodash.omit(transfersByTokenName, 'UNKNOWN')
+  return omit(transfersByTokenName, ['UNKNOWN'])
 }

package/src/tx-log/monitor-utils/get-value-of-transfers.js

@@ -4,19 +4,17 @@
 // array is a transfer for that asset. If we sent more than we received, the value is negative.
 
 export default function getValueOfTransfers(ourWalletAddress, asset, transfers) {
-  return transfers
-    .reduce((balanceDifference, { from, to, value }) => {
-      const transferAmount = asset.currency.baseUnit(value)
+  return transfers.reduce((balanceDifference, { from, to, value }) => {
+    const transferAmount = asset.currency.baseUnit(value)
 
-      if (from === ourWalletAddress) {
-        balanceDifference = balanceDifference.sub(transferAmount)
-      }
+    if (from === ourWalletAddress) {
+      balanceDifference = balanceDifference.sub(transferAmount)
+    }
 
-      if (to === ourWalletAddress) {
-        balanceDifference = balanceDifference.add(transferAmount)
-      }
+    if (to === ourWalletAddress) {
+      balanceDifference = balanceDifference.add(transferAmount)
+    }
 
-      return balanceDifference
-    }, asset.currency.ZERO)
-    .to(asset.ticker)
+    return balanceDifference
+  }, asset.currency.ZERO)
 }

package/src/tx-log/monitor-utils/index.js

@@ -1,8 +1,13 @@
-export { default as getDeriveDataNeededForTick } from './get-derive-data-needed-for-tick'
+export { default as getDeriveDataNeededForTick } from './get-derive-data-needed-for-tick.js'
 
-export { default as getAllLogItemsByAsset } from './get-all-log-items-by-asset'
-export { default as getLogItemsFromServerTx } from './get-log-items-from-server-tx'
-export { default as getHistoryFromServer } from './get-history-from-server'
-export { default as checkPendingTransactions } from './check-pending-transactions'
-export { default as getDeriveTransactionsToCheck } from './get-derive-transactions-to-check'
-export * from './exclude-unchanged-token-balances'
+export { default as getAllLogItemsByAsset } from './get-all-log-items-by-asset.js'
+export { default as getLogItemsFromServerTx } from './get-log-items-from-server-tx.js'
+export { default as getHistoryFromServer } from './get-history-from-server.js'
+export { default as checkPendingTransactions } from './check-pending-transactions.js'
+export { default as getDeriveTransactionsToCheck } from './get-derive-transactions-to-check.js'
+export { default as getCurrentEIP7702Delegation } from './get-current-eip7702-delegation.js'
+export { default as getCurrentBlackListStatus } from './get-current-blacklist-status.js'
+export { default as verifyRpcPendingTxStatusBatch } from './verify-pending-tx-status-rpc.js'
+export { default as isUnverifiablePendingTxExpired } from './is-unverifiable-pending-tx-expired.js'
+export { extractBalanceFromClarityAccountInfo } from './extract-balance-from-clarity-account-info.js'
+export * from './exclude-unchanged-token-balances.js'

package/src/tx-log/monitor-utils/is-unverifiable-pending-tx-expired.js

@@ -0,0 +1,19 @@
+import { SynchronizedTime } from '@exodus/basic-utils'
+import ms from 'ms'
+
+// Upper bound on how long a pending tx with a per-entry 'unknown' verdict
+// (a hash the node persistently errors on) keeps being preserved across
+// refreshes. Without it, "cannot verify this hash" would mean "keep forever"
+// and a phantom tx would pin nonce derivation indefinitely.
+// Positively verified txs ('pending'/'confirmed') are exempt: their lifetime
+// is bounded by the node itself (mempool eviction yields a 'dropped' verdict).
+// A full batch failure is also exempt: it is evidence about nothing, so the
+// monitors preserve unconditionally until the batch path recovers.
+export const UNVERIFIABLE_PENDING_TX_MAX_AGE = ms('1h')
+
+export default function isUnverifiablePendingTxExpired(tx) {
+  const txTime = tx.date?.getTime()
+  // Fail closed: a tx with a missing or invalid date cannot prove it is young
+  if (!Number.isFinite(txTime)) return true
+  return SynchronizedTime.now() - txTime > UNVERIFIABLE_PENDING_TX_MAX_AGE
+}

package/src/tx-log/monitor-utils/verify-pending-tx-status-rpc.js

@@ -0,0 +1,90 @@
+/**
+ * Determines the status of an RPC transaction response.
+ *
+ * `undefined` means the node returned a JSON-RPC error entry for this hash
+ * (tolerant batch parsing) - no verdict, as opposed to `null` which is a
+ * definitive "not found".
+ *
+ * @param {Object|null|undefined} rpcTx - The RPC transaction response
+ * @returns {{status: 'confirmed' | 'pending' | 'dropped' | 'unknown', blockNumber?: number}}
+ */
+function getTxStatus(rpcTx) {
+  if (rpcTx === undefined) {
+    return { status: 'unknown' }
+  }
+
+  if (rpcTx?.blockNumber) {
+    return { status: 'confirmed', blockNumber: parseInt(rpcTx.blockNumber, 16) }
+  }
+
+  if (rpcTx) {
+    return { status: 'pending' }
+  }
+
+  return { status: 'dropped' }
+}
+
+/**
+ * Batch verify pending transactions against the RPC node before marking them as dropped.
+ *
+ * Any lag in the Clarity indexer can cause confirmed transactions to be incorrectly
+ * flagged as dropped if Clarity hasn't indexed their block yet.
+ * By checking the RPC directly, we avoid this race condition.
+ *
+ * Uses a single batch RPC call for efficiency and graceful error handling.
+ *
+ * @param {Object} params
+ * @param {Object} params.server - RPC server used to verify pending transactions
+ * @param {Object} params.logger - Logger instance for info/debug output
+ * @param {string[]} params.txIds - Array of transaction IDs/hashes to verify
+ * @returns {Promise<Object<string, {status: 'confirmed' | 'pending' | 'dropped' | 'unknown', blockNumber?: number}>>}
+ */
+export default async function verifyRpcPendingTxStatusBatch({ server, logger, txIds }) {
+  if (txIds.length === 0) return {}
+
+  // Build batch request
+  const requests = txIds.map((txId) => server.getTransactionByHashRequest(txId))
+
+  let responses
+  try {
+    // Tolerant parsing: one bad hash must not void the verdicts for every other tx
+    responses = await server.sendBatchRequest(requests, { tolerant: true })
+  } catch (error) {
+    // If batch request fails, skip all drop checks (safe default)
+    logger.warn('Batch RPC request failed, skipping drop checks', error)
+    return {}
+  }
+
+  if (!Array.isArray(responses) || responses.length !== txIds.length) {
+    // A malformed batch response must not produce 'dropped' verdicts (safe default)
+    logger.warn('Batch RPC response shape mismatch, skipping drop checks')
+    return {}
+  }
+
+  // Map responses to statuses
+  const results = Object.create(null)
+  txIds.forEach((txId, idx) => {
+    const rpcTx = responses[idx]
+    const txStatus = getTxStatus(rpcTx)
+    results[txId] = txStatus
+
+    // Log each tx status
+    switch (txStatus.status) {
+      case 'confirmed':
+        logger.info(
+          `tx ${txId} is confirmed on-chain (block ${txStatus.blockNumber}), skipping drop`
+        )
+        break
+      case 'pending':
+        logger.info(`tx ${txId} is still in mempool, skipping drop`)
+        break
+      case 'unknown':
+        logger.warn(`tx ${txId} could not be verified (RPC error entry), skipping drop`)
+        break
+      default:
+        logger.info(`tx ${txId} not found on-chain, marking as dropped`)
+    }
+  })
+
+  return results
+}

package/src/tx-log-staking-processor/asset-staking-tx-data.js

@@ -3,57 +3,115 @@ import {
   isEthereumDelegate,
   isEthereumUndelegate,
   isEthereumUndelegatePending,
-} from '../staking/ethereum/staking-utils'
-
-import { isPolygonClaimUndelegate, isPolygonDelegate } from '../staking/matic'
-
-import { decodePolygonStakingTxInputAmount } from './utils.js'
+} from '../staking/ethereum/staking-utils.js'
+import {
+  isPolygonClaimUndelegate,
+  isPolygonDelegate,
+  isPolygonUndelegate,
+} from '../staking/matic/index.js'
+import {
+  calculateRewardsFromStakeTx,
+  decodeEthLikeStakingTxInputAmount,
+  decodePolygonStakingTxInputAmount,
+} from './utils.js'
 
-const getEthereumStakeTxType = ({ tx }) => {
+const getEthereumStakingTxData = ({ tx, currency }) => {
   if (
     ['delegate', 'undelegatePending', 'undelegate', 'claimUndelegate'].some(
       (stakeTx) => tx.data?.[stakeTx]
-    )
-  )
+    ) &&
+    tx.coinAmount.isZero
+  ) {
     return
+  }
+
+  const txAmount = tx.coinAmount.toDefaultString()
 
   if (isEthereumDelegate(tx)) {
-    return { delegate: tx.coinAmount.toDefaultString() }
+    return {
+      coinAmount: currency.ZERO,
+      data: { delegate: txAmount, txAmount },
+    }
   }
 
   // undelegate must be taken in consideration, if unstaked ETH is still
   // in the pool queue, undelgate transfers staked funds back inmediatly to the user
-  if (isEthereumUndelegatePending(tx))
+  if (isEthereumUndelegatePending(tx)) {
+    const undelegatePending = currency
+      .baseUnit(decodeEthLikeStakingTxInputAmount(tx))
+      .toDefaultString()
     return {
-      undelegatePending: tx.coinAmount.toDefaultString(),
+      coinAmount: currency.ZERO,
+      data: { undelegatePending, txAmount },
     }
+  }
 
   if (isEthereumUndelegate(tx)) {
-    return { undelegate: tx.coinAmount.toDefaultString() }
+    const undelegate = currency.baseUnit(decodeEthLikeStakingTxInputAmount(tx)).toDefaultString()
+    return {
+      coinAmount: currency.ZERO,
+      data: { undelegate, txAmount },
+    }
   }
 
   // In the case of the ETH being actually staked and earning,
   // unstake has a withdraw period, after that, unstaked can be claimed.
   if (isEthereumClaimUndelegate(tx)) {
-    return { claimUndelegate: tx.coinAmount.toDefaultString() }
+    return {
+      coinAmount: currency.ZERO,
+      data: { claimUndelegate: txAmount, txAmount },
+    }
   }
 }
 
-const getPolygonStakeTxType = ({ tx, currency, server }) => {
-  if (tx.coinAmount.isZero) return
+const getPolygonStakingTxData = ({ tx, currency }) => {
+  if (tx.data?.claimUndelegate) return
+
+  if (['delegate', 'undelegate'].some((stakeTx) => tx.data?.[stakeTx]) && tx.coinAmount.isZero) {
+    return
+  }
+
+  const txAmount = tx.coinAmount.toDefaultString()
 
   if (isPolygonDelegate(tx)) {
-    const stakeTxAmount = currency
-      .baseUnit(decodePolygonStakingTxInputAmount({ tx, server }))
-      .toDefaultString()
-    return { delegate: stakeTxAmount }
+    const delegate = currency.baseUnit(decodePolygonStakingTxInputAmount(tx)).toDefaultString()
+    // MATIC returned in unstake tx is always reward
+    const rewards = calculateRewardsFromStakeTx({ tx, currency })
+    return {
+      coinAmount: currency.ZERO,
+      data: {
+        delegate,
+        txAmount,
+        ...(rewards ? { rewards } : {}),
+      },
+    }
   }
 
-  if (isPolygonClaimUndelegate(tx)) return { undelegate: tx.coinAmount.toDefaultString() }
+  if (isPolygonUndelegate(tx)) {
+    const undelegate = currency.baseUnit(decodePolygonStakingTxInputAmount(tx)).toDefaultString()
+    // MATIC returned in unstake tx is always reward
+    const rewards = txAmount
+    return {
+      coinAmount: currency.ZERO,
+      data: { undelegate, txAmount, rewards },
+    }
+  }
+
+  if (isPolygonClaimUndelegate(tx)) {
+    return {
+      // NOTE: We intentionally omit for compatibility with `rx`:
+      //       https://github.com/ExodusMovement/exodus-mobile/blob/229c9c0634af3e8e17eb1624019682c6fffe29bf/src/utils/getTxTag.js#L186
+      //
+      // coinAmount: currency.ZERO,
+      data: {
+        claimUndelegate: txAmount,
+        txAmount,
+      },
+    }
+  }
 }
 
-export const assetStakingTxData = {
-  polygon: getPolygonStakeTxType,
-  ethereum: getEthereumStakeTxType,
-  ethereumholesky: getEthereumStakeTxType,
+export const assetStakingTxProps = {
+  polygon: getPolygonStakingTxData,
+  ethereum: getEthereumStakingTxData,
 }