@aztec/end-to-end 2.0.0-nightly.20250826 → 2.0.0-nightly.20250828

package/src/e2e_multi_validator/utils.ts

@@ -0,0 +1,264 @@
+import type { AztecAddress } from '@aztec/aztec.js';
+import { getAddressFromPrivateKey } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { EthPrivateKey } from '@aztec/node-keystore';
+
+import { writeFile } from 'fs/promises';
+import { createServer } from 'http';
+import { signMessage, signTypedData } from 'viem/accounts';
+
+// Create a mock JSON RPC signer
+// Only supports signing messages and type data
+
+const SUPPORTED_METHODS = ['eth_sign', 'eth_signTypedData_v4'];
+
+export function createJSONRPCSigner(keyLookup: Map<string, EthPrivateKey>, stats: Map<string, number>) {
+  return createServer((req, res) => {
+    if (req.method === 'POST') {
+      let body = '';
+      req.on('data', chunk => {
+        body += chunk.toString();
+      });
+      req.on('end', () => {
+        try {
+          const jsonRequest = JSON.parse(body);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+
+          if (!SUPPORTED_METHODS.includes(jsonRequest.method)) {
+            res.end(
+              JSON.stringify({
+                jsonrpc: '2.0',
+                id: jsonRequest.id,
+                error: { code: -32601, message: 'Method not supported' },
+              }),
+            );
+            return;
+          }
+
+          // Get the address sending the transaction
+          const [address, data] = jsonRequest.params;
+
+          const lowerCaseAddress = address.toLowerCase();
+          stats.set(lowerCaseAddress, (stats.get(lowerCaseAddress) ?? 0) + 1);
+
+          // Find the private key for the address
+          const privateKey = keyLookup.get(address.toLowerCase());
+          if (!privateKey) {
+            res.end(
+              JSON.stringify({
+                jsonrpc: '2.0',
+                id: jsonRequest.id,
+                error: { code: -32602, message: `No private key found for address ${address}` },
+              }),
+            );
+            return;
+          }
+
+          const promise =
+            jsonRequest.method === 'eth_sign'
+              ? signMessage({ message: { raw: data as `0x${string}` }, privateKey })
+              : signTypedData({
+                  privateKey,
+                  ...data,
+                });
+
+          void promise.then(signature => {
+            res.end(
+              JSON.stringify({
+                jsonrpc: '2.0',
+                id: jsonRequest.id,
+                result: signature,
+              }),
+            );
+          });
+        } catch (err) {
+          res.end(
+            JSON.stringify({
+              jsonrpc: '2.0',
+              id: 1,
+              error: { code: -32603, message: `${err}` },
+            }),
+          );
+        }
+      });
+    } else {
+      res.writeHead(405);
+      res.end('Method not allowed');
+    }
+  });
+}
+
+// Functions for creating file based key stores for the e2e_multi_validator_node_key_store test
+export async function createKeyFile1(
+  fileName: string,
+  mnemonic: string,
+  validatorIndex: number,
+  publisher1Key: EthPrivateKey,
+  publisher2Key: EthPrivateKey,
+  coinbase: EthAddress,
+  feeRecipient: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    validators: [
+      {
+        attester: {
+          mnemonic: mnemonic,
+          accountIndex: 0,
+          addressIndex: validatorIndex,
+          addressCount: 1,
+        },
+        coinbase: coinbase.toChecksumString(),
+        publisher: [publisher1Key, publisher2Key],
+        feeRecipient: feeRecipient.toString(),
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile2(
+  fileName: string,
+  validatorKey: EthPrivateKey,
+  publisherMnemonic: string,
+  publisher1Index: number,
+  coinbase: EthAddress,
+  feeRecipient: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    validators: [
+      {
+        attester: validatorKey,
+        coinbase: coinbase.toChecksumString(),
+        publisher: {
+          mnemonic: publisherMnemonic,
+          accountIndex: 0,
+          addressIndex: publisher1Index,
+          addressCount: 2,
+        },
+        feeRecipient: feeRecipient.toString(),
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile3(
+  fileName: string,
+  validatorAddress: EthAddress,
+  publisher1Key: EthPrivateKey,
+  publisher2Key: EthPrivateKey,
+  coinbase: EthAddress,
+  remoteSignerUrl: string,
+  feeRecipient: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    validators: [
+      {
+        attester: {
+          address: validatorAddress.toChecksumString(),
+        },
+        coinbase: coinbase.toChecksumString(),
+        publisher: [publisher1Key, publisher2Key],
+        feeRecipient: feeRecipient.toString(),
+        remoteSigner: {
+          remoteSignerUrl: remoteSignerUrl,
+        },
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile4(
+  fileName: string,
+  validator1Address: EthAddress,
+  validator2Address: EthAddress,
+  publisher1Index: number,
+  publisher2Key: EthPrivateKey,
+  mnemonic: string,
+  publisher3Key: EthPrivateKey,
+  coinbase1: EthAddress,
+  coinbase2: EthAddress,
+  remoteSignerUrl: string,
+  feeRecipient1: AztecAddress,
+  feeRecipient2: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    remoteSigner: {
+      remoteSignerUrl: remoteSignerUrl,
+    },
+    validators: [
+      {
+        attester: {
+          address: validator1Address.toChecksumString(),
+        },
+        coinbase: coinbase1.toChecksumString(),
+        publisher: {
+          mnemonic: mnemonic,
+          accountIndex: 0,
+          addressIndex: publisher1Index,
+          addressCount: 2,
+        },
+        feeRecipient: feeRecipient1.toString(),
+      },
+      {
+        attester: {
+          address: validator2Address.toChecksumString(),
+        },
+        coinbase: coinbase2.toChecksumString(),
+        publisher: [publisher2Key, publisher3Key],
+        feeRecipient: feeRecipient2.toString(),
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile5(fileName: string, proverAddress: EthAddress, remoteSignerUrl: string) {
+  const obj = {
+    schemaVersion: 1,
+    prover: {
+      id: '0x1234567890123456789012345678901234567890',
+      publisher: [
+        {
+          address: proverAddress.toChecksumString(),
+          remoteSignerUrl: remoteSignerUrl,
+        },
+      ],
+    },
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile6(
+  fileName: string,
+  mnemonic: string,
+  validator1Index: number,
+  coinbase: EthAddress,
+  feeRecipient: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    validators: [
+      {
+        attester: {
+          mnemonic: mnemonic,
+          accountIndex: 0,
+          addressIndex: validator1Index,
+          addressCount: 2,
+        },
+        coinbase: coinbase.toChecksumString(),
+        feeRecipient: feeRecipient.toString(),
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export function addressForPrivateKey(privateKey: EthPrivateKey): EthAddress {
+  return EthAddress.fromString(getAddressFromPrivateKey(privateKey));
+}

package/src/e2e_p2p/p2p_network.ts

@@ -3,20 +3,22 @@ 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 {
+  type EmpireSlashingProposerContract,
   type ExtendedViemWalletClient,
   GSEContract,
-  L1TxUtils,
   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 { EmpireSlashingProposerAbi, RollupAbi, SlasherAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+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';
@@ -71,6 +73,7 @@ export class P2PNetworkTest {
 
   public deployedAccounts: InitialAccountData[] = [];
   public prefilledPublicData: PublicDataTreeLeaf[] = [];
+
   // The re-execution test needs a wallet and a spam contract
   public wallet?: AccountWalletWithSecretKey;
   public defaultAccountAddress?: AztecAddress;
@@ -349,7 +352,7 @@ export class P2PNetworkTest {
   }
 
   private async _sendDummyTx(l1Client: ExtendedViemWalletClient) {
-    const l1TxUtils = new L1TxUtils(l1Client);
+    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
     return await l1TxUtils.sendAndMonitorTransaction({
       to: l1Client.account!.address,
       value: 1n,
@@ -392,7 +395,7 @@ export class P2PNetworkTest {
   async getContracts(): Promise<{
     rollup: RollupContract;
     slasherContract: GetContractReturnType<typeof SlasherAbi, ViemClient>;
-    slashingProposer: GetContractReturnType<typeof EmpireSlashingProposerAbi, ViemClient>;
+    slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
     slashFactory: SlashFactoryContract;
   }> {
     if (!this.ctx.deployL1ContractsValues) {
@@ -410,11 +413,8 @@ export class P2PNetworkTest {
       client: this.ctx.deployL1ContractsValues.l1Client,
     });
 
-    const slashingProposer = getContract({
-      address: getAddress(await slasherContract.read.PROPOSER()),
-      abi: EmpireSlashingProposerAbi,
-      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,

package/src/e2e_p2p/shared.ts

@@ -12,16 +12,16 @@ import {
   retryUntil,
 } from '@aztec/aztec.js';
 import type { RollupCheatCodes } from '@aztec/aztec/testing';
-import type { RollupContract, ViemClient } from '@aztec/ethereum';
+import type { EmpireSlashingProposerContract, RollupContract, TallySlashingProposerContract } from '@aztec/ethereum';
 import { timesAsync, unique } from '@aztec/foundation/collection';
-import type { EmpireSlashingProposerAbi } from '@aztec/l1-artifacts/EmpireSlashingProposerAbi';
+import type { TestDateProvider } from '@aztec/foundation/timer';
 import type { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.js/Test';
 import { PXEService, createPXEService, getPXEServiceConfig 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 type { GetContractReturnType } from 'viem';
-
 import type { NodeContext } from '../fixtures/setup_p2p_test.js';
 import { submitTxsTo } from '../shared/submit-transactions.js';
 
@@ -107,25 +107,36 @@ export async function createPXEServiceAndPrepareTransactions(
   return { txs, pxeService: pxe, node };
 }
 
-export async function awaitProposalExecution(
-  slashingProposer: GetContractReturnType<typeof EmpireSlashingProposerAbi, ViemClient>,
+export function awaitProposalExecution(
+  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract,
   timeoutSeconds: number,
-) {
-  await retryUntil(
-    async () => {
-      const events = await slashingProposer.getEvents.PayloadSubmitted();
-      if (events.length === 0) {
-        return false;
-      }
-      const event = events[0];
-      const roundNumber = event.args.round;
-      const payload = event.args.payload;
-      return roundNumber && payload;
-    },
-    'payload submitted',
-    timeoutSeconds,
-    1,
-  );
+  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({
@@ -148,6 +159,35 @@ export async function awaitCommitteeExists({
   return committee!;
 }
 
+export async function awaitOffenseDetected({
+  logger,
+  nodeAdmin,
+  slashingRoundSize,
+  epochDuration,
+}: {
+  nodeAdmin: AztecNodeAdmin;
+  logger: Logger;
+  slashingRoundSize: number;
+  epochDuration: number;
+}) {
+  logger.info(`Waiting for an offense to be detected`);
+  const offenses = await retryUntil(
+    async () => {
+      const offenses = await nodeAdmin.getSlashOffenses('all');
+      if (offenses.length > 0) {
+        return offenses;
+      }
+    },
+    'non-empty offenses',
+    60,
+  );
+  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.
@@ -161,52 +201,58 @@ export async function awaitCommitteeKicked({
   slashingRoundSize,
   aztecSlotDuration,
   logger,
-  sendDummyTx,
+  dateProvider,
 }: {
   rollup: RollupContract;
   cheatCodes: RollupCheatCodes;
   committee: readonly `0x${string}`[];
   slashFactory: SlashFactoryContract;
-  slashingProposer: GetContractReturnType<typeof EmpireSlashingProposerAbi, ViemClient>;
+  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
   slashingRoundSize: number;
   aztecSlotDuration: number;
+  dateProvider: TestDateProvider;
   logger: Logger;
-  sendDummyTx: () => Promise<void>;
 }) {
-  logger.info(`Advancing epochs so slash payload gets deployed`);
-  await cheatCodes.debugRollup();
-  await cheatCodes.advanceToNextEpoch();
-  await cheatCodes.advanceToNextEpoch();
+  if (!slashingProposer) {
+    throw new Error('No slashing proposer configured. Cannot test slashing.');
+  }
 
-  // Await for the slash payload to be created and check that all committee members are slashed
-  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);
+  logger.info(`Advancing epochs so we start slashing`);
+  await cheatCodes.debugRollup();
+  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
+  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
 
-  // 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);
+  // Await for the slash payload to be created if empire (no payload is created on tally until execution time)
+  if (slashingProposer.type === 'empire') {
+    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,
+    );
+  }
 
   const attestersPre = await rollup.getAttesters();
   expect(attestersPre.length).toBe(committee.length);
 
   for (const attester of attestersPre) {
     const attesterInfo = await rollup.getAttesterView(attester);
-    // Check that status isValidating
-    expect(attesterInfo.status).toEqual(1);
+    expect(attesterInfo.status).toEqual(1); // Validating
   }
 
-  logger.info(`Waiting for slash proposal to be executed`);
-  await awaitProposalExecution(slashingProposer, slashingRoundSize * 2 * aztecSlotDuration);
+  const timeout = slashingRoundSize * 2 * aztecSlotDuration;
+  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
+  // 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);
@@ -214,18 +260,15 @@ export async function awaitCommitteeKicked({
   const attestersPostSlashing = await rollup.getAttesters();
   expect(attestersPostSlashing.length).toBe(0);
 
-  // TODO(palla/slash): Reinstate this check if applies
-  // for (const attester of attestersPre) {
-  //   const attesterInfo = await rollup.getAttesterView(attester);
-  //   // Check that status is Living
-  //   expect(attesterInfo.status).toEqual(2);
-  // }
+  for (const attester of attestersPre) {
+    const attesterInfo = await rollup.getAttesterView(attester);
+    expect(attesterInfo.status).toEqual(2); // Living
+  }
 
+  logger.info(`Advancing two epochs to check current committee`);
   await cheatCodes.debugRollup();
-  await cheatCodes.advanceToNextEpoch();
-  await sendDummyTx();
-  await cheatCodes.advanceToNextEpoch();
-  await sendDummyTx();
+  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
+  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
   await cheatCodes.debugRollup();
 
   const committeeNextEpoch = await rollup.getCurrentEpochCommittee();

package/src/fixtures/e2e_prover_test.ts

@@ -296,10 +296,10 @@ export class FullProverTest {
       ...this.context.aztecNodeConfig,
       txCollectionNodeRpcUrls: [],
       dataDirectory: undefined,
-      proverId: this.proverAddress.toField(),
+      proverId: this.proverAddress,
       realProofs: this.realProofs,
       proverAgentCount: 2,
-      publisherPrivateKey: new SecretValue(`0x${proverNodePrivateKey!.toString('hex')}` as const),
+      publisherPrivateKeys: [new SecretValue(`0x${proverNodePrivateKey!.toString('hex')}` as const)],
       proverNodeMaxPendingJobs: 100,
       proverNodeMaxParallelBlocksPerEpoch: 32,
       proverNodePollingIntervalMs: 100,

package/src/fixtures/setup_p2p_test.ts

@@ -154,7 +154,7 @@ export async function createValidatorConfig(
   const attesterPrivateKey = bufferToHex(getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!);
 
   config.validatorPrivateKeys = new SecretValue([attesterPrivateKey]);
-  config.publisherPrivateKey = new SecretValue(attesterPrivateKey);
+  config.publisherPrivateKeys = [new SecretValue(attesterPrivateKey)];
 
   const nodeConfig: AztecNodeConfig = {
     ...config,

package/src/fixtures/snapshot_manager.ts

@@ -8,6 +8,7 @@ import {
   type CompleteAddress,
   type ContractFunctionInteraction,
   DefaultWaitForProvenOpts,
+  EthAddress,
   type Logger,
   type PXE,
   type Wallet,
@@ -342,11 +343,14 @@ async function setupFromFresh(
   const publisherPrivKeyRaw = hdAccount.getHdKey().privateKey;
   const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
 
+  const l1Client = createExtendedL1Client([aztecNodeConfig.l1RpcUrls[0]], hdAccount, foundry);
+
   const validatorPrivKey = getPrivateKeyFromIndex(0);
   const proverNodePrivateKey = getPrivateKeyFromIndex(0);
 
-  aztecNodeConfig.publisherPrivateKey = new SecretValue<`0x${string}`>(`0x${publisherPrivKey!.toString('hex')}`);
+  aztecNodeConfig.publisherPrivateKeys = [new SecretValue<`0x${string}`>(`0x${publisherPrivKey!.toString('hex')}`)];
   aztecNodeConfig.validatorPrivateKeys = new SecretValue([`0x${validatorPrivKey!.toString('hex')}`]);
+  aztecNodeConfig.coinbase = opts.coinbase ?? EthAddress.fromString(`${hdAccount.address}`);
 
   const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
 
@@ -361,7 +365,6 @@ async function setupFromFresh(
     opts.initialAccountFeeJuice,
   );
 
-  const l1Client = createExtendedL1Client([aztecNodeConfig.l1RpcUrls[0]], hdAccount, foundry);
   await deployMulticall3(l1Client, logger);
 
   const deployL1ContractsValues = await setupL1Contracts(aztecNodeConfig.l1RpcUrls[0], hdAccount, logger, {
@@ -439,7 +442,7 @@ async function setupFromFresh(
   );
   await blobSink.start();
 
-  logger.verbose('Creating and synching an aztec node...');
+  logger.info('Creating and synching an aztec node...');
   const aztecNode = await AztecNodeService.createAndSync(
     aztecNodeConfig,
     { telemetry, dateProvider },