@aztec/end-to-end 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/e2e_p2p/p2p_network.ts

@@ -1,26 +1,39 @@
 import { getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
-import type { AccountWalletWithSecretKey } from '@aztec/aztec.js';
-import { ChainMonitor } from '@aztec/aztec.js/ethereum';
-import { RollupContract, getExpectedAddress, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
-import { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
-import { EthCheatCodesWithState } from '@aztec/ethereum/test';
+import { type AccountWalletWithSecretKey, AztecAddress, EthAddress, Fr } from '@aztec/aztec.js';
+import {
+  type EmpireSlashingProposerContract,
+  type ExtendedViemWalletClient,
+  GSEContract,
+  MultiAdderArtifact,
+  type Operator,
+  RollupContract,
+  type TallySlashingProposerContract,
+  type ViemClient,
+  createL1TxUtilsFromViemWallet,
+  deployL1Contract,
+  getL1ContractsConfigEnvVars,
+} from '@aztec/ethereum';
+import { ChainMonitor } from '@aztec/ethereum/test';
+import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { ForwarderAbi, ForwarderBytecode, RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
-import { SpamContract } from '@aztec/noir-contracts.js/Spam';
+import { RollupAbi, SlasherAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import type { BootstrapNode } from '@aztec/p2p/bootstrap';
 import { createBootstrapNodeFromPrivateKey, getBootstrapNodeEnr } from '@aztec/p2p/test-helpers';
+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 { getGenesisValues } from '@aztec/world-state/testing';
 
 import getPort from 'get-port';
-import { getContract } from 'viem';
+import { type GetContractReturnType, getAddress, getContract } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
 import {
   ATTESTER_PRIVATE_KEYS_START_INDEX,
-  PROPOSER_PRIVATE_KEYS_START_INDEX,
   createValidatorConfig,
   generatePrivateKeys,
 } from '../fixtures/setup_p2p_test.js';
@@ -30,7 +43,7 @@ import {
   createSnapshotManager,
   deployAccounts,
 } from '../fixtures/snapshot_manager.js';
-import { getPrivateKeyFromIndex } 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
@@ -38,14 +51,16 @@ const BOOTSTRAP_NODE_PRIVATE_KEY = '080212208f988fc0899e4a73a5aee4d271a5f2067060
 const l1ContractsConfig = getL1ContractsConfigEnvVars();
 export const WAIT_FOR_TX_TIMEOUT = l1ContractsConfig.aztecSlotDuration * 3;
 
-export const SHORTENED_BLOCK_TIME_CONFIG = {
+export const SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES = {
   aztecSlotDuration: 12,
   ethereumSlotDuration: 4,
+  aztecProofSubmissionWindow: 640,
 };
 
 export class P2PNetworkTest {
   private snapshotManager: ISnapshotManager;
-  private baseAccount;
+  public baseAccountPrivateKey: `0x${string}`;
+  public baseAccount;
 
   public logger: Logger;
   public monitor!: ChainMonitor;
@@ -53,38 +68,44 @@ export class P2PNetworkTest {
   public ctx!: SubsystemsContext;
   public attesterPrivateKeys: `0x${string}`[] = [];
   public attesterPublicKeys: string[] = [];
-  public proposerPrivateKeys: `0x${string}`[] = [];
   public peerIdPrivateKeys: string[] = [];
+  public validators: Operator[] = [];
 
   public deployedAccounts: InitialAccountData[] = [];
   public prefilledPublicData: PublicDataTreeLeaf[] = [];
+
   // The re-execution test needs a wallet and a spam contract
   public wallet?: AccountWalletWithSecretKey;
+  public defaultAccountAddress?: AztecAddress;
   public spamContract?: SpamContract;
 
   public bootstrapNode?: BootstrapNode;
 
-  private cleanupInterval: NodeJS.Timeout | undefined = undefined;
-
-  private gasUtils: L1TxUtilsWithBlobs | undefined = undefined;
-
   constructor(
-    testName: string,
+    public readonly testName: string,
     public bootstrapNodeEnr: string,
     public bootNodePort: number,
-    private numberOfNodes: number,
-    initialValidatorConfig: AztecNodeConfig,
+    public numberOfValidators: number,
+    initialValidatorConfig: SetupOptions,
+    public numberOfNodes = 0,
     // If set enable metrics collection
     private metricsPort?: number,
+    startProverNode?: boolean,
+    mockZkPassportVerifier?: boolean,
   ) {
     this.logger = createLogger(`e2e:e2e_p2p:${testName}`);
 
     // Set up the base account and node private keys for the initial network deployment
-    this.baseAccount = privateKeyToAccount(`0x${getPrivateKeyFromIndex(0)!.toString('hex')}`);
-    this.proposerPrivateKeys = generatePrivateKeys(PROPOSER_PRIVATE_KEYS_START_INDEX, numberOfNodes);
-    this.attesterPrivateKeys = generatePrivateKeys(ATTESTER_PRIVATE_KEYS_START_INDEX, numberOfNodes);
+    this.baseAccountPrivateKey = `0x${getPrivateKeyFromIndex(1)!.toString('hex')}`;
+    this.baseAccount = privateKeyToAccount(this.baseAccountPrivateKey);
+    this.attesterPrivateKeys = generatePrivateKeys(
+      ATTESTER_PRIVATE_KEYS_START_INDEX + numberOfNodes,
+      numberOfValidators,
+    );
     this.attesterPublicKeys = this.attesterPrivateKeys.map(privateKey => privateKeyToAccount(privateKey).address);
 
+    const zkPassportParams = ZkPassportProofParams.random();
+
     this.snapshotManager = createSnapshotManager(
       `e2e_p2p_network/${testName}`,
       process.env.E2E_DATA_PATH,
@@ -93,19 +114,35 @@ export class P2PNetworkTest {
         ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
         aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
         aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
-        aztecProofSubmissionWindow:
-          initialValidatorConfig.aztecProofSubmissionWindow ?? l1ContractsConfig.aztecProofSubmissionWindow,
+        aztecProofSubmissionEpochs:
+          initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
+        slashingRoundSizeInEpochs:
+          initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
+        slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
+        aztecTargetCommitteeSize: numberOfValidators,
         salt: 420,
         metricsPort: metricsPort,
-        numberOfInitialFundedAccounts: 1,
+        numberOfInitialFundedAccounts: 2,
+        startProverNode,
       },
       {
+        ...initialValidatorConfig,
         aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
+        slashingRoundSizeInEpochs:
+          initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
+        slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
+
         ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
         aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
-        aztecProofSubmissionWindow:
-          initialValidatorConfig.aztecProofSubmissionWindow ?? l1ContractsConfig.aztecProofSubmissionWindow,
+        aztecProofSubmissionEpochs:
+          initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
+        aztecTargetCommitteeSize: numberOfValidators,
         initialValidators: [],
+        zkPassportArgs: {
+          mockZkPassportVerifier,
+          zkPassportDomain: zkPassportParams.domain,
+          zkPassportScope: zkPassportParams.scope,
+        },
       },
     );
   }
@@ -113,15 +150,21 @@ export class P2PNetworkTest {
   static async create({
     testName,
     numberOfNodes,
+    numberOfValidators,
     basePort,
     metricsPort,
     initialConfig,
+    startProverNode,
+    mockZkPassportVerifier,
   }: {
     testName: string;
     numberOfNodes: number;
+    numberOfValidators: number;
     basePort?: number;
     metricsPort?: number;
-    initialConfig?: Partial<AztecNodeConfig>;
+    initialConfig?: SetupOptions;
+    startProverNode?: boolean;
+    mockZkPassportVerifier?: boolean;
   }) {
     const port = basePort || (await getPort());
 
@@ -133,7 +176,17 @@ export class P2PNetworkTest {
       bootstrapNodeEnr,
     );
 
-    return new P2PNetworkTest(testName, bootstrapNodeEnr, port, numberOfNodes, initialValidatorConfig, metricsPort);
+    return new P2PNetworkTest(
+      testName,
+      bootstrapNodeEnr,
+      port,
+      numberOfValidators,
+      initialValidatorConfig,
+      numberOfNodes,
+      metricsPort,
+      startProverNode,
+      mockZkPassportVerifier,
+    );
   }
 
   get fundedAccount() {
@@ -143,33 +196,7 @@ export class P2PNetworkTest {
     return this.deployedAccounts[0];
   }
 
-  /**
-   * Start a loop to sync the mock system time with the L1 block time
-   */
-  public startSyncMockSystemTimeInterval() {
-    this.cleanupInterval = setInterval(() => {
-      void this.syncMockSystemTime().catch(err => this.logger.error('Error syncing mock system time', err));
-    }, l1ContractsConfig.aztecSlotDuration * 1000);
-  }
-
-  /**
-   * When using fake timers, we need to keep the system and anvil clocks in sync.
-   */
-  public async syncMockSystemTime() {
-    this.logger.info('Syncing mock system time');
-    const { dateProvider, deployL1ContractsValues } = this.ctx!;
-    // Send a tx and only update the time after the tx is mined, as eth time is not continuous
-    const { receipt } = await this.gasUtils!.sendAndMonitorTransaction({
-      to: this.baseAccount.address,
-      data: '0x',
-      value: 1n,
-    });
-    const timestamp = await deployL1ContractsValues.publicClient.getBlock({ blockNumber: receipt.blockNumber });
-    this.logger.info(`Timestamp: ${timestamp.timestamp}`);
-    dateProvider.setTime(Number(timestamp.timestamp) * 1000);
-  }
-
-  async applyBaseSnapshots() {
+  async addBootstrapNode() {
     await this.snapshotManager.snapshot('add-bootstrap-node', async ({ aztecNodeConfig }) => {
       const telemetry = getEndToEndTestTelemetryClient(this.metricsPort);
       this.bootstrapNode = await createBootstrapNodeFromPrivateKey(
@@ -181,84 +208,98 @@ export class P2PNetworkTest {
       // Overwrite enr with updated info
       this.bootstrapNodeEnr = this.bootstrapNode.getENR().encodeTxt();
     });
+  }
+
+  getValidators() {
+    const validators: Operator[] = [];
+
+    for (let i = 0; i < this.numberOfValidators; i++) {
+      const keyIndex = i;
+      const attester = privateKeyToAccount(this.attesterPrivateKeys[keyIndex]!);
+
+      validators.push({
+        attester: EthAddress.fromString(attester.address),
+        withdrawer: EthAddress.fromString(attester.address),
+        bn254SecretKey: new SecretValue(Fr.random().toBigInt()),
+      });
+
+      this.logger.info(`Adding attester ${attester.address} as validator`);
+    }
+    return { validators };
+  }
 
+  async applyBaseSnapshots() {
+    await this.addBootstrapNode();
     await this.snapshotManager.snapshot(
       'add-validators',
-      async ({ deployL1ContractsValues, aztecNodeConfig, dateProvider }) => {
+      async ({ deployL1ContractsValues, dateProvider, cheatCodes }) => {
         const rollup = getContract({
           address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
           abi: RollupAbi,
-          client: deployL1ContractsValues.walletClient,
+          client: deployL1ContractsValues.l1Client,
         });
 
-        this.logger.verbose(`Adding ${this.numberOfNodes} validators`);
+        this.logger.info(`Adding ${this.numberOfValidators} validators`);
 
         const stakingAsset = getContract({
           address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
           abi: TestERC20Abi,
-          client: deployL1ContractsValues.walletClient,
+          client: deployL1ContractsValues.l1Client,
+        });
+
+        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 stakeNeeded = l1ContractsConfig.minimumStake * BigInt(this.numberOfNodes);
+        const stakeNeeded = (await rollup.read.getActivationThreshold()) * BigInt(this.numberOfValidators);
         await Promise.all(
-          [
-            await stakingAsset.write.mint(
-              [deployL1ContractsValues.walletClient.account.address, stakeNeeded],
-              {} as any,
-            ),
-            await stakingAsset.write.approve(
-              [deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(), stakeNeeded],
-              {} as any,
-            ),
-          ].map(txHash => deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash: txHash })),
+          [await stakingAsset.write.mint([multiAdder.address, stakeNeeded], {} as any)].map(txHash =>
+            deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: txHash }),
+          ),
         );
 
-        const validators = [];
-
-        for (let i = 0; i < this.numberOfNodes; i++) {
-          const attester = privateKeyToAccount(this.attesterPrivateKeys[i]!);
-          const proposerEOA = privateKeyToAccount(this.proposerPrivateKeys[i]!);
-          const forwarder = getExpectedAddress(
-            ForwarderAbi,
-            ForwarderBytecode,
-            [proposerEOA.address],
-            proposerEOA.address,
-          ).address;
-          validators.push({
-            attester: attester.address,
-            proposer: forwarder,
-            withdrawer: attester.address,
-            amount: l1ContractsConfig.minimumStake,
-          } as const);
-
-          this.logger.verbose(`Adding (attester, proposer) pair: (${attester.address}, ${forwarder}) as validator`);
+        const { validators } = this.getValidators();
+        this.validators = validators;
+
+        const gseAddress = deployL1ContractsValues.l1ContractAddresses.gseAddress!;
+        if (!gseAddress) {
+          throw new Error('GSE contract not deployed');
         }
 
-        await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-          hash: await rollup.write.cheat__InitialiseValidatorSet([validators]),
-        });
+        const gseContract = new GSEContract(deployL1ContractsValues.l1Client, gseAddress.toString());
 
-        const slotsInEpoch = await rollup.read.getEpochDuration();
-        const timestamp = await rollup.read.getTimestampForSlot([slotsInEpoch]);
-        const cheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
-        try {
-          await cheatCodes.warp(Number(timestamp));
-        } catch (err) {
-          this.logger.debug('Warp failed, time already satisfied');
-        }
+        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));
 
-        // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-        await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-          hash: await deployL1ContractsValues.walletClient.sendTransaction({
-            to: this.baseAccount.address,
-            value: 1n,
-            account: this.baseAccount,
-          }),
+        await deployL1ContractsValues.l1Client.waitForTransactionReceipt({
+          hash: await multiAdder.write.addValidators([validatorTuples]),
         });
 
-        // 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);
+        await cheatCodes.rollup.advanceToEpoch(
+          (await cheatCodes.rollup.getEpoch()) + (await rollup.read.getLagInEpochs()) + 1n,
+          {
+            updateDateProvider: dateProvider,
+          },
+        );
+
+        // Send and await a tx to make sure we mine a block for the warp to correctly progress.
+        await this._sendDummyTx(deployL1ContractsValues.l1Client);
       },
     );
   }
@@ -271,6 +312,7 @@ export class P2PNetworkTest {
         this.deployedAccounts = deployedAccounts;
         const [account] = deployedAccounts;
         this.wallet = await getSchnorrWalletWithSecretKey(pxe, account.secret, account.signingKey, account.salt);
+        this.defaultAccountAddress = this.wallet.getAddress();
       },
     );
   }
@@ -283,7 +325,9 @@ export class P2PNetworkTest {
           throw new Error('Call snapshot t.setupAccount before deploying account contract');
         }
 
-        const spamContract = await SpamContract.deploy(this.wallet).send().deployed();
+        const spamContract = await SpamContract.deploy(this.wallet)
+          .send({ from: this.defaultAccountAddress! })
+          .deployed();
         return { contractAddress: spamContract.address };
       },
       async ({ contractAddress }) => {
@@ -297,17 +341,11 @@ export class P2PNetworkTest {
 
   async removeInitialNode() {
     await this.snapshotManager.snapshot(
-      'remove-inital-validator',
+      'remove-initial-validator',
       async ({ deployL1ContractsValues, aztecNode, dateProvider }) => {
         // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-        const receipt = await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-          hash: await deployL1ContractsValues.walletClient.sendTransaction({
-            to: this.baseAccount.address,
-            value: 1n,
-            account: this.baseAccount,
-          }),
-        });
-        const block = await deployL1ContractsValues.publicClient.getBlock({
+        const { receipt } = await this._sendDummyTx(deployL1ContractsValues.l1Client);
+        const block = await deployL1ContractsValues.l1Client.getBlock({
           blockNumber: receipt.blockNumber,
         });
         dateProvider.setTime(Number(block.timestamp) * 1000);
@@ -317,29 +355,30 @@ export class P2PNetworkTest {
     );
   }
 
+  async sendDummyTx() {
+    return await this._sendDummyTx(this.ctx.deployL1ContractsValues.l1Client);
+  }
+
+  private async _sendDummyTx(l1Client: ExtendedViemWalletClient) {
+    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
+    return await l1TxUtils.sendAndMonitorTransaction({
+      to: l1Client.account!.address,
+      value: 1n,
+    });
+  }
+
   async setup() {
     this.ctx = await this.snapshotManager.setup();
 
-    this.prefilledPublicData = (
-      await getGenesisValues(this.ctx.initialFundedAccounts.map(a => a.address))
-    ).prefilledPublicData;
+    const sponsoredFPCAddress = await getSponsoredFPCAddress();
+    const initialFundedAccounts = [...this.ctx.initialFundedAccounts.map(a => a.address), sponsoredFPCAddress];
 
-    this.startSyncMockSystemTimeInterval();
+    const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
+    this.prefilledPublicData = prefilledPublicData;
 
-    this.gasUtils = new L1TxUtilsWithBlobs(
-      this.ctx.deployL1ContractsValues.publicClient,
-      this.ctx.deployL1ContractsValues.walletClient,
-      this.logger,
-      {
-        gasLimitBufferPercentage: 20,
-        maxGwei: 500n,
-        maxAttempts: 3,
-        checkIntervalMs: 100,
-        stallTimeMs: 1000,
-      },
-    );
-
-    this.monitor = new ChainMonitor(RollupContract.getFromL1ContractsValues(this.ctx.deployL1ContractsValues)).start();
+    const rollupContract = RollupContract.getFromL1ContractsValues(this.ctx.deployL1ContractsValues);
+    this.monitor = new ChainMonitor(rollupContract, this.ctx.dateProvider).start();
+    this.monitor.on('l1-block', ({ timestamp }) => this.ctx.dateProvider.setTime(Number(timestamp) * 1000));
   }
 
   async stopNodes(nodes: AztecNodeService[]) {
@@ -356,11 +395,40 @@ export class P2PNetworkTest {
   }
 
   async teardown() {
-    this.monitor.stop();
-    await this.bootstrapNode?.stop();
+    await this.monitor.stop();
+    await tryStop(this.bootstrapNode, this.logger);
     await this.snapshotManager.teardown();
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
+  }
+
+  async getContracts(): Promise<{
+    rollup: RollupContract;
+    slasherContract: GetContractReturnType<typeof SlasherAbi, ViemClient>;
+    slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
+    slashFactory: SlashFactoryContract;
+  }> {
+    if (!this.ctx.deployL1ContractsValues) {
+      throw new Error('DeployL1ContractsValues not set');
     }
+
+    const rollup = new RollupContract(
+      this.ctx.deployL1ContractsValues!.l1Client,
+      this.ctx.deployL1ContractsValues!.l1ContractAddresses.rollupAddress,
+    );
+
+    const slasherContract = getContract({
+      address: getAddress(await rollup.getSlasherAddress()),
+      abi: SlasherAbi,
+      client: this.ctx.deployL1ContractsValues.l1Client,
+    });
+
+    // Get the actual slashing proposer from rollup (which handles both empire and tally)
+    const slashingProposer = await rollup.getSlashingProposer();
+
+    const slashFactory = new SlashFactoryContract(
+      this.ctx.deployL1ContractsValues.l1Client,
+      getAddress(this.ctx.deployL1ContractsValues.l1ContractAddresses.slashFactoryAddress!.toString()),
+    );
+
+    return { rollup, slasherContract, slashingProposer, slashFactory };
   }
 }