@aztec-labs/ethereum 6.0.0-nightly.20260829

package/dest/utils.js

@@ -0,0 +1,260 @@
+import { ErrorsAbi } from '@aztec/l1-artifacts/ErrorsAbi';
+import { BaseError, ContractFunctionRevertedError, decodeErrorResult, decodeEventLog } from 'viem';
+import { formatAbiItem, formatAbiParams } from 'viem/utils';
+export class FormattedViemError extends Error {
+    metaMessages;
+    constructor(message, metaMessages, options){
+        super(message, options);
+        this.name = 'FormattedViemError';
+        this.metaMessages = metaMessages;
+    }
+}
+export function extractEvent(logs, address, abi, eventName, filter, logger) {
+    const event = tryExtractEvent(logs, address, abi, eventName, filter, logger);
+    if (!event) {
+        throw new Error(`Failed to find matching event ${eventName} for contract ${address}`);
+    }
+    return event;
+}
+export function tryExtractEvent(logs, address, abi, eventName, filter, logger) {
+    for (const log of logs){
+        if (log.address.toLowerCase() === address.toLowerCase()) {
+            try {
+                const decodedEvent = decodeEventLog({
+                    abi,
+                    ...log
+                });
+                if (decodedEvent.eventName === eventName) {
+                    const matchingEvent = decodedEvent;
+                    if (!filter || filter(matchingEvent)) {
+                        return matchingEvent;
+                    }
+                }
+            } catch (err) {
+                logger?.warn(`Failed to decode event log for contract ${address}: ${err}`);
+            }
+        }
+    }
+}
+export function prettyLogViemErrorMsg(err) {
+    if (err instanceof BaseError) {
+        const revertError = err.walk((err)=>err instanceof ContractFunctionRevertedError);
+        if (revertError instanceof ContractFunctionRevertedError) {
+            const errorName = revertError.data?.errorName ?? '';
+            const args = revertError.metaMessages && revertError.metaMessages?.length > 1 ? revertError.metaMessages[1].trimStart() : '';
+            return `${errorName}${args}`;
+        }
+    }
+    return err?.message ?? err;
+}
+export function mergeAbis(abis) {
+    let merged = [];
+    const seen = new Set();
+    for (const abi of abis){
+        for (const item of abi){
+            const key = getAbiItemKey(item);
+            if (!seen.has(key)) {
+                seen.add(key);
+                merged = [
+                    ...merged,
+                    item
+                ];
+            }
+        }
+    }
+    return merged;
+}
+function getAbiItemKey(item) {
+    if (item.type === 'function') {
+        const signature = formatAbiItem(item);
+        const outputs = formatAbiParams(item.outputs);
+        const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+        return `function:${signature}:${outputs}:${stateMutability}`;
+    }
+    if (item.type === 'event') {
+        const signature = formatAbiItem(item);
+        const indexed = (item.inputs ?? []).map((input)=>input.indexed ? '1' : '0').join('');
+        const anonymous = item.anonymous ? 'anonymous' : 'not-anonymous';
+        return `event:${signature}:${indexed}:${anonymous}`;
+    }
+    if (item.type === 'error') {
+        const signature = formatAbiItem(item);
+        return `error:${signature}`;
+    }
+    if (item.type === 'constructor') {
+        const inputs = formatAbiParams(item.inputs);
+        const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+        return `constructor::${inputs}:${stateMutability}`;
+    }
+    if (item.type === 'fallback' || item.type === 'receive') {
+        const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+        return `${item.type}:::${stateMutability}`;
+    }
+    return 'unknown';
+}
+function getNestedErrorData(error) {
+    // If nothing, bail
+    if (!error) {
+        return undefined;
+    }
+    // If it's an object with a `data` property, return it
+    // (Remember to check TS type-safely or cast as needed)
+    if (typeof error === 'object' && error !== null && 'data' in error) {
+        const possibleData = error.data;
+        if (typeof possibleData === 'string' && possibleData.startsWith('0x')) {
+            return possibleData;
+        }
+    }
+    // If it has a `cause`, recurse
+    if (typeof error === 'object' && error !== null && 'cause' in error) {
+        return getNestedErrorData(error.cause);
+    }
+    // Not found
+    return undefined;
+}
+/**
+ * Truncates an error message to a safe length for log renderers.
+ * LogExplorer can only render up to 2500 characters in its summary view.
+ * We cap at 2000 to leave room for decorating context added by callers.
+ */ function truncateErrorMessage(message) {
+    const MAX = 2000;
+    const CHUNK = 950;
+    if (message.length <= MAX) {
+        return message;
+    }
+    const truncated = message.length - 2 * CHUNK;
+    return message.slice(0, CHUNK) + `...${truncated} characters truncated...` + message.slice(-CHUNK);
+}
+/**
+ * Formats a Viem error into a FormattedViemError instance.
+ * @param error - The error to format.
+ * @param abi - The ABI to use for decoding.
+ * @returns A FormattedViemError instance.
+ */ export function formatViemError(error, abi = ErrorsAbi) {
+    // If error is already a FormattedViemError, return it as is
+    if (error instanceof FormattedViemError) {
+        return error;
+    }
+    const originalError = error;
+    // First try to decode as a custom error using the ABI
+    try {
+        const data = getNestedErrorData(error);
+        if (data) {
+            // Try to decode the error data using the ABI
+            const decoded = decodeErrorResult({
+                abi,
+                data: data
+            });
+            if (decoded) {
+                return new FormattedViemError(`${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`, error?.metaMessages, {
+                    cause: originalError
+                });
+            }
+        }
+        // If it's a BaseError, try to get the custom error through ContractFunctionRevertedError
+        if (error instanceof BaseError) {
+            const revertError = error.walk((err)=>err instanceof ContractFunctionRevertedError);
+            if (revertError instanceof ContractFunctionRevertedError) {
+                let errorName = revertError.data?.errorName;
+                if (!errorName) {
+                    errorName = revertError.signature ?? '';
+                }
+                const args = revertError.metaMessages && revertError.metaMessages?.length > 1 ? revertError.metaMessages[1].trimStart() : '';
+                return new FormattedViemError(`${errorName}${args}`, error?.metaMessages, {
+                    cause: originalError
+                });
+            }
+        }
+    } catch  {
+    // If decoding fails, we fall back to the original formatting
+    }
+    // Strip ABI from the error object before formatting
+    if (error && typeof error === 'object') {
+        // Create a clone to avoid modifying the original
+        const errorClone = structuredClone(error);
+        // Helper function to recursively remove ABI properties
+        // Strip ABIs from the clone
+        stripAbis(errorClone);
+        // Use the cleaned clone for further processing
+        error = errorClone;
+    }
+    // If it's a regular Error instance, return it with its message
+    if (error instanceof Error) {
+        return new FormattedViemError(truncateErrorMessage(error.message), error?.metaMessages, {
+            cause: originalError
+        });
+    }
+    return new FormattedViemError(truncateErrorMessage(String(error)), undefined, {
+        cause: originalError
+    });
+}
+function stripAbis(obj) {
+    if (!obj || typeof obj !== 'object') {
+        return;
+    }
+    // Delete ABI property at current level
+    if ('abi' in obj) {
+        delete obj.abi;
+    }
+    // Process cause property
+    if (obj.cause) {
+        stripAbis(obj.cause);
+    }
+    // Process arrays and objects
+    Object.values(obj).forEach((value)=>{
+        if (value && typeof value === 'object') {
+            stripAbis(value);
+        }
+    });
+}
+/**
+ * Best-effort decode of a raw revert payload (`0x...`) against an ABI.
+ * Returns a human-readable `ErrorName(arg1, arg2, ...)` string, or `undefined` if the selector
+ * is unknown or the payload is empty. Use to surface decoded error names alongside the raw
+ * payload in log lines for operators.
+ */ export function tryDecodeRevertReason(data, abi) {
+    if (!data || data === '0x') {
+        return undefined;
+    }
+    try {
+        const decoded = decodeErrorResult({
+            abi,
+            data
+        });
+        return `${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`;
+    } catch  {
+        return undefined;
+    }
+}
+export function tryGetCustomErrorName(err) {
+    try {
+        // See https://viem.sh/docs/contract/simulateContract#handling-custom-errors
+        if (err.name === 'ViemError' || err.name === 'ContractFunctionExecutionError') {
+            const baseError = err;
+            const revertError = baseError.walk((err)=>err.name === 'ContractFunctionRevertedError');
+            if (revertError) {
+                return revertError.data?.errorName;
+            }
+        }
+    } catch  {
+        return undefined;
+    }
+}
+/**
+ * Type guard to check if a transaction is a blob transaction (EIP-4844).
+ * Blob transactions have maxFeePerBlobGas and blobVersionedHashes fields.
+ */ export function isBlobTransaction(tx) {
+    return 'maxFeePerBlobGas' in tx && tx.maxFeePerBlobGas !== undefined && 'blobVersionedHashes' in tx && tx.blobVersionedHashes !== undefined;
+}
+/**
+ * Calculates a percentile from an array of bigints
+ */ export function calculatePercentile(values, percentile) {
+    if (values.length === 0) {
+        return 0n;
+    }
+    const sorted = [
+        ...values
+    ].sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
+    const index = Math.ceil((sorted.length - 1) * (percentile / 100));
+    return sorted[index];
+}

