@exodus/ethereum-api 10.0.0 → 10.1.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,