@exodus/ethereum-api 8.38.1 → 8.40.0

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.40.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.39.0...@exodus/ethereum-api@8.40.0) (2025-06-26)
+
+
+### Features
+
+
+* feat: enable ws reconnection and timeout fallback to rest on clarity (#5900)
+
+
+
+## [8.39.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.38.1...@exodus/ethereum-api@8.39.0) (2025-06-20)
+
+
+### Features
+
+
+* feat: add `isPrivate` flag to `txSend` and export `transactionPrivacy` feature (#5906)
+
+
+
 ## [8.38.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.38.0...@exodus/ethereum-api@8.38.1) (2025-06-19)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.38.1",
+  "version": "8.40.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",
@@ -53,6 +53,7 @@
     "@exodus/bsc-meta": "^2.1.2",
     "@exodus/ethereumarbone-meta": "^2.0.3",
     "@exodus/fantommainnet-meta": "^2.0.2",
+    "@exodus/matic-meta": "^2.2.6",
     "@exodus/rootstock-meta": "^2.0.3"
   },
   "bugs": {
@@ -62,5 +63,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "29460910f5183b5f2c5298f806e837050df0ecdf"
+  "gitHead": "8c81c64076e7092e8a1a0d7c9a51f410a94aeec9"
 }

package/src/create-asset-utils.js

@@ -1,6 +1,11 @@
 import assert from 'minimalistic-assert'
+import ms from 'ms'
 
 import { createEvmServer, ValidMonitorTypes } from './exodus-eth-server/index.js'
+import { createEthereumHooks } from './hooks/index.js'
+import { ClarityMonitor } from './tx-log/clarity-monitor.js'
+import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
+import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor.js'
 
 // Determines the appropriate `monitorType`, `serverUrl` and `monitorInterval`
 // to use for a given config.
@@ -74,3 +79,63 @@ export const createBroadcastTxFactory = ({ assetName, server, privacyRpcUrl }) =
     broadcastPrivateTx: (...args) => privacyServer.sendRawTransaction(...args),
   }
 }
+
+export const createHistoryMonitorFactory = ({
+  assetName,
+  assetClientInterface,
+  monitorInterval,
+  monitorType,
+  server,
+  stakingAssetNames,
+}) => {
+  assert(assetName, 'expected assetName')
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(monitorType, 'expected monitorType')
+  assert(server, 'expected server')
+  assert(Array.isArray(stakingAssetNames), 'expected array stakingAssetNames')
+
+  return (args) => {
+    let monitor
+    switch (monitorType) {
+      case 'clarity':
+      case 'clarity-v2':
+        monitor = new ClarityMonitor({
+          assetClientInterface,
+          interval: ms(monitorInterval || '5m'),
+          server,
+          ...args,
+        })
+        break
+      case 'no-history':
+        monitor = new EthereumNoHistoryMonitor({
+          assetClientInterface,
+          interval: ms(monitorInterval || '15s'),
+          server,
+          ...args,
+        })
+        break
+      case 'magnifier':
+        monitor = new EthereumMonitor({
+          assetClientInterface,
+          interval: ms(monitorInterval || '15s'),
+          server,
+          ...args,
+        })
+        break
+      default:
+        throw new Error(`Monitor type ${monitorType} of evm asset ${assetName} is unknown`)
+    }
+
+    if (stakingAssetNames.length > 0) {
+      const afterTickHook = createEthereumHooks({
+        assetClientInterface,
+        assetName,
+        stakingAssetNames,
+        server,
+      })['after-tick']
+      monitor.addHook('after-tick', afterTickHook)
+    }
+
+    return monitor
+  }
+}

package/src/create-asset.js

@@ -19,10 +19,13 @@ import {
 } from '@exodus/ethereum-lib'
 import lodash from 'lodash'
 import assert from 'minimalistic-assert'
-import ms from 'ms'
 
 import { addressHasHistoryFactory } from './address-has-history.js'
-import { createBroadcastTxFactory, resolveMonitorSettings } from './create-asset-utils.js'
+import {
+  createBroadcastTxFactory,
+  createHistoryMonitorFactory,
+  resolveMonitorSettings,
+} from './create-asset-utils.js'
 import { createTokenFactory } from './create-token-factory.js'
 import { createCustomFeesApi } from './custom-fees.js'
 import { createEvmServer } from './exodus-eth-server/index.js'
