Merge branch 'v5-next' into merge-train/fairies-v5

Author: AztecBot

yarn-project/end-to-end/src/fixtures/setup.ts

@@ -24,6 +24,7 @@ import {
 import type { Delayer } from '@aztec/ethereum/l1-tx-utils';
 import { EthCheatCodes, EthCheatCodesWithState, startAnvil, warmBlobKzg } from '@aztec/ethereum/test';
 import type { Anvil } from '@aztec/ethereum/test';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto/random';
@@ -152,7 +153,7 @@ export async function setupPXEAndGetWallet(
 }
 
 /** Options for the e2e tests setup */
-export type SetupOptions = {
+export type SetupOptions<TDeployExtraL1ContractsReturnType = unknown> = {
   /** State load */
   stateLoad?: string;
   /** Whether to enable metrics collection, if undefined, metrics collection is disabled */
@@ -190,6 +191,20 @@ export type SetupOptions = {
    * that assert on genesis-relative L1 timing need to opt out with `false`.
    */
   automineL1Setup?: boolean;
+  /**
+   * Hook invoked after the Aztec L1 rollup contracts are deployed but BEFORE the node/sequencer
+   * start, while anvil automine is still enabled (when `automineL1Setup` is true, the default).
+   * Deploy extra L1 contracts a test needs here (e.g. a cross-chain token portal + ERC20) so they
+   * mine instantly under automine instead of paying the L1 block interval once the node is running
+   * (and racing the live sequencer/archiver). The resolved value is exposed on the returned context
+   * as `extraL1DeployResult`. The hook receives setup's L1 deployer client (the same one used to
+   * deploy Multicall3).
+   */
+  deployExtraL1Contracts?: (deps: {
+    l1Client: ExtendedViemWalletClient;
+    deployL1ContractsValues: DeployAztecL1ContractsReturnType;
+    logger: Logger;
+  }) => Promise<TDeployExtraL1ContractsReturnType>;
   /** How many accounts to seed and unlock in anvil. */
   anvilAccounts?: number;
   /** Port to start anvil (defaults to 8545) */
@@ -220,7 +235,7 @@ export type SetupOptions = {
 } & Partial<AztecNodeConfig>;
 
 /** Context for an end-to-end test as returned by the `setup` function */
-export type EndToEndContext = {
+export type EndToEndContext<TDeployExtraL1ContractsReturnType = unknown> = {
   /** The Anvil instance (only set if anvil was started locally). */
   anvil: Anvil | undefined;
   /** The Aztec Node service or client a connected to it. */
@@ -263,6 +278,8 @@ export type EndToEndContext = {
   proverDelayer: Delayer | undefined;
   /** Genesis data used for setting up nodes. */
   genesis: GenesisData | undefined;
+  /** Resolved value of the `deployExtraL1Contracts` setup hook, if one was provided. */
+  extraL1DeployResult: TDeployExtraL1ContractsReturnType;
   /** ACVM config (only set if running locally). */
   acvmConfig: Awaited<ReturnType<typeof getACVMConfig>>;
   /** BB config (only set if running locally). */
@@ -305,12 +322,12 @@ function assertContractArtifactsVersion() {
  * @param opts - Options to pass to the node initialization and to the setup script.
  * @param pxeOpts - Options to pass to the PXE initialization.
  */
-export function setup(
+export function setup<TDeployExtraL1ContractsReturnType = unknown>(
   numberOfAccounts = 1,
-  opts: SetupOptions = {},
+  opts: SetupOptions<TDeployExtraL1ContractsReturnType> = {},
   pxeOpts: Partial<PXEConfig> = {},
   chain: Chain = foundry,
-): Promise<EndToEndContext> {
+): Promise<EndToEndContext<TDeployExtraL1ContractsReturnType>> {
   // Tag the top-level env spin-up with the prover mode (none → fake → real), the largest config-driven
   // swing in setup cost, so the three factories are comparable on the span leaderboard. The internals
   // (anvil / l1-deploy / sequencer-start / pxe / wallet:create) decompose this further.
@@ -325,12 +342,12 @@ export function setup(
   });
 }
 
-async function setupInner(
+async function setupInner<TDeployExtraL1ContractsReturnType = unknown>(
   numberOfAccounts: number,
-  opts: SetupOptions,
+  opts: SetupOptions<TDeployExtraL1ContractsReturnType>,
   pxeOpts: Partial<PXEConfig>,
   chain: Chain,
-): Promise<EndToEndContext> {
+): Promise<EndToEndContext<TDeployExtraL1ContractsReturnType>> {
   assertContractArtifactsVersion();
   const logger = getLogger();
   let anvil: Anvil | undefined;
@@ -508,6 +525,21 @@ async function setupInner(
       }
     }
 
+    // Deploy any test-specific L1 contracts while automine is still on and before the node starts,
+    // so they mine instantly rather than paying the L1 block interval once the sequencer is live.
+    let extraL1DeployResult: TDeployExtraL1ContractsReturnType = undefined as TDeployExtraL1ContractsReturnType;
+    if (opts.deployExtraL1Contracts) {
+      logger.trace('Running deployExtraL1Contracts hook');
+      extraL1DeployResult = await opts.deployExtraL1Contracts({
+        l1Client,
+        deployL1ContractsValues,
+        logger,
+      });
+      // The hook reused `l1Client` to send deploy txs, so refresh viem's nonce cache to avoid a
+      // stale cached nonce for later transactions on the publisher account.
+      await l1Client.getTransactionCount({ address: l1Client.account.address });
+    }
+
     if (enableAutomine) {
       await ethCheatCodes.setAutomine(false);
       await ethCheatCodes.setIntervalMining(config.ethereumSlotDuration);
@@ -713,6 +745,7 @@ async function setupInner(
       logger,
       mockGossipSubNetwork,
       genesis,
+      extraL1DeployResult,
       proverNode,
       sequencerDelayer,
       proverDelayer,

yarn-project/end-to-end/src/shared/cross_chain_test_harness.ts

@@ -43,6 +43,7 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   rollupRegistryAddress: EthAddress,
   owner: AztecAddress,
   underlyingERC20Address: EthAddress,
+  predeployedTokenPortalAddress?: EthAddress,
 ): Promise<{
   /**
    * The L2 token contract instance.
@@ -65,8 +66,9 @@ export async function deployAndInitializeTokenAndBridgeContracts(
    */
   underlyingERC20: any;
 }> {
-  // deploy the token portal
-  const { address: tokenPortalAddress } = await deployL1Contract(l1Client, TokenPortalAbi, TokenPortalBytecode);
+  // Deploy the token portal, unless it was already deployed before the node started (under automine).
+  const tokenPortalAddress =
+    predeployedTokenPortalAddress ?? (await deployL1Contract(l1Client, TokenPortalAbi, TokenPortalBytecode)).address;
   const tokenPortal = getContract({
     address: tokenPortalAddress.toString(),
     abi: TokenPortalAbi,
@@ -135,6 +137,7 @@ export class CrossChainTestHarness {
     ownerAddress: AztecAddress,
     logger: Logger,
     underlyingERC20Address: EthAddress,
+    predeployedTokenPortalAddress?: EthAddress,
   ): Promise<CrossChainTestHarness> {
     const ethAccount = EthAddress.fromString((await l1Client.getAddresses())[0]);
     const l1ContractAddresses = (await aztecNode.getNodeInfo()).l1ContractAddresses;
@@ -147,6 +150,7 @@ export class CrossChainTestHarness {
       l1ContractAddresses.registryAddress,
       ownerAddress,
       underlyingERC20Address,
+      predeployedTokenPortalAddress,
     );
     logger.info('Deployed and initialized token, portal and its bridge.');
 

yarn-project/end-to-end/src/single-node/cross-chain/cross_chain_messaging_test.ts

@@ -13,22 +13,33 @@ import type {
 } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
 import { pickL1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { EpochNumber } from '@aztec/foundation/branded-types';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
-import { TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
+import { TestERC20Abi, TestERC20Bytecode, TokenPortalAbi, TokenPortalBytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
 import type { PXEConfig } from '@aztec/pxe/server';
 import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 
+import { mnemonicToAccount } from 'viem/accounts';
+
 import { MNEMONIC } from '../../fixtures/fixtures.js';
 import { type SetupOptions, ensureAuthRegistryPublished, setup } from '../../fixtures/setup.js';
 import { CrossChainTestHarness } from '../../shared/cross_chain_test_harness.js';
 import type { TestWallet } from '../../test-wallet/test_wallet.js';
 import { SingleNodeTestContext, type SingleNodeTestOpts } from '../single_node_test_context.js';
 
+/** Optional configuration for {@link CrossChainMessagingTest}. */
+export type CrossChainMessagingTestOpts = {
+  /** Mnemonic account index for the harness L1 client (token portal, inbox, minting). Defaults to the first account. */
+  l1HarnessAccountIndex?: number;
+  /** Whether to deploy the L1/L2 token bridge. Set to false for suites that only pass arbitrary messages. Defaults to true. */
+  deployTokenBridge?: boolean;
+};
+
 /**
  * The cross-chain-messaging harness over the single-node topology: extends {@link SingleNodeTestContext}
  * so it reuses the base node tracking / chain monitor / teardown machinery, but builds its environment
@@ -42,6 +53,9 @@ export class CrossChainMessagingTest extends SingleNodeTestContext {
   private deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs>;
   private pxeOpts: Partial<PXEConfig>;
   private l1HarnessAccountIndex?: number;
+  private deployTokenBridge: boolean;
+  /** L1 token portal + ERC20 deployed before the node started (under automine) by the setup hook. */
+  private preDeployedCrossChainL1?: { underlyingERC20Address: EthAddress; tokenPortalAddress: EthAddress };
   private testName: string;
   aztecNode!: AztecNode;
   aztecNodeConfig!: AztecNodeConfig;
@@ -53,6 +67,8 @@ export class CrossChainMessagingTest extends SingleNodeTestContext {
   user2Address!: AztecAddress;
   crossChainTestHarness!: CrossChainTestHarness;
   ethAccount!: EthAddress;
+  /** L1 client used for cross-chain L1 interactions (token portal, inbox), tied to `l1HarnessAccountIndex`. */
+  harnessL1Client!: ExtendedViemWalletClient;
   l2Token!: TokenContract;
   l2Bridge!: TokenBridgeContract;
 
@@ -77,7 +93,7 @@ export class CrossChainMessagingTest extends SingleNodeTestContext {
     opts: SetupOptions = {},
     deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {},
     pxeOpts: Partial<PXEConfig> = {},
-    l1HarnessAccountIndex?: number,
+    crossChainOpts: CrossChainMessagingTestOpts = {},
   ) {
     super();
     this.testName = testName;
@@ -88,7 +104,8 @@ export class CrossChainMessagingTest extends SingleNodeTestContext {
       ...deployL1ContractsArgs,
     };
     this.pxeOpts = pxeOpts;
-    this.l1HarnessAccountIndex = l1HarnessAccountIndex;
+    this.l1HarnessAccountIndex = crossChainOpts.l1HarnessAccountIndex;
+    this.deployTokenBridge = crossChainOpts.deployTokenBridge ?? true;
     this.requireEpochProven = opts.startProverNode ?? false;
   }
 
@@ -112,6 +129,35 @@ export class CrossChainMessagingTest extends SingleNodeTestContext {
           ...opts.proverNodeConfig,
           txGatheringTimeoutMs: opts.proverNodeConfig?.txGatheringTimeoutMs ?? 10 * 60 * 1000,
         },
+        // Deploy the cross-chain token portal + ERC20 before the node starts, while anvil is still
+        // automining, instead of paying the L1 block interval for them once the sequencer is live.
+        deployExtraL1Contracts: this.deployTokenBridge
+          ? async ({ l1Client, logger }) => {
+              // The harness mints the underlying ERC20 from `l1HarnessAccountIndex` and `TestERC20.mint`
+              // is onlyMinter, so its owner/initial-minter must be that account even though setup's
+              // publisher client sends the deploy tx.
+              const harnessAddress = mnemonicToAccount(MNEMONIC, {
+                addressIndex: this.l1HarnessAccountIndex ?? 0,
+              }).address;
+              const { address: underlyingERC20Address } = await deployL1Contract(
+                l1Client,
+                TestERC20Abi,
+                TestERC20Bytecode,
+                ['Underlying', 'UND', harnessAddress],
+              );
+              // The TokenPortal's initialize is permissionless, so it can be deployed by the publisher.
+              const { address: tokenPortalAddress } = await deployL1Contract(
+                l1Client,
+                TokenPortalAbi,
+                TokenPortalBytecode,
+              );
+              this.preDeployedCrossChainL1 = { underlyingERC20Address, tokenPortalAddress };
+              logger.verbose(
+                `Pre-deployed cross-chain L1 ERC20 ${underlyingERC20Address} and portal ${tokenPortalAddress}`,
+              );
+              return this.preDeployedCrossChainL1;
+            }
+          : undefined,
       },
       { ...this.pxeOpts, ...pxeOpts },
     );
@@ -193,12 +239,29 @@ export class CrossChainMessagingTest extends SingleNodeTestContext {
       undefined,
       this.l1HarnessAccountIndex,
     );
+    this.harnessL1Client = harnessL1Client;
+    this.ethAccount = EthAddress.fromString((await harnessL1Client.getAddresses())[0]);
+
+    // L1 contract handles every cross-chain test needs, independent of the token bridge.
+    const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+    this.l1Client = l1Client;
+    const l1Contracts = pickL1ContractAddresses(this.aztecNodeConfig);
+    this.rollup = new RollupContract(l1Client, l1Contracts.rollupAddress.toString());
+    this.inbox = new InboxContract(l1Client, l1Contracts.inboxAddress.toString());
+    this.outbox = new OutboxContract(l1Client, l1Contracts.outboxAddress.toString());
 
-    const underlyingERC20Address = await deployL1Contract(harnessL1Client, TestERC20Abi, TestERC20Bytecode, [
-      'Underlying',
-      'UND',
-      harnessL1Client.account.address,
-    ]).then(({ address }) => address);
+    // Tests that only pass arbitrary L1<->L2 messages (not token bridging) never touch the L2 token,
+    // bridge, or portal. Skip the token+portal+bridge deploy (an L1 ERC20, an L1 portal, and two L2
+    // contract deploys plus their init txs) entirely for them.
+    if (!this.deployTokenBridge) {
+      this.logger.info('Skipping token bridge deploy; test only needs L1 handles and ethAccount');
+      return;
+    }
+
+    // The ERC20 and token portal were deployed before the node started (under automine) by the
+    // `deployExtraL1Contracts` setup hook above; the harness reuses them and only deploys the L2 token,
+    // L2 bridge, and the portal init that need the running node.
+    const { underlyingERC20Address, tokenPortalAddress: predeployedTokenPortalAddress } = this.preDeployedCrossChainL1!;
 
     this.logger.verbose(`Setting up cross chain harness...`);
     this.crossChainTestHarness = await CrossChainTestHarness.new(
@@ -208,6 +271,7 @@ export class CrossChainMessagingTest extends SingleNodeTestContext {
       this.ownerAddress,
       this.logger,
       underlyingERC20Address,
+      predeployedTokenPortalAddress,
     );
 
     this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
@@ -221,14 +285,6 @@ export class CrossChainMessagingTest extends SingleNodeTestContext {
     this.ethAccount = EthAddress.fromString(crossChainContext.ethAccount.toString());
     const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
 
-    const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-    this.l1Client = l1Client;
-
-    const l1Contracts = pickL1ContractAddresses(this.aztecNodeConfig);
-    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.logger,