@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -1,22 +1,25 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
 import type { AztecNodeConfig } from '@aztec/aztec-node';
-import {
-  type AccountWallet,
-  AztecAddress,
-  type AztecNode,
-  CheatCodes,
-  type CompleteAddress,
-  EthAddress,
-  type Logger,
-  type PXE,
-  createLogger,
-} from '@aztec/aztec.js';
-import { type ViemPublicClient, createL1Clients, deployL1Contract } from '@aztec/ethereum';
-import { InboxAbi, OutboxAbi, RollupAbi, TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { waitForProven } from '@aztec/aztec.js/contracts';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { TxReceipt } from '@aztec/aztec.js/tx';
+import { CheatCodes } from '@aztec/aztec/testing';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { InboxContract, OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import type {
+  DeployAztecL1ContractsArgs,
+  DeployAztecL1ContractsReturnType,
+} from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import { sleep } from '@aztec/foundation/sleep';
+import { TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
-
-import { getContract } from 'viem';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { MNEMONIC } from '../fixtures/fixtures.js';
 import {
@@ -26,49 +29,83 @@ import {
   deployAccounts,
   publicDeployAccounts,
 } from '../fixtures/snapshot_manager.js';
+import type { SetupOptions } from '../fixtures/utils.js';
 import { CrossChainTestHarness } from '../shared/cross_chain_test_harness.js';
 
 const { E2E_DATA_PATH: dataPath } = process.env;
 
 export class CrossChainMessagingTest {
   private snapshotManager: ISnapshotManager;
+  private requireEpochProven: boolean;
   logger: Logger;
-  wallets: AccountWallet[] = [];
-  accounts: CompleteAddress[] = [];
   aztecNode!: AztecNode;
-  pxe!: PXE;
   aztecNodeConfig!: AztecNodeConfig;
+  aztecNodeAdmin!: AztecNodeAdmin;
+  ctx!: SubsystemsContext;
 
-  publicClient!: ViemPublicClient | undefined;
+  l1Client!: ExtendedViemWalletClient | undefined;
 
-  user1Wallet!: AccountWallet;
-  user2Wallet!: AccountWallet;
+  wallet!: TestWallet;
+  ownerAddress!: AztecAddress;
+  user1Address!: AztecAddress;
+  user2Address!: AztecAddress;
   crossChainTestHarness!: CrossChainTestHarness;
   ethAccount!: EthAddress;
-  ownerAddress!: AztecAddress;
   l2Token!: TokenContract;
   l2Bridge!: TokenBridgeContract;
 
-  rollup!: any; // GetContractReturnType<typeof RollupAbi> | undefined;
-  inbox!: any; // GetContractReturnType<typeof InboxAbi> | undefined;
-  outbox!: any; // GetContractReturnType<typeof OutboxAbi> | undefined;
-  cheatcodes!: CheatCodes;
+  rollup!: RollupContract;
+  inbox!: InboxContract;
+  outbox!: OutboxContract;
+  cheatCodes!: CheatCodes;
+
+  deployL1ContractsValues!: DeployAztecL1ContractsReturnType;
 
-  constructor(testName: string) {
+  constructor(
+    testName: string,
+    opts: SetupOptions = {},
+    deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {},
+  ) {
     this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_cross_chain_messaging/${testName}`, dataPath);
+    this.snapshotManager = createSnapshotManager(`e2e_cross_chain_messaging/${testName}`, dataPath, opts, {
+      initialValidators: [],
+      ...deployL1ContractsArgs,
+    });
+    this.requireEpochProven = opts.startProverNode ?? false;
   }
 
-  async assumeProven() {
-    await this.cheatcodes.rollup.markAsProven(await this.rollup.read.getPendingBlockNumber());
+  async setup() {
+    this.ctx = await this.snapshotManager.setup();
+    this.aztecNode = this.ctx.aztecNode;
+    this.wallet = this.ctx.wallet;
+    this.aztecNodeConfig = this.ctx.aztecNodeConfig;
+    this.cheatCodes = this.ctx.cheatCodes;
+    this.deployL1ContractsValues = this.ctx.deployL1ContractsValues;
+    this.aztecNodeAdmin = this.ctx.aztecNode;
+
+    if (this.requireEpochProven) {
+      // Turn off the watcher to prevent it from keep marking blocks as proven.
+      this.ctx.watcher.setIsMarkingAsProven(false);
+    }
   }
 
-  async setup() {
-    const { aztecNode, pxe, aztecNodeConfig } = await this.snapshotManager.setup();
-    this.aztecNode = aztecNode;
-    this.pxe = pxe;
-    this.aztecNodeConfig = aztecNodeConfig;
-    this.cheatcodes = await CheatCodes.create(this.aztecNodeConfig.l1RpcUrls, this.pxe);
+  async advanceToEpochProven(l2TxReceipt: TxReceipt): Promise<EpochNumber> {
+    const epoch = await this.rollup.getEpochNumberForCheckpoint(
+      CheckpointNumber.fromBlockNumber(l2TxReceipt.blockNumber!),
+    );
+    // Warp to the next epoch.
+    await this.cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
+    // Wait for the tx to be proven.
+    await waitForProven(this.aztecNode, l2TxReceipt, { provenTimeout: 300 });
+    // Return the epoch the tx is in.
+    return epoch;
+  }
+
+  async catchUpProvenChain() {
+    const bn = await this.aztecNode.getBlockNumber();
+    while ((await this.aztecNode.getProvenBlockNumber()) < bn) {
+      await sleep(1000);
+    }
   }
 
   snapshot = <T>(
@@ -82,29 +119,18 @@ export class CrossChainMessagingTest {
   }
 
   async applyBaseSnapshots() {
-    // Note that we are using the same `pxe`, `aztecNodeConfig` and `aztecNode` across all snapshots.
+    // Note that we are using the same `wallet`, `aztecNodeConfig` and `aztecNode` across all snapshots.
     // This is to not have issues with different networks.
 
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe, aztecNodeConfig, aztecNode, deployL1ContractsValues }) => {
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.accounts = this.wallets.map(w => w.getCompleteAddress());
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-
-        this.rollup = getContract({
-          address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
-          abi: RollupAbi,
-          client: deployL1ContractsValues.walletClient,
-        });
-
-        this.user1Wallet = this.wallets[0];
-        this.user2Wallet = this.wallets[1];
-
-        this.pxe = pxe;
+      ({ deployedAccounts }, { wallet, aztecNodeConfig, aztecNode }) => {
+        [this.ownerAddress, this.user1Address, this.user2Address] = deployedAccounts.map(a => a.address);
+        this.wallet = wallet;
         this.aztecNode = aztecNode;
         this.aztecNodeConfig = aztecNodeConfig;
+        return Promise.resolve();
       },
     );
 
@@ -114,107 +140,62 @@ export class CrossChainMessagingTest {
         // 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, 3));
-
-        const { publicClient, walletClient } = createL1Clients(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+        await publicDeployAccounts(this.wallet, [this.ownerAddress, this.user1Address, this.user2Address]);
 
-        const underlyingERC20Address = await deployL1Contract(
-          walletClient,
-          publicClient,
-          TestERC20Abi,
-          TestERC20Bytecode,
-          ['Underlying', 'UND', walletClient.account.address],
-        ).then(({ address }) => address);
+        this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
 
-        const underlyingERC20 = getContract({
-          address: underlyingERC20Address!.toString(),
-          abi: TestERC20Abi,
-          client: walletClient,
-        });
-
-        // allow anyone to mint
-        await underlyingERC20.write.setFreeForAll([true], {} as any);
+        const underlyingERC20Address = await deployL1Contract(this.l1Client, TestERC20Abi, TestERC20Bytecode, [
+          'Underlying',
+          'UND',
+          this.l1Client.account.address,
+        ]).then(({ address }) => address);
 
         this.logger.verbose(`Setting up cross chain harness...`);
         this.crossChainTestHarness = await CrossChainTestHarness.new(
           this.aztecNode,
-          this.pxe,
-          publicClient,
-          walletClient,
-          this.wallets[0],
+          this.l1Client,
+          this.wallet,
+          this.ownerAddress,
           this.logger,
           underlyingERC20Address,
         );
 
         this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
 
-        return this.toCrossChainContext();
+        return this.crossChainTestHarness.toCrossChainContext();
       },
-      async crossChainContext => {
-        this.l2Token = await TokenContract.at(crossChainContext.l2Token, this.user1Wallet);
-        this.l2Bridge = await TokenBridgeContract.at(crossChainContext.l2Bridge, this.user1Wallet);
+      crossChainContext => {
+        this.l2Token = TokenContract.at(crossChainContext.l2Token, this.wallet);
+        this.l2Bridge = TokenBridgeContract.at(crossChainContext.l2Bridge, this.wallet);
 
         // There is an issue with the reviver so we are getting strings sometimes. Working around it here.
         this.ethAccount = EthAddress.fromString(crossChainContext.ethAccount.toString());
-        this.ownerAddress = AztecAddress.fromString(crossChainContext.ownerAddress.toString());
         const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
 
-        const { publicClient, walletClient } = createL1Clients(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+        const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+        this.l1Client = l1Client;
 
-        const inbox = getContract({
-          address: this.aztecNodeConfig.l1Contracts.inboxAddress.toString(),
-          abi: InboxAbi,
-          client: walletClient,
-        });
-        const outbox = getContract({
-          address: this.aztecNodeConfig.l1Contracts.outboxAddress.toString(),
-          abi: OutboxAbi,
-          client: walletClient,
-        });
+        const l1Contracts = this.aztecNodeConfig.l1Contracts;
+        this.rollup = new RollupContract(l1Client, l1Contracts.rollupAddress.toString());
+        this.inbox = new InboxContract(l1Client, l1Contracts.inboxAddress.toString());
+        this.outbox = new OutboxContract(l1Client, l1Contracts.outboxAddress.toString());
 
         this.crossChainTestHarness = new CrossChainTestHarness(
           this.aztecNode,
-          this.pxe,
           this.logger,
           this.l2Token,
           this.l2Bridge,
           this.ethAccount,
           tokenPortalAddress,
           crossChainContext.underlying,
-          publicClient,
-          walletClient,
+          l1Client,
           this.aztecNodeConfig.l1Contracts,
-          this.user1Wallet,
+          this.wallet,
+          this.ownerAddress,
         );
 
-        this.publicClient = publicClient;
-        this.inbox = inbox;
-        this.outbox = outbox;
+        return Promise.resolve();
       },
     );
   }
-
-  toCrossChainContext(): CrossChainContext {
-    return {
-      l2Token: this.crossChainTestHarness.l2Token.address,
-      l2Bridge: this.crossChainTestHarness.l2Bridge.address,
-      tokenPortal: this.crossChainTestHarness.tokenPortalAddress,
-      underlying: this.crossChainTestHarness.underlyingERC20Address,
-      ethAccount: this.crossChainTestHarness.ethAccount,
-      ownerAddress: this.crossChainTestHarness.ownerAddress,
-      inbox: this.crossChainTestHarness.l1ContractAddresses.inboxAddress,
-      outbox: this.crossChainTestHarness.l1ContractAddresses.outboxAddress,
-    };
-  }
 }
-
-type CrossChainContext = {
-  l2Token: AztecAddress;
-  l2Bridge: AztecAddress;
-  tokenPortal: EthAddress;
-  underlying: EthAddress;
-  ethAccount: EthAddress;
-  ownerAddress: AztecAddress;
-  inbox: EthAddress;
-  outbox: EthAddress;
-};

package/src/e2e_deploy_contract/deploy_test.ts

@@ -1,19 +1,14 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import {
-  type AccountWallet,
-  type AztecAddress,
-  type AztecNode,
-  type ContractArtifact,
-  type ContractBase,
-  Fr,
-  type Logger,
-  type PXE,
-  type PublicKeys,
-  type Wallet,
-  createLogger,
-  getContractInstanceFromDeployParams,
-} from '@aztec/aztec.js';
-import type { StatefulTestContract } from '@aztec/noir-contracts.js/StatefulTest';
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { type ContractBase, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { PublicKeys } from '@aztec/aztec.js/keys';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import type { StatefulTestContract } from '@aztec/noir-test-contracts.js/StatefulTest';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { type ISnapshotManager, createSnapshotManager, deployAccounts } from '../fixtures/snapshot_manager.js';
 
@@ -21,12 +16,11 @@ const { E2E_DATA_PATH: dataPath } = process.env;
 
 export class DeployTest {
   private snapshotManager: ISnapshotManager;
-  private wallets: AccountWallet[] = [];
-
   public logger: Logger;
-  public pxe!: PXE;
-  public wallet!: AccountWallet;
+  public wallet!: TestWallet;
+  public defaultAccountAddress!: AztecAddress;
   public aztecNode!: AztecNode;
+  public aztecNodeAdmin!: AztecNodeAdmin;
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_deploy_contract:${testName}`);
@@ -36,7 +30,8 @@ export class DeployTest {
   async setup() {
     await this.applyInitialAccountSnapshot();
     const context = await this.snapshotManager.setup();
-    ({ pxe: this.pxe, aztecNode: this.aztecNode } = context);
+    ({ aztecNode: this.aztecNode, wallet: this.wallet } = context);
+    this.aztecNodeAdmin = context.aztecNode;
     return this;
   }
 
@@ -45,15 +40,10 @@ export class DeployTest {
   }
 
   private async applyInitialAccountSnapshot() {
-    await this.snapshotManager.snapshot(
-      'initial_account',
-      deployAccounts(1, this.logger),
-      async ({ deployedAccounts }, { pxe }) => {
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-        this.wallet = this.wallets[0];
-      },
-    );
+    await this.snapshotManager.snapshot('initial_account', deployAccounts(1, this.logger), ({ deployedAccounts }) => {
+      this.defaultAccountAddress = deployedAccounts[0].address;
+      return Promise.resolve();
+    });
   }
 
   async registerContract<T extends ContractBase>(
@@ -68,26 +58,21 @@ export class DeployTest {
     } = {},
   ): Promise<T> {
     const { salt, publicKeys, initArgs, constructorName, deployer } = opts;
-    const instance = await getContractInstanceFromDeployParams(contractArtifact.artifact, {
+    const instance = await getContractInstanceFromInstantiationParams(contractArtifact.artifact, {
       constructorArgs: initArgs ?? [],
       constructorArtifact: constructorName,
-      salt,
+      salt: salt ?? Fr.random(),
       publicKeys,
       deployer,
     });
-    await wallet.registerContract({ artifact: contractArtifact.artifact, instance });
+    await wallet.registerContract(instance, contractArtifact.artifact);
     return contractArtifact.at(instance.address, wallet);
   }
-
-  async registerRandomAccount(): Promise<AztecAddress> {
-    const completeAddress = await this.pxe.registerAccount(Fr.random(), Fr.random());
-    return completeAddress.address;
-  }
 }
 
 export type StatefulContractCtorArgs = Parameters<StatefulTestContract['methods']['constructor']>;
 
 export type ContractArtifactClass<T extends ContractBase> = {
-  at(address: AztecAddress, wallet: Wallet): Promise<T>;
+  at(address: AztecAddress, wallet: Wallet): T;
   artifact: ContractArtifact;
 };