@exodus/ethereum-api 8.77.3 → 8.78.0

package/CHANGELOG.md

@@ -3,6 +3,31 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.78.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.1...@exodus/ethereum-api@8.78.0) (2026-08-04)
+
+
+### 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))
+* **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))
+
+
+
+## [8.77.4](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.1...@exodus/ethereum-api@8.77.4) (2026-07-14)
+
+
+### Bug Fixes
+
+* **ethereum-api:** detect legacy delegate transactions ([#8357](https://github.com/ExodusMovement/assets/issues/8357)) ([070e529](https://github.com/ExodusMovement/assets/commit/070e5295f21f12695e97e721ff8c0601c553e447))
+* **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))
+
+
+
 ## [8.77.3](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.1...@exodus/ethereum-api@8.77.3) (2026-07-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.77.3",
+  "version": "8.78.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",
@@ -69,5 +69,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "ccdff56c057e6c4892b304fa47ecfc6c4389f629"
+  "gitHead": "e878130c84c596ee86050984806b0da491e14910"
 }

package/src/create-asset-utils.js

@@ -275,7 +275,7 @@ export const createHistoryMonitorFactory = ({
   stakingAssetNames,
   rpcBalanceAssetNames,
   wsGatewayUri,
-  eip7702Supported,
+  eip7702Whitelist,
   getBlackListStatus,
 }) => {
   assert(assetName, 'expected assetName')
@@ -297,7 +297,7 @@ export const createHistoryMonitorFactory = ({
           interval: ms(monitorInterval || '5m'),
           server,
           rpcBalanceAssetNames,
-          eip7702Supported,
+          eip7702Whitelist,
           getBlackListStatus,
           ...args,
         })
@@ -307,7 +307,7 @@ export const createHistoryMonitorFactory = ({
           assetClientInterface,
           interval: ms(monitorInterval || '5m'),
           server,
-          eip7702Supported,
+          eip7702Whitelist,
           getBlackListStatus,
           ...args,
         })
@@ -317,7 +317,7 @@ export const createHistoryMonitorFactory = ({
           assetClientInterface,
           interval: ms(monitorInterval || '15s'),
           server,
-          eip7702Supported,
+          eip7702Whitelist,
           getBlackListStatus,
           ...args,
         })
@@ -349,7 +349,7 @@ export const createHistoryMonitorFactory = ({
   }
 }
 
-export const createSecurityChecks = ({ eip7702Supported }) => {
+export const createSecurityChecks = ({ eip7702Whitelist }) => {
   return ({ accountState }) => {
     // Always return global scam findings before lower-severity checks because
     // global checks can block the app at startup.
@@ -362,7 +362,11 @@ export const createSecurityChecks = ({ eip7702Supported }) => {
     }
 
     const delegation = accountState?.eip7702Delegation
-    if (eip7702Supported && Boolean(delegation?.isDelegated) && !delegation?.isWhitelisted) {
+    if (
+      eip7702Whitelist.isSupported() &&
+      Boolean(delegation?.isDelegated) &&
+      !delegation?.isWhitelisted
+    ) {
       return {
         isSecure: false,
         type: 'LOST_PERMISSIONS',

package/src/create-asset.js

@@ -35,6 +35,7 @@ import {
 } from './create-asset-utils.js'
 import { createTokenFactory } from './create-token-factory.js'
 import { createCustomFeesApi } from './custom-fees.js'
+import { createEip7702Whitelist } from './eip7702-whitelist.js'
 import { getEIP7702Delegation, getIsNftContract } from './eth-like-util.js'
 import { createEvmServer } from './exodus-eth-server/index.js'
 import { createFeeData } from './fee-data/index.js'
@@ -270,6 +271,11 @@ export const createAssetFactory = ({
 
     const getBlackListStatus = createGetBlackListStatus({ server, address, blacklistChecks })
 
+    // eip7702Supported is the chain-level feature flag ([] when supported).
+    // The whitelist itself is populated from remote config through the
+    // history monitor's setServer.
+    const eip7702Whitelist = createEip7702Whitelist(eip7702Supported)
+
     const accountStateClass =
       CustomAccountState || createEthereumLikeAccountState({ asset: base, assets, extraData })
 
@@ -282,7 +288,7 @@ export const createAssetFactory = ({
       stakingAssetNames,
       rpcBalanceAssetNames,
       wsGatewayUri,
-      eip7702Supported,
+      eip7702Whitelist,
       getBlackListStatus,
     })
 
@@ -318,7 +324,7 @@ export const createAssetFactory = ({
 
     const { getNonce } = getNonceFactory({ assetClientInterface, useAbsoluteBalanceAndNonce })
 
-    const securityChecks = createSecurityChecks({ eip7702Supported })
+    const securityChecks = createSecurityChecks({ eip7702Whitelist })
 
     const web3 = createWeb3API({ asset })
 
@@ -412,7 +418,9 @@ export const createAssetFactory = ({
       estimateL1DataFee,
       forceGasLimitEstimation,
       eip7623Supported,
-      eip7702Supported,
+      // Stable array reference kept up to date with remote config by the
+      // history monitor's setServer.
+      eip7702Supported: eip7702Whitelist.get(),
       getEIP7702Delegation: (addr) => getEIP7702Delegation({ address: addr, server }),
       getNonce,
       server,

package/src/eip7702-whitelist.js

@@ -0,0 +1,62 @@
+const ADDRESS_REGEX = /^0x[\dA-Fa-f]{40}$/
+
+const isValidWhitelistEntry = (entry) =>
+  typeof entry?.address === 'string' &&
+  ADDRESS_REGEX.test(entry.address) &&
+  typeof entry.name === 'string' &&
+  entry.name.length > 0
+
+export const isValidEip7702Whitelist = (whitelist) =>
+  Array.isArray(whitelist) && whitelist.every((entry) => isValidWhitelistEntry(entry))
+
+/**
+ * Mutable holder for the EIP-7702 delegation whitelist, shared between the
+ * history monitors, security checks and the asset itself. The whitelist data
+ * comes exclusively from remote config; plugins pass `eip7702Supported: []`
+ * as the chain-level feature flag, and the list stays empty until remote
+ * config delivers it. Only chains created with an array accept updates.
+ *
+ * @param {Array<{address: string, name: string}>} [defaultWhitelist] - The
+ *   in-code value, `[]` for supported chains. A non-array means the chain
+ *   does not support EIP-7702.
+ */
+export const createEip7702Whitelist = (defaultWhitelist) => {
+  const supported = Array.isArray(defaultWhitelist)
+  // The array identity is stable across updates (mutated in place), so
+  // consumers holding a reference (e.g. asset.eip7702Supported, which gets
+  // spread-copied into the wallet's asset registry) observe updates too.
+  const current = supported
+    ? defaultWhitelist.map(({ address, name }) => ({ address, name }))
+    : undefined
+
+  return {
+    isSupported: () => supported,
+    get: () => current,
+    /**
+     * Replaces the whitelist with the remote-config value. Returns whether the
+     * update was applied. Invalid payloads and updates on chains without
+     * EIP-7702 support are ignored, keeping the last known good whitelist.
+     */
+    update: (remoteWhitelist) => {
+      if (!supported) return false
+      if (!isValidEip7702Whitelist(remoteWhitelist)) return false
+
+      current.length = 0
+      current.push(...remoteWhitelist.map(({ address, name }) => ({ address, name })))
+      return true
+    },
+  }
+}
+
+/**
+ * Applies the `eip7702Whitelist` field of a per-asset remote config payload,
+ * as delivered to the monitors through `monitor.setServer(remoteConfig)`.
+ */
+export const applyRemoteConfigEip7702Whitelist = ({ eip7702Whitelist, remoteConfig, logger }) => {
+  const remoteWhitelist = remoteConfig?.eip7702Whitelist
+  if (remoteWhitelist === undefined) return
+
+  if (!eip7702Whitelist.update(remoteWhitelist)) {
+    logger?.warn('ignoring invalid eip7702Whitelist from remote config')
+  }
+}

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

@@ -1,15 +1,13 @@
 import { safeString } from '@exodus/safe-string'
 import lodash from 'lodash'
 
-import { fromHexToString } from '../number-utils.js'
 import { errorMessageToSafeHint } from './errors.js'
-import EthLikeServerBase from './eth-like-server-base.js'
+import { EthLikeServer } from './eth-like-server.js'
 import { fetchJsonRetry } from './fetch-json.js'
-import { getFallbackGasPriceEstimation } from './utils.js'
 
 const { isEmpty } = lodash
 
-export default class ApiCoinNodesServer extends EthLikeServerBase {
+export default class ApiCoinNodesServer extends EthLikeServer {
   constructor({ baseAssetName, uri }) {
     super()
     this.baseAssetName = baseAssetName
@@ -59,109 +57,6 @@ export default class ApiCoinNodesServer extends EthLikeServerBase {
     return result
   }
 
-  async isContract(address) {
-    const code = await this.getCode(address)
-    return code.length > 2
-  }
-
-  async balanceOf(address, tokenAddress, tag = 'latest') {
-    const request = this.balanceOfRequest(address, tokenAddress, tag)
-    const result = await this.sendRequest(request)
-    const balance = fromHexToString(result)
-    return {
-      confirmed: {
-        [tokenAddress]: balance,
-      },
-    }
-  }
-
-  async getBalance(...params) {
-    const request = this.getBalanceRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getBalanceProxied(...params) {
-    return this.getBalance(...params)
-  }
-
-  async gasPrice(...params) {
-    const request = this.gasPriceRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getGasPriceEstimation() {
-    return getFallbackGasPriceEstimation({ server: this })
-  }
-
-  // for fee monitor
-  getGasPrice = this.gasPrice
-
-  async getLatestBlock() {
-    return this.sendRequest(this.getBlockByNumberRequest('latest', false))
-  }
-
-  async getBaseFeePerGas() {
-    const response = await this.getLatestBlock()
-    if (response.baseFeePerGas) {
-      return fromHexToString(response.baseFeePerGas)
-    }
-  }
-
-  async estimateGas(...params) {
-    const request = this.estimateGasRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async sendRawTransaction(...params) {
-    const request = this.sendRawTransactionRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getCode(...params) {
-    const request = this.getCodeRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getStorageAt(...params) {
-    const request = this.getStorageAtRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getTransactionCount(...params) {
-    const request = this.getTransactionCountRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getTransactionByHash(...params) {
-    const request = this.getTransactionByHashRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getTransactionReceipt(...params) {
-    const request = this.getTransactionReceiptRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async ethCall(...params) {
-    const request = this.ethCallRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async blockNumber(...params) {
-    const request = this.blockNumberRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getBlockByNumber(...params) {
-    const request = this.getBlockByNumberRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async simulateRawTransaction(...params) {
-    const request = this.simulateRawTransactionRequest(...params)
-    return this.sendRequest(request)
-  }
-
   stop() {
     // no web socket to stop!
   }

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

@@ -2,14 +2,12 @@ import { safeString } from '@exodus/safe-string'
 import { TraceId } from '@exodus/traceparent'
 import io from 'socket.io-client'
 
-import { fromHexToString } from '../number-utils.js'
 import { errorMessageToSafeHint } from './errors.js'
-import EthLikeServerBase from './eth-like-server-base.js'
-import { getFallbackGasPriceEstimation } from './utils.js'
+import { EthLikeServer } from './eth-like-server.js'
 
 export const RPC_REQUEST_TIMEOUT = 'RPC_REQUEST_TIMEOUT'
 
-export default class ClarityServer extends EthLikeServerBase {
+export default class ClarityServer extends EthLikeServer {
   constructor({ baseAssetName, uri }) {
     super()
     this.baseAssetName = baseAssetName
@@ -192,10 +190,6 @@ export default class ClarityServer extends EthLikeServerBase {
     return fee?.gasPrice
   }
 
-  async getGasPriceEstimation() {
-    return getFallbackGasPriceEstimation({ server: this })
-  }
-
   async sendRpcRequest(rpcRequest) {
     const rpcSocket = this.connectRpc()
     return new Promise((resolve, reject) => {
@@ -226,168 +220,6 @@ export default class ClarityServer extends EthLikeServerBase {
     return this.handleJsonRPCResponse(response)
   }
 
-  // Transport: Via getCode → sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async isContract(address) {
-    const code = await this.getCode(address)
-    return code.length > 2
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async proxyToCoinNode(params) {
-    const request = this.buildRequest(params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async balanceOf(address, tokenAddress, tag = 'latest') {
-    const request = this.balanceOfRequest(address, tokenAddress, tag)
-    const result = await this.sendRequest(request)
-    const balance = fromHexToString(result)
-    return {
-      confirmed: {
-        [tokenAddress]: balance,
-      },
-    }
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getBalance(...params) {
-    const request = this.getBalanceRequest(...params) // eth_getBalance
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via getBalance → sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getBalanceProxied(...params) {
-    return this.getBalance(...params) // eth_getBalance
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async gasPrice(...params) {
-    const request = this.gasPriceRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: WS only in ClarityServer, HTTP only in ClarityServerV2 (overridden)
-  async estimateGas(...params) {
-    const request = this.estimateGasRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: WS only in ClarityServer, HTTP only in ClarityServerV2 (overridden)
-  async sendRawTransaction(...params) {
-    const request = this.sendRawTransactionRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getCode(...params) {
-    const request = this.getCodeRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getStorageAt(...params) {
-    const request = this.getStorageAtRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: WS only in ClarityServer, HTTP only in ClarityServerV2 (overridden)
-  async getTransactionCount(...params) {
-    const request = this.getTransactionCountRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getTransactionByHash(...params) {
-    const request = this.getTransactionByHashRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getTransactionReceipt(...params) {
-    const request = this.getTransactionReceiptRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async ethCall(...params) {
-    const request = this.ethCallRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async blockNumber(...params) {
-    const request = this.blockNumberRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via getBlockByNumber → sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getLatestBlock() {
-    return this.getBlockByNumber('latest')
-  }
-
-  // Transport: Via getLatestBlock → getBlockByNumber → sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getBaseFeePerGas() {
-    const response = await this.getLatestBlock()
-    if (response.baseFeePerGas) {
-      return fromHexToString(response.baseFeePerGas)
-    }
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getBlockByHash(...params) {
-    const request = this.getBlockByHashRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getBlockTransactionCountByNumber(...params) {
-    const request = this.getBlockTransactionCountByNumberRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getBlockByNumber(...params) {
-    const request = this.getBlockByNumberRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async simulateV1(...params) {
-    const request = this.simulateV1Request(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async simulateRawTransaction(...params) {
-    const request = this.simulateRawTransactionRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getCoinbase() {
-    const request = this.coinbaseRequest()
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getCompilers() {
-    const request = this.getCompilersRequest()
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getNetVersion() {
-    const request = this.getNetVersionRequest()
-    return this.sendRequest(request)
-  }
-
-  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
-  async getLogs(...params) {
-    const request = this.getLogsRequest(...params)
-    return this.sendRequest(request)
-  }
-
   formatTransactionsNamespace(address) {
     return `${this.baseNamespace}/addresses/${address}/transactions`
   }

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

@@ -0,0 +1,377 @@
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import SolidityContract from '@exodus/solidity-contract'
+import EventEmitter from 'events/events.js'
+import assert from 'minimalistic-assert'
+
+import { fromHexToString } from '../number-utils.js'
+import { getFallbackGasPriceEstimation } from './utils.js'
+
+export class EthLikeServerBase extends EventEmitter {
+  id = 0
+
+  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, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_estimateGas', params: [data, tag] })
+  }
+
+  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] })
+  }
+
+  // @deprecated
+  coinbaseRequest() {
+    return this.buildRequest({ method: 'eth_coinbase' })
+  }
+
+  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' })
+  }
+
+  getLogsRequest(object) {
+    return this.buildRequest({ method: 'eth_getLogs', params: [object] })
+  }
+
+  getBlockByNumberRequest(numberHex, isFullTxs = false) {
+    return this.buildRequest({ method: 'eth_getBlockByNumber', params: [numberHex, isFullTxs] })
+  }
+
+  getBlockByHashRequest(blockHash, isFullTxs = false) {
+    return this.buildRequest({ method: 'eth_getBlockByHash', params: [blockHash, isFullTxs] })
+  }
+
+  getBlockTransactionCountByHashRequest(blockHash) {
+    return this.buildRequest({ method: 'eth_getBlockTransactionCountByHash', params: [blockHash] })
+  }
+
+  getBlockTransactionCountByNumberRequest(quantityOrTag) {
+    return this.buildRequest({
+      method: 'eth_getBlockTransactionCountByNumber',
+      params: [quantityOrTag],
+    })
+  }
+
+  // @deprectated
+  getCompilersRequest() {
+    return this.buildRequest({ method: 'eth_getCompilers' })
+  }
+
+  // TODO: Expose on Clarity
+  // maxPriorityFeePerGasRequest() {
+  //   return this.buildRequest({ method: 'eth_maxPriorityFeePerGas' })
+  // }
+
+  // TODO: Expose on Clarity
+  // feeHistoryRequest(blockCount, newestBlock, rewardPercentiles) {
+  //   return this.buildRequest({
+  //     method: 'eth_feeHistory',
+  //     params: [blockCount, newestBlock, rewardPercentiles],
+  //   })
+  // }
+
+  simulateV1Request(...params) {
+    return this.buildRequest({
+      method: 'eth_simulateV1',
+      params,
+    })
+  }
+
+  getNetVersionRequest() {
+    return this.buildRequest({ method: 'net_version' })
+  }
+
+  // @deprecated
+  simulateRawTransactionRequest(rawTx, applyPending = true) {
+    const replaced = rawTx.replace('0x', '')
+    return this.buildRequest({
+      method: 'debug_simulateRawTransaction',
+      params: [replaced, applyPending],
+    })
+  }
+
+  contractStaticCallFromRequest(contract, functionName, from, ...args) {
+    assert(contract instanceof SolidityContract, 'expected SolidityContract contract')
+    assert(typeof functionName === 'string', 'expected string functionName')
+
+    const requestProps = {
+      to: contract.address,
+      data: bufferToHex(contract[functionName].build(...args)),
+    }
+
+    if (from) requestProps.from = from
+
+    return this.ethCallRequest(requestProps)
+  }
+
+  sendBundleRequest({ txs }) {
+    assert(Array.isArray(txs), 'expected array txs')
+    return this.buildRequest({ method: 'eth_sendBundle', params: [{ txs }] })
+  }
+}
+
+const __MISSING_FUNCTION_IMPLEMENTATION__ = () => assert(false)
+
+export class EthLikeServer extends EthLikeServerBase {
+  /**
+   * Validates a JSON-RPC batch response, returning each `result` ordered to
+   * match `batch` (correlated by `id`, since responses can arrive out of order).
+   *
+   * @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`.
+   */
+  parseBatchResponse({ batch, responses, errorMessage }) {
+    // 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`).
+      const message = [responses?.message, responses?.error?.message].find(
+        (value) => typeof value === 'string'
+      )
+      const preview = message ? `: ${message.slice(0, 100)}` : ''
+      throw new Error(`${errorMessage}${preview}`)
+    }
+
+    const isValid = responses.every(
+      (response) => !isNaN(response?.id) && response?.result !== undefined
+    )
+    if (responses.length !== batch.length || !isValid) {
+      throw new Error(errorMessage)
+    }
+
+    // Safe against prototype keys: every `id` is validated numeric by the `isValid` check above.
+    const keyed = Object.fromEntries(
+      responses.map((response) => [`${response.id}`, response.result])
+    )
+    return batch.map((request) => keyed[`${request.id}`])
+  }
+
+  async getCode(...params) {
+    const request = this.getCodeRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async estimateGas(...params) {
+    const request = this.estimateGasRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async sendRawTransaction(...params) {
+    const request = this.sendRawTransactionRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getStorageAt(...params) {
+    const request = this.getStorageAtRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getTransactionCount(...params) {
+    const request = this.getTransactionCountRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getTransactionByHash(...params) {
+    const request = this.getTransactionByHashRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getTransactionReceipt(...params) {
+    const request = this.getTransactionReceiptRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async ethCall(...params) {
+    const request = this.ethCallRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async blockNumber(...params) {
+    const request = this.blockNumberRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getBlockByNumber(...params) {
+    const request = this.getBlockByNumberRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async isContract(address) {
+    const code = await this.getCode(address)
+    return code.length > 2
+  }
+
+  // @deprecated
+  async simulateRawTransaction(...params) {
+    const request = this.simulateRawTransactionRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getBaseFeePerGas() {
+    const response = await this.getLatestBlock()
+    if (response.baseFeePerGas) {
+      return fromHexToString(response.baseFeePerGas)
+    }
+  }
+
+  async getLatestBlock() {
+    return this.getBlockByNumber('latest')
+  }
+
+  async gasPrice(...params) {
+    const request = this.gasPriceRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  // for fee monitor
+  async getGasPrice() {
+    return this.gasPrice()
+  }
+
+  async getBalance(...params) {
+    const request = this.getBalanceRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getBalanceProxied(...params) {
+    return this.getBalance(...params)
+  }
+
+  async getBlockByHash(...params) {
+    const request = this.getBlockByHashRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getBlockTransactionCountByNumber(...params) {
+    const request = this.getBlockTransactionCountByNumberRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async getBlockTransactionCountByHash(...params) {
+    const request = this.getBlockTransactionCountByHashRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async simulateV1(...params) {
+    const request = this.simulateV1Request(...params)
+    return this.sendRequest(request)
+  }
+
+  // @deprecated
+  async getCoinbase() {
+    const request = this.coinbaseRequest()
+    return this.sendRequest(request)
+  }
+
+  // @deprecated
+  async getCompilers() {
+    const request = this.getCompilersRequest()
+    return this.sendRequest(request)
+  }
+
+  // TODO: Expose on Clarity
+  // async getMaxPriorityFeePerGas() {
+  //   const request = this.maxPriorityFeePerGasRequest()
+  //   return this.sendRequest(request)
+  // }
+
+  // TODO: Expose on Clarity
+  // async getFeeHistory(...params) {
+  //   const request = this.feeHistoryRequest(...params)
+  //   return this.sendRequest(request)
+  // }
+
+  async getNetVersion() {
+    const request = this.getNetVersionRequest()
+    return this.sendRequest(request)
+  }
+
+  async getLogs(...params) {
+    const request = this.getLogsRequest(...params)
+    return this.sendRequest(request)
+  }
+
+  async proxyToCoinNode(params) {
+    const request = this.buildRequest(params)
+    return this.sendRequest(request)
+  }
+
+  async getGasPriceEstimation() {
+    return getFallbackGasPriceEstimation({ server: this })
+  }
+
+  async balanceOf(address, tokenAddress, tag = 'latest') {
+    const request = this.balanceOfRequest(address, tokenAddress, tag)
+    const result = await this.sendRequest(request)
+    const balance = fromHexToString(result)
+    return {
+      confirmed: {
+        [tokenAddress]: balance,
+      },
+    }
+  }
+
+  async contractStaticCallFrom(contract, functionName, ...params) {
+    const request = this.contractStaticCallFromRequest(contract, functionName, ...params)
+    return contract[functionName].parse(await this.sendRequest(request))
+  }
+
+  async contractStaticCall(contract, functionName, ...params) {
+    return this.contractStaticCallFrom(contract, functionName, undefined, ...params)
+  }
+
+  sendRequest() {
+    return __MISSING_FUNCTION_IMPLEMENTATION__()
+  }
+
+  sendBatchRequest() {
+    return __MISSING_FUNCTION_IMPLEMENTATION__()
+  }
+}

package/src/multicall3/index.js

@@ -4,7 +4,7 @@ import { bufferToHex } from '@exodus/ethereumjs/util'
 import SolidityContract from '@exodus/solidity-contract'
 import assert from 'minimalistic-assert'
 
-import EthLikeServerBase from '../exodus-eth-server/eth-like-server-base.js'
+import { EthLikeServerBase } from '../exodus-eth-server/eth-like-server.js'
 import { BLOCK_TAG_LATEST } from '../tx-send/nonce-utils.js'
 
 const assertValidMulticall3BlockTag = (blockTag) =>
@@ -73,6 +73,11 @@ export class EthLikeRpcRequestAccumulator extends EthLikeServerBase {
       assertValidMulticall3BlockTag(tag)
     }
 
+    if (method === 'eth_call') {
+      const { from } = params[0]
+      assert(!from, 'cannot specify "from"')
+    }
+
     void this.#requests.push({
       originalRequest,
       request: this._serializeRequest({ originalRequest }),
@@ -103,19 +108,17 @@ export class EthLikeRpcRequestAccumulator extends EthLikeServerBase {
     )(...args)
   }
 
-  contractStaticCallRequest(contract, functionName, ...args) {
-    assert(contract instanceof SolidityContract, 'expected SolidityContract contract')
-    assert(typeof functionName === 'string', 'expected string functionName')
-
+  contractStaticCallFromRequest(contract, functionName, ...args) {
     const requestParser = ({ result }) => contract[functionName].parse(result)
+    return this.#withRequestParser('contractStaticCallFromRequest', requestParser)(
+      contract,
+      functionName,
+      ...args
+    )
+  }
 
-    return this.#withRequestParser(
-      'ethCallRequest',
-      requestParser
-    )({
-      to: contract.address,
-      data: bufferToHex(contract[functionName].build(...args)),
-    })
+  contractStaticCallRequest(contract, functionName, ...args) {
+    return this.contractStaticCallFromRequest(contract, functionName, undefined, ...args)
   }
 
   length() {

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

@@ -39,8 +39,8 @@ const createBalanceAmount = (amount, { decimals, symbol }) => {
   return beforeAmount.sub(afterAmount)
 }
 
-const handleExpectedBalanceChange = (expectedBalanceChange, simulationResult, { network }) => {
-  const { willApprove, willSend, willReceive } = simulationResult.balanceChanges
+const handleExpectedBalanceChange = (expectedBalanceChange, balanceChanges, { network }) => {
+  const { willApprove, willSend, willReceive } = balanceChanges
   const { data, kind } = expectedBalanceChange.rawInfo
 
   if (kind === 'FARCASTER_CHANGE_RECOVERY_ADDRESS' || kind === 'ERC20_PERMIT') {
@@ -49,6 +49,10 @@ const handleExpectedBalanceChange = (expectedBalanceChange, simulationResult, {
 
   const { asset: simulationAsset } = data
 
+  if (!simulationAsset) {
+    return
+  }
+
   const isNftTransfer =
     kind === 'ERC721_TRANSFER' || (kind === 'ERC1155_TRANSFER' && !simulationAsset.decimals)
   const isNftTransferApproval =
@@ -132,17 +136,6 @@ const handleExpectedBalanceChange = (expectedBalanceChange, simulationResult, {
   }
 }
 
-const simulationResultHasAssets = (expectedStateChanges) => {
-  for (const expectedChange of expectedStateChanges) {
-    const { asset: simulationAsset } = expectedChange.rawInfo.data
-    if (!simulationAsset) {
-      return false
-    }
-  }
-
-  return true
-}
-
 export const SimulationErrorMessages = {
   APICallFailed: 0,
   SimulationFailed: 1,
@@ -230,7 +223,25 @@ export const simulateTransactionsApi = async ({
     })
   }
 
-  const noExpectedStateChangesDetected = Object.keys(expectedStateChanges).length === 0
+  const userAddressLower = userAddress.toLowerCase()
+  const recipientAddressLower =
+    recipientAddress && recipientAddress.toLowerCase() !== userAddressLower
+      ? recipientAddress.toLowerCase()
+      : undefined
+
+  const relevantExpectedChanges = Object.entries(expectedStateChanges).flatMap(
+    ([address, changes]) => {
+      const addressLower = address.toLowerCase()
+      const isUserOwned = addressLower === userAddressLower
+      if (!isUserOwned && addressLower !== recipientAddressLower) {
+        return []
+      }
+
+      return (changes ?? []).map((change) => ({ change, isUserOwned }))
+    }
+  )
+
+  const noExpectedStateChangesDetected = relevantExpectedChanges.length === 0
 
   if (noExpectedStateChangesDetected) {
     simulationResult.balanceChanges.willSend.push({
@@ -244,22 +255,11 @@ export const simulateTransactionsApi = async ({
     return successDefaultResult
   }
 
-  const addressesToProcess = [userAddress.toLowerCase()]
-  if (recipientAddress && recipientAddress.toLowerCase() !== userAddress.toLowerCase()) {
-    addressesToProcess.push(recipientAddress.toLowerCase())
-  }
-
-  const relevantExpectedChanges = Object.entries(expectedStateChanges).flatMap(
-    ([address, changes]) =>
-      addressesToProcess.includes(address.toLowerCase()) ? changes ?? [] : []
-  )
-
-  if (!simulationResultHasAssets(relevantExpectedChanges)) {
-    return successDefaultResult
-  }
-
-  relevantExpectedChanges.forEach((expectedChange) => {
-    handleExpectedBalanceChange(expectedChange, simulationResult, { network })
+  relevantExpectedChanges.forEach(({ change, isUserOwned }) => {
+    const balanceChanges = isUserOwned
+      ? simulationResult.balanceChanges
+      : simulationResult.recipientBalanceChanges
+    handleExpectedBalanceChange(change, balanceChanges, { network })
   })
 
   return successDefaultResult

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

@@ -3,6 +3,7 @@ import { getAssetAddresses } from '@exodus/ethereum-lib'
 import lodash from 'lodash'
 import assert from 'minimalistic-assert'
 
+import { applyRemoteConfigEip7702Whitelist, createEip7702Whitelist } from '../eip7702-whitelist.js'
 import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
 import {
   filterEffects,
@@ -29,6 +30,7 @@ export class ClarityMonitor extends BaseMonitor {
     config,
     rpcBalanceAssetNames,
     eip7702Supported,
+    eip7702Whitelist,
     getBlackListStatus,
     ...args
   }) {
@@ -36,7 +38,7 @@ export class ClarityMonitor extends BaseMonitor {
     this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
     this.server = server
     this.rpcBalanceAssetNames = rpcBalanceAssetNames
-    this.eip7702Supported = eip7702Supported
+    this.eip7702Whitelist = eip7702Whitelist ?? createEip7702Whitelist(eip7702Supported)
     this.getBlackListStatus = getBlackListStatus
     this.getAllLogItemsByAsset = getAllLogItemsByAsset
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
@@ -48,6 +50,12 @@ export class ClarityMonitor extends BaseMonitor {
   }
 
   setServer(config) {
+    applyRemoteConfigEip7702Whitelist({
+      eip7702Whitelist: this.eip7702Whitelist,
+      remoteConfig: config,
+      logger: this.logger,
+    })
+
     const uri = config?.server || this.server.defaultUri
 
     if (uri === this.server.uri) {
@@ -294,7 +302,7 @@ export class ClarityMonitor extends BaseMonitor {
     const eip7702Delegation = await getCurrentEIP7702Delegation({
       server: this.server,
       address: derivedData.ourWalletAddress,
-      eip7702Supported: this.eip7702Supported,
+      eip7702Supported: this.eip7702Whitelist.get(),
       currentDelegation: derivedData.currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })

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

@@ -32,7 +32,7 @@ export class ClarityTruncatedHistoryMonitor extends ClarityMonitor {
     const eip7702Delegation = await getCurrentEIP7702Delegation({
       server: this.server,
       address: derivedData.ourWalletAddress,
-      eip7702Supported: this.eip7702Supported,
+      eip7702Supported: this.eip7702Whitelist.get(),
       currentDelegation: derivedData.currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })

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

@@ -3,6 +3,7 @@ import { SynchronizedTime } from '@exodus/basic-utils'
 import { Tx } from '@exodus/models'
 import lodash from 'lodash'
 
+import { applyRemoteConfigEip7702Whitelist, createEip7702Whitelist } from '../eip7702-whitelist.js'
 import { getBatchedRpcBalances } from './monitor-utils/get-batched-rpc-balances.js'
 import { UNCONFIRMED_TX_LIMIT } from './monitor-utils/get-derive-transactions-to-check.js'
 import {
@@ -18,11 +19,11 @@ const { isEmpty, unionBy, zipObject } = lodash
 // The base ethereum monitor no history class handles listening for assets with no history
 
 export class EthereumNoHistoryMonitor extends BaseMonitor {
-  constructor({ server, config, eip7702Supported, getBlackListStatus, ...args }) {
+  constructor({ server, config, eip7702Supported, eip7702Whitelist, getBlackListStatus, ...args }) {
     super(args)
     this.server = server
     this.config = { ...config }
-    this.eip7702Supported = eip7702Supported
+    this.eip7702Whitelist = eip7702Whitelist ?? createEip7702Whitelist(eip7702Supported)
     this.getBlackListStatus = getBlackListStatus
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
@@ -31,6 +32,12 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
   }
 
   setServer(config) {
+    applyRemoteConfigEip7702Whitelist({
+      eip7702Whitelist: this.eip7702Whitelist,
+      remoteConfig: config,
+      logger: this.logger,
+    })
+
     const uri = config?.server || this.server.defaultUri
 
     if (uri === this.server.uri) {
@@ -173,7 +180,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
     const eip7702Delegation = await getCurrentEIP7702Delegation({
       server: this.server,
       address: ourWalletAddress,
-      eip7702Supported: this.eip7702Supported,
+      eip7702Supported: this.eip7702Whitelist.get(),
       currentDelegation: currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })

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

@@ -1,158 +0,0 @@
-import { bufferToHex } from '@exodus/ethereumjs/util'
-import SolidityContract from '@exodus/solidity-contract'
-import EventEmitter from 'events/events.js'
-import assert from 'minimalistic-assert'
-
-export default class EthLikeServerBase extends EventEmitter {
-  id = 0
-
-  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, tag = 'latest') {
-    return this.buildRequest({ method: 'eth_estimateGas', params: [data, tag] })
-  }
-
-  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] })
-  }
-
-  coinbaseRequest() {
-    return this.buildRequest({ method: 'eth_coinbase' })
-  }
-
-  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' })
-  }
-
-  getLogsRequest(object) {
-    return this.buildRequest({ method: 'eth_getLogs', params: [object] })
-  }
-
-  getBlockByNumberRequest(numberHex, isFullTxs = false) {
-    return this.buildRequest({ method: 'eth_getBlockByNumber', params: [numberHex, isFullTxs] })
-  }
-
-  getBlockByHashRequest(blockHash, isFullTxs = false) {
-    return this.buildRequest({ method: 'eth_getBlockByHash', params: [blockHash, isFullTxs] })
-  }
-
-  getBlockTransactionCountByHashRequest(blockHash) {
-    return this.buildRequest({ method: 'eth_getBlockTransactionCountByHash', params: [blockHash] })
-  }
-
-  getBlockTransactionCountByNumberRequest(quantityOrTag) {
-    return this.buildRequest({
-      method: 'eth_getBlockTransactionCountByNumber',
-      params: [quantityOrTag],
-    })
-  }
-
-  getCompilersRequest() {
-    return this.buildRequest({ method: 'eth_getCompilers' })
-  }
-
-  simulateV1Request(...params) {
-    return this.buildRequest({
-      method: 'eth_simulateV1',
-      params,
-    })
-  }
-
-  getNetVersionRequest() {
-    return this.buildRequest({ method: 'net_version' })
-  }
-
-  simulateRawTransactionRequest(rawTx, applyPending = true) {
-    const replaced = rawTx.replace('0x', '')
-    return this.buildRequest({
-      method: 'debug_simulateRawTransaction',
-      params: [replaced, applyPending],
-    })
-  }
-
-  sendBundleRequest({ txs }) {
-    assert(Array.isArray(txs), 'expected array txs')
-    return this.buildRequest({ method: 'eth_sendBundle', params: [{ txs }] })
-  }
-
-  /**
-   * Validates a JSON-RPC batch response, returning each `result` ordered to
-   * match `batch` (correlated by `id`, since responses can arrive out of order).
-   *
-   * @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`.
-   */
-  parseBatchResponse({ batch, responses, errorMessage }) {
-    // 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`).
-      const message = [responses?.message, responses?.error?.message].find(
-        (value) => typeof value === 'string'
-      )
-      const preview = message ? `: ${message.slice(0, 100)}` : ''
-      throw new Error(`${errorMessage}${preview}`)
-    }
-
-    const isValid = responses.every(
-      (response) => !isNaN(response?.id) && response?.result !== undefined
-    )
-    if (responses.length !== batch.length || !isValid) {
-      throw new Error(errorMessage)
-    }
-
-    // Safe against prototype keys: every `id` is validated numeric by the `isValid` check above.
-    const keyed = Object.fromEntries(
-      responses.map((response) => [`${response.id}`, response.result])
-    )
-    return batch.map((request) => keyed[`${request.id}`])
-  }
-}