@exodus/ethereum-api 9.0.0-alpha.3 → 9.0.0

package/src/tx-log-staking-processor/index.js

@@ -1,27 +1,41 @@
-import { assetStakingTxData } from './asset-staking-tx-data'
-import { getStakeTxAmount } from './get-asset-tx-amount'
+import { getPolygonUndelegateTxInEthereumTxLog } from '../staking/matic/matic-staking-utils.js'
+import { assetStakingTxProps } from './asset-staking-tx-data.js'
 
-const getTxStakeData = ({ assetName, currency, tx, server }) => {
-  return assetStakingTxData[assetName]({ tx, currency, server })
+const getAssetExpandedTxLog = async ({ assetName, aci, txs, walletAccount }) => {
+  const additionalTxs = []
+  if (assetName === 'polygon') {
+    const ethereumTxLog = await aci.getTxLog({ walletAccount, assetName: 'ethereum' })
+    const polygonUndelegateTxs = getPolygonUndelegateTxInEthereumTxLog(ethereumTxLog)
+
+    for (const tx of polygonUndelegateTxs) {
+      if (txs.has(tx.txId)) continue
+
+      additionalTxs.push(tx)
+    }
+  }
+
+  return additionalTxs
 }
 
-const processTxLog = async ({ asset, assetClientInterface: aci, walletAccount, batch, server }) => {
+const processTxLog = async ({ asset, assetClientInterface: aci, walletAccount, batch }) => {
   const { name: assetName, currency } = asset
   const txs = await aci.getTxLog({ assetName, walletAccount })
 
   const newTxs = []
   for (const tx of txs) {
-    const txStakeData = getTxStakeData({ assetName, currency, tx, server })
-    if (txStakeData) {
-      const txAmount = getStakeTxAmount[assetName]({ tx, currency, type: txStakeData, server })
-      newTxs.push({
-        ...tx,
-        coinAmount: txAmount,
-        data: { ...tx.data, ...txStakeData },
-      })
-    }
+    const stakingProps = assetStakingTxProps[assetName]?.({ tx, currency })
+    if (!stakingProps) continue
+
+    newTxs.push({
+      ...tx,
+      ...stakingProps,
+      data: { ...tx.data, ...stakingProps.data },
+    })
   }
 
+  const expandedTxs = await getAssetExpandedTxLog({ assetName, aci, txs, walletAccount })
+  newTxs.push(...expandedTxs)
+
   if (newTxs.length > 0) {
     aci.updateTxLogAndNotifyBatch({ assetName, walletAccount, txs: newTxs, batch })
   }

package/src/tx-log-staking-processor/utils.js

@@ -1,9 +1,18 @@
-import { EthereumStaking, isEthereumStakingTx, MaticStakingApi } from '../staking'
 import { asset as ethereum } from '@exodus/ethereum-meta'
-import { asset as ethereumholesky } from '@exodus/ethereumholesky-meta'
 
-export const decodePolygonStakingTxInputAmount = ({ tx, server }) => {
-  const polygonStakingApi = new MaticStakingApi({ server })
+import { EthereumStaking } from '../staking/ethereum/api.js'
+import { isEthereumStakingTx } from '../staking/ethereum/staking-utils.js'
+import { MaticStakingApi } from '../staking/matic/api.js'
+
+const polygonStakingApi = new MaticStakingApi()
+const ethereumStakingApi = new EthereumStaking(
+  ethereum.name,
+  ethereum.currency,
+  undefined,
+  undefined
+)
+
+export const decodePolygonStakingTxInputAmount = (tx) => {
   const {
     data: { data: txInput },
   } = tx
@@ -15,43 +24,35 @@ export const decodePolygonStakingTxInputAmount = ({ tx, server }) => {
   return amount
 }
 
-export const calculateTxAmountAndRewardFromStakeTx = ({ tx, currency, server }) => {
-  const stakedAmount = currency.baseUnit(decodePolygonStakingTxInputAmount({ tx, server }))
-  const { reward } = tx.data
+export const calculateRewardsFromStakeTx = ({ tx, currency }) => {
+  const stakedAmount = currency.baseUnit(decodePolygonStakingTxInputAmount(tx))
+  const { rewards } = tx.data
   // stake tx might have rewards in it,
   // i.e: https://etherscan.io/tx/0x0a81d266109034a3a70c6f1b9601c105d8caebbd0de652a0619344f9559ae4fa
   // thus reward = txInputAmount(amount to stake) - tx.coinAmount
   // tx.coinAmount is already computed from monitor; incoming - outgoing ERC20 token txs
   const stakeTxContainsReward = !stakedAmount.equals(tx.coinAmount.abs())
 
-  if (reward) {
+  if (rewards) {
     // cache rewards
-    return currency.baseUnit(reward)
+    return rewards
   }
 
   if (stakeTxContainsReward) {
     const txAmount = stakedAmount.sub(tx.coinAmount.abs()).abs()
-    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only -- TODO: Fix this the next time the file is edited.
-    tx.data.reward = txAmount.toBaseString()
-    return txAmount
+    // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only -- TODO: Fix this the next time the file is edited.
+    return txAmount.toDefaultString()
   }
-
-  // no rewards, set stake tx amount to ZERO
-  return currency.ZERO
 }
 
-export const decodeEthLikeStakingTxInputAmount = ({ tx, server }) => {
+export const decodeEthLikeStakingTxInputAmount = (tx) => {
   const {
     data: { data: txInput },
     coinName: assetName,
   } = tx
 
-  const ethereumStakingApi = new EthereumStaking({ asset: ethereum, server })
-  const ethereumHoleskyStakingApi = new EthereumStaking({ asset: ethereumholesky, server })
-
   const ethereumLikeContracts = {
     ethereum: ethereumStakingApi,
-    ethereumholesky: ethereumHoleskyStakingApi,
   }
 
   const ethLikeContract = ethereumLikeContracts[assetName]

package/src/tx-send/broadcast-error-handler.js

@@ -0,0 +1,63 @@
+import { EthLikeError, EVM_ERROR_REASONS, getEvmErrorReason } from '../error-wrapper.js'
+import { transactionExists } from '../eth-like-util.js'
+
+/**
+ * Handles broadcast errors by parsing the error message and either throwing
+ * an appropriate EthLikeError or returning info for retry logic.
+ *
+ * @param {Error} err - The error from broadcastTx.
+ * @param {Object} options - Context for error handling.
+ * @param {Object} options.asset - The asset.
+ * @param {string} options.txId - The transaction ID.
+ * @param {boolean} options.isHardware - Whether this is a hardware wallet.
+ * @param {string} options.hint - Hint for the error.
+ * @param {boolean} options.isBumpTx - Whether the occur occured whilst bumping a Tx.
+ * @param {boolean} options.isRetryNonceTx - If the error occurred during a nonce bump.
+ * @returns {Promise<{ shouldRetry: boolean }>} - Returns if nonce too low and can retry.
+ * @throws {EthLikeError} - Throws for all other error cases.
+ */
+export const handleBroadcastError = async (
+  err,
+  { asset, txId, isHardware, hint, isBumpTx, isRetryNonceTx }
+) => {
+  const message = err.message
+
+  const errorInfo = getEvmErrorReason(message) || EVM_ERROR_REASONS.broadcastTxFailed
+
+  const isNonceTooLow = errorInfo.reason === EVM_ERROR_REASONS.nonceTooLow.reason
+  const isAmbiguousError =
+    isNonceTooLow || errorInfo.reason === EVM_ERROR_REASONS.transactionUnderpriced.reason
+
+  if (errorInfo.reason === EVM_ERROR_REASONS.alreadyKnown.reason) {
+    console.debug('tx already broadcast')
+    return { shouldRetry: false }
+  }
+
+  let txAlreadyExists = false
+  if (isAmbiguousError) {
+    try {
+      txAlreadyExists = await transactionExists({ asset, txId })
+    } catch (verifyErr) {
+      // Can't verify - fall through to original error handling
+      console.warn('Could not verify tx existence:', verifyErr.message)
+    }
+  }
+
+  if (txAlreadyExists) {
+    console.debug('tx already broadcast')
+    return { shouldRetry: false }
+  }
+
+  // NOTE: Don't auto-retry nonce repair for bump/replacement txs.
+  // A replacement must keep the *same nonce* as the tx it's replacing.
+  // If we "fix" a bump tx by advancing the nonce, we create a brand-new tx instead of replacing the pending one.
+  if (isNonceTooLow && !isHardware && !isBumpTx && !isRetryNonceTx) return { shouldRetry: true }
+
+  throw new EthLikeError({
+    message: err.message,
+    errorReasonInfo: errorInfo,
+    hint,
+    traceId: err.traceId,
+    baseAssetName: asset.baseAsset.name,
+  })
+}

package/src/tx-send/index.js

@@ -1,2 +1 @@
-export { default as txSendFactory } from './tx-send'
-export { default as getFeeInfo } from './get-fee-info'
+export { default as txSendFactory } from './tx-send.js'

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

@@ -0,0 +1,97 @@
+import assert from 'minimalistic-assert'
+
+import { getNonce } from '../eth-like-util.js'
+import { getLatestCanonicalAbsoluteNonceTx } from '../tx-log/clarity-utils/absolute.js'
+
+export const BLOCK_TAG_LATEST = 'latest'
+export const BLOCK_TAG_PENDING = 'pending'
+
+const VALID_BLOCK_TAGS = new Set([BLOCK_TAG_LATEST, BLOCK_TAG_PENDING])
+
+// NOTE: We do not yet support tags at arbitrary block heights.
+const assertValidBlockTag = (tag) => assert(VALID_BLOCK_TAGS.has(tag), `invalid tag "${tag}"`)
+
+export const resolveNonce = async ({
+  asset,
+  forceFromNode,
+  fromAddress,
+  txLog, // TxSet expected. Array only for testing purposes.
+  accountState,
+  tag = BLOCK_TAG_LATEST,
+  useAbsoluteNonce,
+}) => {
+  assertValidBlockTag(tag)
+
+  if (asset.baseAsset?.api?.features?.noHistory || forceFromNode) {
+    return getNonce({ asset: asset.baseAsset, address: fromAddress, tag })
+  }
+
+  const nonceFromTxLog = getNonceFromTxLog({ txLog, useAbsoluteNonce, tag })
+
+  // `accountState.nonce` is the single source of truth — clarity-truncated-history
+  // collapses both `account_balance` and `truncated` source nonces into this field.
+  const nonceFromAccountState = accountState?.nonce || 0
+
+  return Math.max(nonceFromTxLog, nonceFromAccountState)
+}
+
+const getLatestTxWithNonceChange = ({ reversedTxLog }) => {
+  assert(reversedTxLog, 'expected reversedTxLog')
+
+  const maybeLatestAbsoluteNonceTx = getLatestCanonicalAbsoluteNonceTx({
+    reversedTxLog,
+  })
+
+  if (maybeLatestAbsoluteNonceTx) return maybeLatestAbsoluteNonceTx
+
+  for (const tx of reversedTxLog) {
+    if (tx.data.nonceChange) {
+      return tx
+    }
+  }
+}
+
+/**
+ * Computes the next nonce from the given `txLog`.
+ *
+ * @param {Object} options
+ * @param {import('@exodus/models').TxSet} options.txLog - A `TxSet` from
+ *     `@exodus/models`, NOT a plain `Array`.
+ * @param {boolean} [options.useAbsoluteNonce]
+ * @param {string} [options.tag]
+ * @returns {number}
+ */
+const getNonceFromTxLog = ({ txLog, useAbsoluteNonce, tag }) => {
+  if (!txLog || txLog.size === 0) return 0
+
+  let absoluteNonce = 0
+
+  if (useAbsoluteNonce) {
+    // NOTE: `TxSet#reverse()` returns a one-shot iterable yielding txs
+    //       in reverse order — it is NOT an in-place reversal like
+    //       `Array.prototype.reverse()`, so the caller's `txLog` is
+    //       left untouched.
+    const reversedTxLog = txLog.reverse()
+    const maybeLatestTxWithNonceChange = getLatestTxWithNonceChange({ reversedTxLog })
+
+    if (maybeLatestTxWithNonceChange) {
+      // NOTE: This is the latest nonce currently confirmed by
+      //       Clarity, which lags behind `CLARITY_MIN_CONFIRMS`
+      //       depth:
+      //
+      //       https://github.com/ExodusMovement/clarity/blob/4a6ea30fce33246d1ef1440e61b0a84b876900d6/deployment/eth-clarity-indexer/values.yaml#L34
+      absoluteNonce = parseInt(maybeLatestTxWithNonceChange.data.nonceChange.to, 10)
+    }
+  }
+
+  // TODO: can't we iterate in reverse up to the first (few) nonce(s)?
+  const nonceFromLog = [...txLog]
+    .filter((tx) => tx.sent && !tx.dropped && tx.data.nonce != null)
+    // NOTE: If we're only considering the `'latest'` block `tag`,
+    //       then we should not take into account unconfirmed
+    //       transactions when computing the `nonce`.
+    .filter((tx) => tag !== BLOCK_TAG_LATEST || !tx.pending)
+    .reduce((nonce, tx) => Math.max(tx.data.nonce + 1, nonce), 0)
+
+  return Math.max(absoluteNonce, nonceFromLog)
+}