@exodus/ethereum-plugin 2.30.2 → 2.30.4

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.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)
+
+
+### Bug Fixes
+
+
+* fix: correct `getTokenBalance` eth-like-util (#8047)
+
+
+
 ## [2.30.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.30.1...@exodus/ethereum-plugin@2.30.2) (2026-05-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-plugin",
-  "version": "2.30.2",
+  "version": "2.30.4",
   "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.5",
-    "@exodus/ethereum-lib": "^5.24.0",
+    "@exodus/ethereum-api": "^8.74.1",
+    "@exodus/ethereum-lib": "^5.24.1",
     "@exodus/ethereum-meta": "^2.9.0",
     "@exodus/ethereumjs": "^1.0.0",
     "@exodus/safe-string": "^1.4.0",
@@ -53,5 +53,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "7238e1dc3c4d73cabd4b4a19509de6ee0aa87068"
+  "gitHead": "7f184588091acba3b358e4af13783ee1e2bab4ba"
 }

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,42 @@
 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 +93,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 })
 
@@ -247,7 +373,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 +430,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 +492,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,
@@ -536,7 +682,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
  *