@aztec/end-to-end 5.0.0-rc.1 → 5.0.0

package/src/multi-node/block-production/setup.ts

@@ -0,0 +1,272 @@
+import type { Archiver } from '@aztec/archiver';
+import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { NO_WAIT } from '@aztec/aztec.js/contracts';
+import { generateClaimSecret } from '@aztec/aztec.js/ethereum';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import { isL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
+import { waitForTx } from '@aztec/aztec.js/node';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { waitUntilL1Timestamp } from '@aztec/ethereum/l1-tx-utils';
+import { asyncMap } from '@aztec/foundation/async-map';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { timesAsync } from '@aztec/foundation/collection';
+import { retryUntil } from '@aztec/foundation/retry';
+import { sleep } from '@aztec/foundation/sleep';
+import { executeTimeout } from '@aztec/foundation/timer';
+import { TestContract } from '@aztec/noir-test-contracts.js/Test';
+import type { SequencerEvents } from '@aztec/sequencer-client';
+import { getSlotAtTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { GasFees } from '@aztec/stdlib/gas';
+import { TxStatus } from '@aztec/stdlib/tx';
+
+import { jest } from '@jest/globals';
+
+import { sendL1ToL2Message } from '../../fixtures/l1_to_l2_messaging.js';
+import { testSpan } from '../../fixtures/timing.js';
+import type { EndToEndContext } from '../../fixtures/utils.js';
+import { waitForBlockNumber, waitForTxs } from '../../fixtures/wait_helpers.js';
+import type { TestWallet } from '../../test-wallet/test_wallet.js';
+import { proveInteraction } from '../../test-wallet/utils.js';
+import {
+  type BlockProposedEvent,
+  MOCK_GOSSIP_MULTI_VALIDATOR_OPTS,
+  MULTI_VALIDATOR_BLOCK_PRODUCTION_TIMING,
+  MultiNodeTestContext,
+  type MultiNodeTestOpts,
+  type RegisteredValidator,
+  type TrackedSequencerEvent,
+  WIDE_SLOT_TIMING,
+  buildMockGossipValidators,
+} from '../multi_node_test_context.js';
+
+jest.setTimeout(1000 * 60 * 20);
+
+export const NODE_COUNT = 4;
+
+// Send enough transactions to trigger multiple blocks within a checkpoint assuming 2 txs per block.
+// If we start including txs at the 2nd block of a checkpoint, we can ensure a 3-block checkpoint
+// if we produce 10 txs:
+// - Checkpoint 1: Block 1 (0 txs), Block 2 (2 txs), Block 3 (2 txs)
+// - Checkpoint 2: Block 1 (2 txs), Block 2 (2 txs), Block 3 (2 txs)
+export const TX_COUNT = 10;
+
+/** The validator cluster + context produced by {@link setupSimpleBlockProduction}. */
+export type SimpleBlockProductionFixture = {
+  test: MultiNodeTestContext;
+  context: EndToEndContext;
+  logger: Logger;
+  validators: RegisteredValidator[];
+  nodes: AztecNodeService[];
+  from: AztecAddress;
+};
+
+/** State shared by the wide-slot `it`s (handles 4 validators + prover + a wallet pointed at node 0). */
+export type BlockProductionWithProverFixture = {
+  test: MultiNodeTestContext;
+  context: EndToEndContext;
+  logger: Logger;
+  rollup: RollupContract;
+  archiver: Archiver;
+  validators: RegisteredValidator[];
+  nodes: AztecNodeService[];
+  contract: TestContract;
+  wallet: TestWallet;
+  from: AztecAddress;
+  failEvents: TrackedSequencerEvent[];
+};
+
+/** Per-validator node config, or a function deriving it from the validator's 0-based index. */
+type ValidatorNodeOpts = Partial<AztecNodeConfig> & { dontStartSequencer?: boolean };
+
+/** Shared spine: builds N mock-gossip validators, sets up the context, spawns one node per validator. */
+async function buildValidatorCluster(opts: {
+  nodeCount: number;
+  setupOpts: Partial<MultiNodeTestOpts>;
+  nodeOpts?: ValidatorNodeOpts | ((index: number) => ValidatorNodeOpts);
+}): Promise<SimpleBlockProductionFixture> {
+  const validators = buildMockGossipValidators(opts.nodeCount);
+
+  const test = await MultiNodeTestContext.setup({
+    ...opts.setupOpts,
+    initialValidators: validators,
+  });
+
+  const { context, logger } = test;
+  const from = context.accounts[0];
+
+  logger.warn(`Initial setup complete. Starting ${opts.nodeCount} validator nodes.`);
+  const nodes = await asyncMap(validators, ({ privateKey }, i) =>
+    test.createValidatorNode(
+      [privateKey],
+      typeof opts.nodeOpts === 'function' ? opts.nodeOpts(i) : { ...opts.nodeOpts },
+    ),
+  );
+  logger.warn(`Started ${opts.nodeCount} validator nodes.`, { validators: validators.map(v => v.attester.toString()) });
+
+  return { test, context, logger, validators, nodes, from };
+}
+
+/**
+ * Stands up the `block-production` validator cluster shared by the `MULTI_VALIDATOR_BLOCK_PRODUCTION_TIMING` tests
+ * (`simple`, `high_tps`): builds `nodeCount` mock-gossip validators, sets up the context with the
+ * block-production timing profile, spawns one validator node per validator, and returns the cluster. The
+ * per-test divergence (`fakeProcessingDelayPerTxMs`, `txDelayerMaxInclusionTimeIntoSlot`,
+ * min/maxTxsPerBlock, whether sequencers start eagerly, contract type) passes through `opts`. Mirrors
+ * how {@link setupBlockProductionWithProver} factors out the prover-backed setup; the test still registers its own contract.
+ */
+export function setupSimpleBlockProduction(opts: {
+  nodeCount: number;
+  setupOpts?: Partial<MultiNodeTestOpts>;
+  nodeOpts?: Partial<AztecNodeConfig> & { dontStartSequencer?: boolean };
+}): Promise<SimpleBlockProductionFixture> {
+  return buildValidatorCluster({
+    nodeCount: opts.nodeCount,
+    setupOpts: { ...MOCK_GOSSIP_MULTI_VALIDATOR_OPTS, ...MULTI_VALIDATOR_BLOCK_PRODUCTION_TIMING, ...opts.setupOpts },
+    nodeOpts: opts.nodeOpts,
+  });
+}
+
+/**
+ * Creates validators and sets up a wide-slot test context with the pipelining timing profile and a prover
+ * node, then starts (paused) validator nodes and points the wallet at node 0. Mirrors the per-test
+ * setup from the dissolved `mbps.parallel` file. The blob-promotion and pipeline-prune suites layer their
+ * adverse-network shape on via `mockGossipSubNetworkLatency`, `maxTxsPerCheckpoint`, `clearInheritedCoinbase`,
+ * and `disableCheckpointPromotionOnFirstNode`.
+ */
+export async function setupBlockProductionWithProver(opts: {
+  syncChainTip: 'proposed' | 'checkpointed';
+  minTxsPerBlock?: number;
+  maxTxsPerBlock?: number;
+  maxTxsPerCheckpoint?: number;
+  buildCheckpointIfEmpty?: boolean;
+  skipPushProposedBlocksToArchiver?: boolean;
+  /** Injects artificial mock-gossip propagation latency (ms) to model adverse network conditions. */
+  mockGossipSubNetworkLatency?: number;
+  /** Clears each validator node's inherited coinbase so it derives one from its own attester key. */
+  clearInheritedCoinbase?: boolean;
+  /**
+   * Disables checkpoint promotion on node 0 (`skipPromoteProposedCheckpointDuringL1Sync`), so node 0 fetches
+   * blobs during L1 sync while its peers promote their own proposed checkpoints and skip the blob fetch.
+   */
+  disableCheckpointPromotionOnFirstNode?: boolean;
+}): Promise<BlockProductionWithProverFixture> {
+  const {
+    syncChainTip = 'checkpointed',
+    clearInheritedCoinbase = false,
+    disableCheckpointPromotionOnFirstNode = false,
+    ...setupOpts
+  } = opts;
+
+  // WIDE_SLOT_TIMING is the wide 72s/12s pipelining cadence (see A-914 on why the tighter 36s/4s breaks
+  // non-proposer nodes); the JSDoc on the profile carries the full rationale.
+  const { test, context, logger, validators, nodes, from } = await buildValidatorCluster({
+    nodeCount: NODE_COUNT,
+    setupOpts: {
+      ...WIDE_SLOT_TIMING,
+      numberOfAccounts: 0,
+      mockGossipSubNetwork: true,
+      startProverNode: true,
+      ...setupOpts,
+      pxeOpts: { syncChainTip },
+      skipInitialSequencer: true,
+      inboxLag: 2,
+    },
+    nodeOpts: (index: number) => ({
+      dontStartSequencer: true,
+      ...(clearInheritedCoinbase ? { coinbase: undefined } : {}),
+      ...(disableCheckpointPromotionOnFirstNode && index === 0
+        ? { skipPromoteProposedCheckpointDuringL1Sync: true }
+        : {}),
+    }),
+  });
+
+  const { rollup } = test;
+  const wallet = context.wallet as TestWallet;
+  const { failEvents } = test.watchNodeSequencerEvents(nodes);
+
+  // Point the wallet at a validator node. The initial node-0 has all validator keys in its config,
+  // so it rejects block proposals from validators thinking they come from itself. By redirecting
+  // the wallet to a validator node, the PXE correctly tracks proposed blocks.
+  wallet.updateNode(nodes[0]);
+  const archiver = nodes[0].getBlockSource() as Archiver;
+
+  // Register contract for sending txs.
+  const contract = await test.registerTestContract(wallet);
+  logger.warn(`Test setup completed.`, { validators: validators.map(v => v.attester.toString()) });
+
+  return { test, context, logger, rollup, archiver, validators, nodes, contract, wallet, from, failEvents };
+}
+
+/** Waits until a specific multi-block checkpoint is proven, verifying that proving succeeds with multiple-blocks-per-slot. */
+export async function waitForProvenCheckpoint(
+  fixture: BlockProductionWithProverFixture,
+  targetCheckpoint: CheckpointNumber,
+) {
+  const { test, nodes, logger, failEvents } = fixture;
+  test.assertNoFailuresFromSequencers(failEvents);
+
+  logger.warn(`Stopping validator sequencers before waiting for checkpoint ${targetCheckpoint} to be proven`);
+  await Promise.all(nodes.map(n => n.getSequencer()?.stop()));
+
+  // With the sequencers stopped, no further blocks are produced, so waiting out the rest of the epoch in
+  // wall-clock is dead time. Warp the L1 clock forward past the epoch boundary so the epoch containing
+  // targetCheckpoint closes and the fake prover can prove+submit it; the subsequent wait then only covers
+  // the (real-time) proving+submission. A single next-epoch jump stays inside the proof-submission window
+  // (proofSubmissionEpochs >= 1), so it never crosses the submission deadline. Skipped if already proven,
+  // and forward-only since advanceToNextEpoch never rewinds.
+  const { proven } = await test.context.cheatCodes.rollup.getTips();
+  if (proven < targetCheckpoint) {
+    await testSpan('warp:proven-checkpoint-epoch', () => test.context.cheatCodes.rollup.advanceToNextEpoch());
+  }
+
+  const provenTimeout = test.L2_SLOT_DURATION_IN_S * test.epochDuration * 4;
+  logger.warn(`Waiting for checkpoint ${targetCheckpoint} to be proven (timeout=${provenTimeout}s)`);
+  await test.waitUntilProvenCheckpointNumber(targetCheckpoint, provenTimeout);
+  logger.warn(`Proven checkpoint advanced to ${test.monitor.provenCheckpointNumber}`);
+}
+
+export {
+  type Archiver,
+  type AztecNodeConfig,
+  type AztecNodeService,
+  AztecAddress,
+  EthAddress,
+  NO_WAIT,
+  generateClaimSecret,
+  Fr,
+  type Logger,
+  isL1ToL2MessageReady,
+  waitForTx,
+  RollupContract,
+  waitUntilL1Timestamp,
+  asyncMap,
+  BlockNumber,
+  CheckpointNumber,
+  SlotNumber,
+  timesAsync,
+  retryUntil,
+  sleep,
+  executeTimeout,
+  TestContract,
+  type SequencerEvents,
+  getSlotAtTimestamp,
+  getTimestampForSlot,
+  GasFees,
+  TxStatus,
+  jest,
+  sendL1ToL2Message,
+  type EndToEndContext,
+  waitForBlockNumber,
+  waitForTxs,
+  type TestWallet,
+  proveInteraction,
+  type BlockProposedEvent,
+  WIDE_SLOT_TIMING,
+  MULTI_VALIDATOR_BLOCK_PRODUCTION_TIMING,
+  MultiNodeTestContext,
+  type RegisteredValidator,
+  type TrackedSequencerEvent,
+  buildMockGossipValidators,
+};

package/src/multi-node/governance/setup.ts

@@ -0,0 +1,172 @@
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { retryUntil } from '@aztec/foundation/retry';
+import { GovernanceAbi, GovernanceProposerAbi } from '@aztec/l1-artifacts';
+
+import { jest } from '@jest/globals';
+import { type GetContractReturnType, encodeFunctionData, getAddress, getContract } from 'viem';
+
+import type { MultiNodeTestContext } from '../multi_node_test_context.js';
+
+jest.setTimeout(1000 * 60 * 10);
+
+/**
+ * The shortened block-time timing the governance tests run on: a 12s L2 slot, 4s L1 slot, and a long
+ * proof-submission window so unproven blocks are never pruned (the committee runs no prover). Spread into
+ * a {@link MultiNodeTestContext.setup} call alongside {@link MOCK_GOSSIP_MULTI_VALIDATOR_OPTS} and
+ * `initialValidators`.
+ */
+export const GOVERNANCE_TIMING = {
+  aztecSlotDuration: 12,
+  ethereumSlotDuration: 4,
+  aztecProofSubmissionEpochs: 640,
+} as const;
+
+/** The current round leader's payload and its signal count, as observed by {@link GovernanceTestDriver.govInfo}. */
+type GovRoundState = { round: bigint; leaderVotes: bigint };
+
+/**
+ * Wraps the L1 governance-proposer / governance / rollup contracts and the round-driving mechanics shared by
+ * the governance suites (`add_rollup`, `upgrade_governance_proposer`): warping to round boundaries, polling
+ * round state, waiting for signal quorum, submitting the round winner, and voting a proposal through to
+ * executable. Scenario-specific payload construction, node signaling, and post-execution assertions stay in
+ * each test.
+ */
+export interface GovernanceTestDriver {
+  governanceProposer: GetContractReturnType<typeof GovernanceProposerAbi, ExtendedViemWalletClient>;
+  governance: GetContractReturnType<typeof GovernanceAbi, ExtendedViemWalletClient>;
+  rollup: RollupContract;
+  roundSize: bigint;
+  emperor: ExtendedViemWalletClient['account'];
+  /** Sends a 1-wei self-transfer to mine a fresh L1 block, so warped time takes effect. */
+  waitL1Block: () => Promise<void>;
+  /** Reads the current round's leading payload and its signal count. */
+  govInfo: () => Promise<GovRoundState>;
+  /** Warps L1 to the start of the next governance-proposer round. */
+  warpToNextRound: () => Promise<void>;
+  /** Polls once per L2 slot until the round leader reaches quorum, returning the round state at that point. */
+  waitForQuorum: (quorumSize: bigint, timeoutSeconds: number) => Promise<GovRoundState>;
+  /** Submits the winning payload of `round` to the governance proposer, creating the on-chain proposal. */
+  submitRoundWinner: (round: bigint) => Promise<void>;
+  /**
+   * Warps past the proposal's voting delay, casts a yes vote (asserting it lands), then warps past the
+   * voting duration and execution delay so the proposal becomes executable.
+   */
+  voteToExecutable: () => Promise<void>;
+}
+
+/** Builds a {@link GovernanceTestDriver} over the context's L1 governance contracts. */
+export async function createGovernanceTestDriver(
+  test: MultiNodeTestContext,
+  l1TxUtils: L1TxUtils,
+): Promise<GovernanceTestDriver> {
+  const { l1Client, l1ContractAddresses } = test.context.deployL1ContractsValues;
+  const rollupAddress = l1ContractAddresses.rollupAddress.toString();
+
+  const governanceProposer = getContract({
+    address: getAddress(l1ContractAddresses.governanceProposerAddress.toString()),
+    abi: GovernanceProposerAbi,
+    client: l1Client,
+  });
+  const governance = getContract({
+    address: getAddress(l1ContractAddresses.governanceAddress.toString()),
+    abi: GovernanceAbi,
+    client: l1Client,
+  });
+  const rollup = new RollupContract(l1Client, l1ContractAddresses.rollupAddress);
+  const roundSize = await governanceProposer.read.ROUND_SIZE();
+  const emperor = l1Client.account;
+
+  const waitL1Block = async () => {
+    await l1TxUtils.sendAndMonitorTransaction({ to: emperor.address, value: 1n });
+  };
+
+  const govInfo = async (): Promise<GovRoundState> => {
+    const bn = await test.context.cheatCodes.eth.blockNumber();
+    const slot = await rollup.getSlotNumber();
+    const round = await governanceProposer.read.computeRound([BigInt(slot)]);
+    const info = await governanceProposer.read.getRoundData([rollupAddress, round]);
+    const leaderVotes = await governanceProposer.read.signalCount([rollupAddress, round, info.payloadWithMostSignals]);
+    test.logger.info(
+      `Governance stats for round ${round} (Slot: ${slot}, BN: ${bn}). Leader: ${info.payloadWithMostSignals} have ${leaderVotes} signals`,
+    );
+    return { round, leaderVotes };
+  };
+
+  const warpToNextRound = async () => {
+    const currentSlot = await rollup.getSlotNumber();
+    const nextRoundSlot = SlotNumber.fromBigInt((BigInt(currentSlot) / roundSize) * roundSize + roundSize);
+    const nextRoundTimestamp = await rollup.getTimestampForSlot(nextRoundSlot);
+    await test.context.cheatCodes.eth.warp(Number(nextRoundTimestamp));
+  };
+
+  const waitForQuorum = (quorumSize: bigint, timeoutSeconds: number) =>
+    retryUntil(
+      async () => {
+        const data = await govInfo();
+        return data.leaderVotes >= quorumSize ? data : undefined;
+      },
+      'governance leader reaches quorum',
+      timeoutSeconds,
+      GOVERNANCE_TIMING.aztecSlotDuration,
+    );
+
+  const submitRoundWinner = async (round: bigint) => {
+    await l1TxUtils.sendAndMonitorTransaction({
+      to: governanceProposer.address,
+      data: encodeFunctionData({ abi: GovernanceProposerAbi, functionName: 'submitRoundWinner', args: [round] }),
+    });
+  };
+
+  const voteToExecutable = async () => {
+    const proposal = await governance.read.getProposal([0n]);
+
+    const timeToActive = proposal.creation + proposal.config.votingDelay;
+    await test.context.cheatCodes.eth.warp(Number(timeToActive + 1n));
+    await waitL1Block();
+
+    const voteTx = await rollup.vote(l1TxUtils, 0n);
+    expect(voteTx.receipt?.status).toBe('success');
+
+    const timeToExecutable = timeToActive + proposal.config.votingDuration + proposal.config.executionDelay + 1n;
+    await test.context.cheatCodes.eth.warp(Number(timeToExecutable));
+    await waitL1Block();
+  };
+
+  return {
+    governanceProposer,
+    governance,
+    rollup,
+    roundSize,
+    emperor,
+    waitL1Block,
+    govInfo,
+    warpToNextRound,
+    waitForQuorum,
+    submitRoundWinner,
+    voteToExecutable,
+  };
+}
+
+/**
+ * Drives one governance round to an executable proposal: waits for the signaled payload to reach quorum,
+ * warps to the next round, submits the round winner, then votes the resulting proposal through its voting
+ * and execution delays. Returns the round state observed at quorum; the caller performs the scenario-specific
+ * execution and assertions.
+ */
+export async function driveGovernanceRound(
+  driver: GovernanceTestDriver,
+  opts: { quorumTimeoutSeconds: number },
+): Promise<{ govData: GovRoundState }> {
+  const quorumSize = await driver.governanceProposer.read.QUORUM_SIZE();
+  const govData = await driver.waitForQuorum(quorumSize, opts.quorumTimeoutSeconds);
+  await driver.warpToNextRound();
+  await driver.waitL1Block();
+  await driver.submitRoundWinner(govData.round);
+  await driver.voteToExecutable();
+  return { govData };
+}
+
+export { jest };