@aztec/end-to-end 0.0.1-commit.b6e433891 → 0.0.1-commit.b8a057fa

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -1,179 +0,0 @@
-import type { AztecNodeService } from '@aztec/aztec-node';
-import { EthAddress } from '@aztec/aztec.js/addresses';
-import { RollupContract } from '@aztec/ethereum/contracts';
-import { EpochNumber } from '@aztec/foundation/branded-types';
-
-import fs from 'fs';
-import 'jest-extended';
-import os from 'os';
-import path from 'path';
-
-import { createNodes } from '../fixtures/setup_p2p_test.js';
-import { P2PNetworkTest } from './p2p_network.js';
-
-const NUM_NODES = 6;
-const NUM_VALIDATORS = NUM_NODES;
-const COMMITTEE_SIZE = NUM_VALIDATORS;
-const SLASHING_QUORUM = 3;
-const EPOCH_DURATION = 2;
-const SLASHING_ROUND_SIZE_IN_EPOCHS = 2;
-const BOOT_NODE_UDP_PORT = 4500;
-const ETHEREUM_SLOT_DURATION = process.env.CI ? 8 : 4;
-const AZTEC_SLOT_DURATION = ETHEREUM_SLOT_DURATION * 2;
-const SLASHING_UNIT = BigInt(1e18);
-const SLASHING_AMOUNT = SLASHING_UNIT * 3n;
-
-// How many epochs it may take to set everything up, so we dont slash during this period
-const SETUP_EPOCH_DURATION = 8;
-
-export class P2PInactivityTest {
-  public nodes!: AztecNodeService[];
-  public activeNodes!: AztecNodeService[];
-  public inactiveNodes!: AztecNodeService[];
-
-  public rollup!: RollupContract;
-  public offlineValidators!: EthAddress[];
-
-  private dataDir: string;
-  private inactiveNodeCount: number;
-  private keepInitialNode: boolean;
-
-  constructor(
-    public readonly test: P2PNetworkTest,
-    opts: { inactiveNodeCount: number; keepInitialNode?: boolean },
-  ) {
-    this.dataDir = fs.mkdtempSync(path.join(os.tmpdir(), test.testName));
-    this.inactiveNodeCount = opts.inactiveNodeCount;
-    this.keepInitialNode = opts.keepInitialNode ?? false;
-  }
-
-  static async create(
-    testName: string,
-    opts: { slashInactivityConsecutiveEpochThreshold: number; inactiveNodeCount: number; keepInitialNode?: boolean },
-  ) {
-    const test = await P2PNetworkTest.create({
-      testName,
-      numberOfNodes: 0,
-      numberOfValidators: NUM_VALIDATORS,
-      basePort: BOOT_NODE_UDP_PORT,
-      startProverNode: true,
-      initialConfig: {
-        proverNodeConfig: { proverNodeEpochProvingDelayMs: AZTEC_SLOT_DURATION * 1000 },
-        aztecTargetCommitteeSize: COMMITTEE_SIZE,
-        aztecSlotDuration: AZTEC_SLOT_DURATION,
-        ethereumSlotDuration: ETHEREUM_SLOT_DURATION,
-        aztecProofSubmissionEpochs: 1024, // effectively do not reorg
-        listenAddress: '127.0.0.1',
-        minTxsPerBlock: 0,
-        aztecEpochDuration: EPOCH_DURATION,
-        validatorReexecute: false,
-        sentinelEnabled: true,
-        slashingQuorum: SLASHING_QUORUM,
-        slashingRoundSizeInEpochs: SLASHING_ROUND_SIZE_IN_EPOCHS,
-        slashInactivityTargetPercentage: 0.8,
-        slashGracePeriodL2Slots: SETUP_EPOCH_DURATION * EPOCH_DURATION, // do not slash during setup
-        slashAmountSmall: SLASHING_UNIT,
-        slashAmountMedium: SLASHING_UNIT * 2n,
-        slashAmountLarge: SLASHING_UNIT * 3n,
-        ...opts,
-      },
-    });
-    return new P2PInactivityTest(test, opts);
-  }
-
-  public async setup() {
-    await this.test.setup();
-    await this.test.applyBaseSetup();
-
-    // Set slashing penalties for inactivity
-    const { rollup } = await this.test.getContracts();
-    const [activationThreshold, ejectionThreshold, localEjectionThreshold] = await Promise.all([
-      rollup.getActivationThreshold(),
-      rollup.getEjectionThreshold(),
-      rollup.getLocalEjectionThreshold(),
-    ]);
-    const biggestEjection = ejectionThreshold > localEjectionThreshold ? ejectionThreshold : localEjectionThreshold;
-    expect(activationThreshold - SLASHING_AMOUNT).toBeLessThan(biggestEjection);
-    this.test.ctx.aztecNodeConfig.slashInactivityPenalty = SLASHING_AMOUNT;
-    this.rollup = rollup;
-
-    if (!this.keepInitialNode) {
-      await this.test.ctx.aztecNodeService.stop();
-    }
-
-    // Create all active nodes
-    this.activeNodes = await createNodes(
-      this.test.ctx.aztecNodeConfig,
-      this.test.ctx.dateProvider,
-      this.test.bootstrapNodeEnr,
-      NUM_NODES - this.inactiveNodeCount - Number(this.keepInitialNode),
-      BOOT_NODE_UDP_PORT,
-      this.test.prefilledPublicData,
-      this.dataDir,
-      undefined,
-      Number(this.keepInitialNode),
-    );
-
-    // And the ones with an initially disabled sequencer
-    const inactiveConfig = { ...this.test.ctx.aztecNodeConfig, dontStartSequencer: true };
-    this.inactiveNodes = await createNodes(
-      inactiveConfig,
-      this.test.ctx.dateProvider,
-      this.test.bootstrapNodeEnr,
-      this.inactiveNodeCount,
-      BOOT_NODE_UDP_PORT,
-      this.test.prefilledPublicData,
-      this.dataDir,
-      undefined,
-      NUM_NODES - this.inactiveNodeCount,
-    );
-
-    this.nodes = [
-      ...(this.keepInitialNode ? [this.test.ctx.aztecNodeService] : []),
-      ...this.activeNodes,
-      ...this.inactiveNodes,
-    ];
-
-    if (this.nodes.length !== NUM_NODES) {
-      throw new Error(`Expected ${NUM_NODES} nodes but got ${this.nodes.length}`);
-    }
-
-    this.offlineValidators = this.test.validators
-      .slice(this.test.validators.length - this.inactiveNodeCount)
-      .map(a => a.attester);
-
-    this.test.logger.warn(`Setup complete. Offline validators are ${this.offlineValidators.join(', ')}.`, {
-      validators: this.test.validators,
-      offlineValidators: this.offlineValidators,
-    });
-
-    // Wait for P2P mesh to be fully formed before starting slashing period
-    // This prevents race conditions where validators propose blocks before the network is ready
-    await this.test.waitForP2PMeshConnectivity(this.nodes, NUM_NODES);
-
-    this.test.logger.warn(`Advancing to epoch ${SETUP_EPOCH_DURATION - 1} (slashing will start after it is completed)`);
-    await this.test.ctx.cheatCodes.rollup.advanceToEpoch(EpochNumber(SETUP_EPOCH_DURATION - 1));
-
-    return this;
-  }
-
-  public async teardown() {
-    await this.test.stopNodes(this.nodes);
-    await this.test.teardown();
-    for (let i = 0; i < NUM_NODES; i++) {
-      fs.rmSync(`${this.dataDir}-${i}`, { recursive: true, force: true, maxRetries: 3 });
-    }
-  }
-
-  public get ctx() {
-    return this.test.ctx;
-  }
-
-  public get logger() {
-    return this.test.logger;
-  }
-
-  public get slashingAmount() {
-    return SLASHING_AMOUNT;
-  }
-}

