@aztec/end-to-end 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/dest/e2e_deploy_contract/deploy_test.js

@@ -1,14 +1,15 @@
 import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { Fr, createLogger, getContractInstanceFromDeployParams } from '@aztec/aztec.js';
+import { Fr, createLogger, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js';
 import { createSnapshotManager, deployAccounts } from '../fixtures/snapshot_manager.js';
 const { E2E_DATA_PATH: dataPath } = process.env;
 export class DeployTest {
     snapshotManager;
-    wallets = [];
     logger;
     pxe;
     wallet;
+    defaultAccountAddress;
     aztecNode;
+    aztecNodeAdmin;
     constructor(testName){
         this.logger = createLogger(`e2e:e2e_deploy_contract:${testName}`);
         this.snapshotManager = createSnapshotManager(`e2e_deploy_contract/${testName}`, dataPath);
@@ -17,6 +18,7 @@ export class DeployTest {
         await this.applyInitialAccountSnapshot();
         const context = await this.snapshotManager.setup();
         ({ pxe: this.pxe, aztecNode: this.aztecNode } = context);
+        this.aztecNodeAdmin = context.aztecNode;
         return this;
     }
     async teardown() {
@@ -24,14 +26,15 @@ export class DeployTest {
     }
     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];
+            const wallets = await Promise.all(deployedAccounts.map((a)=>getSchnorrWallet(pxe, a.address, a.signingKey)));
+            wallets.forEach((w, i)=>this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
+            this.wallet = wallets[0];
+            this.defaultAccountAddress = this.wallet.getAddress();
         });
     }
     async registerContract(wallet, contractArtifact, opts = {}) {
         const { salt, publicKeys, initArgs, constructorName, deployer } = opts;
-        const instance = await getContractInstanceFromDeployParams(contractArtifact.artifact, {
+        const instance = await getContractInstanceFromInstantiationParams(contractArtifact.artifact, {
             constructorArgs: initArgs ?? [],
             constructorArtifact: constructorName,
             salt,

package/dest/e2e_epochs/epochs_test.d.ts

@@ -1,20 +1,29 @@
-import { AztecNodeService } from '@aztec/aztec-node';
-import { type Logger } from '@aztec/aztec.js';
-import { ChainMonitor } from '@aztec/aztec.js/ethereum';
+import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { Fr, type Logger, type Wallet } from '@aztec/aztec.js';
+import { EpochCache } from '@aztec/epoch-cache';
+import { type ExtendedViemWalletClient } from '@aztec/ethereum';
 import { RollupContract } from '@aztec/ethereum/contracts';
-import { type Delayer } from '@aztec/ethereum/test';
-import { ProverNode } from '@aztec/prover-node';
-import type { L2BlockNumber } from '@aztec/stdlib/block';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
-import type { PublicClient } from 'viem';
+import { ChainMonitor, type Delayer } from '@aztec/ethereum/test';
+import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
+import { ProverNode, type ProverNodeConfig } from '@aztec/prover-node';
+import { type SequencerClient, type SequencerEvents } from '@aztec/sequencer-client';
+import { EthAddress, type L2BlockNumber } from '@aztec/stdlib/block';
+import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { type EndToEndContext, type SetupOptions } from '../fixtures/utils.js';
-export declare const L1_BLOCK_TIME_IN_S: number;
-export declare const EPOCH_DURATION_IN_L2_SLOTS = 4;
-export declare const L2_SLOT_DURATION_IN_L1_SLOTS = 2;
 export declare const WORLD_STATE_BLOCK_HISTORY = 2;
 export declare const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
 export declare const ARCHIVER_POLL_INTERVAL = 50;
-export type EpochsTestOpts = Partial<Pick<SetupOptions, 'startProverNode'>>;
+export declare const DEFAULT_L1_BLOCK_TIME: number;
+export type EpochsTestOpts = Partial<SetupOptions> & {
+    numberOfAccounts?: number;
+};
+export type TrackedSequencerEvent = {
+    [K in keyof SequencerEvents]: Parameters<SequencerEvents[K]>[0] & {
+        type: K;
+        sequencerIndex: number;
+        validator: EthAddress;
+    };
+}[keyof SequencerEvents];
 /**
  * Tests building of epochs using fast block times and short epochs.
  * Spawns an aztec node and a prover node with fake proofs.
@@ -22,30 +31,60 @@ export type EpochsTestOpts = Partial<Pick<SetupOptions, 'startProverNode'>>;
  */
 export declare class EpochsTestContext {
     context: EndToEndContext;
-    l1Client: PublicClient;
+    l1Client: ExtendedViemWalletClient;
     rollup: RollupContract;
     constants: L1RollupConstants;
     logger: Logger;
     monitor: ChainMonitor;
+    epochCache: EpochCache;
     proverDelayer: Delayer;
     sequencerDelayer: Delayer;
     proverNodes: ProverNode[];
     nodes: AztecNodeService[];
+    epochDuration: number;
+    L1_BLOCK_TIME_IN_S: number;
+    L2_SLOT_DURATION_IN_S: number;
     static setup(opts?: EpochsTestOpts): Promise<EpochsTestContext>;
+    static getSlotDurations(opts?: EpochsTestOpts): {
+        ethereumSlotDuration: number;
+        aztecSlotDuration: number;
+        aztecEpochDuration: number;
+        aztecProofSubmissionEpochs: number;
+    };
     setup(opts?: EpochsTestOpts): Promise<void>;
     teardown(): Promise<void>;
-    createProverNode(): Promise<ProverNode>;
-    createNonValidatorNode(): Promise<AztecNodeService>;
+    createProverNode(opts?: {
+        dontStart?: boolean;
+    } & Partial<ProverNodeConfig>): Promise<ProverNode>;
+    createNonValidatorNode(opts?: Partial<AztecNodeConfig>): Promise<AztecNodeService>;
+    createValidatorNode(privateKeys: `0x${string}`[], opts?: Partial<AztecNodeConfig> & {
+        txDelayerMaxInclusionTimeIntoSlot?: number;
+        dontStartSequencer?: boolean;
+    }): Promise<AztecNodeService>;
+    private createNode;
     private getNextPrivateKey;
     /** Waits until the epoch begins (ie until the immediately previous L1 block is mined). */
     waitUntilEpochStarts(epoch: number): Promise<bigint>;
     /** Waits until the given L2 block number is mined. */
     waitUntilL2BlockNumber(target: number, timeout?: number): Promise<void>;
     /** Waits until the given L2 block number is marked as proven. */
-    waitUntilProvenL2BlockNumber(t: number, timeout?: number): Promise<void>;
+    waitUntilProvenL2BlockNumber(t: number, timeout?: number): Promise<number>;
+    /** Waits until the last slot of the proof submission window for a given epoch. */
+    waitUntilLastSlotOfProofSubmissionWindow(epochNumber: number | bigint): Promise<void>;
     /** Waits for the aztec node to sync to the target block number. */
-    waitForNodeToSync(blockNumber: number, type: 'finalised' | 'historic'): Promise<void>;
+    waitForNodeToSync(blockNumber: number, type: 'proven' | 'finalized' | 'historic'): Promise<void>;
+    /** Registers the SpamContract on the given wallet. */
+    registerSpamContract(wallet: Wallet, salt?: Fr): Promise<SpamContract>;
+    /** Creates an L1 client using a fresh account with funds from anvil, with a tx delayer already set up. */
+    createL1Client(): Promise<{
+        client: ExtendedViemWalletClient;
+        delayer: Delayer;
+    }>;
     /** Verifies whether the given block number is found on the aztec node. */
     verifyHistoricBlock(blockNumber: L2BlockNumber, expectedSuccess: boolean): Promise<void>;
+    watchSequencerEvents(sequencers: SequencerClient[], getMetadata?: (i: number) => Record<string, any>): {
+        failEvents: TrackedSequencerEvent[];
+        stateChanges: TrackedSequencerEvent[];
+    };
 }
 //# sourceMappingURL=epochs_test.d.ts.map

package/dest/e2e_epochs/epochs_test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"epochs_test.d.ts","sourceRoot":"","sources":["../../src/e2e_epochs/epochs_test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAM,KAAK,MAAM,EAAgD,MAAM,iBAAiB,CAAC;AAChG,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAkB,KAAK,OAAO,EAAwB,MAAM,sBAAsB,CAAC;AAG1F,OAAO,EAAE,UAAU,EAAuB,MAAM,oBAAoB,CAAC;AAIrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAIrE,OAAO,KAAK,EAAO,YAAY,EAAE,MAAM,MAAM,CAAC;AAE9C,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,YAAY,EAIlB,MAAM,sBAAsB,CAAC;AAG9B,eAAO,MAAM,kBAAkB,QAAsE,CAAC;AACtG,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAC5C,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAC9C,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAC3C,eAAO,MAAM,gCAAgC,KAAK,CAAC;AACnD,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAE5E;;;;GAIG;AACH,qBAAa,iBAAiB;IACrB,OAAO,EAAG,eAAe,CAAC;IAC1B,QAAQ,EAAG,YAAY,CAAC;IACxB,MAAM,EAAG,cAAc,CAAC;IACxB,SAAS,EAAG,iBAAiB,CAAC;IAC9B,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAG,YAAY,CAAC;IACvB,aAAa,EAAG,OAAO,CAAC;IACxB,gBAAgB,EAAG,OAAO,CAAC;IAE3B,WAAW,EAAE,UAAU,EAAE,CAAM;IAC/B,KAAK,EAAE,gBAAgB,EAAE,CAAM;WAElB,KAAK,CAAC,IAAI,GAAE,cAAmB;IAMtC,KAAK,CAAC,IAAI,GAAE,cAAmB;IA+D/B,QAAQ;IAOR,gBAAgB;IAgBhB,sBAAsB;IAcnC,OAAO,CAAC,iBAAiB;IAKzB,0FAA0F;IAC7E,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAO/C,sDAAsD;IACzC,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,SAAK;IAShE,iEAAiE;IACpD,4BAA4B,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,SAAK;IASjE,mEAAmE;IACtD,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,UAAU;IAclF,0EAA0E;IAC7D,mBAAmB,CAAC,WAAW,EAAE,aAAa,EAAE,eAAe,EAAE,OAAO;CAOtF"}
+{"version":3,"file":"epochs_test.d.ts","sourceRoot":"","sources":["../../src/e2e_epochs/epochs_test.ts"],"names":[],"mappings":"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"}

package/dest/e2e_epochs/epochs_test.js

@@ -1,20 +1,25 @@
 import { AztecNodeService } from '@aztec/aztec-node';
-import { Fr, getTimestampRangeForEpoch, retryUntil, sleep } from '@aztec/aztec.js';
-import { ChainMonitor } from '@aztec/aztec.js/ethereum';
+import { Fr, MerkleTreeId, getContractInstanceFromInstantiationParams, getTimestampRangeForEpoch, retryUntil, sleep } from '@aztec/aztec.js';
+import { EpochCache } from '@aztec/epoch-cache';
+import { DefaultL1ContractsConfig, createExtendedL1Client } from '@aztec/ethereum';
 import { RollupContract } from '@aztec/ethereum/contracts';
-import { waitUntilL1Timestamp } from '@aztec/ethereum/test';
+import { ChainMonitor, DelayedTxUtils, waitUntilL1Timestamp, withDelayer } from '@aztec/ethereum/test';
+import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { withLogNameSuffix } from '@aztec/foundation/log';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
+import { getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
+import { SequencerState } from '@aztec/sequencer-client';
+import { EthAddress } from '@aztec/stdlib/block';
+import { getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
+import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { join } from 'path';
+import { privateKeyToAccount } from 'viem/accounts';
 import { createAndSyncProverNode, getPrivateKeyFromIndex, setup } from '../fixtures/utils.js';
-// This can be lowered to as much as 2s in non-CI
-export const L1_BLOCK_TIME_IN_S = process.env.L1_BLOCK_TIME ? parseInt(process.env.L1_BLOCK_TIME) : 8;
-export const EPOCH_DURATION_IN_L2_SLOTS = 4;
-export const L2_SLOT_DURATION_IN_L1_SLOTS = 2;
 export const WORLD_STATE_BLOCK_HISTORY = 2;
 export const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
 export const ARCHIVER_POLL_INTERVAL = 50;
+export const DEFAULT_L1_BLOCK_TIME = process.env.CI ? 12 : 8;
 /**
  * Tests building of epochs using fast block times and short epochs.
  * Spawns an aztec node and a prover node with fake proofs.
@@ -26,38 +31,61 @@ export const ARCHIVER_POLL_INTERVAL = 50;
     constants;
     logger;
     monitor;
+    epochCache;
     proverDelayer;
     sequencerDelayer;
     proverNodes = [];
     nodes = [];
+    epochDuration;
+    L1_BLOCK_TIME_IN_S;
+    L2_SLOT_DURATION_IN_S;
     static async setup(opts = {}) {
         const test = new EpochsTestContext();
         await test.setup(opts);
         return test;
     }
+    static getSlotDurations(opts = {}) {
+        const envEthereumSlotDuration = process.env.L1_BLOCK_TIME ? parseInt(process.env.L1_BLOCK_TIME) : DEFAULT_L1_BLOCK_TIME;
+        const ethereumSlotDuration = opts.ethereumSlotDuration ?? envEthereumSlotDuration;
+        const aztecSlotDuration = opts.aztecSlotDuration ?? ethereumSlotDuration * 2;
+        const aztecEpochDuration = opts.aztecEpochDuration ?? 6;
+        const aztecProofSubmissionEpochs = opts.aztecProofSubmissionEpochs ?? 1;
+        return {
+            ethereumSlotDuration,
+            aztecSlotDuration,
+            aztecEpochDuration,
+            aztecProofSubmissionEpochs
+        };
+    }
     async setup(opts = {}) {
+        const { ethereumSlotDuration, aztecSlotDuration, aztecEpochDuration, aztecProofSubmissionEpochs } = EpochsTestContext.getSlotDurations(opts);
+        this.L1_BLOCK_TIME_IN_S = ethereumSlotDuration;
+        this.L2_SLOT_DURATION_IN_S = aztecSlotDuration;
         // Set up system without any account nor protocol contracts
         // and with faster block times and shorter epochs.
-        const context = await setup(0, {
+        const context = await setup(opts.numberOfAccounts ?? 0, {
+            automineL1Setup: true,
             checkIntervalMs: 50,
             archiverPollingIntervalMS: ARCHIVER_POLL_INTERVAL,
             worldStateBlockCheckIntervalMS: WORLD_STATE_BLOCK_CHECK_INTERVAL,
             skipProtocolContracts: true,
             salt: 1,
-            aztecEpochDuration: EPOCH_DURATION_IN_L2_SLOTS,
-            aztecSlotDuration: L1_BLOCK_TIME_IN_S * L2_SLOT_DURATION_IN_L1_SLOTS,
-            ethereumSlotDuration: L1_BLOCK_TIME_IN_S,
-            aztecProofSubmissionWindow: EPOCH_DURATION_IN_L2_SLOTS * 2 - 1,
+            aztecEpochDuration,
+            aztecSlotDuration,
+            ethereumSlotDuration,
+            aztecProofSubmissionEpochs,
+            aztecTargetCommitteeSize: opts.initialValidators?.length ?? 0,
             minTxsPerBlock: 0,
             realProofs: false,
             startProverNode: true,
+            proverTestDelayMs: opts.proverTestDelayMs ?? 0,
             // We use numeric incremental prover ids for simplicity, but we can switch to
             // using the prover's eth address if the proverId is used for something in the rollup contract
-            proverId: Fr.fromString('1'),
-            // This must be enough so that the tx from the prover is delayed properly,
-            // but not so much to hang the sequencer and timeout the teardown
-            txPropagationMaxQueryAttempts: 12,
+            // Use numeric EthAddress for deterministic prover id
+            proverId: EthAddress.fromNumber(1),
             worldStateBlockHistory: WORLD_STATE_BLOCK_HISTORY,
+            exitDelaySeconds: DefaultL1ContractsConfig.exitDelaySeconds,
+            slasherFlavor: 'none',
             ...opts
         });
         this.context = context;
@@ -68,52 +96,109 @@ export const ARCHIVER_POLL_INTERVAL = 50;
             context.aztecNode
         ] : [];
         this.logger = context.logger;
-        this.l1Client = context.deployL1ContractsValues.publicClient;
+        this.l1Client = context.deployL1ContractsValues.l1Client;
         this.rollup = RollupContract.getFromConfig(context.config);
+        this.epochCache = await EpochCache.create(this.rollup, context.config, {
+            dateProvider: context.dateProvider
+        });
         // Loop that tracks L1 and L2 block numbers and logs whenever there's a new one.
-        this.monitor = new ChainMonitor(this.rollup, this.logger).start();
+        this.monitor = new ChainMonitor(this.rollup, context.dateProvider, this.logger).start();
         // This is hideous.
         // We ought to have a definite reference to the l1TxUtils that we're using in both places, provided by the test context.
         this.proverDelayer = context.proverNode ? context.proverNode.publisher.l1TxUtils.delayer : undefined;
-        this.sequencerDelayer = context.sequencer.sequencer.publisher.l1TxUtils.delayer;
-        if (context.proverNode && !this.proverDelayer || !this.sequencerDelayer) {
+        this.sequencerDelayer = context.sequencer ? context.sequencer.sequencer.publisher.l1TxUtils.delayer : undefined;
+        if (context.proverNode && !this.proverDelayer || context.sequencer && !this.sequencerDelayer) {
             throw new Error(`Could not find prover or sequencer delayer`);
         }
         // Constants used for time calculation
+        this.epochDuration = aztecEpochDuration;
         this.constants = {
-            epochDuration: EPOCH_DURATION_IN_L2_SLOTS,
-            slotDuration: L1_BLOCK_TIME_IN_S * L2_SLOT_DURATION_IN_L1_SLOTS,
+            epochDuration: aztecEpochDuration,
+            slotDuration: aztecSlotDuration,
             l1StartBlock: await this.rollup.getL1StartBlock(),
             l1GenesisTime: await this.rollup.getL1GenesisTime(),
-            ethereumSlotDuration: L1_BLOCK_TIME_IN_S
+            ethereumSlotDuration,
+            proofSubmissionEpochs: Number(await this.rollup.getProofSubmissionEpochs())
         };
         this.logger.info(`L2 genesis at L1 block ${this.constants.l1StartBlock} (timestamp ${this.constants.l1GenesisTime})`);
     }
     async teardown() {
-        this.monitor.stop();
-        await Promise.all(this.proverNodes.map((node)=>node.stop()));
-        await Promise.all(this.nodes.map((node)=>node.stop()));
+        await this.monitor.stop();
+        await Promise.all(this.proverNodes.map((node)=>tryStop(node, this.logger)));
+        await Promise.all(this.nodes.map((node)=>tryStop(node, this.logger)));
         await this.context.teardown();
     }
-    async createProverNode() {
+    async createProverNode(opts = {}) {
         this.logger.warn('Creating and syncing a simulated prover node...');
         const proverNodePrivateKey = this.getNextPrivateKey();
         const suffix = (this.proverNodes.length + 1).toString();
+        const proverId = EthAddress.fromNumber(parseInt(suffix, 10));
         const proverNode = await withLogNameSuffix(suffix, ()=>createAndSyncProverNode(proverNodePrivateKey, {
                 ...this.context.config,
-                proverId: Fr.fromString(suffix)
-            }, this.context.aztecNode, join(this.context.config.dataDirectory, randomBytes(8).toString('hex'))));
+                proverId
+            }, {
+                dataDirectory: join(this.context.config.dataDirectory, randomBytes(8).toString('hex')),
+                proverId,
+                ...opts
+            }, this.context.aztecNode, undefined, {
+                dateProvider: this.context.dateProvider
+            }));
         this.proverNodes.push(proverNode);
         return proverNode;
     }
-    async createNonValidatorNode() {
+    createNonValidatorNode(opts = {}) {
         this.logger.warn('Creating and syncing a node without a validator...');
+        return this.createNode({
+            ...opts,
+            disableValidator: true
+        });
+    }
+    createValidatorNode(privateKeys, opts = {}) {
+        this.logger.warn('Creating and syncing a validator node...');
+        return this.createNode({
+            ...opts,
+            disableValidator: false,
+            validatorPrivateKeys: new SecretValue(privateKeys)
+        });
+    }
+    async createNode(opts = {}) {
         const suffix = (this.nodes.length + 1).toString();
+        const { mockGossipSubNetwork } = this.context;
+        const resolvedConfig = {
+            ...this.context.config,
+            ...opts
+        };
+        const p2pEnabled = resolvedConfig.p2pEnabled || mockGossipSubNetwork !== undefined;
+        const p2pIp = resolvedConfig.p2pIp ?? (p2pEnabled ? '127.0.0.1' : undefined);
         const node = await withLogNameSuffix(suffix, ()=>AztecNodeService.createAndSync({
-                ...this.context.config,
-                disableValidator: true,
-                dataDirectory: join(this.context.config.dataDirectory, randomBytes(8).toString('hex'))
+                ...resolvedConfig,
+                dataDirectory: join(this.context.config.dataDirectory, randomBytes(8).toString('hex')),
+                validatorPrivateKeys: opts.validatorPrivateKeys ?? new SecretValue([]),
+                p2pEnabled,
+                p2pIp
+            }, {
+                dateProvider: this.context.dateProvider,
+                p2pClientDeps: {
+                    p2pServiceFactory: mockGossipSubNetwork ? getMockPubSubP2PServiceFactory(mockGossipSubNetwork) : undefined
+                }
+            }, {
+                prefilledPublicData: this.context.prefilledPublicData,
+                ...opts
             }));
+        // REFACTOR: We're getting too much into the internals of the sequencer here.
+        // We should have a single method for constructing an aztec node that returns a TestAztecNodeService
+        // which directly exposes the delayer and sets any test config.
+        if (opts.txDelayerMaxInclusionTimeIntoSlot !== undefined) {
+            this.logger.info(`Setting tx delayer max inclusion time into slot to ${opts.txDelayerMaxInclusionTimeIntoSlot} seconds`);
+            // Here we reach into the sequencer and hook in a tx delayer. The problem is that the sequencer's l1 utils only uses a public client, not a wallet.
+            // The delayer needs a wallet (a client that can sign), so we have to create one here.
+            const l1Client = createExtendedL1Client(resolvedConfig.l1RpcUrls, resolvedConfig.publisherPrivateKeys[0].getValue());
+            const sequencer = node.getSequencer();
+            const publisher = sequencer.sequencer.publisher;
+            const delayed = DelayedTxUtils.fromL1TxUtils(publisher.l1TxUtils, this.L1_BLOCK_TIME_IN_S, l1Client);
+            delayed.delayer.setMaxInclusionTimeIntoSlot(opts.txDelayerMaxInclusionTimeIntoSlot);
+            publisher.l1TxUtils = delayed;
+        }
         this.nodes.push(node);
         return node;
     }
@@ -124,32 +209,127 @@ export const ARCHIVER_POLL_INTERVAL = 50;
     /** Waits until the epoch begins (ie until the immediately previous L1 block is mined). */ async waitUntilEpochStarts(epoch) {
         const [start] = getTimestampRangeForEpoch(BigInt(epoch), this.constants);
         this.logger.info(`Waiting until L1 timestamp ${start} is reached as the start of epoch ${epoch}`);
-        await waitUntilL1Timestamp(this.l1Client, start - BigInt(L1_BLOCK_TIME_IN_S));
+        await waitUntilL1Timestamp(this.l1Client, start - BigInt(this.L1_BLOCK_TIME_IN_S), undefined, 30 * this.epochDuration);
         return start;
     }
     /** Waits until the given L2 block number is mined. */ async waitUntilL2BlockNumber(target, timeout = 60) {
-        await retryUntil(()=>Promise.resolve(target === this.monitor.l2BlockNumber), `Wait until L2 block ${target}`, timeout, 0.1);
+        await retryUntil(()=>Promise.resolve(target <= this.monitor.l2BlockNumber), `Wait until L2 block ${target}`, timeout, 0.1);
     }
     /** Waits until the given L2 block number is marked as proven. */ async waitUntilProvenL2BlockNumber(t, timeout = 60) {
-        await retryUntil(()=>Promise.resolve(t === this.monitor.l2ProvenBlockNumber), `Wait proven L2 block ${t}`, timeout, 0.1);
+        await retryUntil(()=>Promise.resolve(t <= this.monitor.l2ProvenBlockNumber), `Wait proven L2 block ${t}`, timeout, 0.1);
+        return this.monitor.l2ProvenBlockNumber;
+    }
+    /** Waits until the last slot of the proof submission window for a given epoch. */ async waitUntilLastSlotOfProofSubmissionWindow(epochNumber) {
+        const deadline = getProofSubmissionDeadlineTimestamp(BigInt(epochNumber), this.constants);
+        const oneSlotBefore = deadline - BigInt(this.constants.slotDuration);
+        const date = new Date(Number(oneSlotBefore) * 1000);
+        this.logger.info(`Waiting until last slot of submission window for epoch ${epochNumber} at ${date}`, {
+            oneSlotBefore
+        });
+        await waitUntilL1Timestamp(this.l1Client, oneSlotBefore);
     }
     /** Waits for the aztec node to sync to the target block number. */ async waitForNodeToSync(blockNumber, type) {
         const waitTime = ARCHIVER_POLL_INTERVAL + WORLD_STATE_BLOCK_CHECK_INTERVAL;
         let synched = false;
         while(!synched){
             await sleep(waitTime);
-            const syncState = await this.context.aztecNode.getWorldStateSyncStatus();
-            if (type === 'finalised') {
-                synched = syncState.finalisedBlockNumber >= blockNumber;
+            const [syncState, tips] = await Promise.all([
+                this.context.aztecNode.getWorldStateSyncStatus(),
+                await this.context.aztecNode.getL2Tips()
+            ]);
+            this.logger.info(`Wait for node synch ${blockNumber} ${type}`, {
+                blockNumber,
+                type,
+                syncState,
+                tips
+            });
+            if (type === 'proven') {
+                synched = tips.proven.number >= blockNumber && syncState.latestBlockNumber >= blockNumber;
+            } else if (type === 'finalized') {
+                synched = syncState.finalizedBlockNumber >= blockNumber;
             } else {
                 synched = syncState.oldestHistoricBlockNumber >= blockNumber;
             }
         }
     }
+    /** Registers the SpamContract on the given wallet. */ async registerSpamContract(wallet, salt = Fr.ZERO) {
+        const instance = await getContractInstanceFromInstantiationParams(SpamContract.artifact, {
+            constructorArgs: [],
+            constructorArtifact: undefined,
+            salt,
+            publicKeys: undefined,
+            deployer: undefined
+        });
+        await wallet.registerContract({
+            artifact: SpamContract.artifact,
+            instance
+        });
+        return SpamContract.at(instance.address, wallet);
+    }
+    /** Creates an L1 client using a fresh account with funds from anvil, with a tx delayer already set up. */ async createL1Client() {
+        const { client, delayer } = withDelayer(createExtendedL1Client([
+            ...this.l1Client.chain.rpcUrls.default.http
+        ], privateKeyToAccount(this.getNextPrivateKey()), this.l1Client.chain), this.context.dateProvider, {
+            ethereumSlotDuration: this.L1_BLOCK_TIME_IN_S
+        });
+        expect(await client.getBalance({
+            address: client.account.address
+        })).toBeGreaterThan(0n);
+        return {
+            client,
+            delayer
+        };
+    }
     /** Verifies whether the given block number is found on the aztec node. */ async verifyHistoricBlock(blockNumber, expectedSuccess) {
-        const result = await this.context.aztecNode.findBlockNumbersForIndexes(blockNumber, MerkleTreeId.NULLIFIER_TREE, [
-            0n
+        // We use `findLeavesIndexes` here, but could use any function that queries the world-state
+        // at a particular block, so we know whether that historic block is available or has been
+        // pruned. Note that `getBlock` would not work here, since it only hits the archiver.
+        const result = await this.context.aztecNode.findLeavesIndexes(blockNumber, MerkleTreeId.NULLIFIER_TREE, [
+            Fr.ZERO
         ]).then((_)=>true).catch((_)=>false);
         expect(result).toBe(expectedSuccess);
     }
+    watchSequencerEvents(sequencers, getMetadata = ()=>({})) {
+        const stateChanges = [];
+        const failEvents = [];
+        // Note we do not include the 'tx-count-check-failed' event here, since it is fine if we dont build
+        // due to lack of txs available.
+        const failEventsKeys = [
+            'block-build-failed',
+            'block-publish-failed',
+            'proposer-rollup-check-failed'
+        ];
+        const makeEvent = (i, eventName, args)=>({
+                ...args,
+                type: eventName,
+                sequencerIndex: i + 2,
+                ...getMetadata(i)
+            });
+        sequencers.forEach((sequencer, i)=>{
+            const sequencerIndex = i + 2;
+            sequencer.getSequencer().on('state-changed', (args)=>{
+                const noisyStates = [
+                    SequencerState.IDLE,
+                    SequencerState.PROPOSER_CHECK,
+                    SequencerState.SYNCHRONIZING
+                ];
+                if (!noisyStates.includes(args.newState)) {
+                    const evt = makeEvent(i, 'state-changed', args);
+                    stateChanges.push(evt);
+                    this.logger.verbose(`Sequencer ${sequencerIndex} transitioned from state ${args.oldState} to state ${args.newState}`, evt);
+                }
+            });
+            failEventsKeys.forEach((eventName)=>{
+                sequencer.getSequencer().on(eventName, (args)=>{
+                    const evt = makeEvent(i, eventName, args);
+                    failEvents.push(evt);
+                    this.logger.error(`Failed event ${eventName} from sequencer ${sequencerIndex}`, undefined, evt);
+                });
+            });
+        });
+        return {
+            failEvents,
+            stateChanges
+        };
+    }
 }

package/dest/e2e_fees/bridging_race.notest.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bridging_race.notest.d.ts.map

package/dest/e2e_fees/bridging_race.notest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridging_race.notest.d.ts","sourceRoot":"","sources":["../../src/e2e_fees/bridging_race.notest.ts"],"names":[],"mappings":""}

package/dest/e2e_fees/bridging_race.notest.js

@@ -0,0 +1,60 @@
+import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import { Fr, sleep } from '@aztec/aztec.js';
+import { Fq } from '@aztec/foundation/fields';
+import { jest } from '@jest/globals';
+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', ()=>{
+    const ETHEREUM_SLOT_DURATION = 4;
+    const AZTEC_SLOT_DURATION = ETHEREUM_SLOT_DURATION * 2;
+    const t = new FeesTest('bridging_race', 1, {
+        ethereumSlotDuration: ETHEREUM_SLOT_DURATION,
+        aztecSlotDuration: AZTEC_SLOT_DURATION,
+        minTxsPerBlock: 0
+    });
+    beforeAll(async ()=>{
+        await t.applyInitialAccountsSnapshot();
+        await t.applyPublicDeployAccountsSnapshot();
+        await t.applySetupFeeJuiceSnapshot();
+        ({ pxe, logger } = await t.setup());
+    });
+    afterAll(async ()=>{
+        await t.teardown();
+    });
+    let logger;
+    let pxe;
+    let bobsAddress;
+    beforeEach(async ()=>{
+        const bobsSecretKey = Fr.random();
+        const bobsPrivateSigningKey = Fq.random();
+        const bobsAccountManager = await getSchnorrAccount(pxe, bobsSecretKey, bobsPrivateSigningKey, Fr.random());
+        const bobsCompleteAddress = await bobsAccountManager.getCompleteAddress();
+        bobsAddress = bobsCompleteAddress.address;
+        await bobsAccountManager.getWallet();
+        await bobsAccountManager.register();
+    });
+    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
+        const l1TokenManager = t.feeJuiceBridgeTestHarness.l1TokenManager;
+        const origApprove = l1TokenManager.approve.bind(l1TokenManager);
+        l1TokenManager.approve = async (amount, address, addressName = '')=>{
+            await origApprove(amount, address, addressName);
+            const sleepTime = (Number(t.chainMonitor.l2BlockTimestamp) + 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);
+        };
+        // Waiting for the archiver to sync the message _before_ waiting for the mandatory 2 L2 blocks to pass fixed it
+        // This was added everywhere we wait for two blocks, which is spread across three different places in the codebase
+        // Yes, we need to REFACTOR it at some point
+        const claim = await t.feeJuiceBridgeTestHarness.prepareTokensOnL1(bobsAddress);
+        const { claimSecret: secret, messageLeafIndex: index } = claim;
+        await t.feeJuiceContract.methods.claim(bobsAddress, claim.claimAmount, secret, index).send({
+            from: bobsAddress
+        }).wait();
+        const [balance] = await t.getGasBalanceFn(bobsAddress);
+        expect(balance).toEqual(claim.claimAmount);
+    });
+});