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

package/dest/fixtures/timing.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Runs `fn` with every {@link testSpan} inside its async call tree attributed to `owner` instead of the
+ * currently running test. Use a non-test sentinel owner (e.g. `other:mempool-feeder`) to keep a
+ * background producer's spans out of the per-test view.
+ */
+export declare function withTestSpanOwner<T>(owner: string, fn: () => Promise<T>): Promise<T>;
+/** One recorded span occurrence on the process-wide `performance.now()` clock. */
+export type TimingSpan = {
+    /** Full name of the test running when the span started, or `null` if inside a beforeAll/afterAll hook. */
+    owner: string | null;
+    /** Stable `category:label` tag, aggregated across occurrences (e.g. `wait:checkpoint`, `setup:node`). */
+    name: string;
+    /** `performance.now()` at span start. */
+    start: number;
+    /** `performance.now()` at span end. */
+    end: number;
+};
+/**
+ * The collector shared by the timing environment on `globalThis.__e2eTimings`. `current` is the full
+ * name of the test currently running (`null` during beforeAll/afterAll); the environment sets it. The
+ * `spans` array accumulates every recorded span until the environment folds it into the per-test /
+ * per-suite JSONL line at flush.
+ */
+export type SpanCollector = {
+    /** Full name of the running test, or `null` during a beforeAll/afterAll hook. */
+    current: string | null;
+    /** All recorded spans, drained by the timing environment at flush time. */
+    spans: TimingSpan[];
+};
+/**
+ * Times `fn` and records a span tagged `name`, attributed to the test (or suite) running when it
+ * started. The span is recorded even when `fn` throws. Pure passthrough: when no collector is
+ * installed (i.e. `TEST_TIMING_FILE` is unset) this calls `fn()` directly with zero overhead.
+ *
+ * Use stable `category:label` tags and prefer wrapping at the leaf wait/setup/tx level — labels are
+ * forever aggregation keys, and leaf-level tagging keeps spans additive. See `SPEEDUP_FOLLOWUPS` and
+ * the A-1179 design doc for the tag taxonomy.
+ */
+export declare function testSpan<T>(name: string, fn: () => Promise<T>): Promise<T>;
+/** Synchronous variant of {@link testSpan} for non-async helpers. Same zero-cost guarantee when unset. */
+export declare function testSpanSync<T>(name: string, fn: () => T): T;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltaW5nLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZml4dHVyZXMvdGltaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXNCQTs7OztHQUlHO0FBQ0gsd0JBQWdCLGlCQUFpQixDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxNQUFNLE9BQU8sQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBRXBGO0FBRUQsa0ZBQWtGO0FBQ2xGLE1BQU0sTUFBTSxVQUFVLEdBQUc7SUFDdkIsMEdBQTBHO0lBQzFHLEtBQUssRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUFDO0lBQ3JCLHlHQUF5RztJQUN6RyxJQUFJLEVBQUUsTUFBTSxDQUFDO0lBQ2IseUNBQXlDO0lBQ3pDLEtBQUssRUFBRSxNQUFNLENBQUM7SUFDZCx1Q0FBdUM7SUFDdkMsR0FBRyxFQUFFLE1BQU0sQ0FBQztDQUNiLENBQUM7QUFFRjs7Ozs7R0FLRztBQUNILE1BQU0sTUFBTSxhQUFhLEdBQUc7SUFDMUIsaUZBQWlGO0lBQ2pGLE9BQU8sRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUFDO0lBQ3ZCLDJFQUEyRTtJQUMzRSxLQUFLLEVBQUUsVUFBVSxFQUFFLENBQUM7Q0FDckIsQ0FBQztBQU1GOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLFFBQVEsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsTUFBTSxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQVloRjtBQUVELDBHQUEwRztBQUMxRyx3QkFBZ0IsWUFBWSxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxNQUFNLENBQUMsR0FBRyxDQUFDLENBWTVEIn0=

package/dest/fixtures/timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../../src/fixtures/timing.ts"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEpF;AAED,kFAAkF;AAClF,MAAM,MAAM,UAAU,GAAG;IACvB,0GAA0G;IAC1G,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,yGAAyG;IACzG,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iFAAiF;IACjF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,2EAA2E;IAC3E,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB,CAAC;AAMF;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAYhF;AAED,0GAA0G;AAC1G,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAY5D"}

package/dest/fixtures/timing.js

