@exodus/ethereum-api 10.0.0 → 10.1.0

package/CHANGELOG.md

@@ -3,6 +3,15 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [10.1.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@10.0.0...@exodus/ethereum-api@10.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))
+
+
+
 ## [10.0.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@9.0.3...@exodus/ethereum-api@10.0.0) (2026-10-05)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "10.0.0",
+  "version": "10.1.0",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Ethereum and EVM-based blockchains",
   "type": "module",
   "main": "src/index.js",
@@ -66,5 +66,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "83a0e678debb92fbfcefd92e7bd0453d1a92136b"
+  "gitHead": "f5c81fc2962e5d2836794149870fb9aaf094ddc9"
 }

package/src/create-asset-utils.js

@@ -176,7 +176,7 @@ export const createTransactionPrivacyResult = ({
     return { nonce, txId }
   }
 
-  const sendPrivateBundle = async ({ unsignedTxBundle }) => {
+  const sendPrivateBundle = async ({ unsignedTxBundle, onBeforeSign }) => {
     assert(
       Array.isArray(unsignedTxBundle) && unsignedTxBundle.length > 0,
       'expected non-empty unsignedTxBundle'
@@ -188,11 +188,11 @@ export const createTransactionPrivacyResult = ({
       await assertNonZeroTipGasPrice({ asset, assetClientInterface, unsignedTx })
     }
 
-    const signTxResults = await Promise.all(
-      unsignedTxBundle.map(({ asset, unsignedTx, walletAccount }) =>
-        signTx({ assetClientInterface, asset, unsignedTx, walletAccount })
-      )
-    )
+    const signTxResults = []
+    for (const [index, { asset, unsignedTx, walletAccount }] of unsignedTxBundle.entries()) {
+      onBeforeSign?.({ index, total: unsignedTxBundle.length })
+      signTxResults.push(await signTx({ assetClientInterface, asset, unsignedTx, walletAccount }))
+    }
 
     const maybeBundleResult = await broadcastPrivateBundle({
       txs: signTxResults.map(({ rawTx }) => rawTx.toString('hex')),

package/src/create-asset.js

@@ -49,6 +49,11 @@ import { estimateL1DataFeeFactory, getL1GetFeeFactory } from './optimism-gas/ind
 import { createSendValidations } from './send-validations.js'
 import { serverBasedFeeMonitorFactoryFactory } from './server-based-fee-monitor.js'
 import { stakingApiFactory } from './staking/api/index.js'
+import {
+  applyStakingApiOverrides,
+  composeStakingApi,
+  isStakingApiEnabled,
+} from './staking/evm/compose-staking-api.js'
 import { createTxFactory } from './tx-create.js'
 import { txSendFactory } from './tx-send/index.js'
 import { createWeb3API } from './web3/index.js'
@@ -135,8 +140,14 @@ export const createAssetFactory = ({
       supportsTransactionPrivacy,
       transactionAssessment,
       multicall3Address,
+      stakingApiEnabled: stakingApiOverrides,
     } = configWithOverrides
 
+    const assetStakingDependencies = applyStakingApiOverrides({
+      stakingDependencies,
+      overrides: stakingApiOverrides,
+    })
+
     const asset = assets[base.name]
 
     const { monitorType, serverUrl, monitorInterval } = resolveMonitorSettings({
@@ -206,7 +217,7 @@ export const createAssetFactory = ({
         assetClientInterface,
         server,
         stakingConfiguration,
-        stakingDependencies,
+        stakingDependencies: assetStakingDependencies,
         createRpcRequestAccumulator,
       },
       assets
@@ -236,6 +247,23 @@ export const createAssetFactory = ({
         supportsTransactionPrivacy,
       })
 
+    const stakingApiEnabled =
+      supportsStaking && isStakingApiEnabled(assetStakingDependencies[asset.name])
+
+    const createAssetStakingApi = () =>
+      composeStakingApi({
+        assetClientInterface,
+        stakingDependencies: assetStakingDependencies[asset.name],
+        legacyStakingApi: stakingApiFactory({
+          assetName: asset.name,
+          currency: asset.currency,
+          assetClientInterface,
+          server,
+          stakingConfiguration: stakingConfiguration[asset.name],
+          stakingDependencies: assetStakingDependencies[asset.name],
+        }),
+      })
+
     const features = {
       accountState: true,
       customTokens,
@@ -254,6 +282,7 @@ export const createAssetFactory = ({
       supportsCustomFees,
       supportsTransactionPrivacy: Boolean(supportsTransactionPrivacy),
       ...(supportsStaking && { staking: {} }),
+      ...(stakingApiEnabled && { stakingApi: true }),
       ...(delisted && { delisted }),
     }
 
@@ -393,15 +422,8 @@ export const createAssetFactory = ({
         signer ? signMessageWithSigner({ message, signer }) : signMessage({ privateKey, message }),
       ...(checkTx && { checkTx }),
       ...(supportsStaking &&
-        stakingDependencies[asset.name] && {
-          staking: stakingApiFactory({
-            assetName: asset.name,
-            currency: asset.currency,
-            assetClientInterface,
-            server,
-            stakingConfiguration: stakingConfiguration[asset.name],
-            stakingDependencies: stakingDependencies[asset.name],
-          }),
+        assetStakingDependencies[asset.name] && {
+          staking: createAssetStakingApi(),
         }),
       validateAssetId: address.validate,
       web3,

package/src/create-token-factory.js

@@ -3,6 +3,7 @@ import { createContract } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
 import { stakingApiFactory } from './staking/api/index.js'
+import { composeStakingApi, isStakingApiEnabled } from './staking/evm/compose-staking-api.js'
 import {
   isPolygonClaimUndelegate,
   isPolygonDelegate,
@@ -48,7 +49,13 @@ const getCreateBaseToken =
   }) =>
   ({ name, contract, features, ...tokenDef }) => {
     assert(getBalances, 'getBalances is required')
-    const tokenSpecificFeatures = name === 'polygon' ? { staking: {} } : {}
+    const tokenSpecificFeatures =
+      name === 'polygon'
+        ? {
+            staking: {},
+            ...(isStakingApiEnabled(stakingDependencies[name]) && { stakingApi: true }),
+          }
+        : {}
 
     const tokenFeatures = { ...defaultTokenFeatures, ...features, ...tokenSpecificFeatures }
     const baseApi = {
@@ -72,14 +79,18 @@ const getCreateBaseToken =
     }
 
     if (name === 'polygon' && stakingDependencies[name]) {
-      baseApi.staking = stakingApiFactory({
-        assetName: tokenAsset.name,
-        currency: tokenAsset.currency,
+      baseApi.staking = composeStakingApi({
         assetClientInterface,
-        server,
-        stakingConfiguration: stakingConfiguration[name],
         stakingDependencies: stakingDependencies[name],
-        createRpcRequestAccumulator,
+        legacyStakingApi: stakingApiFactory({
+          assetName: tokenAsset.name,
+          currency: tokenAsset.currency,
+          assetClientInterface,
+          server,
+          stakingConfiguration: stakingConfiguration[name],
+          stakingDependencies: stakingDependencies[name],
+          createRpcRequestAccumulator,
+        }),
       })
     }
 

package/src/index.js

@@ -43,6 +43,20 @@ export { createEncodeMultisigContract } from './multisig-address.js'
 export { FantomStaking, stakingProviderClientFactory } from './staking/index.js'
 export { EthLikeRpcRequestAccumulator } from './multicall3/index.js'
 export { createCachedStakingRead } from './staking/cached-read.js'
+export { createStakingTxs, sendStakingTxs, STAKING_TX_MODE } from './staking/evm/staking-txs.js'
+export { createEvmStakingApi } from './staking/evm/create-evm-staking-api.js'
+export {
+  createRejectionError as createStakingRejectionError,
+  createSubmitError as createStakingSubmitError,
+  fail as failStakingCheck,
+  pass as passStakingCheck,
+  sumOperationFees as sumStakingOperationFees,
+  warnIfBelow as warnIfStakingBalanceBelow,
+} from './staking/evm/staking-errors.js'
+export {
+  createEverstakeStakingAdapter,
+  ETH_STAKING_GAS_LIMITS,
+} from './staking/ethereum/staking-adapter.js'
 export { ethereumStakingDeps } from './staking/ethereum/deps.js'
 export { getEthereumStakingInfo, createEthereumStakingService } from './staking/ethereum/service.js'
 export { EthereumStaking } from './staking/ethereum/api.js'
@@ -65,6 +79,7 @@ export {
   isPolygonReward,
   isPolygonClaimUndelegate,
   isPendingPolygonUndelegateTxInEthereumTxLog,
+  isPolygonUndelegateTxInEthereumTxLog,
 } from './staking/matic/matic-staking-utils.js'
 
 export { fetchTxPreview } from './simulate-tx/fetch-tx-preview.js'

package/src/staking/api/index.js

@@ -36,8 +36,9 @@ export const stakingApiFactory = ({
 
   return {
     ...stakingService,
+    // @deprecated legacy staking api, remove once evm staking unification is done
     isStaking: async ({ isDelegating }) => isDelegating,
     isUnstaking: async ({ isUndelegateInProgress }) => isUndelegateInProgress,
-    isUnstaked: async ({ canClaimUndelegateBalance }) => canClaimUndelegateBalance,
+    isUnstaked: async ({ canClaimUndelegatedBalance }) => canClaimUndelegatedBalance,
   }
 }

package/src/staking/ethereum/api.js

@@ -7,9 +7,8 @@ import assert from 'minimalistic-assert'
 import { EVM_ERROR_REASONS, withErrorReason } from '../../error-wrapper.js'
 import { EthLikeRpcRequestAccumulator } from '../../multicall3/index.js'
 import { createCachedStakingRead } from '../cached-read.js'
+import { ETH_STAKING_MIN_AMOUNT } from './min-amount.js'
 
-// TODO: Shouldn't this be a function of `ethereumStakingState.minDelegateAmount`?
-const MIN_AMOUNT = '0.1'
 const RETRY_DELAYS = ['10s']
 
 const EVERSTAKE_API_URL = 'https://eth-clarity.a.exodus.io/everstake-rewards'
@@ -46,7 +45,7 @@ export class EthereumStaking {
     return txInputHex.toLowerCase().startsWith(EthereumStaking.METHODS_IDS.DELEGATE)
   }
 
-  constructor(assetName, currency, minAmount = MIN_AMOUNT, server) {
+  constructor(assetName, currency, minAmount = ETH_STAKING_MIN_AMOUNT, server) {
     this.asset = { name: assetName, currency }
     const accountingAddress =
       EthereumStaking.addresses[assetName].EVERSTAKE_ADDRESS_CONTRACT_ACCOUNTING

package/src/staking/ethereum/deps.js

@@ -1,5 +1,6 @@
 import { EthereumStaking } from './api.js'
 import { createEthereumStakingService, getEthereumStakingInfo } from './service.js'
+import { createEverstakeStakingAdapter } from './staking-adapter.js'
 
 /** Staking server factory for ethereum (used by stakingApiFactory). */
 export const stakingServerFactory = ({ assetName, currency, server, minAmount }) =>
@@ -24,6 +25,7 @@ export const stakingServiceFactory = ({ assetClientInterface, server, stakingSer
         useQueueCache,
         background,
       }),
+    // @deprecated legacy staking api, remove once evm staking unification is done
     stake: service.delegate,
     unstake: service.undelegate,
     claimUnstaked: service.claimUndelegatedBalance,
@@ -34,4 +36,5 @@ export const stakingServiceFactory = ({ assetClientInterface, server, stakingSer
 export const ethereumStakingDeps = {
   stakingServerFactory,
   stakingServiceFactory,
+  createStakingAdapter: ({ service }) => createEverstakeStakingAdapter({ service }),
 }

package/src/staking/ethereum/min-amount.js

@@ -0,0 +1 @@
+export const ETH_STAKING_MIN_AMOUNT = '0.1'

package/src/staking/ethereum/service.js

@@ -66,11 +66,12 @@ 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 { createStakingTxs, sendStakingTxs, STAKING_TX_MODE } from '../evm/staking-txs.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 { ETH_STAKING_MIN_AMOUNT } from './min-amount.js'
 import { simulateUndelegateTransactions } from './staking-utils.js'
 
 const WETH9_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
@@ -174,7 +175,6 @@ export function createEthereumStakingService({
   asset: deprectedArg, // @deprecated use `assetName` instead
   assetName,
   assetClientInterface,
-  createWatchTx = defaultCreateWatch,
   stakingProvider = stakingProviderClientFactory(),
 }) {
   if (deprectedArg && !assetName) {
@@ -202,7 +202,21 @@ export function createEthereumStakingService({
     return { delegatorAddress, feeData }
   }
 
-  async function delegate({ walletAccount, amount, feeData, isDelegateAll }) {
+  const createPlanTxs = 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,
+    })
+    return createdTxs.map(({ unsignedTx }) => unsignedTx)
+  }
+
+  async function planDelegate({ walletAccount, amount, feeData, isDelegateAll }) {
     const asset = await getAsset(assetName)
     const staking = getStakingApi(asset)
     amount = amountToCurrency({ asset, amount })
@@ -228,24 +242,40 @@ export function createEthereumStakingService({
 
     // 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}`)
-    }
+    if (isDelegateAll) amount = amount.sub(fee)
 
-    const txId = await prepareAndSendTx({
+    return {
       asset,
-      walletAccount,
-      to,
+      delegatorAddress,
       amount,
-      txData: data,
+      fee,
+      feeData,
       gasPrice,
-      gasLimit,
       tipGasPrice,
-      feeData,
-    })
+      steps: [{ to, txInput: data, amount, gasLimit }],
+      mode: STAKING_TX_MODE.single,
+    }
+  }
+
+  async function buildDelegate(params) {
+    const plan = await planDelegate(params)
+    if (params.isDelegateAll) {
+      const minAmount = getMinAmount(plan.asset)
+      // Re-validate that the amount after fee subtraction is still above the minimum
+      assert(plan.amount.gte(minAmount), `Min Amount ${minAmount}`)
+    }
+
+    const unsignedTxs = await createPlanTxs({ walletAccount: params.walletAccount, plan })
+    return { ...plan, unsignedTxs }
+  }
+
+  async function delegate({ walletAccount, amount, feeData, isDelegateAll }) {
+    const plan = await buildDelegate({ walletAccount, amount, feeData, isDelegateAll })
+    const { asset, delegatorAddress, unsignedTxs, mode } = plan
+    amount = plan.amount
+    const {
+      txIds: [txId],
+    } = await sendStakingTxs({ asset, walletAccount, unsignedTxs, mode })
 
     // Goerli is not supported
     if (assetName === 'ethereum') {
@@ -276,11 +306,6 @@ export function createEthereumStakingService({
     ])
     const delegatorAddress = address.toLowerCase()
     const pendingAmount = await staking.pendingBalanceOf(delegatorAddress)
-    const baseNonce = await asset.baseAsset.getNonce({
-      asset,
-      fromAddress: delegatorAddress,
-      walletAccount,
-    })
 
     return {
       asset,
@@ -290,7 +315,6 @@ export function createEthereumStakingService({
       feeData: resolvedFeeData,
       delegatorAddress,
       pendingAmount,
-      baseNonce,
     }
   }
 
@@ -340,12 +364,7 @@ export function createEthereumStakingService({
     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 }) {
+  async function planUndelegate({ walletAccount, amount, feeData }) {
     const {
       asset,
       staking,
@@ -354,7 +373,6 @@ export function createEthereumStakingService({
       feeData: resolvedFeeData,
       delegatorAddress,
       pendingAmount,
-      baseNonce,
     } = await prepareUndelegate({ walletAccount, amount, feeData })
 
     if (!requestedAmount.isPositive) {
@@ -423,48 +441,68 @@ export function createEthereumStakingService({
       tipGasPrice = tipGasPrice || undelegateResult.feeInfo.tipGasPrice
     }
 
-    // 3. Create unsigned txs
-    const createTxBaseArgs = {
+    const plannedSteps = Object.values(txSteps).filter((txStep) => txStep.plan)
+    const fee = [pendingResult, undelegateResult]
+      .filter(Boolean)
+      .reduce((total, { feeInfo }) => total.add(feeInfo.fee), asset.currency.ZERO)
+
+    return {
       asset,
-      walletAccount,
-      fromAddress: delegatorAddress,
-      amount: asset.currency.ZERO,
-      tipGasPrice,
+      delegatorAddress,
+      amount: requestedAmount,
+      fee,
+      feeData: resolvedFeeData,
       gasPrice,
+      tipGasPrice,
+      txSteps,
+      steps: plannedSteps.map((txStep) => ({
+        to: txStep.plan.to,
+        txInput: txStep.plan.txData,
+        gasLimit: txStep.gasLimit,
+      })),
+      mode: STAKING_TX_MODE.bundle,
     }
+  }
 
-    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]
-        })
+  async function simulateUndelegate({ plan, unsignedTxs, revertOnSimulationError = true }) {
+    const plannedSteps = Object.values(plan.txSteps).filter((txStep) => txStep.plan)
+    const txSteps = Object.fromEntries(
+      Object.entries(plan.txSteps).map(([key, txStep]) => [
+        key,
+        { ...txStep, unsignedTx: unsignedTxs[plannedSteps.indexOf(txStep)] ?? null },
+      ])
     )
 
-    for (const [key, unsignedTx] of createdTxEntries) {
-      txSteps[key].unsignedTx = unsignedTx
-    }
-
     await simulateUndelegateTransactions({
-      asset,
+      asset: plan.asset,
       txSteps,
-      senderAddress: delegatorAddress,
-      gasPrice,
+      senderAddress: plan.delegatorAddress,
+      gasPrice: plan.gasPrice,
       revertOnSimulationError,
     })
 
-    const unsignedTxBundle = createdTxEntries.map(([_, unsignedTx]) => ({
-      asset,
-      unsignedTx,
+    return txSteps
+  }
+
+  async function buildUndelegate({ walletAccount, amount, feeData, revertOnSimulationError }) {
+    const plan = await planUndelegate({ walletAccount, amount, feeData })
+    const unsignedTxs = await createPlanTxs({ walletAccount, plan })
+    const txSteps = await simulateUndelegate({ plan, unsignedTxs, revertOnSimulationError })
+    return { ...plan, txSteps, unsignedTxs }
+  }
+
+  // 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, delegatorAddress, txSteps, unsignedTxs, mode } = await buildUndelegate({
       walletAccount,
-    }))
+      amount,
+      feeData,
+      revertOnSimulationError,
+    })
 
     // 4. Sign transactions
     //
@@ -498,7 +536,7 @@ export function createEthereumStakingService({
     const {
       bundleHash,
       txIds: [...txIds],
-    } = await asset.baseAsset.sendPrivateBundle({ unsignedTxBundle })
+    } = await sendStakingTxs({ asset, walletAccount, unsignedTxs, mode })
 
     for (const txStep of Object.values(txSteps)) {
       if (!txStep.unsignedTx) continue
@@ -525,7 +563,7 @@ export function createEthereumStakingService({
     return bundleHash
   }
 
-  async function claimUndelegatedBalance({ walletAccount, feeData }) {
+  async function planClaimUndelegatedBalance({ walletAccount, feeData }) {
     const asset = await getAsset(assetName)
     const staking = getStakingApi(asset)
 
@@ -536,29 +574,52 @@ export function createEthereumStakingService({
       address: delegatorAddress,
     })
 
-    if (withdrawRequest) {
-      const { to, data } = withdrawRequest
+    if (!withdrawRequest) return null
 
-      const { gasLimit, gasPrice, tipGasPrice } = await estimateTxFee({
-        from: delegatorAddress,
-        to,
-        amount: null,
-        txInput: data,
-        feeData,
-      })
-      return prepareAndSendTx({
-        asset,
-        walletAccount,
-        to,
-        txData: data,
-        gasLimit,
-        gasPrice,
-        tipGasPrice,
-        feeData,
-      })
+    const { to, data } = withdrawRequest
+    const { gasLimit, gasPrice, tipGasPrice, fee } = await estimateTxFee({
+      from: delegatorAddress,
+      to,
+      amount: null,
+      txInput: data,
+      feeData,
+    })
+
+    return {
+      asset,
+      delegatorAddress,
+      fee,
+      feeData,
+      gasPrice,
+      tipGasPrice,
+      steps: [{ to, txInput: data, gasLimit }],
+      mode: STAKING_TX_MODE.single,
     }
   }
 
+  async function buildClaimUndelegatedBalance(params) {
+    const plan = await planClaimUndelegatedBalance(params)
+    if (!plan) return null
+
+    const unsignedTxs = await createPlanTxs({ walletAccount: params.walletAccount, plan })
+    return { ...plan, unsignedTxs }
+  }
+
+  async function claimUndelegatedBalance({ walletAccount, feeData }) {
+    const plan = await buildClaimUndelegatedBalance({ walletAccount, feeData })
+    if (!plan) return
+
+    const {
+      txIds: [txId],
+    } = await sendStakingTxs({
+      asset: plan.asset,
+      walletAccount,
+      unsignedTxs: plan.unsignedTxs,
+      mode: plan.mode,
+    })
+    return txId
+  }
+
   async function estimateDelegateOperation({ walletAccount, operation, args, feeData }) {
     const asset = await getAsset(assetName)
 
@@ -723,52 +784,16 @@ export function createEthereumStakingService({
     }
   }
 
-  async function prepareAndSendTx({
-    asset,
-    walletAccount,
-    to,
-    amount,
-    txData: txInput,
-    gasPrice,
-    gasLimit,
-    tipGasPrice,
-    waitForConfirmation = false,
-    feeData,
-  }) {
-    const { unsignedTx } = await asset.baseAsset.api.createTx({
-      asset,
-      walletAccount,
-      address: to,
-      amount: amount || asset.currency.ZERO,
-      txInput,
-      gasPrice,
-      gasLimit,
-      // HACK: Override the `tipGasPrice` to use a custom `maxPriorityFeePerGas`.
-      tipGasPrice,
-      feeData,
-    })
-
-    const { txId } = await asset.baseAsset.api.sendTx({ asset, walletAccount, unsignedTx })
-
-    const baseAsset = asset.baseAsset
-    if (waitForConfirmation) {
-      const getTxLog = (...args) => assetClientInterface.getTxLog(...args)
-      const watchTx = createWatchTx({
-        walletAccount,
-        getTxLog,
-        baseAsset,
-      })
-      await watchTx(txId)
-    }
-
-    return txId
-  }
-
   return {
+    planDelegate,
+    planUndelegate,
+    planClaimUndelegatedBalance,
+    simulateUndelegate,
+    getEthereumStakingInfo,
+    // @deprecated legacy staking api, remove once evm staking unification is done
     delegate,
     undelegate,
     claimUndelegatedBalance,
-    getEthereumStakingInfo,
     estimateDelegateOperation,
     getMinAmount,
     getDelegateSelectAllAmount,
@@ -801,7 +826,7 @@ export async function getEthereumStakingInfo({
   ])
 
   const delegatedBalance = activeStakedBalance.add(pendingBalance).add(pendingDepositedBalance)
-  const minDelegateAmount = currency.defaultUnit(0.1)
+  const minDelegateAmount = currency.defaultUnit(ETH_STAKING_MIN_AMOUNT)
 
   const {
     requested,