@exodus/ethereum-api 8.78.1 → 8.79.0

package/CHANGELOG.md

@@ -3,6 +3,71 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.79.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.1...@exodus/ethereum-api@8.79.0) (2026-08-18)
+
+
+### Features
+
+
+* feat: source eip7702 delegation whitelist from remote config (#8356)
+
+
+### Bug Fixes
+
+
+* fix: disable @exodus/hydra/no-param-reassign-prop-only warnings (#8531)
+
+* fix(ethereum-api): detect legacy delegate transactions (#8357)
+
+* fix(ethereum-api): preserve live pending txs across refresh to prevent nonce reuse (#8430)
+
+* fix(ethereum-api): preserve precision for wei values in tx simulation (#7920)
+
+* fix(ethereum-api): reference defined ethereum asset in simulate-tx tests (#8525)
+
+* fix(ethereum): prevent silently dropped zero-tip private bundles (#8493)
+
+* fix(lint): add explicit process imports and enforce no-implicit-process (#8530)
+
+* fix(lint): convert console.log/info to console.debug and enforce no-console (#8529)
+
+* fix(lint): fix import/named warnings and upgrade to error (#8496)
+
+* fix(lint): fix JSDoc warnings across multiple packages (#8519)
+
+* fix(lint): fix no-throw-literal warnings and upgrade to error (#8498)
+
+* fix(lint): fix oxlint warnings and convert rules to error (#8489)
+
+* fix(simulation): route recipient changes to dedicated field, guard asset-less entries (#8370)
+
+* fix: upgrade low-complexity lint rules to error (#8510)
+
+
+
+## [8.78.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.1...@exodus/ethereum-api@8.78.2) (2026-08-14)
+
+
+### Features
+
+* source eip7702 delegation whitelist from remote config ([#8356](https://github.com/ExodusMovement/assets/issues/8356)) ([1a0966b](https://github.com/ExodusMovement/assets/commit/1a0966b08befb6e9310993f323c21d003dea2754))
+
+
+### Bug Fixes
+
+* **ethereum-api:** detect legacy delegate transactions ([#8357](https://github.com/ExodusMovement/assets/issues/8357)) ([070e529](https://github.com/ExodusMovement/assets/commit/070e5295f21f12695e97e721ff8c0601c553e447))
+* **ethereum-api:** preserve precision for wei values in tx simulation ([#7920](https://github.com/ExodusMovement/assets/issues/7920)) ([5c99258](https://github.com/ExodusMovement/assets/commit/5c9925871d450167fcf23e33ba62e100a2d71a9b))
+* **ethereum-api:** reference defined ethereum asset in simulate-tx tests ([#8525](https://github.com/ExodusMovement/assets/issues/8525)) ([27a8918](https://github.com/ExodusMovement/assets/commit/27a8918f5ba3112f1830ac0111a43d30921aa3b3))
+* **ethereum:** prevent silently dropped zero-tip private bundles ([#8493](https://github.com/ExodusMovement/assets/issues/8493)) ([67dd1ff](https://github.com/ExodusMovement/assets/commit/67dd1ffd7e1c22e7119b1781968c4be321ab1822))
+* **lint:** fix import/named warnings and upgrade to error ([#8496](https://github.com/ExodusMovement/assets/issues/8496)) ([8d290c9](https://github.com/ExodusMovement/assets/commit/8d290c948a0d3c2c1897287cb133f9d26cad73b0))
+* **lint:** fix JSDoc warnings across multiple packages ([#8519](https://github.com/ExodusMovement/assets/issues/8519)) ([5fefcd5](https://github.com/ExodusMovement/assets/commit/5fefcd5af996efbe9587cecba540efc7f469ceb2))
+* **lint:** fix no-throw-literal warnings and upgrade to error ([#8498](https://github.com/ExodusMovement/assets/issues/8498)) ([8fc68eb](https://github.com/ExodusMovement/assets/commit/8fc68eb65682e0b5a7da9415410ee1dedf309696))
+* **lint:** fix oxlint warnings and convert rules to error ([#8489](https://github.com/ExodusMovement/assets/issues/8489)) ([19d35be](https://github.com/ExodusMovement/assets/commit/19d35be718391303d331978926884f2f376b356f))
+* **simulation:** route recipient changes to dedicated field, guard asset-less entries ([#8370](https://github.com/ExodusMovement/assets/issues/8370)) ([c0a082b](https://github.com/ExodusMovement/assets/commit/c0a082b6c80710408337ff9285a19fb657c656be))
+* upgrade low-complexity lint rules to error ([#8510](https://github.com/ExodusMovement/assets/issues/8510)) ([25016bd](https://github.com/ExodusMovement/assets/commit/25016bdf43526c6bc9efe2771f92f1ae1ebf7cd7))
+
+
+
 ## [8.78.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.1...@exodus/ethereum-api@8.78.1) (2026-08-13)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.78.1",
+  "version": "8.79.0",
   "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",
@@ -17,7 +17,7 @@
     "provenance": false
   },
   "scripts": {
-    "test": "run -T exodus-test --jest"
+    "test": "exodus-test --jest"
   },
   "dependencies": {
     "@exodus/asset": "^2.0.4",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "5c444367f50e09f2f5f5c1c65829c2b07c473549"
+  "gitHead": "85b01e122492dcdd4205ed06df8f4c0af545d25b"
 }

package/src/allowance/index.js

@@ -1,4 +1,3 @@
-// eslint-disable-next-line @exodus/import/no-deprecated
 import { isNumberUnit } from '@exodus/currency'
 import { buffer2currency, createUnsignedTxFactory } from '@exodus/ethereum-lib'
 import { bufferToInt } from '@exodus/ethereumjs/util'
@@ -46,7 +45,6 @@ export const buildApproveTx = async ({
 }) => {
   assert(asset, 'expected asset')
   assert(feeData, 'expected feeData')
-  // eslint-disable-next-line @exodus/import/no-deprecated
   assert(isNumberUnit(approveAmount), 'expected approveAmount')
   assert(typeof spenderAddress === 'string', 'expected spenderAddress')
   assert(walletAccount, 'expected walletAccount')
@@ -231,7 +229,7 @@ export const createApproveSpendingTokens =
 
       txIds.push(revokeTokenApprovalTxId)
       // Hardcoded min gas limit. Otherwise `fetchGasLimit` will fail since `approve(_spender, 0)` is not yet confirmed
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       data.gasLimit = Math.max(data.gasLimit || 0, APPROVAL_GAS_LIMIT)
     }
 

package/src/create-asset-utils.js

@@ -1,4 +1,5 @@
 import { BlacklistCheckTypes } from '@exodus/asset-lib'
+import { parseUnsignedTx } from '@exodus/ethereum-lib'
 import { defaultAbiCoder } from '@exodus/ethereumjs/ethers5-abi'
 import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
@@ -61,7 +62,7 @@ export const resolveMonitorSettings = (
   }
 
   const fallbackWithWarning = (msg) => {
-    console.log([msg, `Falling back to ${defaultMonitorType}<${defaultServerUrl}>.`].join(' '))
+    console.debug([msg, `Falling back to ${defaultMonitorType}<${defaultServerUrl}>.`].join(' '))
     return defaultResolution
   }
 
@@ -112,6 +113,29 @@ const assertSendPrivateTxProps = ({ asset, unsignedTx, walletAccount }) => {
   assert(walletAccount, 'expected walletAccount')
 }
 
+// Block builders drop private transactions that carry no bid — accepted by
+// the relay but never included on chain (ExodusMovement/assets#8084). The
+// effective bid is min(tipGasPrice, gasPrice - baseFeePerGas): `gasPrice` is
+// the maxFeePerGas ceiling for EIP-1559 transactions and the all-in price
+// for legacy ones, so either term at zero kills the bid.
+const assertNonZeroTipGasPrice = async ({ asset, assetClientInterface, unsignedTx }) => {
+  const { eip1559Enabled, gasPrice, tipGasPrice } = parseUnsignedTx({ asset, unsignedTx })
+
+  if (eip1559Enabled && (!tipGasPrice || tipGasPrice.isZero)) {
+    throw new Error(
+      'ERR_PRIVATE_TX_ZERO_TIP: transaction pays no tipGasPrice; block builders drop zero-bid private transactions'
+    )
+  }
+
+  const feeData = await assetClientInterface.getFeeConfig({ assetName: asset.baseAsset.name })
+  const baseFeePerGas = feeData?.baseFeePerGas
+  if (!baseFeePerGas || gasPrice.gt(baseFeePerGas)) return
+
+  throw new Error(
+    `ERR_PRIVATE_TX_ZERO_TIP: transaction gasPrice (${gasPrice.toBaseString()}) does not exceed baseFeePerGas (${baseFeePerGas.toBaseString()}); block builders drop zero-bid private transactions`
+  )
+}
+
 export const createTransactionPrivacyResult = ({
   assetClientInterface,
   broadcastPrivateBundle,
@@ -123,6 +147,7 @@ export const createTransactionPrivacyResult = ({
 
   const sendPrivateTx = async ({ asset, unsignedTx, walletAccount }) => {
     assertSendPrivateTxProps({ asset, unsignedTx, walletAccount })
+    await assertNonZeroTipGasPrice({ asset, assetClientInterface, unsignedTx })
 
     const { rawTx, txId } = await signTx({
       asset,
@@ -160,6 +185,10 @@ export const createTransactionPrivacyResult = ({
 
     unsignedTxBundle.forEach(assertSendPrivateTxProps)
 
+    for (const { asset, unsignedTx } of unsignedTxBundle) {
+      await assertNonZeroTipGasPrice({ asset, assetClientInterface, unsignedTx })
+    }
+
     const signTxResults = await Promise.all(
       unsignedTxBundle.map(({ asset, unsignedTx, walletAccount }) =>
         signTx({ assetClientInterface, asset, unsignedTx, walletAccount })
@@ -288,7 +317,7 @@ export const createHistoryMonitorFactory = ({
     let monitor
     switch (monitorType) {
       case 'clarity-v3':
-        console.log('clarity-v3 is no longer supported, falling back to clarity-v2')
+        console.debug('clarity-v3 is no longer supported, falling back to clarity-v2')
       // eslint-disable-next-line no-fallthrough
       case 'clarity':
       case 'clarity-v2':

package/src/ens/index.js

@@ -1,4 +1,3 @@
-// eslint-disable-next-line @exodus/import/no-deprecated
 import { hashSync } from '@exodus/crypto/hash'
 import { ABI } from '@exodus/ethereum-lib'
 import SolidityContract from '@exodus/solidity-contract'
@@ -25,7 +24,6 @@ function namehash(inputName) {
   const name = normalize(inputName)
   if (name) {
     for (const label of name.split('.').reverse()) {
-      // eslint-disable-next-line @exodus/import/no-deprecated
       node = hashSync('keccak256', [node, hashSync('keccak256', label, 'uint8')], 'buffer')
     }
   }

package/src/exodus-eth-server/api-coin-nodes.js

@@ -29,10 +29,15 @@ export default class ApiCoinNodesServer extends EthLikeServer {
     return fetchJsonRetry(this.uri, options)
   }
 
-  async sendBatchRequest(batch) {
+  async sendBatchRequest(batch, { tolerant } = {}) {
     if (isEmpty(batch)) return batch
     const responses = await this.request(batch)
-    return this.parseBatchResponse({ batch, responses, errorMessage: 'Bad rpc batch response' })
+    return this.parseBatchResponse({
+      batch,
+      responses,
+      errorMessage: 'Bad rpc batch response',
+      tolerant,
+    })
   }
 
   async sendRequest(request) {

package/src/exodus-eth-server/api.js

@@ -263,11 +263,11 @@ export function create(defaultURL, ensAssetName) {
     },
 
     async proxyToCoinNode(requestData) {
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       if (!requestData.jsonrpc) requestData.jsonrpc = '2.0'
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       if (!requestData.id) requestData.id = randomUUID()
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       if (!requestData.params) requestData.params = []
 
       return request('proxy', requestData, { version: 'v2', method: 'post' })

package/src/exodus-eth-server/clarity.js

@@ -198,7 +198,7 @@ export default class ClarityServer extends EthLikeServer {
         clearTimeout(timeout)
         const rawTraceparent = response?.traceparent || response?.[0]?.traceparent
         if (rawTraceparent) {
-          // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+          // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
           response.traceparent = TraceId.fromRawTraceparent(rawTraceparent)
         }
 
@@ -208,9 +208,9 @@ export default class ClarityServer extends EthLikeServer {
   }
 
   // Transport: WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2
-  async sendBatchRequest(batch) {
+  async sendBatchRequest(batch, { tolerant } = {}) {
     const responses = await this.sendRpcRequest(batch)
-    return this.parseBatchResponse({ batch, responses, errorMessage: 'Bad Response' })
+    return this.parseBatchResponse({ batch, responses, errorMessage: 'Bad Response', tolerant })
   }
 
   // Transport: Uses sendRpcRequest - WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2

package/src/exodus-eth-server/eth-like-server.js

@@ -165,10 +165,11 @@ export class EthLikeServer extends EthLikeServerBase {
    * @param {Array<{ id: number|string }>} args.batch - Requests sent, in the order results are expected.
    * @param {unknown} args.responses - Raw transport payload; expected `[{ id, result }]` but treated as untrusted (gateways may return `{ message }` on error).
    * @param {string} args.errorMessage - Thrown-error prefix per transport (e.g. `'Bad rpc batch response'`, `'Bad Response'`).
-   * @returns {unknown[]} Each request's `result`, ordered to match `batch`.
-   * @throws {Error} When `responses` isn't an array, length mismatches `batch`, or any entry lacks a numeric `id` / defined `result`.
+   * @param {boolean} [args.tolerant] - When true, a request without a valid entry (JSON-RPC error entry, non-numeric `id`, duplicated or out-of-batch `id`, missing from a short response) maps to `undefined` instead of failing the whole batch.
+   * @returns {unknown[]} Each request's `result`, ordered to match `batch`. Entries with a duplicated or out-of-batch `id` are discarded in both modes, so an affected request maps to `undefined` rather than another request's result.
+   * @throws {Error} When `responses` isn't an array; in strict mode also when length mismatches `batch` or any entry lacks a numeric `id` / defined `result`.
    */
-  parseBatchResponse({ batch, responses, errorMessage }) {
+  parseBatchResponse({ batch, responses, errorMessage, tolerant = false }) {
     // Gateways can respond with a JSON object (e.g. `{ message }`) instead of a batch array.
     if (!Array.isArray(responses)) {
       // Untrusted server text: keep only a short string preview, developer-facing (no `hint`).
@@ -179,16 +180,23 @@ export class EthLikeServer extends EthLikeServerBase {
       throw new Error(`${errorMessage}${preview}`)
     }
 
-    const isValid = responses.every(
-      (response) => !isNaN(response?.id) && response?.result !== undefined
-    )
-    if (responses.length !== batch.length || !isValid) {
+    const isValidEntry = (response) => !isNaN(response?.id) && response?.result !== undefined
+
+    if (!tolerant && (responses.length !== batch.length || !responses.every(isValidEntry))) {
       throw new Error(errorMessage)
     }
 
-    // Safe against prototype keys: every `id` is validated numeric by the `isValid` check above.
+    // Safe against prototype keys: only entries with a validated numeric `id` are kept.
     const keyed = Object.fromEntries(
-      responses.map((response) => [`${response.id}`, response.result])
+      responses
+        .filter(isValidEntry)
+        .filter(({ id }, _i, all) => {
+          const key = `${id}`
+          const inBatch = batch.some((request) => `${request.id}` === key)
+          const unique = all.filter(({ id: other }) => `${other}` === key).length === 1
+          return inBatch && unique
+        })
+        .map((response) => [`${response.id}`, response.result])
     )
     return batch.map((request) => keyed[`${request.id}`])
   }

package/src/exodus-eth-server/index.js

@@ -1,9 +1,6 @@
 import {
-  // eslint-disable-next-line @exodus/import/no-deprecated
   DEFAULT_SERVER_URLS,
-  // eslint-disable-next-line @exodus/import/no-deprecated
   ETHEREUM_LIKE_ASSETS,
-  // eslint-disable-next-line @exodus/import/no-deprecated
   ETHEREUM_LIKE_MONITOR_TYPES,
 } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
@@ -80,11 +77,8 @@ export const createWsGateway = ({ uri } = Object.create(null)) => {
 
 // @Deprecated
 const serverMap = Object.fromEntries(
-  // eslint-disable-next-line @exodus/import/no-deprecated
   ETHEREUM_LIKE_ASSETS.map((assetName) => {
-    // eslint-disable-next-line @exodus/import/no-deprecated
     const monitorType = ETHEREUM_LIKE_MONITOR_TYPES[assetName]
-    // eslint-disable-next-line @exodus/import/no-deprecated
     const serverUrl = DEFAULT_SERVER_URLS[assetName]
     return [assetName, createEvmServer({ assetName, serverUrl, monitorType })]
   })

package/src/exodus-eth-server/ws-gateway.js

@@ -21,8 +21,8 @@ const parseSubscriptionKey = (subscriptionKey) => {
 
 /**
  * @typedef subscribeWalletAddresses
- * @property {string} network
- * @property {string} address
+ * @property {string} network - The network identifier
+ * @property {string} address - The wallet address to subscribe
  */
 
 export default class WsGateway extends EventEmitter {

package/src/fee-data/EthLikeFeeData.js

@@ -3,7 +3,6 @@ import {
   mapCurrency as defaultMapCurrency,
   modelToJSON,
 } from '@exodus/asset-lib/src/utils/index.js'
-// eslint-disable-next-line @exodus/import/no-deprecated
 import { isNumberUnit } from '@exodus/currency'
 import lodash from 'lodash'
 
@@ -13,7 +12,6 @@ const PRE_EIP1559_UNIT_KEYS_GUARD = ['gasPrice']
 const EIP1559_UNIT_KEYS_GUARD = ['gasPrice', 'baseFeePerGas']
 
 export const bound = ({ val, multiplier, max, min }) => {
-  // eslint-disable-next-line @exodus/import/no-deprecated
   if (!isNumberUnit(val)) return val
 
   if (multiplier) {

package/src/fee-utils.js

@@ -111,9 +111,18 @@ export const calculateEthLikeFeeMonitorUpdateEip1559 = async ({
   //       at least the `baseFeePerGas`.
   const gasPrice = baseFeePerGas > defaultGasPrice ? baseFeePerGas : defaultGasPrice
 
+  // `eth_gasPrice` embeds the node's prevailing tip on top of the
+  // `baseFeePerGas`. Without an explicit `tipGasPrice`, `refineFeeConfig`
+  // collapses the effective gas price to the bare base fee, producing
+  // zero-tip transactions that private bundle relays drop silently.
+  const inferredTipGasPrice = gasPrice - baseFeePerGas
+
   const defaultFeeConfig = {
     gasPrice: `${gasPrice.toString()} wei`,
     baseFeePerGas: `${baseFeePerGas.toString()} wei`,
+    ...(inferredTipGasPrice > BigInt(0) && {
+      tipGasPrice: `${inferredTipGasPrice.toString()} wei`,
+    }),
   }
 
   // Determine if there are any `rewardPercentiles` specified in the

package/src/index.js

@@ -41,28 +41,29 @@ export { getStakingHistoryBalance, getBalancesFactory } from './get-balances.js'
 export { getHistoricalBalanceFactory } from './get-historical-balance.js'
 export { createEncodeMultisigContract } from './multisig-address.js'
 
+export { FantomStaking, stakingProviderClientFactory } from './staking/index.js'
+export { ethereumStakingDeps } from './staking/ethereum/deps.js'
+export { getEthereumStakingInfo, createEthereumStakingService } from './staking/ethereum/service.js'
+export { EthereumStaking } from './staking/ethereum/api.js'
 export {
-  FantomStaking,
-  stakingProviderClientFactory,
-  ethereumStakingDeps,
-  getEthereumStakingInfo,
-  createEthereumStakingService,
-  EthereumStaking,
   isEthereumStakingTx,
   isEthereumDelegate,
   isEthereumUndelegatePending,
   isEthereumUndelegate,
   isEthereumClaimUndelegate,
-  MaticStakingApi,
+} from './staking/ethereum/staking-utils.js'
+export { MaticStakingApi } from './staking/matic/index.js'
+export {
   isPolygonTx,
   isPolygonDelegate,
   isPolygonUndelegate,
   isPolygonReward,
   isPolygonClaimUndelegate,
   isPendingPolygonUndelegateTxInEthereumTxLog,
-} from './staking/index.js'
+} from './staking/matic/matic-staking-utils.js'
 
-export { fetchTxPreview, maybeRemoveDuplicates, retrieveSideEffects } from './simulate-tx/index.js'
+export { fetchTxPreview } from './simulate-tx/fetch-tx-preview.js'
+export { maybeRemoveDuplicates, retrieveSideEffects } from './simulate-tx/simulate-eth-tx.js'
 export { simulateTransactions } from './simulation/simulate-transactions.js'
 
 export {

package/src/simulate-tx/simulate-eth-tx.js

@@ -8,11 +8,22 @@ import SolidityContract from '@exodus/solidity-contract'
 import assert from 'minimalistic-assert'
 
 import { getERC20Params } from '../eth-like-util.js'
+import { fromHexToBigInt } from '../number-utils.js'
 import { fetchTxPreview } from './fetch-tx-preview.js'
 
 const ethDecimals = ethereum.units.ETH
 
-const ethHexToInt = (hexValue) => parseInt(hexValue, '16')
+// Convert a hex transaction field (e.g. "0x10a741a462780000" for 1.2 ETH in wei)
+// to a precision-preserving decimal string. `parseInt` would silently truncate
+// values above Number.MAX_SAFE_INTEGER (~9e15), and Ethereum wei amounts routinely
+// exceed that (1 ETH = 1e18 wei).
+const ethHexToDecimalString = (hexValue) => {
+  if (hexValue === undefined || hexValue === null || hexValue === '' || hexValue === '0x') {
+    return '0'
+  }
+
+  return fromHexToBigInt(hexValue).toString()
+}
 
 async function getAssetSymbolFromContract(contractAddress, asset) {
   const { symbol: assetSymbol } = await getERC20Params({
@@ -169,14 +180,16 @@ export async function retrieveSideEffects({ transaction, asset, shouldSimulate =
 
   if (!transaction.to) throw new Error(`'to' field is missing in the TX object`)
 
+  const txValueDecimal = ethHexToDecimalString(transaction.value)
+
   const blocknativeTxObject = {
     to: transaction.to,
     input: transaction.data,
     from: transaction.from,
-    value: ethHexToInt(transaction.value),
-    gas: ethHexToInt(transaction.gas),
-    maxFeePerGas: ethHexToInt(transaction.maxFeePerGas),
-    maxPriorityFeePerGas: ethHexToInt(transaction.maxPriorityFeePerGas),
+    value: txValueDecimal,
+    gas: ethHexToDecimalString(transaction.gas),
+    maxFeePerGas: ethHexToDecimalString(transaction.maxFeePerGas),
+    maxPriorityFeePerGas: ethHexToDecimalString(transaction.maxPriorityFeePerGas),
   }
 
   try {
@@ -224,7 +237,7 @@ export async function retrieveSideEffects({ transaction, asset, shouldSimulate =
     if (willSend.length === 0) {
       willSend.push({
         symbol: 'ETH',
-        balance: `-${ethHexToInt(transaction.value)}`,
+        balance: `-${txValueDecimal}`,
         assetType: 'ether',
         decimal: ethDecimals,
       })

package/src/simulation/simulate-message-api.js

@@ -30,7 +30,7 @@ const convertToAPIPayload = ({ address, message, url }) => {
 
 export const handleActionResponse = ({ simulationResult, response }) => {
   if (['BLOCK', 'WARN'].includes(response.action)) {
-    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+    // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
     simulationResult.action = response.action
   }
 }

package/src/simulation/simulate-transactions-api.js

@@ -194,7 +194,7 @@ export const simulateTransactionsApi = async ({
     }
   }
 
-  // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+  // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
   simulationResult.metadata.simulatedLocally = false
 
   const { expectedStateChanges = {}, error } = response.simulationResults.aggregated

package/src/staking/ethereum/service.js

@@ -178,7 +178,7 @@ export function createEthereumStakingService({
   stakingProvider = stakingProviderClientFactory(),
 }) {
   if (deprectedArg && !assetName) {
-    console.log('using deprecated ARG `asset` instead of `assetName`')
+    console.debug('using deprecated ARG `asset` instead of `assetName`')
     assetName = deprectedArg.name
   }
 
@@ -212,7 +212,7 @@ export function createEthereumStakingService({
 
     const { to, data } = await staking.stake({ amount })
 
-    console.log(
+    console.debug(
       `delegator address ${delegatorAddress} staking ${amount.toDefaultString({
         unit: true,
       })}`
@@ -376,7 +376,7 @@ export function createEthereumStakingService({
       },
     }
 
-    console.log(
+    console.debug(
       `delegator address ${delegatorAddress} unstaking ${requestedAmount.toDefaultString({
         unit: true,
       })} - pending amount: ${pendingAmount.toDefaultString({ unit: true })}`

package/src/staking/utils/index.js

@@ -1,10 +1,8 @@
-// eslint-disable-next-line @exodus/import/no-deprecated
 import { isNumberUnit } from '@exodus/currency'
 
 export const DISABLE_BALANCE_CHECKS = '0x0'
 
 export function amountToCurrency({ asset, amount }) {
-  // eslint-disable-next-line @exodus/import/no-deprecated
   return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
 }
 

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

@@ -19,6 +19,7 @@ import {
   getCurrentEIP7702Delegation,
   getDeriveDataNeededForTick,
   getDeriveTransactionsToCheck,
+  isUnverifiablePendingTxExpired,
   verifyRpcPendingTxStatusBatch,
 } from './monitor-utils/index.js'
 
@@ -90,19 +91,23 @@ export class ClarityMonitor extends BaseMonitor {
 
   // eslint-disable-next-line no-undef
   async checkPendingTransactions(params) {
-    const { pendingTransactionsToCheck, pendingTransactionsGroupedByAddressAndNonce } =
-      checkPendingTransactions(params)
+    const {
+      pendingTransactionsToCheck,
+      pendingTransactionsGroupedByAddressAndNonce,
+      recentPendingTransactions,
+    } = checkPendingTransactions(params)
     const txsToRemove = []
     const { walletAccount } = params
 
-    const updateTx = (tx, asset, { error, remove }) => {
+    const updateTx = (tx, asset, { error, remove, preserve, isTxConfirmed }) => {
       if (remove) {
         txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
+      } else if (preserve) {
+        params.logItemsByAsset[asset].push(tx)
       } else {
         params.logItemsByAsset[asset].push({
           ...tx,
-          dropped: true,
-          error,
+          ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error }),
         })
       }
 
@@ -115,11 +120,15 @@ export class ClarityMonitor extends BaseMonitor {
             assetSource: { asset: assetName, walletAccount },
           })
         } else if (tokenTxSet && tokenTxSet.has(tx.txId)) {
-          params.logItemsByAsset[assetName].push({
-            ...tokenTxSet.get(tx.txId),
-            error,
-            dropped: true,
-          })
+          // Optional: the stored tx may name a token since removed from the registry
+          params.logItemsByAsset[assetName]?.push(
+            preserve
+              ? tokenTxSet.get(tx.txId)
+              : {
+                  ...tokenTxSet.get(tx.txId),
+                  ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error }),
+                }
+          )
         }
       })
       return Promise.all(promises)
@@ -131,28 +140,55 @@ export class ClarityMonitor extends BaseMonitor {
       if (replaced) {
         await updateTx(tx, assetName, { remove: true })
         delete pendingTransactionsToCheck[tx.txId]
+        delete recentPendingTransactions[tx.txId]
       }
     }
 
-    // Batch verify all pending txs with a single RPC call (skip if refresh)
+    // Batch verify all pending txs with a single RPC call
     const txIds = Object.keys(pendingTransactionsToCheck)
-    const statuses = params.refresh
-      ? {}
-      : await verifyRpcPendingTxStatusBatch({
-          server: this.server,
-          logger: this.logger,
-          txIds,
-        })
+    const statuses = await verifyRpcPendingTxStatusBatch({
+      server: this.server,
+      logger: this.logger,
+      txIds,
+    })
 
     for (const { tx, assetName } of Object.values(pendingTransactionsToCheck)) {
+      const txStatus = statuses[tx.txId]
       if (params.refresh) {
-        await updateTx(tx, assetName, { remove: true })
-      } else {
-        const txStatus = statuses[tx.txId]
         if (txStatus?.status === 'dropped') {
-          await updateTx(tx, assetName, { error: 'Dropped' })
+          await updateTx(tx, assetName, { remove: true })
+        } else if (txStatus?.status === 'confirmed') {
+          // Confirmed on-chain but missing from the indexer response: mark it
+          // confirmed so it stops being a pending entry that would otherwise be
+          // preserved (exempt from the age ceiling) on every refresh forever.
+          await updateTx(tx, assetName, { isTxConfirmed: true })
+        } else if (
+          // No txStatus at all means the whole verification batch failed - evidence
+          // about nothing, so preserve unconditionally; the age ceiling only applies
+          // to a per-entry 'unknown' verdict (evidence about that one hash).
+          !txStatus ||
+          txStatus.status === 'pending' ||
+          !isUnverifiablePendingTxExpired(tx)
+        ) {
+          // Still live on-chain (or not verifiable yet) but missing from the indexer
+          // response: re-add it so the refresh overwrite cannot wipe it and break
+          // tx-log-based nonce resolution.
+          await updateTx(tx, assetName, { preserve: true })
+        } else {
+          // Unverifiable past the age ceiling: purge so a hash the node keeps
+          // erroring on cannot pin nonce derivation forever.
+          await updateTx(tx, assetName, { remove: true })
         }
-        // status === 'confirmed' or 'pending' - tx is fine, wait for Clarity to confirm
+      } else if (txStatus?.status === 'dropped') {
+        await updateTx(tx, assetName, { error: 'Dropped' })
+      }
+      // non-refresh: 'confirmed', 'pending' or unknown - tx is fine, wait for Clarity to confirm
+    }
+
+    if (params.refresh) {
+      // Too recent for a reliable on-chain verdict - always survive the refresh overwrite
+      for (const { tx, assetName } of Object.values(recentPendingTransactions)) {
+        await updateTx(tx, assetName, { preserve: true })
       }
     }
 
@@ -284,7 +320,9 @@ export class ClarityMonitor extends BaseMonitor {
     }
 
     if (historyError) {
-      throw historyError
+      throw historyError instanceof Error
+        ? historyError
+        : new Error(String(historyError), { cause: historyError })
     }
 
     if (refresh || hasNewTxs) {

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

@@ -229,7 +229,9 @@ export class ClarityTruncatedHistoryMonitor extends ClarityMonitor {
     }
 
     if (historyError) {
-      throw historyError
+      throw historyError instanceof Error
+        ? historyError
+        : new Error(String(historyError), { cause: historyError })
     }
 
     if (refresh || hasNewTxs) {

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

@@ -12,6 +12,7 @@ import {
   getDeriveTransactionsToCheck,
   getHistoryFromServer,
   getLogItemsFromServerTx,
+  isUnverifiablePendingTxExpired,
   verifyRpcPendingTxStatusBatch,
 } from './monitor-utils/index.js'
 import {
@@ -74,16 +75,21 @@ export class EthereumMonitor extends BaseMonitor {
 
   // eslint-disable-next-line no-undef
   async checkPendingTransactions(params) {
-    const { pendingTransactionsToCheck, pendingTransactionsGroupedByAddressAndNonce } =
-      checkPendingTransactions(params)
+    const {
+      pendingTransactionsToCheck,
+      pendingTransactionsGroupedByAddressAndNonce,
+      recentPendingTransactions,
+    } = checkPendingTransactions(params)
     const txsToRemove = []
     const {
       assetSource: { walletAccount },
     } = params
 
-    const updateTx = (tx, asset, { isTxConfirmed, remove }) => {
+    const updateTx = (tx, asset, { isTxConfirmed, remove, preserve }) => {
       if (remove) {
         txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
+      } else if (preserve) {
+        params.logItemsByAsset[asset].push(tx)
       } else {
         params.logItemsByAsset[asset].push({
           ...tx,
@@ -100,10 +106,15 @@ export class EthereumMonitor extends BaseMonitor {
             assetSource: { asset: assetName, walletAccount },
           })
         } else if (tokenTxSet && tokenTxSet.has(tx.txId)) {
-          params.logItemsByAsset[assetName].push({
-            ...tokenTxSet.get(tx.txId),
-            ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error: 'Dropped' }),
-          })
+          // Optional: the stored tx may name a token since removed from the registry
+          params.logItemsByAsset[assetName]?.push(
+            preserve
+              ? tokenTxSet.get(tx.txId)
+              : {
+                  ...tokenTxSet.get(tx.txId),
+                  ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error: 'Dropped' }),
+                }
+          )
         }
       })
 
@@ -116,30 +127,50 @@ export class EthereumMonitor extends BaseMonitor {
       if (replaced) {
         await updateTx(tx, assetName, { remove: true })
         delete pendingTransactionsToCheck[tx.txId]
+        delete recentPendingTransactions[tx.txId]
       }
     }
 
-    // Batch verify all pending txs with a single RPC call (skip if refresh)
+    // Batch verify all pending txs with a single RPC call
     const txIds = Object.keys(pendingTransactionsToCheck)
-    const statuses = params.refresh
-      ? {}
-      : await verifyRpcPendingTxStatusBatch({
-          server: this.server,
-          logger: this.logger,
-          txIds,
-        })
+    const statuses = await verifyRpcPendingTxStatusBatch({
+      server: this.server,
+      logger: this.logger,
+      txIds,
+    })
 
     for (const { tx, assetName } of Object.values(pendingTransactionsToCheck)) {
-      if (params.refresh) {
-        await updateTx(tx, assetName, { remove: true })
-      } else {
-        const txStatus = statuses[tx.txId]
-        if (txStatus?.status === 'confirmed') {
-          await updateTx(tx, assetName, { isTxConfirmed: true })
-        } else if (txStatus?.status === 'dropped') {
+      const txStatus = statuses[tx.txId]
+      if (txStatus?.status === 'confirmed') {
+        await updateTx(tx, assetName, { isTxConfirmed: true })
+      } else if (txStatus?.status === 'dropped') {
+        if (params.refresh) {
+          await updateTx(tx, assetName, { remove: true })
+        } else {
           await updateTx(tx, assetName, { isTxConfirmed: false })
         }
-        // status === 'pending' or missing - tx still in mempool, do nothing
+      } else if (params.refresh) {
+        // No txStatus at all means the whole verification batch failed - evidence
+        // about nothing, so preserve unconditionally; the age ceiling only applies
+        // to a per-entry 'unknown' verdict (evidence about that one hash).
+        if (!txStatus || txStatus.status === 'pending' || !isUnverifiablePendingTxExpired(tx)) {
+          // Still in the mempool (or not verifiable yet) but missing from the history
+          // server response: re-add it so the refresh overwrite cannot wipe it and
+          // break tx-log-based nonce resolution.
+          await updateTx(tx, assetName, { preserve: true })
+        } else {
+          // Unverifiable past the age ceiling: purge so a hash the node keeps
+          // erroring on cannot pin nonce derivation forever.
+          await updateTx(tx, assetName, { remove: true })
+        }
+      }
+      // non-refresh: 'pending' or unknown - tx still in mempool, do nothing
+    }
+
+    if (params.refresh) {
+      // Too recent for a reliable on-chain verdict - always survive the refresh overwrite
+      for (const { tx, assetName } of Object.values(recentPendingTransactions)) {
+        await updateTx(tx, assetName, { preserve: true })
       }
     }
 

package/src/tx-log/get-optimistic-txlog-effects.js

@@ -82,7 +82,7 @@ export const getOptimisticTxLogEffects = async ({
     maybeTxToReplace && maybeTxToReplace.feeAmount.lt(feeAmount) ? maybeTxToReplace.txId : undefined
 
   if (!replacedTxId && maybeTxToReplace) {
-    console.log('Attempting to replace a transaction using an insufficient fee!')
+    console.debug('Attempting to replace a transaction using an insufficient fee!')
   }
 
   // Contains effects for smart-contract initiated token movements.

package/src/tx-log/monitor-utils/check-pending-transactions.js

@@ -4,13 +4,18 @@ import getSenderNonceKey from './get-sender-nonce-key.js'
 export default function checkPendingTransactions({
   pendingTransactionsGroupedByAddressAndNonce = {},
   pendingTransactionsToCheck = {},
+  recentPendingTransactions = {},
   txlist,
   ourWalletAddress,
   asset,
 }) {
   for (const tx of txlist) {
-    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
-    delete pendingTransactionsToCheck[tx.txId || tx.hash] // Found this transaction, do not mark it as dropped
+    const txId = tx.txId || tx.hash
+    // Found this transaction on the server, do not mark it as dropped or re-add it
+    // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
+    delete pendingTransactionsToCheck[txId]
+    // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
+    delete recentPendingTransactions[txId]
 
     // check if this TX replaces another pending TX
     const replacedTx =
@@ -29,5 +34,9 @@ export default function checkPendingTransactions({
     }
   }
 
-  return { pendingTransactionsGroupedByAddressAndNonce, pendingTransactionsToCheck }
+  return {
+    pendingTransactionsGroupedByAddressAndNonce,
+    pendingTransactionsToCheck,
+    recentPendingTransactions,
+  }
 }

package/src/tx-log/monitor-utils/get-derive-transactions-to-check.js

@@ -10,6 +10,7 @@ const mapToObject = (map) => Object.fromEntries(map.entries()) // only for strin
 export default function getDeriveTransactionsToCheck({ getTxLog }) {
   return async ({ assetName: _assetName, walletAccount, tokens, ourWalletAddress }) => {
     const pendingTransactionsToCheck = new Map()
+    const recentPendingTransactions = new Map()
     const pendingTransactionsGroupedByAddressAndNonce = new Map()
     const simulatedTransactions = new Map()
     const now = SynchronizedTime.now()
@@ -19,11 +20,13 @@ export default function getDeriveTransactionsToCheck({ getTxLog }) {
       for (const tx of txSet) {
         // ERC20 sends have an entry in ETH and one in the ERC20 log so we just want the ETH one
         if (
-          !pendingTransactionsToCheck.has(tx.txId) &&
           tx.pending &&
-          now - tx.date.getTime() > UNCONFIRMED_TX_LIMIT
+          !pendingTransactionsToCheck.has(tx.txId) &&
+          !recentPendingTransactions.has(tx.txId)
         ) {
-          pendingTransactionsToCheck.set(tx.txId, { tx, assetName })
+          const isRecent = now - tx.date.getTime() <= UNCONFIRMED_TX_LIMIT
+          const map = isRecent ? recentPendingTransactions : pendingTransactionsToCheck
+          map.set(tx.txId, { tx, assetName })
         }
 
         if (tx.meta.simulated) simulatedTransactions.set(tx.txId, tx)
@@ -45,6 +48,7 @@ export default function getDeriveTransactionsToCheck({ getTxLog }) {
 
     return {
       pendingTransactionsToCheck: mapToObject(pendingTransactionsToCheck),
+      recentPendingTransactions: mapToObject(recentPendingTransactions),
       pendingTransactionsGroupedByAddressAndNonce: mapToObject(
         pendingTransactionsGroupedByAddressAndNonce
       ),

package/src/tx-log/monitor-utils/index.js

@@ -8,5 +8,6 @@ export { default as getDeriveTransactionsToCheck } from './get-derive-transactio
 export { default as getCurrentEIP7702Delegation } from './get-current-eip7702-delegation.js'
 export { default as getCurrentBlackListStatus } from './get-current-blacklist-status.js'
 export { default as verifyRpcPendingTxStatusBatch } from './verify-pending-tx-status-rpc.js'
+export { default as isUnverifiablePendingTxExpired } from './is-unverifiable-pending-tx-expired.js'
 export { extractBalanceFromClarityAccountInfo } from './extract-balance-from-clarity-account-info.js'
 export * from './exclude-unchanged-token-balances.js'

package/src/tx-log/monitor-utils/is-unverifiable-pending-tx-expired.js

@@ -0,0 +1,19 @@
+import { SynchronizedTime } from '@exodus/basic-utils'
+import ms from 'ms'
+
+// Upper bound on how long a pending tx with a per-entry 'unknown' verdict
+// (a hash the node persistently errors on) keeps being preserved across
+// refreshes. Without it, "cannot verify this hash" would mean "keep forever"
+// and a phantom tx would pin nonce derivation indefinitely.
+// Positively verified txs ('pending'/'confirmed') are exempt: their lifetime
+// is bounded by the node itself (mempool eviction yields a 'dropped' verdict).
+// A full batch failure is also exempt: it is evidence about nothing, so the
+// monitors preserve unconditionally until the batch path recovers.
+export const UNVERIFIABLE_PENDING_TX_MAX_AGE = ms('1h')
+
+export default function isUnverifiablePendingTxExpired(tx) {
+  const txTime = tx.date?.getTime()
+  // Fail closed: a tx with a missing or invalid date cannot prove it is young
+  if (!Number.isFinite(txTime)) return true
+  return SynchronizedTime.now() - txTime > UNVERIFIABLE_PENDING_TX_MAX_AGE
+}

package/src/tx-log/monitor-utils/verify-pending-tx-status-rpc.js

@@ -1,10 +1,18 @@
 /**
  * Determines the status of an RPC transaction response.
  *
- * @param {Object|null} rpcTx - The RPC transaction response
- * @returns {{status: 'confirmed' | 'pending' | 'dropped', blockNumber?: number}}
+ * `undefined` means the node returned a JSON-RPC error entry for this hash
+ * (tolerant batch parsing) - no verdict, as opposed to `null` which is a
+ * definitive "not found".
+ *
+ * @param {Object|null|undefined} rpcTx - The RPC transaction response
+ * @returns {{status: 'confirmed' | 'pending' | 'dropped' | 'unknown', blockNumber?: number}}
  */
 function getTxStatus(rpcTx) {
+  if (rpcTx === undefined) {
+    return { status: 'unknown' }
+  }
+
   if (rpcTx?.blockNumber) {
     return { status: 'confirmed', blockNumber: parseInt(rpcTx.blockNumber, 16) }
   }
@@ -29,7 +37,7 @@ function getTxStatus(rpcTx) {
  * @param {Object} params.server - RPC server used to verify pending transactions
  * @param {Object} params.logger - Logger instance for info/debug output
  * @param {string[]} params.txIds - Array of transaction IDs/hashes to verify
- * @returns {Promise<Object<string, {status: 'confirmed' | 'pending' | 'dropped', blockNumber?: number}>>}
+ * @returns {Promise<Object<string, {status: 'confirmed' | 'pending' | 'dropped' | 'unknown', blockNumber?: number}>>}
  */
 export default async function verifyRpcPendingTxStatusBatch({ server, logger, txIds }) {
   if (txIds.length === 0) return {}
@@ -39,27 +47,42 @@ export default async function verifyRpcPendingTxStatusBatch({ server, logger, tx
 
   let responses
   try {
-    responses = await server.sendBatchRequest(requests)
+    // Tolerant parsing: one bad hash must not void the verdicts for every other tx
+    responses = await server.sendBatchRequest(requests, { tolerant: true })
   } catch (error) {
     // If batch request fails, skip all drop checks (safe default)
     logger.warn('Batch RPC request failed, skipping drop checks', error)
     return {}
   }
 
+  if (!Array.isArray(responses) || responses.length !== txIds.length) {
+    // A malformed batch response must not produce 'dropped' verdicts (safe default)
+    logger.warn('Batch RPC response shape mismatch, skipping drop checks')
+    return {}
+  }
+
   // Map responses to statuses
-  const results = {}
+  const results = Object.create(null)
   txIds.forEach((txId, idx) => {
     const rpcTx = responses[idx]
     const txStatus = getTxStatus(rpcTx)
     results[txId] = txStatus
 
     // Log each tx status
-    if (txStatus.status === 'confirmed') {
-      logger.info(`tx ${txId} is confirmed on-chain (block ${txStatus.blockNumber}), skipping drop`)
-    } else if (txStatus.status === 'pending') {
-      logger.info(`tx ${txId} is still in mempool, skipping drop`)
-    } else {
-      logger.info(`tx ${txId} not found on-chain, marking as dropped`)
+    switch (txStatus.status) {
+      case 'confirmed':
+        logger.info(
+          `tx ${txId} is confirmed on-chain (block ${txStatus.blockNumber}), skipping drop`
+        )
+        break
+      case 'pending':
+        logger.info(`tx ${txId} is still in mempool, skipping drop`)
+        break
+      case 'unknown':
+        logger.warn(`tx ${txId} could not be verified (RPC error entry), skipping drop`)
+        break
+      default:
+        logger.info(`tx ${txId} not found on-chain, marking as dropped`)
     }
   })
 

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

@@ -47,7 +47,7 @@ export const calculateRewardsFromStakeTx = ({ tx, currency }) => {
 
   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.
+    // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only -- TODO: Fix this the next time the file is edited.
     return txAmount.toDefaultString()
   }
 }

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

@@ -29,7 +29,7 @@ export const handleBroadcastError = async (
     isNonceTooLow || errorInfo.reason === EVM_ERROR_REASONS.transactionUnderpriced.reason
 
   if (errorInfo.reason === EVM_ERROR_REASONS.alreadyKnown.reason) {
-    console.info('tx already broadcast')
+    console.debug('tx already broadcast')
     return { shouldRetry: false }
   }
 
@@ -44,7 +44,7 @@ export const handleBroadcastError = async (
   }
 
   if (txAlreadyExists) {
-    console.info('tx already broadcast')
+    console.debug('tx already broadcast')
     return { shouldRetry: false }
   }
 

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

@@ -50,7 +50,7 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
       })
 
       if (shouldRetry) {
-        console.info('trying to send again...') // inject logger factory from platform
+        console.debug('trying to send again...') // inject logger factory from platform
 
         // let's try to fix the nonce issue
         let newNonce = await baseAsset.getNonce({
@@ -73,14 +73,14 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
         //
         // TODO: should return an unsignedTx -> i.e. completely replicate the transaction
         if (unsignedTx.txData.transactionBuffer) {
-          // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+          // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
           unsignedTx.txData.transactionBuffer = updateNonce({
             chainId: baseAsset.chainId,
             newNonce,
             unsignedTx,
           })
         } else {
-          // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+          // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
           unsignedTx.txData.nonce = newNonce
         }