@@ -0,0 +1,72 @@
+/**
+ * E2e span instrumentation. Wrapping a shared test helper in {@link testSpan} / {@link testSpanSync}
+ * records how long it ran, attributed to the test (or suite) that was executing, so a full CI run can
+ * be aggregated into a ranked list of where the suite spends wall-clock (setup, protocol waits, client
+ * proving, warp scans, ...). See the A-1178 timing environment in `shared/timing_env.mjs`.
+ *
+ * Everything here is gated on the collector installed by that environment, which only exists when
+ * `TEST_TIMING_FILE` is set. When it is unset, {@link testSpan} calls `fn()` directly with no extra work
+ * and no clock reads — instrumentation is exactly zero-cost and cannot change a test's behavior or
+ * timing.
+ */ import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * Async-context owner override. A span normally attributes itself to the running test
+ * (`collector.current`), but a background producer (e.g. the mempool feeder) runs interleaved with
+ * arbitrary tests, so its spans would smear across whichever test happened to be current when each
+ * round fired. Running such work inside {@link withTestSpanOwner} pins every span in that async call
+ * tree to a fixed owner instead — isolated by async context from concurrent test-body spans.
+ */ const ownerOverride = new AsyncLocalStorage();
+/**
+ * Runs `fn` with every {@link testSpan} inside its async call tree attributed to `owner` instead of the
+ * currently running test. Use a non-test sentinel owner (e.g. `other:mempool-feeder`) to keep a
+ * background producer's spans out of the per-test view.
+ */ export function withTestSpanOwner(owner, fn) {
+    return ownerOverride.run(owner, fn);
+}
+function getCollector() {
+    return globalThis.__e2eTimings;
+}
+/**
+ * Times `fn` and records a span tagged `name`, attributed to the test (or suite) running when it
+ * started. The span is recorded even when `fn` throws. Pure passthrough: when no collector is
+ * installed (i.e. `TEST_TIMING_FILE` is unset) this calls `fn()` directly with zero overhead.
+ *
+ * Use stable `category:label` tags and prefer wrapping at the leaf wait/setup/tx level — labels are
+ * forever aggregation keys, and leaf-level tagging keeps spans additive. See `SPEEDUP_FOLLOWUPS` and
+ * the A-1179 design doc for the tag taxonomy.
+ */ export async function testSpan(name, fn) {
+    const collector = getCollector();
+    if (!collector) {
+        return fn();
+    }
+    const owner = ownerOverride.getStore() ?? collector.current;
+    const start = performance.now();
+    try {
+        return await fn();
+    } finally{
+        collector.spans.push({
+            owner,
+            name,
+            start,
+            end: performance.now()
+        });
+    }
+}
+/** Synchronous variant of {@link testSpan} for non-async helpers. Same zero-cost guarantee when unset. */ export function testSpanSync(name, fn) {
+    const collector = getCollector();
+    if (!collector) {
+        return fn();
+    }
+    const owner = ownerOverride.getStore() ?? collector.current;
+    const start = performance.now();
+    try {
+        return fn();
+    } finally{
+        collector.spans.push({
+            owner,
+            name,
+            start,
+            end: performance.now()
+        });
+    }
+}

package/dest/fixtures/token_utils.d.ts

@@ -2,11 +2,29 @@ import type { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { Logger } from '@aztec/aztec.js/log';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { TestTokenContract } from '@aztec/noir-test-contracts.js/TestToken';
+/**
+ * Either token flavour. Canonical `TokenContract` uses constrained message delivery (production / docs
+ * source of truth); `TestTokenContract` is its codegen'd unconstrained-delivery sibling, used by tests
+ * where a token is just a unit-of-account vehicle. The two share an identical ABI, so helpers that only
+ * read balances or mint accept either.
+ */
+export type AnyTokenContract = TokenContract | TestTokenContract;
 export declare function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger): Promise<{
     contract: TokenContract;
     instance: import("@aztec/aztec.js/contracts").ContractInstanceWithAddress;
 }>;
