@aztec/ethereum 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/deploy_l1_contract.ts

@@ -0,0 +1,362 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+
+import {
+  type Abi,
+  type ContractConstructorArgs,
+  type Hex,
+  type Narrow,
+  concatHex,
+  encodeAbiParameters,
+  encodeDeployData,
+  getContractAddress,
+  numberToHex,
+  padHex,
+} from 'viem';
+
+import {
+  type ContractArtifacts,
+  DEPLOYER_ADDRESS,
+  type Libraries,
+  type VerificationLibraryEntry,
+  type VerificationRecord,
+} from './deploy_aztec_l1_contracts.js';
+import { RegisterNewRollupVersionPayloadArtifact } from './l1_artifacts.js';
+import { type L1TxUtilsConfig, getL1TxUtilsConfigEnvVars } from './l1_tx_utils/config.js';
+import { createL1TxUtilsFromViemWallet } from './l1_tx_utils/factory.js';
+import type { L1TxUtils } from './l1_tx_utils/l1_tx_utils.js';
+import type { GasPrice, L1TxConfig, L1TxRequest } from './l1_tx_utils/types.js';
+import type { ExtendedViemWalletClient } from './types.js';
+import { formatViemError } from './utils.js';
+
+export class L1Deployer {
+  private salt: Hex | undefined;
+  private txHashes: Hex[] = [];
+  public readonly l1TxUtils: L1TxUtils;
+  public readonly verificationRecords: VerificationRecord[] = [];
+
+  constructor(
+    public readonly client: ExtendedViemWalletClient,
+    maybeSalt: number | undefined,
+    dateProvider: DateProvider = new DateProvider(),
+    private acceleratedTestDeployments: boolean = false,
+    private logger: Logger = createLogger('L1Deployer'),
+    private txUtilsConfig?: L1TxUtilsConfig,
+    private createVerificationJson: boolean = false,
+  ) {
+    this.salt = maybeSalt ? padHex(numberToHex(maybeSalt), { size: 32 }) : undefined;
+    this.l1TxUtils = createL1TxUtilsFromViemWallet(
+      this.client,
+      { logger: this.logger, dateProvider },
+      { ...this.txUtilsConfig, debugMaxGasLimit: acceleratedTestDeployments },
+    );
+  }
+
+  async deploy<const TAbi extends Abi>(
+    params: ContractArtifacts<TAbi>,
+    args?: ContractConstructorArgs<TAbi>,
+    opts: { gasLimit?: bigint; noSimulation?: boolean } = {},
+  ): Promise<{ address: EthAddress; existed: boolean }> {
+    this.logger.debug(`Deploying ${params.name} contract`, { args });
+    try {
+      const { txHash, address, deployedLibraries, existed } = await deployL1Contract(
+        this.client,
+        params.contractAbi,
+        params.contractBytecode,
+        (args ?? []) as readonly unknown[],
+        {
+          salt: this.salt,
+          libraries: params.libraries,
+          logger: this.logger,
+          l1TxUtils: this.l1TxUtils,
+          acceleratedTestDeployments: this.acceleratedTestDeployments,
+          gasLimit: opts.gasLimit,
+          noSimulation: opts.noSimulation,
+        },
+      );
+      if (txHash) {
+        this.txHashes.push(txHash);
+      }
+      this.logger.debug(`Deployed ${params.name} at ${address}`, { args });
+
+      if (this.createVerificationJson) {
+        // Encode constructor args for verification
+        let constructorArgsHex: Hex = '0x';
+        try {
+          const abiItem: any = (params.contractAbi as any[]).find((x: any) => x && x.type === 'constructor');
+          const inputDefs: any[] = abiItem && Array.isArray(abiItem.inputs) ? abiItem.inputs : [];
+          constructorArgsHex =
+            inputDefs.length > 0 ? (encodeAbiParameters(inputDefs as any, (args ?? []) as any) as Hex) : ('0x' as Hex);
+        } catch {
+          constructorArgsHex = '0x' as Hex;
+        }
+
+        this.verificationRecords.push({
+          name: params.name,
+          address: address.toString(),
+          constructorArgsHex,
+          libraries: deployedLibraries ?? [],
+        });
+      }
+      return {
+        address,
+        existed,
+      };
+    } catch (error) {
+      throw new Error(`Failed to deploy ${params.name}`, { cause: formatViemError(error) });
+    }
+  }
+
+  async waitForDeployments(): Promise<void> {
+    if (this.acceleratedTestDeployments) {
+      this.logger.info('Accelerated test deployments - skipping waiting for deployments');
+      return;
+    }
+    if (this.txHashes.length === 0) {
+      return;
+    }
+
+    this.logger.verbose(`Waiting for ${this.txHashes.length} transactions to be mined`, { txHashes: this.txHashes });
+    const receipts = await Promise.all(
+      this.txHashes.map(txHash => this.client.waitForTransactionReceipt({ hash: txHash })),
+    );
+    const failed = receipts.filter(r => r.status !== 'success');
+    if (failed.length > 0) {
+      throw new Error(`Some deployment txs have failed: ${failed.map(f => f.transactionHash).join(', ')}`);
+    }
+    this.logger.info('All transactions mined successfully', { txHashes: this.txHashes });
+  }
+
+  sendTransaction(
+    tx: L1TxRequest,
+    options?: L1TxConfig,
+  ): Promise<{ txHash: Hex; gasLimit: bigint; gasPrice: GasPrice }> {
+    return this.l1TxUtils.sendTransaction(tx, options).then(({ txHash, state }) => ({
+      txHash,
+      gasLimit: state.gasLimit,
+      gasPrice: state.gasPrice,
+    }));
+  }
+}
+
+/**
+ * Helper function to deploy ETH contracts.
+ * @param walletClient - A viem WalletClient.
+ * @param publicClient - A viem PublicClient.
+ * @param abi - The ETH contract's ABI (as abitype's Abi).
+ * @param bytecode  - The ETH contract's bytecode.
+ * @param args - Constructor arguments for the contract.
+ * @param salt - Optional salt for CREATE2 deployment (does not wait for deployment tx to be mined if set, does not send tx if contract already exists).
+ * @returns The ETH address the contract was deployed to.
+ */
+export async function deployL1Contract(
+  extendedClient: ExtendedViemWalletClient,
+  abi: Narrow<Abi | readonly unknown[]>,
+  bytecode: Hex,
+  args: readonly unknown[] = [],
+  opts: {
+    salt?: Hex;
+    libraries?: Libraries;
+    logger?: Logger;
+    l1TxUtils?: L1TxUtils;
+    gasLimit?: bigint;
+    acceleratedTestDeployments?: boolean;
+    noSimulation?: boolean;
+  } = {},
+): Promise<{
+  address: EthAddress;
+  txHash: Hex | undefined;
+  deployedLibraries?: VerificationLibraryEntry[];
+  existed: boolean;
+}> {
+  let txHash: Hex | undefined = undefined;
+  let resultingAddress: Hex | null | undefined = undefined;
+  const deployedLibraries: VerificationLibraryEntry[] = [];
+
+  const { salt: saltFromOpts, libraries, logger, gasLimit, acceleratedTestDeployments, noSimulation } = opts;
+  let { l1TxUtils } = opts;
+
+  if (!l1TxUtils) {
+    const config = getL1TxUtilsConfigEnvVars();
+    l1TxUtils = createL1TxUtilsFromViemWallet(
+      extendedClient,
+      { logger },
+      { ...config, debugMaxGasLimit: acceleratedTestDeployments },
+    );
+  }
+
+  if (libraries) {
+    // Note that this does NOT work well for linked libraries having linked libraries.
+
+    // Verify that all link references have corresponding code
+    for (const linkRef in libraries.linkReferences) {
+      for (const contractName in libraries.linkReferences[linkRef]) {
+        if (!libraries.libraryCode[contractName]) {
+          throw new Error(`Missing library code for ${contractName}`);
+        }
+      }
+    }
+
+    const replacements: Record<string, EthAddress> = {};
+    const libraryTxs: Hex[] = [];
+    for (const libraryName in libraries?.libraryCode) {
+      const lib = libraries.libraryCode[libraryName];
+      const { libraries: _libraries, ...optsWithoutLibraries } = opts;
+      const { address, txHash } = await deployL1Contract(
+        extendedClient,
+        lib.contractAbi,
+        lib.contractBytecode,
+        [],
+        optsWithoutLibraries,
+      );
+
+      // Log deployed library name and address for easier verification/triage
+      logger?.verbose(`Linked library deployed`, { library: libraryName, address: address.toString(), txHash });
+
+      if (txHash) {
+        libraryTxs.push(txHash);
+      }
+
+      // Try to find the source file for this library from linkReferences
+      let fileNameForLibrary: string | undefined = undefined;
+      for (const fileName in libraries.linkReferences) {
+        if (libraries.linkReferences[fileName] && libraries.linkReferences[fileName][libraryName]) {
+          fileNameForLibrary = fileName;
+          break;
+        }
+      }
+      if (fileNameForLibrary) {
+        deployedLibraries.push({
+          file: fileNameForLibrary,
+          contract: libraryName,
+          address: address.toString(),
+        });
+      }
+
+      for (const linkRef in libraries.linkReferences) {
+        for (const contractName in libraries.linkReferences[linkRef]) {
+          // If the library name matches the one we just deployed, we replace it.
+          if (contractName !== libraryName) {
+            continue;
+          }
+
+          // We read the first instance to figure out what we are to replace.
+          const start = 2 + 2 * libraries.linkReferences[linkRef][contractName][0].start;
+          const length = 2 * libraries.linkReferences[linkRef][contractName][0].length;
+
+          const toReplace = bytecode.slice(start, start + length);
+          replacements[toReplace] = address;
+        }
+      }
+    }
+
+    const escapeRegExp = (s: string) => {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // Escape special characters
+    };
+
+    for (const toReplace in replacements) {
+      const replacement = replacements[toReplace].toString().slice(2);
+      bytecode = bytecode.replace(new RegExp(escapeRegExp(toReplace), 'g'), replacement) as Hex;
+    }
+
+    // Reth fails gas estimation if the deployed contract attempts to call a library that is not yet deployed,
+    // so we wait for all library deployments to be mined before deploying the contract.
+    // However, if we are in fast mode or using debugMaxGasLimit, we will skip simulation, so we can skip waiting.
+    if (libraryTxs.length > 0 && !acceleratedTestDeployments) {
+      logger?.verbose(`Awaiting for linked libraries to be deployed`);
+      await Promise.all(libraryTxs.map(txHash => extendedClient.waitForTransactionReceipt({ hash: txHash })));
+    } else {
+      logger?.verbose(
+        `Skipping waiting for linked libraries to be deployed ${
+          acceleratedTestDeployments ? '(accelerated test deployments)' : ''
+        }`,
+      );
+    }
+  }
+
+  let existed = false;
+
+  if (saltFromOpts) {
+    logger?.info(`Deploying contract with salt ${saltFromOpts}`);
+    const { address, paddedSalt: salt, calldata } = getExpectedAddress(abi, bytecode, args, saltFromOpts);
+    resultingAddress = address;
+    const existing = await extendedClient.getCode({ address: resultingAddress });
+    if (existing === undefined || existing === '0x') {
+      if (!noSimulation) {
+        try {
+          await l1TxUtils.simulate({ to: DEPLOYER_ADDRESS, data: concatHex([salt, calldata]), gas: gasLimit });
+        } catch (err) {
+          logger?.error(`Failed to simulate deployment tx using universal deployer`, err);
+          await l1TxUtils.simulate({ to: null, data: encodeDeployData({ abi, bytecode, args }), gas: gasLimit });
+        }
+      }
+      const res = await l1TxUtils.sendTransaction(
+        { to: DEPLOYER_ADDRESS, data: concatHex([salt, calldata]) },
+        { gasLimit },
+      );
+      txHash = res.txHash;
+
+      logger?.verbose(`Deployed contract with salt ${salt} to address ${resultingAddress} in tx ${txHash}.`);
+    } else {
+      logger?.verbose(`Skipping existing deployment of contract with salt ${salt} to address ${resultingAddress}`);
+      existed = true;
+    }
+  } else {
+    const deployData = encodeDeployData({ abi, bytecode, args });
+    const { receipt } = await l1TxUtils.sendAndMonitorTransaction(
+      {
+        to: null,
+        data: deployData,
+      },
+      { gasLimit },
+    );
+
+    txHash = receipt.transactionHash;
+    resultingAddress = receipt.contractAddress;
+    if (!resultingAddress) {
+      throw new Error(
+        `No contract address found in receipt: ${JSON.stringify(receipt, (_, val) =>
+          typeof val === 'bigint' ? String(val) : val,
+        )}`,
+      );
+    }
+  }
+
+  return { address: EthAddress.fromString(resultingAddress!), txHash, deployedLibraries, existed };
+}
+
+export function getExpectedAddress(
+  abi: Narrow<Abi | readonly unknown[]>,
+  bytecode: Hex,
+  args: readonly unknown[],
+  salt: Hex,
+) {
+  const paddedSalt = padHex(salt, { size: 32 });
+  const calldata = encodeDeployData({ abi, bytecode, args });
+  const address = getContractAddress({
+    from: DEPLOYER_ADDRESS,
+    salt: paddedSalt,
+    bytecode: calldata,
+    opcode: 'CREATE2',
+  });
+  return {
+    address,
+    paddedSalt,
+    calldata,
+  };
+}
+
+export const deployUpgradePayload = async (
+  deployer: L1Deployer,
+  addresses: { registryAddress: EthAddress; rollupAddress: EthAddress },
+) => {
+  const payloadAddress = (
+    await deployer.deploy(RegisterNewRollupVersionPayloadArtifact, [
+      addresses.registryAddress.toString(),
+      addresses.rollupAddress.toString(),
+    ])
+  ).address;
+
+  return payloadAddress;
+};

