@exodus/ethereum-api 8.64.6 → 8.65.0

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

@@ -1,4 +1,5 @@
 import { retry } from '@exodus/simple-retry'
+import { TraceId } from '@exodus/traceparent'
 import assert from 'minimalistic-assert'
 
 import ClarityServer, { RPC_REQUEST_TIMEOUT } from './clarity.js'
@@ -43,14 +44,31 @@ const fetchJson = async (url, fetchOptions) => {
   const response = await fetch(url, fetchOptions)
 
   if (!response.ok) {
-    throw new Error(
+    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 response.json()
+  return json
 }
 
 async function fetchJsonRetry(url, fetchOptions) {
@@ -126,9 +144,6 @@ export default class ClarityServerV2 extends ClarityServer {
       //       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.
@@ -185,8 +200,9 @@ export default class ClarityServerV2 extends ClarityServer {
     }
   }
 
-  fetchRpcHttpRequest = ({ baseApiPath, body }) =>
-    fetchHttpRequest({ baseApiPath, path: '/rpc', method: 'POST', body })
+  fetchRpcHttpRequest = ({ baseApiPath, body }) => {
+    return fetchHttpRequest({ baseApiPath, path: '/rpc', method: 'POST', body })
+  }
 
   async sendRpcRequest(rpcRequest) {
     try {
@@ -201,6 +217,8 @@ export default class ClarityServerV2 extends ClarityServer {
     }
   }
 
+  // Maybe some functions from clarity should be overriden to have handleJsonRPCResponse as well
+
   async sendRawTransaction(...params) {
     const { baseApiPath } = this
     const request = this.sendRawTransactionRequest(...params)

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

@@ -1,6 +1,7 @@
 import { bufferToHex } from '@exodus/ethereumjs/util'
 import { safeString } from '@exodus/safe-string'
 import SolidityContract from '@exodus/solidity-contract'
+import { TraceId } from '@exodus/traceparent'
 import EventEmitter from 'events/events.js'
 import io from 'socket.io-client'
 
@@ -104,12 +105,20 @@ export default class ClarityServer extends EventEmitter {
 
       const revisedError = new Error(`Bad rpc response: ${message}`)
       revisedError.hint = safeString`Bad rpc response: ${errorMessageToSafeHint(message)}`
+
+      // Preserve trace ID: from HTTP (__traceId) or WebSocket (traceparent in JSON body)
+      const traceId = response?.__traceId || response?.traceparent
+      if (traceId) {
+        revisedError.traceId = traceId
+      }
+
       throw revisedError
     }
 
     return result
   }
 
+  // Transport: WS only in ClarityServer, HTTP only in ClarityServerV2 (overridden)
   async getAllTransactions(params) {
     const transactions = { pending: [], confirmed: [] }
     const cursor = await this.getTransactions({
@@ -129,6 +138,7 @@ export default class ClarityServer extends EventEmitter {
     return { cursor, transactions }
   }
 
+  // Transport: WS only (uses transactions socket, not RPC socket)
   async getTransactions({ walletAccount, address, cursor, onChunk }) {
     const socket = this.connectTransactions({ walletAccount, address })
     const listener = (isPending, chunk, callback) => {
@@ -149,6 +159,7 @@ export default class ClarityServer extends EventEmitter {
       .finally(() => socket.off('transactionsChunk', listener))
   }
 
+  // Transport: WS only (uses fee socket)
   getFeeFromWebSocket() {
     const socket = this.connectFee()
     return new Promise((resolve, reject) => {
@@ -165,10 +176,12 @@ export default class ClarityServer extends EventEmitter {
     })
   }
 
+  // Transport: WS only in ClarityServer, HTTP first → WS fallback in ClarityServerV2 (overridden)
   async getFee() {
     return this.getFeeFromWebSocket()
   }
 
+  // Transport: Depends on getFee() - WS only in ClarityServer, HTTP first → WS fallback in ClarityServerV2
   // for fee monitors
   async getGasPrice() {
     const fee = await this.getFee()
@@ -185,11 +198,18 @@ export default class ClarityServer extends EventEmitter {
       const timeout = setTimeout(() => reject(new Error(RPC_REQUEST_TIMEOUT)), 3000)
       rpcSocket.emit('request', rpcRequest, (response) => {
         clearTimeout(timeout)
+        const rawTraceparent = response?.traceparent || response?.[0]?.traceparent
+        if (rawTraceparent) {
+          // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+          response.traceparent = TraceId.fromRawTraceparent(rawTraceparent)
+        }
+
         resolve(response)
       })
     })
   }
 
+  // Transport: WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2
   async sendBatchRequest(batch) {
     const responses = await this.sendRpcRequest(batch)
     // FIXME: this falls apart if responses is not an array
@@ -206,12 +226,14 @@ export default class ClarityServer extends EventEmitter {
     return batch.map((request) => keyed[`${request.id}`])
   }
 
+  // Transport: Uses sendRpcRequest - WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2
   async sendRequest(request) {
     const response = await this.sendRpcRequest(request)
 
     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
@@ -327,11 +349,13 @@ export default class ClarityServer extends EventEmitter {
     })
   }
 
+  // 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)
@@ -343,69 +367,83 @@ export default class ClarityServer extends EventEmitter {
     }
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getBalance(...params) {
-    const request = this.getBalanceRequest(...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)
+    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) {
@@ -413,46 +451,55 @@ export default class ClarityServer extends EventEmitter {
     }
   }
 
+  // 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.getNetVersion()
     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)

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

@@ -22,7 +22,7 @@ export function createEvmServer({ assetName, serverUrl, monitorType }) {
   assert(monitorType, 'monitorType is required')
   switch (monitorType) {
     case 'no-history':
-      return new ApiCoinNodesServer({ uri: serverUrl })
+      return new ApiCoinNodesServer({ baseAssetName: assetName, uri: serverUrl })
     case 'clarity':
       return new ClarityServer({ baseAssetName: assetName, uri: serverUrl })
     case 'clarity-v2':

package/src/fee-utils.js

@@ -1,34 +1,40 @@
 import assert from 'minimalistic-assert'
 
-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 })
-}
-
 /**
  * Returns augmented `feeConfig` values manipulated using the `feeData`,
  * for example, like multiplying the `gasPrice`. This helps us to apply
  * modifications to values before presenting them to the consumer.
- *
- * TODO: We shouldn't actually do this, lol. The closer we are to
- *       the node, the better!
  */
-export const rewriteFeeConfig = ({ feeAsset, feeConfig, gasPriceMultiplier }) => {
+export const refineFeeConfig = ({ feeAsset, feeConfig, gasPriceBump, gasPriceMultiplier }) => {
+  const fromString = (str) => {
+    assert(typeof str === 'string', 'expected string')
+    return feeAsset.currency.parse(str)
+  }
+
   try {
-    const { gasPrice, baseFeePerGas, ...extras } = feeConfig
+    const { gasPrice, baseFeePerGas, tipGasPrice, ...extras } = feeConfig
+
+    gasPriceMultiplier ||= 1
+    gasPriceBump ||= feeAsset.currency.ZERO
+
+    if (!baseFeePerGas) {
+      const nextGasPrice = fromString(gasPrice).mul(gasPriceMultiplier).add(gasPriceBump)
+      return {
+        ...extras,
+        gasPrice: nextGasPrice.toBaseString({ unit: true }),
+      }
+    }
+
+    const nextBaseFeePerGas = fromString(baseFeePerGas).mul(gasPriceMultiplier)
+    const nextTipGasPrice = tipGasPrice
+      ? fromString(tipGasPrice).mul(gasPriceMultiplier).add(gasPriceBump)
+      : gasPriceBump
+
     return {
       ...extras,
-      gasPrice: applyMultiplierToPrice({
-        feeAsset,
-        gasPriceMultiplier,
-        price: gasPrice,
-      }) /* required */,
-      baseFeePerGas: baseFeePerGas
-        ? applyMultiplierToPrice({ feeAsset, gasPriceMultiplier, price: baseFeePerGas })
-        : undefined,
+      baseFeePerGas: nextBaseFeePerGas.toBaseString({ unit: true }),
+      tipGasPrice: nextTipGasPrice.toBaseString({ unit: true }),
+      gasPrice: nextBaseFeePerGas.add(nextTipGasPrice).toBaseString({ unit: true }),
     }
   } catch (e) {
     console.error(
@@ -148,9 +154,10 @@ export const calculateEthLikeFeeMonitorUpdate = async ({
 
   // Depending on whether `eip1559Enabled` on the client, we
   // can choose to return different properties.
-  const { eip1559Enabled, gasPriceMultiplier } = await assetClientInterface.getFeeConfig({
-    assetName: feeAsset.name,
-  })
+  const { eip1559Enabled, gasPriceBump, gasPriceMultiplier } =
+    await assetClientInterface.getFeeConfig({
+      assetName: feeAsset.name,
+    })
 
   // NOTE: The `gasPrice` is a required value for all EVM networks.
   const gasPrice = ensureBigInt(fetchedGasPrices.gasPrice)
@@ -159,12 +166,7 @@ export const calculateEthLikeFeeMonitorUpdate = async ({
     ? 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 })
+  return refineFeeConfig({ feeAsset, feeConfig, gasPriceBump, gasPriceMultiplier })
 }
 
 /**

package/src/index.js

@@ -88,7 +88,13 @@ export {
   fromHexToBN,
 } from './number-utils.js'
 
-export { reasons as errorReasons, withErrorReason, EthLikeError } from './error-wrapper.js'
+export {
+  EVM_ERROR_REASONS,
+  EVM_ERROR_TYPES,
+  getEvmErrorReason,
+  withErrorReason,
+  EthLikeError,
+} from './error-wrapper.js'
 
 export { txSendFactory } from './tx-send/index.js'
 

package/src/nft-utils.js

@@ -1,7 +1,8 @@
+import { safeString } from '@exodus/safe-string'
 import SolidityContract from '@exodus/solidity-contract'
 import assert from 'minimalistic-assert'
 
-import * as ErrorWrapper from './error-wrapper.js'
+import { EthLikeError, EVM_ERROR_REASONS } from './error-wrapper.js'
 import { fetchGasLimit } from './gas-estimation.js'
 
 export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) => {
@@ -44,10 +45,11 @@ export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) =>
       }
     })
   ).catch((e) => {
-    throw new ErrorWrapper.EthLikeError({
+    throw new EthLikeError({
       message: errors.join('\n'),
-      reason: ErrorWrapper.reasons.fetchGasLimitFailed,
-      hint: 'getNftArguments',
+      errorReasonInfo: EVM_ERROR_REASONS.fetchGasLimitFailed,
+      hint: safeString`getNftArguments`,
+      traceId: e.traceId,
     })
   })
   return {

package/src/optimism-gas/index.js

@@ -1,7 +1,9 @@
 import { createContract, createEthereumJsTx } from '@exodus/ethereum-lib'
 import { bufferToHex } from '@exodus/ethereumjs/util'
+import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
 
+import { EVM_ERROR_REASONS, withErrorReason } from '../error-wrapper.js'
 import { fromHexToBigInt } from '../number-utils.js'
 
 export const estimateL1DataFeeFactory = ({ l1GasOracleAddress, server }) => {
@@ -14,7 +16,12 @@ export const estimateL1DataFeeFactory = ({ l1GasOracleAddress, server }) => {
     const callData = gasContract.getL1Fee.build(serialized)
     const buffer = Buffer.from(callData)
     const data = bufferToHex(buffer)
-    const hex = await server.ethCall({ to: l1GasOracleAddress, data }, 'latest')
+    const hex = await withErrorReason({
+      promise: server.ethCall({ to: l1GasOracleAddress, data }, 'latest'),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallFailed,
+      hint: safeString`estimateL1DataFee`,
+      baseAssetName: server.baseAssetName,
+    })
     const l1DataFee = fromHexToBigInt(hex)
     const padFee = l1DataFee / BigInt(4)
     const maxL1DataFee = l1DataFee + padFee

package/src/staking/ethereum/api.js

@@ -1,7 +1,9 @@
 import { createContract } from '@exodus/ethereum-lib'
 import { bufferToHex } from '@exodus/ethereumjs/util'
+import { safeString } from '@exodus/safe-string'
 import { retry } from '@exodus/simple-retry'
 
+import { EVM_ERROR_REASONS, withErrorReason } from '../../error-wrapper.js'
 import { getServerByName } from '../../exodus-eth-server/index.js'
 
 // TODO: Shouldn't this be a function of `ethereumStakingState.minDelegateAmount`?
@@ -78,7 +80,12 @@ export class EthereumStaking {
     if (typeof from === 'string' && from.length > 0) data.from = from
 
     const eth = this.server || getServerByName(this.asset.name)
-    return retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data)
+    return withErrorReason({
+      promise: retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallFailed,
+      hint: safeString`stakingEthReadFunctionContract`,
+      baseAssetName: eth.baseAssetName,
+    })
   }
 
   // === ACCOUNTING ===

package/src/staking/matic/api.js

@@ -1,9 +1,11 @@
 import { createContract } from '@exodus/ethereum-lib'
 import ethAssets from '@exodus/ethereum-meta'
 import { bufferToHex } from '@exodus/ethereumjs/util'
+import { safeString } from '@exodus/safe-string'
 import { retry } from '@exodus/simple-retry'
 import BN from 'bn.js'
 
+import { EVM_ERROR_REASONS, withErrorReason } from '../../error-wrapper.js'
 import { getServerByName } from '../../exodus-eth-server/index.js'
 import { fromHexToBN, fromHexToString, splitIn32BytesArray } from '../../number-utils.js'
 
@@ -43,7 +45,12 @@ export class MaticStakingApi {
     }
 
     const eth = this.server || getServerByName('ethereum')
-    return retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data)
+    return withErrorReason({
+      promise: retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallFailed,
+      hint: safeString`stakingMaticReadFunctionContract`,
+      baseAssetName: eth.baseAssetName,
+    })
   }
 
   getWithdrawalDelay = async () => {

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

@@ -28,7 +28,14 @@ export class ClarityMonitorV2 extends BaseMonitor {
   #walletAccountByAddress = new Map()
   #walletAccountInfo = new Map()
   #rpcBalanceAssetNames = []
-  constructor({ server, wsGatewayClient, rpcBalanceAssetNames, config, ...args } = {}) {
+  constructor({
+    server,
+    wsGatewayClient,
+    rpcBalanceAssetNames,
+    eip7702Supported,
+    config,
+    ...args
+  } = {}) {
     super(args)
     assert(wsGatewayClient instanceof WsGateway, 'expected WsGateway wsGatewayClient')
 
@@ -36,6 +43,7 @@ export class ClarityMonitorV2 extends BaseMonitor {
     this.server = server
     this.#wsClient = wsGatewayClient
     this.#rpcBalanceAssetNames = rpcBalanceAssetNames
+    this.eip7702Supported = eip7702Supported
     this.getAllLogItemsByAsset = getAllLogItemsByAsset
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
@@ -227,6 +235,7 @@ export class ClarityMonitorV2 extends BaseMonitor {
     const eip7702Delegation = await getCurrentEIP7702Delegation({
       server: this.server,
       address: derivedData.ourWalletAddress,
+      eip7702Supported: this.eip7702Supported,
       currentDelegation: derivedData.currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })

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

@@ -23,11 +23,12 @@ import {
 const { isEmpty } = lodash
 
 export class ClarityMonitor extends BaseMonitor {
-  constructor({ server, config, rpcBalanceAssetNames, ...args }) {
+  constructor({ server, config, rpcBalanceAssetNames, eip7702Supported, ...args }) {
     super(args)
     this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
     this.server = server
     this.rpcBalanceAssetNames = rpcBalanceAssetNames
+    this.eip7702Supported = eip7702Supported
     this.getAllLogItemsByAsset = getAllLogItemsByAsset
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
@@ -191,6 +192,7 @@ export class ClarityMonitor extends BaseMonitor {
     const eip7702Delegation = await getCurrentEIP7702Delegation({
       server: this.server,
       address: derivedData.ourWalletAddress,
+      eip7702Supported: this.eip7702Supported,
       currentDelegation: derivedData.currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })

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

@@ -17,10 +17,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, ...args }) {
+  constructor({ server, config, eip7702Supported, ...args }) {
     super(args)
     this.server = server
     this.config = { ...config }
+    this.eip7702Supported = eip7702Supported
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
       getTxLog: (...args) => this.aci.getTxLog(...args),
@@ -190,6 +191,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
     const eip7702Delegation = await getCurrentEIP7702Delegation({
       server: this.server,
       address: ourWalletAddress,
+      eip7702Supported: this.eip7702Supported,
       currentDelegation: currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })