@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/l1_tx_utils/tx_delayer.ts

@@ -0,0 +1,294 @@
+import { omit } from '@aztec/foundation/collection';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import type { DateProvider } from '@aztec/foundation/timer';
+
+import { inspect } from 'util';
+import {
+  type Client,
+  type Hex,
+  type PublicClient,
+  type TransactionSerializableEIP4844,
+  type TransactionSerialized,
+  keccak256,
+  parseTransaction,
+  publicActions,
+  recoverTransactionAddress,
+  serializeTransaction,
+  walletActions,
+} from 'viem';
+
+import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
+
+const MAX_WAIT_TIME_SECONDS = 180;
+
+export function waitUntilBlock<T extends Client>(
+  client: T,
+  blockNumber: number | bigint,
+  logger?: Logger,
+  timeout?: number,
+) {
+  const publicClient =
+    'getBlockNumber' in client && typeof client.getBlockNumber === 'function'
+      ? (client as unknown as PublicClient)
+      : client.extend(publicActions);
+
+  return retryUntil(
+    async () => {
+      const currentBlockNumber = await publicClient.getBlockNumber({ cacheTime: 0 });
+      logger?.debug(`Block number is ${currentBlockNumber} (waiting until ${blockNumber})`);
+      return currentBlockNumber >= BigInt(blockNumber);
+    },
+    `Wait until L1 block ${blockNumber}`,
+    timeout ?? MAX_WAIT_TIME_SECONDS,
+    0.1,
+  );
+}
+
+export function waitUntilL1Timestamp<T extends Client>(
+  client: T,
+  timestamp: number | bigint,
+  logger?: Logger,
+  timeout?: number,
+) {
+  const publicClient =
+    'getBlockNumber' in client && typeof client.getBlockNumber === 'function'
+      ? (client as unknown as PublicClient)
+      : client.extend(publicActions);
+
+  let lastBlock: bigint | undefined = undefined;
+  return retryUntil(
+    async () => {
+      const currentBlockNumber = await publicClient.getBlockNumber({ cacheTime: 0 });
+      if (currentBlockNumber === lastBlock) {
+        return false;
+      }
+      lastBlock = currentBlockNumber;
+      const currentBlock = await publicClient.getBlock({ includeTransactions: false, blockNumber: currentBlockNumber });
+      const currentTs = currentBlock.timestamp;
+      logger?.debug(`Block timstamp is ${currentTs} (waiting until ${timestamp})`);
+      return currentTs >= BigInt(timestamp);
+    },
+    `Wait until L1 timestamp ${timestamp}`,
+    timeout ?? MAX_WAIT_TIME_SECONDS,
+    0.1,
+  );
+}
+
+/** Manages tx delaying for testing, intercepting sendRawTransaction calls to delay or cancel them. */
+export class Delayer {
+  private logger: Logger;
+
+  public maxInclusionTimeIntoSlot: number | undefined = undefined;
+  public ethereumSlotDuration: bigint;
+  public nextWait: { l1Timestamp: bigint } | { l1BlockNumber: bigint } | { indefinitely: true } | undefined = undefined;
+  public sentTxHashes: Hex[] = [];
+  public cancelledTxs: Hex[] = [];
+
+  constructor(
+    public dateProvider: DateProvider,
+    opts: { ethereumSlotDuration: bigint | number },
+    bindings: LoggerBindings,
+  ) {
+    this.ethereumSlotDuration = BigInt(opts.ethereumSlotDuration);
+    this.logger = createLogger('ethereum:tx_delayer', bindings);
+  }
+
+  /** Returns the logger instance used by this delayer. */
+  getLogger(): Logger {
+    return this.logger;
+  }
+
+  /** Returns the hashes of all effectively sent txs. */
+  getSentTxHashes() {
+    return this.sentTxHashes;
+  }
+
+  /** Returns the raw hex for all cancelled txs. */
+  getCancelledTxs(): Hex[] {
+    return this.cancelledTxs;
+  }
+
+  /** Delays the next tx to be sent so it lands on the given L1 block number. */
+  pauseNextTxUntilBlock(l1BlockNumber: number | bigint) {
+    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber) };
+  }
+
+  /** Delays the next tx to be sent so it lands on the given timestamp. */
+  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint) {
+    this.nextWait = { l1Timestamp: BigInt(l1Timestamp) };
+  }
+
+  /** Delays the next tx to be sent indefinitely. */
+  cancelNextTx() {
+    this.nextWait = { indefinitely: true };
+  }
+
+  /**
+   * Sets max inclusion time into slot. If more than this many seconds have passed
+   * since the last L1 block was mined, then any tx will not be mined in the current
+   * L1 slot but will be deferred for the next one.
+   */
+  setMaxInclusionTimeIntoSlot(seconds: number | undefined) {
+    this.maxInclusionTimeIntoSlot = seconds;
+  }
+}
+
+/**
+ * Creates a new Delayer instance. Exposed so callers can create a single shared delayer
+ * and pass it to multiple `wrapClientWithDelayer` calls.
+ */
+export function createDelayer(
+  dateProvider: DateProvider,
+  opts: { ethereumSlotDuration: bigint | number },
+  bindings: LoggerBindings,
+): Delayer {
+  return new Delayer(dateProvider, opts, bindings);
+}
+
+/** Tries to recover the sender address from a serialized signed transaction. */
+async function tryRecoverSender(serializedTransaction: Hex): Promise<string | undefined> {
+  try {
+    return await recoverTransactionAddress({
+      serializedTransaction: serializedTransaction as TransactionSerialized,
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Wraps a viem client with tx delaying logic. Returns the wrapped client.
+ * The delayer intercepts sendRawTransaction calls and delays them based on the delayer's state.
+ */
+export function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer: Delayer): T {
+  const logger = delayer.getLogger();
+
+  // Cast to ExtendedViemWalletClient for the extend chain since it has sendRawTransaction.
+  // The sendRawTransaction override is applied to all clients regardless of type.
+  const withRawTx = (client as unknown as ExtendedViemWalletClient)
+    // Tweak sendRawTransaction so it uses the delay defined in the delayer.
+    // Note that this will only work with local accounts (ie accounts for which we have the private key).
+    // Transactions signed by the node will not be delayed since they use sendTransaction directly,
+    // but we do not use them in our codebase at all.
+    .extend(client => ({
+      async sendRawTransaction(...args) {
+        let wait: Promise<unknown> | undefined;
+        let txHash: Hex | undefined;
+
+        const { serializedTransaction } = args[0];
+        const publicClient = client as unknown as PublicClient;
+        const sender = await tryRecoverSender(serializedTransaction);
+
+        if (delayer.nextWait !== undefined) {
+          // Check if we have been instructed to delay the next tx.
+          const waitUntil = delayer.nextWait;
+          delayer.nextWait = undefined;
+
+          // Compute the tx hash manually so we emulate sendRawTransaction response
+          txHash = computeTxHash(serializedTransaction);
+
+          // Cancel tx outright if instructed
+          if ('indefinitely' in waitUntil && waitUntil.indefinitely) {
+            logger.info(`Cancelling tx ${txHash}`, { sender });
+            delayer.cancelledTxs.push(serializedTransaction);
+            return Promise.resolve(txHash);
+          }
+
+          // Or wait until the desired block number or timestamp
+          wait =
+            'l1BlockNumber' in waitUntil
+              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger)
+              : 'l1Timestamp' in waitUntil
+                ? waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger)
+                : undefined;
+
+          logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
+            sender,
+            argsLen: args.length,
+            ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
+          });
+        } else if (delayer.maxInclusionTimeIntoSlot !== undefined) {
+          // Check if we need to delay txs sent too close to the end of the slot.
+          const currentBlock = await publicClient.getBlock({ includeTransactions: false });
+          const { timestamp: lastBlockTimestamp, number } = currentBlock;
+          const now = delayer.dateProvider.now();
+
+          txHash = computeTxHash(serializedTransaction);
+          const logData = {
+            sender,
+            ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
+            lastBlockTimestamp,
+            now,
+            maxInclusionTimeIntoSlot: delayer.maxInclusionTimeIntoSlot,
+          };
+
+          if (now / 1000 - Number(lastBlockTimestamp) > delayer.maxInclusionTimeIntoSlot) {
+            // If the last block was mined more than `maxInclusionTimeIntoSlot` seconds ago, then we cannot include
+            // any txs in the current slot, so we delay the tx until the next slot.
+            logger.info(`Delaying inclusion of tx ${txHash} until the next slot since it was sent too late`, logData);
+            wait = waitUntilBlock(publicClient, number + 1n, logger);
+          } else {
+            logger.debug(`Immediately sending tx ${txHash} as it was received early enough in the slot`, logData);
+          }
+        }
+
+        if (wait !== undefined) {
+          // Do not await here so we can return the tx hash immediately as if it had been sent on the spot.
+          // Instead, delay it so it lands on the desired block number or timestamp, assuming anvil will
+          // mine it immediately.
+          void wait!
+            .then(async () => {
+              const clientTxHash = await client.sendRawTransaction(...args);
+              if (clientTxHash !== txHash) {
+                logger.error(`Tx hash returned by the client does not match computed one`, {
+                  clientTxHash,
+                  computedTxHash: txHash,
+                });
+              }
+              logger.info(`Sent previously delayed tx ${clientTxHash}`, { sender });
+              delayer.sentTxHashes.push(clientTxHash);
+            })
+            .catch(err => logger.error(`Error sending tx after delay`, err));
+          return Promise.resolve(txHash!);
+        } else {
+          const txHash = await client.sendRawTransaction(...args);
+          logger.debug(`Sent tx immediately ${txHash}`, { sender });
+          delayer.sentTxHashes.push(txHash);
+          return txHash;
+        }
+      },
+    }));
+
+  // Only re-bind wallet actions (sendTransaction, writeContract, deployContract) for wallet clients.
+  // This is needed for tests that use wallet actions directly rather than sendRawTransaction.
+  const isWalletClient = 'account' in client && client.account !== undefined;
+  const extended = isWalletClient
+    ? withRawTx
+        // Re-extend with sendTransaction so it uses the modified sendRawTransaction.
+        .extend(client => ({ sendTransaction: walletActions(client).sendTransaction }))
+        // And with the actions that depend on the modified sendTransaction
+        .extend(client => ({
+          writeContract: walletActions(client).writeContract,
+          deployContract: walletActions(client).deployContract,
+        }))
+    : withRawTx;
+
+  return extended as T;
+}
+
+/**
+ * Compute the tx hash given the serialized tx. Note that if this is a blob tx, we need to
+ * exclude the blobs, commitments, and proofs from the hash.
+ */
+function computeTxHash(serializedTransaction: Hex) {
+  if (serializedTransaction.startsWith('0x03')) {
+    const parsed = parseTransaction(serializedTransaction);
+    if (parsed.blobs || parsed.sidecars) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { blobs, sidecars, ...rest } = parsed;
+      return keccak256(serializeTransaction({ type: 'eip4844', ...rest } as TransactionSerializableEIP4844));
+    }
+  }
+  return keccak256(serializedTransaction);
+}

