@exodus/ethereum-plugin 3.0.0 → 3.1.1

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.1.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@3.1.0...@exodus/ethereum-plugin@3.1.1) (2026-10-05)
+
+
+### Bug Fixes
+
+* **ethereum-plugin:** require ethereum-api ^10.1.0 for staking exports ([#8859](https://github.com/ExodusMovement/assets/issues/8859)) ([fecb514](https://github.com/ExodusMovement/assets/commit/fecb5140617cd9700ad28541e720c8dfc2bbd46e))
+
+
+
+## [3.1.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@3.0.0...@exodus/ethereum-plugin@3.1.0) (2026-10-05)
+
+
+### Features
+
+* **ethereum:** add evm staking api core with Everstake ETH and polygon adapters ([#8775](https://github.com/ExodusMovement/assets/issues/8775)) ([2d90106](https://github.com/ExodusMovement/assets/commit/2d901069989be82eb56aa253d5171e4f6af97356))
+
+
+
 ## [3.0.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.35.2...@exodus/ethereum-plugin@3.0.0) (2026-10-05)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-plugin",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "description": "Ethereum plugin for Exodus SDK powered wallets",
   "type": "module",
   "main": "src/index.js",
@@ -22,7 +22,7 @@
     "@exodus/asset-lib": "^5.9.2",
     "@exodus/basic-utils": "^3.0.1",
     "@exodus/currency": "^6.0.1",
-    "@exodus/ethereum-api": "^10.0.0",
+    "@exodus/ethereum-api": "^10.1.0",
     "@exodus/ethereum-lib": "^5.25.0",
     "@exodus/ethereum-meta": "^2.9.0",
     "@exodus/ethereumjs": "^1.0.0",
@@ -36,10 +36,10 @@
     "@exodus/assets": "^11.4.0",
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/crypto": "^1.0.0-rc.13",
-    "@exodus/evm-fork-testing": "^0.7.2",
+    "@exodus/evm-fork-testing": "^0.7.3",
     "@exodus/models": "^13.0.0",
     "@exodus/solidity-contract": "^1.3.0",
-    "@exodus/web3-ethereum-utils": "^5.0.1",
+    "@exodus/web3-ethereum-utils": "^5.0.2",
     "delay": "^4.0.1",
     "ms": "^2.1.1"
   },
@@ -51,5 +51,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "83a0e678debb92fbfcefd92e7bd0453d1a92136b"
+  "gitHead": "a7072c68dd2d7254a2670e0eea6a48660751a585"
 }

package/src/staking/polygon/index.js

@@ -4,6 +4,7 @@ import { stakingAccountState } from './account-state.js'
 import { stakingServerFactory } from './api.js'
 import { mainnetContracts, methodIds } from './contracts/index.js'
 import { stakingServiceFactory } from './service.js'
+import { createPolygonStakingAdapter } from './staking-adapter.js'
 import { txUtilsFactory } from './staking-utils.js'
 
 const polygon = tokens.find(({ name: tokenName }) => tokenName === 'polygon')
@@ -30,4 +31,6 @@ export const polygonStakingDeps = {
   txUtilsFactory,
   stakingServiceFactory,
   stakingServerFactory,
+  createStakingAdapter: ({ service }) => createPolygonStakingAdapter({ service }),
+  stakingApiEnabled: false,
 }

package/src/staking/polygon/service.js

@@ -1,11 +1,14 @@
 import { memoize } from '@exodus/basic-utils'
 import NumberUnit, { isNumberUnit } from '@exodus/currency'
 import {
+  createStakingTxs,
   estimateGasLimit,
   EthLikeError,
   EVM_ERROR_TYPES,
   getAggregateTransactionPricing,
   scaleGasLimitEstimate,
+  sendStakingTxs,
+  STAKING_TX_MODE,
   stakingProviderClientFactory,
 } from '@exodus/ethereum-api'
 import { safeString } from '@exodus/safe-string'
@@ -189,7 +192,48 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
     }
   }
 
-  async function approveDelegateAmount({ walletAccount, amount, feeData } = {}) {
+  const planSingleTx = async ({ delegatorAddress, to, txInput, feeData }) => {
+    const { feeAsset } = await getStakeAssets()
+    const { gasPrice, gasLimit, tipGasPrice, fee } = await estimateTxFee({
+      from: delegatorAddress,
+      to,
+      txInput,
+      feeData,
+    })
+
+    return {
+      asset: feeAsset,
+      delegatorAddress,
+      fee,
+      feeData,
+      gasPrice,
+      tipGasPrice,
+      steps: [{ to, txInput, gasLimit }],
+      mode: STAKING_TX_MODE.single,
+    }
+  }
+
+  const sendPlan = async ({ walletAccount, plan }) => {
+    const createdTxs = await createStakingTxs({
+      asset: plan.asset,
+      walletAccount,
+      fromAddress: plan.delegatorAddress,
+      steps: plan.steps,
+      mode: plan.mode,
+      gasPrice: plan.gasPrice,
+      tipGasPrice: plan.tipGasPrice,
+      feeData: plan.feeData,
+    })
+    const { txIds } = await sendStakingTxs({
+      asset: plan.asset,
+      walletAccount,
+      unsignedTxs: createdTxs.map(({ unsignedTx }) => unsignedTx),
+      mode: plan.mode,
+    })
+    return txIds[txIds.length - 1]
+  }
+
+  async function planApproveDelegateAmount({ walletAccount, amount, feeData } = {}) {
     feeData = await resolveOptionalFeeData({ feeData })
 
     const [delegatorAddress, { asset }] = await Promise.all([
@@ -199,34 +243,20 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
 
     amount = amountToCurrency({ asset, amount })
 
-    const txApproveData = await stakingServer.approveStakeManager(amount)
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
+    return planSingleTx({
+      delegatorAddress,
       to: stakingServer.polygonContract.address,
-      txInput: txApproveData,
+      txInput: await stakingServer.approveStakeManager(amount),
       feeData,
     })
+  }
 
-    return prepareAndSendTx({
-      walletAccount,
-      waitForConfirmation: true,
-      to: stakingServer.polygonContract.address,
-      txData: txApproveData,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
-      feeData,
-    })
+  async function approveDelegateAmount(params) {
+    const plan = await planApproveDelegateAmount(params)
+    return sendPlan({ walletAccount: params.walletAccount, plan })
   }
 
-  /**
-   * Delegate MATIC tokens for staking.
-   * @param {walletAccount} params.walletAccount - The walletAccount for the delegator (required).
-   * @param {NumberUnit} params.amount - The amount of MATIC to delegate (required).
-   * @param {FeeData} params.feeData - Optional feeData to use for the transaction (optional, if not provided will be obtained from the asset client interface).
-   * @param {Boolean} params.revertOnSimulationError - Optional boolean to revert on simulation error (optional, default is true). Allows us to quickly react to simulator issues.
-   */
-  async function delegate({ walletAccount, amount, feeData, revertOnSimulationError = true } = {}) {
+  async function planDelegate({ walletAccount, amount, feeData } = {}) {
     const [delegatorAddress, { asset, feeAsset }, resolvedFeeData] = await Promise.all([
       getDelegatorAddress({ walletAccount }),
       getStakeAssets(),
@@ -237,12 +267,6 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
 
     amount = amountToCurrency({ asset, amount })
 
-    const baseNonce = await feeAsset.getNonce({
-      asset: feeAsset,
-      fromAddress: delegatorAddress.toString(),
-      walletAccount,
-    })
-
     const [txApproveData, txDelegateData] = await Promise.all([
       stakingServer.approveStakeManager(amount),
       stakingServer.delegate({ amount }),
@@ -264,66 +288,83 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
       feeData,
     })
 
-    const createTxBaseArgs = {
+    return {
       asset: feeAsset,
-      walletAccount,
-      fromAddress: delegatorAddress.toString(),
-      amount: feeAsset.currency.ZERO,
-      tipGasPrice,
+      stakeAsset: asset,
+      delegatorAddress: delegatorAddress.toString(),
+      amount,
+      fee: gasPrice.mul(approveGasLimit).add(gasPrice.mul(estimatedDelegateGasLimit)),
+      feeData,
       gasPrice,
+      tipGasPrice,
+      steps: [
+        {
+          to: stakingServer.polygonContract.address,
+          txInput: txApproveData,
+          gasLimit: approveGasLimit,
+        },
+        {
+          to: stakingServer.validatorShareContract.address,
+          txInput: txDelegateData,
+          gasLimit: estimatedDelegateGasLimit,
+        },
+      ],
+      mode: STAKING_TX_MODE.bundle,
     }
-    const [unsignedTxApprove, unsignedTxDelegate] = await Promise.all([
-      feeAsset.api.createTx({
-        ...createTxBaseArgs,
-        toAddress: stakingServer.polygonContract.address,
-        txInput: txApproveData,
-        gasLimit: approveGasLimit,
-        nonce: baseNonce,
-      }),
-      feeAsset.api.createTx({
-        ...createTxBaseArgs,
-        toAddress: stakingServer.validatorShareContract.address,
-        txInput: txDelegateData,
-        gasLimit: estimatedDelegateGasLimit,
-        nonce: baseNonce + 1,
-      }),
-    ])
+  }
 
+  async function simulateDelegate({ plan, createdTxs, revertOnSimulationError = true }) {
+    const [unsignedTxApprove, unsignedTxDelegate] = createdTxs
     await maticDelegateSimulateTransactions({
-      asset,
+      asset: plan.stakeAsset,
       unsignedTxApprove,
       unsignedTxDelegate,
-      senderAddress: delegatorAddress.toString(),
+      senderAddress: plan.delegatorAddress,
       revertOnSimulationError,
     })
+  }
 
-    const { txIds } = await asset.baseAsset.sendPrivateBundle({
-      unsignedTxBundle: [
-        {
-          asset: feeAsset,
-          unsignedTx: unsignedTxApprove.unsignedTx,
-          walletAccount,
-        },
-        {
-          asset: feeAsset,
-          unsignedTx: unsignedTxDelegate.unsignedTx,
-          walletAccount,
-        },
-      ],
+  /**
+   * Delegate MATIC tokens for staking.
+   * @param {walletAccount} params.walletAccount - The walletAccount for the delegator (required).
+   * @param {NumberUnit} params.amount - The amount of MATIC to delegate (required).
+   * @param {FeeData} params.feeData - Optional feeData to use for the transaction (optional, if not provided will be obtained from the asset client interface).
+   * @param {Boolean} params.revertOnSimulationError - Optional boolean to revert on simulation error (optional, default is true). Allows us to quickly react to simulator issues.
+   */
+  async function delegate({ walletAccount, amount, feeData, revertOnSimulationError = true } = {}) {
+    const plan = await planDelegate({ walletAccount, amount, feeData })
+    const createdTxs = await createStakingTxs({
+      asset: plan.asset,
+      walletAccount,
+      fromAddress: plan.delegatorAddress,
+      steps: plan.steps,
+      mode: plan.mode,
+      gasPrice: plan.gasPrice,
+      tipGasPrice: plan.tipGasPrice,
+    })
+
+    await simulateDelegate({ plan, createdTxs, revertOnSimulationError })
+
+    const unsignedTxs = createdTxs.map(({ unsignedTx }) => unsignedTx)
+    const { txIds } = await sendStakingTxs({
+      asset: plan.asset,
+      walletAccount,
+      unsignedTxs,
+      mode: plan.mode,
     })
 
     const delegateTxId = txIds[txIds.length - 1]
 
     await stakingProvider.notifyStaking({
       txId: delegateTxId,
-      asset: asset.name,
-      delegator: delegatorAddress,
-      amount: amount.toBaseString(),
+      asset: plan.stakeAsset.name,
+      delegator: plan.delegatorAddress,
+      amount: plan.amount.toBaseString(),
     })
     return delegateTxId
   }
 
-  async function undelegate({ walletAccount, amount, feeData, waitForConfirmation = false } = {}) {
+  async function planUndelegate({ walletAccount, amount, feeData } = {}) {
     feeData = await resolveOptionalFeeData({ feeData })
 
     const [delegatorAddress, { asset }] = await Promise.all([
@@ -340,49 +381,39 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
       asset,
     })
 
-    const txUndelegateData = await stakingServer.undelegate(undelegateParams)
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress.toLowerCase(),
-      to: stakingServer.validatorShareContract.address,
-      txInput: txUndelegateData,
-      feeData,
-    })
-    return prepareAndSendTx({
-      walletAccount,
+    const plan = await planSingleTx({
+      delegatorAddress: delegatorAddress.toLowerCase(),
       to: stakingServer.validatorShareContract.address,
-      txData: txUndelegateData,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
-      waitForConfirmation,
+      txInput: await stakingServer.undelegate(undelegateParams),
       feeData,
     })
+    return { ...plan, amount }
   }
 
-  async function claimRewards({ walletAccount, feeData } = {}) {
+  async function undelegate(params = {}) {
+    const plan = await planUndelegate(params)
+    return sendPlan({ walletAccount: params.walletAccount, plan })
+  }
+
+  async function planClaimRewards({ walletAccount, feeData } = {}) {
     feeData = await resolveOptionalFeeData({ feeData })
 
     const delegatorAddress = await getDelegatorAddress({ walletAccount })
 
-    const txWithdrawRewardsData = await stakingServer.withdrawRewards()
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingServer.validatorShareContract.address,
-      txInput: txWithdrawRewardsData,
-      feeData,
-    })
-    return prepareAndSendTx({
-      walletAccount,
+    return planSingleTx({
+      delegatorAddress,
       to: stakingServer.validatorShareContract.address,
-      txData: txWithdrawRewardsData,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
+      txInput: await stakingServer.withdrawRewards(),
       feeData,
     })
   }
 
-  async function claimUndelegatedBalance({ walletAccount, unbondNonce, feeData } = {}) {
+  async function claimRewards(params = {}) {
+    const plan = await planClaimRewards(params)
+    return sendPlan({ walletAccount: params.walletAccount, plan })
+  }
+
+  async function planClaimUndelegatedBalance({ walletAccount, unbondNonce, feeData } = {}) {
     feeData = await resolveOptionalFeeData({ feeData })
 
     const [delegatorAddress, { asset }] = await Promise.all([
@@ -396,28 +427,24 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
       unbondNonce,
     })
 
-    const txClaimUndelegatedData = await stakingServer.claimUndelegatedBalance({ unbondNonce })
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingServer.validatorShareContract.address,
-      txInput: txClaimUndelegatedData,
-      feeData,
-    })
-    const txId = await prepareAndSendTx({
-      walletAccount,
+    const plan = await planSingleTx({
+      delegatorAddress,
       to: stakingServer.validatorShareContract.address,
-      txData: txClaimUndelegatedData,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
+      txInput: await stakingServer.claimUndelegatedBalance({ unbondNonce }),
       feeData,
     })
+    return { ...plan, amount: unclaimedUndelegatedBalance, stakeAsset: asset }
+  }
+
+  async function claimUndelegatedBalance(params = {}) {
+    const plan = await planClaimUndelegatedBalance(params)
+    const txId = await sendPlan({ walletAccount: params.walletAccount, plan })
 
     await stakingProvider.notifyUnstaking({
       txId,
-      asset: asset.name,
-      delegator: delegatorAddress,
-      amount: unclaimedUndelegatedBalance.toBaseString(),
+      asset: plan.stakeAsset.name,
+      delegator: plan.delegatorAddress,
+      amount: plan.amount.toBaseString(),
     })
 
     return txId
@@ -538,46 +565,21 @@ export function stakingServiceFactory({ assetClientInterface, server: _server, s
     return { ...fee, gasLimit }
   }
 
-  async function prepareAndSendTx({
-    walletAccount,
-    to,
-    txData: txInput,
-    gasPrice,
-    gasLimit,
-    tipGasPrice,
-    waitForConfirmation = false,
-    feeData,
-  } = {}) {
-    const { feeAsset } = await getStakeAssets()
-    const { unsignedTx } = await feeAsset.api.createTx({
-      asset: feeAsset,
-      walletAccount,
-      address: to,
-      amount: feeAsset.currency.ZERO,
-      txInput,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
-      waitForConfirmation,
-      feeData,
-    })
-
-    const { txId } = await feeAsset.api.sendTx({ asset: feeAsset, walletAccount, unsignedTx })
-
-    return txId
-  }
-
   const getStakingInfo = getPolygonStakingInfo({ assetClientInterface, stakingServer })
 
   return {
-    // Unified API (used by stakingApiFactory when exposed on asset.api.staking)
+    planDelegate,
+    simulateDelegate,
+    planUndelegate,
+    planClaimRewards,
+    planClaimUndelegatedBalance,
+    getStakingInfo,
+    // @deprecated legacy staking api, remove once evm staking unification is done
     approveStake: approveDelegateAmount,
     stake: delegate,
     unstake: undelegate,
     claimUnstaked: claimUndelegatedBalance,
     claimRewards,
-    getStakingInfo,
-    // Legacy names (for direct service usage)
     approveDelegateAmount,
     delegate,
     undelegate,

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

@@ -0,0 +1,394 @@
+import {
+  createStakingRejectionError,
+  failStakingCheck as fail,
+  isPendingPolygonUndelegateTxInEthereumTxLog,
+  isPolygonClaimUndelegate,
+  isPolygonDelegate,
+  isPolygonReward,
+  isPolygonTx,
+  isPolygonUndelegate,
+  isPolygonUndelegateTxInEthereumTxLog,
+  passStakingCheck as pass,
+  stakingProviderClientFactory,
+  sumStakingOperationFees as sumOperationFees,
+  warnIfStakingBalanceBelow as warnIfBelow,
+} from '@exodus/ethereum-api'
+import { getMethodIdFromEthTx } from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
+
+import { mainnetContracts, methodIds } from './contracts/index.js'
+import { POLYGON_STAKING_PREFLIGHT_ERROR_REASONS } from './service.js'
+
+export const POL_STAKING_GAS_LIMITS = Object.freeze({
+  stake: 430_000,
+  unstake: 450_000,
+  claimUnstaked: 350_000,
+  claimRewards: 350_000,
+})
+
+const POL_UNBONDING_MS = 4 * 24 * 60 * 60 * 1000
+const VALIDATOR_NAME = 'Everstake'
+const DEFAULT_MIN_AMOUNT = '1'
+
+const REASON_CODE_BY_PREFLIGHT_REASON = new Map([
+  [
+    POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeAmountInvalid.reason,
+    'UNSTAKE_BELOW_MINIMUM',
+  ],
+  [
+    POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeAmountUnavailable.reason,
+    'UNSTAKE_EXCEEDS_STAKED',
+  ],
+  [
+    POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeClaimNonceInvalid.reason,
+    'NOTHING_TO_CLAIM',
+  ],
+  [
+    POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeClaimUnavailable.reason,
+    'NOTHING_TO_CLAIM',
+  ],
+  [
+    POLYGON_STAKING_PREFLIGHT_ERROR_REASONS.polygonUnstakeClaimNotReady.reason,
+    'UNBONDING_IN_PROGRESS',
+  ],
+])
+
+const OPERATION_BY_VALIDATOR_METHOD_ID = new Map([
+  [methodIds.DELEGATE, 'stake'],
+  [methodIds.UNDELEGATE, 'unstake'],
+  [methodIds.CLAIM_UNDELEGATE, 'claimUnstaked'],
+  [methodIds.CLAIM_REWARD, 'claimRewards'],
+])
+
+const toAmount = (asset, value) =>
+  typeof value === 'string' ? asset.currency.defaultUnit(value) : undefined
+
+const isUnstakeTx = (tx) => Boolean(tx.data?.undelegate) || isPolygonUndelegate(tx)
+
+const getLatestTxTime = (txLogs, matches) => {
+  let latest
+  for (const txLog of txLogs) {
+    for (const tx of txLog ?? []) {
+      if (!matches(tx)) continue
+      const time = new Date(tx.date).getTime()
+      if (latest === undefined || time > latest) latest = time
+    }
+  }
+
+  return latest
+}
+
+const resolveUnstakeAmount = ({ state, intent }) =>
+  intent.isMax ? state.balances.staked : intent.amount
+
+export const createPolygonStakingAdapter = ({
+  service,
+  validatorAddress = mainnetContracts.VALIDATOR_SHARES_CONTRACT_ADDR,
+  stakingProvider = stakingProviderClientFactory(),
+}) => {
+  assert(service, '`service` required')
+
+  const target = { kind: 'validator', id: validatorAddress.toLowerCase(), name: VALIDATOR_NAME }
+
+  const getCapabilities = ({ asset }) => ({
+    participation: 'amount',
+    liquid: false,
+    positions: 'aggregate',
+    operations: {
+      stake: { amount: 'required', supportsMax: true, positionSelectable: false, multiTx: true },
+      unstake: { amount: 'required', supportsMax: true, positionSelectable: false, multiTx: false },
+      claimUnstaked: {
+        amount: 'none',
+        supportsMax: false,
+        positionSelectable: false,
+        multiTx: false,
+      },
+      claimRewards: {
+        amount: 'none',
+        supportsMax: false,
+        positionSelectable: false,
+        multiTx: false,
+      },
+    },
+    target: { kind: 'validator', selection: 'fixed', default: target },
+    unbonding: { kind: 'epoch', approxDurationMs: POL_UNBONDING_MS },
+    claimUnstaked: 'manual',
+    rewards: { distribution: 'claimable' },
+    feeAssetName: asset.feeAsset.name,
+    maxPositions: 1,
+    hardwareWallets: ['ledger'],
+  })
+
+  const toPositions = ({ balances, info, txLog, feeAssetTxLog }) => {
+    const unstakedAt = getLatestTxTime(
+      [txLog, feeAssetTxLog],
+      (tx) => isUnstakeTx(tx) || isPolygonUndelegateTxInEthereumTxLog(tx)
+    )
+    const unbondId = `unbond-${info.unbondNonce ?? 0}`
+    const position = (id, status, amount, availableAt) =>
+      amount.isPositive ? [{ id, status, amount, target, ...(availableAt && { availableAt }) }] : []
+
+    return [
+      ...position('active', 'active', balances.staked),
+      ...position(
+        unbondId,
+        'deactivating',
+        balances.unstaking,
+        unstakedAt === undefined ? undefined : unstakedAt + POL_UNBONDING_MS
+      ),
+      ...position(unbondId, 'withdrawable', balances.unstaked),
+    ]
+  }
+
+  const readState = ({ asset, accountState, txLog, feeAssetTxLog }) => {
+    const { currency } = asset
+    const zero = currency.ZERO
+    const info = accountState.staking?.[asset.name] || {}
+    const loaded = Boolean(accountState.stakingSnapshotOwners?.[asset.name])
+    const balances = asset.api.getBalances({ asset, accountState, txLog })
+    const { feeAsset } = asset
+    const feeBalance = feeAssetTxLog
+      ? feeAsset.api.getBalances({ asset: feeAsset, accountState, txLog: feeAssetTxLog }).spendable
+      : undefined
+    const hasPendingUndelegate = [...(feeAssetTxLog ?? [])].some((tx) =>
+      isPendingPolygonUndelegateTxInEthereumTxLog(tx)
+    )
+    const liquidRewards = info.liquidRewards || zero
+    const { staking, staked, unstaking, unstaked } = balances
+
+    return {
+      loaded,
+      isStaking: staked.isPositive,
+      hasPosition: [staked, unstaking, unstaked, liquidRewards].some((amount) => amount.isPositive),
+      totals: { staking, staked, unstaking, unstaked, rewards: liquidRewards },
+      ...(loaded && info.rewardsBalance && { earned: info.rewardsBalance }),
+      positions: toPositions({ balances, info, txLog, feeAssetTxLog }),
+      target,
+      ...(hasPendingUndelegate && { pendingOperation: 'unstake' }),
+      balances,
+      feeBalance,
+      minAmount: info.minDelegateAmount || currency.defaultUnit(DEFAULT_MIN_AMOUNT),
+      minRewardsToWithdraw: info.minRewardsToWithdraw || currency.defaultUnit(DEFAULT_MIN_AMOUNT),
+      liquidRewards,
+      unbondNonce: Number(info.unbondNonce || 0),
+      isUndelegateInProgress: Boolean(info.isUndelegateInProgress),
+      canClaimUndelegatedBalance: Boolean(info.canClaimUndelegatedBalance),
+      unclaimedUndelegatedBalance: info.unclaimedUndelegatedBalance || zero,
+    }
+  }
+
+  const getGasLimit = ({ operation }) => POL_STAKING_GAS_LIMITS[operation]
+
+  const getLimits = ({ operation, state }) => {
+    switch (operation) {
+      case 'stake':
+        return { min: state.minAmount, max: state.balances.spendable }
+      case 'unstake':
+        return { max: state.balances.staked }
+      case 'claimUnstaked':
+        return { max: state.balances.unstaked }
+      case 'claimRewards':
+        return { min: state.minRewardsToWithdraw, max: state.liquidRewards }
+    }
+  }
+
+  const checkFee = ({ asset, state, fee }) =>
+    fee && state.feeBalance && state.feeBalance.lt(fee)
+      ? fail('INSUFFICIENT_FEE_BALANCE', fee.sub(state.feeBalance), asset.feeAsset.name)
+      : pass()
+
+  const warnLaterFee = ({ state, fee, estimateOperationFee, operations, warning }) =>
+    warnIfBelow({
+      balance: state.feeBalance && fee && state.feeBalance.sub(fee),
+      required: sumOperationFees({ estimateOperationFee, operations }),
+      warning,
+    })
+
+  const checkStake = ({ asset, intent, state, fee, estimateOperationFee }) => {
+    const { spendable } = state.balances
+    const amount = intent.isMax ? spendable : intent.amount
+    if (!amount || amount.lt(state.minAmount)) {
+      return fail('BELOW_MINIMUM', state.minAmount.sub(amount ?? asset.currency.ZERO), asset.name)
+    }
+
+    if (spendable.lt(amount)) return fail('INSUFFICIENT_BALANCE', amount.sub(spendable), asset.name)
+    const feeCheck = checkFee({ asset, state, fee })
+    if (!feeCheck.ok) return feeCheck
+
+    return warnLaterFee({
+      state,
+      fee,
+      estimateOperationFee,
+      operations: ['unstake', 'claimUnstaked'],
+      warning: 'LOW_FEE_BALANCE',
+    })
+  }
+
+  const checkUnstake = ({ asset, intent, state, fee, estimateOperationFee }) => {
+    const { staked } = state.balances
+    if (!staked.isPositive) return fail('NOTHING_TO_UNSTAKE')
+    if (state.isUndelegateInProgress || state.unclaimedUndelegatedBalance.isPositive) {
+      return fail('MAX_POSITIONS_REACHED')
+    }
+
+    const amount = resolveUnstakeAmount({ state, intent })
+    if (!amount?.isPositive) return fail('UNSTAKE_BELOW_MINIMUM')
+    if (amount.gt(staked)) return fail('UNSTAKE_EXCEEDS_STAKED', amount.sub(staked), asset.name)
+    const feeCheck = checkFee({ asset, state, fee })
+    if (!feeCheck.ok) return feeCheck
+
+    return warnLaterFee({
+      state,
+      fee,
+      estimateOperationFee,
+      operations: ['claimUnstaked'],
+      warning: 'LOW_FEE_BALANCE_FOR_CLAIM',
+    })
+  }
+
+  const checkClaimUnstaked = ({ asset, state, fee }) => {
+    if (!state.unclaimedUndelegatedBalance.isPositive) return fail('NOTHING_TO_CLAIM')
+    if (!state.canClaimUndelegatedBalance) return fail('UNBONDING_IN_PROGRESS')
+    return checkFee({ asset, state, fee })
+  }
+
+  const checkClaimRewards = ({ asset, state, fee }) => {
+    const { liquidRewards, minRewardsToWithdraw } = state
+    if (!liquidRewards.isPositive) return fail('NO_REWARDS_TO_CLAIM')
+    if (liquidRewards.lt(minRewardsToWithdraw)) {
+      return fail('REWARDS_BELOW_MINIMUM', minRewardsToWithdraw.sub(liquidRewards), asset.name)
+    }
+
+    return checkFee({ asset, state, fee })
+  }
+
+  const CHECKS = {
+    stake: checkStake,
+    unstake: checkUnstake,
+    claimUnstaked: checkClaimUnstaked,
+    claimRewards: checkClaimRewards,
+  }
+
+  const checkOperation = ({ asset, operation, intent, state, fee, estimateOperationFee }) =>
+    CHECKS[operation]?.({ asset, intent, state, fee, estimateOperationFee }) ??
+    fail('OPERATION_UNSUPPORTED')
+
+  const planOperation = ({ walletAccount, operation, intent, state, feeData }) => {
+    switch (operation) {
+      case 'stake':
+        return service.planDelegate({
+          walletAccount,
+          amount: intent.isMax ? state.balances.spendable : intent.amount,
+          feeData,
+        })
+      case 'unstake':
+        return service.planUndelegate({
+          walletAccount,
+          amount: resolveUnstakeAmount({ state, intent }),
+          feeData,
+        })
+      case 'claimUnstaked':
+        return service.planClaimUndelegatedBalance({
+          walletAccount,
+          unbondNonce: state.unbondNonce,
+          feeData,
+        })
+      case 'claimRewards':
+        return service
+          .planClaimRewards({ walletAccount, feeData })
+          .then((plan) => ({ ...plan, amount: state.liquidRewards }))
+      default:
+        throw new Error(`Unsupported polygon staking operation: ${operation}`)
+    }
+  }
+
+  const toRejection = ({ operation, error }) => {
+    const reasonCode = REASON_CODE_BY_PREFLIGHT_REASON.get(error.reason)
+    if (!reasonCode) return error
+    return createStakingRejectionError({ operation, check: fail(reasonCode) })
+  }
+
+  const buildSteps = async ({ asset, walletAccount, operation, intent, state, feeData }) => {
+    let plan
+    try {
+      plan = await planOperation({ walletAccount, operation, intent, state, feeData })
+    } catch (error) {
+      throw toRejection({ operation, error })
+    }
+
+    const check = checkFee({ asset, state, fee: plan.fee })
+    if (!check.ok) throw createStakingRejectionError({ operation, check })
+    return plan
+  }
+
+  const simulate = async ({ operation, built, createdTxs }) => {
+    if (operation !== 'stake') return
+    await service.simulateDelegate({ plan: built, createdTxs })
+  }
+
+  const notify = async ({ asset, plan, txIds, delegator }) => {
+    if (plan.operation === 'stake') {
+      await stakingProvider.notifyStaking({
+        txId: txIds[txIds.length - 1],
+        asset: asset.name,
+        delegator,
+        amount: plan.amount.toBaseString(),
+      })
+      return
+    }
+
+    if (plan.operation !== 'claimUnstaked') return
+    await stakingProvider.notifyUnstaking({
+      txId: txIds[0],
+      asset: asset.name,
+      delegator,
+      amount: plan.amount.toBaseString(),
+    })
+  }
+
+  const classifyValidatorCall = ({ tx }) => {
+    if (tx.to?.toLowerCase() !== target.id) return
+
+    const operation = OPERATION_BY_VALIDATOR_METHOD_ID.get(
+      getMethodIdFromEthTx(tx, methodIds.DELEGATE)
+    )
+    if (!operation) return
+
+    const amount = operation === 'stake' && isPolygonTx(tx) ? tx.coinAmount?.abs() : undefined
+    return { operation, ...(amount?.isPositive && { amount }) }
+  }
+
+  const classifyPolygonTx = ({ asset, tx }) => {
+    const data = tx.data || {}
+    const withAmount = (operation, amount) => ({ operation, ...(amount && { amount }) })
+
+    if (typeof data.delegate === 'string' || isPolygonDelegate(tx)) {
+      return withAmount('stake', toAmount(asset, data.delegate))
+    }
+
+    if (isUnstakeTx(tx)) return withAmount('unstake', toAmount(asset, data.undelegate))
+
+    if (typeof data.claimUndelegate === 'string' || isPolygonClaimUndelegate(tx)) {
+      return withAmount('claimUnstaked', toAmount(asset, data.claimUndelegate))
+    }
+
+    if (isPolygonReward(tx)) return withAmount('claimRewards', tx.coinAmount?.abs())
+  }
+
+  const classifyTx = ({ asset, tx }) => {
+    if (isPolygonTx(tx)) return classifyPolygonTx({ asset, tx }) ?? classifyValidatorCall({ tx })
+    if (tx.coinName === asset.baseAsset.name) return classifyValidatorCall({ tx })
+  }
+
+  return {
+    getCapabilities,
+    readState,
+    getGasLimit,
+    getLimits,
+    checkOperation,
+    buildSteps,
+    simulate,
+    notify,
+    classifyTx,
+  }
+}