package/src/forwarder_proxy.ts

@@ -0,0 +1,108 @@
+/* eslint-disable no-console */
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+
+import { type Hex, extractChain } from 'viem';
+import { anvil, mainnet, sepolia } from 'viem/chains';
+
+import { L1Deployer } from './deploy_l1_contract.js';
+import type { ExtendedViemWalletClient } from './types.js';
+
+export const FORWARDER_SOLIDITY_SOURCE = `
+contract ForwarderProxy {
+  function forward(address target, bytes calldata data) external payable returns (bytes memory) {
+    (bool success, bytes memory result) = target.call{value: msg.value}(data);
+    require(success, "call failed");
+    return result;
+  }
+}`;
+
+export const FORWARDER_ABI = [
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'target',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes',
+        name: 'data',
+        type: 'bytes',
+      },
+    ],
+    name: 'forward',
+    outputs: [
+      {
+        internalType: 'bytes',
+        name: '',
+        type: 'bytes',
+      },
+    ],
+    stateMutability: 'payable',
+    type: 'function',
+  },
+] as const;
+
+export const FORWARDER_BYTECODE =
+  '0x6080604052348015600e575f5ffd5b506103bf8061001c5f395ff3fe60806040526004361061001d575f3560e01c80636fadcf7214610021575b5f5ffd5b61003b600480360381019061003691906101d0565b610051565b604051610048919061029d565b60405180910390f35b60605f5f8573ffffffffffffffffffffffffffffffffffffffff1634868660405161007d9291906102f9565b5f6040518083038185875af1925050503d805f81146100b7576040519150601f19603f3d011682016040523d82523d5f602084013e6100bc565b606091505b509150915081610101576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100f89061036b565b60405180910390fd5b80925050509392505050565b5f5ffd5b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61013e82610115565b9050919050565b61014e81610134565b8114610158575f5ffd5b50565b5f8135905061016981610145565b92915050565b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83601f8401126101905761018f61016f565b5b8235905067ffffffffffffffff8111156101ad576101ac610173565b5b6020830191508360018202830111156101c9576101c8610177565b5b9250929050565b5f5f5f604084860312156101e7576101e661010d565b5b5f6101f48682870161015b565b935050602084013567ffffffffffffffff81111561021557610214610111565b5b6102218682870161017b565b92509250509250925092565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f61026f8261022d565b6102798185610237565b9350610289818560208601610247565b61029281610255565b840191505092915050565b5f6020820190508181035f8301526102b58184610265565b905092915050565b5f81905092915050565b828183375f83830152505050565b5f6102e083856102bd565b93506102ed8385846102c7565b82840190509392505050565b5f6103058284866102d5565b91508190509392505050565b5f82825260208201905092915050565b7f63616c6c206661696c65640000000000000000000000000000000000000000005f82015250565b5f610355600b83610311565b915061036082610321565b602082019050919050565b5f6020820190508181035f83015261038281610349565b905091905056fea26469706673582212209a1c8cf638cf1569450a731ef9457b862f9e153b0a46e5555429bcf4dffd999564736f6c634300081e0033' as Hex;
+
+const FORWARDER_ARTIFACT = {
+  name: 'Forwarder',
+  contractAbi: FORWARDER_ABI,
+  contractBytecode: FORWARDER_BYTECODE,
+};
+
+/**
+ * Deploys the forwarder proxy contract to L1.
+ * @param client - The L1 client to use for deployment
+ * @param logger - Optional logger
+ * @returns The deployed forwarder contract address
+ */
+export async function deployForwarderProxy(client: ExtendedViemWalletClient, logger?: Logger): Promise<EthAddress> {
+  const log = logger ?? createLogger('ethereum:forwarder');
+  const nonce = await client.getTransactionCount({ address: client.account.address });
+  const deployer = new L1Deployer(client, nonce, new DateProvider(), false, log, undefined, false);
+
+  log.info('Deploying forwarder proxy contract');
+  const deployment = await deployer.deploy(FORWARDER_ARTIFACT, []);
+  log.info(`Forwarder proxy deployed at ${deployment.address.toString()}`);
+
+  return deployment.address;
+}
+
+/**
+ * Main function for deploying the forwarder proxy from command line.
+ * Usage: node forwarder_proxy.js <private_key> <rpc_url>
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 3) {
+    console.error('Usage: node forwarder_proxy.js <private_key> <rpc_url> <chain_id>');
+    process.exit(1);
+  }
+
+  const [privateKey, rpcUrl, chainId] = args;
+
+  // Dynamic import to avoid pulling in dependencies at module load time
+  const { createExtendedL1Client } = await import('./client.js');
+
+  const client = createExtendedL1Client(
+    [rpcUrl],
+    privateKey.startsWith('0x') ? privateKey : `0x${privateKey}`,
+    extractChain({ chains: [mainnet, sepolia, anvil], id: parseInt(chainId) as any }),
+  );
+  const address = await deployForwarderProxy(client);
+
+  console.log(`Forwarder proxy deployed at: ${address.toString()}`);
+}
+
+// Only run main if this is the entry point
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(err => {
+    console.error('Failed to deploy forwarder proxy:', err);
+    process.exit(1);
+  });
+}

package/src/l1_artifacts.ts

@@ -1,6 +1,8 @@
 import {
   CoinIssuerAbi,
   CoinIssuerBytecode,
+  DateGatedRelayerAbi,
+  DateGatedRelayerBytecode,
   EmpireSlasherDeploymentExtLibAbi,
   EmpireSlasherDeploymentExtLibBytecode,
   EmpireSlashingProposerAbi,
@@ -31,10 +33,10 @@ import {
   RegisterNewRollupVersionPayloadBytecode,
   RegistryAbi,
   RegistryBytecode,
-  RewardDeploymentExtLibAbi,
-  RewardDeploymentExtLibBytecode,
   RewardDistributorAbi,
   RewardDistributorBytecode,
+  RewardExtLibAbi,
+  RewardExtLibBytecode,
   RollupAbi,
   RollupBytecode,
   RollupLinkReferences,
@@ -100,10 +102,10 @@ export const RollupArtifact = {
         contractAbi: ValidatorOperationsExtLibAbi,
         contractBytecode: ValidatorOperationsExtLibBytecode as Hex,
       },
-      RewardDeploymentExtLib: {
-        name: 'RewardDeploymentExtLib',
-        contractAbi: RewardDeploymentExtLibAbi,
-        contractBytecode: RewardDeploymentExtLibBytecode as Hex,
+      RewardExtLib: {
+        name: 'RewardExtLib',
+        contractAbi: RewardExtLibAbi,
+        contractBytecode: RewardExtLibBytecode as Hex,
       },
       TallySlasherDeploymentExtLib: {
         name: 'TallySlasherDeploymentExtLib',
@@ -149,6 +151,12 @@ export const CoinIssuerArtifact = {
   contractBytecode: CoinIssuerBytecode as Hex,
 };
 
+export const DateGatedRelayerArtifact = {
+  name: 'DateGatedRelayer',
+  contractAbi: DateGatedRelayerAbi,
+  contractBytecode: DateGatedRelayerBytecode as Hex,
+};
+
 export const GovernanceProposerArtifact = {
   name: 'GovernanceProposer',
   contractAbi: GovernanceProposerAbi,

package/src/l1_contract_addresses.ts

@@ -1,6 +1,6 @@
 import type { ConfigMappingsType } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
@@ -32,31 +32,35 @@ export type L1ContractAddresses = {
   stakingAssetHandlerAddress?: EthAddress | undefined;
   zkPassportVerifierAddress?: EthAddress | undefined;
   gseAddress?: EthAddress | undefined;
+  dateGatedRelayerAddress?: EthAddress | undefined;
 };
 
-export const L1ContractAddressesSchema = z.object({
-  rollupAddress: schemas.EthAddress,
-  registryAddress: schemas.EthAddress,
-  inboxAddress: schemas.EthAddress,
-  outboxAddress: schemas.EthAddress,
-  feeJuiceAddress: schemas.EthAddress,
-  stakingAssetAddress: schemas.EthAddress,
-  feeJuicePortalAddress: schemas.EthAddress,
-  coinIssuerAddress: schemas.EthAddress,
-  rewardDistributorAddress: schemas.EthAddress,
-  governanceProposerAddress: schemas.EthAddress,
-  governanceAddress: schemas.EthAddress,
-  slashFactoryAddress: schemas.EthAddress.optional(),
-  feeAssetHandlerAddress: schemas.EthAddress.optional(),
-  stakingAssetHandlerAddress: schemas.EthAddress.optional(),
-  zkPassportVerifierAddress: schemas.EthAddress.optional(),
-  gseAddress: schemas.EthAddress.optional(),
-}) satisfies ZodFor<L1ContractAddresses>;
+export const L1ContractAddressesSchema = zodFor<L1ContractAddresses>()(
+  z.object({
+    rollupAddress: schemas.EthAddress,
+    registryAddress: schemas.EthAddress,
+    inboxAddress: schemas.EthAddress,
+    outboxAddress: schemas.EthAddress,
+    feeJuiceAddress: schemas.EthAddress,
+    stakingAssetAddress: schemas.EthAddress,
+    feeJuicePortalAddress: schemas.EthAddress,
+    coinIssuerAddress: schemas.EthAddress,
+    rewardDistributorAddress: schemas.EthAddress,
+    governanceProposerAddress: schemas.EthAddress,
+    governanceAddress: schemas.EthAddress,
+    slashFactoryAddress: schemas.EthAddress.optional(),
+    feeAssetHandlerAddress: schemas.EthAddress.optional(),
+    stakingAssetHandlerAddress: schemas.EthAddress.optional(),
+    zkPassportVerifierAddress: schemas.EthAddress.optional(),
+    gseAddress: schemas.EthAddress.optional(),
+    dateGatedRelayerAddress: schemas.EthAddress.optional(),
+  }),
+);
 
 const parseEnv = (val: string) => EthAddress.fromString(val);
 
 export const l1ContractAddressesMapping: ConfigMappingsType<
-  Omit<L1ContractAddresses, 'gseAddress' | 'zkPassportVerifierAddress'>
+  Omit<L1ContractAddresses, 'gseAddress' | 'zkPassportVerifierAddress' | 'dateGatedRelayerAddress'>
 > = {
   registryAddress: {
     env: 'REGISTRY_CONTRACT_ADDRESS',

package/src/l1_reader.ts

@@ -4,8 +4,10 @@ import { type L1ContractAddresses, l1ContractAddressesMapping } from './l1_contr
 
 /** Configuration of the L1GlobalReader. */
 export interface L1ReaderConfig {
-  /** The RPC Url of the ethereum host. */
+  /** List of URLs of Ethereum RPC nodes that services will connect to (comma separated). */
   l1RpcUrls: string[];
+  /** The RPC Url of the ethereum debug host for trace and debug methods. */
+  l1DebugRpcUrls: string[];
   /** The chain ID of the ethereum host. */
   l1ChainId: number;
   /** The deployed l1 contract addresses */
@@ -26,7 +28,13 @@ export const l1ReaderConfigMappings: ConfigMappingsType<L1ReaderConfig> = {
   },
   l1RpcUrls: {
     env: 'ETHEREUM_HOSTS',
-    description: 'The RPC Url of the ethereum host.',
+    description: 'List of URLs of Ethereum RPC nodes that services will connect to (comma separated).',
+    parseEnv: (val: string) => val.split(',').map(url => url.trim()),
+    defaultValue: [],
+  },
+  l1DebugRpcUrls: {
+    env: 'ETHEREUM_DEBUG_HOSTS',
+    description: 'The RPC Url of the ethereum debug host for trace and debug methods.',
     parseEnv: (val: string) => val.split(',').map(url => url.trim()),
     defaultValue: [],
   },