@aztec/ethereum 3.0.0-devnet.2 → 3.0.0-devnet.20251212

package/src/contracts/tally_slashing_proposer.ts

@@ -1,4 +1,7 @@
-import { type L1TxRequest, type ViemClient, tryExtractEvent } from '@aztec/ethereum';
+import type { L1TxRequest } from '@aztec/ethereum/l1-tx-utils';
+import type { ViemClient } from '@aztec/ethereum/types';
+import { tryExtractEvent } from '@aztec/ethereum/utils';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
@@ -97,8 +100,8 @@ export class TallySlashingProposerContract {
    * @param slot - The slot number to check at
    * @returns Whether the round is ready to execute
    */
-  public async isRoundReadyToExecute(round: bigint, slot: bigint): Promise<boolean> {
-    return await this.contract.read.isRoundReadyToExecute([round, slot]);
+  public async isRoundReadyToExecute(round: bigint, slot: SlotNumber): Promise<boolean> {
+    return await this.contract.read.isRoundReadyToExecute([round, BigInt(slot)]);
   }
 
   /** Returns the slash actions and payload address for a given round (zero if no slash actions) */
@@ -149,7 +152,7 @@ export class TallySlashingProposerContract {
    */
   public async buildVoteRequestFromSigner(
     votes: Hex,
-    slot: bigint,
+    slot: SlotNumber,
     signer: (msg: TypedDataDefinition) => Promise<Hex>,
   ): Promise<L1TxRequest> {
     const typedData = this.buildVoteTypedData(votes, slot);
@@ -166,7 +169,7 @@ export class TallySlashingProposerContract {
   }
 
   /** Returns the typed data definition to EIP712-sign for voting */
-  public buildVoteTypedData(votes: Hex, slot: bigint): TypedDataDefinition {
+  public buildVoteTypedData(votes: Hex, slot: SlotNumber): TypedDataDefinition {
     const domain = {
       name: 'TallySlashingProposer',
       version: '1',
@@ -187,12 +190,12 @@ export class TallySlashingProposerContract {
       ],
     };
 
-    return { domain, types, primaryType: 'Vote', message: { votes, slot } };
+    return { domain, types, primaryType: 'Vote', message: { votes, slot: BigInt(slot) } };
   }
 
   /** Gets the digest to sign for voting directly from the contract */
-  public async getVoteDataDigest(votes: Hex, slot: bigint): Promise<Buffer32> {
-    return Buffer32.fromString(await this.contract.read.getVoteSignatureDigest([votes, slot]));
+  public async getVoteDataDigest(votes: Hex, slot: SlotNumber): Promise<Buffer32> {
+    return Buffer32.fromString(await this.contract.read.getVoteSignatureDigest([votes, BigInt(slot)]));
   }
 
   /**

package/src/deploy_l1_contracts.ts

@@ -1,15 +1,16 @@
 import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { SecretValue, getActiveNetworkName } from '@aztec/foundation/config';
-import { keccak256String } from '@aztec/foundation/crypto';
+import { keccak256String } from '@aztec/foundation/crypto/keccak';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
 import type { Abi, Narrow } from 'abitype';
-import { mkdir, writeFile } from 'fs/promises';
+import fs from 'fs';
 import chunk from 'lodash.chunk';
 import {
   type Chain,
@@ -276,6 +277,25 @@ export const deploySharedContracts = async (
     feeAssetAddress = deployedFee.address;
     logger.verbose(`Deployed Fee Asset at ${feeAssetAddress}`);
 
+    // Mint a tiny bit of tokens to satisfy coin-issuer constraints
+    const { txHash } = await deployer.sendTransaction(
+      {
+        to: feeAssetAddress.toString(),
+        data: encodeFunctionData({
+          abi: FeeAssetArtifact.contractAbi,
+          functionName: 'mint',
+          args: [l1Client.account.address, 1n * 10n ** 18n],
+        }),
+      },
+      {
+        // contract may not have been deployed yet (CREATE2 returns address before mining),
+        // which causes gas estimation to fail. Hardcode to 100k which is plenty for ERC20 mint.
+        gasLimit: 100_000n,
+      },
+    );
+    await l1Client.waitForTransactionReceipt({ hash: txHash });
+    logger.verbose(`Minted tiny bit of tokens to satisfy coin-issuer constraints in ${txHash}`);
+
     const deployedStaking = await deployer.deploy(StakingAssetArtifact, ['Staking', 'STK', l1Client.account.address]);
     stakingAssetAddress = deployedStaking.address;
     logger.verbose(`Deployed Staking Asset at ${stakingAssetAddress}`);
@@ -351,12 +371,19 @@ export const deploySharedContracts = async (
     txHashes.push(txHash);
   }
 
+  logger.verbose(`Waiting for deployments to complete`);
+  await deployer.waitForDeployments();
+
   const coinIssuerAddress = (
-    await deployer.deploy(CoinIssuerArtifact, [
-      feeAssetAddress.toString(),
-      2n * 10n ** 17n, // hard cap of 20% per year
-      l1Client.account.address,
-    ])
+    await deployer.deploy(
+      CoinIssuerArtifact,
+      [
+        feeAssetAddress.toString(),
+        2n * 10n ** 17n, // hard cap of 20% per year
+        l1Client.account.address,
+      ],
+      { gasLimit: 1_000_000n, noSimulation: true },
+    )
   ).address;
   logger.verbose(`Deployed CoinIssuer at ${coinIssuerAddress}`);
 
@@ -375,17 +402,16 @@ export const deploySharedContracts = async (
     /*                          CHEAT CODES START HERE                            */
     /* -------------------------------------------------------------------------- */
 
-    feeAssetHandlerAddress = (
-      await deployer.deploy(FeeAssetHandlerArtifact, [
-        l1Client.account.address,
-        feeAssetAddress.toString(),
-        BigInt(1000n * 10n ** 18n),
-      ])
-    ).address;
+    const deployedFeeAssetHandler = await deployer.deploy(FeeAssetHandlerArtifact, [
+      l1Client.account.address,
+      feeAssetAddress.toString(),
+      BigInt(1000n * 10n ** 18n),
+    ]);
+    feeAssetHandlerAddress = deployedFeeAssetHandler.address;
     logger.verbose(`Deployed FeeAssetHandler at ${feeAssetHandlerAddress}`);
 
-    // Only if we are "fresh" will we be adding as a minter, otherwise above will simply get same address
-    if (needToSetGovernance) {
+    // Only add as minter if this is a new deployment (not reusing existing handler from failed previous run)
+    if (!deployedFeeAssetHandler.existed) {
       const { txHash } = await deployer.sendTransaction({
         to: feeAssetAddress.toString(),
         data: encodeFunctionData({
@@ -462,9 +488,9 @@ export const deploySharedContracts = async (
   const rewardDistributorAddress = await registry.getRewardDistributor();
 
   if (!args.existingTokenAddress) {
-    const blockReward = getRewardConfig(networkName).blockReward;
+    const checkpointReward = getRewardConfig(networkName).checkpointReward;
 
-    const funding = blockReward * 200000n;
+    const funding = checkpointReward * 200000n;
     const { txHash: fundRewardDistributorTxHash } = await deployer.sendTransaction({
       to: feeAssetAddress.toString(),
       data: encodeFunctionData({
@@ -693,7 +719,7 @@ async function writeVerificationJson(
     const date = new Date();
     const formattedDate = date.toISOString().slice(2, 19).replace(/[-T:]/g, '');
     // Ensure the verification output directory exists
-    await mkdir(outputDirectory, { recursive: true });
+    await fs.promises.mkdir(outputDirectory, { recursive: true });
     const suffix = filenameSuffix ? `-${filenameSuffix}` : '';
     const verificationOutputPath = `${outputDirectory}/l1-verify${suffix}-${chainId}-${formattedDate.slice(0, 6)}-${formattedDate.slice(6)}.json`;
     const networkName = getActiveNetworkName();
@@ -702,7 +728,7 @@ async function writeVerificationJson(
       network: networkName,
       records: deployer.verificationRecords,
     };
-    await writeFile(verificationOutputPath, JSON.stringify(verificationData, null, 2));
+    await fs.promises.writeFile(verificationOutputPath, JSON.stringify(verificationData, null, 2));
     logger.info(`Wrote L1 verification data to ${verificationOutputPath}`);
   } catch (e) {
     logger.warn(`Failed to write L1 verification data file: ${String(e)}`);
@@ -838,7 +864,8 @@ export const deployRollup = async (
     aztecSlotDuration: BigInt(args.aztecSlotDuration),
     aztecEpochDuration: BigInt(args.aztecEpochDuration),
     targetCommitteeSize: BigInt(args.aztecTargetCommitteeSize),
-    lagInEpochs: BigInt(args.lagInEpochs),
+    lagInEpochsForValidatorSet: BigInt(args.lagInEpochsForValidatorSet),
+    lagInEpochsForRandao: BigInt(args.lagInEpochsForRandao),
     aztecProofSubmissionEpochs: BigInt(args.aztecProofSubmissionEpochs),
     slashingQuorum: BigInt(args.slashingQuorum ?? (args.slashingRoundSizeInEpochs * args.aztecEpochDuration) / 2 + 1),
     slashingRoundSize: BigInt(args.slashingRoundSizeInEpochs * args.aztecEpochDuration),
@@ -1493,13 +1520,13 @@ export const deployL1Contracts = async (
       // Need to get the time
       const currentSlot = await rollup.getSlotNumber();
 
-      if (BigInt(currentSlot) === 0n) {
-        const ts = Number(await rollup.getTimestampForSlot(1n));
+      if (currentSlot === 0) {
+        const ts = Number(await rollup.getTimestampForSlot(SlotNumber(1)));
         await rpcCall('evm_setNextBlockTimestamp', [ts]);
         await rpcCall('hardhat_mine', [1]);
         const currentSlot = await rollup.getSlotNumber();
 
-        if (BigInt(currentSlot) !== 1n) {
+        if (currentSlot !== 1) {
           throw new Error(`Error jumping time: current slot is ${currentSlot}`);
         }
         logger.info(`Jumped to slot 1`);
@@ -1550,7 +1577,7 @@ export class L1Deployer {
   async deploy<const TAbi extends Abi>(
     params: ContractArtifacts<TAbi>,
     args?: ContractConstructorArgs<TAbi>,
-    opts: { gasLimit?: bigint } = {},
+    opts: { gasLimit?: bigint; noSimulation?: boolean } = {},
   ): Promise<{ address: EthAddress; existed: boolean }> {
     this.logger.debug(`Deploying ${params.name} contract`, { args });
     try {
@@ -1566,6 +1593,7 @@ export class L1Deployer {
           l1TxUtils: this.l1TxUtils,
           acceleratedTestDeployments: this.acceleratedTestDeployments,
           gasLimit: opts.gasLimit,
+          noSimulation: opts.noSimulation,
         },
       );
       if (txHash) {
@@ -1655,6 +1683,7 @@ export async function deployL1Contract(
     l1TxUtils?: L1TxUtils;
     gasLimit?: bigint;
     acceleratedTestDeployments?: boolean;
+    noSimulation?: boolean;
   } = {},
 ): Promise<{
   address: EthAddress;
@@ -1666,7 +1695,7 @@ export async function deployL1Contract(
   let resultingAddress: Hex | null | undefined = undefined;
   const deployedLibraries: VerificationLibraryEntry[] = [];
 
-  const { salt: saltFromOpts, libraries, logger, gasLimit, acceleratedTestDeployments } = opts;
+  const { salt: saltFromOpts, libraries, logger, gasLimit, acceleratedTestDeployments, noSimulation } = opts;
   let { l1TxUtils } = opts;
 
   if (!l1TxUtils) {
@@ -1775,11 +1804,13 @@ export async function deployL1Contract(
     resultingAddress = address;
     const existing = await extendedClient.getCode({ address: resultingAddress });
     if (existing === undefined || existing === '0x') {
-      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 });
+      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]) },

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_contracts.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_reader.ts

@@ -6,6 +6,8 @@ import { type L1ContractAddresses, l1ContractAddressesMapping } from './l1_contr
 export interface L1ReaderConfig {
   /** 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 */
@@ -30,6 +32,12 @@ export const l1ReaderConfigMappings: ConfigMappingsType<L1ReaderConfig> = {
     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: [],
+  },
   viemPollingIntervalMS: {
     env: 'L1_READER_VIEM_POLLING_INTERVAL_MS',
     description: 'The polling interval viem uses in ms',

package/src/l1_tx_utils/config.ts

@@ -1,7 +1,7 @@
 import {
   type ConfigMappingsType,
-  bigintConfigHelper,
   booleanConfigHelper,
+  floatConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
@@ -15,11 +15,11 @@ export interface L1TxUtilsConfig {
   /**
    * Maximum gas price in gwei
    */
-  maxGwei?: bigint;
+  maxGwei?: number;
   /**
    * Maximum blob fee per gas in gwei
    */
-  maxBlobGwei?: bigint;
+  maxBlobGwei?: number;
   /**
    * Priority fee bump percentage
    */
@@ -29,9 +29,9 @@ export interface L1TxUtilsConfig {
    */
   priorityFeeRetryBumpPercentage?: number;
   /**
-   * Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage config
+   * Minimum priority fee per gas in Gwei. Acts as a floor for the computed priority fee.
    */
-  fixedPriorityFeePerGas?: number;
+  minimumPriorityFeePerGas?: number;
   /**
    * Maximum number of speed-up attempts
    */
@@ -69,14 +69,16 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
     ...numberConfigHelper(20),
   },
   maxGwei: {
-    description: 'Maximum gas price in gwei',
+    description: 'Maximum gas price in gwei to be used for transactions.',
     env: 'L1_GAS_PRICE_MAX',
-    ...bigintConfigHelper(500n),
+    fallback: ['L1_FEE_PER_GAS_GWEI_MAX'],
+    ...floatConfigHelper(2000),
   },
   maxBlobGwei: {
     description: 'Maximum blob fee per gas in gwei',
     env: 'L1_BLOB_FEE_PER_GAS_MAX',
-    ...bigintConfigHelper(1_500n),
+    fallback: ['L1_BLOB_FEE_PER_GAS_GWEI_MAX'],
+    ...floatConfigHelper(3000),
   },
   priorityFeeBumpPercentage: {
     description: 'How much to increase priority fee by each attempt (percentage)',
@@ -88,10 +90,22 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
     env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
     ...numberConfigHelper(50),
   },
-  fixedPriorityFeePerGas: {
-    description: 'Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage',
-    env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
-    ...numberConfigHelper(0),
+  minimumPriorityFeePerGas: {
+    description:
+      'Minimum priority fee per gas in Gwei. Acts as a floor for the computed priority fee. If network conditions require a higher fee, the higher fee will be used.',
+    env: 'L1_MINIMUM_PRIORITY_FEE_PER_GAS_GWEI',
+    fallback: ['L1_FIXED_PRIORITY_FEE_PER_GAS', 'L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI'],
+    deprecatedFallback: [
+      {
+        env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
+        message: deprecatedFixedFeeMessage('L1_FIXED_PRIORITY_FEE_PER_GAS'),
+      },
+      {
+        env: 'L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI',
+        message: deprecatedFixedFeeMessage('L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI'),
+      },
+    ],
+    ...floatConfigHelper(0),
   },
   maxSpeedUpAttempts: {
     description: 'Maximum number of speed-up attempts',
@@ -106,7 +120,7 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   stallTimeMs: {
     description: 'How long before considering tx stalled',
     env: 'L1_TX_MONITOR_STALL_TIME_MS',
-    ...numberConfigHelper(24_000), // 24s, 2 ethereum slots
+    ...numberConfigHelper(12_000), // 12s, 1 ethereum slot
   },
   txTimeoutMs: {
     description: 'How long to wait for a tx to be mined before giving up. Set to 0 to disable.',
@@ -138,3 +152,10 @@ export const defaultL1TxUtilsConfig = getDefaultConfig<L1TxUtilsConfig>(
 export function getL1TxUtilsConfigEnvVars(): L1TxUtilsConfig {
   return getConfigFromMappings(l1TxUtilsConfigMappings);
 }
+
+function deprecatedFixedFeeMessage(envVar: string): string {
+  return (
+    `Environment variable ${envVar} is deprecated. It is now used as a MINIMUM priority fee rather than a fixed value. ` +
+    'Please use L1_MINIMUM_PRIORITY_FEE_PER_GAS_GWEI instead. If network conditions require a higher fee, the higher fee will be used.'
+  );
+}

package/src/l1_tx_utils/forwarder_l1_tx_utils.ts

@@ -0,0 +1,119 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
+
+import { type Hex, encodeFunctionData } from 'viem';
+
+import type { EthSigner } from '../eth-signer/eth-signer.js';
+import { FORWARDER_ABI } from '../forwarder_proxy.js';
+import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
+import type { L1TxUtilsConfig } from './config.js';
+import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
+import { L1TxUtilsWithBlobs } from './l1_tx_utils_with_blobs.js';
+import { createViemSigner } from './signer.js';
+import type { L1BlobInputs, L1TxConfig, L1TxRequest, SigningCallback } from './types.js';
+
+/**
+ * Extends L1TxUtilsWithBlobs to wrap all transactions through a forwarder contract.
+ * This is mainly used for testing the archiver's ability to decode transactions that go through proxies.
+ */
+export class ForwarderL1TxUtils extends L1TxUtilsWithBlobs {
+  constructor(
+    client: ViemClient | ExtendedViemWalletClient,
+    senderAddress: EthAddress,
+    signingCallback: SigningCallback,
+    logger: Logger | undefined,
+    dateProvider: DateProvider | undefined,
+    config: Partial<L1TxUtilsConfig>,
+    debugMaxGasLimit: boolean,
+    store: IL1TxStore | undefined,
+    metrics: IL1TxMetrics | undefined,
+    private readonly forwarderAddress: EthAddress,
+  ) {
+    super(client, senderAddress, signingCallback, logger, dateProvider, config, debugMaxGasLimit, store, metrics);
+  }
+
+  /**
+   * Wraps the transaction request in a call to the forwarder contract.
+   */
+  private wrapInForwarder(request: L1TxRequest): L1TxRequest {
+    const forwarderCalldata = encodeFunctionData({
+      abi: FORWARDER_ABI,
+      functionName: 'forward',
+      args: [request.to as Hex, request.data as Hex],
+    });
+
+    return {
+      to: this.forwarderAddress.toString() as Hex,
+      data: forwarderCalldata,
+      value: request.value,
+      abi: request.abi, // Preserve the original ABI for error decoding
+    };
+  }
+
+  /**
+   * Override sendAndMonitorTransaction to wrap the request in a forwarder call.
+   */
+  public override sendAndMonitorTransaction(request: L1TxRequest, gasConfig?: L1TxConfig, blobInputs?: L1BlobInputs) {
+    this.logger.debug(`Wrapping transaction to ${request.to} in forwarder at ${this.forwarderAddress.toString()}`);
+    const wrappedRequest = this.wrapInForwarder(request);
+    return super.sendAndMonitorTransaction(wrappedRequest, gasConfig, blobInputs);
+  }
+}
+
+export function createForwarderL1TxUtilsFromViemWallet(
+  client: ExtendedViemWalletClient,
+  forwarderAddress: EthAddress,
+  deps: {
+    logger?: Logger;
+    dateProvider?: DateProvider;
+    store?: IL1TxStore;
+    metrics?: IL1TxMetrics;
+  } = {},
+  config: Partial<L1TxUtilsConfig> = {},
+  debugMaxGasLimit: boolean = false,
+) {
+  return new ForwarderL1TxUtils(
+    client,
+    EthAddress.fromString(client.account.address),
+    createViemSigner(client),
+    deps.logger,
+    deps.dateProvider,
+    config,
+    debugMaxGasLimit,
+    deps.store,
+    deps.metrics,
+    forwarderAddress,
+  );
+}
+
+export function createForwarderL1TxUtilsFromEthSigner(
+  client: ViemClient,
+  signer: EthSigner,
+  forwarderAddress: EthAddress,
+  deps: {
+    logger?: Logger;
+    dateProvider?: DateProvider;
+    store?: IL1TxStore;
+    metrics?: IL1TxMetrics;
+  } = {},
+  config: Partial<L1TxUtilsConfig> = {},
+  debugMaxGasLimit: boolean = false,
+) {
+  const callback: SigningCallback = async (transaction, _signingAddress) => {
+    return (await signer.signTransaction(transaction)).toViemTransactionSignature();
+  };
+
+  return new ForwarderL1TxUtils(
+    client,
+    signer.address,
+    callback,
+    deps.logger,
+    deps.dateProvider,
+    config,
+    debugMaxGasLimit,
+    deps.store,
+    deps.metrics,
+    forwarderAddress,
+  );
+}

package/src/l1_tx_utils/index-blobs.ts

@@ -0,0 +1,2 @@
+export * from './forwarder_l1_tx_utils.js';
+export * from './l1_tx_utils_with_blobs.js';

package/src/l1_tx_utils/interfaces.ts

@@ -46,7 +46,7 @@ export interface IL1TxStore {
    * @param account - The sender account address
    * @param stateId - The state ID to delete
    */
-  deleteState(account: string, stateId: number): Promise<void>;
+  deleteState(account: string, ...stateId: number[]): Promise<void>;
 
   /**
    * Clears all transaction states for a specific account.

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -130,12 +130,32 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       return;
     }
 
-    // Convert loaded states (which have id) to the txs format
-    this.txs = loadedStates;
-    this.logger.info(`Rehydrated ${loadedStates.length} tx states for account ${account}`);
+    // Clean up excess states if we have more than MAX_L1_TX_STATES
+    if (loadedStates.length > MAX_L1_TX_STATES) {
+      this.logger.warn(
+        `Found ${loadedStates.length} tx states for account ${account}, pruning to most recent ${MAX_L1_TX_STATES}`,
+      );
+
+      // Keep only the most recent MAX_L1_TX_STATES
+      const statesToKeep = loadedStates.slice(-MAX_L1_TX_STATES);
+      const statesToDelete = loadedStates.slice(0, -MAX_L1_TX_STATES);
+
+      // Batch delete old states in a transaction for efficiency
+      const idsToDelete = statesToDelete.map(s => s.id);
+      await this.store.deleteState(account, ...idsToDelete);
+
+      this.txs = statesToKeep;
+      this.logger.info(
+        `Cleaned up ${statesToDelete.length} old tx states, kept ${statesToKeep.length} for account ${account}`,
+      );
+    } else {
+      // Convert loaded states (which have id) to the txs format
+      this.txs = loadedStates;
+      this.logger.info(`Rehydrated ${loadedStates.length} tx states for account ${account}`);
+    }
 
     // Find all pending states and resume monitoring
-    const pendingStates = loadedStates.filter(state => !TerminalTxUtilsState.includes(state.status));
+    const pendingStates = this.txs.filter(state => !TerminalTxUtilsState.includes(state.status));
     if (pendingStates.length === 0) {
       return;
     }