@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/e2e_p2p/reqresp/utils.ts

@@ -0,0 +1,207 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import { createLogger } from '@aztec/aztec.js/log';
+import { waitForTx } from '@aztec/aztec.js/node';
+import { Tx } from '@aztec/aztec.js/tx';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { timesAsync } from '@aztec/foundation/collection';
+import { retryUntil } from '@aztec/foundation/retry';
+
+import { jest } from '@jest/globals';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { shouldCollectMetrics } from '../../fixtures/fixtures.js';
+import { createNodes } from '../../fixtures/setup_p2p_test.js';
+import { P2PNetworkTest, SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES, WAIT_FOR_TX_TIMEOUT } from '../p2p_network.js';
+import { prepareTransactions } from '../shared.js';
+
+// Don't set this to a higher value than 9 because each node will use a different L1 publisher account and anvil seeds
+export const NUM_VALIDATORS = 6;
+export const NUM_TXS_PER_NODE = 2;
+export const BOOT_NODE_UDP_PORT = 4500;
+
+export const createReqrespDataDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'reqresp-'));
+
+type ReqrespOptions = {
+  disableStatusHandshake?: boolean;
+};
+
+export async function createReqrespTest(options: ReqrespOptions = {}): Promise<P2PNetworkTest> {
+  const { disableStatusHandshake = false } = options;
+  const t = await P2PNetworkTest.create({
+    testName: 'e2e_p2p_reqresp_tx',
+    numberOfNodes: 0,
+    numberOfValidators: NUM_VALIDATORS,
+    basePort: BOOT_NODE_UDP_PORT,
+    // To collect metrics - run in aztec-packages `docker compose --profile metrics up`
+    metricsPort: shouldCollectMetrics(),
+    initialConfig: {
+      ...SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES,
+      aztecSlotDuration: 24,
+      ...(disableStatusHandshake ? { p2pDisableStatusHandshake: true } : {}),
+      listenAddress: '127.0.0.1',
+      aztecEpochDuration: 64, // stable committee
+    },
+  });
+  await t.setup();
+  await t.applyBaseSetup();
+  return t;
+}
+
+export async function cleanupReqrespTest(params: { t: P2PNetworkTest; nodes?: AztecNodeService[]; dataDir: string }) {
+  const { t, nodes, dataDir } = params;
+  if (nodes) {
+    await t.stopNodes(nodes);
+  }
+  await t.teardown();
+  for (let i = 0; i < NUM_VALIDATORS; i++) {
+    fs.rmSync(`${dataDir}-${i}`, { recursive: true, force: true, maxRetries: 3 });
+  }
+}
+
+const getNodePort = (nodeIndex: number) => BOOT_NODE_UDP_PORT + 1 + nodeIndex;
+
+export async function runReqrespTxTest(params: {
+  t: P2PNetworkTest;
+  dataDir: string;
+  disableStatusHandshake?: boolean;
+}): Promise<AztecNodeService[]> {
+  const { t, dataDir, disableStatusHandshake = false } = params;
+
+  if (!t.bootstrapNodeEnr) {
+    throw new Error('Bootstrap node ENR is not available');
+  }
+
+  t.logger.info('Creating nodes');
+  const aztecNodeConfig = disableStatusHandshake
+    ? { ...t.ctx.aztecNodeConfig, p2pDisableStatusHandshake: true }
+    : t.ctx.aztecNodeConfig;
+
+  const nodes = await createNodes(
+    aztecNodeConfig,
+    t.ctx.dateProvider!,
+    t.bootstrapNodeEnr,
+    NUM_VALIDATORS,
+    BOOT_NODE_UDP_PORT,
+    t.prefilledPublicData,
+    dataDir,
+    shouldCollectMetrics(),
+  );
+
+  t.logger.info('Waiting for nodes to connect');
+  await t.waitForP2PMeshConnectivity(nodes, NUM_VALIDATORS);
+
+  await t.setupAccount();
+
+  const targetBlockNumber = await t.ctx.aztecNodeService!.getBlockNumber();
+  await retryUntil(
+    async () => {
+      const blockNumbers = await Promise.all(nodes.map(node => node.getBlockNumber()));
+      return blockNumbers.every(blockNumber => blockNumber >= targetBlockNumber) ? true : undefined;
+    },
+    `validators to sync to L2 block ${targetBlockNumber}`,
+    60,
+    0.5,
+  );
+
+  t.logger.info('Preparing transactions to send');
+  const txBatches = await timesAsync(2, () =>
+    prepareTransactions(t.logger, t.ctx.aztecNodeService!, NUM_TXS_PER_NODE, t.fundedAccount),
+  );
+
+  t.logger.info('Removing initial node');
+  await t.removeInitialNode();
+
+  t.logger.info('Starting fresh slot');
+  const [timestamp] = await t.ctx.cheatCodes.rollup.advanceToNextSlot();
+  t.ctx.dateProvider!.setTime(Number(timestamp) * 1000);
+  const startSlotTimestamp = BigInt(timestamp);
+
+  const { proposerIndexes, nodesToTurnOffTxGossip } = await getProposerIndexes(t, startSlotTimestamp);
+  t.logger.info(`Turning off tx gossip for nodes: ${nodesToTurnOffTxGossip.map(getNodePort)}`);
+  t.logger.info(`Sending txs to proposer nodes: ${proposerIndexes.map(getNodePort)}`);
+
+  // Replace the p2p node implementation of some of the nodes with a spy such that it does not store transactions that are gossiped to it
+  // Original implementation of `handleGossipedTx` will store received transactions in the tx pool.
+  // We chose the first 2 nodes that will be the proposers for the next few slots
+  for (const nodeIndex of nodesToTurnOffTxGossip) {
+    const logger = createLogger(`p2p:${getNodePort(nodeIndex)}`);
+    jest.spyOn((nodes[nodeIndex] as any).p2pClient.p2pService, 'handleGossipedTx').mockImplementation(((
+      payloadData: Buffer,
+    ) => {
+      const txHash = Tx.fromBuffer(payloadData).getTxHash();
+      logger.info(`Skipping storage of gossiped transaction ${txHash.toString()}`);
+      return Promise.resolve();
+    }) as any);
+  }
+
+  // We send the tx to the proposer nodes directly, ignoring the pxe and node in each context
+  // We cannot just call tx.send since they were created using a pxe wired to the first node which is now stopped
+  t.logger.info('Sending transactions through proposer nodes');
+  const submittedTxs = await Promise.all(
+    txBatches.map(async (batch, batchIndex) => {
+      const proposerNode = nodes[proposerIndexes[batchIndex]];
+      await Promise.all(
+        batch.map(async tx => {
+          try {
+            await proposerNode.sendTx(tx);
+          } catch (err) {
+            t.logger.error(`Error sending tx: ${err}`);
+            throw err;
+          }
+        }),
+      );
+      return batch.map(tx => ({ node: proposerNode, txHash: tx.getTxHash() }));
+    }),
+  );
+
+  t.logger.info('Waiting for all transactions to be mined');
+  await Promise.all(
+    submittedTxs.flatMap((batch, batchIndex) =>
+      batch.map(async (submittedTx, txIndex) => {
+        t.logger.info(`Waiting for tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} to be mined`);
+        await waitForTx(submittedTx.node, submittedTx.txHash, { timeout: WAIT_FOR_TX_TIMEOUT * 1.5 });
+        t.logger.info(`Tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} has been mined`);
+      }),
+    ),
+  );
+
+  t.logger.info('All transactions mined');
+
+  return nodes;
+}
+
+async function getProposerIndexes(t: P2PNetworkTest, startSlotTimestamp: bigint) {
+  // Get the nodes for the next set of slots
+  const rollupContract = new RollupContract(
+    t.ctx.deployL1ContractsValues.l1Client,
+    t.ctx.deployL1ContractsValues.l1ContractAddresses.rollupAddress,
+  );
+
+  const attesters = await rollupContract.getAttesters();
+  const startSlot = await rollupContract.getSlotAt(startSlotTimestamp);
+
+  const proposers = await Promise.all(
+    Array.from({ length: 3 }, async (_, i) => {
+      const slot = SlotNumber(startSlot + i);
+      const slotTimestamp = await rollupContract.getTimestampForSlot(slot);
+      return await rollupContract.getProposerAt(slotTimestamp);
+    }),
+  );
+  // Get the indexes of the nodes that are responsible for the next two slots
+  const proposerIndexes = proposers.map(proposer => attesters.findIndex(a => a.equals(proposer)));
+
+  if (proposerIndexes.some(i => i === -1)) {
+    throw new Error(
+      `Proposer index not found for proposer ` +
+        `(proposers=${proposers.map(p => p.toString()).join(',')}, indices=${proposerIndexes.join(',')})`,
+    );
+  }
+
+  const nodesToTurnOffTxGossip = Array.from({ length: NUM_VALIDATORS }, (_, i) => i).filter(
+    i => !proposerIndexes.includes(i),
+  );
+  return { proposerIndexes, nodesToTurnOffTxGossip };
+}

