@aztec/ethereum 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

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/generated/l1-contracts-defaults.ts

@@ -0,0 +1,32 @@
+// Auto-generated from spartan/environments/network-defaults.yml
+// Do not edit manually - run yarn generate to regenerate
+
+/** Default L1 contracts configuration values from network-defaults.yml */
+export const l1ContractsDefaultEnv = {
+  ETHEREUM_SLOT_DURATION: 12,
+  AZTEC_SLOT_DURATION: 36,
+  AZTEC_EPOCH_DURATION: 32,
+  AZTEC_TARGET_COMMITTEE_SIZE: 48,
+  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
+  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
+  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
+  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
+  AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
+  AZTEC_EXIT_DELAY_SECONDS: 172800,
+  AZTEC_INBOX_LAG: 1,
+  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_MANA_TARGET: 100000000,
+  AZTEC_PROVING_COST_PER_MANA: 100,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
+  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
+  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+  AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
+  AZTEC_SLASHING_DISABLE_DURATION: 432000,
+  AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
+  AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
+  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300,
+} as const;

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';
 
@@ -35,25 +35,27 @@ export type L1ContractAddresses = {
   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(),
-  dateGatedRelayerAddress: 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);
 

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

@@ -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
    */
@@ -90,10 +90,21 @@ 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',
-    fallback: ['L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI'],
+  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: {
@@ -141,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/constants.ts

@@ -16,3 +16,14 @@ export const MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE = 100;
 
 // Avg ethereum block time is ~12s
 export const BLOCK_TIME_MS = 12_000;
+
+// Gas per blob (EIP-4844)
+export const GAS_PER_BLOB = 131072n;
+
+// Blob capacity schedule based on Ethereum upgrades
+export const BLOB_CAPACITY_SCHEDULE = [
+  { timestamp: 1734357600, target: 14, max: 21 }, // BPO2: Dec 17, 2025
+  { timestamp: 1733752800, target: 10, max: 15 }, // BPO1: Dec 9, 2025
+  { timestamp: 1733234400, target: 6, max: 9 }, // Fusaka: Dec 3, 2025
+  { timestamp: 0, target: 6, max: 9 }, // Pectra/earlier
+];

package/src/l1_tx_utils/fee-strategies/index.ts

@@ -0,0 +1,22 @@
+import { P75AllTxsPriorityFeeStrategy } from './p75_competitive.js';
+import { P75BlobTxsOnlyPriorityFeeStrategy } from './p75_competitive_blob_txs_only.js';
+import type { PriorityFeeStrategy } from './types.js';
+
+export {
+  HISTORICAL_BLOCK_COUNT,
+  type PriorityFeeStrategy,
+  type PriorityFeeStrategyContext,
+  type PriorityFeeStrategyResult,
+} from './types.js';
+
+export { P75AllTxsPriorityFeeStrategy } from './p75_competitive.js';
+export { P75BlobTxsOnlyPriorityFeeStrategy } from './p75_competitive_blob_txs_only.js';
+
+/**
+ * Default list of priority fee strategies to analyze.
+ * Add more strategies here for comparison.
+ */
+export const DEFAULT_PRIORITY_FEE_STRATEGIES: PriorityFeeStrategy[] = [
+  P75AllTxsPriorityFeeStrategy,
+  P75BlobTxsOnlyPriorityFeeStrategy,
+];