@aztec/end-to-end 0.0.1-commit.21caa21 → 0.0.1-commit.2ed92850

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.`);
   }
 }

package/src/fixtures/e2e_prover_test.ts

@@ -11,9 +11,8 @@ import {
   TestCircuitVerifier,
 } from '@aztec/bb-prover';
 import { BackendType, Barretenberg } from '@aztec/bb.js';
-import { createBlobSinkClient } from '@aztec/blob-sink/client';
-import type { BlobSinkServer } from '@aztec/blob-sink/server';
-import type { DeployL1ContractsReturnType } from '@aztec/ethereum';
+import { createBlobClientWithFileStores } from '@aztec/blob-client/client';
+import type { DeployAztecL1ContractsReturnType } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { SecretValue } from '@aztec/foundation/config';
 import { FeeAssetHandlerAbi } from '@aztec/l1-artifacts';
@@ -31,15 +30,15 @@ import { TokenSimulator } from '../simulators/token_simulator.js';
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
 import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
+  type EndToEndContext,
   deployAccounts,
+  getPrivateKeyFromIndex,
+  getSponsoredFPCAddress,
   publicDeployAccounts,
-} from './snapshot_manager.js';
-import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setupPXEAndGetWallet } from './utils.js';
-
-const { E2E_DATA_PATH: dataPath } = process.env;
+  setup,
+  setupPXEAndGetWallet,
+  teardown,
+} from './setup.js';
 
 type ProvenSetup = {
   wallet: TestWallet;
@@ -57,7 +56,6 @@ export class FullProverTest {
   static TOKEN_NAME = 'USDC';
   static TOKEN_SYMBOL = 'USD';
   static TOKEN_DECIMALS = 18n;
-  private snapshotManager: ISnapshotManager;
   logger: Logger;
   wallet!: TestWallet;
   provenWallet!: TestWallet;
@@ -69,111 +67,95 @@ export class FullProverTest {
   aztecNode!: AztecNode;
   aztecNodeAdmin!: AztecNodeAdmin;
   cheatCodes!: CheatCodes;
-  blobSink!: BlobSinkServer;
   private provenComponents: ProvenSetup[] = [];
   private bbConfigCleanup?: () => Promise<void>;
   private acvmConfigCleanup?: () => Promise<void>;
   circuitProofVerifier?: ClientProtocolCircuitVerifier;
   provenAsset!: TokenContract;
-  private context!: SubsystemsContext;
+  context!: EndToEndContext;
   private proverNode!: ProverNode;
   private simulatedProverNode!: ProverNode;
-  public l1Contracts!: DeployL1ContractsReturnType;
+  public l1Contracts!: DeployAztecL1ContractsReturnType;
   public proverAddress!: EthAddress;
+  private minNumberOfTxsPerBlock: number;
+  private coinbase: EthAddress;
+  private realProofs: boolean;
 
-  constructor(
-    testName: string,
-    private minNumberOfTxsPerBlock: number,
-    coinbase: EthAddress,
-    private realProofs = true,
-  ) {
+  constructor(testName: string, minNumberOfTxsPerBlock: number, coinbase: EthAddress, realProofs = true) {
     this.logger = createLogger(`e2e:full_prover_test:${testName}`);
-    this.snapshotManager = createSnapshotManager(
-      `full_prover_integration/${testName}`,
-      dataPath,
-      { startProverNode: true, fundRewardDistributor: true, coinbase },
-      {
-        realVerifier: realProofs,
-      },
-    );
+    this.minNumberOfTxsPerBlock = minNumberOfTxsPerBlock;
+    this.coinbase = coinbase;
+    this.realProofs = realProofs;
   }
 
   /**
-   * Adds two state shifts to snapshot manager.
-   * 1. Add 2 accounts.
-   * 2. Publicly deploy accounts, deploy token contract
+   * Applies base setup: deploys 2 accounts and token contract.
    */
-  async applyBaseSnapshots() {
-    await this.snapshotManager.snapshot(
-      '2_accounts',
-      deployAccounts(2, this.logger),
-      ({ deployedAccounts }, { wallet }) => {
-        this.deployedAccounts = deployedAccounts;
-        this.accounts = deployedAccounts.map(a => a.address);
-        this.wallet = wallet;
-        return Promise.resolve();
-      },
-    );
-
-    await this.snapshotManager.snapshot(
-      'client_prover_integration',
-      async () => {
-        // Create the token contract state.
-        // Move this account thing to addAccounts above?
-        this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
-
-        this.logger.verbose(`Deploying TokenContract...`);
-        const { contract: asset, instance } = await TokenContract.deploy(
-          this.wallet,
-          this.accounts[0],
-          FullProverTest.TOKEN_NAME,
-          FullProverTest.TOKEN_SYMBOL,
-          FullProverTest.TOKEN_DECIMALS,
-        )
-          .send({ from: this.accounts[0] })
-          .wait();
-        this.logger.verbose(`Token deployed to ${asset.address}`);
-
-        return { tokenContractAddress: asset.address, tokenContractInstance: instance };
-      },
-      async ({ tokenContractAddress, tokenContractInstance }) => {
-        // Restore the token contract state.
-        this.fakeProofsAsset = TokenContract.at(tokenContractAddress, this.wallet);
-        this.fakeProofsAssetInstance = tokenContractInstance;
-        this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
-
-        this.tokenSim = new TokenSimulator(
-          this.fakeProofsAsset,
-          this.wallet,
-          this.accounts[0],
-          this.logger,
-          this.accounts,
-        );
-
-        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0] })).toBe(
-          this.accounts[0].toBigInt(),
-        );
-      },
+  private async applyBaseSetup() {
+    this.logger.info('Applying base setup: deploying accounts');
+    const { deployedAccounts } = await deployAccounts(
+      2,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
+    this.deployedAccounts = deployedAccounts;
+    this.accounts = deployedAccounts.map(a => a.address);
+    this.wallet = this.context.wallet;
+
+    this.logger.info('Applying base setup: publicly deploying accounts');
+    await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
+
+    this.logger.info('Applying base setup: deploying token contract');
+    const { contract: asset, instance } = await TokenContract.deploy(
+      this.wallet,
+      this.accounts[0],
+      FullProverTest.TOKEN_NAME,
+      FullProverTest.TOKEN_SYMBOL,
+      FullProverTest.TOKEN_DECIMALS,
+    ).send({ from: this.accounts[0], wait: { returnReceipt: true } });
+    this.logger.verbose(`Token deployed to ${asset.address}`);
+
+    this.fakeProofsAsset = asset;
+    this.fakeProofsAssetInstance = instance;
+    this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
+
+    this.tokenSim = new TokenSimulator(this.fakeProofsAsset, this.wallet, this.accounts[0], this.logger, this.accounts);
+
+    expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0] })).toBe(
+      this.accounts[0].toBigInt(),
     );
   }
 
   async setup() {
-    this.context = await this.snapshotManager.setup();
+    this.logger.info('Setting up subsystems from fresh');
+    this.context = await setup(0, {
+      startProverNode: true,
+      coinbase: this.coinbase,
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+      l1ContractsArgs: { realVerifier: this.realProofs },
+    });
+
+    await this.applyBaseSetup();
+    await this.applyMint();
+
+    this.logger.info(`Enabling proving`, { realProofs: this.realProofs });
 
     // We don't wish to mark as proven automatically, so we set the flag to false
-    this.context.watcher.setIsMarkingAsProven(false);
+    this.context.watcher!.setIsMarkingAsProven(false);
 
     this.simulatedProverNode = this.context.proverNode!;
     ({
       aztecNode: this.aztecNode,
       deployL1ContractsValues: this.l1Contracts,
       cheatCodes: this.cheatCodes,
-      blobSink: this.blobSink,
     } = this.context);
-    this.aztecNodeAdmin = this.context.aztecNode;
+    this.aztecNodeAdmin = this.context.aztecNodeService!;
 
-    const blobSinkClient = createBlobSinkClient({ blobSinkUrl: `http://localhost:${this.blobSink.port}` });
+    const config = this.context.aztecNodeConfig;
+    const blobClient = await createBlobClientWithFileStores(config, this.logger);
 
     // Configure a full prover PXE
     let acvmConfig: Awaited<ReturnType<typeof getACVMConfig>> | undefined;