package/src/l1_tx_utils/types.ts

@@ -0,0 +1,85 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ViemTransactionSignature } from '@aztec/foundation/eth-signature';
+
+import type { Abi, Address, Hex, TransactionReceipt, TransactionSerializable } from 'viem';
+
+import type { L1TxUtilsConfig } from './config.js';
+
+export interface L1TxRequest {
+  to: Address | null;
+  data?: Hex;
+  value?: bigint;
+  abi?: Abi;
+}
+
+export type L1TxConfig = Partial<L1TxUtilsConfig> & { gasLimit?: bigint; txTimeoutAt?: Date };
+
+export interface L1BlobInputs {
+  blobs: Uint8Array[];
+  kzg: BlobKzgInstance;
+  maxFeePerBlobGas?: bigint;
+}
+
+export interface GasPrice {
+  maxFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
+  maxFeePerBlobGas?: bigint;
+}
+
+export type TransactionStats = {
+  /** Address of the sender. */
+  sender: string;
+  /** Hash of the transaction. */
+  transactionHash: string;
+  /** Size in bytes of the tx calldata */
+  calldataSize: number;
+  /** Gas required to pay for the calldata inclusion (depends on size and number of zeros)  */
+  calldataGas: number;
+};
+
+export enum TxUtilsState {
+  IDLE,
+  SENT,
+  SPEED_UP,
+  CANCELLED,
+  NOT_MINED,
+  MINED,
+}
+
+export const TerminalTxUtilsState = [TxUtilsState.IDLE, TxUtilsState.MINED, TxUtilsState.NOT_MINED];
+
+export type L1TxState = {
+  id: number;
+  txHashes: Hex[];
+  cancelTxHashes: Hex[];
+  gasLimit: bigint;
+  gasPrice: GasPrice;
+  txConfigOverrides: L1TxConfig;
+  request: L1TxRequest;
+  status: TxUtilsState;
+  nonce: number;
+  sentAtL1Ts: Date;
+  lastSentAtL1Ts: Date;
+  receipt?: TransactionReceipt;
+  blobInputs: L1BlobInputs | undefined;
+};
+
+export type SigningCallback = (
+  transaction: TransactionSerializable,
+  signingAddress: EthAddress,
+) => Promise<ViemTransactionSignature>;
+
+export class UnknownMinedTxError extends Error {
+  constructor(nonce: number, account: string) {
+    super(`Nonce ${nonce} from account ${account} is MINED but not by one of our expected transactions`);
+    this.name = 'UnknownMinedTxError';
+  }
+}
+
+export class DroppedTransactionError extends Error {
+  constructor(nonce: number, account: string) {
+    super(`Transaction with nonce ${nonce} from account ${account} was dropped from the mempool`);
+    this.name = 'DroppedTransactionError';
+  }
+}

