@exodus/ethereum-plugin 2.23.0 → 2.23.1

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.23.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.23.0...@exodus/ethereum-plugin@2.23.1) (2026-02-09)
+
+
+### Bug Fixes
+
+
+* fix: monitors should check rpc before dropping (#7277)
+
+
+
 ## [2.23.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.22.0...@exodus/ethereum-plugin@2.23.0) (2026-01-14)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-plugin",
-  "version": "2.23.0",
+  "version": "2.23.1",
   "description": "Ethereum plugin for Exodus SDK powered wallets",
   "type": "module",
   "main": "src/index.js",
@@ -21,8 +21,9 @@
     "lint:fix": "yarn lint --fix"
   },
   "dependencies": {
+    "@exodus/basic-utils": "^3.0.1",
     "@exodus/currency": "^6.0.1",
-    "@exodus/ethereum-api": "^8.64.0",
+    "@exodus/ethereum-api": "^8.64.4",
     "@exodus/ethereum-lib": "^5.21.0",
     "@exodus/ethereum-meta": "^2.9.0",
     "@exodus/ethereumjs": "^1.0.0",
@@ -33,11 +34,10 @@
   "devDependencies": {
     "@exodus/assets": "^11.4.0",
     "@exodus/assets-testing": "^1.0.0",
-    "@exodus/basic-utils": "^3.0.1",
     "@exodus/crypto": "^1.0.0-rc.13",
     "@exodus/evm-fork-testing": "^0.4.0",
     "@exodus/models": "^12.13.0",
-    "@exodus/web3-ethereum-utils": "^4.7.1",
+    "@exodus/web3-ethereum-utils": "^4.7.2",
     "delay": "^4.0.1",
     "ms": "^2.1.1"
   },
@@ -49,5 +49,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "11f40d9da07e1e70a4e07f94defa3042c6fb21cc"
+  "gitHead": "ebcc3fe022dfc1e21e3ccdc00faf0769e8fb3092"
 }

package/src/staking/polygon/api.js

@@ -115,6 +115,30 @@ class StakingServer {
     return this.asset.currency.baseUnit(liquidRewards)
   }
 
+  getTotalRewards = async (address) => {
+    // use external everstake API to get total rewards
+    const EVERSTAKE_API_URL = 'https://polygon-clarity.a.exodus.io/everstake-rewards'
+    const url = new URL(EVERSTAKE_API_URL)
+
+    const options = {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        address,
+      }),
+    }
+
+    try {
+      const response = await fetch(url.toString(), options)
+      const res = await response.json()
+      if (res === 'address' || !res?.rewards) return this.asset.currency.ZERO // address not found
+      return this.asset.currency.baseUnit(res.rewards)
+    } catch (error) {
+      console.warn('Error fetching Polygon total rewards:', error)
+      return this.asset.currency.ZERO
+    }
+  }
+
   getTotalStake = async (address) => {
     const stakeInfo = await this.#callReadFunctionContract(
       this.validatorShareContract,
@@ -182,5 +206,5 @@ class StakingServer {
   }
 }
 
-export const stakingServerFactory = ({ asset, contracts, server }) =>
-  new StakingServer({ asset, contracts, server })
+export const stakingServerFactory = ({ assetName, currency, contracts, server }) =>
+  new StakingServer({ asset: { name: assetName, currency }, contracts, server })

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