package/src/e2e_p2p/shared.ts

@@ -1,343 +0,0 @@
-import type { InitialAccountData } from '@aztec/accounts/testing';
-import type { AztecNodeService } from '@aztec/aztec-node';
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { NO_WAIT, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
-import { Fr } from '@aztec/aztec.js/fields';
-import type { Logger } from '@aztec/aztec.js/log';
-import { TxHash } from '@aztec/aztec.js/tx';
-import type { RollupCheatCodes } from '@aztec/aztec/testing';
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import type {
-  EmpireSlashingProposerContract,
-  RollupContract,
-  TallySlashingProposerContract,
-} from '@aztec/ethereum/contracts';
-import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
-import { timesAsync, unique } from '@aztec/foundation/collection';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { retryUntil } from '@aztec/foundation/retry';
-import { pluralize } from '@aztec/foundation/string';
-import type { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
-import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.js/Test';
-import { getPXEConfig, getPXEConfig as getRpcConfig } from '@aztec/pxe/server';
-import { getRoundForOffense } from '@aztec/slasher';
-import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import type { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
-
-import { submitTxsTo } from '../shared/submit-transactions.js';
-import { TestWallet } from '../test-wallet/test_wallet.js';
-import { type ProvenTx, proveInteraction } from '../test-wallet/utils.js';
-
-// submits a set of transactions to the provided Private eXecution Environment (PXE)
-export const submitComplexTxsTo = async (
-  logger: Logger,
-  from: AztecAddress,
-  spamContract: SpamContract,
-  numTxs: number,
-  opts: { callPublic?: boolean } = {},
-) => {
-  const txs: TxHash[] = [];
-
-  const seed = 1234n;
-  const spamCount = 15;
-  for (let i = 0; i < numTxs; i++) {
-    const method = spamContract.methods.spam(seed + BigInt(i * spamCount), spamCount, !!opts.callPublic);
-    const { txHash } = await method.send({ from, wait: NO_WAIT });
-    logger.info(`Tx sent with hash ${txHash.toString()}`);
-    txs.push(txHash);
-  }
-  return txs;
-};
-
-// creates a wallet and submit a given number of transactions through it.
-export const submitTransactions = async (
-  logger: Logger,
-  node: AztecNodeService,
-  numTxs: number,
-  fundedAccount: InitialAccountData,
-): Promise<TxHash[]> => {
-  const rpcConfig = getRpcConfig();
-  rpcConfig.proverEnabled = false;
-  const wallet = await TestWallet.create(
-    node,
-    { ...getPXEConfig(), proverEnabled: false },
-    { loggerActorLabel: 'pxe-tx' },
-  );
-  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
-  return submitTxsTo(wallet, fundedAccountManager.address, numTxs, logger);
-};
-
-export async function prepareTransactions(
-  logger: Logger,
-  node: AztecNodeService,
-  numTxs: number,
-  fundedAccount: InitialAccountData,
-): Promise<ProvenTx[]> {
-  const rpcConfig = getRpcConfig();
-  rpcConfig.proverEnabled = false;
-
-  const wallet = await TestWallet.create(
-    node,
-    { ...getPXEConfig(), proverEnabled: false },
-    { loggerActorLabel: 'pxe-tx' },
-  );
-  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
-
-  const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {
-    salt: Fr.random(),
-  });
-  await wallet.registerContract(testContractInstance, TestContractArtifact);
-  const contract = TestContract.at(testContractInstance.address, wallet);
-
-  return timesAsync(numTxs, async () => {
-    const tx = await proveInteraction(wallet, contract.methods.emit_nullifier(Fr.random()), {
-      from: fundedAccountManager.address,
-    });
-    logger.info(`Tx prepared with hash ${tx.getTxHash()}`);
-    return tx;
-  });
-}
-
-export function awaitProposalExecution(
-  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract,
-  timeoutSeconds: number,
-  logger: Logger,
-): Promise<bigint> {
-  return new Promise<bigint>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      logger.warn(`Timed out waiting for proposal execution`);
-      reject(new Error(`Timeout waiting for proposal execution after ${timeoutSeconds}s`));
-    }, timeoutSeconds * 1000);
-
-    if (slashingProposer.type === 'empire') {
-      const unwatch = slashingProposer.listenToPayloadSubmitted(args => {
-        logger.warn(`Proposal ${args.payload} from round ${args.round} executed`);
-        clearTimeout(timeout);
-        unwatch();
-        resolve(args.round);
-      });
-    } else if (slashingProposer.type === 'tally') {
-      const unwatch = slashingProposer.listenToRoundExecuted(args => {
-        logger.warn(`Slash from round ${args.round} executed`);
-        clearTimeout(timeout);
-        unwatch();
-        resolve(args.round);
-      });
-    } else {
-      clearTimeout(timeout);
-      reject(new Error(`Unknown slashing proposer type: ${(slashingProposer as any).type}`));
-    }
-  });
-}
-
-export async function awaitCommitteeExists({
-  rollup,
-  logger,
-}: {
-  rollup: RollupContract;
-  logger: Logger;
-}): Promise<readonly `0x${string}`[]> {
-  logger.info(`Waiting for committee to be set`);
-  let committee: EthAddress[] | undefined;
-  await retryUntil(
-    async () => {
-      committee = await rollup.getCurrentEpochCommittee();
-      return committee && committee.length > 0;
-    },
-    'non-empty committee',
-    60,
-  );
-  logger.warn(`Committee has been formed`, { committee: committee!.map(c => c.toString()) });
-  return committee!.map(c => c.toString() as `0x${string}`);
-}
-
-/**
- * Advance epochs until we find one where the target proposer is selected for at least one slot,
- * then stop one epoch before it. This leaves time for the caller to start sequencers before
- * warping to the target epoch, avoiding the race where the target epoch passes before sequencers
- * are ready.
- *
- * Returns the target epoch number so the caller can warp to it after starting sequencers.
- */
-export async function advanceToEpochBeforeProposer({
-  epochCache,
-  cheatCodes,
-  targetProposer,
-  logger,
-  maxAttempts = 20,
-}: {
-  epochCache: EpochCacheInterface;
-  cheatCodes: RollupCheatCodes;
-  targetProposer: EthAddress;
-  logger: Logger;
-  maxAttempts?: number;
-}): Promise<{ targetEpoch: EpochNumber }> {
-  const { epochDuration } = await cheatCodes.getConfig();
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const currentEpoch = await cheatCodes.getEpoch();
-    // Check the NEXT epoch's slots so we stay one epoch before the target,
-    // giving the caller time to start sequencers before the target epoch arrives.
-    const nextEpoch = Number(currentEpoch) + 1;
-    const startSlot = nextEpoch * Number(epochDuration);
-    const endSlot = startSlot + Number(epochDuration);
-
-    logger.info(
-      `Checking next epoch ${nextEpoch} (slots ${startSlot}-${endSlot - 1}) for proposer ${targetProposer} (current epoch: ${currentEpoch})`,
-    );
-
-    for (let s = startSlot; s < endSlot; s++) {
-      const proposer = await epochCache.getProposerAttesterAddressInSlot(SlotNumber(s));
-      if (proposer && proposer.equals(targetProposer)) {
-        logger.warn(
-          `Found target proposer ${targetProposer} in slot ${s} of epoch ${nextEpoch}. Staying at epoch ${currentEpoch} to allow sequencer startup.`,
-        );
-        return { targetEpoch: EpochNumber(nextEpoch) };
-      }
-    }
-
-    logger.info(`Target proposer not found in epoch ${nextEpoch}, advancing to next epoch`);
-    await cheatCodes.advanceToNextEpoch();
-  }
-
-  throw new Error(`Target proposer ${targetProposer} not found in any slot after ${maxAttempts} epoch attempts`);
-}
-
-export async function awaitOffenseDetected({
-  logger,
-  nodeAdmin,
-  slashingRoundSize,
-  epochDuration,
-  waitUntilOffenseCount,
-  timeoutSeconds = 120,
-}: {
-  nodeAdmin: AztecNodeAdmin;
-  logger: Logger;
-  slashingRoundSize: number;
-  epochDuration: number;
-  waitUntilOffenseCount?: number;
-  timeoutSeconds?: number;
-}) {
-  const targetOffenseCount = waitUntilOffenseCount ?? 1;
-  logger.warn(`Waiting for ${pluralize('offense', targetOffenseCount)} to be detected`);
-  const offenses = await retryUntil(
-    async () => {
-      const offenses = await nodeAdmin.getSlashOffenses('all');
-      if (offenses.length >= targetOffenseCount) {
-        return offenses;
-      }
-    },
-    'non-empty offenses',
-    timeoutSeconds,
-  );
-  logger.info(
-    `Hit ${offenses.length} offenses on rounds ${unique(offenses.map(o => getRoundForOffense(o, { slashingRoundSize, epochDuration })))}`,
-    { offenses },
-  );
-  return offenses;
-}
-
-/**
- * Await the committee to be slashed out of the validator set.
- * Currently assumes that the committee is the same size as the validator set.
- */
-export async function awaitCommitteeKicked({
-  rollup,
-  cheatCodes,
-  committee,
-  slashFactory,
-  slashingProposer,
-  slashingRoundSize,
-  aztecSlotDuration,
-  aztecEpochDuration,
-  logger,
-  offenseEpoch,
-}: {
-  rollup: RollupContract;
-  cheatCodes: RollupCheatCodes;
-  committee: readonly `0x${string}`[];
-  slashFactory: SlashFactoryContract;
-  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
-  slashingRoundSize: number;
-  aztecSlotDuration: number;
-  aztecEpochDuration: number;
-  logger: Logger;
-  offenseEpoch: number;
-}) {
-  if (!slashingProposer) {
-    throw new Error('No slashing proposer configured. Cannot test slashing.');
-  }
-
-  await cheatCodes.debugRollup();
-
-  if (slashingProposer.type === 'empire') {
-    // Await for the slash payload to be created if empire (no payload is created on tally until execution time)
-    const targetEpoch = EpochNumber((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1);
-    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(targetEpoch);
-
-    const slashPayloadEvents = await retryUntil(
-      async () => {
-        const events = await slashFactory.getSlashPayloadCreatedEvents();
-        return events.length > 0 ? events : undefined;
-      },
-      'slash payload created',
-      120,
-      1,
-    );
-    expect(slashPayloadEvents.length).toBe(1);
-    // The uniqueness check is needed since a validator may be slashed more than once on the same round (eg because they let two epochs be pruned)
-    expect(unique(slashPayloadEvents[0].slashes.map(slash => slash.validator.toString()))).toHaveLength(
-      committee.length,
-    );
-  } else {
-    // Use the slash offset to ensure we are in the right epoch for tally
-    const slashOffsetInRounds = await slashingProposer.getSlashOffsetInRounds();
-    const slashingRoundSizeInEpochs = slashingRoundSize / aztecEpochDuration;
-    const slashingOffsetInEpochs = Number(slashOffsetInRounds) * slashingRoundSizeInEpochs;
-    const firstEpochInOffenseRound = offenseEpoch - (offenseEpoch % slashingRoundSizeInEpochs);
-    const targetEpoch = firstEpochInOffenseRound + slashingOffsetInEpochs;
-    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(EpochNumber(targetEpoch), { offset: -aztecSlotDuration / 2 });
-  }
-
-  const attestersPre = await rollup.getAttesters();
-  expect(attestersPre.length).toBe(committee.length);
-
-  for (const attester of attestersPre) {
-    const attesterInfo = await rollup.getAttesterView(attester);
-    expect(attesterInfo.status).toEqual(1); // Validating
-  }
-
-  const timeout = slashingRoundSize * 2 * aztecSlotDuration + 30;
-  logger.info(`Waiting for slash to be executed (timeout ${timeout}s)`);
-  await awaitProposalExecution(slashingProposer, timeout, logger);
-
-  // The attesters should still form the committee but they should be reduced to the "living" status
-  await cheatCodes.debugRollup();
-  const committeePostSlashing = await rollup.getCurrentEpochCommittee();
-  expect(committeePostSlashing?.length).toBe(attestersPre.length);
-
-  const attestersPostSlashing = await rollup.getAttesters();
-  expect(attestersPostSlashing.length).toBe(0);
-
-  for (const attester of attestersPre) {
-    const attesterInfo = await rollup.getAttesterView(attester);
-    expect(attesterInfo.status).toEqual(2); // Living
-  }
-
-  logger.info(`Advancing to check current committee`);
-  await cheatCodes.debugRollup();
-  await cheatCodes.advanceToEpoch(
-    EpochNumber((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1),
-  );
-  await cheatCodes.debugRollup();
-
-  const committeeNextEpoch = await rollup.getCurrentEpochCommittee();
-  // The committee should be undefined, since the validator set is empty
-  // and the tests currently using this helper always set a target committee size.
-  expect(committeeNextEpoch).toBeUndefined();
-
-  const attestersNextEpoch = await rollup.getAttesters();
-  expect(attestersNextEpoch.length).toBe(0);
-}