@@ -243,7 +225,7 @@ export class FullProverTest {
     this.logger.verbose('Starting archiver for new prover node');
     const archiver = await createArchiver(
       { ...this.context.aztecNodeConfig, dataDirectory: undefined },
-      { blobSinkClient, dateProvider: this.context.dateProvider },
+      { blobClient, dateProvider: this.context.dateProvider! },
       { blockUntilSync: true },
     );
 
@@ -283,13 +265,12 @@ export class FullProverTest {
       {
         aztecNodeTxProvider: this.aztecNode,
         archiver: archiver as Archiver,
-        blobSinkClient,
       },
       { prefilledPublicData },
     );
     await this.proverNode.start();
 
-    this.logger.warn(`Proofs are now enabled`);
+    this.logger.warn(`Proofs are now enabled`, { realProofs: this.realProofs });
     return this;
   }
 
@@ -302,15 +283,7 @@ export class FullProverTest {
     await this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash });
   }
 
-  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);
-
   async teardown() {
-    await this.snapshotManager.teardown();
-
     // Cleanup related to the full prover PXEs
     for (let i = 0; i < this.provenComponents.length; i++) {
       await this.provenComponents[i].teardown();
@@ -322,52 +295,42 @@ export class FullProverTest {
     await Barretenberg.destroySingleton();
     await this.bbConfigCleanup?.();
     await this.acvmConfigCleanup?.();
+
+    await teardown(this.context);
   }
 
-  async applyMintSnapshot() {
-    await this.snapshotManager.snapshot(
-      'mint',
-      async () => {
-        const { fakeProofsAsset: asset, accounts } = this;
-        const privateAmount = 10000n;
-        const publicAmount = 10000n;
+  private async applyMint() {
+    this.logger.info('Applying mint setup');
+    const { fakeProofsAsset: asset, accounts } = this;
+    const privateAmount = 10000n;
+    const publicAmount = 10000n;
 
-        this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
-        await asset.methods
-          .mint_to_public(accounts[0], privateAmount + publicAmount)
-          .send({ from: accounts[0] })
-          .wait();
+    this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
+    await asset.methods.mint_to_public(accounts[0], privateAmount + publicAmount).send({ from: accounts[0] });
 
-        this.logger.verbose(`Transferring ${privateAmount} to private...`);
-        await asset.methods.transfer_to_private(accounts[0], privateAmount).send({ from: accounts[0] }).wait();
+    this.logger.verbose(`Transferring ${privateAmount} to private...`);
+    await asset.methods.transfer_to_private(accounts[0], privateAmount).send({ from: accounts[0] });
 
-        this.logger.verbose(`Minting complete.`);
+    this.logger.info(`Minting complete`);
 
-        return { amount: publicAmount };
-      },
-      async ({ amount }) => {
-        const {
-          fakeProofsAsset: asset,
-          accounts: [address],
-          tokenSim,
-        } = this;
-        tokenSim.mintPublic(address, amount);
-
-        const publicBalance = await asset.methods.balance_of_public(address).simulate({ from: address });
-        this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
-
-        tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate({ from: address });
-        this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
-
-        const totalSupply = await asset.methods.total_supply().simulate({ from: address });
-        this.logger.verbose(`Total supply: ${totalSupply}`);
-        expect(totalSupply).toEqual(tokenSim.totalSupply);
-
-        return Promise.resolve();
-      },
-    );
+    const {
+      fakeProofsAsset,
+      accounts: [address],
+      tokenSim,
+    } = this;
+    tokenSim.mintPublic(address, publicAmount);
+
+    const publicBalance = await fakeProofsAsset.methods.balance_of_public(address).simulate({ from: address });
+    this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
+    expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
+
+    tokenSim.mintPrivate(address, publicAmount);
+    const privateBalance = await fakeProofsAsset.methods.balance_of_private(address).simulate({ from: address });
+    this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
+    expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
+
+    const totalSupply = await fakeProofsAsset.methods.total_supply().simulate({ from: address });
+    this.logger.verbose(`Total supply: ${totalSupply}`);
+    expect(totalSupply).toEqual(tokenSim.totalSupply);
   }
 }

package/src/fixtures/fixtures.ts

@@ -8,7 +8,7 @@ export const shouldCollectMetrics = () => {
 };
 
 export const TEST_PEER_CHECK_INTERVAL_MS = 1000;
-export const TEST_MAX_TX_POOL_SIZE = 2 * 1024 * 1024 * 1024; // 2GB
+export const TEST_MAX_PENDING_TX_POOL_COUNT = 10_000; // Number of max pending TXs ~ 1.56GB
 
 export const MNEMONIC = 'test test test test test test test test test test test junk';
 export const privateKey = Buffer.from('ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80', 'hex');
@@ -22,8 +22,5 @@ export const BITSIZE_TOO_BIG_ERROR = "Assertion failed: call to assert_max_bit_s
 export const DUPLICATE_NULLIFIER_ERROR = /dropped|nullifier|reverted/i;
 export const NO_L1_TO_L2_MSG_ERROR =
   /No non-nullified L1 to L2 message found for message hash|Tried to consume nonexistent L1-to-L2 message/;
-export const STATIC_CALL_STATE_MODIFICATION_ERROR =
-  /Static call cannot update the state, emit L2->L1 messages or generate logs.*/;
+export const STATIC_CALL_STATE_MODIFICATION_ERROR = /Static call cannot update the state.*/;
 export const STATIC_CONTEXT_ASSERTION_ERROR = /Assertion failed: Function .* can only be called statically.*/;
-
-export const DEFAULT_BLOB_SINK_PORT = '5052';

package/src/fixtures/get_acvm_config.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '@aztec/aztec.js/log';
 import { parseBooleanEnv } from '@aztec/foundation/config';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import { tryRmDir } from '@aztec/foundation/fs';
 
 import { promises as fs } from 'fs';

package/src/fixtures/l1_to_l2_messaging.ts

@@ -1,5 +1,7 @@
-import { type ExtendedViemWalletClient, type L1ContractAddresses, RollupContract } from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { tryJsonStringify } from '@aztec/foundation/json-rpc';
 import { InboxAbi } from '@aztec/l1-artifacts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';