package/dest/zkPassportVerifierAddress.d.ts

@@ -0,0 +1,15 @@
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+/**
+ * The address of the zk passport verifier on sepolia
+ * get address from: ROOT/l1-contracts/lib/circuits/src/solidity/deployments/deployment-11155111.json
+ */
+export declare const ZK_PASSPORT_VERIFIER_ADDRESS: EthAddress;
+/**
+ * The default domain of the zk passport site
+ */
+export declare const ZK_PASSPORT_DOMAIN = "testnet.aztec.network";
+/**
+ * The default scope of the zk passport proofs
+ */
+export declare const ZK_PASSPORT_SCOPE = "personhood";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemtQYXNzcG9ydFZlcmlmaWVyQWRkcmVzcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3prUGFzc3BvcnRWZXJpZmllckFkZHJlc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRWhFOzs7R0FHRztBQUNILGVBQU8sTUFBTSw0QkFBNEIsWUFBc0UsQ0FBQztBQUNoSDs7R0FFRztBQUNILGVBQU8sTUFBTSxrQkFBa0IsMEJBQTBCLENBQUM7QUFDMUQ7O0dBRUc7QUFDSCxlQUFPLE1BQU0saUJBQWlCLGVBQWUsQ0FBQyJ9

package/dest/zkPassportVerifierAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zkPassportVerifierAddress.d.ts","sourceRoot":"","sources":["../src/zkPassportVerifierAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,4BAA4B,YAAsE,CAAC;AAChH;;GAEG;AACH,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAC1D;;GAEG;AACH,eAAO,MAAM,iBAAiB,eAAe,CAAC"}