package/src/l1_tx_utils/utils.ts

@@ -0,0 +1,16 @@
+import { compactArray } from '@aztec/foundation/collection';
+
+import type { ContractFunctionExecutionError } from 'viem';
+
+export function tryGetCustomErrorNameContractFunction(err: ContractFunctionExecutionError) {
+  return compactArray([err.shortMessage, ...(err.metaMessages ?? []).slice(0, 2).map(s => s.trim())]).join(' ');
+}
+
+/*
+ * Returns cost of calldata usage in Ethereum.
+ * @param data - Calldata.
+ * @returns 4 for each zero byte, 16 for each nonzero.
+ */
+export function getCalldataGasUsage(data: Uint8Array) {
+  return data.filter(byte => byte === 0).length * 4 + data.filter(byte => byte !== 0).length * 16;
+}

package/src/l1_types.ts

@@ -0,0 +1,6 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+
+export type L1BlockId = {
+  l1BlockNumber: bigint;
+  l1BlockHash: Buffer32;
+};

package/src/publisher_manager.ts

@@ -0,0 +1,108 @@
+import { pick } from '@aztec/foundation/collection';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+
+import { L1TxUtils, TxUtilsState } from './l1_tx_utils/index.js';
+
+// Defines the order in which we prioritise publishers based on their state (first is better)
+const sortOrder = [
+  // Always prefer sending from idle publishers
+  TxUtilsState.IDLE,
+  // Then from publishers that have sent a tx and it got mined
+  TxUtilsState.MINED,
+  // Then from publishers that have sent a tx but it's in-flight
+  TxUtilsState.SPEED_UP,
+  TxUtilsState.SENT,
+  // We leave cancelled and not-mined states for last, since these represent failures to mines and could be problematic
+  TxUtilsState.CANCELLED,
+  TxUtilsState.NOT_MINED,
+];
+
+// Which states represent a busy publisher that we should avoid if possible
+const busyStates: TxUtilsState[] = [
+  TxUtilsState.SENT,
+  TxUtilsState.SPEED_UP,
+  TxUtilsState.CANCELLED,
+  TxUtilsState.NOT_MINED,
+];
+
+export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
+
+export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
+  private log: Logger;
+  private config: { publisherAllowInvalidStates?: boolean };
+
+  constructor(
+    private publishers: UtilsType[],
+    config: { publisherAllowInvalidStates?: boolean },
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('publisher:manager', bindings);
+    this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
+    this.publishers = publishers;
+    this.config = pick(config, 'publisherAllowInvalidStates');
+  }
+
+  /** Loads the state of all publishers and resumes monitoring any pending txs */
+  public async loadState(): Promise<void> {
+    await Promise.all(this.publishers.map(pub => pub.loadStateAndResumeMonitoring()));
+  }
+
+  // Finds and prioritises available publishers based on
+  // 1. Validity as per the provided filter function
+  // 2. Validity based on the state the publisher is in
+  // 3. Priority based on state as defined by sortOrder
+  // 4. Then priority based on highest balance
+  // 5. Then priority based on least recently used
+  public async getAvailablePublisher(filter: PublisherFilter<UtilsType> = () => true): Promise<UtilsType> {
+    this.log.debug(`Getting available publisher`, {
+      publishers: this.publishers.map(p => ({
+        address: p.getSenderAddress(),
+        state: p.state,
+        lastMined: p.lastMinedAtBlockNumber,
+      })),
+    });
+
+    // Extract the valid publishers
+    let validPublishers = this.publishers.filter((pub: UtilsType) => !busyStates.includes(pub.state) && filter(pub));
+
+    // If none found but we allow invalid (busy) states, try again including them
+    if (validPublishers.length === 0 && this.config.publisherAllowInvalidStates) {
+      this.log.warn(`No valid publishers found. Trying again including invalid states.`);
+      validPublishers = this.publishers.filter(pub => filter(pub));
+    }
+
+    // Error if none found
+    if (validPublishers.length === 0) {
+      throw new Error(`Failed to find an available publisher.`);
+    }
+
+    // Get the balances
+    const publishersWithBalance = await Promise.all(
+      validPublishers.map(async pub => {
+        return { balance: await pub.getSenderBalance(), publisher: pub };
+      }),
+    );
+
+    // Sort based on state, then balance, then time since last use
+    const sortedPublishers = publishersWithBalance.sort((a, b) => {
+      const stateComparison = sortOrder.indexOf(a.publisher.state) - sortOrder.indexOf(b.publisher.state);
+      if (stateComparison !== 0) {
+        return stateComparison;
+      }
+      const balanceComparison = Number(b.balance - a.balance);
+      if (balanceComparison !== 0) {
+        return balanceComparison;
+      }
+      const lastUsedComparison = Number(
+        (a.publisher.lastMinedAtBlockNumber ?? 0n) - (b.publisher.lastMinedAtBlockNumber ?? 0n),
+      );
+      return lastUsedComparison;
+    });
+
+    return sortedPublishers[0].publisher;
+  }
+
+  public interrupt() {
+    this.publishers.forEach(pub => pub.interrupt());
+  }
+}