package/src/e2e_p2p/shared.ts

@@ -1,67 +1,288 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeService } from '@aztec/aztec-node';
-import { type Logger, type SentTx, TxStatus } from '@aztec/aztec.js';
-import type { SpamContract } from '@aztec/noir-contracts.js/Spam';
-import { createPXEService, getPXEServiceConfig as getRpcConfig } from '@aztec/pxe/server';
+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 {
+  EmpireSlashingProposerContract,
+  RollupContract,
+  TallySlashingProposerContract,
+} from '@aztec/ethereum/contracts';
+import { EpochNumber } 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 { type ProvenTx, TestWallet, proveInteraction } from '@aztec/test-wallet/server';
 
-import type { NodeContext } from '../fixtures/setup_p2p_test.js';
 import { submitTxsTo } from '../shared/submit-transactions.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: SentTx[] = [];
+  const txs: TxHash[] = [];
 
   const seed = 1234n;
   const spamCount = 15;
   for (let i = 0; i < numTxs; i++) {
-    const tx = spamContract.methods
-      .spam(seed + BigInt(i * spamCount), spamCount, !!opts.callPublic)
-      .send({ skipPublicSimulation: true });
-    const txHash = await tx.getTxHash();
-
-    logger.info(`Tx sent with hash ${txHash}`);
-    const receipt = await tx.getReceipt();
-    expect(receipt).toEqual(
-      expect.objectContaining({
-        status: TxStatus.PENDING,
-        error: '',
-      }),
-    );
-    logger.info(`Receipt received for ${txHash}`);
-    txs.push(tx);
+    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 an instance of the PXE and submit a given number of transactions to it.
-export const createPXEServiceAndSubmitTransactions = async (
+// 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<NodeContext> => {
+): Promise<TxHash[]> => {
   const rpcConfig = getRpcConfig();
-  const pxeService = await createPXEService(node, rpcConfig, true);
-
-  const account = await getSchnorrAccount(
-    pxeService,
-    fundedAccount.secret,
-    fundedAccount.signingKey,
-    fundedAccount.salt,
+  rpcConfig.proverEnabled = false;
+  const wallet = await TestWallet.create(
+    node,
+    { ...getPXEConfig(), proverEnabled: false },
+    { loggerActorLabel: 'pxe-tx' },
   );
-  await account.register();
-  const wallet = await account.getWallet();
+  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+  return submitTxsTo(wallet, fundedAccountManager.address, numTxs, logger);
+};
 
-  const txs = await submitTxsTo(pxeService, numTxs, wallet, logger);
-  return {
-    txs,
-    pxeService,
+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,
+  );
+  return committee!.map(c => c.toString() as `0x${string}`);
+}
+
+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);
+}