@aztec/ethereum 0.0.1-commit.24de95ac → 0.0.1-commit.29c6b1a3

package/src/test/eth_cheat_codes.ts

@@ -1,12 +1,13 @@
 import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
-import { keccak256 } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 import { pluralize } from '@aztec/foundation/string';
 import type { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 
-import { type Hex, type Transaction, createPublicClient, fallback, hexToNumber, http } from 'viem';
+import { type Chain, type Hex, type Transaction, createPublicClient, fallback, hexToNumber, http } from 'viem';
+import { foundry } from 'viem/chains';
 
 import type { ViemPublicClient } from '../types.js';
 
@@ -28,9 +29,14 @@ export class EthCheatCodes {
      * The logger to use for the eth cheatcodes
      */
     public logger = createLogger('ethereum:cheat_codes'),
+    /**
+     * The chain configuration provided to Anvil
+     */
+    public chain: Chain = foundry,
   ) {
     this.publicClient = createPublicClient({
-      transport: fallback(this.rpcUrls.map(url => http(url))),
+      transport: fallback(this.rpcUrls.map(url => http(url, { batch: false }))),
+      chain: chain,
     });
   }
 

package/src/test/rollup_cheat_codes.ts

@@ -1,5 +1,7 @@
-import { RollupContract, type ViemPublicClient } from '@aztec/ethereum';
+import { OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
@@ -14,7 +16,6 @@ import {
   hexToBigInt,
   http,
 } from 'viem';
-import { foundry } from 'viem/chains';
 
 import { EthCheatCodes } from './eth_cheat_codes.js';
 
@@ -30,8 +31,8 @@ export class RollupCheatCodes {
     addresses: Pick<L1ContractAddresses, 'rollupAddress'>,
   ) {
     this.client = createPublicClient({
-      chain: foundry,
-      transport: fallback(ethCheatCodes.rpcUrls.map(url => http(url))),
+      chain: ethCheatCodes.chain,
+      transport: fallback(ethCheatCodes.rpcUrls.map(url => http(url, { batch: false }))),
     });
     this.rollup = getContract({
       abi: RollupAbi,
@@ -50,15 +51,24 @@ export class RollupCheatCodes {
   }
 
   /** Returns the current slot */
-  public async getSlot() {
+  public async getSlot(): Promise<SlotNumber> {
     const ts = BigInt((await this.client.getBlock()).timestamp);
-    return await this.rollup.read.getSlotAt([ts]);
+    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([ts]));
+  }
+
+  /** Returns the number of seconds until the start of the given slot based on L1 block timestamp. */
+  public async getSecondsUntilSlot(slot: SlotNumber): Promise<number> {
+    const [currentTimestamp, targetTimestamp] = await Promise.all([
+      this.client.getBlock().then(b => BigInt(b.timestamp)),
+      this.rollup.read.getTimestampForSlot([BigInt(slot)]),
+    ]);
+    return Math.max(0, Number(targetTimestamp - currentTimestamp));
   }
 
   /** Returns the current epoch */
-  public async getEpoch() {
+  public async getEpoch(): Promise<EpochNumber> {
     const slotNumber = await this.getSlot();
-    return await this.rollup.read.getEpochAtSlot([slotNumber]);
+    return EpochNumber.fromBigInt(await this.rollup.read.getEpochAtSlot([BigInt(slotNumber)]));
   }
 
   /**
@@ -66,13 +76,13 @@ export class RollupCheatCodes {
    * @returns The pending and proven chain tips
    */
   public async getTips(): Promise<{
-    /** The pending chain tip */ pending: bigint;
-    /** The proven chain tip */ proven: bigint;
+    /** The pending chain tip */ pending: CheckpointNumber;
+    /** The proven chain tip */ proven: CheckpointNumber;
   }> {
-    const res = await this.rollup.read.getTips();
+    const { pending, proven } = await this.rollup.read.getTips();
     return {
-      pending: res.pendingBlockNumber,
-      proven: res.provenBlockNumber,
+      pending: CheckpointNumber.fromBigInt(pending),
+      proven: CheckpointNumber.fromBigInt(proven),
     };
   }
 
@@ -81,16 +91,16 @@ export class RollupCheatCodes {
    */
   public async debugRollup() {
     const rollup = new RollupContract(this.client, this.rollup.address);
-    const pendingNum = await rollup.getBlockNumber();
-    const provenNum = await rollup.getProvenBlockNumber();
+    const pendingNum = await rollup.getCheckpointNumber();
+    const provenNum = await rollup.getProvenCheckpointNumber();
     const validators = await rollup.getAttesters();
     const committee = await rollup.getCurrentEpochCommittee();
     const archive = await rollup.archive();
     const slot = await this.getSlot();
     const epochNum = await rollup.getEpochNumberForSlotNumber(slot);
 
-    this.logger.info(`Pending block num: ${pendingNum}`);
-    this.logger.info(`Proven block num: ${provenNum}`);
+    this.logger.info(`Pending checkpoint num: ${pendingNum}`);
+    this.logger.info(`Proven checkpoint num: ${provenNum}`);
     this.logger.info(`Validators: ${validators.map(v => v.toString()).join(', ')}`);
     this.logger.info(`Committee: ${committee?.map(v => v.toString()).join(', ')}`);
     this.logger.info(`Archive: ${archive}`);
@@ -101,13 +111,13 @@ export class RollupCheatCodes {
   /** Fetches the epoch and slot duration config from the rollup contract */
   public async getConfig(): Promise<{
     /** Epoch duration */ epochDuration: bigint;
-    /** Slot duration */ slotDuration: bigint;
+    /** Slot duration */ slotDuration: number;
   }> {
     const [epochDuration, slotDuration] = await Promise.all([
       this.rollup.read.getEpochDuration(),
       this.rollup.read.getSlotDuration(),
     ]);
-    return { epochDuration, slotDuration };
+    return { epochDuration, slotDuration: Number(slotDuration) };
   }
 
   /**
@@ -116,18 +126,18 @@ export class RollupCheatCodes {
    * @param opts - Options
    */
   public async advanceToEpoch(
-    epoch: bigint | number,
+    epoch: EpochNumber,
     opts: {
       /** Offset in seconds */
       offset?: number;
     } = {},
   ) {
     const { epochDuration: slotsInEpoch } = await this.getConfig();
-    const timestamp =
-      (await this.rollup.read.getTimestampForSlot([BigInt(epoch) * slotsInEpoch])) + BigInt(opts.offset ?? 0);
+    const slotNumber = SlotNumber(Number(epoch) * Number(slotsInEpoch));
+    const timestamp = (await this.rollup.read.getTimestampForSlot([BigInt(slotNumber)])) + BigInt(opts.offset ?? 0);
     try {
       await this.ethCheatCodes.warp(Number(timestamp), { ...opts, silent: true, resetBlockInterval: true });
-      this.logger.warn(`Warped to epoch ${epoch}`);
+      this.logger.warn(`Warped to epoch ${epoch}`, { offset: opts.offset, timestamp });
     } catch (err) {
       this.logger.warn(`Warp to epoch ${epoch} failed: ${err}`);
     }
@@ -138,8 +148,8 @@ export class RollupCheatCodes {
   public async advanceToNextEpoch() {
     const slot = await this.getSlot();
     const { epochDuration, slotDuration } = await this.getConfig();
-    const slotsUntilNextEpoch = epochDuration - (slot % epochDuration) + 1n;
-    const timeToNextEpoch = slotsUntilNextEpoch * slotDuration;
+    const slotsUntilNextEpoch = epochDuration - (BigInt(slot) % epochDuration) + 1n;
+    const timeToNextEpoch = slotsUntilNextEpoch * BigInt(slotDuration);
     const l1Timestamp = BigInt((await this.client.getBlock()).timestamp);
     await this.ethCheatCodes.warp(Number(l1Timestamp + timeToNextEpoch), {
       silent: true,
@@ -151,10 +161,11 @@ export class RollupCheatCodes {
   /** Warps time in L1 until the beginning of the next slot. */
   public async advanceToNextSlot() {
     const currentSlot = await this.getSlot();
-    const timestamp = await this.rollup.read.getTimestampForSlot([currentSlot + 1n]);
+    const nextSlot = SlotNumber(currentSlot + 1);
+    const timestamp = await this.rollup.read.getTimestampForSlot([BigInt(nextSlot)]);
     await this.ethCheatCodes.warp(Number(timestamp), { silent: true, resetBlockInterval: true });
-    this.logger.warn(`Advanced to slot ${currentSlot + 1n}`);
-    return [timestamp, currentSlot + 1n];
+    this.logger.warn(`Advanced to slot ${nextSlot}`);
+    return [timestamp, nextSlot];
   }
 
   /**
@@ -163,42 +174,42 @@ export class RollupCheatCodes {
    */
   public async advanceSlots(howMany: number) {
     const l1Timestamp = (await this.client.getBlock()).timestamp;
-    const slotDuration = await this.rollup.read.getSlotDuration();
-    const timeToWarp = BigInt(howMany) * slotDuration;
+    const slotDuration = Number(await this.rollup.read.getSlotDuration());
+    const timeToWarp = BigInt(howMany) * BigInt(slotDuration);
     await this.ethCheatCodes.warp(l1Timestamp + timeToWarp, { silent: true, resetBlockInterval: true });
     const [slot, epoch] = await Promise.all([this.getSlot(), this.getEpoch()]);
     this.logger.warn(`Advanced ${howMany} slots up to slot ${slot} in epoch ${epoch}`);
   }
 
   /**
-   * Marks the specified block (or latest if none) as proven
-   * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
+   * Marks the specified checkpoint (or latest if none) as proven
+   * @param maybeCheckpointNumber - The checkpoint number to mark as proven (defaults to latest pending)
    */
-  public markAsProven(maybeBlockNumber?: number | bigint) {
+  public markAsProven(maybeCheckpointNumber?: CheckpointNumber) {
     return this.ethCheatCodes.execWithPausedAnvil(async () => {
       const tipsBefore = await this.getTips();
       const { pending, proven } = tipsBefore;
 
-      let blockNumber = maybeBlockNumber;
-      if (blockNumber === undefined || blockNumber > pending) {
-        blockNumber = pending;
+      let checkpointNumber = maybeCheckpointNumber;
+      if (checkpointNumber === undefined || checkpointNumber > pending) {
+        checkpointNumber = pending;
       }
-      if (blockNumber <= proven) {
-        this.logger.debug(`Block ${blockNumber} is already proven`);
+      if (checkpointNumber <= proven) {
+        this.logger.debug(`Checkpoint ${checkpointNumber} is already proven`);
         return;
       }
 
       // @note @LHerskind this is heavily dependent on the storage layout and size of values
       // The rollupStore is a struct and if the size of elements or the struct changes, this can break
-      const provenBlockNumberSlot = hexToBigInt(RollupContract.stfStorageSlot);
+      const provenCheckpointNumberSlot = hexToBigInt(RollupContract.stfStorageSlot);
 
       // Need to pack it as a single 32 byte word
-      const newValue = (BigInt(tipsBefore.pending) << 128n) | BigInt(blockNumber);
-      await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provenBlockNumberSlot, newValue);
+      const newValue = (BigInt(tipsBefore.pending) << 128n) | BigInt(checkpointNumber);
+      await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provenCheckpointNumberSlot, newValue);
 
       const tipsAfter = await this.getTips();
       if (tipsAfter.pending < tipsAfter.proven) {
-        throw new Error('Overwrote pending tip to a block in the past');
+        throw new Error('Overwrote pending tip to a checkpoint in the past');
       }
 
       this.logger.info(
@@ -209,7 +220,7 @@ export class RollupCheatCodes {
 
   /**
    * Overrides the inProgress field of the Inbox contract state
-   * @param howMuch - How many blocks to move it forward
+   * @param howMuch - How many checkpoints to move it forward
    */
   public advanceInboxInProgress(howMuch: number | bigint): Promise<bigint> {
     return this.ethCheatCodes.execWithPausedAnvil(async () => {
@@ -248,6 +259,15 @@ export class RollupCheatCodes {
     });
   }
 
+  public insertOutbox(epoch: EpochNumber, outHash: bigint) {
+    return this.ethCheatCodes.execWithPausedAnvil(async () => {
+      const outboxAddress = await this.rollup.read.getOutbox();
+      const epochRootSlot = OutboxContract.getEpochRootStorageSlot(epoch);
+      await this.ethCheatCodes.store(EthAddress.fromString(outboxAddress), epochRootSlot, outHash);
+      this.logger.warn(`Advanced outbox to epoch ${epoch} with out hash ${outHash}`);
+    });
+  }
+
   /**
    * Executes an action impersonated as the owner of the Rollup contract.
    * @param action - The action to execute

package/src/test/start_anvil.ts

@@ -15,6 +15,9 @@ export async function startAnvil(
     log?: boolean;
     captureMethodCalls?: boolean;
     accounts?: number;
+    chainId?: number;
+    /** The hardfork to use - note: @viem/anvil types are out of date but 'cancun' and 'latest' work */
+    hardfork?: string;
   } = {},
 ): Promise<{ anvil: Anvil; methodCalls?: string[]; rpcUrl: string; stop: () => Promise<void> }> {
   const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
@@ -35,6 +38,7 @@ export async function startAnvil(
         stopTimeout: 1000,
         accounts: opts.accounts ?? 20,
         gasLimit: 45_000_000n,
+        chainId: opts.chainId ?? 31337,
       });
 
       // Listen to the anvil output to get the port.

package/src/test/tx_delayer.ts

@@ -18,6 +18,8 @@ import {
 
 import { type ViemClient, isExtendedClient } from '../types.js';
 
+const MAX_WAIT_TIME_SECONDS = 180;
+
 export function waitUntilBlock<T extends Client>(
   client: T,
   blockNumber: number | bigint,
@@ -36,7 +38,7 @@ export function waitUntilBlock<T extends Client>(
       return currentBlockNumber >= BigInt(blockNumber);
     },
     `Wait until L1 block ${blockNumber}`,
-    timeout ?? 120,
+    timeout ?? MAX_WAIT_TIME_SECONDS,
     0.1,
   );
 }
@@ -66,7 +68,7 @@ export function waitUntilL1Timestamp<T extends Client>(
       return currentTs >= BigInt(timestamp);
     },
     `Wait until L1 timestamp ${timestamp}`,
-    timeout ?? 120,
+    timeout ?? MAX_WAIT_TIME_SECONDS,
     0.1,
   );
 }
@@ -230,7 +232,7 @@ export function withDelayer<T extends ViemClient>(
           return Promise.resolve(txHash!);
         } else {
           const txHash = await client.sendRawTransaction(...args);
-          logger.verbose(`Sent tx immediately ${txHash}`);
+          logger.debug(`Sent tx immediately ${txHash}`);
           delayer.sentTxHashes.push(txHash);
           return txHash;
         }

package/src/types.ts

@@ -5,6 +5,7 @@ import type {
   Client,
   FallbackTransport,
   GetContractReturnType,
+  Hex,
   HttpTransport,
   PublicActions,
   PublicClient,
@@ -16,6 +17,67 @@ import type {
 /** Type for a viem public client */
 export type ViemPublicClient = PublicClient<FallbackTransport<HttpTransport[]>, Chain>;
 
+export type PublicRpcDebugSchema = [
+  {
+    Method: 'debug_traceTransaction';
+    Parameters: [txHash: `0x${string}`, options: { tracer: 'callTracer' }];
+    ReturnType: DebugCallTrace;
+  },
+  {
+    Method: 'trace_transaction';
+    Parameters: [txHash: `0x${string}`];
+    ReturnType: TraceTransactionResponse[];
+  },
+];
+
+/** Return type for a debug_traceTransaction call */
+export type DebugCallTrace = {
+  from: Hex;
+  to?: Hex;
+  type: string;
+  input?: Hex;
+  output?: Hex;
+  gas?: Hex;
+  gasUsed?: Hex;
+  value?: Hex;
+  error?: string;
+  calls?: DebugCallTrace[];
+};
+
+/** Action object for a trace_transaction call */
+export type TraceAction = {
+  from: Hex;
+  to?: Hex;
+  callType: string;
+  gas?: Hex;
+  input?: Hex;
+  value?: Hex;
+};
+
+/** Result object for a trace_transaction call */
+export type TraceResult = {
+  gasUsed?: Hex;
+  output?: Hex;
+};
+
+/** Return type for a single trace in trace_transaction response */
+export type TraceTransactionResponse = {
+  action: TraceAction;
+  result?: TraceResult;
+  error?: string;
+  subtraces: number;
+  traceAddress: number[];
+  type: string;
+};
+
+/** Type for a viem public client with support for debug methods */
+export type ViemPublicDebugClient = PublicClient<
+  FallbackTransport<HttpTransport[]>,
+  Chain,
+  undefined,
+  [...PublicRpcSchema, ...PublicRpcDebugSchema]
+>;
+
 export type ExtendedViemWalletClient = Client<
   FallbackTransport<readonly HttpTransport[]>,
   Chain,

package/src/utils.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
 import { ErrorsAbi } from '@aztec/l1-artifacts/ErrorsAbi';
 
@@ -8,6 +8,7 @@ import {
   type ContractEventName,
   ContractFunctionRevertedError,
   type DecodeEventLogReturnType,
+  type FormattedTransaction,
   type Hex,
   type Log,
   decodeErrorResult,
@@ -233,3 +234,31 @@ export function tryGetCustomErrorName(err: any) {
     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: FormattedTransaction): tx is FormattedTransaction & {
+  maxFeePerBlobGas: bigint;
+  blobVersionedHashes: readonly Hex[];
+} {
+  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: bigint[], percentile: number): bigint {
+  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/deploy_l1_contracts.d.ts

@@ -1,226 +0,0 @@
-import { SecretValue } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
-import { type Logger } from '@aztec/foundation/log';
-import { DateProvider } from '@aztec/foundation/timer';
-import type { Abi, Narrow } from 'abitype';
-import { type Chain, type ContractConstructorArgs, type HDAccount, type Hex, type PrivateKeyAccount } from 'viem';
-import { type L1ContractsConfig } from './config.js';
-import { RollupContract } from './contracts/rollup.js';
-import type { L1ContractAddresses } from './l1_contract_addresses.js';
-import { type GasPrice, type L1TxConfig, type L1TxRequest, L1TxUtils, type L1TxUtilsConfig } from './l1_tx_utils/index.js';
-import type { ExtendedViemWalletClient } from './types.js';
-export declare const DEPLOYER_ADDRESS: Hex;
-export type Operator = {
-    attester: EthAddress;
-    withdrawer: EthAddress;
-    bn254SecretKey: SecretValue<bigint>;
-};
-/**
- * Return type of the deployL1Contract function.
- */
-export type DeployL1ContractsReturnType = {
-    /** Extended Wallet Client Type. */
-    l1Client: ExtendedViemWalletClient;
-    /** The currently deployed l1 contract addresses */
-    l1ContractAddresses: L1ContractAddresses;
-    /** Version of the current rollup contract. */
-    rollupVersion: number;
-};
-export interface LinkReferences {
-    [fileName: string]: {
-        [contractName: string]: ReadonlyArray<{
-            start: number;
-            length: number;
-        }>;
-    };
-}
-export interface Libraries {
-    linkReferences: LinkReferences;
-    libraryCode: Record<string, ContractArtifacts>;
-}
-/**
- * Contract artifacts
- */
-export interface ContractArtifacts<TAbi extends Abi | readonly unknown[] = Abi> {
-    /**
-     * The contract name.
-     */
-    name: string;
-    /**
-     * The contract abi.
-     */
-    contractAbi: Narrow<TAbi>;
-    /**
-     * The contract bytecode
-     */
-    contractBytecode: Hex;
-    /**
-     * The contract libraries
-     */
-    libraries?: Libraries;
-}
-export type VerificationLibraryEntry = {
-    file: string;
-    contract: string;
-    address: string;
-};
-export type VerificationRecord = {
-    name: string;
-    address: string;
-    constructorArgsHex: Hex;
-    libraries: VerificationLibraryEntry[];
-};
-export interface DeployL1ContractsArgs extends Omit<L1ContractsConfig, keyof L1TxUtilsConfig> {
-    /** The vk tree root. */
-    vkTreeRoot: Fr;
-    /** The hash of the protocol contracts. */
-    protocolContractsHash: Fr;
-    /** The genesis root of the archive tree. */
-    genesisArchiveRoot: Fr;
-    /** The salt for CREATE2 deployment. */
-    salt: number | undefined;
-    /** The initial validators for the rollup contract. */
-    initialValidators?: Operator[];
-    /** Configuration for the L1 tx utils module. */
-    l1TxConfig?: Partial<L1TxUtilsConfig>;
-    /** Enable fast mode for deployments (fire and forget transactions) */
-    acceleratedTestDeployments?: boolean;
-    /** The initial balance of the fee juice portal. This is the amount of fee juice that is prefunded to accounts */
-    feeJuicePortalInitialBalance?: bigint;
-    /** Whether to deploy the real verifier or the mock verifier */
-    realVerifier: boolean;
-    /** The zk passport args */
-    zkPassportArgs?: ZKPassportArgs;
-    /** If provided, use this token for BOTH fee and staking assets (skip deployments) */
-    existingTokenAddress?: EthAddress;
-}
-export interface ZKPassportArgs {
-    /** Whether to use the mock zk passport verifier */
-    mockZkPassportVerifier?: boolean;
-    /** The domain of the zk passport (url) */
-    zkPassportDomain?: string;
-    /** The scope of the zk passport (personhood, etc) */
-    zkPassportScope?: string;
-}
-/**
- * Validates that the provided address points to a contract that resembles an ERC20 token.
- * Checks for contract code and attempts common ERC20 view calls.
- * Throws an error if validation fails.
- */
-export declare function validateExistingErc20TokenAddress(l1Client: ExtendedViemWalletClient, tokenAddress: EthAddress, logger: Logger): Promise<void>;
-export declare const deploySharedContracts: (l1Client: ExtendedViemWalletClient, deployer: L1Deployer, args: DeployL1ContractsArgs, logger: Logger) => Promise<{
-    feeAssetAddress: EthAddress;
-    feeAssetHandlerAddress: EthAddress | undefined;
-    stakingAssetAddress: EthAddress;
-    stakingAssetHandlerAddress: EthAddress | undefined;
-    zkPassportVerifierAddress: EthAddress | undefined;
-    registryAddress: EthAddress;
-    gseAddress: EthAddress;
-    governanceAddress: EthAddress;
-    governanceProposerAddress: EthAddress;
-    coinIssuerAddress: EthAddress;
-    rewardDistributorAddress: EthAddress;
-}>;
-/**
- * Deploys a new rollup, using the existing canonical version to derive certain values (addresses of assets etc).
- * @param clients - The L1 clients.
- * @param args - The deployment arguments.
- * @param registryAddress - The address of the registry.
- * @param logger - The logger.
- * @param txUtilsConfig - The L1 tx utils config.
- * @param createVerificationJson - Optional path to write verification data for forge verify.
- */
-export declare const deployRollupForUpgrade: (extendedClient: ExtendedViemWalletClient, args: Omit<DeployL1ContractsArgs, "governanceProposerQuorum" | "governanceProposerRoundSize" | "ejectionThreshold" | "activationThreshold">, registryAddress: EthAddress, logger: Logger, txUtilsConfig: L1TxUtilsConfig, createVerificationJson?: string | false) => Promise<{
-    rollup: RollupContract;
-    slashFactoryAddress: EthAddress;
-}>;
-export declare const deploySlashFactory: (deployer: L1Deployer, rollupAddress: Hex, logger: Logger) => Promise<EthAddress>;
-export declare const deployUpgradePayload: (deployer: L1Deployer, addresses: Pick<L1ContractAddresses, "registryAddress" | "rollupAddress">) => Promise<EthAddress>;
-/**
- * Deploys a new rollup contract, funds and initializes the fee juice portal, and initializes the validator set.
- */
-export declare const deployRollup: (extendedClient: ExtendedViemWalletClient, deployer: L1Deployer, args: Omit<DeployL1ContractsArgs, "governanceProposerQuorum" | "governanceProposerRoundSize" | "ejectionThreshold" | "activationThreshold">, addresses: Pick<L1ContractAddresses, "feeJuiceAddress" | "registryAddress" | "rewardDistributorAddress" | "stakingAssetAddress" | "gseAddress" | "governanceAddress">, logger: Logger) => Promise<{
-    rollup: RollupContract;
-    slashFactoryAddress: EthAddress;
-}>;
-export declare const handoverToGovernance: (extendedClient: ExtendedViemWalletClient, deployer: L1Deployer, registryAddress: EthAddress, gseAddress: EthAddress, coinIssuerAddress: EthAddress, feeAssetAddress: EthAddress, governanceAddress: EthAddress, logger: Logger, acceleratedTestDeployments: boolean | undefined, useExternalToken?: boolean) => Promise<{
-    dateGatedRelayerAddress: EthAddress;
-}>;
-export declare const addMultipleValidators: (extendedClient: ExtendedViemWalletClient, deployer: L1Deployer, gseAddress: Hex, rollupAddress: Hex, stakingAssetAddress: Hex, validators: Operator[], acceleratedTestDeployments: boolean | undefined, logger: Logger) => Promise<void>;
-/**
- * Initialize the fee asset handler and make it a minter on the fee asset.
- * @note This function will only be used for testing purposes.
- *
- * @param extendedClient - The L1 clients.
- * @param deployer - The L1 deployer.
- * @param feeAssetAddress - The address of the fee asset.
- * @param logger - The logger.
- */
-export declare const cheat_initializeFeeAssetHandler: (extendedClient: ExtendedViemWalletClient, deployer: L1Deployer, feeAssetAddress: EthAddress, logger: Logger) => Promise<{
-    feeAssetHandlerAddress: EthAddress;
-    txHash: Hex;
-}>;
-/**
- * Deploys the aztec L1 contracts; Rollup & (optionally) Decoder Helper.
- * @param rpcUrls - List of URLs of the ETH RPC to use for deployment.
- * @param account - Private Key or HD Account that will deploy the contracts.
- * @param chain - The chain instance to deploy to.
- * @param logger - A logger object.
- * @param args - Arguments for initialization of L1 contracts
- * @returns A list of ETH addresses of the deployed contracts.
- */
-export declare const deployL1Contracts: (rpcUrls: string[], account: HDAccount | PrivateKeyAccount, chain: Chain, logger: Logger, args: DeployL1ContractsArgs, txUtilsConfig?: L1TxUtilsConfig, createVerificationJson?: string | false) => Promise<DeployL1ContractsReturnType>;
-export declare class L1Deployer {
-    readonly client: ExtendedViemWalletClient;
-    private acceleratedTestDeployments;
-    private logger;
-    private txUtilsConfig?;
-    private createVerificationJson;
-    private salt;
-    private txHashes;
-    readonly l1TxUtils: L1TxUtils;
-    readonly verificationRecords: VerificationRecord[];
-    constructor(client: ExtendedViemWalletClient, maybeSalt: number | undefined, dateProvider?: DateProvider, acceleratedTestDeployments?: boolean, logger?: Logger, txUtilsConfig?: L1TxUtilsConfig | undefined, createVerificationJson?: boolean);
-    deploy<const TAbi extends Abi>(params: ContractArtifacts<TAbi>, args?: ContractConstructorArgs<TAbi>, opts?: {
-        gasLimit?: bigint;
-    }): Promise<{
-        address: EthAddress;
-        existed: boolean;
-    }>;
-    waitForDeployments(): Promise<void>;
-    sendTransaction(tx: L1TxRequest, options?: L1TxConfig): Promise<{
-        txHash: Hex;
-        gasLimit: bigint;
-        gasPrice: 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 declare 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;
-}): Promise<{
-    address: EthAddress;
-    txHash: Hex | undefined;
-    deployedLibraries?: VerificationLibraryEntry[];
-    existed: boolean;
-}>;
-export declare function getExpectedAddress(abi: Narrow<Abi | readonly unknown[]>, bytecode: Hex, args: readonly unknown[], salt: Hex): {
-    address: `0x${string}`;
-    paddedSalt: `0x${string}`;
-    calldata: `0x${string}`;
-};
-//# sourceMappingURL=deploy_l1_contracts.d.ts.map