@aztec/end-to-end 3.0.0-canary.a9708bd → 3.0.0-devnet.20251212

package/src/e2e_nested_contract/nested_contract_test.ts

@@ -1,5 +1,7 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { type AccountWallet, AztecAddress, type Logger, type PXE, createLogger } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import { ChildContract } from '@aztec/noir-test-contracts.js/Child';
 import { ParentContract } from '@aztec/noir-test-contracts.js/Parent';
 
@@ -16,9 +18,9 @@ const { E2E_DATA_PATH: dataPath } = process.env;
 export class NestedContractTest {
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallet!: AccountWallet;
+  wallet!: Wallet;
   defaultAccountAddress!: AztecAddress;
-  pxe!: PXE;
+  aztecNode!: AztecNode;
 
   parentContract!: ParentContract;
   childContract!: ChildContract;
@@ -40,12 +42,11 @@ export class NestedContractTest {
     await this.snapshotManager.snapshot(
       'accounts',
       deployAccounts(this.numberOfAccounts, this.logger),
-      async ({ deployedAccounts }, { pxe }) => {
-        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-        [this.wallet] = wallets;
-        this.defaultAccountAddress = this.wallet.getAddress();
-        this.pxe = pxe;
+      ({ deployedAccounts }, { wallet, aztecNode }) => {
+        this.wallet = wallet;
+        [{ address: this.defaultAccountAddress }] = deployedAccounts;
+        this.aztecNode = aztecNode;
+        return Promise.resolve();
       },
     );
 
@@ -85,9 +86,10 @@ export class NestedContractTest {
           .deployed();
         return { parentContractAddress: parentContract.address, childContractAddress: childContract.address };
       },
-      async ({ parentContractAddress, childContractAddress }) => {
-        this.parentContract = await ParentContract.at(parentContractAddress, this.wallet);
-        this.childContract = await ChildContract.at(childContractAddress, this.wallet);
+      ({ parentContractAddress, childContractAddress }) => {
+        this.parentContract = ParentContract.at(parentContractAddress, this.wallet);
+        this.childContract = ChildContract.at(childContractAddress, this.wallet);
+        return Promise.resolve();
       },
     );
   }

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -0,0 +1,184 @@
+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 = 5;
+
+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.applyBaseSnapshots();
+    await this.test.setup();
+
+    // 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.aztecNode.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.aztecNode] : []),
+      ...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);
+
+    const ethereumSlotDuration = this.test.ctx.aztecNodeConfig.ethereumSlotDuration!;
+    this.test.logger.warn(
+      `Advancing to epoch ${SETUP_EPOCH_DURATION} (slashing will start after this epoch is complete)`,
+    );
+    await this.test.ctx.cheatCodes.rollup.advanceToEpoch(EpochNumber(SETUP_EPOCH_DURATION), {
+      offset: -ethereumSlotDuration,
+    });
+
+    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/p2p_network.ts

@@ -1,23 +1,24 @@
-import { getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
-import { type AccountWalletWithSecretKey, AztecAddress, EthAddress, Fr } from '@aztec/aztec.js';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
 import {
   type EmpireSlashingProposerContract,
-  type ExtendedViemWalletClient,
   GSEContract,
-  MultiAdderArtifact,
-  type Operator,
   RollupContract,
   type TallySlashingProposerContract,
-  type ViemClient,
-  createL1TxUtilsFromViemWallet,
-  deployL1Contract,
-  getL1ContractsConfigEnvVars,
-} from '@aztec/ethereum';
+} from '@aztec/ethereum/contracts';
+import type { Operator } from '@aztec/ethereum/deploy-l1-contracts';
+import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contracts';
+import { MultiAdderArtifact } from '@aztec/ethereum/l1-artifacts';
+import { createL1TxUtilsFromViemWallet } from '@aztec/ethereum/l1-tx-utils';
 import { ChainMonitor } from '@aztec/ethereum/test';
+import type { ExtendedViemWalletClient, ViemClient } from '@aztec/ethereum/types';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import { RollupAbi, SlasherAbi, TestERC20Abi } from '@aztec/l1-artifacts';
 import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import type { BootstrapNode } from '@aztec/p2p/bootstrap';
@@ -26,6 +27,7 @@ import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
+import type { TestWallet } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import getPort from 'get-port';
@@ -43,7 +45,7 @@ import {
   createSnapshotManager,
   deployAccounts,
 } from '../fixtures/snapshot_manager.js';
-import { getPrivateKeyFromIndex, getSponsoredFPCAddress } from '../fixtures/utils.js';
+import { type SetupOptions, getPrivateKeyFromIndex, getSponsoredFPCAddress } from '../fixtures/utils.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
 
 // Use a fixed bootstrap node private key so that we can re-use the same snapshot and the nodes can find each other
@@ -75,18 +77,18 @@ export class P2PNetworkTest {
   public prefilledPublicData: PublicDataTreeLeaf[] = [];
 
   // The re-execution test needs a wallet and a spam contract
-  public wallet?: AccountWalletWithSecretKey;
+  public wallet?: TestWallet;
   public defaultAccountAddress?: AztecAddress;
   public spamContract?: SpamContract;
 
   public bootstrapNode?: BootstrapNode;
 
   constructor(
-    testName: string,
+    public readonly testName: string,
     public bootstrapNodeEnr: string,
     public bootNodePort: number,
     public numberOfValidators: number,
-    initialValidatorConfig: AztecNodeConfig,
+    initialValidatorConfig: SetupOptions,
     public numberOfNodes = 0,
     // If set enable metrics collection
     private metricsPort?: number,
@@ -162,7 +164,7 @@ export class P2PNetworkTest {
     numberOfValidators: number;
     basePort?: number;
     metricsPort?: number;
-    initialConfig?: Partial<AztecNodeConfig>;
+    initialConfig?: SetupOptions;
     startProverNode?: boolean;
     mockZkPassportVerifier?: boolean;
   }) {
@@ -198,7 +200,7 @@ export class P2PNetworkTest {
 
   async addBootstrapNode() {
     await this.snapshotManager.snapshot('add-bootstrap-node', async ({ aztecNodeConfig }) => {
-      const telemetry = getEndToEndTestTelemetryClient(this.metricsPort);
+      const telemetry = await getEndToEndTestTelemetryClient(this.metricsPort);
       this.bootstrapNode = await createBootstrapNodeFromPrivateKey(
         BOOTSTRAP_NODE_PRIVATE_KEY,
         this.bootNodePort,
@@ -230,88 +232,85 @@ export class P2PNetworkTest {
 
   async applyBaseSnapshots() {
     await this.addBootstrapNode();
-    await this.snapshotManager.snapshot(
-      'add-validators',
-      async ({ deployL1ContractsValues, dateProvider, cheatCodes }) => {
-        const rollup = getContract({
-          address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
-          abi: RollupAbi,
-          client: deployL1ContractsValues.l1Client,
-        });
+    await this.snapshotManager.snapshot('add-validators', async ({ deployL1ContractsValues, cheatCodes }) => {
+      const rollup = getContract({
+        address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
+        abi: RollupAbi,
+        client: deployL1ContractsValues.l1Client,
+      });
 
-        this.logger.info(`Adding ${this.numberOfValidators} validators`);
+      this.logger.info(`Adding ${this.numberOfValidators} validators`);
 
-        const stakingAsset = getContract({
-          address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
-          abi: TestERC20Abi,
-          client: deployL1ContractsValues.l1Client,
-        });
+      const stakingAsset = getContract({
+        address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
+        abi: TestERC20Abi,
+        client: deployL1ContractsValues.l1Client,
+      });
 
-        const { address: multiAdderAddress } = await deployL1Contract(
-          deployL1ContractsValues.l1Client,
-          MultiAdderArtifact.contractAbi,
-          MultiAdderArtifact.contractBytecode,
-          [rollup.address, deployL1ContractsValues.l1Client.account.address],
-        );
+      const { address: multiAdderAddress } = await deployL1Contract(
+        deployL1ContractsValues.l1Client,
+        MultiAdderArtifact.contractAbi,
+        MultiAdderArtifact.contractBytecode,
+        [rollup.address, deployL1ContractsValues.l1Client.account.address],
+      );
 
-        const multiAdder = getContract({
-          address: multiAdderAddress.toString(),
-          abi: MultiAdderArtifact.contractAbi,
-          client: deployL1ContractsValues.l1Client,
-        });
+      const multiAdder = getContract({
+        address: multiAdderAddress.toString(),
+        abi: MultiAdderArtifact.contractAbi,
+        client: deployL1ContractsValues.l1Client,
+      });
 
-        const stakeNeeded = l1ContractsConfig.activationThreshold * BigInt(this.numberOfValidators);
-        await Promise.all(
-          [await stakingAsset.write.mint([multiAdder.address, stakeNeeded], {} as any)].map(txHash =>
-            deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: txHash }),
-          ),
-        );
+      const stakeNeeded = (await rollup.read.getActivationThreshold()) * BigInt(this.numberOfValidators);
+      await Promise.all(
+        [await stakingAsset.write.mint([multiAdder.address, stakeNeeded], {} as any)].map(txHash =>
+          deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: txHash }),
+        ),
+      );
 
-        const { validators } = this.getValidators();
-        this.validators = validators;
+      const { validators } = this.getValidators();
+      this.validators = validators;
 
-        const gseAddress = deployL1ContractsValues.l1ContractAddresses.gseAddress!;
-        if (!gseAddress) {
-          throw new Error('GSE contract not deployed');
-        }
+      const gseAddress = deployL1ContractsValues.l1ContractAddresses.gseAddress!;
+      if (!gseAddress) {
+        throw new Error('GSE contract not deployed');
+      }
 
-        const gseContract = new GSEContract(deployL1ContractsValues.l1Client, gseAddress.toString());
+      const gseContract = new GSEContract(deployL1ContractsValues.l1Client, gseAddress.toString());
 
-        const makeValidatorTuples = async (validator: Operator) => {
-          const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
-          return {
-            attester: validator.attester.toString() as `0x${string}`,
-            withdrawer: validator.withdrawer.toString() as `0x${string}`,
-            ...registrationTuple,
-          };
+      const makeValidatorTuples = async (validator: Operator) => {
+        const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
+        return {
+          attester: validator.attester.toString() as `0x${string}`,
+          withdrawer: validator.withdrawer.toString() as `0x${string}`,
+          ...registrationTuple,
         };
-        const validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
+      };
+      const validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
 
-        await deployL1ContractsValues.l1Client.waitForTransactionReceipt({
-          hash: await multiAdder.write.addValidators([validatorTuples]),
-        });
-
-        const timestamp = await cheatCodes.rollup.advanceToEpoch(2n, { updateDateProvider: dateProvider });
+      await deployL1ContractsValues.l1Client.waitForTransactionReceipt({
+        hash: await multiAdder.write.addValidators([validatorTuples]),
+      });
 
-        // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-        await this._sendDummyTx(deployL1ContractsValues.l1Client);
+      await cheatCodes.rollup.advanceToEpoch(
+        EpochNumber.fromBigInt(
+          BigInt(await cheatCodes.rollup.getEpoch()) + (await rollup.read.getLagInEpochsForValidatorSet()) + 1n,
+        ),
+      );
 
-        // Set the system time in the node, only after we have warped the time and waited for a block
-        // Time is only set in the NEXT block
-        dateProvider.setTime(Number(timestamp) * 1000);
-      },
-    );
+      // Send and await a tx to make sure we mine a block for the warp to correctly progress.
+      await this._sendDummyTx(deployL1ContractsValues.l1Client);
+    });
   }
 
   async setupAccount() {
     await this.snapshotManager.snapshot(
       'setup-account',
-      deployAccounts(1, this.logger, false),
-      async ({ deployedAccounts }, { pxe }) => {
+      deployAccounts(1, this.logger),
+      ({ deployedAccounts }, { wallet }) => {
         this.deployedAccounts = deployedAccounts;
-        const [account] = deployedAccounts;
-        this.wallet = await getSchnorrWalletWithSecretKey(pxe, account.secret, account.signingKey, account.salt);
-        this.defaultAccountAddress = this.wallet.getAddress();
+        [{ address: this.defaultAccountAddress }] = deployedAccounts;
+        this.wallet = wallet;
+        return Promise.resolve();
       },
     );
   }
@@ -329,11 +328,12 @@ export class P2PNetworkTest {
           .deployed();
         return { contractAddress: spamContract.address };
       },
-      async ({ contractAddress }) => {
+      ({ contractAddress }) => {
         if (!this.wallet) {
           throw new Error('Call snapshot t.setupAccount before deploying account contract');
         }
-        this.spamContract = await SpamContract.at(contractAddress, this.wallet);
+        this.spamContract = SpamContract.at(contractAddress, this.wallet);
+        return Promise.resolve();
       },
     );
   }
@@ -393,6 +393,48 @@ export class P2PNetworkTest {
     this.logger.info('Nodes stopped');
   }
 
+  /**
+   * Wait for P2P mesh to be fully formed across all nodes.
+   * This ensures that all nodes are connected to each other before proceeding,
+   * preventing race conditions where validators propose blocks before the network is ready.
+   *
+   * @param nodes - Array of nodes to check for P2P connectivity
+   * @param expectedNodeCount - Expected number of nodes in the network (defaults to nodes.length)
+   * @param timeoutSeconds - Maximum time to wait for connections (default: 30 seconds)
+   * @param checkIntervalSeconds - How often to check connectivity (default: 0.1 seconds)
+   */
+  async waitForP2PMeshConnectivity(
+    nodes: AztecNodeService[],
+    expectedNodeCount?: number,
+    timeoutSeconds = 30,
+    checkIntervalSeconds = 0.1,
+  ) {
+    const nodeCount = expectedNodeCount ?? nodes.length;
+    const minPeerCount = nodeCount - 1;
+
+    this.logger.warn(
+      `Waiting for all ${nodeCount} nodes to connect to P2P mesh (at least ${minPeerCount} peers each)...`,
+    );
+
+    await Promise.all(
+      nodes.map(async (node, index) => {
+        const p2p = node.getP2P();
+        await retryUntil(
+          async () => {
+            const peers = await p2p.getPeers();
+            // Each node should be connected to at least N-1 other nodes
+            return peers.length >= minPeerCount ? true : undefined;
+          },
+          `Node ${index} to connect to at least ${minPeerCount} peers`,
+          timeoutSeconds,
+          checkIntervalSeconds,
+        );
+      }),
+    );
+
+    this.logger.warn('All nodes connected to P2P mesh');
+  }
+
   async teardown() {
     await this.monitor.stop();
     await tryStop(this.bootstrapNode, this.logger);
@@ -415,7 +457,7 @@ export class P2PNetworkTest {
     );
 
     const slasherContract = getContract({
-      address: getAddress(await rollup.getSlasher()),
+      address: getAddress(await rollup.getSlasherAddress()),
       abi: SlasherAbi,
       client: this.ctx.deployL1ContractsValues.l1Client,
     });