@aztec/end-to-end 0.0.1-commit.c7c42ec → 0.0.1-commit.c80b6263

package/src/e2e_p2p/shared.ts

@@ -1,10 +1,10 @@
 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,
@@ -13,6 +13,7 @@ import type {
 } 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';
@@ -21,7 +22,7 @@ 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 ProvenTx, TestWallet, proveInteraction } from '@aztec/test-wallet/server';
 
 import { submitTxsTo } from '../shared/submit-transactions.js';
 
@@ -33,24 +34,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;
 };
@@ -61,10 +53,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);
 };
@@ -74,11 +70,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, {
@@ -91,8 +91,7 @@ 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;
   });
 }
@@ -137,7 +136,7 @@ export async function awaitCommitteeExists({
   logger: Logger;
 }): Promise<readonly `0x${string}`[]> {
   logger.info(`Waiting for committee to be set`);
-  let committee: readonly `0x${string}`[] | undefined;
+  let committee: EthAddress[] | undefined;
   await retryUntil(
     async () => {
       committee = await rollup.getCurrentEpochCommittee();
@@ -146,7 +145,7 @@ export async function awaitCommitteeExists({
     'non-empty committee',
     60,
   );
-  return committee!;
+  return committee!.map(c => c.toString() as `0x${string}`);
 }
 
 export async function awaitOffenseDetected({
@@ -218,9 +217,9 @@ export async function awaitCommitteeKicked({
 
   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;
+    const targetEpoch = EpochNumber((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1);
     logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(EpochNumber.fromBigInt(targetEpoch));
+    await cheatCodes.advanceToEpoch(targetEpoch);
 
     const slashPayloadEvents = await retryUntil(
       async () => {
@@ -275,7 +274,7 @@ export async function awaitCommitteeKicked({
   logger.info(`Advancing to check current committee`);
   await cheatCodes.debugRollup();
   await cheatCodes.advanceToEpoch(
-    EpochNumber.fromBigInt(BigInt(await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1n),
+    EpochNumber((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1),
   );
   await cheatCodes.debugRollup();
 

package/src/e2e_token_contract/token_contract_test.ts

@@ -7,24 +7,19 @@ import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { jest } from '@jest/globals';
 
-import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
-  deployAccounts,
-  publicDeployAccounts,
-} from '../fixtures/snapshot_manager.js';
+import { type EndToEndContext, deployAccounts, publicDeployAccounts, setup, teardown } from '../fixtures/setup.js';
 import { mintTokensToPrivate } from '../fixtures/token_utils.js';
 import { TokenSimulator } from '../simulators/token_simulator.js';
 
-const { E2E_DATA_PATH: dataPath, METRICS_PORT: metricsPort } = process.env;
+const { METRICS_PORT: metricsPort } = process.env;
 
 export class TokenContractTest {
   static TOKEN_NAME = 'USDC';
   static TOKEN_SYMBOL = 'USD';
   static TOKEN_DECIMALS = 18n;
-  private snapshotManager: ISnapshotManager;
+  context!: EndToEndContext;
   logger: Logger;
+  metricsPort?: number;
   asset!: TokenContract;
   tokenSim!: TokenSimulator;
   node!: AztecNode;
@@ -35,133 +30,123 @@ export class TokenContractTest {
   account1Address!: AztecAddress;
   account2Address!: AztecAddress;
 
+  private shouldApplyBaseSetup = false;
+  private shouldApplyMint = false;
+
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_token_contract:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_token_contract/${testName}`, dataPath, {
-      metricsPort: metricsPort ? parseInt(metricsPort) : undefined,
-    });
+    this.metricsPort = metricsPort ? parseInt(metricsPort) : undefined;
+  }
+
+  /**
+   * Registers that base setup should be applied during setup().
+   * Call this before setup() to deploy 3 accounts, publicly deploy accounts, token contract and a "bad account".
+   */
+  applyBaseSnapshots() {
+    this.shouldApplyBaseSetup = true;
   }
 
   /**
-   * Adds two state shifts to snapshot manager.
-   * 1. Add 3 accounts.
-   * 2. Publicly deploy accounts, deploy token contract and a "bad account".
+   * Registers that mint should be applied during setup().
+   * Call this before setup() to mint tokens to the admin account.
    */
-  async applyBaseSnapshots() {
+  applyMintSnapshot() {
+    this.shouldApplyMint = true;
+  }
+
+  /**
+   * Applies base setup: deploys 3 accounts, publicly deploys accounts, token contract and a "bad account".
+   */
+  private async applyBaseSetup() {
     // Adding a timeout of 2 minutes in here such that it is propagated to the underlying tests
     jest.setTimeout(120_000);
 
-    await this.snapshotManager.snapshot(
-      '3_accounts',
-      deployAccounts(3, this.logger),
-      ({ deployedAccounts }, { wallet, aztecNode }) => {
-        this.node = aztecNode;
-        this.wallet = wallet;
-        [this.adminAddress, this.account1Address, this.account2Address] = deployedAccounts.map(acc => acc.address);
-        return Promise.resolve();
-      },
-    );
+    this.logger.info('Applying base setup - deploying 3 accounts');
+    const { deployedAccounts } = await deployAccounts(
+      3,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
 
-    await this.snapshotManager.snapshot(
-      'e2e_token_contract',
-      async () => {
-        // Create the token contract state.
-        // Move this account thing to addAccounts above?
-        this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallet, [this.adminAddress, this.account1Address]);
-
-        this.logger.verbose(`Deploying TokenContract...`);
-        const asset = await TokenContract.deploy(
-          this.wallet,
-          this.adminAddress,
-          TokenContractTest.TOKEN_NAME,
-          TokenContractTest.TOKEN_SYMBOL,
-          TokenContractTest.TOKEN_DECIMALS,
-        )
-          .send({ from: this.adminAddress })
-          .deployed();
-        this.logger.verbose(`Token deployed to ${asset.address}`);
-
-        this.logger.verbose(`Deploying bad account...`);
-        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 = TokenContract.at(tokenContractAddress, this.wallet);
-        this.logger.verbose(`Token contract address: ${this.asset.address}`);
-
-        this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
-          this.adminAddress,
-          this.account1Address,
-        ]);
-
-        this.badAccount = InvalidAccountContract.at(badAccountAddress, this.wallet);
-        this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
-
-        expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
-          this.adminAddress.toBigInt(),
-        );
-      },
+    this.node = this.context.aztecNodeService!;
+    this.wallet = this.context.wallet;
+    [this.adminAddress, this.account1Address, this.account2Address] = deployedAccounts.map(acc => acc.address);
+
+    this.logger.info('Applying base setup - deploying token contract');
+    this.logger.verbose(`Public deploy accounts...`);
+    await publicDeployAccounts(this.wallet, [this.adminAddress, this.account1Address]);
+
+    this.logger.verbose(`Deploying TokenContract...`);
+    this.asset = await TokenContract.deploy(
+      this.wallet,
+      this.adminAddress,
+      TokenContractTest.TOKEN_NAME,
+      TokenContractTest.TOKEN_SYMBOL,
+      TokenContractTest.TOKEN_DECIMALS,
+    ).send({ from: this.adminAddress });
+    this.logger.verbose(`Token deployed to ${this.asset.address}`);
+
+    this.logger.verbose(`Deploying bad account...`);
+    this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress });
+    this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
+
+    this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
+      this.adminAddress,
+      this.account1Address,
+    ]);
+
+    expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
+      this.adminAddress.toBigInt(),
     );
-
-    // TokenContract.artifact.functions.forEach(fn => {
-    //   const sig = decodeFunctionSignature(fn.name, fn.parameters);
-    //   logger.verbose(`Function ${sig} and the selector: ${FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)}`);
-    // });
   }
 
   async setup() {
-    await this.snapshotManager.setup();
-  }
+    this.context = await setup(0, {
+      metricsPort: this.metricsPort,
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+    });
 
-  snapshot = <T>(
-    name: string,
-    apply: (context: SubsystemsContext) => Promise<T>,
-    restore: (snapshotData: T, context: SubsystemsContext) => Promise<void> = () => Promise.resolve(),
-  ): Promise<void> => this.snapshotManager.snapshot(name, apply, restore);
+    if (this.shouldApplyBaseSetup) {
+      await this.applyBaseSetup();
+    }
+
+    if (this.shouldApplyMint) {
+      await this.applyMint();
+    }
+  }
 
   async teardown() {
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
-  async applyMintSnapshot() {
-    await this.snapshotManager.snapshot(
-      'mint',
-      async () => {
-        const { asset, adminAddress } = this;
-        const amount = 10000n;
-
-        this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress }).wait();
-
-        this.logger.verbose(`Minting ${amount} privately...`);
-        await mintTokensToPrivate(asset, adminAddress, adminAddress, amount);
-        this.logger.verbose(`Minting complete.`);
-
-        return { amount };
-      },
-      async ({ amount }) => {
-        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(adminAddress));
-
-        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(adminAddress));
-
-        const totalSupply = await asset.methods.total_supply().simulate({ from: adminAddress });
-        this.logger.verbose(`Total supply: ${totalSupply}`);
-        expect(totalSupply).toEqual(tokenSim.totalSupply);
-
-        return Promise.resolve();
-      },
-    );
+  private async applyMint() {
+    this.logger.info('Applying mint setup');
+    const { asset, adminAddress, tokenSim } = this;
+    const amount = 10000n;
+
+    this.logger.verbose(`Minting ${amount} publicly...`);
+    await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress });
+    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(adminAddress));
+
+    this.logger.verbose(`Minting ${amount} privately...`);
+    await mintTokensToPrivate(asset, adminAddress, adminAddress, amount);
+    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(adminAddress));
+
+    const totalSupply = await asset.methods.total_supply().simulate({ from: adminAddress });
+    this.logger.verbose(`Total supply: ${totalSupply}`);
+    expect(totalSupply).toEqual(tokenSim.totalSupply);
+
+    this.logger.verbose(`Minting complete.`);
   }
 }