@aztec/end-to-end 0.0.1-commit.d431d1c → 0.0.1-commit.d939eb5aa

package/src/e2e_p2p/shared.ts

@@ -1,17 +1,14 @@
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeService } from '@aztec/aztec-node';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { type SentTx, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+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 { Tx, TxStatus } from '@aztec/aztec.js/tx';
+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 type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { RollupContract, SlashingProposerContract } 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';
@@ -21,10 +18,10 @@ import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.j
 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 { TestWallet, proveInteraction } from '@aztec/test-wallet/server';
 
 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 (
@@ -34,24 +31,15 @@ export const submitComplexTxsTo = async (
   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({ from });
-    const txHash = await tx.getTxHash();
-
+    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()}`);
-    const receipt = await tx.getReceipt();
-    expect(receipt).toEqual(
-      expect.objectContaining({
-        status: TxStatus.PENDING,
-        error: '',
-      }),
-    );
-    logger.info(`Receipt received for ${txHash.toString()}`);
-    txs.push(tx);
+    txs.push(txHash);
   }
   return txs;
 };
@@ -62,10 +50,14 @@ export const submitTransactions = async (
   node: AztecNodeService,
   numTxs: number,
   fundedAccount: InitialAccountData,
-): Promise<SentTx[]> => {
+): Promise<TxHash[]> => {
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
-  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
+  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);
 };
@@ -75,11 +67,15 @@ export async function prepareTransactions(
   node: AztecNodeService,
   numTxs: number,
   fundedAccount: InitialAccountData,
-): Promise<Tx[]> {
+): Promise<ProvenTx[]> {
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
 
-  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
+  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, {
@@ -92,14 +88,13 @@ export async function prepareTransactions(
     const tx = await proveInteraction(wallet, contract.methods.emit_nullifier(Fr.random()), {
       from: fundedAccountManager.address,
     });
-    const txHash = tx.getTxHash();
-    logger.info(`Tx prepared with hash ${txHash}`);
+    logger.info(`Tx prepared with hash ${tx.getTxHash()}`);
     return tx;
   });
 }
 
 export function awaitProposalExecution(
-  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract,
+  slashingProposer: SlashingProposerContract,
   timeoutSeconds: number,
   logger: Logger,
 ): Promise<bigint> {
@@ -109,24 +104,12 @@ export function awaitProposalExecution(
       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 {
+    const unwatch = slashingProposer.listenToRoundExecuted(args => {
+      logger.warn(`Slash from round ${args.round} executed`);
       clearTimeout(timeout);
-      reject(new Error(`Unknown slashing proposer type: ${(slashingProposer as any).type}`));
-    }
+      unwatch();
+      resolve(args.round);
+    });
   });
 }
 
@@ -147,9 +130,62 @@ export async function awaitCommitteeExists({
     '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,
@@ -192,7 +228,6 @@ export async function awaitCommitteeKicked({
   rollup,
   cheatCodes,
   committee,
-  slashFactory,
   slashingProposer,
   slashingRoundSize,
   aztecSlotDuration,
@@ -203,8 +238,7 @@ export async function awaitCommitteeKicked({
   rollup: RollupContract;
   cheatCodes: RollupCheatCodes;
   committee: readonly `0x${string}`[];
-  slashFactory: SlashFactoryContract;
-  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
+  slashingProposer: SlashingProposerContract | undefined;
   slashingRoundSize: number;
   aztecSlotDuration: number;
   aztecEpochDuration: number;
@@ -217,36 +251,14 @@ export async function awaitCommitteeKicked({
 
   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 });
-  }
+  // 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);