-export declare function mintTokensToPrivate(token: TokenContract, minter: AztecAddress, recipient: AztecAddress, amount: bigint, additionalScopes?: AztecAddress[]): Promise<void>;
-export declare function expectTokenBalance(wallet: Wallet, token: TokenContract, owner: AztecAddress, expectedBalance: bigint, logger: Logger): Promise<void>;
-export declare function mintNotes(wallet: Wallet, minter: AztecAddress, recipient: AztecAddress, asset: TokenContract, noteAmounts: bigint[]): Promise<bigint>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5fdXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maXh0dXJlcy90b2tlbl91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUU5RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFL0Qsd0JBQXNCLFdBQVcsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxZQUFZLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxNQUFNOzs7R0Fhakg7QUFFRCx3QkFBc0IsbUJBQW1CLENBQ3ZDLEtBQUssRUFBRSxhQUFhLEVBQ3BCLE1BQU0sRUFBRSxZQUFZLEVBQ3BCLFNBQVMsRUFBRSxZQUFZLEVBQ3ZCLE1BQU0sRUFBRSxNQUFNLEVBQ2QsZ0JBQWdCLENBQUMsRUFBRSxZQUFZLEVBQUUsaUJBR2xDO0FBRUQsd0JBQXNCLGtCQUFrQixDQUN0QyxNQUFNLEVBQUUsTUFBTSxFQUNkLEtBQUssRUFBRSxhQUFhLEVBQ3BCLEtBQUssRUFBRSxZQUFZLEVBQ25CLGVBQWUsRUFBRSxNQUFNLEVBQ3ZCLE1BQU0sRUFBRSxNQUFNLGlCQU9mO0FBRUQsd0JBQXNCLFNBQVMsQ0FDN0IsTUFBTSxFQUFFLE1BQU0sRUFDZCxNQUFNLEVBQUUsWUFBWSxFQUNwQixTQUFTLEVBQUUsWUFBWSxFQUN2QixLQUFLLEVBQUUsYUFBYSxFQUNwQixXQUFXLEVBQUUsTUFBTSxFQUFFLEdBQ3BCLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FXakIifQ==
+/**
+ * Deploys the unconstrained-delivery `TestTokenContract`. Use this in tests where the token is a
+ * unit-of-account vehicle rather than the subject, so they don't pay constrained delivery's first-send
+ * handshake cost (which distorts step/log counts that benches assert on). Use {@link deployToken} when a
+ * test exercises canonical Token semantics or note discovery.
+ */
+export declare function deployTestToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger): Promise<{
+    contract: TestTokenContract;
+    instance: import("@aztec/aztec.js/contracts").ContractInstanceWithAddress;
+}>;
+export declare function mintTokensToPrivate(token: AnyTokenContract, minter: AztecAddress, recipient: AztecAddress, amount: bigint, additionalScopes?: AztecAddress[]): Promise<void>;
+export declare function expectTokenBalance(wallet: Wallet, token: AnyTokenContract, owner: AztecAddress, expectedBalance: bigint, logger: Logger): Promise<void>;
+export declare function mintNotes(wallet: Wallet, minter: AztecAddress, recipient: AztecAddress, asset: AnyTokenContract, noteAmounts: bigint[]): Promise<bigint>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5fdXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maXh0dXJlcy90b2tlbl91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUU5RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDL0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFFNUU7Ozs7O0dBS0c7QUFDSCxNQUFNLE1BQU0sZ0JBQWdCLEdBQUcsYUFBYSxHQUFHLGlCQUFpQixDQUFDO0FBRWpFLHdCQUFzQixXQUFXLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsWUFBWSxFQUFFLG1CQUFtQixFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTTs7O0dBYWpIO0FBRUQ7Ozs7O0dBS0c7QUFDSCx3QkFBc0IsZUFBZSxDQUNuQyxNQUFNLEVBQUUsTUFBTSxFQUNkLEtBQUssRUFBRSxZQUFZLEVBQ25CLG1CQUFtQixFQUFFLE1BQU0sRUFDM0IsTUFBTSxFQUFFLE1BQU07OztHQWNmO0FBRUQsd0JBQXNCLG1CQUFtQixDQUN2QyxLQUFLLEVBQUUsZ0JBQWdCLEVBQ3ZCLE1BQU0sRUFBRSxZQUFZLEVBQ3BCLFNBQVMsRUFBRSxZQUFZLEVBQ3ZCLE1BQU0sRUFBRSxNQUFNLEVBQ2QsZ0JBQWdCLENBQUMsRUFBRSxZQUFZLEVBQUUsaUJBR2xDO0FBRUQsd0JBQXNCLGtCQUFrQixDQUN0QyxNQUFNLEVBQUUsTUFBTSxFQUNkLEtBQUssRUFBRSxnQkFBZ0IsRUFDdkIsS0FBSyxFQUFFLFlBQVksRUFDbkIsZUFBZSxFQUFFLE1BQU0sRUFDdkIsTUFBTSxFQUFFLE1BQU0saUJBT2Y7QUFFRCx3QkFBc0IsU0FBUyxDQUM3QixNQUFNLEVBQUUsTUFBTSxFQUNkLE1BQU0sRUFBRSxZQUFZLEVBQ3BCLFNBQVMsRUFBRSxZQUFZLEVBQ3ZCLEtBQUssRUFBRSxnQkFBZ0IsRUFDdkIsV0FBVyxFQUFFLE1BQU0sRUFBRSxHQUNwQixPQUFPLENBQUMsTUFBTSxDQUFDLENBV2pCIn0=

