@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/e2e_p2p/shared.ts

@@ -1,16 +1,30 @@
-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 { type SentTx, 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 type { RollupCheatCodes } from '@aztec/aztec/testing';
+import type { EmpireSlashingProposerContract, RollupContract, TallySlashingProposerContract } from '@aztec/ethereum';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { timesAsync, unique } from '@aztec/foundation/collection';
+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 { 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 } = {},
@@ -20,12 +34,10 @@ export const submitComplexTxsTo = async (
   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 tx = spamContract.methods.spam(seed + BigInt(i * spamCount), spamCount, !!opts.callPublic).send({ from });
     const txHash = await tx.getTxHash();
 
-    logger.info(`Tx sent with hash ${txHash}`);
+    logger.info(`Tx sent with hash ${txHash.toString()}`);
     const receipt = await tx.getReceipt();
     expect(receipt).toEqual(
       expect.objectContaining({
@@ -33,35 +45,241 @@ export const submitComplexTxsTo = async (
         error: '',
       }),
     );
-    logger.info(`Receipt received for ${txHash}`);
+    logger.info(`Receipt received for ${txHash.toString()}`);
     txs.push(tx);
   }
   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<SentTx[]> => {
   const rpcConfig = getRpcConfig();
-  const pxeService = await createPXEService(node, rpcConfig, true);
+  rpcConfig.proverEnabled = false;
+  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
+  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+  return submitTxsTo(wallet, fundedAccountManager.address, numTxs, logger);
+};
+
+export async function prepareTransactions(
+  logger: Logger,
+  node: AztecNodeService,
+  numTxs: number,
+  fundedAccount: InitialAccountData,
+): Promise<Tx[]> {
+  const rpcConfig = getRpcConfig();
+  rpcConfig.proverEnabled = false;
+
+  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
+  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,
+    });
+    const txHash = tx.getTxHash();
+    logger.info(`Tx prepared with hash ${txHash}`);
+    return tx;
+  });
+}
 
-  const account = await getSchnorrAccount(
-    pxeService,
-    fundedAccount.secret,
-    fundedAccount.signingKey,
-    fundedAccount.salt,
+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: readonly `0x${string}`[] | undefined;
+  await retryUntil(
+    async () => {
+      committee = await rollup.getCurrentEpochCommittee();
+      return committee && committee.length > 0;
+    },
+    'non-empty committee',
+    60,
   );
-  await account.register();
-  const wallet = await account.getWallet();
-
-  const txs = await submitTxsTo(pxeService, numTxs, wallet, logger);
-  return {
-    txs,
-    pxeService,
-    node,
-  };
-};
+  return committee!;
+}
+
+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 = BigInt(await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1n;
+    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
+    await cheatCodes.advanceToEpoch(EpochNumber.fromBigInt(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.fromBigInt(BigInt(await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1n),
+  );
+  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);
+}

package/src/e2e_token_contract/token_contract_test.ts

@@ -1,7 +1,9 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { type AccountWallet, type CompleteAddress, type Logger, createLogger } from '@aztec/aztec.js';
-import { DocsExampleContract } from '@aztec/noir-contracts.js/DocsExample';
+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 { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
+import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { jest } from '@jest/globals';
 
@@ -23,11 +25,15 @@ export class TokenContractTest {
   static TOKEN_DECIMALS = 18n;
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallets: AccountWallet[] = [];
-  accounts: CompleteAddress[] = [];
   asset!: TokenContract;
   tokenSim!: TokenSimulator;
-  badAccount!: DocsExampleContract;
+  node!: AztecNode;
+
+  badAccount!: InvalidAccountContract;
+  wallet!: TestWallet;
+  adminAddress!: AztecAddress;
+  account1Address!: AztecAddress;
+  account2Address!: AztecAddress;
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_token_contract:${testName}`);
@@ -48,9 +54,11 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe }) => {
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.accounts = this.wallets.map(w => w.getCompleteAddress());
+      ({ deployedAccounts }, { wallet, aztecNode }) => {
+        this.node = aztecNode;
+        this.wallet = wallet;
+        [this.adminAddress, this.account1Address, this.account2Address] = deployedAccounts.map(acc => acc.address);
+        return Promise.resolve();
       },
     );
 
@@ -60,42 +68,42 @@ export class TokenContractTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 2));
+        await publicDeployAccounts(this.wallet, [this.adminAddress, this.account1Address]);
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
-          this.wallets[0],
-          this.accounts[0],
+          this.wallet,
+          this.adminAddress,
           TokenContractTest.TOKEN_NAME,
           TokenContractTest.TOKEN_SYMBOL,
           TokenContractTest.TOKEN_DECIMALS,
         )
-          .send()
+          .send({ from: this.adminAddress })
           .deployed();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
         this.logger.verbose(`Deploying bad account...`);
-        this.badAccount = await DocsExampleContract.deploy(this.wallets[0]).send().deployed();
+        this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress }).deployed();
         this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
         return { tokenContractAddress: asset.address, badAccountAddress: this.badAccount.address };
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenContract.at(tokenContractAddress, this.wallets[0]);
+        this.asset = TokenContract.at(tokenContractAddress, this.wallet);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
-        this.tokenSim = new TokenSimulator(
-          this.asset,
-          this.wallets[0],
-          this.logger,
-          this.accounts.map(a => a.address),
-        );
+        this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
+          this.adminAddress,
+          this.account1Address,
+        ]);
 
-        this.badAccount = await DocsExampleContract.at(badAccountAddress, this.wallets[0]);
+        this.badAccount = InvalidAccountContract.at(badAccountAddress, this.wallet);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
-        expect(await this.asset.methods.get_admin().simulate()).toBe(this.accounts[0].address.toBigInt());
+        expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
+          this.adminAddress.toBigInt(),
+        );
       },
     );
 
@@ -123,36 +131,32 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       'mint',
       async () => {
-        const { asset, wallets } = this;
+        const { asset, adminAddress } = this;
         const amount = 10000n;
 
         this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_to_public(wallets[0].getAddress(), amount).send().wait();
+        await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress }).wait();
 
         this.logger.verbose(`Minting ${amount} privately...`);
-        await mintTokensToPrivate(asset, wallets[0], wallets[0].getAddress(), amount);
+        await mintTokensToPrivate(asset, adminAddress, adminAddress, amount);
         this.logger.verbose(`Minting complete.`);
 
         return { amount };
       },
       async ({ amount }) => {
-        const {
-          asset,
-          accounts: [{ address }],
-          tokenSim,
-        } = this;
-        tokenSim.mintPublic(address, amount);
-
-        const publicBalance = await asset.methods.balance_of_public(address).simulate();
+        const { asset, adminAddress, tokenSim } = this;
+        tokenSim.mintPublic(adminAddress, amount);
+
+        const publicBalance = await asset.methods.balance_of_public(adminAddress).simulate({ from: adminAddress });
         this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
+        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(adminAddress));
 
-        tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate();
+        tokenSim.mintPrivate(adminAddress, amount);
+        const privateBalance = await asset.methods.balance_of_private(adminAddress).simulate({ from: adminAddress });
         this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
+        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(adminAddress));
 
-        const totalSupply = await asset.methods.total_supply().simulate();
+        const totalSupply = await asset.methods.total_supply().simulate({ from: adminAddress });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);