@exodus/ethereum-api 8.34.7 → 8.34.8

package/src/staking/matic/service.js

@@ -1,140 +1,71 @@
-import { memoize } from '@exodus/basic-utils'
+import BN from 'bn.js'
 
-import { estimateGasLimit, scaleGasLimitEstimate } from '../../gas-estimation.js'
-import { getFeeFactoryGasPrices } from '../../get-fee.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,
-  DISABLE_BALANCE_CHECKS,
-  resolveFeeData as defaultResolveFeeData,
-} from '../utils/index.js'
+import { amountToCurrency, getEvmStakingServiceFee } from '../utils/index.js'
 import { MaticStakingApi } from './api.js'
 
-const createStakingApiForFeeAsset = ({ feeAsset: { server } }) =>
-  new MaticStakingApi(undefined, undefined, server)
+const DISABLE_BALANCE_CHECKS = '0x0'
+const MAX_PRIORITY_FEE_PER_GAS = '0.06 Gwei' // semi-urgent
 
-// TODO: This should be `createMaticStakingService` to avoid confusion with Polygon staking.
 export function createPolygonStakingService({
   assetClientInterface,
   createWatchTx = defaultCreateWatch,
-  stakingProvider = stakingProviderClientFactory(),
 }) {
+  const stakingApi = new MaticStakingApi()
   const assetName = 'ethereum'
+  const stakingProvider = stakingProviderClientFactory()
 
-  const getStakeAssets = memoize(async () => {
-    const { polygon: asset, [assetName]: feeAsset } =
-      await assetClientInterface.getAssetsForNetwork({
-        baseAssetName: assetName,
-      })
+  async function getStakeAssets() {
+    const { polygon: asset, ethereum: feeAsset } = await assetClientInterface.getAssetsForNetwork({
+      baseAssetName: assetName,
+    })
     return { asset, feeAsset }
-  })
-
-  const createStakingApi = memoize(async () => {
-    const { asset, feeAsset } = await getStakeAssets()
-    return { asset, feeAsset, stakingApi: createStakingApiForFeeAsset({ feeAsset }) }
-  })
-
-  // Helper function which selects the correct `asset` to use for when
-  // determining `feeData` for MATIC staking.
-  const resolveFeeData = async ({ feeData }) => {
-    const { feeAsset } = await getStakeAssets()
-    return defaultResolveFeeData({ asset: feeAsset, assetClientInterface, feeData })
-  }
-
-  const getLatestFeeData = async () => {
-    const { feeAsset } = await getStakeAssets()
-    return assetClientInterface.getFeeData({ assetName: feeAsset.name })
   }
 
-  const resolveOptionalFeeData = async ({ feeData }) => {
-    // If the caller provides truthy `feeData`, we can continue
-    // as normal.
-    if (feeData) return feeData
-
-    // If the caller specifically omits `feeData`, then we
-    // provide a backup without warning. This is useful for
-    // calls with no expectations on the caller to provide
-    // `feeData`, i.e. one-shot transactions, or transactions
-    // which do not render a fee estimation.
-    return getLatestFeeData()
-  }
-
-  const getDelegatorAddress = async ({ walletAccount }) => {
+  async function delegate({ walletAccount, amount } = {}) {
     const address = await assetClientInterface.getReceiveAddress({
       assetName,
       walletAccount,
     })
-    return address.toLowerCase()
-  }
-
-  async function delegate({ walletAccount, amount, feeData, waitForConfirmation = true } = {}) {
-    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-    ])
-
-    // NOTE: We do not provide a silent fallback for `feeData` omission
-    //       for a delegation transaction, since `feeData` is expected
-    //       to have been provided during `estimateDelegateTxFee`.
-    feeData = await resolveFeeData({ feeData })
+    const delegatorAddress = address.toLowerCase()
 
+    const { asset } = await getStakeAssets()
     amount = amountToCurrency({ asset, amount })
 
     const txApproveData = await stakingApi.approveStakeManager(amount)
-    let { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.polygonContract.address,
-      txInput: txApproveData,
-      feeData,
-    })
+    let { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
+      delegatorAddress,
+      stakingApi.polygonContract.address,
+      txApproveData
+    )
     await prepareAndSendTx({
       walletAccount,
-      waitForConfirmation,
+      waitForConfirmation: true,
       to: stakingApi.polygonContract.address,
       txData: txApproveData,
       gasPrice,
       gasLimit,
       tipGasPrice,
-      feeData,
     })
 
-    // NOTE: Whenever we `waitForConfirmation`, we must recalculate
-    //       the `feeData` as this may have changed since our last
-    //       transaction was mined.
-    //
-    //       In most cases, this shouldn't affect previous estimates,
-    //       since the amount we aren't trying to stake using the
-    //       base currency; however for users with marginal balances,
-    //       an increase in `gasPrice` could result in transaction
-    //       failure.
-    //
-    // HACK: This will invaldiate the original estimate in calculated
-    //       in `estimateDelegateTxFee`!
-    // TODO: Submit these transactions as an atomic bundle.
-    if (waitForConfirmation) {
-      feeData = await getLatestFeeData()
-    }
-
     const txDelegateData = await stakingApi.delegate({ amount })
 
-    ;({ gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.validatorShareContract.address,
-      txInput: txDelegateData,
-      feeData,
-    }))
+    ;({ gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
+      delegatorAddress,
+      stakingApi.validatorShareContract.address,
+      txDelegateData
+    ))
 
     const txId = await prepareAndSendTx({
       walletAccount,
-      // TOOD: Why shouldn't we wait for confirmation here? Is it because we want to `notifyStaking`?
-      waitForConfirmation: false,
       to: stakingApi.validatorShareContract.address,
       txData: txDelegateData,
       gasPrice,
       gasLimit,
       tipGasPrice,
-      feeData,
     })
 
     await stakingProvider.notifyStaking({
@@ -147,24 +78,22 @@ export function createPolygonStakingService({
     return txId
   }
 
-  async function undelegate({ walletAccount, amount, feeData, waitForConfirmation = false } = {}) {
-    feeData = await resolveOptionalFeeData({ feeData })
-
-    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-    ])
+  async function undelegate({ walletAccount, amount } = {}) {
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
 
+    const { asset } = await getStakeAssets()
     amount = amountToCurrency({ asset, amount })
 
     const txUndelegateData = await stakingApi.undelegate({ amount })
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress.toLowerCase(),
-      to: stakingApi.validatorShareContract.address,
-      txInput: txUndelegateData,
-      feeData,
-    })
-
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
+      delegatorAddress.toLowerCase(),
+      stakingApi.validatorShareContract.address,
+      txUndelegateData
+    )
     return prepareAndSendTx({
       walletAccount,
       to: stakingApi.validatorShareContract.address,
@@ -172,26 +101,22 @@ export function createPolygonStakingService({
       gasPrice,
       gasLimit,
       tipGasPrice,
-      feeData,
-      waitForConfirmation,
     })
   }
 
-  async function claimRewards({ walletAccount, feeData } = {}) {
-    feeData = await resolveOptionalFeeData({ feeData })
-
-    const [delegatorAddress, { stakingApi }] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-    ])
+  async function claimRewards({ walletAccount } = {}) {
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
 
     const txWithdrawRewardsData = await stakingApi.withdrawRewards()
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.validatorShareContract.address,
-      txInput: txWithdrawRewardsData,
-      feeData,
-    })
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
+      delegatorAddress,
+      stakingApi.validatorShareContract.address,
+      txWithdrawRewardsData
+    )
     return prepareAndSendTx({
       walletAccount,
       to: stakingApi.validatorShareContract.address,
@@ -199,18 +124,17 @@ export function createPolygonStakingService({
       gasPrice,
       gasLimit,
       tipGasPrice,
-      feeData,
     })
   }
 
-  async function claimUndelegatedBalance({ walletAccount, unbondNonce, feeData } = {}) {
-    feeData = await resolveOptionalFeeData({ feeData })
-
-    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-    ])
+  async function claimUndelegatedBalance({ walletAccount, unbondNonce } = {}) {
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
 
+    const { asset } = await getStakeAssets()
     const { currency } = asset
     const unstakedClaimInfo = await fetchUnstakedClaimInfo({
       stakingApi,
@@ -225,12 +149,11 @@ export function createPolygonStakingService({
     })
 
     const txClaimUndelegatedData = await stakingApi.claimUndelegatedBalance({ unbondNonce })
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.validatorShareContract.address,
-      txInput: txClaimUndelegatedData,
-      feeData,
-    })
+    const { gasPrice, gasLimit, tipGasPrice, fee } = await estimateTxFee(
+      delegatorAddress,
+      stakingApi.validatorShareContract.address,
+      txClaimUndelegatedData
+    )
     const txId = await prepareAndSendTx({
       walletAccount,
       to: stakingApi.validatorShareContract.address,
@@ -238,7 +161,7 @@ export function createPolygonStakingService({
       gasPrice,
       gasLimit,
       tipGasPrice,
-      feeData,
+      fee,
     })
 
     await stakingProvider.notifyUnstaking({
@@ -251,42 +174,31 @@ export function createPolygonStakingService({
     return txId
   }
 
-  async function estimateDelegateOperation({
-    walletAccount,
-    operation,
-    args,
-    // NOTE: When estimating transactions, ideally we'd expect the `feeData`
-    //       that we intend to send the transaction using. If this is not
-    //       defined, we'll fallback to a default (with a warning).
-    feeData,
-  }) {
-    // HACK: For delegation transactions, we must fall back to the
-    //       custom implementation, since we can't currently estimate
-    //       the transaction due to a dependence upon approvals.
-    if (operation === 'delegate') return estimateDelegateTxFee({ feeData })
-
-    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-    ])
-
-    feeData = await resolveFeeData({ feeData })
-
+  async function estimateDelegateOperation({ walletAccount, operation, args }) {
     const delegateOperation = stakingApi[operation]
-    if (!delegateOperation) return
+
+    if (!delegateOperation) {
+      return
+    }
+
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
 
     const { amount } = args
     if (amount) {
+      const { asset } = await getStakeAssets()
       args = { ...args, amount: amountToCurrency({ asset, amount }) }
     }
 
     const operationTxData = await delegateOperation({ ...args, walletAccount })
-    const { fee } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.validatorShareContract.address,
-      txInput: operationTxData,
-      feeData,
-    })
+    const { fee } = await estimateTxFee(
+      delegatorAddress,
+      stakingApi.validatorShareContract.address,
+      operationTxData
+    )
 
     return fee
   }
@@ -301,27 +213,23 @@ export function createPolygonStakingService({
    * This is just for displaying purposes and it's just an aproximation of the delegate gas cost,
    * NOT the real fee cost
    */
-  async function estimateDelegateTxFee({ feeData } = {}) {
+  async function estimateDelegateTxFee() {
     // approx gas limits
     const { ethereum } = await assetClientInterface.getAssetsForNetwork({
       baseAssetName: 'ethereum',
     })
+    const erc20ApproveGas = 4900
+    const delegateGas = 240_000
+    const gasPrice = parseInt(await getServer(ethereum).gasPrice(), 16)
+    const extraPercentage = 20
+
+    const gasLimit = erc20ApproveGas + delegateGas
+    const gasLimitWithBuffer = new BN(gasLimit)
+      .imuln(100 + extraPercentage)
+      .idivn(100)
+      .toString()
 
-    feeData = await resolveFeeData({ feeData })
-
-    // TODO: update estimation to use a mock source address for
-    //       deposits so we can simulate the necessary approvals,
-    //       we shouldn't maintain constants like these
-    const erc20ApproveGas = 80_000
-    const delegateGas = 250_000
-
-    const { gasPrice } = getFeeFactoryGasPrices({ feeData })
-
-    const gasLimitWithBuffer = scaleGasLimitEstimate({
-      estimatedGasLimit: BigInt(erc20ApproveGas + delegateGas),
-    })
-
-    const fee = BigInt(gasLimitWithBuffer) * BigInt(gasPrice.toBaseNumber())
+    const fee = new BN(gasLimitWithBuffer).mul(new BN(gasPrice))
 
     return {
       gasLimit: gasLimitWithBuffer,
@@ -330,7 +238,7 @@ export function createPolygonStakingService({
     }
   }
 
-  async function estimateTxFee({ from, to, txInput, feeData }) {
+  async function estimateTxFee(from, to, txInput) {
     const { ethereum } = await assetClientInterface.getAssetsForNetwork({
       baseAssetName: 'ethereum',
     })
@@ -346,7 +254,13 @@ export function createPolygonStakingService({
       DISABLE_BALANCE_CHECKS
     )
 
-    return ethereum.api.getFee({ asset: ethereum, feeData, gasLimit, amount })
+    return getEvmStakingServiceFee({
+      amount,
+      asset: ethereum,
+      assetClientInterface,
+      maxPriorityFeePerGas: MAX_PRIORITY_FEE_PER_GAS,
+      gasLimit,
+    })
   }
 
   async function prepareAndSendTx({
@@ -357,7 +271,6 @@ export function createPolygonStakingService({
     gasLimit,
     tipGasPrice,
     waitForConfirmation = false,
-    feeData,
   } = {}) {
     const { ethereum: asset } = await assetClientInterface.getAssetsForNetwork({
       baseAssetName: 'ethereum',
@@ -375,7 +288,6 @@ export function createPolygonStakingService({
         tipGasPrice,
       },
       waitForConfirmation,
-      feeData,
     }
 
     const { txId } = await asset.baseAsset.api.sendTx(sendTxArgs)
@@ -497,8 +409,9 @@ async function fetchRewardsInfo({ stakingApi, delegator, currency }) {
   }
 }
 
-export async function getPolygonStakingInfo({ address, asset: { currency, baseAsset: feeAsset } }) {
-  const stakingApi = createStakingApiForFeeAsset({ feeAsset })
+export async function getPolygonStakingInfo({ address, asset, server }) {
+  const { currency } = asset
+  const stakingApi = new MaticStakingApi(undefined, undefined, server)
   const delegator = address.toLowerCase()
   const [
     delegatedBalance,

package/src/staking/utils/index.js

@@ -1,39 +1,73 @@
 import { isNumberUnit } from '@exodus/currency'
 
-export const DISABLE_BALANCE_CHECKS = '0x0'
-
 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),
+  }
+}
+
 /**
- * Previously, EVM staking services would determine `feeData`
- * dynamically on behalf of callers, however, this risks invalidating
- * fee estimation over the course of a sequence of multiple staking
- * transactions.
- *
- * For example, when determining the amount for a `sendAll`
- * transaction, if the gas price were to increase between estimation
- * and execution, this would invalidate the previous estimation.
- *
- * In future usage, we would want assets code to fetch FeeData from ACI,
- * construct a transaction including determining the fee and then report
- * back to the client what the fee is going to be.
- *
- * Importantly, the provided `feeData` must be sufficiently
- * up-to-date; else, we risk the transactions not being included at all.
+ * 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 const resolveFeeData = async ({
-  // TODO: maybe asset name would be better
+export async function getEvmStakingServiceFee({
+  amount,
   asset,
   assetClientInterface,
-  feeData,
-}) => {
-  if (feeData) return feeData
+  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)
 
-  console.warn(
-    'The evm staking service was not explicitly passed `feeData`. This can result in transaction nondeterminism.'
-  )
+  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,
+    },
+  })
 
-  return assetClientInterface.getFeeData({ assetName: asset.name })
+  // 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-send/get-fee-info.js

@@ -1,6 +1,4 @@
-import { ensureSaneEip1559GasPriceForTipGasPrice } from '../fee-utils.js'
 import { fetchGasLimit } from '../gas-estimation.js'
-import { getFeeFactoryGasPrices } from '../get-fee.js'
 
 const getFeeInfo = async function getFeeInfo({
   assetClientInterface,
@@ -10,48 +8,25 @@ const getFeeInfo = async function getFeeInfo({
   amount,
   txInput,
   feeOpts = {},
-  feeData,
-  customFee,
 }) {
-  // HACK: Previously, calls `getFeeInfo` were not provided a reference
-  //       to `feeData`. For backwards compatibility, we'll revert to
-  //       legacy behaviour.
-  // NOTE: This shouldn't actually be used outside of the `assets` repo;
-  //       this is done just for safety.
-  if (!feeData) {
-    console.warn('`getFeeInfo` was not explicitly passed a `feeData` object.')
-    const { name: assetName } = asset
-    feeData = await assetClientInterface.getFeeData({ assetName })
-  }
-
-  const {
-    gasPrice: gasPrice_,
-    feeData: { tipGasPrice: tipGasPrice_, eip1559Enabled },
-  } = getFeeFactoryGasPrices({ customFee, feeData })
-
-  const tipGasPrice = feeOpts.tipGasPrice || tipGasPrice_
+  const { gasPrice: gasPrice_, tipGasPrice: tipGasPrice_ } = await assetClientInterface.getFeeData({
+    assetName: asset.name,
+  })
 
-  const maybeGasPrice = feeOpts.gasPrice || gasPrice_
+  let { gasLimit, gasPrice = gasPrice_, tipGasPrice = tipGasPrice_ } = feeOpts
 
-  // HACK: If we've received an invalid combination of `tipGasPrice`
-  //       (maxPriorityFeePerGas) and `gasPrice` (maxFeePerGas), then
-  //       we must normalize these before returning.
-  const gasPrice = eip1559Enabled
-    ? ensureSaneEip1559GasPriceForTipGasPrice({ gasPrice: maybeGasPrice, tipGasPrice })
-    : maybeGasPrice
-
-  const gasLimit =
-    feeOpts.gasLimit ||
-    (await fetchGasLimit({
+  if (!gasLimit) {
+    gasLimit = await fetchGasLimit({
       asset,
       fromAddress,
       toAddress,
       amount,
       txInput,
       throwOnError: false,
-    }))
+    })
+  }
 
-  return { gasPrice, gasLimit, tipGasPrice, eip1559Enabled }
+  return { gasPrice, gasLimit, tipGasPrice }
 }
 
 export default getFeeInfo

package/src/tx-send/nonce-utils.js

@@ -7,11 +7,10 @@ export const resolveNonce = async ({
   providedNonce,
   txLog,
   triedNonce,
-  tag = 'latest', // use 'pending' for unconfirmed txs
 }) => {
   const nonceFromNode =
     asset.baseAsset?.api?.features?.noHistory || forceFromNode
-      ? await getNonce({ asset: asset.baseAsset, address: fromAddress, tag })
+      ? await getNonce({ asset: asset.baseAsset, address: fromAddress, tag: 'latest' }) // maybe 'pending' to unconfirmed txs
       : 0
 
   const nonceFromLog = [...txLog]