package/dest/fixtures/token_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token_utils.d.ts","sourceRoot":"","sources":["../../src/fixtures/token_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;GAajH;AAED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,YAAY,EACvB,MAAM,EAAE,MAAM,EACd,gBAAgB,CAAC,EAAE,YAAY,EAAE,iBAGlC;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,YAAY,EACnB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,iBAOf;AAED,wBAAsB,SAAS,CAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,MAAM,CAAC,CAWjB"}
+{"version":3,"file":"token_utils.d.ts","sourceRoot":"","sources":["../../src/fixtures/token_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAE5E;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG,iBAAiB,CAAC;AAEjE,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;GAajH;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,YAAY,EACnB,mBAAmB,EAAE,MAAM,EAC3B,MAAM,EAAE,MAAM;;;GAcf;AAED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,YAAY,EACvB,MAAM,EAAE,MAAM,EACd,gBAAgB,CAAC,EAAE,YAAY,EAAE,iBAGlC;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,YAAY,EACnB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,iBAOf;AAED,wBAAsB,SAAS,CAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,gBAAgB,EACvB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,MAAM,CAAC,CAWjB"}

package/dest/fixtures/token_utils.js

@@ -1,5 +1,6 @@
 import { BatchCall } from '@aztec/aztec.js/contracts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { TestTokenContract } from '@aztec/noir-test-contracts.js/TestToken';
 export async function deployToken(wallet, admin, initialAdminBalance, logger) {
     logger.info(`Deploying Token contract...`);
     const { contract, instance } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
@@ -14,6 +15,25 @@ export async function deployToken(wallet, admin, initialAdminBalance, logger) {
         instance
     };
 }
+/**
+ * Deploys the unconstrained-delivery `TestTokenContract`. Use this in tests where the token is a
+ * unit-of-account vehicle rather than the subject, so they don't pay constrained delivery's first-send
+ * handshake cost (which distorts step/log counts that benches assert on). Use {@link deployToken} when a
+ * test exercises canonical Token semantics or note discovery.
+ */ export async function deployTestToken(wallet, admin, initialAdminBalance, logger) {
+    logger.info(`Deploying TestToken contract...`);
+    const { contract, instance } = await TestTokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
+        from: admin
+    });
+    if (initialAdminBalance > 0n) {
+        await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
+    }
+    logger.info('L2 contract deployed');
+    return {
+        contract,
+        instance
+    };
+}
 export async function mintTokensToPrivate(token, minter, recipient, amount, additionalScopes) {
     await token.methods.mint_to_private(recipient, amount).send({
         from: minter,
@@ -22,7 +42,7 @@ export async function mintTokensToPrivate(token, minter, recipient, amount, addi
 }
 export async function expectTokenBalance(wallet, token, owner, expectedBalance, logger) {
     // Then check the balance
-    const contractWithWallet = TokenContract.at(token.address, wallet);
+    const contractWithWallet = token.withWallet(wallet);
     const { result: balance } = await contractWithWallet.methods.balance_of_private(owner).simulate({
         from: owner
     });

package/dest/fixtures/wait_helpers.d.ts

@@ -0,0 +1,135 @@
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
+import type { Fr } from '@aztec/aztec.js/fields';
+import type { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Sequencer, SequencerState } from '@aztec/sequencer-client';
+import type { L2BlockTag } from '@aztec/stdlib/block';
+import type { AztecNode, CheckpointTag } from '@aztec/stdlib/interfaces/client';
+import type { L2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
+import type { TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+/** Options for the block-number polling helpers. */
+export type WaitForBlockOpts = {
+    /** Which chain tip to read; defaults to 'proposed'. */
+    tag?: L2BlockTag;
+    /** How the node's block number must relate to `target`; defaults to `(actual, target) => actual >= target`. */
+    compare?: (actual: number, target: number) => boolean;
+    /** Seconds before the poll rejects; defaults to 60. */
+    timeout?: number;
+    /** Seconds between polls; defaults to 0.25. */
+    interval?: number;
+};
+/**
+ * Polls `node.getBlockNumber(tag)` until `opts.compare(actual, target)` holds (default `>=`). Replaces
+ * the ad-hoc `retryUntil(() => node.getBlockNumber(tag) <op> target)` polls scattered across the suite,
+ * where the node may sync forward or prune backward — the caller passes the comparator for whichever it
+ * expects.
+ * @returns The block number once the comparison holds.
+ */
+export declare function waitForBlockNumber(node: AztecNode, target: number, opts?: WaitForBlockOpts): Promise<BlockNumber>;
+/** Convenience for {@link waitForBlockNumber} on the proven tip. */
+export declare function waitForProvenBlock(node: AztecNode, target: number, opts?: Omit<WaitForBlockOpts, 'tag'>): Promise<BlockNumber>;
+/** Compares the node's checkpoint number against the target; defaults to `>=`. */
+export type CheckpointComparator = (actual: number, target: number) => boolean;
+/** Options for {@link waitForNodeCheckpoint}. */
+export type WaitForCheckpointOpts = {
+    /** Which checkpoint tip to read; defaults to 'checkpointed'. */
+    tag?: CheckpointTag;
+    /** How the node's checkpoint number must relate to `target`; defaults to `(actual, target) => actual >= target`. */
+    compare?: CheckpointComparator;
+    /** Seconds before the poll rejects; defaults to 30. */
+    timeout?: number;
+    /** Seconds between polls; defaults to 0.5. */
+    interval?: number;
+};
+/**
+ * Polls a single node's checkpoint number until `opts.compare(actual, target)` holds. Replaces the
+ * `retryUntil(() => node.getChainTips().then(tips => tips.<tag>.checkpoint.number <op> target))` polls
+ * duplicated across the reorg/proving tests, where the node may sync forward, prune backward, or land
+ * exactly on a value — the caller passes the comparator lambda for whichever it expects.
+ * @returns The node's checkpoint number once the comparison holds.
+ */
+export declare function waitForNodeCheckpoint(node: AztecNode, target: number, opts?: WaitForCheckpointOpts): Promise<CheckpointNumber>;
+/** Convenience for {@link waitForNodeCheckpoint} on the proven tip. */
+export declare function waitForNodeProvenCheckpoint(node: AztecNode, target: number, opts?: Omit<WaitForCheckpointOpts, 'tag'>): Promise<CheckpointNumber>;
+/**
+ * Waits for all of `txHashes` to reach the desired status on `node`. The plural form of
+ * {@link waitForTx}; resolves with the receipts in input order.
+ */
+export declare function waitForTxs(node: AztecNode, txHashes: TxHash[], opts?: WaitOpts): Promise<TxReceipt[]>;
+/** Options for {@link waitForBlocksAtSlots}. */
+export type WaitForBlocksAtSlotsOpts = {
+    /** Block number to start scanning from; defaults to the initial L2 block. */
+    from?: BlockNumber;
+    /** How many blocks to fetch per poll; defaults to 10. */
+    limit?: number;
+    /** Seconds before the poll rejects; defaults to 20. */
+    timeout?: number;
+    /** Seconds between polls; defaults to 0.25. */
+    interval?: number;
+};
+/**
+ * Polls `node.getBlocks` until every slot in `slots` is present among the fetched blocks' slot
+ * numbers. Replaces the hand-rolled `retryUntil` over `getBlocks(...).map(getSlot)` membership check.
+ */
+export declare function waitForBlocksAtSlots(node: AztecNode, slots: SlotNumber[], opts?: WaitForBlocksAtSlotsOpts): Promise<void>;
+/**
+ * Polls `node.getL2ToL1MembershipWitness(txHash, message)` until a witness is available, resolving
+ * with it. Wraps the `retryUntil` the cross-chain tests hand-roll while waiting for an L2-to-L1
+ * message's membership witness to become provable.
+ */
+export declare function waitForL2ToL1Witness(node: AztecNode, txHash: TxHash, message: Fr, opts?: {
+    timeout?: number;
+    interval?: number;
+}): Promise<L2ToL1MembershipWitness>;
+/** Options for the tx-receipt polling helpers. */
+export type WaitForTxReceiptOpts = {
+    /** Seconds before the poll rejects; defaults to 30. */
+    timeout?: number;
+    /** Seconds between polls; defaults to 0.25. */
+    interval?: number;
+};
+/**
+ * Polls `node.getTxReceipt(txHash)` until `predicate(receipt)` holds, resolving with the receipt.
+ * Wraps the `retryUntil` that the block-building reorg tests hand-roll while waiting for a tx to
+ * transition between statuses (pruned, re-included, ...).
+ * @returns The receipt once the predicate holds.
+ */
+export declare function waitForTxReceipt(node: AztecNode, txHash: TxHash, predicate: (receipt: TxReceipt) => boolean, opts?: WaitForTxReceiptOpts): Promise<TxReceipt>;
+/** Polls until `node.getTxReceipt(txHash).status === status`. Thin wrapper over {@link waitForTxReceipt}. */
+export declare function waitForTxStatus(node: AztecNode, txHash: TxHash, status: TxStatus, opts?: WaitForTxReceiptOpts): Promise<TxReceipt>;
+/** Compares the node's pending-tx count against the target; defaults to `>=`. */
+export type PendingTxCountComparator = (actual: number, target: number) => boolean;
+/** Options for {@link waitForPendingTxCount}. */
+export type WaitForPendingTxCountOpts = {
+    /** How the node's pending-tx count must relate to `target`; defaults to `(actual, target) => actual >= target`. */
+    compare?: PendingTxCountComparator;
+    /** Seconds before the poll rejects; defaults to 30. */
+    timeout?: number;
+    /** Seconds between polls; defaults to 0.25. */
+    interval?: number;
+};
+/**
+ * Polls `node.getPendingTxCount()` until `opts.compare(actual, target)` holds (default `>=`).
+ * Replaces the hand-rolled mempool-size poll in the slashing tests.
+ * @returns The pending-tx count once the comparison holds.
+ */
+export declare function waitForPendingTxCount(node: AztecNode, target: number, opts?: WaitForPendingTxCountOpts): Promise<number>;
+/** Options for {@link waitForSequencerState}. */
+export type WaitForSequencerStateOpts = {
+    /** Milliseconds before the wait rejects; defaults to 30000. */
+    timeout?: number;
+    /**
+     * Action to run after subscribing to the sequencer but before awaiting the transition. Subscribing
+     * first guarantees the state change the action triggers is not missed between the action and the
+     * listener attaching.
+     */
+    after?: () => unknown;
+};
+/**
+ * Resolves once `sequencer` reaches `state`. Subscribes to the `state-changed` event first, then (if
+ * `opts.after` is given) runs the action, then resolves immediately if the sequencer is already at
+ * `state`, otherwise waits for the transition. The listener is cleaned up on both resolve and timeout.
+ * Replaces the hand-rolled `state-changed` on/off subscriptions duplicated across the fee, cross-chain,
+ * and keystore-reload tests.
+ */
+export declare function waitForSequencerState(sequencer: Sequencer, state: SequencerState, opts?: WaitForSequencerStateOpts): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/fixtures/wait_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait_helpers.d.ts","sourceRoot":"","sources":["../../src/fixtures/wait_helpers.ts"],"names":[],"mappings":"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"}

package/dest/fixtures/wait_helpers.js

@@ -0,0 +1,154 @@
+import { waitForTx } from '@aztec/aztec.js/node';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/aztec.js/protocol';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { retryUntil } from '@aztec/foundation/retry';
+import { testSpan } from './timing.js';
+/**
+ * Polls `node.getBlockNumber(tag)` until `opts.compare(actual, target)` holds (default `>=`). Replaces
+ * the ad-hoc `retryUntil(() => node.getBlockNumber(tag) <op> target)` polls scattered across the suite,
+ * where the node may sync forward or prune backward — the caller passes the comparator for whichever it
+ * expects.
+ * @returns The block number once the comparison holds.
+ */ export function waitForBlockNumber(node, target, opts = {}) {
+    const tag = opts.tag ?? 'proposed';
+    const compare = opts.compare ?? ((actual, target)=>actual >= target);
+    return testSpan(`wait:${tag}`, ()=>// Wrap the matched value: retryUntil treats any falsy return as "keep polling", so a legitimate
+        // match of block 0 (e.g. a freshly-pruned tip) would otherwise loop until timeout.
+        retryUntil(async ()=>{
+            const blockNumber = await node.getBlockNumber(tag);
+            return compare(blockNumber, target) ? {
+                blockNumber
+            } : undefined;
+        }, `block ${tag} ${compare} ${target}`, opts.timeout ?? 60, opts.interval ?? 0.25).then(({ blockNumber })=>blockNumber));
+}
+/** Convenience for {@link waitForBlockNumber} on the proven tip. */ export function waitForProvenBlock(node, target, opts = {}) {
+    return waitForBlockNumber(node, target, {
+        ...opts,
+        tag: 'proven'
+    });
+}
+/**
+ * Polls a single node's checkpoint number until `opts.compare(actual, target)` holds. Replaces the
+ * `retryUntil(() => node.getChainTips().then(tips => tips.<tag>.checkpoint.number <op> target))` polls
+ * duplicated across the reorg/proving tests, where the node may sync forward, prune backward, or land
+ * exactly on a value — the caller passes the comparator lambda for whichever it expects.
+ * @returns The node's checkpoint number once the comparison holds.
+ */ export function waitForNodeCheckpoint(node, target, opts = {}) {
+    const tag = opts.tag ?? 'checkpointed';
+    const compare = opts.compare ?? ((actual, target)=>actual >= target);
+    return testSpan(tag === 'proven' ? 'wait:proven-checkpoint' : 'wait:checkpoint', ()=>// Wrap the matched value: retryUntil treats any falsy return as "keep polling", so a legitimate
+        // match of checkpoint 0 (e.g. proven === 0 or checkpointed <= 1 after a prune) would otherwise
+        // loop until timeout instead of resolving.
+        retryUntil(async ()=>{
+            const checkpointNumber = await node.getCheckpointNumber(tag);
+            return compare(checkpointNumber, target) ? {
+                checkpointNumber
+            } : undefined;
+        }, `node checkpoint ${tag} ${compare} ${target}`, opts.timeout ?? 30, opts.interval ?? 0.5).then(({ checkpointNumber })=>checkpointNumber));
+}
+/** Convenience for {@link waitForNodeCheckpoint} on the proven tip. */ export function waitForNodeProvenCheckpoint(node, target, opts = {}) {
+    return waitForNodeCheckpoint(node, target, {
+        ...opts,
+        tag: 'proven'
+    });
+}
+/**
+ * Waits for all of `txHashes` to reach the desired status on `node`. The plural form of
+ * {@link waitForTx}; resolves with the receipts in input order.
+ */ export function waitForTxs(node, txHashes, opts) {
+    const optsWithInterval = {
+        ...opts,
+        interval: opts?.interval ?? 0.25
+    };
+    return testSpan('wait:tx-mined', ()=>Promise.all(txHashes.map((txHash)=>waitForTx(node, txHash, optsWithInterval))));
+}
+/**
+ * Polls `node.getBlocks` until every slot in `slots` is present among the fetched blocks' slot
+ * numbers. Replaces the hand-rolled `retryUntil` over `getBlocks(...).map(getSlot)` membership check.
+ */ export async function waitForBlocksAtSlots(node, slots, opts = {}) {
+    const from = opts.from ?? INITIAL_L2_BLOCK_NUM;
+    const limit = opts.limit ?? 10;
+    await testSpan('wait:block', ()=>retryUntil(async ()=>{
+            const blocks = await node.getBlocks(from, limit);
+            const foundSlots = blocks.map((block)=>block.header.getSlot());
+            return slots.every((slot)=>foundSlots.includes(slot)) || undefined;
+        }, `blocks at slots ${slots.join(', ')}`, opts.timeout ?? 20, opts.interval ?? 0.25));
+}
+/**
+ * Polls `node.getL2ToL1MembershipWitness(txHash, message)` until a witness is available, resolving
+ * with it. Wraps the `retryUntil` the cross-chain tests hand-roll while waiting for an L2-to-L1
+ * message's membership witness to become provable.
+ */ export function waitForL2ToL1Witness(node, txHash, message, opts = {}) {
+    return testSpan('wait:l2-to-l1-witness', ()=>retryUntil(()=>node.getL2ToL1MembershipWitness(txHash, message), `L2-to-L1 membership witness for ${txHash.toString()}`, opts.timeout ?? 30, opts.interval ?? 0.25));
+}
+/**
+ * Polls `node.getTxReceipt(txHash)` until `predicate(receipt)` holds, resolving with the receipt.
+ * Wraps the `retryUntil` that the block-building reorg tests hand-roll while waiting for a tx to
+ * transition between statuses (pruned, re-included, ...).
+ * @returns The receipt once the predicate holds.
+ */ export function waitForTxReceipt(node, txHash, predicate, opts = {}) {
+    return testSpan('wait:tx-mined', ()=>retryUntil(async ()=>{
+            const receipt = await node.getTxReceipt(txHash);
+            return predicate(receipt) ? {
+                receipt
+            } : undefined;
+        }, `tx receipt for ${txHash.toString()}`, opts.timeout ?? 30, opts.interval ?? 0.25).then(({ receipt })=>receipt));
+}
+/** Polls until `node.getTxReceipt(txHash).status === status`. Thin wrapper over {@link waitForTxReceipt}. */ export function waitForTxStatus(node, txHash, status, opts = {}) {
+    return waitForTxReceipt(node, txHash, (receipt)=>receipt.status === status, opts);
+}
+/**
+ * Polls `node.getPendingTxCount()` until `opts.compare(actual, target)` holds (default `>=`).
+ * Replaces the hand-rolled mempool-size poll in the slashing tests.
+ * @returns The pending-tx count once the comparison holds.
+ */ export function waitForPendingTxCount(node, target, opts = {}) {
+    const compare = opts.compare ?? ((actual, target)=>actual >= target);
+    return testSpan('wait:pending-tx', ()=>// Wrap the matched value: retryUntil treats any falsy return as "keep polling", so a legitimate
+        // match of 0 pending txs would otherwise loop until timeout instead of resolving.
+        retryUntil(async ()=>{
+            const count = await node.getPendingTxCount();
+            return compare(count, target) ? {
+                count
+            } : undefined;
+        }, `pending tx count ${compare} ${target}`, opts.timeout ?? 30, opts.interval ?? 0.25).then(({ count })=>count));
+}
+/**
+ * Resolves once `sequencer` reaches `state`. Subscribes to the `state-changed` event first, then (if
+ * `opts.after` is given) runs the action, then resolves immediately if the sequencer is already at
+ * `state`, otherwise waits for the transition. The listener is cleaned up on both resolve and timeout.
+ * Replaces the hand-rolled `state-changed` on/off subscriptions duplicated across the fee, cross-chain,
+ * and keystore-reload tests.
+ */ export function waitForSequencerState(sequencer, state, opts = {}) {
+    return testSpan('wait:sequencer-state', ()=>waitForSequencerStateInner(sequencer, state, opts));
+}
+async function waitForSequencerStateInner(sequencer, state, opts) {
+    const timeout = opts.timeout ?? 30000;
+    const { promise, resolve, reject } = promiseWithResolvers();
+    let settled = false;
+    const handler = (args)=>{
+        if (args.newState === state) {
+            finish(resolve);
+        }
+    };
+    const timer = setTimeout(()=>finish(()=>reject(new Error(`Timeout waiting for sequencer ${state} state`))), timeout);
+    function finish(complete) {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        sequencer.off('state-changed', handler);
+        complete();
+    }
+    sequencer.on('state-changed', handler);
+    try {
+        await opts.after?.();
+        if (sequencer.status().state === state) {
+            finish(resolve);
+        }
+        await promise;
+    } catch (err) {
+        finish(()=>{});
+        throw err;
+    }
+}

package/dest/forward-compatibility/wallet_service.js

@@ -27,7 +27,7 @@ async function main() {
     const extraAccountSecret = Fr.fromHexString('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
     const extraAccountSalt = Fr.ZERO;
     const extraAccountSigningKey = GrumpkinScalar.random();
-    const extraAccountAddress = await getSchnorrAccountContractAddress(extraAccountSecret, extraAccountSalt, extraAccountSigningKey);
+    const extraAccountAddress = await getSchnorrAccountContractAddress(extraAccountSigningKey, extraAccountSalt, extraAccountSecret);
     logger.info('Starting wallet service...', {
         l1RpcUrls
     });

package/dest/multi-node/block-production/setup.d.ts

@@ -0,0 +1,97 @@
+import type { Archiver } from '@aztec/archiver';
+import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { NO_WAIT } from '@aztec/aztec.js/contracts';
+import { generateClaimSecret } from '@aztec/aztec.js/ethereum';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import { isL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
+import { waitForTx } from '@aztec/aztec.js/node';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { waitUntilL1Timestamp } from '@aztec/ethereum/l1-tx-utils';
+import { asyncMap } from '@aztec/foundation/async-map';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { timesAsync } from '@aztec/foundation/collection';
+import { retryUntil } from '@aztec/foundation/retry';
+import { sleep } from '@aztec/foundation/sleep';
+import { executeTimeout } from '@aztec/foundation/timer';
+import { TestContract } from '@aztec/noir-test-contracts.js/Test';
+import type { SequencerEvents } from '@aztec/sequencer-client';
+import { getSlotAtTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { GasFees } from '@aztec/stdlib/gas';
+import { TxStatus } from '@aztec/stdlib/tx';
+import { jest } from '@jest/globals';
+import { sendL1ToL2Message } from '../../fixtures/l1_to_l2_messaging.js';
+import type { EndToEndContext } from '../../fixtures/utils.js';
+import { waitForBlockNumber, waitForTxs } from '../../fixtures/wait_helpers.js';
+import type { TestWallet } from '../../test-wallet/test_wallet.js';
+import { proveInteraction } from '../../test-wallet/utils.js';
+import { type BlockProposedEvent, MULTI_VALIDATOR_BLOCK_PRODUCTION_TIMING, MultiNodeTestContext, type MultiNodeTestOpts, type RegisteredValidator, type TrackedSequencerEvent, WIDE_SLOT_TIMING, buildMockGossipValidators } from '../multi_node_test_context.js';
+export declare const NODE_COUNT = 4;
+export declare const TX_COUNT = 10;
+/** The validator cluster + context produced by {@link setupSimpleBlockProduction}. */
+export type SimpleBlockProductionFixture = {
+    test: MultiNodeTestContext;
+    context: EndToEndContext;
+    logger: Logger;
+    validators: RegisteredValidator[];
+    nodes: AztecNodeService[];
+    from: AztecAddress;
+};
+/** State shared by the wide-slot `it`s (handles 4 validators + prover + a wallet pointed at node 0). */
+export type BlockProductionWithProverFixture = {
+    test: MultiNodeTestContext;
+    context: EndToEndContext;
+    logger: Logger;
+    rollup: RollupContract;
+    archiver: Archiver;
+    validators: RegisteredValidator[];
+    nodes: AztecNodeService[];
+    contract: TestContract;
+    wallet: TestWallet;
+    from: AztecAddress;
+    failEvents: TrackedSequencerEvent[];
+};
+/**
+ * Stands up the `block-production` validator cluster shared by the `MULTI_VALIDATOR_BLOCK_PRODUCTION_TIMING` tests
+ * (`simple`, `high_tps`): builds `nodeCount` mock-gossip validators, sets up the context with the
+ * block-production timing profile, spawns one validator node per validator, and returns the cluster. The
+ * per-test divergence (`fakeProcessingDelayPerTxMs`, `txDelayerMaxInclusionTimeIntoSlot`,
+ * min/maxTxsPerBlock, whether sequencers start eagerly, contract type) passes through `opts`. Mirrors
+ * how {@link setupBlockProductionWithProver} factors out the prover-backed setup; the test still registers its own contract.
+ */
+export declare function setupSimpleBlockProduction(opts: {
+    nodeCount: number;
+    setupOpts?: Partial<MultiNodeTestOpts>;
+    nodeOpts?: Partial<AztecNodeConfig> & {
+        dontStartSequencer?: boolean;
+    };
+}): Promise<SimpleBlockProductionFixture>;
+/**
+ * Creates validators and sets up a wide-slot test context with the pipelining timing profile and a prover
+ * node, then starts (paused) validator nodes and points the wallet at node 0. Mirrors the per-test
+ * setup from the dissolved `mbps.parallel` file. The blob-promotion and pipeline-prune suites layer their
+ * adverse-network shape on via `mockGossipSubNetworkLatency`, `maxTxsPerCheckpoint`, `clearInheritedCoinbase`,
+ * and `disableCheckpointPromotionOnFirstNode`.
+ */
+export declare function setupBlockProductionWithProver(opts: {
+    syncChainTip: 'proposed' | 'checkpointed';
+    minTxsPerBlock?: number;
+    maxTxsPerBlock?: number;
+    maxTxsPerCheckpoint?: number;
+    buildCheckpointIfEmpty?: boolean;
+    skipPushProposedBlocksToArchiver?: boolean;
+    /** Injects artificial mock-gossip propagation latency (ms) to model adverse network conditions. */
+    mockGossipSubNetworkLatency?: number;
+    /** Clears each validator node's inherited coinbase so it derives one from its own attester key. */
+    clearInheritedCoinbase?: boolean;
+    /**
+     * Disables checkpoint promotion on node 0 (`skipPromoteProposedCheckpointDuringL1Sync`), so node 0 fetches
+     * blobs during L1 sync while its peers promote their own proposed checkpoints and skip the blob fetch.
+     */
+    disableCheckpointPromotionOnFirstNode?: boolean;
+}): Promise<BlockProductionWithProverFixture>;
+/** Waits until a specific multi-block checkpoint is proven, verifying that proving succeeds with multiple-blocks-per-slot. */
+export declare function waitForProvenCheckpoint(fixture: BlockProductionWithProverFixture, targetCheckpoint: CheckpointNumber): Promise<void>;
+export { type Archiver, type AztecNodeConfig, type AztecNodeService, AztecAddress, EthAddress, NO_WAIT, generateClaimSecret, Fr, type Logger, isL1ToL2MessageReady, waitForTx, RollupContract, waitUntilL1Timestamp, asyncMap, BlockNumber, CheckpointNumber, SlotNumber, timesAsync, retryUntil, sleep, executeTimeout, TestContract, type SequencerEvents, getSlotAtTimestamp, getTimestampForSlot, GasFees, TxStatus, jest, sendL1ToL2Message, type EndToEndContext, waitForBlockNumber, waitForTxs, type TestWallet, proveInteraction, type BlockProposedEvent, WIDE_SLOT_TIMING, MULTI_VALIDATOR_BLOCK_PRODUCTION_TIMING, MultiNodeTestContext, type RegisteredValidator, type TrackedSequencerEvent, buildMockGossipValidators, };
+//# sourceMappingURL=data:application/json;base64,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