@@ -31,13 +34,9 @@ import { createGetBalanceForAddress } from './get-balance-for-address.js'
 import { getBalancesFactory } from './get-balances.js'
 import { getFeeFactory } from './get-fee.js'
 import getFeeAsyncFactory from './get-fee-async.js'
-import { createEthereumHooks } from './hooks/index.js'
 import { estimateL1DataFeeFactory, getL1GetFeeFactory } from './optimism-gas/index.js'
 import { serverBasedFeeMonitorFactoryFactory } from './server-based-fee-monitor.js'
 import { createStakingApi } from './staking-api.js'
-import { ClarityMonitor } from './tx-log/clarity-monitor.js'
-import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
-import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor.js'
 import { txSendFactory } from './tx-send/index.js'
 import { createWeb3API } from './web3/index.js'
 
@@ -171,6 +170,12 @@ export const createAssetFactory = ({
       server,
     })
 
+    const { broadcastTx, broadcastPrivateTx } = createBroadcastTxFactory({
+      assetName: asset.name,
+      server,
+      privacyRpcUrl,
+    })
+
     const features = {
       accountState: true,
       customTokens,
@@ -180,6 +185,7 @@ export const createAssetFactory = ({
       isTestnet,
       nfts,
       noHistory: monitorType === 'no-history',
+      transactionPrivacy: typeof broadcastPrivateTx === 'function',
       signWithSigner: true,
       signMessageWithSigner: true,
       supportsCustomFees,
@@ -201,50 +207,14 @@ export const createAssetFactory = ({
     const accountStateClass =
       CustomAccountState || createEthereumLikeAccountState({ asset: base, assets, extraData })
 
-    const createHistoryMonitor = (args) => {
-      let monitor
-      switch (monitorType) {
-        case 'clarity':
-        case 'clarity-v2':
-          monitor = new ClarityMonitor({
-            assetClientInterface,
-            interval: ms(monitorInterval || '5m'),
-            server,
-            ...args,
-          })
-          break
-        case 'no-history':
-          monitor = new EthereumNoHistoryMonitor({
-            assetClientInterface,
-            interval: ms(monitorInterval || '15s'),
-            server,
-            ...args,
-          })
-          break
-        case 'magnifier':
-          monitor = new EthereumMonitor({
-            assetClientInterface,
-            interval: ms(monitorInterval || '15s'),
-            server,
-            ...args,
-          })
-          break
-        default:
-          throw new Error(`Monitor type ${monitorType} of evm asset ${asset.name} is unknown`)
-      }
-
-      if (stakingAssetNames.length > 0) {
-        const afterTickHook = createEthereumHooks({
-          assetClientInterface,
-          assetName: asset.name,
-          stakingAssetNames,
-          server,
-        })['after-tick']
-        monitor.addHook('after-tick', afterTickHook)
-      }
-
-      return monitor
-    }
+    const createHistoryMonitor = createHistoryMonitorFactory({
+      assetName: asset.name,
+      assetClientInterface,
+      monitorInterval,
+      monitorType,
+      server,
+      stakingAssetNames,
+    })
 
     const defaultAddressPath = 'm/0/0'
 
@@ -266,12 +236,6 @@ export const createAssetFactory = ({
       ? getL1GetFeeFactory({ asset, originalGetFee })
       : originalGetFee
 
-    const { broadcastTx, broadcastPrivateTx } = createBroadcastTxFactory({
-      assetName: asset.name,
-      server,
-      privacyRpcUrl,
-    })
-
     const api = {
       addressHasHistory,
       broadcastTx,

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

@@ -1,6 +1,7 @@
 import { retry } from '@exodus/simple-retry'
+import assert from 'minimalistic-assert'
 
-import ClarityServer from './clarity.js'
+import ClarityServer, { RPC_REQUEST_TIMEOUT } from './clarity.js'
 
 export const encodeCursor = (blockNumberBigInt, isLegacy = false) => {
   if (typeof blockNumberBigInt !== 'bigint') throw new Error('expected bigint')
@@ -50,6 +51,22 @@ const fetchJson = async (url, fetchOptions) => {
   return response.json()
 }
 
+const fetchHttpRequest = ({ baseApiPath, path, method, body }) => {
+  assert(typeof baseApiPath === 'string', 'expected string baseApiPath')
+
+  const url = new URL(`${baseApiPath}${path}`)
+  const fetchOptions = {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+  }
+
+  if (body) fetchOptions.body = JSON.stringify(body)
+  return fetchJson(url, fetchOptions)
+}
+
+const fetchRpcHttpRequest = ({ baseApiPath, body }) =>
+  fetchHttpRequest({ baseApiPath, path: '/rpc', method: 'POST', body })
+
 async function fetchJsonRetry(url, fetchOptions) {
   const waitTimes = ['3s']
   const fetchWithRetry = retry(fetchJson, { delayTimesMs: waitTimes })
@@ -78,6 +95,48 @@ export default class ClarityServerV2 extends ClarityServer {
     return fetchJsonRetry(url)
   }
 
+  // Clarity exposes a new way to determine fee data for EIP-1559
+  // networks. In addition to the `nextBlockBaseFeePerGas`, we also
+  // receive a `rewardPercentiles` mapping, which defines the prevailing
+  // 25th, 50th and 75th percentiles of `maxPriorityFeePerGas` for
+  // an EVM-based network.
+  async getGasPriceEstimation() {
+    return fetchJson(`${this.baseApiPath}/gas-price-estimation`)
+  }
+
+  async getFee() {
+    // HACK: When we call `getFee`, we should still
+    //       subscribe for period fee updates.
+    await this.connectFee()
+
+    try {
+      // NOTE: Depending on whether the network is `eip1559Enabled`
+      //       **on the backend**, this can omit certain
+      //       properties.
+      //
+      //       By default, we should receive:
+      //       + blockNumber
+      //       + gasPrice
+      //       + baseGasPrice (deprecated)
+      //
+      //       In addition, when `eip1559Enabled` on Clarity:
+      //       + baseFeePerGas
+      //       + nextBaseFeePerGas
+      //       + rewardPercentiles
+      //
+      //       See: https://github.com/ExodusMovement/clarity/blob/d3c2a7f501a4391da630592bca3bf57c3ddd5e89/src/modules/ethereum-like/gas-price/index.js#L192C5-L219C6
+      return await this.getGasPriceEstimation()
+    } catch {
+      console.log(
+        `failed to query ${this.baseAssetName} gas-price-estimation endpoint, falling back to websocket`
+      )
+      // HACK: The `getGasPriceEstimation` endpoint is not guaranteed
+      //       to exist for all assets. In this case, we'll fallback
+      //       to legacy behaviour, which is to query via the WebSocket.
+      return this.getFeeFromWebSocket()
+    }
+  }
+
   async getAllTransactions({ address, cursor }) {
     let { blockNumber } = decodeCursor(cursor)
     blockNumber = blockNumber.toString()
@@ -125,40 +184,29 @@ export default class ClarityServerV2 extends ClarityServer {
     }
   }
 
-  async sendHttpRequest({ path, method, body }) {
-    const url = new URL(`${this.baseApiPath}${path}`)
-    const fetchOptions = {
-      method,
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    }
+  async sendRpcRequest(rpcRequest) {
+    try {
+      return await super.sendRpcRequest(rpcRequest)
+    } catch (err) {
+      // If we encounter an error which isn't associated
+      // with transport timeouts, then bubble up.
+      if (err.message !== RPC_REQUEST_TIMEOUT) throw err
 
-    if (body) {
-      fetchOptions.body = JSON.stringify(body)
+      const { baseApiPath } = this
+      return fetchRpcHttpRequest({ baseApiPath, body: rpcRequest })
     }
-
-    const response = await fetchJson(url, fetchOptions)
-
-    return this.handleJsonRPCResponse(response)
   }
 
   async sendRawTransaction(...params) {
+    const { baseApiPath } = this
     const request = this.sendRawTransactionRequest(...params)
-    return this.sendHttpRequest({
-      path: '/rpc',
-      method: 'POST',
-      body: request,
-    })
+    return this.handleJsonRPCResponse(await fetchRpcHttpRequest({ baseApiPath, body: request }))
   }
 
   async getTransactionCount(...params) {
     // nonce is called during tx send, use it in rest api
+    const { baseApiPath } = this
     const request = this.getTransactionCountRequest(...params)
-    return this.sendHttpRequest({
-      path: '/rpc',
-      method: 'POST',
-      body: request,
-    })
+    return this.handleJsonRPCResponse(await fetchRpcHttpRequest({ baseApiPath, body: request }))
   }
 }

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

@@ -5,6 +5,8 @@ import io from 'socket.io-client'
 
 import { fromHexToString } from '../number-utils.js'
 
+export const RPC_REQUEST_TIMEOUT = 'RPC_REQUEST_TIMEOUT'
+
 export default class ClarityServer extends EventEmitter {
   constructor({ baseAssetName, uri }) {
     super()
@@ -56,6 +58,7 @@ export default class ClarityServer extends EventEmitter {
     return io(`${this.uri}${namespace}`, {
       transports: ['websocket', 'polling'],
       extraHeaders: { 'User-Agent': 'exodus' },
+      reconnection: true,
     })
   }
 
@@ -137,10 +140,10 @@ export default class ClarityServer extends EventEmitter {
       .finally(() => socket.off('transactionsChunk', listener))
   }
 
-  async getFee() {
+  getFeeFromWebSocket() {
     const socket = this.connectFee()
     return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error('Fee Timeout')), 30_000)
+      const timeout = setTimeout(() => reject(new Error('Fee Timeout')), 3000)
       socket.emit('getFee', (fee) => {
         clearTimeout(timeout)
         if (!fee) {
@@ -153,6 +156,10 @@ export default class ClarityServer extends EventEmitter {
     })
   }
 
+  async getFee() {
+    return this.getFeeFromWebSocket()
+  }
+
   // for fee monitors
   async getGasPrice() {
     const fee = await this.getFee()
@@ -162,7 +169,7 @@ export default class ClarityServer extends EventEmitter {
   async sendRpcRequest(rpcRequest) {
     const rpcSocket = this.connectRpc()
     return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error('Rpc Timeout')), 30_000)
+      const timeout = setTimeout(() => reject(new Error(RPC_REQUEST_TIMEOUT)), 3000)
       rpcSocket.emit('request', rpcRequest, (response) => {
         clearTimeout(timeout)
         resolve(response)

package/src/fee-utils.js

@@ -1,10 +1,20 @@
 import assert from 'minimalistic-assert'
 
-const applyMultiplierToPriceInWei = ({ feeAsset, feeData, priceInWei }) => {
-  assert(typeof priceInWei === 'string', 'gasPriceInWei should be a string')
+export const shouldFetchEthLikeFallbackGasPrices = async ({ eip1559Enabled, server }) => {
+  const [gasPrice, baseFeePerGas] = await Promise.all([
+    server.getGasPrice(),
+    eip1559Enabled ? server.getBaseFeePerGas() : undefined,
+  ])
 
-  const gasPriceMultiplier = feeData.gasPriceMultiplier || 1
-  return feeAsset.currency.parse(priceInWei).mul(gasPriceMultiplier).toBaseString({ unit: true })
+  return { gasPrice, baseFeePerGas }
+}
+
+export const applyMultiplierToPrice = ({ feeAsset, gasPriceMultiplier, price }) => {
+  assert(typeof price === 'string', 'price should be a string')
+  return feeAsset.currency
+    .parse(price)
+    .mul(gasPriceMultiplier || 1)
+    .toBaseString({ unit: true })
 }
 
 /**
@@ -15,18 +25,18 @@ const applyMultiplierToPriceInWei = ({ feeAsset, feeData, priceInWei }) => {
  * TODO: We shouldn't actually do this, lol. The closer we are to
  *       the node, the better!
  */
-export const rewriteFeeConfig = ({ feeAsset, feeConfig, feeData }) => {
+export const rewriteFeeConfig = ({ feeAsset, feeConfig, gasPriceMultiplier }) => {
   try {
     const { gasPrice, baseFeePerGas, ...extras } = feeConfig
     return {
       ...extras,
-      gasPrice: applyMultiplierToPriceInWei({
+      gasPrice: applyMultiplierToPrice({
         feeAsset,
-        feeData,
-        priceInWei: gasPrice,
+        gasPriceMultiplier,
+        price: gasPrice,
       }) /* required */,
       baseFeePerGas: baseFeePerGas
-        ? applyMultiplierToPriceInWei({ feeAsset, feeData, priceInWei: baseFeePerGas })
+        ? applyMultiplierToPrice({ feeAsset, gasPriceMultiplier, price: baseFeePerGas })
         : undefined,
     }
   } catch (e) {
@@ -38,6 +48,154 @@ export const rewriteFeeConfig = ({ feeAsset, feeConfig, feeData }) => {
   }
 }
 
+const canNormalizeToBigInt = (val) =>
+  typeof val === 'string' || typeof val === 'number' || typeof val === 'bigint'
+
+// Returns a `bigint`ified version of the supplied value.
+export const ensureBigInt = (val) => {
+  assert(canNormalizeToBigInt(val), `unable to normalize ${String(val)}`)
+  return BigInt(val)
+}
+
+export const getOptionalBigInt = (fetchedGasPrices, prop) => {
+  const val = fetchedGasPrices?.[prop]
+  return canNormalizeToBigInt(val) ? BigInt(val) : null
+}
+
+const calculateEthLikeFeeMonitorUpdateNonEip1559 = async ({ gasPrice }) => ({
+  gasPrice: `${gasPrice.toString()} wei`,
+})
+
+export const getBaseFeePerGasFromServerOrNull = async ({ feeAsset }) => {
+  try {
+    const { server } = feeAsset
+    return ensureBigInt(await server.getBaseFeePerGas())
+  } catch {
+    return null
+  }
+}
+
+// HACK: If the `baseFeePerGas` has not been defined for a network,
+//       or due to issues with the `baseFeePerGas` being returned
+//       as `0` from WebSockets, we'll make a fresh attempt to query
+// .     the RPC here. If that still doesn't work we'll return `null`.
+const getBaseFeePerGasOrNull = async ({ feeAsset, fetchedGasPrices }) => {
+  const baseFeePerGas = getOptionalBigInt(fetchedGasPrices, 'baseFeePerGas')
+
+  if (typeof baseFeePerGas === 'bigint' && baseFeePerGas > BigInt('0')) return baseFeePerGas
+
+  return getBaseFeePerGasFromServerOrNull({ feeAsset })
+}
+
+export const calculateEthLikeFeeMonitorUpdateEip1559 = async ({
+  feeAsset,
+  fetchedGasPrices,
+  gasPrice: defaultGasPrice,
+}) => {
+  // Determine the `baseFeePerGas`, if possible.
+  let baseFeePerGas = await getBaseFeePerGasOrNull({ feeAsset, fetchedGasPrices })
+
+  // Some backends will return a `nextBaseFeePerGas`, which
+  // provides us more information about pricing in an upcoming
+  // block.
+  //
+  // As a precaution, rather than choose this value unconditionally,
+  // we'll aim to use the larger between the two (where defined).
+  const nextBaseFeePerGas = getOptionalBigInt(fetchedGasPrices, 'nextBaseFeePerGas')
+  if (typeof nextBaseFeePerGas === 'bigint' && nextBaseFeePerGas > BigInt(baseFeePerGas || 0)) {
+    baseFeePerGas = nextBaseFeePerGas
+  }
+
+  // Knowing the `baseFeePerGas` is required for EIP-1559 networks,
+  // so we if we haven't found one, we cannot continue.
+  if (typeof baseFeePerGas !== 'bigint') throw new Error('expected baseFeePerGas')
+
+  // HACK: Enforce our expectations that the `gasPrice` must be
+  //       at least the `baseFeePerGas`.
+  const gasPrice = baseFeePerGas > defaultGasPrice ? baseFeePerGas : defaultGasPrice
+
+  const defaultFeeConfig = {
+    gasPrice: `${gasPrice.toString()} wei`,
+    baseFeePerGas: `${baseFeePerGas.toString()} wei`,
+  }
+
+  // Determine if there are any `rewardPercentiles` specified in the
+  // `fetchedGasPrices`. If there's nothing, we can continue as normal.
+  if (!fetchedGasPrices.hasOwnProperty('rewardPercentiles')) return defaultFeeConfig
+
+  // If `rewardPercentiles` have been defined, we aim to consume the
+  // `50`th reward percentile, and use this as the `maxPriorityFeePerGas`.
+  const maxPriorityFeePerGas50Percentile = getOptionalBigInt(
+    fetchedGasPrices.rewardPercentiles,
+    '50'
+  )
+
+  // NOTE: We do not use a `maxPriorityFeePerGas50Percentile === 0n` as
+  //       a condition for early termination, since this is a valid
+  //       (although unlikely) condition.
+  if (typeof maxPriorityFeePerGas50Percentile !== 'bigint') return defaultFeeConfig
+
+  return {
+    ...defaultFeeConfig,
+    tipGasPrice: `${maxPriorityFeePerGas50Percentile.toString()} wei`,
+  }
+}
+
+/**
+ * The core logic for normalizing and interpreting cross-server
+ * fee information.
+ */
+export const calculateEthLikeFeeMonitorUpdate = async ({
+  assetClientInterface,
+  feeAsset,
+  fetchedGasPrices,
+}) => {
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(feeAsset, 'expected feeAsset')
+  assert(fetchedGasPrices, 'expected fetchedGasPrices')
+
+  // Depending on whether `eip1559Enabled` on the client, we
+  // can choose to return different properties.
+  const { eip1559Enabled, gasPriceMultiplier } = await assetClientInterface.getFeeConfig({
+    assetName: feeAsset.name,
+  })
+
+  // NOTE: The `gasPrice` is a required value for all EVM networks.
+  const gasPrice = ensureBigInt(fetchedGasPrices.gasPrice)
+
+  const feeConfig = await (eip1559Enabled
+    ? calculateEthLikeFeeMonitorUpdateEip1559({ gasPrice, feeAsset, fetchedGasPrices })
+    : calculateEthLikeFeeMonitorUpdateNonEip1559({ gasPrice }))
+
+  // HACK: We use `rewriteFeeConfig` to apply some additional padding
+  //       to our `gasPrice` and `baseFeePerGas` values. Once we're
+  //       feeling confident, we should be safe to skip doing this for
+  //       `eip1559Enabled` chains, since we should be able to guarantee
+  //       next block inclusion with accuracy.
+  return rewriteFeeConfig({ feeAsset, feeConfig, gasPriceMultiplier })
+}
+
+/**
+ * A common handler for normalizing the handling of `FeeMonitor` updates.
+ */
+export const executeEthLikeFeeMonitorUpdate = async ({
+  assetClientInterface,
+  feeAsset,
+  fetchedGasPrices,
+}) => {
+  const nextFeeConfig = await calculateEthLikeFeeMonitorUpdate({
+    assetClientInterface,
+    feeAsset,
+    fetchedGasPrices,
+  })
+
+  // Update the `assetClientInterface` so our updated fee
+  // settings propagate through the client.
+  await assetClientInterface.updateFeeConfig({ assetName: feeAsset.name, feeConfig: nextFeeConfig })
+
+  return nextFeeConfig
+}
+
 export const resolveGasPrice = ({ feeData }) => {
   assert(feeData, 'feeData is required')
 

package/src/server-based-fee-monitor.js

@@ -1,8 +1,10 @@
 import { FeeMonitor } from '@exodus/asset-lib'
 import assert from 'minimalistic-assert'
 
-import { rewriteFeeConfig } from './fee-utils.js'
-import { fromHexToString } from './number-utils.js'
+import {
+  calculateEthLikeFeeMonitorUpdate,
+  shouldFetchEthLikeFallbackGasPrices,
+} from './fee-utils.js'
 
 /**
  * Generic eth server based fee monitor.
@@ -23,6 +25,11 @@ export const serverBasedFeeMonitorFactoryFactory = ({ asset, interval, server, a
   assert(server, 'server is required')
   assert(aci, 'aci is required')
 
+  const shouldFetchGasPrices = async () => {
+    const { eip1559Enabled } = await aci.getFeeConfig({ assetName: asset.name })
+    return shouldFetchEthLikeFallbackGasPrices({ eip1559Enabled, server })
+  }
+
   const FeeMonitorClass = class ServerBaseEthereumFeeMonitor extends FeeMonitor {
     constructor({ updateFee }) {
       assert(updateFee, 'updateFee is required')
@@ -34,15 +41,11 @@ export const serverBasedFeeMonitorFactoryFactory = ({ asset, interval, server, a
     }
 
     async fetchFee() {
-      const feeData = await aci.getFeeConfig({ assetName: asset.name })
-      const eip1559Enabled = feeData.eip1559Enabled
-      const [gasPrice, baseFeePerGas] = await Promise.all([
-        server.getGasPrice().then((wei) => `${fromHexToString(wei)} wei`),
-        eip1559Enabled ? server.getBaseFeePerGas().then((wei) => `${wei} wei`) : undefined,
-      ])
-
-      const feeConfig = { gasPrice, baseFeePerGas }
-      return rewriteFeeConfig({ feeAsset: asset, feeConfig, feeData })
+      return calculateEthLikeFeeMonitorUpdate({
+        assetClientInterface: aci,
+        feeAsset: asset,
+        fetchedGasPrices: await shouldFetchGasPrices(),
+      })
     }
   }
   return (...args) => new FeeMonitorClass(...args)

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

@@ -2,7 +2,7 @@ import { BaseMonitor } from '@exodus/asset-lib'
 import { getAssetAddresses, isRpcBalanceAsset } from '@exodus/ethereum-lib'
 import lodash from 'lodash'
 
-import { rewriteFeeConfig } from '../fee-utils.js'
+import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
 import { fromHexToString } from '../number-utils.js'
 import { filterEffects, getLogItemsFromServerTx } from './clarity-utils/index.js'
 import {
@@ -286,17 +286,13 @@ export class ClarityMonitor extends BaseMonitor {
     return [...set]
   }
 
-  async updateGasPrice({ gasPrice, baseGasPrice: baseFeePerGas }) {
+  // NOTE: Here, fetchedGasPrices is the result of a call to `ClarityMonitor.getFee()`.
+  async updateGasPrice(fetchedGasPrices) {
     try {
-      const feeData = await this.aci.getFeeConfig({ assetName: this.asset.name })
-
-      const feeConfig = {
-        gasPrice: `${fromHexToString(gasPrice)} wei`,
-        baseFeePerGas: baseFeePerGas ? `${fromHexToString(baseFeePerGas)} wei` : undefined,
-      }
-      await this.aci.updateFeeConfig({
-        assetName: this.asset.name,
-        feeConfig: rewriteFeeConfig({ feeAsset: this.asset, feeData, feeConfig }),
+      await executeEthLikeFeeMonitorUpdate({
+        assetClientInterface: this.aci,
+        feeAsset: this.asset,
+        fetchedGasPrices,
       })
     } catch (e) {
       this.logger.warn('error updating gasPrice', e)

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

@@ -2,7 +2,7 @@ import { BaseMonitor } from '@exodus/asset-lib'
 import { getAssetAddresses, isRpcBalanceAsset } from '@exodus/ethereum-lib'
 import lodash from 'lodash'
 
-import { rewriteFeeConfig } from '../fee-utils.js'
+import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
 import { fromHexToString } from '../number-utils.js'
 import {
   checkPendingTransactions,
@@ -199,30 +199,12 @@ export class EthereumMonitor extends BaseMonitor {
     }
   }
 
-  async updateGasPrice({ gasPrice, baseFeePerGas }) {
+  async updateGasPrice(fetchedGasPrices) {
     try {
-      const feeData = await this.aci.getFeeConfig({ assetName: this.asset.name })
-
-      const resolveBaseFeePerGas = () => {
-        if (!feeData.eip1559Enabled) {
-          return
-        }
-
-        if (baseFeePerGas === 0) {
-          // In some cases, web socker sends 0 baseFeePerGas!!
-          return this.server.getBaseFeePerGas().then((wei) => `${wei} wei`)
-        }
-
-        return `${fromHexToString(baseFeePerGas)} wei`
-      }
-
-      const feeConfig = {
-        gasPrice: `${fromHexToString(gasPrice)} wei`,
-        baseFeePerGas: await resolveBaseFeePerGas(),
-      }
-      await this.aci.updateFeeConfig({
-        assetName: this.asset.name,
-        feeConfig: rewriteFeeConfig({ feeAsset: this.asset, feeConfig, feeData }),
+      await executeEthLikeFeeMonitorUpdate({
+        assetClientInterface: this.aci,
+        feeAsset: this.asset,
+        fetchedGasPrices,
       })
     } catch (e) {
       this.logger.warn('error updating gasPrice', e)

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

@@ -79,6 +79,7 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
       keepTxInput,
       isSendAll,
       isHardware,
+      isPrivate,
     } = options
     let { txInput, feeAmount: providedFeeAmount } = options // avoid let!
 
@@ -230,8 +231,15 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
 
     let { txId, rawTx, nonce, gasLimit, tipGasPrice, feeAmount } = await createTx(createTxParams)
 
+    if (isPrivate && !baseAsset.api.features.transactionPrivacy)
+      throw new Error(
+        `unable to send private transaction - transactionPrivacy is not enabled for ${baseAsset.name}`
+      )
+
+    const broadcastTx = isPrivate ? baseAsset.broadcastPrivateTx : baseAsset.api.broadcastTx
+
     try {
-      await baseAsset.api.broadcastTx(rawTx.toString('hex'))
+      await broadcastTx(rawTx.toString('hex'))
     } catch (err) {
       const nonceTooLowErr = err.message.match(/nonce (is |)too low/i)
       const insufficientFundsErr = err.message.match(/insufficient funds/i)