@exodus/ethereum-api 8.33.0 → 8.33.2

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.33.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.33.1...@exodus/ethereum-api@8.33.2) (2025-03-10)
+
+
+### Bug Fixes
+
+
+* fix: prevent double accounting for ethereum staking (#5184)
+
+
+
+## [8.33.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.33.0...@exodus/ethereum-api@8.33.1) (2025-03-06)
+
+
+### Bug Fixes
+
+
+* fix: ethereum and matic staking service improvements (#5109)
+
+
+
 ## [8.33.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.32.0...@exodus/ethereum-api@8.33.0) (2025-03-03)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.33.0",
+  "version": "8.33.2",
   "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",
@@ -64,5 +64,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "15a7b5013a7364f530b88b226204cbbc769b85f0"
+  "gitHead": "41d13eb347b8624c223888a0e13d6709cd24f932"
 }

package/src/get-balances.js

@@ -8,7 +8,7 @@ import { isRpcBalanceAsset } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
 const getStaked = ({ accountState, asset }) => {
-  return accountState?.staking?.[asset.name]?.delegatedBalance || asset.currency.ZERO
+  return accountState?.staking?.[asset.name]?.activeStakedBalance || asset.currency.ZERO
 }
 
 const getStaking = ({ accountState, asset }) => {

package/src/get-fee-async.js

@@ -134,8 +134,10 @@ const getFeeAsyncFactory = ({
     const l1DataFee = optimismL1DataFee
       ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
       : asset.baseAsset.currency.ZERO
+
     return {
       fee: fee.add(l1DataFee),
+      // TODO: Should this be `l1DataFee`?
       optimismL1DataFee,
       gasLimit,
       gasPrice,

package/src/get-fee.js

@@ -34,12 +34,16 @@ export const getFeeFactory =
     isRbfAllowed = true, // Destkop, isRbfAllowed=true when advanced panel is on
     calculateEffectiveFee,
   }) => {
-    const { eip1559Enabled, baseFeePerGas, tipGasPrice } = feeData
+    const { eip1559Enabled, baseFeePerGas, tipGasPrice, useBaseGasPrice } = feeData
 
     const gasPrice = customFee || resolveGasPrice({ feeData })
 
     const gasLimit = providedGasLimit || asset.gasLimit || defaultGasLimit
 
+    // When explicitly opting into EIP-1559 transactions,
+    // lock in the `tipGasPrice` we used to compute the fees.
+    const maybeReturnTipGasPrice = eip1559Enabled && useBaseGasPrice ? { tipGasPrice } : null
+
     const extraFeeData = getExtraFeeData({ asset, amount })
     if (calculateEffectiveFee && eip1559Enabled) {
       const maxFeePerGas = gasPrice
@@ -47,11 +51,16 @@ export const getFeeFactory =
       const feePerGas = baseFeePerGas.add(tipGasPrice)
       const effectiveGasPrice = feePerGas.lt(maxFeePerGas) ? feePerGas : maxFeePerGas
 
-      return { fee: effectiveGasPrice.mul(gasLimit), gasPrice, extraFeeData }
+      return {
+        ...maybeReturnTipGasPrice,
+        fee: effectiveGasPrice.mul(gasLimit),
+        gasPrice,
+        extraFeeData,
+      }
     }
 
     const fee = gasPrice.mul(gasLimit)
-    return { fee, gasPrice, extraFeeData }
+    return { ...maybeReturnTipGasPrice, fee, gasPrice, extraFeeData }
   }
 
 // Used in BE

package/src/staking/ethereum/api.js

@@ -28,6 +28,14 @@ export class EthereumStaking {
     UNSTAKE: '0x76ec871c', // unstake(uint256 amount)
     UNSTAKE_PENDING: '0xed0723d4', // unstakePending(uint256 amount)
     CLAIM_UNSTAKE: '0x33986ffa', // claimWithdrawRequest(uint256 amount)
+    DEPOSIT: '0x47e7ef24', // deposit(address staker, uint256 amount)
+  }
+
+  static isDelegationTransactonCalldata = (txInput) => {
+    const txInputHex = (Buffer.isBuffer(txInput) ? bufferToHex(txInput) : txInput) || '0x'
+    if (typeof txInputHex !== 'string') throw new Error('expected string')
+
+    return txInputHex.toLowerCase().startsWith(EthereumStaking.METHODS_IDS.DELEGATE)
   }
 
   constructor(
@@ -52,7 +60,10 @@ export class EthereumStaking {
     return contract[method].build(...args)
   }
 
-  #callReadFunctionContract = (contract, method, ...args) => {
+  #callReadFunctionContract = (contract, method, ...args) =>
+    this.#callReadFunctionContractFrom(contract, method, undefined, ...args)
+
+  #callReadFunctionContractFrom = (contract, method, from, ...args) => {
     const callData = this.#buildTxData(contract, method, ...args)
     const data = {
       data: bufferToHex(callData),
@@ -60,6 +71,8 @@ export class EthereumStaking {
       tag: 'latest',
     }
 
+    if (typeof from === 'string' && from.length > 0) data.from = from
+
     const eth = this.server || getServerByName(this.asset.name)
     return retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data)
   }
@@ -151,6 +164,25 @@ export class EthereumStaking {
 
   // === POOL ===
 
+  /** Determine the effects of a deposit operation by mocking a transaction from the Everstake Pool contract, which can be used to estimate slippage. */
+  async getDepositEffects(depositorAddress, amount) {
+    const { address: from } = this.contractPool
+    const prankDepositReturnData = await this.#callReadFunctionContractFrom(
+      this.contractAccounting,
+      'deposit',
+      from,
+      depositorAddress,
+      amount.toBaseString()
+    )
+    const [interchangedAmount, activatedSlots] =
+      this.contractAccounting.deposit.parse(prankDepositReturnData)
+
+    return {
+      interchangedAmount: this.asset.currency.baseUnit(interchangedAmount),
+      activatedSlots: BigInt(activatedSlots),
+    }
+  }
+
   async stake({ amount, source = '2' }) {
     if (amount.gte(this.minAmount)) {
       return {

package/src/staking/ethereum/service.js

@@ -1,13 +1,35 @@
-import { isNumberUnit } from '@exodus/currency'
-
-import { getServer } from '../../exodus-eth-server/index.js'
 import { estimateGasLimit } from '../../gas-estimation.js'
-import { fromHexToBigInt } from '../../number-utils.js'
 import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
 import { stakingProviderClientFactory } from '../staking-provider-client.js'
+import { amountToCurrency, getEvmStakingServiceFee } from '../utils/index.js'
 import { EthereumStaking } from './api.js'
 
-const extraGasLimit = 20_000 // extra gas Limit to prevent tx failing if something change on pool state (till tx is in mempool)
+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
+
+// Use a custom `maxPriorityFeePerGas` so we can
+// respect the default EIP-1559 relationship:
+// maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas.
+//
+// Currently, the backend will return an excessive
+// `tipGasPrice` which hinders the configuration ofrational
+// inclusion incentives when defined using remote config.
+const MAX_PRIORITY_FEE_PER_GAS = '0.06 Gwei' // semi-urgent
+
+const EXTRA_GAS_LIMIT = 20_000 // extra gas Limit to prevent tx failing if something change on pool state (till tx is in mempool)
+
+const DISABLE_BALANCE_CHECKS = '0x0'
 
 export function createEthereumStakingService({
   asset,
@@ -18,10 +40,6 @@ export function createEthereumStakingService({
   const stakingProvider = stakingProviderClientFactory()
   const minAmount = staking.minAmount
 
-  function amountToCurrency({ asset, amount }) {
-    return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
-  }
-
   async function delegate({ walletAccount, amount } = Object.create(null)) {
     const address = await assetClientInterface.getReceiveAddress({
       assetName: asset.name,
@@ -34,13 +52,18 @@ export function createEthereumStakingService({
       amount,
     })
 
-    const { gasPrice, gasLimit } = await estimateTxFee(delegatorAddress, to, amount, data)
-
     console.log(
       `delegator address ${delegatorAddress} staking ${amount.toDefaultString({
         unit: true,
       })}`
     )
+
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
+      delegatorAddress,
+      to,
+      amount,
+      data
+    )
     const txId = await prepareAndSendTx({
       asset,
       walletAccount,
@@ -49,6 +72,7 @@ export function createEthereumStakingService({
       txData: data,
       gasPrice,
       gasLimit,
+      tipGasPrice,
     })
 
     // Goerli is not supported
@@ -83,9 +107,14 @@ export function createEthereumStakingService({
       amount: inactiveAmountToUnstake,
     })
 
-    const feeData = await estimateTxFee(delegatorAddress, to, null, data)
+    const { gasLimit, gasPrice, tipGasPrice } = await estimateTxFee(
+      delegatorAddress,
+      to,
+      null,
+      data
+    )
 
-    return { to, txData: data, ...feeData }
+    return { to, txData: data, gasLimit, gasPrice, tipGasPrice }
   }
 
   async function getUndelegateData({ delegatorAddress, resquestedAmount, pendingAmount }) {
@@ -102,9 +131,13 @@ export function createEthereumStakingService({
       amount: activeAmountToUnstake,
     })
 
-    const feeData = await estimateTxFee(delegatorAddress, to, null, data)
-
-    return { to, txData: data, ...feeData }
+    const { gasLimit, gasPrice, tipGasPrice } = await estimateTxFee(
+      delegatorAddress,
+      to,
+      null,
+      data
+    )
+    return { to, txData: data, gasLimit, gasPrice, tipGasPrice }
   }
 
   /**
@@ -226,14 +259,21 @@ export function createEthereumStakingService({
     })
     if (withdrawRequest) {
       const { to, data } = withdrawRequest
-      const { gasPrice, gasLimit } = await estimateTxFee(delegatorAddress, to, null, data)
+
+      const { gasLimit, gasPrice, tipGasPrice } = await estimateTxFee(
+        delegatorAddress,
+        to,
+        null,
+        data
+      )
       return prepareAndSendTx({
         asset,
         walletAccount,
         to,
         txData: data,
-        gasPrice,
         gasLimit,
+        gasPrice,
+        tipGasPrice,
       })
     }
   }
@@ -266,44 +306,113 @@ export function createEthereumStakingService({
     }
 
     const { amount, data } = await delegateOperation({ ...args, amount: requestedAmount })
-    const toAddress =
-      operation === 'claimUndelegatedBalance' ? staking.accountingAddress : staking.poolAddress
 
-    const { fee } = await estimateTxFee(delegatorAddress, toAddress, amount, data)
+    const { fee } = await (operation === 'claimUndelegatedBalance'
+      ? estimateTxFee(delegatorAddress, staking.accountingAddress, amount, data)
+      : // 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(
+          WETH9_ADDRESS,
+          staking.poolAddress,
+          amount.add(asset.currency.defaultUnit(SLOT_ACTIVATION_PROXIMITY_ETH)),
+          data
+        ))
 
     return fee
   }
 
-  async function estimateTxFee(from, to, amount, txInput, gasPrice = '0x0') {
+  async function estimateTxFee(from, to, amount, txInput) {
     amount = amount || asset.currency.ZERO
+    from = from.toLowerCase()
 
-    const gasLimit = await estimateGasLimit(
+    const estimatedGasLimit = await estimateGasLimit(
       asset,
-      from.toLowerCase(),
+      from,
       to.toLowerCase(),
       amount, // staking contracts does not always require ETH amount to interact with
       txInput,
-      gasPrice
+      DISABLE_BALANCE_CHECKS
     )
 
-    if (gasPrice === '0x0') {
-      gasPrice = await getServer(asset).gasPrice()
-    }
+    const gasLimit = Math.max(
+      estimatedGasLimit + EXTRA_GAS_LIMIT,
 
-    gasPrice = fromHexToBigInt(gasPrice)
-    const fee = gasPrice * BigInt(gasLimit + extraGasLimit)
+      // 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
+    )
 
-    return {
+    return getEvmStakingServiceFee({
+      amount,
+      asset,
+      assetClientInterface,
+      maxPriorityFeePerGas: MAX_PRIORITY_FEE_PER_GAS,
       gasLimit,
-      gasPrice: asset.currency.baseUnit(gasPrice.toString()),
-      fee: asset.currency.baseUnit(fee.toString()),
-    }
+    })
   }
 
+  /** Returns the minimum possible amount that can be staked. */
   function getMinAmount() {
     return staking.minAmount
   }
 
+  /** Determine the maximum possible stake for a given spendable amount. */
+  async function getDelegateSelectAllAmount({
+    walletAccount,
+    spendableForStaking = asset.currency.ZERO,
+  }) {
+    const minAmount = getMinAmount()
+
+    // 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,
+      },
+    })
+
+    // 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(
     {
       asset,
@@ -313,6 +422,7 @@ export function createEthereumStakingService({
       txData: txInput,
       gasPrice,
       gasLimit,
+      tipGasPrice,
       waitForConfirmation = false,
     } = Object.create(null)
   ) {
@@ -327,6 +437,8 @@ export function createEthereumStakingService({
         txInput,
         gasPrice,
         gasLimit,
+        // HACK: Override the `tipGasPrice` to use a custom `maxPriorityFeePerGas`.
+        tipGasPrice,
       },
     }
 
@@ -353,6 +465,7 @@ export function createEthereumStakingService({
     getEthereumStakingInfo,
     estimateDelegateOperation,
     getMinAmount,
+    getDelegateSelectAllAmount,
   }
 }
 

package/src/staking/matic/service.js

@@ -1,12 +1,15 @@
-import { isNumberUnit } from '@exodus/currency'
 import BN from 'bn.js'
 
 import { getServer } from '../../exodus-eth-server/index.js'
 import { estimateGasLimit } from '../../gas-estimation.js'
 import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
 import { stakingProviderClientFactory } from '../staking-provider-client.js'
+import { amountToCurrency, getEvmStakingServiceFee } from '../utils/index.js'
 import { MaticStakingApi } from './api.js'
 
+const DISABLE_BALANCE_CHECKS = '0x0'
+const MAX_PRIORITY_FEE_PER_GAS = '0.06 Gwei' // semi-urgent
+
 export function createPolygonStakingService({
   assetClientInterface,
   createWatchTx = defaultCreateWatch,
@@ -22,10 +25,6 @@ export function createPolygonStakingService({
     return { asset, feeAsset }
   }
 
-  function amountToCurrency({ asset, amount }) {
-    return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
-  }
-
   async function delegate({ walletAccount, amount } = {}) {
     const address = await assetClientInterface.getReceiveAddress({
       assetName,
@@ -37,7 +36,7 @@ export function createPolygonStakingService({
     amount = amountToCurrency({ asset, amount })
 
     const txApproveData = await stakingApi.approveStakeManager(amount)
-    let { gasPrice, gasLimit } = await estimateTxFee(
+    let { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
       delegatorAddress,
       stakingApi.polygonContract.address,
       txApproveData
@@ -49,10 +48,12 @@ export function createPolygonStakingService({
       txData: txApproveData,
       gasPrice,
       gasLimit,
+      tipGasPrice,
     })
 
     const txDelegateData = await stakingApi.delegate({ amount })
-    ;({ gasPrice, gasLimit } = await estimateTxFee(
+
+    ;({ gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
       delegatorAddress,
       stakingApi.validatorShareContract.address,
       txDelegateData
@@ -64,6 +65,7 @@ export function createPolygonStakingService({
       txData: txDelegateData,
       gasPrice,
       gasLimit,
+      tipGasPrice,
     })
 
     await stakingProvider.notifyStaking({
@@ -87,7 +89,7 @@ export function createPolygonStakingService({
     amount = amountToCurrency({ asset, amount })
 
     const txUndelegateData = await stakingApi.undelegate({ amount })
-    const { gasPrice, gasLimit } = await estimateTxFee(
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
       delegatorAddress.toLowerCase(),
       stakingApi.validatorShareContract.address,
       txUndelegateData
@@ -98,6 +100,7 @@ export function createPolygonStakingService({
       txData: txUndelegateData,
       gasPrice,
       gasLimit,
+      tipGasPrice,
     })
   }
 
@@ -109,7 +112,7 @@ export function createPolygonStakingService({
     const delegatorAddress = address.toLowerCase()
 
     const txWithdrawRewardsData = await stakingApi.withdrawRewards()
-    const { gasPrice, gasLimit } = await estimateTxFee(
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
       delegatorAddress,
       stakingApi.validatorShareContract.address,
       txWithdrawRewardsData
@@ -120,6 +123,7 @@ export function createPolygonStakingService({
       txData: txWithdrawRewardsData,
       gasPrice,
       gasLimit,
+      tipGasPrice,
     })
   }
 
@@ -145,7 +149,7 @@ export function createPolygonStakingService({
     })
 
     const txClaimUndelegatedData = await stakingApi.claimUndelegatedBalance({ unbondNonce })
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(
+    const { gasPrice, gasLimit, tipGasPrice, fee } = await estimateTxFee(
       delegatorAddress,
       stakingApi.validatorShareContract.address,
       txClaimUndelegatedData
@@ -156,6 +160,7 @@ export function createPolygonStakingService({
       txData: txClaimUndelegatedData,
       gasPrice,
       gasLimit,
+      tipGasPrice,
       fee,
     })
 
@@ -233,32 +238,29 @@ export function createPolygonStakingService({
     }
   }
 
-  async function estimateTxFee(from, to, txInput, gasPrice = '0x0') {
+  async function estimateTxFee(from, to, txInput) {
     const { ethereum } = await assetClientInterface.getAssetsForNetwork({
       baseAssetName: 'ethereum',
     })
+
     const amount = ethereum.currency.ZERO
+
     const gasLimit = await estimateGasLimit(
       ethereum,
       from,
       to,
       amount, // staking contracts does not require ETH amount to interact with
       txInput,
-      gasPrice
+      DISABLE_BALANCE_CHECKS
     )
 
-    if (gasPrice === '0x0') {
-      gasPrice = await getServer(ethereum).gasPrice()
-    }
-
-    gasPrice = parseInt(gasPrice, 16)
-    const fee = new BN(gasPrice).mul(new BN(gasLimit))
-
-    return {
+    return getEvmStakingServiceFee({
+      amount,
+      asset: ethereum,
+      assetClientInterface,
+      maxPriorityFeePerGas: MAX_PRIORITY_FEE_PER_GAS,
       gasLimit,
-      gasPrice: ethereum.currency.baseUnit(gasPrice),
-      fee: ethereum.currency.baseUnit(fee.toString()),
-    }
+    })
   }
 
   async function prepareAndSendTx({
@@ -267,6 +269,7 @@ export function createPolygonStakingService({
     txData: txInput,
     gasPrice,
     gasLimit,
+    tipGasPrice,
     waitForConfirmation = false,
   } = {}) {
     const { ethereum: asset } = await assetClientInterface.getAssetsForNetwork({
@@ -282,6 +285,7 @@ export function createPolygonStakingService({
         txInput,
         gasPrice,
         gasLimit,
+        tipGasPrice,
       },
       waitForConfirmation,
     }

package/src/staking/utils/index.js

@@ -0,0 +1,73 @@
+import { isNumberUnit } from '@exodus/currency'
+
+export function amountToCurrency({ asset, amount }) {
+  return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
+}
+
+// HACK: Empirically, we can observe that a `feeData` object uses
+//       stringified values for gas i.e. `baseFeePerGas: "10 gwei"`,
+//       however to hook into `asset.api.getFees()`, these values
+//       must be expressed using currency objects.
+function maybeNormalizeFeeData({ asset, feeData }) {
+  const { baseFeePerGas, tipGasPrice, serverGasPrice, gasPrice, ...extras } = feeData
+
+  const maybeNormalizeAmount = (amount) =>
+    typeof amount === 'string' ? amountToCurrency({ amount, asset }) : amount
+
+  return {
+    ...extras,
+    gasPrice: maybeNormalizeAmount(gasPrice),
+    baseFeePerGas: maybeNormalizeAmount(baseFeePerGas),
+    tipGasPrice: maybeNormalizeAmount(tipGasPrice),
+    serverGasPrice: maybeNormalizeAmount(serverGasPrice),
+  }
+}
+
+/**
+ * A common handler for the computation of the `fee`, `gasPrice`,
+ * `gasLimit` and `tipGasPrice` or a staking call. Allows the caller
+ * to specify a custom `maxPriorityFeePerGas` whilst the current
+ * `tipGasPrice` is incompatible with EIP-1559 pricing.
+ */
+export async function getEvmStakingServiceFee({
+  amount,
+  asset,
+  assetClientInterface,
+  maxPriorityFeePerGas: maybeMaxPriorityFeePerGas,
+  gasLimit,
+}) {
+  const defaultFeeData = await assetClientInterface.getFeeData({
+    assetName: asset.name,
+  })
+
+  // HACK: We wish to explicitly enable `useBaseGasPrice`
+  //       since we're using a custom `tipGasPrice`. This
+  //       will be compatible during the transition from
+  //       Magnifier to Clarity, and can be safely removed
+  //       once `useBaseGasPrice` is the default behaviour
+  //       (alongside the custom tip).
+  const { eip1559Enabled } = defaultFeeData
+  const useBaseGasPrice = Boolean(eip1559Enabled) && Boolean(maybeMaxPriorityFeePerGas)
+
+  const normalizedFeeData = maybeNormalizeFeeData({
+    asset,
+    feeData: {
+      ...defaultFeeData,
+      // HACK: The backend currently exports a very large `tipGasPrice` that is
+      //       compatible with Magnifier's legacy `gasPrice`, but it would
+      //       be incompatible with EIP-1559, since this would evaluate into
+      //       a very large `maxPriorityFeePerGas`.
+      ...(useBaseGasPrice ? { tipGasPrice: maybeMaxPriorityFeePerGas } : null),
+      useBaseGasPrice,
+    },
+  })
+
+  // Returns `fee`, `gasPrice`, `extraFeeData`, and `tipGasPrice`
+  // if the config defines we should `useBaseGasPrice`.
+  return asset.api.getFee({
+    asset,
+    feeData: normalizedFeeData,
+    gasLimit,
+    amount,
+  })
+}

package/src/tx-log/clarity-utils/get-log-items-from-server-tx.js

@@ -35,6 +35,7 @@ export default function getLogItemsFromServerTx({
   const methodId = serverTx.input && {
     methodId: serverTx.input.slice(0, Math.max(0, METHOD_ID_LENGTH)),
   }
+  const data = serverTx.input || '0x'
 
   const logItemCommonProperties = {
     confirmations,
@@ -77,7 +78,7 @@ export default function getLogItemsFromServerTx({
           coinAmount,
           coinName: asset.name,
           data: {
-            data: serverTx.input || '0x',
+            data,
             nonce,
             gasLimit,
             ...methodId,
@@ -137,7 +138,7 @@ export default function getLogItemsFromServerTx({
         ...logItemCommonProperties,
         coinAmount,
         coinName: tokenName,
-        data: { nonce, gasLimit },
+        data: { data, nonce, gasLimit, ...methodId },
         ...(isConsideredSent
           ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: token.feeAsset.name }
           : { from: tokenFromAddresses }),