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

package/src/staking/ethereum/service.js

@@ -1,43 +1,240 @@
-import { estimateGasLimit } from '../../gas-estimation'
-import { isNumberUnit } from '@exodus/currency'
-import { stakingProviderClientFactory } from '../staking-provider-client'
-import { EthereumStaking } from './api'
-import { fromHexToBigInt } from '../../number-utils'
+/**
+ * Everstake ETH Staking — Balance States
+ *
+ * When a user stakes ETH via Everstake, their funds move through several
+ * buckets tracked by the Accounting contract. Each bucket has different
+ * rules about what operations are allowed.
+ *
+ *   User Wallet (ETH)
+ *       |
+ *       | stake()
+ *       v
+ *   pendingBalance
+ *       Pool waiting room. ETH sits here until enough accumulates
+ *       (32 ETH across all users) to fund a new validator.
+ *       Can be withdrawn instantly via unstakePending().
+ *       |
+ *       | pool reaches 32 ETH, deposits to Beacon chain
+ *       v
+ *   pendingDepositedBalance
+ *       Sent to Beacon chain but validator not yet activated.
+ *       LOCKED — cannot be unstaked until validator activates.
+ *       |
+ *       | validator activates
+ *       v
+ *   activeStakedBalance (autocompoundBalanceOf)
+ *       User's share of active validator ETH, including compounded
+ *       rewards. Can be unstaked via unstake().
+ *       |
+ *       | unstake()
+ *       |-----> ETH returned immediately (if pool has liquidity / interchange)
+ *       |       goes directly to wallet
+ *       v
+ *   unclaimedUndelegatedBalance
+ *       Withdrawal queue. Waiting for validator exit.
+ *       Global per-user — all unstake() calls accumulate into a single
+ *       balance. Cannot claim until the entire balance is ready.
+ *       |
+ *       | validator(s) exit
+ *       v
+ *   readyForClaim (withdrawRequest.readyForClaim)
+ *       When requested == readyForClaim, user can call
+ *       claimWithdrawRequest() to get ETH back to wallet.
+ *       |
+ *       | claimWithdrawRequest()
+ *       v
+ *   User Wallet (ETH)
+ *
+ * Additional derived values:
+ *   - delegatedBalance = activeStakedBalance + pendingBalance + pendingDepositedBalance
+ *   - depositedBalanceOf = the user's original deposit amount tracked by the
+ *     Accounting contract. Does NOT include compounded rewards — only what the
+ *     user explicitly staked. Grows when user stakes, shrinks when user unstakes.
+ *   - liquidRewards = activeStakedBalance - depositedBalanceOf
+ *     The difference between the user's current share of validator ETH
+ *     (which grows as validators earn rewards and autocompound) and what
+ *     they originally deposited. This is the "unrealized" profit that
+ *     would be forfeited if the user unstakes only their deposited amount.
+ *   - rewardsBalance (getTotalRewards) = historical total rewards from the
+ *     Everstake API, including already-claimed and compounded rewards.
+ *     Unlike liquidRewards, this is NOT derived on-chain — it comes from
+ *     an external Everstake endpoint and may lag behind real-time state.
+ */
+
+import { memoize } from '@exodus/basic-utils'
+import NumberUnit from '@exodus/currency'
+import assert from 'minimalistic-assert'
+
+import { estimateGasLimit, scaleGasLimitEstimate } from '../../gas-estimation.js'
+import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
+import { stakingProviderClientFactory } from '../staking-provider-client.js'
+import { amountToCurrency, DISABLE_BALANCE_CHECKS, resolveFeeData } from '../utils/index.js'
+import { EthereumStaking } from './api.js'
+import { getCachedEverstakeValidatorsQueue } from './everstake.js'
+import { simulateUndelegateTransactions } from './staking-utils.js'
+
+const WETH9_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
+
+// Transactions will usually stake values up to `1 ether`, so
+// we'll assume this amount as a slippage protection mechanism,
+// the idea being that this is a value of ether that we risk
+// being mined whilst our transaction is in-flight.
+const SLOT_ACTIVATION_PROXIMITY_ETH = '1.0'
+
+// We've observed that most transactions which offer
+// a healthy ratio between `gasUsed` had a `gasLimit`
+// over `170_000`. Transactions which have an unhealthy
+// ratio commonly fall under this limit.
+const MINIMUM_DELEGATION_GAS_LIMIT = 180_000
+
+const EXTRA_GAS_LIMIT = 20_000 // extra gas Limit to prevent tx failing if something change on pool state (till tx is in mempool)
+
+// Estimates based on real life transaction averages.
+// Overestimated averages by 4x.
+const STAKING_OPERATION_FALLBACK_FEE_ESTIMATES = {
+  delegate: '0.00081512',
+  undelegate: '0.000554',
+  claimUndelegatedBalance: '0.0001800912',
+}
+
+const getStakingApi = memoize(
+  (asset) => new EthereumStaking(asset.name, asset.currency, undefined, asset.server),
+  (asset) => asset
+)
+
+export async function getUndelegatePendingData({
+  staking,
+  delegatorAddress,
+  requestedAmount,
+  pendingAmount,
+  minAmount,
+  resolvedFeeData,
+  estimateTxFee,
+}) {
+  if (!pendingAmount.isPositive) return null
+
+  const leftOver = pendingAmount.sub(requestedAmount)
+
+  if (leftOver.isPositive && leftOver.lt(minAmount)) return null
+
+  // Essentially the min of the 2 amounts
+  const inactiveAmountToUnstake = pendingAmount.lte(requestedAmount)
+    ? pendingAmount
+    : requestedAmount
 
-const extraGasLimit = 20_000 // extra gas Limit to prevent tx failing if something change on pool state (till tx is in mempool)
+  const { to, data } = await staking.unstakePending({
+    address: delegatorAddress,
+    amount: inactiveAmountToUnstake,
+  })
+
+  const feeInfo = estimateTxFee
+    ? await estimateTxFee({
+        from: delegatorAddress,
+        to,
+        amount: null,
+        txInput: data,
+        feeData: resolvedFeeData,
+      })
+    : null
+
+  return { plan: { to, txData: data, amount: inactiveAmountToUnstake }, feeInfo }
+}
+
+export async function getUndelegateData({
+  staking,
+  delegatorAddress,
+  requestedAmount,
+  pendingAmount,
+  resolvedFeeData,
+  estimateTxFee,
+}) {
+  const activeAmountToUnstake = requestedAmount.sub(pendingAmount)
+
+  if (!activeAmountToUnstake.isPositive) return null
+
+  const { to, data } = await staking.unstake({
+    address: delegatorAddress,
+    amount: activeAmountToUnstake,
+  })
+
+  const feeInfo = estimateTxFee
+    ? await estimateTxFee({
+        from: delegatorAddress,
+        to,
+        amount: null,
+        txInput: data,
+        feeData: resolvedFeeData,
+      })
+    : null
+
+  return { plan: { to, txData: data, amount: activeAmountToUnstake }, feeInfo }
+}
 
 export function createEthereumStakingService({
-  asset,
+  asset: deprectedArg, // @deprecated use `assetName` instead
+  assetName,
   assetClientInterface,
-  createAndBroadcastTX,
-  server,
+  createWatchTx = defaultCreateWatch,
+  stakingProvider = stakingProviderClientFactory(),
 }) {
-  const staking = new EthereumStaking(asset)
-  const stakingProvider = stakingProviderClientFactory()
-
-  function amountToCurrency({ asset, amount }) {
-    return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
+  if (deprectedArg && !assetName) {
+    console.debug('using deprecated ARG `asset` instead of `assetName`')
+    assetName = deprectedArg.name
   }
 
-  async function delegate({ walletAccount, amount } = {}) {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
-      walletAccount,
-    })
+  const getAsset = memoize(async (baseAssetName) => {
+    const { [assetName]: asset } = await assetClientInterface.getAssetsForNetwork({ baseAssetName })
+    return asset
+  })
+
+  const getTransactionProps = async ({ feeData, walletAccount }) => {
+    const asset = await getAsset(assetName)
+    let address
+    ;[address, feeData] = await Promise.all([
+      assetClientInterface.getReceiveAddress({
+        assetName,
+        walletAccount,
+      }),
+      resolveFeeData({ asset, assetClientInterface, feeData }),
+    ])
+
     const delegatorAddress = address.toLowerCase()
+    return { delegatorAddress, feeData }
+  }
+
+  async function delegate({ walletAccount, amount, feeData, isDelegateAll }) {
+    const asset = await getAsset(assetName)
+    const staking = getStakingApi(asset)
     amount = amountToCurrency({ asset, amount })
 
-    const { to, data } = await staking.stake({
-      amount,
-    })
+    let delegatorAddress
+    ;({ feeData, delegatorAddress } = await getTransactionProps({ feeData, walletAccount }))
 
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(delegatorAddress, to, amount, data)
+    const { to, data } = await staking.stake({ amount })
 
-    console.log(
+    console.debug(
       `delegator address ${delegatorAddress} staking ${amount.toDefaultString({
         unit: true,
       })}`
     )
+
+    const { gasPrice, gasLimit, tipGasPrice, fee } = await estimateTxFee({
+      from: delegatorAddress,
+      to,
+      amount,
+      txInput: data,
+      feeData,
+    })
+
+    // If we are delegating all, we need to subtract the estimated ETH cost from the amount
+    // Better to do it here than from the mobile app where fees can change before the transaction is sent
+    if (isDelegateAll) {
+      const minAmount = getMinAmount(asset)
+      amount = amount.sub(fee)
+      // Re-validate that the amount after fee subtraction is still above the minimum
+      assert(amount.gte(minAmount), `Min Amount ${minAmount}`)
+    }
+
     const txId = await prepareAndSendTx({
       asset,
       walletAccount,
@@ -46,204 +243,484 @@ export function createEthereumStakingService({
       txData: data,
       gasPrice,
       gasLimit,
-      fee,
+      tipGasPrice,
+      feeData,
     })
 
     // Goerli is not supported
-    if (asset.name === 'ethereum')
+    if (assetName === 'ethereum') {
       await stakingProvider.notifyStaking({
         txId,
-        asset: asset.name,
+        asset: assetName,
         delegator: delegatorAddress,
         amount: amount.toBaseString(),
       })
+    }
 
     return txId
   }
 
-  async function undelegate({ walletAccount, amount } = {}) {
-    /*
-    unstakePending balance (not yet in validator) + unstake balance (in validator)
-    1. give priority to unstakePending (based on the amount)
-    2. unstake amount in validator.
-    */
-    amount = amountToCurrency({ asset, amount })
+  async function prepareUndelegate({ walletAccount, amount, feeData }) {
+    assert(amount instanceof NumberUnit, 'expected amount to be a NumberUnit')
+    const asset = await getAsset(assetName)
+    const staking = getStakingApi(asset)
+    const minAmount = getMinAmount(asset)
+    const requestedAmount = amount
 
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
+    const [address, resolvedFeeData] = await Promise.all([
+      assetClientInterface.getReceiveAddress({
+        assetName,
+        walletAccount,
+      }),
+      resolveFeeData({ asset, assetClientInterface, feeData }),
+    ])
+    const delegatorAddress = address.toLowerCase()
+    const pendingAmount = await staking.pendingBalanceOf(delegatorAddress)
+    const baseNonce = await asset.baseAsset.getNonce({
+      asset,
+      fromAddress: delegatorAddress,
       walletAccount,
     })
-    const delegatorAddress = address.toLowerCase()
+
+    return {
+      asset,
+      staking,
+      minAmount,
+      requestedAmount,
+      feeData: resolvedFeeData,
+      delegatorAddress,
+      pendingAmount,
+      baseNonce,
+    }
+  }
+
+  /**
+   * Unstaking may involve 2 txs; unstaking from pending and unstaking from validator.
+   * Fee estimation depends on the executed txs. Can be both.
+   * @returns total undelegete fee
+   */
+  async function estimateUndelegate({ walletAccount, amount: requestedAmount, feeData }) {
+    assert(requestedAmount instanceof NumberUnit, 'expected amount to be a NumberUnit')
+    const asset = await getAsset(assetName)
+    const staking = getStakingApi(asset)
+    const minAmount = getMinAmount(asset)
+
+    let delegatorAddress
+    ;({ feeData, delegatorAddress } = await getTransactionProps({ feeData, walletAccount }))
 
     const pendingAmount = await staking.pendingBalanceOf(delegatorAddress)
 
-    console.log(
-      `delegator address ${delegatorAddress} unstaking ${amount.toDefaultString({
+    let pendingResult = null
+    try {
+      pendingResult = await getUndelegatePendingData({
+        staking,
+        delegatorAddress,
+        requestedAmount,
+        pendingAmount,
+        minAmount,
+        resolvedFeeData: feeData,
+        estimateTxFee,
+      })
+    } catch (err) {
+      console.warn('ETH unstake pending estimation failed, continuing with unstake', err)
+    }
+
+    const undelegateResult = await getUndelegateData({
+      staking,
+      delegatorAddress,
+      requestedAmount,
+      pendingAmount,
+      resolvedFeeData: feeData,
+      estimateTxFee,
+    })
+
+    const pendingFee = pendingResult?.feeInfo?.fee ?? asset.currency.ZERO
+    const undelegateFee = undelegateResult?.feeInfo?.fee ?? asset.currency.ZERO
+
+    return pendingFee.add(undelegateFee)
+  }
+
+  // NOTE: Like the legacy `undelegate()` flow, this planner currently splits
+  // the request using `pendingAmount` only. It does not pre-validate that the
+  // validator-side remainder is actually available in active staked balance,
+  // so an oversized request can still fail later when building/sending the
+  // validator unstake step.
+  async function undelegate({ walletAccount, amount, feeData, revertOnSimulationError = true }) {
+    const {
+      asset,
+      staking,
+      minAmount,
+      requestedAmount,
+      feeData: resolvedFeeData,
+      delegatorAddress,
+      pendingAmount,
+      baseNonce,
+    } = await prepareUndelegate({ walletAccount, amount, feeData })
+
+    if (!requestedAmount.isPositive) {
+      throw new Error('Undelegate amount must be positive')
+    }
+
+    const txSteps = {
+      undelegatePending: {
+        plan: null,
+        gasLimit: null,
+        unsignedTx: null,
+        txId: null,
+      },
+      undelegate: {
+        plan: null,
+        gasLimit: null,
+        unsignedTx: null,
+        txId: null,
+      },
+    }
+
+    console.debug(
+      `delegator address ${delegatorAddress} unstaking ${requestedAmount.toDefaultString({
         unit: true,
       })} - pending amount: ${pendingAmount.toDefaultString({ unit: true })}`
     )
 
-    let txId
-    if (!pendingAmount.isZero) {
-      const inactiveAmountToUnstake = pendingAmount.lte(amount) ? pendingAmount : amount
-      const leftOver = pendingAmount.sub(amount)
-      if (leftOver.gt(asset.currency.ZERO)) {
-        const minStake = staking.minAmount
-        if (leftOver.lt(minStake)) {
-          throw new Error(`Pending balance less than min stake amount ${minStake}`)
-        }
-      }
+    // 1. Plan transactions and estimate fees
+    const pendingResult = await getUndelegatePendingData({
+      staking,
+      delegatorAddress,
+      requestedAmount,
+      pendingAmount,
+      minAmount,
+      resolvedFeeData,
+      estimateTxFee,
+    })
 
-      const { to, data } = await staking.unstakePending({
-        address: delegatorAddress,
-        amount: inactiveAmountToUnstake,
-      })
+    const undelegateResult = await getUndelegateData({
+      staking,
+      delegatorAddress,
+      requestedAmount,
+      pendingAmount,
+      resolvedFeeData,
+      estimateTxFee,
+    })
 
-      const { gasPrice, gasLimit, fee } = await estimateTxFee(
-        delegatorAddress.toLowerCase(),
-        to,
-        null,
-        data
-      )
-      txId = await prepareAndSendTx({
-        asset,
-        walletAccount,
-        to,
-        txData: data,
-        gasPrice,
-        gasLimit,
-        fee,
-      })
+    if (!pendingResult && !undelegateResult) {
+      throw new Error('Requested undelegation produced no transactions')
     }
 
-    // need also to unstake
-    if (amount.gt(pendingAmount)) {
-      const activeAmountToUnstake = amount.sub(pendingAmount)
-      const { to, data } = await staking.unstake({
-        address: delegatorAddress,
-        amount: activeAmountToUnstake,
-      })
+    let gasPrice
+    let tipGasPrice
 
-      const { gasPrice, gasLimit, fee } = await estimateTxFee(delegatorAddress, to, null, data)
-      txId = await prepareAndSendTx({
-        asset,
-        walletAccount,
-        to,
-        txData: data,
-        gasPrice,
-        gasLimit,
-        fee,
-      })
+    if (pendingResult) {
+      txSteps.undelegatePending.plan = pendingResult.plan
+      txSteps.undelegatePending.gasLimit = pendingResult.feeInfo.gasLimit
+      gasPrice = pendingResult.feeInfo.gasPrice
+      tipGasPrice = pendingResult.feeInfo.tipGasPrice
     }
 
-    // Goerli is not supported
-    if (asset.name === 'ethereum')
-      await stakingProvider.notifyUnstaking({
-        txId,
-        asset: asset.name,
-        delegator: delegatorAddress,
-        amount: amount.toBaseString(),
-      })
-
-    return txId
-  }
+    if (undelegateResult) {
+      txSteps.undelegate.plan = undelegateResult.plan
+      txSteps.undelegate.gasLimit = undelegateResult.feeInfo.gasLimit
+      gasPrice = gasPrice || undelegateResult.feeInfo.gasPrice
+      tipGasPrice = tipGasPrice || undelegateResult.feeInfo.tipGasPrice
+    }
 
-  async function claimUndelegatedBalance({ walletAccount } = {}) {
-    // withdraw withdrawable balance (of a previous unstake)
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
+    // 3. Create unsigned txs
+    const createTxBaseArgs = {
+      asset,
       walletAccount,
+      fromAddress: delegatorAddress,
+      amount: asset.currency.ZERO,
+      tipGasPrice,
+      gasPrice,
+    }
+
+    const createdTxEntries = await Promise.all(
+      Object.entries(txSteps)
+        .filter(([, txStep]) => txStep.plan)
+        .map(async ([key, txStep], index) => {
+          const result = await asset.baseAsset.api.createTx({
+            ...createTxBaseArgs,
+            toAddress: txStep.plan.to,
+            txInput: txStep.plan.txData,
+            gasLimit: txStep.gasLimit,
+            nonce: baseNonce + index,
+          })
+          return [key, result.unsignedTx]
+        })
+    )
+
+    for (const [key, unsignedTx] of createdTxEntries) {
+      txSteps[key].unsignedTx = unsignedTx
+    }
+
+    await simulateUndelegateTransactions({
+      asset,
+      txSteps,
+      senderAddress: delegatorAddress,
+      gasPrice,
+      revertOnSimulationError,
     })
-    const delegatorAddress = address.toLowerCase()
+
+    const unsignedTxBundle = createdTxEntries.map(([_, unsignedTx]) => ({
+      asset,
+      unsignedTx,
+      walletAccount,
+    }))
+
+    // 4. Sign transactions
+    //
+    // 5. Broadcast transactions via bundle and get bundle hash
+    //
+    // 6. Optimistic tx-log effects: reflect tx presence and fee consumption only.
+    // The ETH returned to the user via the contract's internal transfer is not
+    // captured here — it will be picked up once the tx is confirmed on-chain.
+    // It would also be incorrect to optimistically log the full requested ETH
+    // as immediately received: some portion may instead be routed into the
+    // undelegation queue / withdraw-request system and only become claimable
+    // much later after validator exit.
+    //
+    // We now have a more deterministic model for these incoming ETH amounts,
+    // but it requires staking-operation context that getOptimisticTxLogEffects()
+    // does not currently accept:
+    //
+    // - unstakePending: the ETH returned is exactly the amount passed to
+    //   unstakePending(). In this flow that amount is chosen from the pre-send
+    //   pending balance and the requested undelegation amount:
+    //     amountPassedToUnstakePending = min(totalRequestedAmount, pendingBalanceBefore)
+    // - unstake: the ETH returned can be derived only from staking state before
+    //   and after the operation:
+    //     amountPassedToUnstake = totalRequestedAmount - pendingBalanceBefore
+    //     queuedFromUnstake = unclaimedUndelegatedBalanceAfter - unclaimedUndelegatedBalanceBefore
+    //     returnedImmediatelyFromUnstake = amountPassedToUnstake - queuedFromUnstake
+    //
+    // That is incompatible with the current tx-log side-effect hook, which only
+    // receives tx-local data (method id, calldata, nonce, gas, etc.) and not
+    // staking snapshots or precomputed ETH-return amounts.
+    const {
+      bundleHash,
+      txIds: [...txIds],
+    } = await asset.baseAsset.sendPrivateBundle({ unsignedTxBundle })
+
+    for (const txStep of Object.values(txSteps)) {
+      if (!txStep.unsignedTx) continue
+      assert((txStep.txId = txIds.shift()), 'expected txId')
+    }
+
+    // Testnet assets do not support delegations tracking
+    if (assetName === 'ethereum') {
+      const notify = (txStep) =>
+        stakingProvider.notifyUnstaking({
+          txId: txStep.txId,
+          asset: assetName,
+          delegator: delegatorAddress,
+          amount: txStep.plan.amount.toBaseString(),
+        })
+
+      await Promise.all([
+        txSteps.undelegatePending.txId && notify(txSteps.undelegatePending),
+        txSteps.undelegate.txId && notify(txSteps.undelegate),
+      ])
+    }
+
+    // This is the most correct response, but it doesn't matter, it is not consumed by the apps
+    return bundleHash
+  }
+
+  async function claimUndelegatedBalance({ walletAccount, feeData }) {
+    const asset = await getAsset(assetName)
+    const staking = getStakingApi(asset)
+
+    let delegatorAddress
+    ;({ feeData, delegatorAddress } = await getTransactionProps({ feeData, walletAccount }))
 
     const withdrawRequest = await staking.claimWithdrawRequest({
       address: delegatorAddress,
     })
+
     if (withdrawRequest) {
       const { to, data } = withdrawRequest
-      const { gasPrice, gasLimit, fee } = await estimateTxFee(delegatorAddress, to, null, data)
+
+      const { gasLimit, gasPrice, tipGasPrice } = await estimateTxFee({
+        from: delegatorAddress,
+        to,
+        amount: null,
+        txInput: data,
+        feeData,
+      })
       return prepareAndSendTx({
         asset,
         walletAccount,
         to,
         txData: data,
-        gasPrice,
         gasLimit,
-        fee,
+        gasPrice,
+        tipGasPrice,
+        feeData,
       })
     }
-
-    return null // -> no withdrawable balance
   }
 
-  async function estimateDelegateOperation({ walletAccount, operation, args }) {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName: asset.name,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
+  async function estimateDelegateOperation({ walletAccount, operation, args, feeData }) {
+    const asset = await getAsset(assetName)
 
-    const NAMING_MAP = {
-      delegate: 'stake',
-      undelegate: 'unstake',
-      claimUndelegatedBalance: 'claimWithdrawRequest',
-    }
-    const delegateOperation = staking[NAMING_MAP[operation]].bind(staking)
+    try {
+      const staking = getStakingApi(asset)
 
-    if (!delegateOperation) {
-      return
-    }
+      const requestedAmount = args.amount
+        ? amountToCurrency({ asset, amount: args.amount })
+        : asset.currency.ZERO
 
-    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
-    if (args.amount) args.amount = amountToCurrency({ asset, amount: args.amount })
+      let delegatorAddress
+      ;({ delegatorAddress, feeData } = await getTransactionProps({ feeData, walletAccount }))
 
-    let amount, data, fee
-    try {
-      ;({ amount, data } = await delegateOperation(args))
-      const address =
-        operation === 'claimUndelegatedBalance' ? staking.accountingAddress : staking.poolAddress
-      ;({ fee } = await estimateTxFee(delegatorAddress, address, amount, data))
-    } catch (e) {
-      // If the operation is to unstake and failed retry with unstakePending
       if (operation === 'undelegate') {
-        ;({ amount, data } = await staking.unstakePending(args))
-        ;({ fee } = await estimateTxFee(delegatorAddress, staking.poolAddress, amount, data))
-      } else {
-        throw e
+        return estimateUndelegate({ walletAccount, amount: requestedAmount, feeData })
       }
-    }
 
-    return fee
+      const NAMING_MAP = {
+        delegate: 'stake',
+        undelegate: 'unstake',
+        claimUndelegatedBalance: 'claimWithdrawRequest',
+      }
+
+      const delegateOperation = staking[NAMING_MAP[operation]].bind(staking)
+
+      if (!delegateOperation) throw new Error('Invalid staking operation')
+
+      const { amount, data } = await delegateOperation({ ...args, amount: requestedAmount })
+
+      const { fee } = await (operation === 'claimUndelegatedBalance'
+        ? estimateTxFee({
+            from: delegatorAddress,
+            to: staking.accountingAddress,
+            amount,
+            txInput: data,
+            feeData,
+          })
+        : // The `gasUsed` of a delegation transaction can vary
+          // significantly depending upon whether it will result
+          // in the activation of new slots (i.e. validator creation).
+          //
+          // This can result in transaction `revert` due to slippage
+          // from incompatible transaction ordering.
+          //
+          // To mitigate this, we:
+          // 1. Simulate the delegation at an amplified deposit amount
+          //    to show enhanced fees close to a proximity buffer.
+          // 2. Originate the transaction from the WETH contract,
+          //    which guarantees deep native ether liquidity which
+          //    exceeds any rational user deposit.
+          estimateTxFee({
+            from: WETH9_ADDRESS,
+            to: staking.poolAddress,
+            amount: amount.add(asset.currency.defaultUnit(SLOT_ACTIVATION_PROXIMITY_ETH)),
+            txInput: data,
+            feeData,
+          }))
+
+      return fee
+    } catch (error) {
+      const fallbackFee = STAKING_OPERATION_FALLBACK_FEE_ESTIMATES[operation]
+      if (fallbackFee) {
+        console.warn(
+          `ETH staking fee estimation failed for '${operation}', using fallback:`,
+          error.message
+        )
+        return asset.currency.defaultUnit(fallbackFee)
+      }
+
+      error.message = `StakingFeeEstimationError: Failed to estimate fee for '${operation}' (and no fallback configured). Cause: ${error.message}`
+      throw error
+    }
   }
 
-  async function estimateTxFee(from, to, amount, txInput, gasPrice = '0x0') {
+  async function estimateTxFee({ from, to, amount, txInput, feeData }) {
+    const asset = await getAsset(assetName)
+
     amount = amount || asset.currency.ZERO
+    from = from.toLowerCase()
 
-    const gasLimit = await estimateGasLimit(
+    const estimatedGasLimit = await estimateGasLimit({
       asset,
-      from.toLowerCase(),
-      to.toLowerCase(),
+      fromAddress: from,
+      toAddress: to.toLowerCase(),
       amount, // staking contracts does not always require ETH amount to interact with
-      txInput,
-      gasPrice
-    )
+      data: txInput,
+      gasPrice: DISABLE_BALANCE_CHECKS,
+    })
 
-    if (gasPrice === '0x0') {
-      gasPrice = await server.gasPrice()
-    }
+    const scaledGasLimit = scaleGasLimitEstimate({ estimatedGasLimit })
 
-    gasPrice = fromHexToBigInt(gasPrice)
-    const fee = gasPrice * BigInt(gasLimit + extraGasLimit)
+    const gasLimit = Math.max(
+      scaledGasLimit + EXTRA_GAS_LIMIT,
 
-    return {
+      // For delgation transactions, we enforce an empirical
+      // `MINIMUM_DELEGATE_GAS_LIMIT`, since the majority of
+      // transactions which possess a healthy ratio of
+      // `gasUsed` to `gasLimit` operate at this boundary.
+      EthereumStaking.isDelegationTransactonCalldata(txInput) ? MINIMUM_DELEGATION_GAS_LIMIT : 0
+    )
+
+    const getFeeResult = await asset.api.getFee({
+      asset,
+      feeData,
       gasLimit,
-      gasPrice: asset.currency.baseUnit(gasPrice.toString()),
-      fee: asset.currency.baseUnit(fee.toString()),
-    }
+      amount,
+    })
+
+    return { ...getFeeResult, gasLimit }
   }
 
-  function getMinAmount() {
-    return staking.minAmount
+  /** Returns the minimum possible amount that can be staked. */
+  function getMinAmount(asset) {
+    assert(asset, 'getMinAmount: `asset` is required')
+    return getStakingApi(asset).minAmount
+  }
+
+  /** Determine the maximum possible stake for a given spendable amount. */
+  async function getDelegateSelectAllAmount({ walletAccount, spendableForStaking, feeData }) {
+    const asset = await getAsset(assetName)
+    const minAmount = getMinAmount(asset)
+
+    if (!spendableForStaking) spendableForStaking = asset.currency.ZERO
+    ;({ feeData } = await getTransactionProps({ feeData, walletAccount }))
+
+    // If the caller hasn't specified a value of `spendableForStaking`
+    // which satisfies the minimum amount, then we'll coerce this value
+    // up to the minimum amount so we can at least provide a rational
+    // estimate for the `calculatedFee`, so they know how much ether
+    // to purchase.
+    spendableForStaking = spendableForStaking.lt(minAmount) ? minAmount : spendableForStaking
+
+    // Compute the cost of delegation. Even though the `walletAccount`'s
+    // balance is potentially insufficient, we can still provide
+    // rational fee estimates because the estimation process will mock
+    // the transaction from an account with deep liquidity.
+    const calculatedFee = await estimateDelegateOperation({
+      walletAccount,
+      operation: 'delegate',
+      args: {
+        amount: spendableForStaking,
+      },
+      feeData,
+    })
+
+    // If the `spendableForStaking` is insufficient to cover both the
+    // transaction fee and the minimum stake, then there is no reasonable
+    // value we can recommend.
+    if (calculatedFee.add(minAmount).gt(spendableForStaking)) {
+      return {
+        calculatedFee,
+        selectAllAmount: asset.currency.ZERO,
+      }
+    }
+
+    // At this stage, we've confirmed that the remaining `spendableForStaking`
+    // after transactions is sufficient to cover the minimum stake, so any
+    // excess amounts over this can be.
+    return {
+      calculatedFee,
+      selectAllAmount: spendableForStaking.sub(calculatedFee),
+    }
   }
 
   async function prepareAndSendTx({
@@ -254,25 +731,35 @@ export function createEthereumStakingService({
     txData: txInput,
     gasPrice,
     gasLimit,
-    fee,
-  } = {}) {
-    const sendTxArgs = {
+    tipGasPrice,
+    waitForConfirmation = false,
+    feeData,
+  }) {
+    const { unsignedTx } = await asset.baseAsset.api.createTx({
       asset,
       walletAccount,
       address: to,
       amount: amount || asset.currency.ZERO,
-      options: {
-        shouldLog: true,
-        txInput,
-        gasPrice,
-        gasLimit,
-        feeAmount: fee,
-      },
-    }
+      txInput,
+      gasPrice,
+      gasLimit,
+      // HACK: Override the `tipGasPrice` to use a custom `maxPriorityFeePerGas`.
+      tipGasPrice,
+      feeData,
+    })
 
-    console.log('sending staking tx:', sendTxArgs)
+    const { txId } = await asset.baseAsset.api.sendTx({ asset, walletAccount, unsignedTx })
 
-    const { txId } = await createAndBroadcastTX(sendTxArgs)
+    const baseAsset = asset.baseAsset
+    if (waitForConfirmation) {
+      const getTxLog = (...args) => assetClientInterface.getTxLog(...args)
+      const watchTx = createWatchTx({
+        walletAccount,
+        getTxLog,
+        baseAsset,
+      })
+      await watchTx(txId)
+    }
 
     return txId
   }
@@ -284,26 +771,33 @@ export function createEthereumStakingService({
     getEthereumStakingInfo,
     estimateDelegateOperation,
     getMinAmount,
+    getDelegateSelectAllAmount,
   }
 }
 
-export async function getEthereumStakingInfo({ address, asset, server }) {
+export async function getEthereumStakingInfo({
+  address,
+  asset,
+  server,
+  staking = new EthereumStaking(asset.name, asset.currency, undefined, server),
+  useCache = false,
+  useQueueCache = useCache,
+  background = false,
+}) {
   const { currency } = asset
   const delegator = address.toLowerCase()
-  const staking = new EthereumStaking({ asset, server })
-
   const [
-    activeStakedBalance,
-    pendingBalance,
-    pendingDepositedBalance,
-    withdrawRequest,
+    { activeStakedBalance, pendingBalance, pendingDepositedBalance, withdrawRequest },
     rewardsBalance,
+    everstakeValidatorsQueue,
   ] = await Promise.all([
-    staking.autocompoundBalanceOf(delegator),
-    staking.pendingBalanceOf(delegator),
-    staking.pendingDepositedBalanceOf(delegator),
-    staking.withdrawRequest(delegator),
-    staking.getLiquidRewards(delegator),
+    staking.getStakingState(delegator),
+    // Provider availability must not prevent restoring on-chain stake. Omit
+    // failed metadata so the monitor preserves the last successful rewards.
+    staking
+      .getCachedTotalRewards(delegator, { useCache })
+      .catch(() => (background ? null : currency.ZERO)),
+    getCachedEverstakeValidatorsQueue('ethereum', { useCache: useQueueCache }).catch(() => null),
   ])
 
   const delegatedBalance = activeStakedBalance.add(pendingBalance).add(pendingDepositedBalance)
@@ -323,7 +817,7 @@ export async function getEthereumStakingInfo({ address, asset, server }) {
   const unclaimedUndelegatedBalance = requested
 
   return {
-    rewardsBalance,
+    ...(rewardsBalance !== null && { rewardsBalance }),
     isDelegating,
     activeStakedBalance, // balance staked into the validator
     delegatedBalance, // balance staked into the validator + pending
@@ -333,5 +827,12 @@ export async function getEthereumStakingInfo({ address, asset, server }) {
     unclaimedUndelegatedBalance,
     canClaimUndelegatedBalance,
     isUndelegateInProgress,
+    // Do not replace previous queue estimates with undefined on a transient failure.
+    ...(!background && {
+      validatorActivationTime: undefined,
+      validatorExitTime: undefined,
+      validatorWithdrawTime: undefined,
+    }),
+    ...everstakeValidatorsQueue,
   }
 }