@aztec/end-to-end 5.0.0-rc.1 → 5.0.0

package/src/{e2e_cross_chain_messaging → single-node/cross-chain}/cross_chain_messaging_test.ts

@@ -1,7 +1,7 @@
 import type { AztecNodeConfig } from '@aztec/aztec-node';
 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 { createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import type { TxReceipt } from '@aztec/aztec.js/tx';
 import { CheatCodes, EpochTestSettler } from '@aztec/aztec/testing';
@@ -17,47 +17,61 @@ 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 { MNEMONIC } from '../fixtures/fixtures.js';
-import {
-  type EndToEndContext,
-  type SetupOptions,
-  ensureAuthRegistryPublished,
-  setup,
-  teardown,
-} from '../fixtures/setup.js';
-import { CrossChainTestHarness } from '../shared/cross_chain_test_harness.js';
-import type { TestWallet } from '../test-wallet/test_wallet.js';
-
-export class CrossChainMessagingTest {
+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
+ * with the bespoke cross-chain opts below (optional prover node, sponsored-FPC funding, a generous
+ * prover tx-gathering window for the epoch warps) rather than the base's default node config, and owns
+ * the {@link CrossChainTestHarness} domain object plus the L1 inbox/outbox handles.
+ */
+export class CrossChainMessagingTest extends SingleNodeTestContext {
   private requireEpochProven: boolean;
   private setupOptions: SetupOptions;
   private deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs>;
   private pxeOpts: Partial<PXEConfig>;
-  logger: Logger;
-  context!: EndToEndContext;
+  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;
   aztecNodeAdmin!: AztecNodeAdmin;
 
-  l1Client!: ExtendedViemWalletClient | undefined;
-
   wallet!: TestWallet;
   ownerAddress!: AztecAddress;
   user1Address!: AztecAddress;
   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;
 
-  rollup!: RollupContract;
   inbox!: InboxContract;
   outbox!: OutboxContract;
   cheatCodes!: CheatCodes;
@@ -79,7 +93,10 @@ export class CrossChainMessagingTest {
     opts: SetupOptions = {},
     deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {},
     pxeOpts: Partial<PXEConfig> = {},
+    crossChainOpts: CrossChainMessagingTestOpts = {},
   ) {
+    super();
+    this.testName = testName;
     this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
     this.setupOptions = opts;
     this.deployL1ContractsArgs = {
@@ -87,14 +104,16 @@ export class CrossChainMessagingTest {
       ...deployL1ContractsArgs,
     };
     this.pxeOpts = pxeOpts;
+    this.l1HarnessAccountIndex = crossChainOpts.l1HarnessAccountIndex;
+    this.deployTokenBridge = crossChainOpts.deployTokenBridge ?? true;
     this.requireEpochProven = opts.startProverNode ?? false;
   }
 
-  async setup(opts: Partial<SetupOptions> = {}, pxeOpts: Partial<PXEConfig> = {}) {
+  override async setup(opts: SingleNodeTestOpts = {}, pxeOpts: Partial<PXEConfig> = {}) {
     this.logger.info('Setting up cross chain messaging test');
     // Recompute requireEpochProven from the merged options so per-call startProverNode is honored.
     this.requireEpochProven = opts.startProverNode ?? this.setupOptions.startProverNode ?? false;
-    this.context = await setup(
+    const context = await setup(
       3,
       {
         ...this.setupOptions,
@@ -110,9 +129,45 @@ export class CrossChainMessagingTest {
           ...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 },
     );
+
+    // Reuse the base context machinery (rollup, epoch cache, chain monitor, node tracking, teardown)
+    // over the environment built above. Restore the CrossChainMessagingTest-named logger afterwards,
+    // since hydrateFromContext repoints `this.logger` at the context logger.
+    await this.hydrateFromContext(context);
+    this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${this.testName}`);
+
     await this.applyBaseSetup();
   }
 
@@ -141,9 +196,9 @@ export class CrossChainMessagingTest {
     }
   }
 
-  async teardown() {
+  override async teardown() {
     await this.epochTestSettler?.stop();
-    await teardown(this.context);
+    await super.teardown();
   }
 
   async applyBaseSetup() {
@@ -177,22 +232,46 @@ export class CrossChainMessagingTest {
 
     await ensureAuthRegistryPublished(this.wallet, this.ownerAddress);
 
-    this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+    const harnessL1Client = createExtendedL1Client(
+      this.aztecNodeConfig.l1RpcUrls,
+      MNEMONIC,
+      undefined,
+      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());
+
+    // 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;
+    }
 
-    const underlyingERC20Address = await deployL1Contract(this.l1Client, TestERC20Abi, TestERC20Bytecode, [
-      'Underlying',
-      'UND',
-      this.l1Client.account.address,
-    ]).then(({ address }) => address);
+    // 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(
       this.aztecNode,
-      this.l1Client,
+      harnessL1Client,
       this.wallet,
       this.ownerAddress,
       this.logger,
       underlyingERC20Address,
+      predeployedTokenPortalAddress,
     );
 
     this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
@@ -206,14 +285,6 @@ export class CrossChainMessagingTest {
     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,
@@ -222,7 +293,7 @@ export class CrossChainMessagingTest {
       this.ethAccount,
       tokenPortalAddress,
       crossChainContext.underlying,
-      l1Client,
+      harnessL1Client,
       pickL1ContractAddresses(this.aztecNodeConfig),
       this.wallet,
       this.ownerAddress,

package/src/single-node/cross-chain/message_test_helpers.ts

@@ -0,0 +1,125 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { Fr } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import { isL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { retryUntil } from '@aztec/foundation/retry';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
+
+import { sendL1ToL2Message } from '../../fixtures/l1_to_l2_messaging.js';
+import type { CrossChainMessagingTest } from './cross_chain_messaging_test.js';
+
+/** Scope from which an L1→L2 message is consumed on L2. */
+export type L1ToL2MessageScope = 'private' | 'public';
+
+/** Dependencies the L1→L2 message helpers close over. */
+export interface L1ToL2MessageHelperDeps {
+  t: CrossChainMessagingTest;
+  aztecNode: AztecNode;
+  wallet: Wallet;
+  user1Address: AztecAddress;
+  log: Logger;
+  /** Marks the current pending tip proven on L1, subject to the caller's proving policy. */
+  markAsProven: () => Promise<void>;
+}
+
+/** Helpers for driving L1→L2 messages through the inbox, shared across the L1→L2 messaging suites. */
+export interface L1ToL2MessageHelpers {
+  sendMessageToL2(message: {
+    recipient: AztecAddress;
+    content: Fr;
+    secretHash: Fr;
+  }): ReturnType<typeof sendL1ToL2Message>;
+  advanceBlock(): Promise<BlockNumber>;
+  waitForMessageFetched(msgHash: Fr): Promise<CheckpointNumber>;
+  waitForMessageReady(
+    msgHash: Fr,
+    scope: L1ToL2MessageScope,
+    onNotReady?: (blockNumber: BlockNumber) => Promise<void>,
+  ): Promise<void>;
+}
+
+/**
+ * Builds the L1→L2 message helpers over a running {@link CrossChainMessagingTest}. The `markAsProven`
+ * dependency lets each suite plug in its own proving policy: suites that never pause proving pass an
+ * unconditional mark, while the inbox-drift suite gates it behind a flag it toggles mid-test.
+ */
+export function createL1ToL2MessageHelpers(deps: L1ToL2MessageHelperDeps): L1ToL2MessageHelpers {
+  const { t, aztecNode, wallet, user1Address, log, markAsProven } = deps;
+
+  // Sends an L1→L2 message from the harness L1 account. This suite skips the token bridge, so the
+  // message context is built from the test's L1 handles rather than a CrossChainTestHarness.
+  const sendMessageToL2 = (message: { recipient: AztecAddress; content: Fr; secretHash: Fr }) =>
+    sendL1ToL2Message(message, {
+      l1Client: t.harnessL1Client,
+      l1ContractAddresses: t.deployL1ContractsValues.l1ContractAddresses,
+    });
+
+  // Sends a tx to L2 to advance the block number by 1
+  const advanceBlock = async () => {
+    const block = await aztecNode.getBlockNumber();
+    log.warn(`Sending noop tx at block ${block}`);
+    await wallet.sendTx(ExecutionPayload.empty(), { from: user1Address });
+    const newBlock = await aztecNode.getBlockNumber();
+    log.warn(`Advanced to block ${newBlock}`);
+    if (newBlock === block) {
+      throw new Error(`Failed to advance block ${block}`);
+    }
+    // Keep the proof window from expiring mid-test. No-op once a drift scenario disables proving.
+    await markAsProven();
+    return newBlock;
+  };
+
+  // Waits until the message is fetched by the archiver of the node and returns the msg target checkpoint.
+  // Advances a block on each retry because an L1->L2 message is only indexed once further L2 blocks build.
+  const waitForMessageFetched = async (msgHash: Fr) => {
+    log.warn(`Waiting until the message is fetched by the node`);
+    return await retryUntil(
+      async () => {
+        const checkpoint = await aztecNode.getL1ToL2MessageCheckpoint(msgHash);
+        if (checkpoint !== undefined) {
+          return checkpoint;
+        }
+        await advanceBlock();
+        return undefined;
+      },
+      'get msg checkpoint',
+      60,
+    );
+  };
+
+  // Waits until the message is ready to be consumed on L2 as it's been added to the world state
+  const waitForMessageReady = async (
+    msgHash: Fr,
+    scope: L1ToL2MessageScope,
+    onNotReady?: (blockNumber: BlockNumber) => Promise<void>,
+  ) => {
+    const msgCheckpoint = await waitForMessageFetched(msgHash);
+    log.warn(
+      `Waiting until L2 reaches the first block of msg checkpoint ${msgCheckpoint} (current is ${await aztecNode.getCheckpointNumber()})`,
+    );
+    await retryUntil(
+      async () => {
+        const [blockNumber, checkpointNumber] = await Promise.all([
+          aztecNode.getBlockNumber(),
+          aztecNode.getCheckpointNumber(),
+        ]);
+        const witness = await aztecNode.getL1ToL2MessageMembershipWitness('latest', msgHash);
+        const isReady = await isL1ToL2MessageReady(aztecNode, msgHash);
+        log.info(
+          `Block is ${blockNumber}, checkpoint is ${checkpointNumber}. Message checkpoint is ${msgCheckpoint}. Witness ${!!witness}. Ready ${isReady}.`,
+        );
+        if (!isReady) {
+          await (onNotReady ? onNotReady(blockNumber) : advanceBlock());
+        }
+        return isReady;
+      },
+      `wait for rollup to reach msg checkpoint ${msgCheckpoint}`,
+      240,
+    );
+  };
+
+  return { sendMessageToL2, advanceBlock, waitForMessageFetched, waitForMessageReady };
+}

package/src/{e2e_fees → single-node/fees}/bridging_race.notest.ts

@@ -8,14 +8,18 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { jest } from '@jest/globals';
 import type { Hex } from 'viem';
 
-import type { TestWallet } from '../test-wallet/test_wallet.js';
+import type { TestWallet } from '../../test-wallet/test_wallet.js';
 import { FeesTest } from './fees_test.js';
 
 jest.setTimeout(300_000);
 
 // Regression for https://github.com/AztecProtocol/aztec-packages/issues/12366
 // Similar to e2e_fees/account_init but with no automine
-describe('e2e_fees bridging_race', () => {
+// Disabled (.notest.ts): this regression was covered by fixes applied at each "wait for two blocks"
+// site in the codebase; keeping the file as reference for the original race scenario. Uses FeesTest
+// with prod sequencer (ethSlot=4s, aztecSlot=8s, inboxLag default, minTxsPerBlock=0) and
+// GasBridgingTestHarness for L1↔L2 fee-juice bridging. Single account, fake in-proc prover node.
+describe('single-node/fees/bridging_race', () => {
   const ETHEREUM_SLOT_DURATION = 4;
   const AZTEC_SLOT_DURATION = ETHEREUM_SLOT_DURATION * 2;
 
@@ -50,6 +54,18 @@ describe('e2e_fees bridging_race', () => {
     bobsAddress = bobsAccountManager.address;
   });
 
+  // Sleeps until 500ms before the current L2 slot ends, so the subsequent bridge lands right at the slot
+  // boundary (this is what reproduces the "message not in state" race the test guards against).
+  const sleepUntilNearSlotEnd = async () => {
+    const sleepTime = (Number(t.monitor.checkpointTimestamp) + AZTEC_SLOT_DURATION) * 1000 - Date.now() - 500;
+    logger.info(`Sleeping for ${sleepTime}ms until near end of L2 slot before sending L1 fee juice to L2 inbox`);
+    await sleep(sleepTime);
+  };
+
+  // Reproduces a timing race where an L1→L2 fee-juice bridge message lands just before the end of an
+  // L2 slot, causing the archiver to miss it. The fix was to wait for the archiver to see the message
+  // before waiting for the required two-block confirmation. The sleep injected into approve() simulates
+  // the near-slot-boundary timing.
   it('Alice bridges funds to Bob', async () => {
     // Tweak the token manager so the bridging happens immediately before the end of the current L2 slot
     // This caused the message to be "not in state" when tried to be used
@@ -57,9 +73,7 @@ describe('e2e_fees bridging_race', () => {
     const origApprove = l1TokenManager.approve.bind(l1TokenManager);
     l1TokenManager.approve = async (amount: bigint, address: Hex, addressName = '') => {
       await origApprove(amount, address, addressName);
-      const sleepTime = (Number(t.chainMonitor.checkpointTimestamp) + AZTEC_SLOT_DURATION) * 1000 - Date.now() - 500;
-      logger.info(`Sleeping for ${sleepTime}ms until near end of L2 slot before sending L1 fee juice to L2 inbox`);
-      await sleep(sleepTime);
+      await sleepUntilNearSlotEnd();
     };
 
     // Waiting for the archiver to sync the message _before_ waiting for the mandatory 2 L2 blocks to pass fixed it