@exodus/ethereum-api 8.76.5 → 8.76.7

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.76.7](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.6...@exodus/ethereum-api@8.76.7) (2026-06-26)
+
+
+### Features
+
+* clarity native transaction privacy ([#8265](https://github.com/ExodusMovement/assets/issues/8265)) ([c79975e](https://github.com/ExodusMovement/assets/commit/c79975ec0605ef05a4f6eb8c3d1d0fc4531a1f5b))
+* enable multicall3 balance batches for `'no-history'` monitor ([#8276](https://github.com/ExodusMovement/assets/issues/8276)) ([acccb80](https://github.com/ExodusMovement/assets/commit/acccb8062ad5bc9f8c7f80bc14f53943b4421b2a))
+* introduce multicall3 capability ([#8243](https://github.com/ExodusMovement/assets/issues/8243)) ([8fde0b7](https://github.com/ExodusMovement/assets/commit/8fde0b74322854d69d3ea962e5500287d111ec39))
+
+
+### Bug Fixes
+
+* **ethereum-api:** retry and surface non-OK responses in ApiCoinNodesServer ([#8278](https://github.com/ExodusMovement/assets/issues/8278)) ([99cff43](https://github.com/ExodusMovement/assets/commit/99cff4317d5bb2b311972681625cd373c0b555af))
+* **ethereum:** clamp negative spendable from in-flight sends ([#8246](https://github.com/ExodusMovement/assets/issues/8246)) ([25dbe72](https://github.com/ExodusMovement/assets/commit/25dbe7216bec02b4adec9362cf46509077ea7d1f))
+* prevent incompatible account state from interfering with clarity… ([#8251](https://github.com/ExodusMovement/assets/issues/8251)) ([04ac9d0](https://github.com/ExodusMovement/assets/commit/04ac9d0658d57718c76831569455ed5c75566c55))
+* prevent retry on nonce-too-low retry ([#8299](https://github.com/ExodusMovement/assets/issues/8299)) ([d7028b4](https://github.com/ExodusMovement/assets/commit/d7028b40add3fb33f3868f55de96939d9f452b34))
+* use eip-7623 calldata pricing for defaultGasLimit ([#8288](https://github.com/ExodusMovement/assets/issues/8288)) ([227efda](https://github.com/ExodusMovement/assets/commit/227efda89a79970cd763805a17dd1b2ba07e0b23))
+
+
+
+## [8.76.6](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.5...@exodus/ethereum-api@8.76.6) (2026-06-11)
+
+
+### Bug Fixes
+
+
+* fix: Ledger clear-signing for EVM token approvals (#8207)
+
+
+
 ## [8.76.5](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.4...@exodus/ethereum-api@8.76.5) (2026-06-03)
 
 **Note:** Version bump only for package @exodus/ethereum-api

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.76.5",
+  "version": "8.76.7",
   "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",
@@ -29,7 +29,7 @@
     "@exodus/bip44-constants": "^195.0.0",
     "@exodus/crypto": "^1.0.0-rc.26",
     "@exodus/currency": "^6.0.1",
-    "@exodus/ethereum-lib": "^5.24.2",
+    "@exodus/ethereum-lib": "^5.24.3",
     "@exodus/ethereum-meta": "^2.9.1",
     "@exodus/ethereumholesky-meta": "^2.0.5",
     "@exodus/ethereumjs": "^1.11.0",
@@ -40,7 +40,6 @@
     "@exodus/simple-retry": "^0.0.6",
     "@exodus/solidity-contract": "^1.3.0",
     "@exodus/traceparent": "^3.0.1",
-    "@exodus/web3-ethereum-utils": "^4.7.4",
     "@exodus/web3-utils": "^1.51.2",
     "bn.js": "^5.2.1",
     "delay": "^4.0.1",
@@ -70,5 +69,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "651f8346570d40e724109e3df1cd2a3e10323a6f"
+  "gitHead": "c704777d72888bf3a94f3a7ddc1b0e57cda3e6dc"
 }

package/src/address-has-history.js

@@ -1,6 +1,10 @@
 export const addressHasHistoryFactory =
   ({ server }) =>
   async (address) => {
-    const history = await server.getHistoryV2(address, { index: 0, limit: 1 })
-    return history.length > 0
+    const [nonceHex, balanceHex] = await Promise.all([
+      server.getTransactionCount(address, 'pending'),
+      server.getBalanceProxied(address, 'latest'),
+    ])
+
+    return Number.parseInt(nonceHex, 16) > 0 || Number.parseInt(balanceHex, 16) > 0
   }

package/src/create-asset-plugin-factory.js

@@ -60,6 +60,7 @@ export const createAssetPluginFactory = (config) => {
       ...config.feeData,
     }).filter(([_, value]) => value !== undefined)
   )
+
   const createAsset = createAssetFactory({
     assetsList,
     feeDataConfig,

package/src/create-asset-utils.js

@@ -5,8 +5,13 @@ import assert from 'minimalistic-assert'
 import ms from 'ms'
 
 import { EVM_ERROR_REASONS, withErrorReason } from './error-wrapper.js'
-import { createEvmServer, ValidMonitorTypes } from './exodus-eth-server/index.js'
+import ClarityServerV2 from './exodus-eth-server/clarity-v2.js'
+import { ValidMonitorTypes } from './exodus-eth-server/index.js'
 import { createEthereumHooks } from './hooks/index.js'
+import {
+  EthLikeMulticall3RpcRequestAccumulator,
+  EthLikeRpcRequestAccumulator,
+} from './multicall3/index.js'
 import { ClarityMonitor } from './tx-log/clarity-monitor.js'
 import { ClarityTruncatedHistoryMonitor } from './tx-log/clarity-truncated-history-monitor.js'
 import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
@@ -101,27 +106,6 @@ export const stringifyPrivateTx = (tx) => {
   return `0x${tx}`
 }
 
-const broadcastPrivateBundleFactory =
-  ({ privacyServer }) =>
-  async ({ txs }) => {
-    assert(Array.isArray(txs), 'txs must be an array')
-    assert(txs.length > 0, 'txs must be an non-empty array')
-
-    const sendBundleResult = await privacyServer.sendRequest(
-      privacyServer.buildRequest({
-        method: 'eth_sendBundle',
-        params: [{ txs: txs.map((tx) => stringifyPrivateTx(tx)) }],
-      })
-    )
-    if (typeof sendBundleResult === 'string') return { bundleHash: sendBundleResult }
-
-    const bundleHash = sendBundleResult?.bundleHash
-    if (typeof bundleHash === 'string') return { bundleHash }
-
-    console.warn('unexpected sendBundleResult shape, cannot determine bundle hash')
-    return null
-  }
-
 const assertSendPrivateTxProps = ({ asset, unsignedTx, walletAccount }) => {
   assert(asset, 'expected asset')
   assert(unsignedTx, 'expected unsignedTx')
@@ -132,12 +116,10 @@ export const createTransactionPrivacyResult = ({
   assetClientInterface,
   broadcastPrivateBundle,
   broadcastPrivateTx,
-  privacyServer,
 }) => {
   assert(assetClientInterface, 'expected assetClientInterface')
   assert(typeof broadcastPrivateBundle === 'function')
   assert(typeof broadcastPrivateTx === 'function')
-  assert(privacyServer, 'expected privacyServer')
 
   const sendPrivateTx = async ({ asset, unsignedTx, walletAccount }) => {
     assertSendPrivateTxProps({ asset, unsignedTx, walletAccount })
@@ -229,7 +211,6 @@ export const createTransactionPrivacyResult = ({
   return {
     broadcastPrivateBundle,
     broadcastPrivateTx,
-    privacyServer,
     sendPrivateTx,
     sendPrivateBundle,
   }
@@ -238,30 +219,53 @@ export const createTransactionPrivacyResult = ({
 export const createTransactionPrivacyFactory = ({
   assetClientInterface,
   assetName,
-  privacyRpcUrl,
+  server,
+  supportsTransactionPrivacy,
 }) => {
   assert(assetClientInterface, 'expected assetClientInterface')
+  assert(server, 'expected server')
 
-  if (!privacyRpcUrl) return Object.create(null)
+  if (!supportsTransactionPrivacy) return Object.create(null)
 
-  const privacyServer = createEvmServer({
-    assetName,
-    serverUrl: privacyRpcUrl,
-    monitorType: 'no-history',
-  })
+  if (!(server instanceof ClarityServerV2)) {
+    console.warn(
+      `attempted to enable transactionPrivacy for ${assetName} but provided server is incompatible`
+    )
+    return Object.create(null)
+  }
+
+  const broadcastPrivateBundle = async ({ txs }) => {
+    assert(Array.isArray(txs), 'txs must be an array')
+    assert(txs.length > 0, 'txs must be a non-empty array')
+
+    const sendBundleResult = await server.sendBundle({
+      txs: txs.map((tx) => stringifyPrivateTx(tx)),
+    })
+    if (typeof sendBundleResult === 'string') return { bundleHash: sendBundleResult }
 
-  const broadcastPrivateBundle = broadcastPrivateBundleFactory({ privacyServer })
+    const bundleHash = sendBundleResult?.bundleHash
+    if (typeof bundleHash === 'string') return { bundleHash }
 
-  const broadcastPrivateTx = (...args) => privacyServer.sendRawTransaction(...args)
+    console.warn('unexpected sendBundleResult shape, cannot determine bundle hash')
+    return null
+  }
+
+  const broadcastPrivateTx = (tx) => broadcastPrivateBundle({ txs: [tx] })
 
   return createTransactionPrivacyResult({
     assetClientInterface,
     broadcastPrivateBundle,
     broadcastPrivateTx,
-    privacyServer,
   })
 }
 
+export const createRpcRequestAccumulatorFactory =
+  ({ multicall3Address }) =>
+  () =>
+    multicall3Address
+      ? new EthLikeMulticall3RpcRequestAccumulator({ multicall3Address })
+      : new EthLikeRpcRequestAccumulator()
+
 export const createHistoryMonitorFactory = ({
   assetName,
   assetClientInterface,

package/src/create-asset.js

@@ -27,6 +27,7 @@ import { createCheckTx } from './check-tx/index.js'
 import {
   createGetBlackListStatus,
   createHistoryMonitorFactory,
+  createRpcRequestAccumulatorFactory,
   createSecurityChecks,
   createTransactionPrivacyFactory,
   getNonceFactory,
@@ -34,7 +35,7 @@ import {
 } from './create-asset-utils.js'
 import { createTokenFactory } from './create-token-factory.js'
 import { createCustomFeesApi } from './custom-fees.js'
-import { getEIP7702Delegation } from './eth-like-util.js'
+import { getEIP7702Delegation, getIsNftContract } from './eth-like-util.js'
 import { createEvmServer } from './exodus-eth-server/index.js'
 import { createFeeData } from './fee-data/index.js'
 import { createGetBalanceForAddress } from './get-balance-for-address.js'
@@ -68,6 +69,7 @@ export const createAssetFactory = ({
   l1GasOracleAddress, // l1 extra fee for base and optostakingConfiguration = {},
   monitorInterval: defaultMonitorInterval,
   monitorType: defaultMonitorType = 'magnifier',
+  multicall3Address: defaultMulticall3Address,
   nfts: defaultNfts = false,
   serverUrl: defaultServerUrl,
   stakingConfiguration = Object.create(null),
@@ -79,8 +81,9 @@ export const createAssetFactory = ({
   supportsCustomFees: defaultSupportsCustomFees = false,
   useAbsoluteBalanceAndNonce = false,
   delisted = false,
-  privacyRpcUrl: defaultPrivacyRpcUrl,
+  supportsTransactionPrivacy: defaultSupportsTransactionPrivacy,
   wsGatewayUri: defaultWsGatewayUri,
+  eip7623Supported = false,
   eip7702Supported,
   transactionAssessment: defaultTransactionAssessment,
 }) => {
@@ -105,8 +108,9 @@ export const createAssetFactory = ({
     supportsCustomFees: defaultSupportsCustomFees,
     nfts: defaultNfts,
     customTokens: defaultCustomTokens,
-    privacyRpcUrl: defaultPrivacyRpcUrl,
+    supportsTransactionPrivacy: defaultSupportsTransactionPrivacy,
     transactionAssessment: defaultTransactionAssessment,
+    multicall3Address: defaultMulticall3Address,
   }
   return (
     {
@@ -126,8 +130,9 @@ export const createAssetFactory = ({
       customTokens,
       supportsCustomFees,
       useAbsoluteBalanceAndNonce: overrideUseAbsoluteBalanceAndNonce,
-      privacyRpcUrl,
+      supportsTransactionPrivacy,
       transactionAssessment,
+      multicall3Address,
     } = configWithOverrides
 
     const asset = assets[base.name]
@@ -202,16 +207,16 @@ export const createAssetFactory = ({
       server,
     })
 
-    const {
-      broadcastPrivateBundle,
-      broadcastPrivateTx,
-      privacyServer,
-      sendPrivateTx,
-      sendPrivateBundle,
-    } = createTransactionPrivacyFactory({
-      assetClientInterface,
-      assetName: asset.name,
-      privacyRpcUrl,
+    const { broadcastPrivateBundle, broadcastPrivateTx, sendPrivateTx, sendPrivateBundle } =
+      createTransactionPrivacyFactory({
+        assetClientInterface,
+        assetName: asset.name,
+        server,
+        supportsTransactionPrivacy,
+      })
+
+    const createRpcRequestAccumulator = createRpcRequestAccumulatorFactory({
+      multicall3Address,
     })
 
     const features = {
@@ -228,6 +233,7 @@ export const createAssetFactory = ({
       signWithSigner: true,
       signMessageWithSigner: true,
       supportsCustomFees,
+      supportsTransactionPrivacy: Boolean(supportsTransactionPrivacy),
       ...(supportsStaking && { staking: {} }),
       ...(delisted && { delisted }),
     }
@@ -353,7 +359,10 @@ export const createAssetFactory = ({
         signer
           ? signUnsignedTxWithSigner(unsignedTx, signer)
           : signUnsignedTx(unsignedTx, privateKey),
-      signHardware: signHardwareFactory({ baseAssetName: asset.name }),
+      signHardware: signHardwareFactory({
+        baseAssetName: asset.name,
+        getIsNft: ({ address }) => getIsNftContract({ server, address }),
+      }),
       signMessage: ({ message, privateKey, signer }) =>
         signer ? signMessageWithSigner({ message, signer }) : signMessage({ privateKey, message }),
       ...(checkTx && { checkTx }),
@@ -382,6 +391,7 @@ export const createAssetFactory = ({
       monitorType,
       estimateL1DataFee,
       forceGasLimitEstimation,
+      eip7623Supported,
       eip7702Supported,
       getEIP7702Delegation: (addr) => getEIP7702Delegation({ address: addr, server }),
       getNonce,
@@ -390,7 +400,7 @@ export const createAssetFactory = ({
       ...(fuelThreshold && { fuelThreshold: asset.currency.defaultUnit(fuelThreshold) }),
       broadcastPrivateBundle,
       broadcastPrivateTx,
-      privacyServer,
+      createRpcRequestAccumulator,
       sendPrivateTx,
       sendPrivateBundle,
     }

package/src/eth-like-util.js

@@ -159,6 +159,7 @@ export const getIsForwarderContract = memoizeLruCache(
 
 const ERC20 = new SolidityContract(ABI.erc20)
 const ERC20BytesParams = new SolidityContract(ABI.erc20BytesParams)
+const ERC721 = new SolidityContract(ABI.erc721)
 const DEFAULT_PARAM_NAMES = ['decimals', 'name', 'symbol']
 const erc20ParamsCache = Object.create(null)
 
@@ -213,6 +214,58 @@ export const getERC20Params = async ({ asset, address, paramNames = DEFAULT_PARA
   return response
 }
 
+// ERC-165 introspection used to drive Ledger's clear-signing for contract calls:
+// it tells the device whether the target is an NFT (ERC-721/1155) or a fungible
+// token. See `signHardwareFactory` in ethereum-lib for how this feeds the device's
+// `isNft` hint. Display-only: never affects the signed transaction.
+const buildSupportsInterfaceData = (interfaceId) => {
+  const erc165InterfaceId = `0x${interfaceId}`
+  return `0x${ERC721.supportsInterface.build(erc165InterfaceId).toString('hex')}`
+}
+
+const decodeBool = (result) => {
+  return ERC721.decodeOutput({ method: 'supportsInterface', data: result })[0]
+}
+
+// true = supported, false = not supported / reverted, undefined = transport failure
+const probeSupportsInterface = async ({ server, address, interfaceId }) => {
+  try {
+    const result = await server.ethCall({
+      to: address,
+      data: buildSupportsInterfaceData(interfaceId),
+    })
+    return decodeBool(result)
+  } catch (err) {
+    // Empirically, a contract without supportsInterface comes through Clarity as
+    // "Bad rpc response: execution reverted". Unknown errors stay undefined so
+    // we don't force a wrong hint.
+    const EXECUTION_REVERT_MESSAGE = 'execution reverted'
+    const errorMessage = err?.message || String(err || '')
+    return errorMessage.toLowerCase().includes(EXECUTION_REVERT_MESSAGE) ? false : undefined
+  }
+}
+
+// Resolves whether `address` is an NFT contract (ERC-721 or ERC-1155) via ERC-165.
+// Returns true (NFT), false (not an NFT), or undefined (couldn't determine).
+export async function getIsNftContract({ server, address }) {
+  assert(server, 'getIsNftContract(): server required')
+  assert(address, 'getIsNftContract(): address required')
+
+  const ERC721_INTERFACE_ID = '80ac58cd'
+  const ERC1155_INTERFACE_ID = 'd9b67a26'
+
+  const [isErc721, isErc1155] = await Promise.all([
+    probeSupportsInterface({ server, address, interfaceId: ERC721_INTERFACE_ID }),
+    probeSupportsInterface({ server, address, interfaceId: ERC1155_INTERFACE_ID }),
+  ])
+
+  if (isErc721 === true || isErc1155 === true) {
+    return true
+  }
+
+  if (isErc721 === false && isErc1155 === false) return false
+}
+
 export async function getEIP7702Delegation({ address, server }) {
   const code = await withErrorReason({
     promise: server.getCode(address),

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

@@ -1,22 +1,20 @@
-import { bufferToHex } from '@exodus/ethereumjs/util'
 import { safeString } from '@exodus/safe-string'
-import SolidityContract from '@exodus/solidity-contract'
-import EventEmitter from 'events/events.js'
 import lodash from 'lodash'
 
 import { fromHexToString } from '../number-utils.js'
 import { errorMessageToSafeHint } from './errors.js'
+import EthLikeServerBase from './eth-like-server-base.js'
+import { fetchJsonRetry } from './fetch-json.js'
 import { getFallbackGasPriceEstimation } from './utils.js'
 
 const { isEmpty } = lodash
 
-export default class ApiCoinNodesServer extends EventEmitter {
+export default class ApiCoinNodesServer extends EthLikeServerBase {
   constructor({ baseAssetName, uri }) {
     super()
     this.baseAssetName = baseAssetName
     this.uri = uri
     this.defaultUri = uri
-    this.id = 0
   }
 
   setURI(uri) {
@@ -30,8 +28,7 @@ export default class ApiCoinNodesServer extends EventEmitter {
       body: JSON.stringify(body),
     }
 
-    const response = await fetch(this.uri, options)
-    return response.json()
+    return fetchJsonRetry(this.uri, options)
   }
 
   async sendBatchRequest(batch) {
@@ -60,6 +57,12 @@ export default class ApiCoinNodesServer extends EventEmitter {
 
       const revisedError = new Error(`Bad rpc response: ${message}`)
       revisedError.hint = safeString`Bad rpc response: ${errorMessageToSafeHint(message)}`
+
+      const traceId = response?.__traceId
+      if (traceId) {
+        revisedError.traceId = traceId
+      }
+
       throw revisedError
     }
 
@@ -71,78 +74,6 @@ export default class ApiCoinNodesServer extends EventEmitter {
     return code.length > 2
   }
 
-  buildRequest({ method, params = [] }) {
-    return { jsonrpc: '2.0', id: this.id++, method, params }
-  }
-
-  balanceOfRequest(address, tokenAddress, tag = 'latest') {
-    const contract = SolidityContract.simpleErc20(tokenAddress)
-    const callData = contract.balanceOf.build(address)
-    const data = {
-      data: bufferToHex(callData),
-      to: tokenAddress,
-    }
-    return this.ethCallRequest(data, tag)
-  }
-
-  getBalanceRequest(address, tag = 'latest') {
-    return this.buildRequest({ method: 'eth_getBalance', params: [address, tag] })
-  }
-
-  gasPriceRequest() {
-    return this.buildRequest({ method: 'eth_gasPrice' })
-  }
-
-  estimateGasRequest(data) {
-    return this.buildRequest({ method: 'eth_estimateGas', params: [data] })
-  }
-
-  sendRawTransactionRequest(data) {
-    const _data = data instanceof Uint8Array ? Buffer.from(data).toString('hex') : data
-    const hex = _data.startsWith('0x') ? _data : '0x' + _data
-    return this.buildRequest({ method: 'eth_sendRawTransaction', params: [hex] })
-  }
-
-  getCodeRequest(address, tag = 'latest') {
-    return this.buildRequest({ method: 'eth_getCode', params: [address, tag] })
-  }
-
-  getStorageAtRequest(address, position, tag = 'latest') {
-    return this.buildRequest({ method: 'eth_getStorageAt', params: [address, position, tag] })
-  }
-
-  getTransactionCountRequest(address, tag = 'latest') {
-    return this.buildRequest({ method: 'eth_getTransactionCount', params: [address, tag] })
-  }
-
-  getTransactionByHashRequest(hash) {
-    return this.buildRequest({ method: 'eth_getTransactionByHash', params: [hash] })
-  }
-
-  getTransactionReceiptRequest(txhash) {
-    return this.buildRequest({ method: 'eth_getTransactionReceipt', params: [txhash] })
-  }
-
-  ethCallRequest(data, tag = 'latest') {
-    return this.buildRequest({ method: 'eth_call', params: [data, tag] })
-  }
-
-  blockNumberRequest() {
-    return this.buildRequest({ method: 'eth_blockNumber' })
-  }
-
-  getBlockByNumberRequest(numberHex, isFullTxs = false) {
-    return this.buildRequest({ method: 'eth_getBlockByNumber', params: [numberHex, isFullTxs] })
-  }
-
-  simulateRawTransactionRequest(rawTx, applyPending = true) {
-    const replaced = rawTx.replace('0x', '')
-    return this.buildRequest({
-      method: 'debug_simulateRawTransaction',
-      params: [replaced, applyPending],
-    })
-  }
-
   async balanceOf(address, tokenAddress, tag = 'latest') {
     const request = this.balanceOfRequest(address, tokenAddress, tag)
     const result = await this.sendRequest(request)
@@ -176,11 +107,7 @@ export default class ApiCoinNodesServer extends EventEmitter {
   getGasPrice = this.gasPrice
 
   async getLatestBlock() {
-    const request = this.buildRequest({
-      method: 'eth_getBlockByNumber',
-      params: ['latest', false],
-    })
-    return this.sendRequest(request)
+    return this.sendRequest(this.getBlockByNumberRequest('latest', false))
   }
 
   async getBaseFeePerGas() {

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

@@ -1,8 +1,7 @@
-import { retry } from '@exodus/simple-retry'
-import { TraceId } from '@exodus/traceparent'
 import assert from 'minimalistic-assert'
 
 import ClarityServer, { RPC_REQUEST_TIMEOUT } from './clarity.js'
+import { fetchJsonRetry } from './fetch-json.js'
 
 const ASSETS_GATEWAY_URL = 'https://assets-gateway-clarity-api.a.exodus.io/assets'
 
@@ -33,56 +32,12 @@ export const decodeCursor = (cursor) => {
   return { blockNumber: BigInt(0) }
 }
 
-const getTextFromResponse = async (response) => {
-  try {
-    const responseBody = await response.text()
-    return responseBody.slice(0, 100)
-  } catch {
-    return ''
-  }
-}
-
-const fetchJson = async (url, fetchOptions) => {
-  const response = await fetch(url, fetchOptions)
-
-  if (!response.ok) {
-    const traceId = TraceId.fromResponse(response)
-    const error = new Error(
-      `${url} returned ${response.status}: ${
-        response.statusText || 'Unknown Status Text'
-      }. Body: ${await getTextFromResponse(response)}`
-    )
-    if (traceId) {
-      error.traceId = traceId
-    }
-
-    throw error
-  }
-
-  const json = await response.json()
-
-  // Only capture trace ID if there's an RPC error in the response
-  // (handleJsonRPCResponse will extract it when throwing the error)
-  if (json.error) {
-    const traceId = TraceId.fromResponse(response)
-    if (traceId) {
-      json.__traceId = traceId
-    }
-  }
-
-  return json
-}
-
-async function fetchJsonRetry(url, fetchOptions) {
-  const waitTimes = ['3s']
-  const fetchWithRetry = retry(fetchJson, { delayTimesMs: waitTimes })
-  return fetchWithRetry(url, fetchOptions)
-}
-
-const fetchHttpRequest = ({ baseApiPath, path, method, body }) => {
+const fetchHttpRequest = ({ baseApiPath, path, method, body, search }) => {
   assert(typeof baseApiPath === 'string', 'expected string baseApiPath')
 
   const url = new URL(`${baseApiPath}${path}`)
+  if (search) url.search = search
+
   const fetchOptions = {
     method,
     headers: { 'Content-Type': 'application/json' },
@@ -230,8 +185,8 @@ export default class ClarityServerV2 extends ClarityServer {
     }
   }
 
-  fetchRpcHttpRequest = ({ baseApiPath, body }) => {
-    return fetchHttpRequest({ baseApiPath, path: '/rpc', method: 'POST', body })
+  fetchRpcHttpRequest = ({ baseApiPath, path = '/rpc', body }) => {
+    return fetchHttpRequest({ baseApiPath, path, method: 'POST', body })
   }
 
   async sendRpcRequest(rpcRequest) {
@@ -273,4 +228,28 @@ export default class ClarityServerV2 extends ClarityServer {
       await this.fetchRpcHttpRequest({ baseApiPath, body: request })
     )
   }
+
+  getServoTransactionsByBundleHash({ bundleHash }) {
+    assert(bundleHash, 'expected bundleHash')
+
+    const { baseApiPath } = this
+
+    return fetchHttpRequest({
+      baseApiPath,
+      path: '/proxy/servo/transactions',
+      method: 'GET',
+      search: new URLSearchParams({ bundleHash }).toString(),
+    })
+  }
+
+  async sendBundle(...params) {
+    const { baseApiPath } = this
+    return this.handleJsonRPCResponse(
+      await this.fetchRpcHttpRequest({
+        baseApiPath,
+        path: '/proxy/servo',
+        body: this.sendBundleRequest(...params),
+      })
+    )
+  }
 }