package/dest/zkPassportVerifierAddress.js

@@ -0,0 +1,11 @@
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+/**
+ * The address of the zk passport verifier on sepolia
+ * get address from: ROOT/l1-contracts/lib/circuits/src/solidity/deployments/deployment-11155111.json
+ */ export const ZK_PASSPORT_VERIFIER_ADDRESS = EthAddress.fromString('0x3101Bad9eA5fACadA5554844a1a88F7Fe48D4DE0');
+/**
+ * The default domain of the zk passport site
+ */ export const ZK_PASSPORT_DOMAIN = 'testnet.aztec.network';
+/**
+ * The default scope of the zk passport proofs
+ */ export const ZK_PASSPORT_SCOPE = 'personhood';

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@aztec-labs/ethereum",
+  "version": "6.0.0-nightly.20260829",
+  "type": "module",
+  "exports": {
+    "./account": "./dest/account.js",
+    "./chain": "./dest/chain.js",
+    "./client": "./dest/client.js",
+    "./config": "./dest/config.js",
+    "./constants": "./dest/constants.js",
+    "./contracts": "./dest/contracts/index.js",
+    "./deploy-aztec-l1-contracts": "./dest/deploy_aztec_l1_contracts.js",
+    "./deploy-l1-contract": "./dest/deploy_l1_contract.js",
+    "./contracts/registry": "./dest/contracts/registry.js",
+    "./contracts/rollup": "./dest/contracts/rollup.js",
+    "./eth-signer": "./dest/eth-signer/index.js",
+    "./forwarder-proxy": "./dest/forwarder_proxy.js",
+    "./l1-artifacts": "./dest/l1_artifacts.js",
+    "./l1-contract-addresses": "./dest/l1_contract_addresses.js",
+    "./l1-fee-analysis": "./dest/l1_tx_utils/l1_fee_analyzer.js",
+    "./l1-reader": "./dest/l1_reader.js",
+    "./l1-tx-utils": "./dest/l1_tx_utils/index.js",
+    "./l1-tx-utils-with-blobs": "./dest/l1_tx_utils/index-blobs.js",
+    "./l1-tx-utils/config": "./dest/l1_tx_utils/config.js",
+    "./l1-types": "./dest/l1_types.js",
+    "./publisher-manager": "./dest/publisher_manager.js",
+    "./queries": "./dest/queries.js",
+    "./test": "./dest/test/index.js",
+    "./types": "./dest/types.js",
+    "./utils": "./dest/utils.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Ethereum",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "start:dev": "concurrently -k \"../scripts/tsc.sh --watch\" \"nodemon --watch dest --exec yarn start\"",
+    "start": "node ./dest/index.js",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "proposer-address": "node ./dest/cli/forwarder_address.js"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "dependencies": {
+    "@aztec-labs/blob-lib": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec/l1-artifacts": "6.0.0-nightly.20260826",
+    "dotenv": "^16.0.3",
+    "lodash.chunk": "^4.2.0",
+    "lodash.pickby": "^4.5.0",
+    "tslib": "^2.4.0",
+    "viem": "npm:@aztec/viem@2.38.2",
+    "zod": "^4"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@noble/curves": "=1.7.0",
+    "@types/jest": "^30.0.0",
+    "@types/lodash.pickby": "^4",
+    "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "get-port": "^7.1.0",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "lodash.omit": "^4.5.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/types.d.ts",
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/account.ts

@@ -0,0 +1,5 @@
+import { privateKeyToAccount } from 'viem/accounts';
+
+export function getAddressFromPrivateKey(privateKey: `0x${string}`): `0x${string}` {
+  return privateKeyToAccount(privateKey).address;
+}

package/src/chain.ts

@@ -0,0 +1,71 @@
+import type { Chain } from 'viem';
+import { foundry } from 'viem/chains';
+
+import { AZTEC_TEST_CHAIN_ID } from './constants.js';
+
+/**
+ * Interface containing the connection and chain properties to interact with a blockchain.
+ */
+export interface EthereumChain {
+  /**
+   * An instance of the viem chain data.
+   */
+  chainInfo: Chain;
+
+  /**
+   * The list of actual urls to be used.
+   */
+  rpcUrls: string[];
+}
+
+/**
+ * Helper function to create an instance of Aztec Chain from an rpc url and chain id.
+ * @param rpcUrls - The rpc url of the chain or a chain identifier (e.g. 'http://localhost:8545')
+ * @param chainId - The chain id of the chain or a chain identifier (e.g. 1337)
+ */
+export function createEthereumChain(rpcUrls: string[], _chainId: number | string): EthereumChain {
+  let chainId: number;
+  if (typeof _chainId === 'string') {
+    chainId = +_chainId;
+  } else {
+    chainId = _chainId;
+  }
+  if (chainId) {
+    return {
+      chainInfo: {
+        id: chainId,
+        name: 'Ethereum',
+        rpcUrls: {
+          default: {
+            http: rpcUrls,
+          },
+        },
+        nativeCurrency: {
+          decimals: 18,
+          name: 'Ether',
+          symbol: 'ETH',
+        },
+      },
+      rpcUrls,
+    };
+  } else {
+    return {
+      chainInfo: foundry,
+      rpcUrls,
+    };
+  }
+}
+
+/**
+ * Helper function to determine if a chain id is an instance of Anvil
+ */
+export function isAnvilTestChain(_chainId: number | string): boolean {
+  let chainId: number;
+  if (typeof _chainId === 'string') {
+    chainId = +_chainId;
+  } else {
+    chainId = _chainId;
+  }
+  const testChains = [foundry.id, AZTEC_TEST_CHAIN_ID];
+  return testChains.includes(chainId);
+}

package/src/client.ts

@@ -0,0 +1,165 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import { retryUntil } from '@aztec-labs/foundation/retry';
+import { getErrorCause } from '@aztec-labs/foundation/types';
+import {
+  type Chain,
+  type FallbackTransport,
+  type HDAccount,
+  HttpRequestError,
+  type HttpTransport,
+  type LocalAccount,
+  type PrivateKeyAccount,
+  RpcRequestError,
+  createPublicClient,
+  createWalletClient,
+  fallback,
+  http,
+  publicActions,
+} from 'viem';
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+import { foundry } from 'viem/chains';
+
+import { createEthereumChain } from './chain.js';
+import type { ExtendedViemWalletClient, ViemPublicClient } from './types.js';
+
+type Config = {
+  /** List of URLs of Ethereum RPC nodes that services will connect to (comma separated). */
+  l1RpcUrls: string[];
+  /** The chain ID of the ethereum host. */
+  l1ChainId: number;
+  /** The polling interval viem uses in ms */
+  viemPollingIntervalMS?: number;
+  /** Timeout for HTTP requests to the L1 RPC node in ms. */
+  l1HttpTimeoutMS?: number;
+};
+
+export type { Config as EthereumClientConfig };
+
+/** Error exposed by L1 RPC transports without including provider URLs in its message. */
+export class L1RpcError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = 'L1RpcError';
+  }
+}
+
+/** Creates a viem fallback HTTP transport for the given L1 RPC URLs. */
+export function makeL1HttpTransport(rpcUrls: string[], opts?: { timeout?: number }) {
+  return wrapL1RpcTransport(fallback(rpcUrls.map(url => http(url, { batch: false, timeout: opts?.timeout }))));
+}
+
+/** Returns the HTTP status from an L1 RPC error's cause chain, if one is available. */
+export function getL1RpcHttpStatus(err: unknown): number | undefined {
+  return getErrorCause(err, HttpRequestError)?.status;
+}
+
+/** Returns true when an L1 RPC error's cause chain contains the given HTTP status. */
+export function isL1RpcHttpStatus(err: unknown, status: number): boolean {
+  return getL1RpcHttpStatus(err) === status;
+}
+
+/** Returns the JSON-RPC error code reported by the L1 node, if the error's cause chain carries one. */
+export function getL1RpcErrorCode(err: unknown): number | undefined {
+  return getErrorCause(err, RpcRequestError)?.code;
+}
+
+function wrapL1RpcTransport(transport: FallbackTransport<HttpTransport[]>): FallbackTransport<HttpTransport[]> {
+  const wrappedTransport: FallbackTransport<HttpTransport[]> = parameters => {
+    const fallbackTransport = transport(parameters);
+    const request: typeof fallbackTransport.request = async args => {
+      try {
+        return await fallbackTransport.request(args);
+      } catch (err) {
+        throw err instanceof L1RpcError ? err : new L1RpcError('L1 RPC request failed', { cause: err });
+      }
+    };
+    return { ...fallbackTransport, request };
+  };
+
+  return wrappedTransport;
+}
+
+/**
+ * Returns the individual RPC URLs underlying a viem public client that was constructed with a
+ * fallback HTTP transport (see {@link makeL1HttpTransport}). Returns an empty array if the
+ * transport shape is not recognized (e.g. mock clients in tests, or non-fallback transports).
+ */
+export function getRpcUrlsFromClient(client: ViemPublicClient): string[] {
+  const transport = client.transport as unknown as {
+    transports?: { value?: { url?: string } }[];
+    value?: { url?: string };
+    url?: string;
+  };
+  if (Array.isArray(transport?.transports)) {
+    return transport.transports.map(t => t?.value?.url).filter((url): url is string => typeof url === 'string');
+  }
+  const singleUrl = transport?.value?.url ?? transport?.url;
+  return typeof singleUrl === 'string' ? [singleUrl] : [];
+}
+
+// TODO: Use these methods to abstract the creation of viem clients.
+
+/** Returns a viem public client given the L1 config. */
+export function getPublicClient(config: Config): ViemPublicClient {
+  const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
+  return createPublicClient({
+    chain: chain.chainInfo,
+    transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: config.l1HttpTimeoutMS }),
+    pollingInterval: config.viemPollingIntervalMS,
+  });
+}
+
+/** Returns a viem public client after waiting for the L1 RPC node to become available. */
+export async function waitForPublicClient(config: Config, logger?: Logger): Promise<ViemPublicClient> {
+  const client = getPublicClient(config);
+  await waitForRpc(client, config, logger);
+  return client;
+}
+
+async function waitForRpc(client: ViemPublicClient, config: Config, logger?: Logger) {
+  const l1ChainId = await retryUntil(
+    async () => {
+      let chainId = 0;
+      try {
+        chainId = await client.getChainId();
+      } catch {
+        logger?.warn(`Failed to connect to Ethereum node at ${config.l1RpcUrls.join(', ')}. Retrying...`);
+      }
+      return chainId;
+    },
+    `L1 RPC url at ${config.l1RpcUrls.join(', ')}`,
+    600,
+    1,
+  );
+
+  if (l1ChainId !== config.l1ChainId) {
+    throw new Error(
+      `Ethereum node at ${config.l1RpcUrls.join(', ')} has chain ID ${l1ChainId} but expected ${config.l1ChainId}`,
+    );
+  }
+}
+
+export function createExtendedL1Client(
+  rpcUrls: string[],
+  mnemonicOrPrivateKeyOrHdAccount: string | HDAccount | PrivateKeyAccount | LocalAccount,
+  chain: Chain = foundry,
+  pollingIntervalMS?: number,
+  addressIndex?: number,
+  opts?: { httpTimeoutMS?: number },
+): ExtendedViemWalletClient {
+  const hdAccount =
+    typeof mnemonicOrPrivateKeyOrHdAccount === 'string'
+      ? mnemonicOrPrivateKeyOrHdAccount.startsWith('0x')
+        ? privateKeyToAccount(mnemonicOrPrivateKeyOrHdAccount as `0x${string}`)
+        : mnemonicToAccount(mnemonicOrPrivateKeyOrHdAccount, { addressIndex })
+      : mnemonicOrPrivateKeyOrHdAccount;
+
+  const extendedClient = createWalletClient({
+    account: hdAccount,
+    chain,
+    transport: makeL1HttpTransport(rpcUrls, { timeout: opts?.httpTimeoutMS }),
+    pollingInterval: pollingIntervalMS,
+  }).extend(publicActions);
+
+  return extendedClient;
+}