@@ -0,0 +1,107 @@
+import NumberUnit from '@exodus/currency'
+import { parseUnsignedTx } from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
+
+// Build simulation transaction requests from unsigned transactions
+export function createMaticStakeSimRequestsFromUnsigned({
+  asset,
+  unsignedTxApprove,
+  unsignedTxDelegate,
+}) {
+  const build = (tx) => {
+    const parsed = parseUnsignedTx({ asset, unsignedTx: tx.unsignedTx })
+    const gasPriceUnit = tx.gasPrice
+    const chainId = tx.unsignedTx?.txData?.chainId
+    const from = tx.unsignedTx?.txMeta?.fromAddress
+    const to = tx.unsignedTx?.txMeta?.toAddress
+
+    assert(gasPriceUnit instanceof NumberUnit, 'expected NumberUnit gasPrice')
+    assert(Number.isInteger(chainId), 'expected integer chainId')
+    assert(typeof from === 'string' && from, 'expected string fromAddress')
+    assert(typeof to === 'string' && to, 'expected string toAddress')
+
+    return {
+      chainId,
+      from,
+      to,
+      gas: `0x${parsed.gasLimit.toString(16)}`,
+      gasPrice: `0x${BigInt(gasPriceUnit.toBaseString()).toString(16)}`,
+      value: '0x0',
+      data: `0x${parsed.data?.toString('hex')}`,
+      nonce: `0x${parsed.nonce.toString(16)}`,
+    }
+  }
+
+  return {
+    approveTxRequest: build(unsignedTxApprove),
+    delegateTxRequest: build(unsignedTxDelegate),
+  }
+}
+
+export async function maticDelegateSimulateTransactions({
+  asset,
+  unsignedTxApprove,
+  unsignedTxDelegate,
+  senderAddress,
+  revertOnSimulationError,
+}) {
+  const { approveTxRequest, delegateTxRequest } = createMaticStakeSimRequestsFromUnsigned({
+    asset: asset.baseAsset,
+    unsignedTxApprove,
+    unsignedTxDelegate,
+  })
+
+  // Simulate transactions
+  const simulationTxData = {
+    baseAssetName: asset.baseAsset.name,
+    origin: 'exodus-staking',
+    senderAddress,
+  }
+
+  const simulationResponse = await asset.baseAsset.api.web3.simulateTransactions({
+    ...simulationTxData,
+    transactions: [approveTxRequest, delegateTxRequest],
+  })
+  // These checks are only for simulation issues, not validation of the transactions
+  if (simulationResponse?.warnings?.length || simulationResponse?.metadata?.humanReadableError) {
+    if (revertOnSimulationError) {
+      const err = new Error('StakingMaticSimulationError')
+      err.message = simulationResponse?.metadata?.humanReadableError
+      err.reason = `warnings: ${simulationResponse.warnings.join(', ')}`
+      err.hint = 'delegate-matic-simulation-error'
+      throw err
+    } else {
+      console.warn(
+        'Simulation for staking matic returned issues',
+        simulationResponse?.metadata?.humanReadableError
+      )
+    }
+  }
+
+  // For validation of the transactions, we need to check if the simulation produced the expected effects
+  // hasApprove, hasSend, hasReceive entries must be present
+  const { balanceChanges = Object.create(null) } = simulationResponse || Object.create(null)
+  const asArray = (v) => (Array.isArray(v) ? v : [])
+  const hasApprove = asArray(balanceChanges.willApprove).length > 0
+  const hasSend = asArray(balanceChanges.willSend).length > 0
+  const hasReceive = asArray(balanceChanges.willReceive).length > 0
+
+  if (!(hasApprove && hasSend && hasReceive)) {
+    if (revertOnSimulationError) {
+      const missing = []
+      if (!hasApprove) missing.push('willApprove')
+      if (!hasSend) missing.push('willSend')
+      if (!hasReceive) missing.push('willReceive')
+      const err = new Error('StakingMaticSimulationResultsError')
+      err.message = 'Simulation did not produce expected effects'
+      err.reason = `missing balanceChanges: ${missing.join(', ')}`
+      err.hint = 'delegate-matic-simulation-results-error'
+      throw err
+    } else {
+      console.warn(
+        'Simulation for staking matic returned issues',
+        simulationResponse?.metadata?.humanReadableError
+      )
+    }
+  }
+}

package/src/staking/polygon/service.js

@@ -1,158 +1,299 @@
+import { memoize } from '@exodus/basic-utils'
 import { isNumberUnit } from '@exodus/currency'
-import { estimateGasLimit, stakingProviderClientFactory } from '@exodus/ethereum-api'
-import BN from 'bn.js'
+import {
+  estimateGasLimit,
+  getAggregateTransactionPricing,
+  getOptimisticTxLogEffects,
+  scaleGasLimitEstimate,
+  stakingProviderClientFactory,
+} from '@exodus/ethereum-api'
 
-export function stakingServiceFactory({ assetClientInterface, server, stakingServer }) {
+import { maticDelegateSimulateTransactions } from './matic-staking-utils.js'
+
+export function stakingServiceFactory({ assetClientInterface, server: _server, stakingServer }) {
   const stakingProvider = stakingProviderClientFactory()
+  const assetName = 'ethereum'
 
   function amountToCurrency({ asset, amount }) {
     return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
   }
 
-  async function getStakeAssets() {
+  const getStakeAssets = memoize(async () => {
     const { polygon: asset, ethereum: feeAsset } = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: 'ethereum', // Polygon token lives in ETH network
+      baseAssetName: assetName, // Polygon token lives in ETH network
     })
     return { asset, feeAsset }
+  })
+
+  // Helper function which selects the correct `asset` to use for when
+  // determining `feeData` for MATIC staking.
+  const resolveFeeData = async ({ feeData }) => {
+    const { feeAsset } = await getStakeAssets()
+    if (feeData) return feeData
+
+    console.warn(
+      'The evm staking service was not explicitly passed `feeData`. This can result in transaction nondeterminism.'
+    )
+
+    return assetClientInterface.getFeeData({ assetName: feeAsset.name })
+  }
+
+  const getLatestFeeData = async () => {
+    const { feeAsset } = await getStakeAssets()
+    return assetClientInterface.getFeeData({ assetName: feeAsset.name })
+  }
+
+  const resolveOptionalFeeData = async ({ feeData }) => {
+    // If the caller provides truthy `feeData`, we can continue
+    // as normal.
+    if (feeData) return feeData
+
+    // If the caller specifically omits `feeData`, then we
+    // provide a backup without warning. This is useful for
+    // calls with no expectations on the caller to provide
+    // `feeData`, i.e. one-shot transactions, or transactions
+    // which do not render a fee estimation.
+    return getLatestFeeData()
   }
 
-  async function approveDelegateAmount({ walletAccount, amount } = {}) {
-    const { asset } = await getStakeAssets()
+  const getDelegatorAddress = async ({ walletAccount }) => {
     const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
+      assetName,
       walletAccount,
     })
-    const delegatorAddress = address.toLowerCase()
+    return address.toLowerCase()
+  }
+
+  async function approveDelegateAmount({ walletAccount, amount, feeData } = {}) {
+    feeData = await resolveOptionalFeeData({ feeData })
+
+    const [delegatorAddress, { asset }] = await Promise.all([
+      getDelegatorAddress({ walletAccount }),
+      getStakeAssets(),
+    ])
 
     amount = amountToCurrency({ asset, amount })
 
     const txApproveData = await stakingServer.approveStakeManager(amount)
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress,
-      asset.contracts.TOKEN_CONTRACT,
-      txApproveData
-    )
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingServer.polygonContract.address,
+      txInput: txApproveData,
+      feeData,
+    })
 
     return prepareAndSendTx({
       walletAccount,
       waitForConfirmation: true,
-      to: asset.contracts.TOKEN_CONTRACT,
+      to: stakingServer.polygonContract.address,
       txData: txApproveData,
       gasPrice,
       gasLimit,
-      fee,
+      tipGasPrice,
+      feeData,
     })
   }
 
