@exodus/ethereum-api 8.34.6 → 8.35.1

package/src/staking/matic/service.js

@@ -1,71 +1,140 @@
-import BN from 'bn.js'
+import { memoize } from '@exodus/basic-utils'
 
-import { getServer } from '../../exodus-eth-server/index.js'
-import { estimateGasLimit } from '../../gas-estimation.js'
+import { estimateGasLimit, scaleGasLimitEstimate } from '../../gas-estimation.js'
+import { getFeeFactoryGasPrices } from '../../get-fee.js'
 import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
 import { stakingProviderClientFactory } from '../staking-provider-client.js'
-import { amountToCurrency, getEvmStakingServiceFee } from '../utils/index.js'
+import {
+  amountToCurrency,
+  DISABLE_BALANCE_CHECKS,
+  resolveFeeData as defaultResolveFeeData,
+} 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
+const createStakingApiForFeeAsset = ({ feeAsset: { server } }) =>
+  new MaticStakingApi(undefined, undefined, server)
 
+// 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()
 
-  async function getStakeAssets() {
-    const { polygon: asset, ethereum: feeAsset } = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: assetName,
-    })
+  const getStakeAssets = memoize(async () => {
+    const { polygon: asset, [assetName]: 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 })
   }
 
-  async function delegate({ walletAccount, amount } = {}) {
+  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 }) => {
     const address = await assetClientInterface.getReceiveAddress({
       assetName,
       walletAccount,
     })
-    const delegatorAddress = address.toLowerCase()
+    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 { asset } = await getStakeAssets()
     amount = amountToCurrency({ asset, amount })
 
     const txApproveData = await stakingApi.approveStakeManager(amount)
-    let { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
-      delegatorAddress,
-      stakingApi.polygonContract.address,
-      txApproveData
-    )
+    let { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingApi.polygonContract.address,
+      txInput: txApproveData,
+      feeData,
+    })
     await prepareAndSendTx({
       walletAccount,
-      waitForConfirmation: true,
+      waitForConfirmation,
       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(
-      delegatorAddress,
-      stakingApi.validatorShareContract.address,
-      txDelegateData
-    ))
+    ;({ gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingApi.validatorShareContract.address,
+      txInput: txDelegateData,
+      feeData,
+    }))
 
     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({
@@ -78,22 +147,24 @@ export function createPolygonStakingService({
     return txId
   }
 
-  async function undelegate({ walletAccount, amount } = {}) {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
+  async function undelegate({ walletAccount, amount, feeData, waitForConfirmation = false } = {}) {
+    feeData = await resolveOptionalFeeData({ feeData })
+
+    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
+      getDelegatorAddress({ walletAccount }),
+      createStakingApi(),
+    ])
 
-    const { asset } = await getStakeAssets()
     amount = amountToCurrency({ asset, amount })
 
     const txUndelegateData = await stakingApi.undelegate({ amount })
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
-      delegatorAddress.toLowerCase(),
-      stakingApi.validatorShareContract.address,
-      txUndelegateData
-    )
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+      from: delegatorAddress.toLowerCase(),
+      to: stakingApi.validatorShareContract.address,
+      txInput: txUndelegateData,
+      feeData,
+    })
+
     return prepareAndSendTx({
       walletAccount,
       to: stakingApi.validatorShareContract.address,
@@ -101,22 +172,26 @@ export function createPolygonStakingService({
       gasPrice,
       gasLimit,
       tipGasPrice,
+      feeData,
+      waitForConfirmation,
     })
   }
 
-  async function claimRewards({ walletAccount } = {}) {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
+  async function claimRewards({ walletAccount, feeData } = {}) {
+    feeData = await resolveOptionalFeeData({ feeData })
+
+    const [delegatorAddress, { stakingApi }] = await Promise.all([
+      getDelegatorAddress({ walletAccount }),
+      createStakingApi(),
+    ])
 
     const txWithdrawRewardsData = await stakingApi.withdrawRewards()
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee(
-      delegatorAddress,
-      stakingApi.validatorShareContract.address,
-      txWithdrawRewardsData
-    )
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingApi.validatorShareContract.address,
+      txInput: txWithdrawRewardsData,
+      feeData,
+    })
     return prepareAndSendTx({
       walletAccount,
       to: stakingApi.validatorShareContract.address,
@@ -124,17 +199,18 @@ export function createPolygonStakingService({
       gasPrice,
       gasLimit,
       tipGasPrice,
+      feeData,
     })
   }
 
-  async function claimUndelegatedBalance({ walletAccount, unbondNonce } = {}) {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
+  async function claimUndelegatedBalance({ walletAccount, unbondNonce, feeData } = {}) {
+    feeData = await resolveOptionalFeeData({ feeData })
+
+    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
+      getDelegatorAddress({ walletAccount }),
+      createStakingApi(),
+    ])
 
-    const { asset } = await getStakeAssets()
     const { currency } = asset
     const unstakedClaimInfo = await fetchUnstakedClaimInfo({
       stakingApi,
@@ -149,11 +225,12 @@ export function createPolygonStakingService({
     })
 
     const txClaimUndelegatedData = await stakingApi.claimUndelegatedBalance({ unbondNonce })
-    const { gasPrice, gasLimit, tipGasPrice, fee } = await estimateTxFee(
-      delegatorAddress,
-      stakingApi.validatorShareContract.address,
-      txClaimUndelegatedData
-    )
+    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingApi.validatorShareContract.address,
+      txInput: txClaimUndelegatedData,
+      feeData,
+    })
     const txId = await prepareAndSendTx({
       walletAccount,
       to: stakingApi.validatorShareContract.address,
@@ -161,7 +238,7 @@ export function createPolygonStakingService({
       gasPrice,
       gasLimit,
       tipGasPrice,
-      fee,
+      feeData,
     })
 
     await stakingProvider.notifyUnstaking({
@@ -174,31 +251,42 @@ export function createPolygonStakingService({
     return txId
   }
 
-  async function estimateDelegateOperation({ walletAccount, operation, args }) {
-    const delegateOperation = stakingApi[operation]
-
-    if (!delegateOperation) {
-      return
-    }
+  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 })
 
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
+    const delegateOperation = stakingApi[operation]
+    if (!delegateOperation) return
 
     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(
-      delegatorAddress,
-      stakingApi.validatorShareContract.address,
-      operationTxData
-    )
+    const { fee } = await estimateTxFee({
+      from: delegatorAddress,
+      to: stakingApi.validatorShareContract.address,
+      txInput: operationTxData,
+      feeData,
+    })
 
     return fee
   }
@@ -213,23 +301,27 @@ 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() {
+  async function estimateDelegateTxFee({ feeData } = {}) {
     // 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()
 
-    const fee = new BN(gasLimitWithBuffer).mul(new BN(gasPrice))
+    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())
 
     return {
       gasLimit: gasLimitWithBuffer,
@@ -238,7 +330,7 @@ export function createPolygonStakingService({
     }
   }
 
-  async function estimateTxFee(from, to, txInput) {
+  async function estimateTxFee({ from, to, txInput, feeData }) {
     const { ethereum } = await assetClientInterface.getAssetsForNetwork({
       baseAssetName: 'ethereum',
     })
@@ -254,13 +346,7 @@ export function createPolygonStakingService({
       DISABLE_BALANCE_CHECKS
     )
 
-    return getEvmStakingServiceFee({
-      amount,
-      asset: ethereum,
-      assetClientInterface,
-      maxPriorityFeePerGas: MAX_PRIORITY_FEE_PER_GAS,
-      gasLimit,
-    })
+    return ethereum.api.getFee({ asset: ethereum, feeData, gasLimit, amount })
   }
 
   async function prepareAndSendTx({
@@ -271,6 +357,7 @@ export function createPolygonStakingService({
     gasLimit,
     tipGasPrice,
     waitForConfirmation = false,
+    feeData,
   } = {}) {
     const { ethereum: asset } = await assetClientInterface.getAssetsForNetwork({
       baseAssetName: 'ethereum',
@@ -288,6 +375,7 @@ export function createPolygonStakingService({
         tipGasPrice,
       },
       waitForConfirmation,
+      feeData,
     }
 
     const { txId } = await asset.baseAsset.api.sendTx(sendTxArgs)
@@ -409,9 +497,8 @@ async function fetchRewardsInfo({ stakingApi, delegator, currency }) {
   }
 }
 
-export async function getPolygonStakingInfo({ address, asset, server }) {
-  const { currency } = asset
-  const stakingApi = new MaticStakingApi(undefined, undefined, server)
+export async function getPolygonStakingInfo({ address, asset: { currency, baseAsset: feeAsset } }) {
+  const stakingApi = createStakingApiForFeeAsset({ feeAsset })
   const delegator = address.toLowerCase()
   const [
     delegatedBalance,

package/src/staking/utils/index.js

@@ -1,73 +1,39 @@
 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),
-  }
-}
-
 /**
- * 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.
+ * 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.
  */
-export async function getEvmStakingServiceFee({
-  amount,
+export const resolveFeeData = async ({
+  // TODO: maybe asset name would be better
   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)
+  feeData,
+}) => {
+  if (feeData) return feeData
 
-  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,
-    },
-  })
+  console.warn(
+    'The evm staking service was not explicitly passed `feeData`. This can result in transaction nondeterminism.'
+  )
 
-  // Returns `fee`, `gasPrice`, `extraFeeData`, and `tipGasPrice`
-  // if the config defines we should `useBaseGasPrice`.
-  return asset.api.getFee({
-    asset,
-    feeData: normalizedFeeData,
-    gasLimit,
-    amount,
-  })
+  return assetClientInterface.getFeeData({ assetName: asset.name })
 }

package/src/tx-log/clarity-monitor.js

@@ -156,13 +156,36 @@ export class ClarityMonitor extends BaseMonitor {
       currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
       ourWalletAddress: derivedData.ourWalletAddress,
     })
-    await this.updateAccountState({
+
+    const batch = this.aci.createOperationsBatch()
+
+    this.aci.removeTxLogBatch({
+      assetName,
+      walletAccount,
+      txs: txsToRemove,
+      batch,
+    })
+
+    for (const [assetName, txs] of Object.entries(logItemsByAsset)) {
+      this.aci.updateTxLogAndNotifyBatch({
+        assetName,
+        walletAccount,
+        txs,
+        refresh,
+        batch,
+      })
+    }
+
+    this.aci.updateAccountStateBatch({
+      assetName,
       walletAccount,
+      accountState,
       newData: { clarityCursor: response.cursor, ...accountState },
+      batch,
     })
 
-    await this.removeFromTxLog(txsToRemove)
-    await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })
+    await this.aci.executeOperationsBatch(batch)
+
     if (refresh || hasNewTxs) {
       const unknownTokenAddresses = this.getUnknownTokenAddresses({
         transactions: allTxs,

package/src/tx-send/get-fee-info.js

@@ -1,4 +1,6 @@
+import { ensureSaneEip1559GasPriceForTipGasPrice } from '../fee-utils.js'
 import { fetchGasLimit } from '../gas-estimation.js'
+import { getFeeFactoryGasPrices } from '../get-fee.js'
 
 const getFeeInfo = async function getFeeInfo({
   assetClientInterface,
@@ -8,25 +10,48 @@ const getFeeInfo = async function getFeeInfo({
   amount,
   txInput,
   feeOpts = {},
+  feeData,
+  customFee,
 }) {
-  const { gasPrice: gasPrice_, tipGasPrice: tipGasPrice_ } = await assetClientInterface.getFeeData({
-    assetName: asset.name,
-  })
+  // 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_
 
-  let { gasLimit, gasPrice = gasPrice_, tipGasPrice = tipGasPrice_ } = feeOpts
+  const maybeGasPrice = feeOpts.gasPrice || gasPrice_
 
-  if (!gasLimit) {
-    gasLimit = await fetchGasLimit({
+  // 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({
       asset,
       fromAddress,
       toAddress,
       amount,
       txInput,
       throwOnError: false,
-    })
-  }
+    }))
 
-  return { gasPrice, gasLimit, tipGasPrice }
+  return { gasPrice, gasLimit, tipGasPrice, eip1559Enabled }
 }
 
 export default getFeeInfo

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

@@ -7,10 +7,11 @@ 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: 'latest' }) // maybe 'pending' to unconfirmed txs
+      ? await getNonce({ asset: asset.baseAsset, address: fromAddress, tag })
       : 0
 
   const nonceFromLog = [...txLog]