package/src/queries.ts

@@ -1,7 +1,9 @@
-import type { EthAddress } from '@aztec/foundation/eth-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
 
-import type { L1ContractsConfig } from './config.js';
-import { GovernanceContract } from './contracts/governance.js';
+import { DefaultL1ContractsConfig, type L1ContractsConfig } from './config.js';
+import { ReadOnlyGovernanceContract } from './contracts/governance.js';
+import { GovernanceProposerContract } from './contracts/governance_proposer.js';
+import { InboxContract } from './contracts/inbox.js';
 import { RollupContract } from './contracts/rollup.js';
 import type { ViemPublicClient } from './types.js';
 
@@ -9,50 +11,114 @@ import type { ViemPublicClient } from './types.js';
 export async function getL1ContractsConfig(
   publicClient: ViemPublicClient,
   addresses: { governanceAddress: EthAddress; rollupAddress?: EthAddress },
-): Promise<Omit<L1ContractsConfig, 'ethereumSlotDuration'> & { l1StartBlock: bigint; l1GenesisTime: bigint }> {
-  const governance = new GovernanceContract(addresses.governanceAddress.toString(), publicClient, undefined);
-  const governanceProposer = await governance.getProposer();
-  const rollupAddress = addresses.rollupAddress ?? (await governance.getGovernanceAddresses()).rollupAddress;
+): Promise<
+  Omit<L1ContractsConfig, 'ethereumSlotDuration'> & {
+    l1StartBlock: bigint;
+    l1GenesisTime: bigint;
+    rollupVersion: number;
+    genesisArchiveTreeRoot: `0x${string}`;
+  }
+> {
+  const governance = new ReadOnlyGovernanceContract(addresses.governanceAddress.toString(), publicClient);
+  const governanceProposerAddress = await governance.getGovernanceProposerAddress();
+  const governanceProposer = new GovernanceProposerContract(publicClient, governanceProposerAddress.toString());
+  const rollupAddress = addresses.rollupAddress ?? (await governanceProposer.getRollupAddress());
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
   const slasherProposer = await rollup.getSlashingProposer();
+  const slasher = await rollup.getSlasherContract();
+  const rollupAddresses = await rollup.getRollupAddresses();
+  const inboxContract = new InboxContract(publicClient, rollupAddresses.inboxAddress.toString());
 
   const [
     l1StartBlock,
     l1GenesisTime,
     aztecEpochDuration,
-    aztecProofSubmissionWindow,
     aztecSlotDuration,
+    aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
-    minimumStake,
+    lagInEpochsForValidatorSet,
+    lagInEpochsForRandao,
+    inboxLag,
+    activationThreshold,
+    ejectionThreshold,
+    localEjectionThreshold,
     governanceProposerQuorum,
     governanceProposerRoundSize,
     slashingQuorum,
     slashingRoundSize,
+    slashingLifetimeInRounds,
+    slashingExecutionDelayInRounds,
+    slashingOffsetInRounds,
+    slashingAmounts,
+    slashingVetoer,
+    slashingDisableDuration,
+    manaTarget,
+    provingCostPerMana,
+    rollupVersion,
+    genesisArchiveTreeRoot,
+    exitDelay,
   ] = await Promise.all([
     rollup.getL1StartBlock(),
     rollup.getL1GenesisTime(),
     rollup.getEpochDuration(),
-    rollup.getProofSubmissionWindow(),
     rollup.getSlotDuration(),
+    rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
-    rollup.getMinimumStake(),
+    rollup.getLagInEpochsForValidatorSet(),
+    rollup.getLagInEpochsForRandao(),
+    inboxContract.getLag(),
+    rollup.getActivationThreshold(),
+    rollup.getEjectionThreshold(),
+    rollup.getLocalEjectionThreshold(),
     governanceProposer.getQuorumSize(),
     governanceProposer.getRoundSize(),
-    slasherProposer.getQuorumSize(),
-    slasherProposer.getRoundSize(),
+    slasherProposer?.getQuorumSize() ?? 0n,
+    slasherProposer?.getRoundSize() ?? 0n,
+    slasherProposer?.getLifetimeInRounds() ?? 0n,
+    slasherProposer?.getExecutionDelayInRounds() ?? 0n,
+    slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
+    slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [0n, 0n, 0n],
+    slasher?.getVetoer() ?? EthAddress.ZERO,
+    slasher?.getSlashingDisableDuration() ?? 0,
+    rollup.getManaTarget(),
+    rollup.getProvingCostPerMana(),
+    rollup.getVersion(),
+    rollup.getGenesisArchiveTreeRoot(),
+    rollup.getExitDelay(),
   ] as const);
 
   return {
     l1StartBlock,
     l1GenesisTime,
     aztecEpochDuration: Number(aztecEpochDuration),
-    aztecProofSubmissionWindow: Number(aztecProofSubmissionWindow),
     aztecSlotDuration: Number(aztecSlotDuration),
+    aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+    lagInEpochsForValidatorSet: Number(lagInEpochsForValidatorSet),
+    lagInEpochsForRandao: Number(lagInEpochsForRandao),
+    inboxLag: Number(inboxLag),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
-    minimumStake,
+    governanceVotingDuration: DefaultL1ContractsConfig.governanceVotingDuration,
+    activationThreshold,
+    ejectionThreshold,
+    localEjectionThreshold,
     slashingQuorum: Number(slashingQuorum),
-    slashingRoundSize: Number(slashingRoundSize),
+    slashingRoundSizeInEpochs: Number(Number(slashingRoundSize) / aztecEpochDuration),
+    slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
+    slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
+    slashingVetoer,
+    slashingDisableDuration,
+    manaTarget,
+    provingCostPerMana: provingCostPerMana,
+    rollupVersion: Number(rollupVersion),
+    genesisArchiveTreeRoot: genesisArchiveTreeRoot.toString(),
+    exitDelaySeconds: Number(exitDelay),
+    slasherFlavor: slasherProposer?.type ?? 'tally',
+    slashingOffsetInRounds: Number(slashingOffsetInRounds),
+    slashAmountSmall: slashingAmounts[0],
+    slashAmountMedium: slashingAmounts[1],
+    slashAmountLarge: slashingAmounts[2],
+    initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset,
   };
 }