@exodus/ethereum-plugin 2.30.3 → 2.31.0

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.31.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.30.4...@exodus/ethereum-plugin@2.31.0) (2026-05-19)
+
+
+### Features
+
+
+* feat(ethereum): add no-history receive logs for portfolio transfers (#7967)
+
+
+
+## [2.30.4](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.30.3...@exodus/ethereum-plugin@2.30.4) (2026-05-12)
+
+
+### Bug Fixes
+
+* validate polygon unstake state before gas estimation ([#8002](https://github.com/ExodusMovement/assets/issues/8002)) ([f63a244](https://github.com/ExodusMovement/assets/commit/f63a2441868c6226fe14085c0f7d9587131e69e0))
+
+
+
 ## [2.30.3](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.30.2...@exodus/ethereum-plugin@2.30.3) (2026-05-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-plugin",
-  "version": "2.30.3",
+  "version": "2.31.0",
   "description": "Ethereum plugin for Exodus SDK powered wallets",
   "type": "module",
   "main": "src/index.js",
@@ -24,8 +24,8 @@
     "@exodus/asset-lib": "^5.9.0",
     "@exodus/basic-utils": "^3.0.1",
     "@exodus/currency": "^6.0.1",
-    "@exodus/ethereum-api": "^8.73.6",
-    "@exodus/ethereum-lib": "^5.24.0",
+    "@exodus/ethereum-api": "^8.75.1",
+    "@exodus/ethereum-lib": "^5.24.1",
     "@exodus/ethereum-meta": "^2.9.0",
     "@exodus/ethereumjs": "^1.0.0",
     "@exodus/safe-string": "^1.4.0",
@@ -38,7 +38,7 @@
     "@exodus/assets": "^11.4.0",
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/crypto": "^1.0.0-rc.13",
-    "@exodus/evm-fork-testing": "^0.6.1",
+    "@exodus/evm-fork-testing": "^0.6.2",
     "@exodus/models": "^13.0.0",
     "@exodus/solidity-contract": "^1.3.0",
     "@exodus/web3-ethereum-utils": "^4.7.5",
@@ -53,5 +53,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "79dabe78d5a3652b509c7cc1d1496ac2404104b8"
+  "gitHead": "ee5bf2d01055d8822c6421fa0ad4da84d4a33402"
 }

package/src/index.js

@@ -5,6 +5,8 @@ import assetsList from '@exodus/ethereum-meta'
 import { tetherusdBlackListCheckFactory, usdcoinBlackListCheckFactory } from './blacklist-checks.js'
 import { stakingConfiguration, stakingDependencies } from './staking.js'
 
+export { POLYGON_STAKING_PREFLIGHT_ERROR_REASONS } from './staking/polygon/service.js'
+
 const createAsset = createAssetFactory({
   assetsList,
   feeDataConfig: {

package/src/staking/polygon/service.js

@@ -1,15 +1,41 @@
 import { memoize } from '@exodus/basic-utils'
 // eslint-disable-next-line @exodus/import/no-deprecated
-import { isNumberUnit } from '@exodus/currency'
+import NumberUnit, { isNumberUnit } from '@exodus/currency'
 import {
   estimateGasLimit,
+  EthLikeError,
+  EVM_ERROR_TYPES,
   getAggregateTransactionPricing,
-  getOptimisticTxLogEffects,
   scaleGasLimitEstimate,
   stakingProviderClientFactory,
 } from '@exodus/ethereum-api'
+import { safeString } from '@exodus/safe-string'
 
 import { maticDelegateSimulateTransactions } from './matic-staking-utils.js'
+import { getPendingUndelegateAmountFromEthereumTxLog } from './staking-utils.js'
+
+export const POLYGON_STAKING_PREFLIGHT_ERROR_REASONS = {
+  polygonUnstakeAmountInvalid: {
+    reason: safeString`polygon unstake amount invalid`,
+    type: EVM_ERROR_TYPES.PREFLIGHT_VALIDATION,
+  },
+  polygonUnstakeAmountUnavailable: {
+    reason: safeString`polygon unstake amount unavailable`,
+    type: EVM_ERROR_TYPES.PREFLIGHT_VALIDATION,
+  },
+  polygonUnstakeClaimNonceInvalid: {
+    reason: safeString`polygon unstake claim nonce invalid`,
+    type: EVM_ERROR_TYPES.PREFLIGHT_VALIDATION,
+  },
+  polygonUnstakeClaimUnavailable: {
+    reason: safeString`polygon unstake claim unavailable`,
+    type: EVM_ERROR_TYPES.PREFLIGHT_VALIDATION,
+  },
+  polygonUnstakeClaimNotReady: {
+    reason: safeString`polygon unstake claim not ready`,
+    type: EVM_ERROR_TYPES.PREFLIGHT_VALIDATION,
+  },
+}
 
 export function stakingServiceFactory({ assetClientInterface, server: _server, stakingServer }) {
   const stakingProvider = stakingProviderClientFactory()
@@ -66,6 +92,105 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
     return address.toLowerCase()
   }
 
+  const getPendingUndelegateAmount = async ({ walletAccount, asset }) => {
+    if (typeof assetClientInterface.getTxLog !== 'function') return asset.currency.ZERO
+
+    const ethereumTxLog = await assetClientInterface.getTxLog({ assetName, walletAccount })
+    return getPendingUndelegateAmountFromEthereumTxLog({
+      ethereumTxLog,
+      currency: asset.currency,
+      validatorShareContract: stakingServer.validatorShareContract,
+    })
+  }
+
+  const getUndelegateParams = async ({ walletAccount, amount, delegatorAddress, asset }) => {
+    if (!(amount instanceof NumberUnit) || !amount.gt(asset.currency.ZERO)) {
+      throw new EthLikeError({
+        message: 'Undelegate amount must be positive',
+        errorReasonInfo: POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeAmountInvalid,
+        hint: safeString`polygonStaking:undelegate:amount`,
+        baseAssetName: asset.baseAsset.name,
+      })
+    }
+
+    const [delegatedBalance, pendingUndelegateAmount] = await Promise.all([
+      stakingServer.getTotalStake(delegatorAddress),
+      getPendingUndelegateAmount({ walletAccount, asset }),
+    ])
+
+    if (delegatedBalance.isZero) {
+      throw new EthLikeError({
+        message: 'No active Polygon stake to undelegate',
+        errorReasonInfo: POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeAmountUnavailable,
+        hint: safeString`polygonStaking:undelegate:activeStake`,
+        baseAssetName: asset.baseAsset.name,
+      })
+    }
+
+    const availableActiveStake = delegatedBalance.sub(pendingUndelegateAmount)
+
+    if (amount.gt(availableActiveStake)) {
+      throw new EthLikeError({
+        message: 'Undelegate amount exceeds active Polygon stake',
+        errorReasonInfo: POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeAmountUnavailable,
+        hint: safeString`polygonStaking:undelegate:availableStake`,
+        baseAssetName: asset.baseAsset.name,
+      })
+    }
+
+    return { amount }
+  }
+
+  const getClaimUndelegatedParams = async ({ asset, delegatorAddress, unbondNonce }) => {
+    const { currency } = asset
+
+    if (!Number.isInteger(unbondNonce) || unbondNonce <= 0) {
+      throw new EthLikeError({
+        message: 'Polygon unstake claim nonce is invalid',
+        errorReasonInfo: POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeClaimNonceInvalid,
+        hint: safeString`polygonStaking:claimUnstaked:nonce`,
+        baseAssetName: asset.baseAsset.name,
+      })
+    }
+
+    const [{ shares, withdrawEpoch }, withdrawalDelay, currentEpoch, withdrawExchangeRate] =
+      await Promise.all([
+        stakingServer.getUnboundInfo(delegatorAddress, unbondNonce),
+        stakingServer.getWithdrawalDelay(),
+        stakingServer.getCurrentCheckpoint(),
+        stakingServer.getWithdrawExchangeRate(),
+      ])
+
+    if (shares.isZero()) {
+      throw new EthLikeError({
+        message: 'No Polygon unstake claim available',
+        errorReasonInfo: POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeClaimUnavailable,
+        hint: safeString`polygonStaking:claimUnstaked:shares`,
+        baseAssetName: asset.baseAsset.name,
+      })
+    }
+
+    if (withdrawEpoch.add(withdrawalDelay).gt(currentEpoch)) {
+      throw new EthLikeError({
+        message: 'Polygon unstake claim is not ready',
+        errorReasonInfo: POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeClaimNotReady,
+        hint: safeString`polygonStaking:claimUnstaked:withdrawalDelay`,
+        baseAssetName: asset.baseAsset.name,
+      })
+    }
+
+    return {
+      unclaimedUndelegatedBalance: calculateUnclaimedTokens({
+        currency,
+        exchangeRatePrecision: stakingServer.EXCHANGE_RATE_PRECISION,
+        withdrawExchangeRate,
+        shares,
+        canClaimUndelegatedBalance: true,
+        isUndelegateInProgress: false,
+      }),
+    }
+  }
+
   async function approveDelegateAmount({ walletAccount, amount, feeData } = {}) {
     feeData = await resolveOptionalFeeData({ feeData })
 
@@ -174,59 +299,22 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
       revertOnSimulationError,
     })
 
-    // Sign transactions
-    const [approveSigned, delegateSigned] = await Promise.all([
-      assetClientInterface.signTransaction({
-        assetName: feeAsset.name,
-        unsignedTx: unsignedTxApprove.unsignedTx,
-        walletAccount,
-      }),
-      assetClientInterface.signTransaction({
-        assetName: feeAsset.name,
-        unsignedTx: unsignedTxDelegate.unsignedTx,
-        walletAccount,
-      }),
-    ])
-
-    // Pre-compute txIDs
-    const approveTxId = `0x${approveSigned.txId.toString('hex')}`
-    const delegateTxId = `0x${delegateSigned.txId.toString('hex')}`
-
-    const bundleResponse = await feeAsset.broadcastPrivateBundle({
-      txs: [approveSigned, delegateSigned].map(({ rawTx }) => rawTx),
+    const { txIds } = await asset.baseAsset.sendPrivateBundle({
+      unsignedTxBundle: [
+        {
+          asset: feeAsset,
+          unsignedTx: unsignedTxApprove.unsignedTx,
+          walletAccount,
+        },
+        {
+          asset: feeAsset,
+          unsignedTx: unsignedTxDelegate.unsignedTx,
+          walletAccount,
+        },
+      ],
     })
-    const bundleHash = bundleResponse?.bundleHash
-
-    const { optimisticTxLogEffects: approveOptimisticTxLogEffects } =
-      await getOptimisticTxLogEffects({
-        asset: feeAsset,
-        assetClientInterface,
-        fromAddress: delegatorAddress.toString(),
-        txId: approveTxId,
-        unsignedTx: unsignedTxApprove.unsignedTx,
-        walletAccount,
-        bundleId: bundleHash ?? undefined,
-      })
 
-    const { optimisticTxLogEffects: delegateOptimisticTxLogEffects } =
-      await getOptimisticTxLogEffects({
-        asset: feeAsset,
-        assetClientInterface,
-        fromAddress: delegatorAddress.toString(),
-        txId: delegateTxId,
-        unsignedTx: unsignedTxDelegate.unsignedTx,
-        walletAccount,
-        bundleId: bundleHash ?? undefined,
-      })
-    // Combine optimistic effects from both transactions
-    const tokenOptimisticEffects = [
-      ...approveOptimisticTxLogEffects,
-      ...delegateOptimisticTxLogEffects,
-    ]
-
-    for (const optimisticEffect of tokenOptimisticEffects) {
-      await assetClientInterface.updateTxLogAndNotify(optimisticEffect)
-    }
+    const delegateTxId = txIds[txIds.length - 1]
 
     await stakingProvider.notifyStaking({
       txId: delegateTxId,
@@ -247,7 +335,14 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
 
     amount = amountToCurrency({ asset, amount })
 
-    const txUndelegateData = await stakingServer.undelegate({ amount })
+    const undelegateParams = await getUndelegateParams({
+      walletAccount,
+      amount,
+      delegatorAddress,
+      asset,
+    })
+
+    const txUndelegateData = await stakingServer.undelegate(undelegateParams)
     const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
       from: delegatorAddress.toLowerCase(),
       to: stakingServer.validatorShareContract.address,
@@ -297,17 +392,10 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
       getStakeAssets(),
     ])
 
-    const { currency } = asset
-    const unstakedClaimInfo = await fetchUnstakedClaimInfo({
-      stakingServer,
-      delegator: delegatorAddress,
-    })
-
-    const { unclaimedUndelegatedBalance } = await getUnstakedUnclaimedInfo({
-      stakingServer,
-      currency,
-      delegator: delegatorAddress,
-      ...unstakedClaimInfo,
+    const { unclaimedUndelegatedBalance } = await getClaimUndelegatedParams({
+      asset,
+      delegatorAddress,
+      unbondNonce,
     })
 
     const txClaimUndelegatedData = await stakingServer.claimUndelegatedBalance({ unbondNonce })
@@ -366,6 +454,26 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
       args = { ...args, amount: amountToCurrency({ asset, amount }) }
     }
 
+    if (operation === 'undelegate') {
+      args = {
+        ...args,
+        ...(await getUndelegateParams({
+          walletAccount,
+          amount: args.amount,
+          delegatorAddress,
+          asset,
+        })),
+      }
+    }
+
+    if (operation === 'claimUndelegatedBalance') {
+      await getClaimUndelegatedParams({
+        asset,
+        delegatorAddress,
+        unbondNonce: args.unbondNonce,
+      })
+    }
+
     const operationTxData = await delegateOperation({ ...args, walletAccount })
     const { fee } = await estimateTxFee({
       from: delegatorAddress,
@@ -443,7 +551,7 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
     feeData,
   } = {}) {
     const { feeAsset } = await getStakeAssets()
-    const sendTxArgs = {
+    const { unsignedTx } = await feeAsset.api.createTx({
       asset: feeAsset,
       walletAccount,
       address: to,
@@ -454,9 +562,9 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
       tipGasPrice,
       waitForConfirmation,
       feeData,
-    }
+    })
 
-    const { txId } = await feeAsset.api.sendTx(sendTxArgs)
+    const { txId } = await feeAsset.api.sendTx({ asset: feeAsset, walletAccount, unsignedTx })
 
     return txId
   }
@@ -536,7 +644,7 @@ async function getUnstakedUnclaimedInfo({
   const { withdrawEpoch, shares } = await stakingServer.getUnboundInfo(delegator, unbondNonce)
   const exchangeRatePrecision = stakingServer.EXCHANGE_RATE_PRECISION
   const isUndelegateInProgress =
-    !withdrawEpoch.isZero() && withdrawEpoch.add(withdrawalDelay).gte(currentEpoch)
+    !withdrawEpoch.isZero() && withdrawEpoch.add(withdrawalDelay).gt(currentEpoch)
   const isUndelegatedBalanceClaimable = canClaimUndelegatedBalance({
     shares,
     withdrawEpoch,

package/src/staking/polygon/staking-utils.js

@@ -1,8 +1,116 @@
+import { getMethodIdFromEthTx, isConfirmedTxInLog, isPendingTxInLog } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
 import { mainnetContracts, methodIds as methodIds_ } from './contracts/index.js'
 import { txFiltersFactory } from './tx-filters/index.js'
 
+// Every ethereum txLog writer stores the nonce at `tx.data.nonce` as an
+// integer (the optimistic outgoing-tx effects, the clarity + monitor-utils
+// server-tx normalisers, and the staking optimistic side-effect builders
+// all converge on this shape). There is no top-level `tx.nonce` field on
+// the Tx model, so we only read from `tx.data.nonce`.
+const getTxNonce = (tx) => (Number.isInteger(tx.data?.nonce) ? tx.data.nonce : undefined)
+
+// Identifies txs sent by our wallet. Every ethereum txLog writer produces
+// `from: []` for an outgoing tx: the optimistic outgoing-tx effects set it
+// explicitly, both server-tx normalisers (clarity-utils and monitor-utils)
+// collapse to `from: []` when `serverTx.from === ourWalletAddress`, and the
+// staking optimistic side-effect builders omit `from` so the Tx constructor
+// defaults it to `[]`. Incoming txs always carry `from: [theirAddress]`. We
+// do not check the element against `ourAddress` because no writer produces
+// `from: [ourAddress]` for an outgoing tx — the empty-array convention is
+// the contract.
+const isOurOutgoingTx = (tx) => Array.isArray(tx.from) && tx.from.length === 0
+
+const isPolygonUndelegateTx = ({ tx, validatorShareAddress, methodIds }) =>
+  tx.to?.toLowerCase() === validatorShareAddress &&
+  getMethodIdFromEthTx(tx, methodIds.UNDELEGATE) === methodIds.UNDELEGATE.toLowerCase()
+
+const decodePendingUndelegateAmount = ({ tx, currency, validatorShareContract }) => {
+  const {
+    values: [pendingUndelegateAmount],
+  } = validatorShareContract.decodeInput(tx.data.data)
+
+  return currency.baseUnit(pendingUndelegateAmount)
+}
+
+export const getPendingUndelegateAmountFromEthereumTxLog = ({
+  ethereumTxLog = [],
+  currency,
+  validatorShareContract,
+  methodIds = methodIds_,
+}) => {
+  const validatorShareAddress = validatorShareContract.address.toLowerCase()
+  const txsByNonce = new Map()
+  let pendingAmount = currency.ZERO
+
+  // Only our own txs can affect our delegated stake, so filter early. Bucket
+  // by nonce alone because all surviving txs share a single sender and only
+  // one tx per nonce can ever mine. The txLog is already scoped to the
+  // active wallet account by assetClientInterface.getTxLog, so within that
+  // scope `from: []` uniquely identifies our outgoing txs.
+  for (const tx of ethereumTxLog ?? []) {
+    if (!(isPendingTxInLog(tx) || isConfirmedTxInLog(tx))) continue
+    if (!isOurOutgoingTx(tx)) continue
+
+    const nonce = getTxNonce(tx)
+    if (!Number.isInteger(nonce)) continue
+
+    const txs = txsByNonce.get(nonce) || []
+    txs.push(tx)
+    txsByNonce.set(nonce, txs)
+  }
+
+  for (const txs of txsByNonce.values()) {
+    // Confirmed same-nonce txs mean the pending attempt can no longer execute.
+    if (txs.some(isConfirmedTxInLog)) continue
+
+    const pendingUndelegateTxs = txs.filter(
+      (tx) =>
+        isPendingTxInLog(tx) && isPolygonUndelegateTx({ tx, validatorShareAddress, methodIds })
+    )
+
+    // If the bucket has no pending undelegate, nothing here can reduce our
+    // stake — whatever else lives at this nonce (a cancel, an unrelated tx)
+    // is someone else's problem.
+    //
+    // If there IS a pending undelegate, reserve it even when it shares the
+    // bucket with a cancel/replacement. The cancel almost always wins
+    // (higher fee is a precondition for tx-acceleration), but in the rare
+    // race where the original undelegate mines first we'd otherwise let the
+    // user broadcast a follow-up unstake that would revert on-chain. The
+    // cost of being conservative is a ~1-block UX delay after a successful
+    // cancel until clarity-monitor evicts the dead undelegate from the
+    // txLog.
+    if (pendingUndelegateTxs.length === 0) continue
+
+    // Reserve the largest decoded amount in the bucket. Same-nonce attempts
+    // are racing for the same on-chain slot, so at most one will mine — but we
+    // don't know which. Picking the max means the preflight stays safe even
+    // if an accelerated/replaced tx somehow carries a larger claim than the
+    // original, and it preserves the known-good amount when one of several
+    // attempts has corrupt input data.
+    let amountForNonce
+
+    for (const tx of pendingUndelegateTxs) {
+      try {
+        const amount = decodePendingUndelegateAmount({ tx, currency, validatorShareContract })
+        if (!amountForNonce || amount.gt(amountForNonce)) {
+          amountForNonce = amount
+        }
+      } catch (err) {
+        console.warn('Could not decode pending Polygon unstake amount', tx.txId, err)
+      }
+    }
+
+    if (!amountForNonce) continue
+
+    pendingAmount = pendingAmount.add(amountForNonce)
+  }
+
+  return pendingAmount
+}
+
 /**
  * Used in ethereum-hooks to extract the final tx amount and the staking type
  *