-  async function delegate({ walletAccount, amount } = {}) {
-    const { asset } = await getStakeAssets()
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
+  /**
+   * 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 [delegatorAddress, { asset, feeAsset }, resolvedFeeData] = await Promise.all([
+      getDelegatorAddress({ walletAccount }),
+      getStakeAssets(),
+      resolveFeeData({ feeData }),
+    ])
+
+    feeData = resolvedFeeData
+
+    amount = amountToCurrency({ asset, amount })
+
+    const baseNonce = await feeAsset.getNonce({
+      asset: feeAsset,
+      fromAddress: delegatorAddress.toString(),
       walletAccount,
     })
-    const delegatorAddress = address.toLowerCase()
 
-    amount = amountToCurrency({ asset, amount })
+    const [txApproveData, txDelegateData] = await Promise.all([
+      stakingServer.approveStakeManager(amount),
+      stakingServer.delegate({ amount }),
+    ])
 
-    // const txApproveData = await stakingServer.approveStakeManager(amount)
-    // let { gasPrice, gasLimit, fee } = await estimateTxFee(
-    //   delegatorAddress,
-    //   contracts.TOKEN_CONTRACT,
-    //   txApproveData
-    // )
-    // await prepareAndSendTx({
-    //   walletAccount,
-    //   waitForConfirmation: true,
-    //   to: contracts.TOKEN_CONTRACT,
-    //   txData: txApproveData,
-    //   gasPrice,
-    //   gasLimit,
-    //   fee,
-    // })
-
-    const txDelegateData = await stakingServer.delegate({ amount })
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress,
-      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
-      txDelegateData
-    )
+    const {
+      gasPrice,
+      gasLimit: approveGasLimit,
+      tipGasPrice,
+    } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingServer.polygonContract.address,
+      txInput: txApproveData,
+      feeData,
+    })
 
-    const txId = await prepareAndSendTx({
+    // Estimate based on the average gas usage for the delegate transaction. 250000 is the average.
+    const { gasLimit: estimatedDelegateGasLimit } = await estimateDelegateTxFee({
+      feeData,
+    })
+
+    const createTxBaseArgs = {
+      asset: feeAsset,
       walletAccount,
-      to: asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
-      txData: txDelegateData,
+      fromAddress: delegatorAddress.toString(),
+      amount: feeAsset.currency.ZERO,
+      tipGasPrice,
       gasPrice,
-      gasLimit,
-      fee,
+    }
+    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,
+      }),
+    ])
+
+    await maticDelegateSimulateTransactions({
+      asset,
+      unsignedTxApprove,
+      unsignedTxDelegate,
+      senderAddress: delegatorAddress.toString(),
+      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 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)
+    }
+
     await stakingProvider.notifyStaking({
-      txId,
+      txId: delegateTxId,
       asset: asset.name,
       delegator: delegatorAddress,
       amount: amount.toBaseString(),
     })
-
-    return txId
+    return delegateTxId
   }
 
-  async function undelegate({ walletAccount, amount } = {}) {
-    const { asset } = await getStakeAssets()
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
+  async function undelegate({ walletAccount, amount, feeData, waitForConfirmation = false } = {}) {
+    feeData = await resolveOptionalFeeData({ feeData })
+
+    const [delegatorAddress, { asset }] = await Promise.all([
+      getDelegatorAddress({ walletAccount }),
+      getStakeAssets(),
+    ])
 
     amount = amountToCurrency({ asset, amount })
 
     const txUndelegateData = await stakingServer.undelegate({ amount })
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress.toLowerCase(),
-      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
-      txUndelegateData
-    )
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+      from: delegatorAddress.toLowerCase(),
+      to: stakingServer.validatorShareContract.address,
+      txInput: txUndelegateData,
+      feeData,
+    })
     return prepareAndSendTx({
       walletAccount,
-      to: asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      to: stakingServer.validatorShareContract.address,
       txData: txUndelegateData,
       gasPrice,
       gasLimit,
-      fee,
+      tipGasPrice,
+      waitForConfirmation,
+      feeData,
     })
   }
 
-  async function claimRewards({ walletAccount } = {}) {
-    const { asset } = await getStakeAssets()
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
+  async function claimRewards({ walletAccount, feeData } = {}) {
+    feeData = await resolveOptionalFeeData({ feeData })
+
+    const delegatorAddress = await getDelegatorAddress({ walletAccount })
 
     const txWithdrawRewardsData = await stakingServer.withdrawRewards()
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress,
-      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
-      txWithdrawRewardsData
-    )
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingServer.validatorShareContract.address,
+      txInput: txWithdrawRewardsData,
+      feeData,
+    })
     return prepareAndSendTx({
       walletAccount,
-      to: asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      to: stakingServer.validatorShareContract.address,
       txData: txWithdrawRewardsData,
       gasPrice,
       gasLimit,
-      fee,
+      tipGasPrice,
+      feeData,
     })
   }
 
-  async function claimUndelegatedBalance({ walletAccount, unbondNonce } = {}) {
-    const { asset } = await getStakeAssets()
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
+  async function claimUndelegatedBalance({ walletAccount, unbondNonce, feeData } = {}) {
+    feeData = await resolveOptionalFeeData({ feeData })
+
+    const [delegatorAddress, { asset }] = await Promise.all([
+      getDelegatorAddress({ walletAccount }),
+      getStakeAssets(),
+    ])
 
     const { currency } = asset
     const unstakedClaimInfo = await fetchUnstakedClaimInfo({
@@ -168,18 +309,20 @@ export function stakingServiceFactory({ assetClientInterface, server, stakingSer
     })
 
     const txClaimUndelegatedData = await stakingServer.claimUndelegatedBalance({ unbondNonce })
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress,
-      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
-      txClaimUndelegatedData
-    )
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingServer.validatorShareContract.address,
+      txInput: txClaimUndelegatedData,
+      feeData,
+    })
     const txId = await prepareAndSendTx({
       walletAccount,
-      to: asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      to: stakingServer.validatorShareContract.address,
       txData: txClaimUndelegatedData,
       gasPrice,
       gasLimit,
-      fee,
+      tipGasPrice,
+      feeData,
     })
 
     await stakingProvider.notifyUnstaking({
@@ -192,19 +335,29 @@ export function stakingServiceFactory({ assetClientInterface, server, stakingSer
     return txId
   }
 
-  async function estimateDelegateOperation({ walletAccount, operation, args }) {
-    const delegateOperation = stakingServer[operation]
+  async function estimateDelegateOperation({
+    walletAccount,
+    operation,
+    args,
+    // NOTE: When estimating transactions, ideally we'd expect the `feeData`
+    //       that we intend to send the transaction using. If this is not
+    //       defined, we'll fallback to a default (with a warning).
+    feeData,
+  }) {
+    // HACK: For delegation transactions, we must fall back to the
+    //       custom implementation, since we can't currently estimate
+    //       the transaction due to a dependence upon approvals.
+    if (operation === 'delegate') return estimateDelegateTxFee({ feeData })
+
+    const [delegatorAddress, { asset }] = await Promise.all([
+      getDelegatorAddress({ walletAccount }),
+      getStakeAssets(),
+    ])
 
-    if (!delegateOperation) {
-      return
-    }
+    feeData = await resolveFeeData({ feeData })
 
-    const { asset } = await getStakeAssets()
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
+    const delegateOperation = stakingServer[operation]
+    if (!delegateOperation) return
 
     const { amount } = args
     if (amount) {
@@ -212,11 +365,12 @@ export function stakingServiceFactory({ assetClientInterface, server, stakingSer
     }
 
     const operationTxData = await delegateOperation({ ...args, walletAccount })
-    const { fee } = await estimateTxFee(
-      delegatorAddress,
-      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
-      operationTxData
-    )
+    const { fee } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingServer.validatorShareContract.address,
+      txInput: operationTxData,
+      feeData,
+    })
 
     return fee
   }
@@ -231,21 +385,25 @@ export function stakingServiceFactory({ assetClientInterface, server, stakingSer
    * This is just for displaying purposes and it's just an aproximation of the delegate gas cost,
    * NOT the real fee cost
    */
-  async function estimateDelegateTxFee() {
+  async function estimateDelegateTxFee({ feeData } = Object.create(null)) {
     // approx gas limits
     const { feeAsset } = await getStakeAssets()
-    const erc20ApproveGas = 4900
-    const delegateGas = 240_000
-    const gasPrice = parseInt(await server.gasPrice(), 16)
-    const extraPercentage = 20
-
-    const gasLimit = erc20ApproveGas + delegateGas
-    const gasLimitWithBuffer = new BN(gasLimit)
-      .imuln(100 + extraPercentage)
-      .idivn(100)
-      .toString()
 
-    const fee = new BN(gasLimitWithBuffer).mul(new BN(gasPrice))
+    feeData = await resolveFeeData({ feeData })
+
+    // TODO: update estimation to use a mock source address for
+    //       deposits so we can simulate the necessary approvals,
+    //       we shouldn't maintain constants like these
+    const erc20ApproveGas = 80_000
+    const delegateGas = 250_000
+
+    const { gasPrice } = getAggregateTransactionPricing({ baseAsset: feeAsset, feeData })
+
+    const gasLimitWithBuffer = scaleGasLimitEstimate({
+      estimatedGasLimit: BigInt(erc20ApproveGas + delegateGas),
+    })
+
+    const fee = BigInt(gasLimitWithBuffer) * BigInt(gasPrice.toBaseNumber())
 
     return {
       gasLimit: gasLimitWithBuffer,
@@ -254,31 +412,22 @@ export function stakingServiceFactory({ assetClientInterface, server, stakingSer
     }
   }
 
-  async function estimateTxFee(from, to, txInput, gasPrice = '0x0') {
+  async function estimateTxFee({ from, to, txInput, feeData }) {
     const { feeAsset } = await getStakeAssets()
 
     const amount = feeAsset.currency.ZERO
+
     const gasLimit = await estimateGasLimit({
       asset: feeAsset,
       fromAddress: from,
       toAddress: to,
-      amount,
+      amount, // staking contracts does not require ETH amount to interact with
       data: txInput,
-      gasPrice,
+      gasPrice: '0x0', // DISABLE_BALANCE_CHECKS equivalent
     })
 
-    if (gasPrice === '0x0') {
-      gasPrice = await server.gasPrice()
-    }
-
-    gasPrice = parseInt(gasPrice, 16)
-    const fee = new BN(gasPrice).mul(new BN(gasLimit))
-
-    return {
-      gasLimit,
-      gasPrice: feeAsset.currency.baseUnit(gasPrice),
-      fee: feeAsset.currency.baseUnit(fee.toString()),
-    }
+    const fee = feeAsset.api.getFee({ asset: feeAsset, feeData, gasLimit, amount })
+    return { ...fee, gasLimit }
   }
 
   async function prepareAndSendTx({
@@ -287,30 +436,25 @@ export function stakingServiceFactory({ assetClientInterface, server, stakingSer
     txData: txInput,
     gasPrice,
     gasLimit,
-    fee,
+    tipGasPrice,
     waitForConfirmation = false,
+    feeData,
   } = {}) {
-    const { asset, feeAsset } = await getStakeAssets()
-
+    const { feeAsset } = await getStakeAssets()
     const sendTxArgs = {
       asset: feeAsset,
       walletAccount,
       address: to,
       amount: feeAsset.currency.ZERO,
-      // used in desktop,
-      // remove once, txSend is unified
-      receiver: {
-        address: to,
-        amount: feeAsset.currency.ZERO,
-      },
       txInput,
       gasPrice,
       gasLimit,
-      feeAmount: fee,
+      tipGasPrice,
       waitForConfirmation,
+      feeData,
     }
 
-    const { txId } = await asset.api.sendTx(sendTxArgs)
+    const { txId } = await feeAsset.api.sendTx(sendTxArgs)
 
     return txId
   }
@@ -318,12 +462,18 @@ export function stakingServiceFactory({ assetClientInterface, server, stakingSer
   const getStakingInfo = getPolygonStakingInfo({ assetClientInterface, stakingServer })
 
   return {
+    // Unified API (used by stakingApiFactory when exposed on asset.api.staking)
+    approveStake: approveDelegateAmount,
+    stake: delegate,
+    unstake: undelegate,
+    claimUnstaked: claimUndelegatedBalance,
+    claimRewards,
+    getStakingInfo,
+    // Legacy names (for direct service usage)
     approveDelegateAmount,
     delegate,
     undelegate,
-    claimRewards,
     claimUndelegatedBalance,
-    getStakingInfo,
     estimateDelegateTxFee,
     estimateDelegateOperation,
   }
@@ -406,18 +556,20 @@ async function getUnstakedUnclaimedInfo({
 }
 
 async function fetchRewardsInfo({ stakingServer, delegator, currency }) {
-  const [minRewardsToWithdraw, rewardsBalance] = await Promise.all([
+  const [minRewardsToWithdraw, lastRewards, rewardsBalance] = await Promise.all([
     stakingServer.getMinRewardsToWithdraw(),
     stakingServer.getLiquidRewards(delegator),
+    stakingServer.getTotalRewards(delegator),
   ])
-  const withdrawable = rewardsBalance.sub(minRewardsToWithdraw).gte(currency.ZERO)
-    ? rewardsBalance
+  const withdrawable = lastRewards.sub(minRewardsToWithdraw).gte(currency.ZERO)
+    ? lastRewards
     : currency.ZERO
 
   return {
-    rewardsBalance,
+    rewardsBalance: rewardsBalance.add(lastRewards), // all time accrued rewards
+    liquidRewards: lastRewards, // current pending rewards (on-chain)
     minRewardsToWithdraw,
-    withdrawable,
+    withdrawable, // unclaimed rewards
   }
 }
 
@@ -430,7 +582,7 @@ export function getPolygonStakingInfo({ assetClientInterface, stakingServer }) {
     const delegator = address.toLowerCase()
     const [
       delegatedBalance,
-      { rewardsBalance, minRewardsToWithdraw, withdrawable },
+      { rewardsBalance, liquidRewards, minRewardsToWithdraw, withdrawable },
       { unbondNonce, withdrawalDelay, currentEpoch, withdrawExchangeRate },
     ] = await Promise.all([
       stakingServer.getTotalStake(delegator),
@@ -452,6 +604,7 @@ export function getPolygonStakingInfo({ assetClientInterface, stakingServer }) {
 
     return {
       rewardsBalance,
+      liquidRewards,
       withdrawable,
       unbondNonce,
       isDelegating,

package/src/staking.js

@@ -1,3 +1,4 @@
+import { ethereumStakingDeps } from '@exodus/ethereum-api'
 import { ethStakeAccountState } from '@exodus/ethereum-lib'
 import { asset } from '@exodus/ethereum-meta'
 
@@ -9,5 +10,6 @@ export const stakingConfiguration = {
 }
 
 export const stakingDependencies = {
+  ethereum: ethereumStakingDeps,
   polygon: polygonStakingDeps,
 }