@aztec/end-to-end 5.0.0-rc.2 → 5.0.1

package/dest/single-node/proving/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/single-node/proving/setup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,OAAO,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC/F,OAAO,EAAE,qBAAqB,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAC;AAIvG,OAAO,EACL,IAAI,EACJ,eAAe,EACf,qBAAqB,EACrB,8BAA8B,EAC9B,0BAA0B,EAC1B,mBAAmB,GACpB,CAAC"}

package/dest/single-node/proving/setup.js

@@ -0,0 +1,5 @@
+import { jest } from '@jest/globals';
+import { NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING, setupWithProver } from '../setup.js';
+import { SingleNodeTestContext, WORLD_STATE_CHECKPOINT_HISTORY } from '../single_node_test_context.js';
+jest.setTimeout(1000 * 60 * 15);
+export { jest, setupWithProver, SingleNodeTestContext, WORLD_STATE_CHECKPOINT_HISTORY, NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING };

package/dest/single-node/recovery/setup.d.ts

@@ -0,0 +1,5 @@
+import { jest } from '@jest/globals';
+import { NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING, setupWithProver } from '../setup.js';
+import { SingleNodeTestContext } from '../single_node_test_context.js';
+export { jest, setupWithProver, SingleNodeTestContext, NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dXAuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zaW5nbGUtbm9kZS9yZWNvdmVyeS9zZXR1cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXJDLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxtQkFBbUIsRUFBRSxlQUFlLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDL0YsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFJdkUsT0FBTyxFQUFFLElBQUksRUFBRSxlQUFlLEVBQUUscUJBQXFCLEVBQUUsMEJBQTBCLEVBQUUsbUJBQW1CLEVBQUUsQ0FBQyJ9

package/dest/single-node/recovery/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/single-node/recovery/setup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,OAAO,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC/F,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAIvE,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,qBAAqB,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,CAAC"}

package/dest/single-node/recovery/setup.js

@@ -0,0 +1,5 @@
+import { jest } from '@jest/globals';
+import { NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING, setupWithProver } from '../setup.js';
+import { SingleNodeTestContext } from '../single_node_test_context.js';
+jest.setTimeout(1000 * 60 * 10);
+export { jest, setupWithProver, SingleNodeTestContext, NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING };

package/dest/single-node/setup.d.ts

@@ -0,0 +1,49 @@
+import { SingleNodeTestContext, type SingleNodeTestOpts } from './single_node_test_context.js';
+/**
+ * The single-node setup surface, organized over the prover axis (none / fake / real). Each factory is a
+ * thin wrapper over {@link SingleNodeTestContext.setup} that fixes the prover mode and the defaults that go
+ * with it; tests pick the factory matching their topology and vary it through `opts`.
+ */
+/**
+ * Proof-submission window (in epochs) so large the chain never prunes/reorgs in the test's lifetime.
+ * Tests that must keep unproven blocks alive for their whole run (no prover, or a hand-driven settler)
+ * set `aztecProofSubmissionEpochs` to this rather than picking an arbitrary large number.
+ */
+export declare const NO_REORG_SUBMISSION_EPOCHS = 1024;
+/**
+ * The "12s floor" slot cadence: a 4s L1 slot with 3 L1 slots per L2 slot, i.e. a 12s L2 slot. Shared by
+ * the proving / partial-proof suites whose bodies wait in real wall-clock for the sequencer to build
+ * empty checkpoints (one per L2 slot) and so cannot warp the clock forward. 12s is the shortest L2 slot
+ * that still fits one block per checkpoint under the default 3s block-duration timing model (which needs
+ * S >= ~8.5s); an 8s slot derives 0 blocks per checkpoint and trips the timing-config guard. Running at
+ * this floor keeps those real-time waits as short as possible.
+ */
+export declare const PROVING_SLOT_TIMING: {
+    readonly ethereumSlotDuration: 4;
+    readonly aztecSlotDurationInL1Slots: 3;
+};
+/**
+ * Single sequencer plus the context's fake in-process prover node (`realProofs: false`,
+ * `aztecProofSubmissionEpochs: 1`, `syncChainTip: 'checkpointed'`). This is exactly today's
+ * {@link SingleNodeTestContext.setup} default, used by the proving/partial-proofs/reorg/recovery suites.
+ */
+export declare function setupWithProver(opts?: SingleNodeTestOpts): Promise<SingleNodeTestContext>;
+/**
+ * Single production sequencer with **no prover node**, used by the block-building/sequencer/sync suites.
+ *
+ * Dropping the prover requires raising `aztecProofSubmissionEpochs` to a high value
+ * ({@link NO_REORG_SUBMISSION_EPOCHS}): with the context's default window of `1` and no prover producing
+ * proofs, unproven blocks get pruned out from under the test after an epoch — so the high window keeps the
+ * blocks alive. Also defaults the PXE to `syncChainTip: 'proposed'` (rather than the context's
+ * `'checkpointed'`) since these tests assert on freshly proposed, not-yet-checkpointed blocks.
+ *
+ * Defaults `aztecEpochDuration` to `32` (the production default). These tests were written against the raw
+ * `setup()` helper, which deployed with the 32-slot production epoch; the context's own default of `6`
+ * lands an epoch boundary mid-test, where proposer selection changes and the propose for the boundary slot
+ * silently reverts (no checkpoint lands, the chain stops advancing). The 32-slot epoch keeps the boundary
+ * out past the short runs these tests need. All three (`startProverNode`, the proof window, the epoch) and
+ * `pxeOpts` can be overridden via `opts` — tests that need a shorter epoch (e.g. governance signalling) set
+ * their own.
+ */
+export declare function setupBlockProducer(opts?: SingleNodeTestOpts): Promise<SingleNodeTestContext>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dXAuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zaW5nbGUtbm9kZS9zZXR1cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsS0FBSyxrQkFBa0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRS9GOzs7O0dBSUc7QUFFSDs7OztHQUlHO0FBQ0gsZUFBTyxNQUFNLDBCQUEwQixPQUFPLENBQUM7QUFFL0M7Ozs7Ozs7R0FPRztBQUNILGVBQU8sTUFBTSxtQkFBbUI7OztDQUd0QixDQUFDO0FBRVg7Ozs7R0FJRztBQUNILHdCQUFnQixlQUFlLENBQUMsSUFBSSxHQUFFLGtCQUF1QixHQUFHLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBQyxDQUU3RjtBQUVEOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBQ0gsd0JBQWdCLGtCQUFrQixDQUFDLElBQUksR0FBRSxrQkFBdUIsR0FBRyxPQUFPLENBQUMscUJBQXFCLENBQUMsQ0FRaEcifQ==

package/dest/single-node/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/single-node/setup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,KAAK,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAE/F;;;;GAIG;AAEH;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,GAAE,kBAAuB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAE7F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,kBAAuB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAQhG"}

package/dest/single-node/setup.js

@@ -0,0 +1,56 @@
+import { SingleNodeTestContext } from './single_node_test_context.js';
+/**
+ * The single-node setup surface, organized over the prover axis (none / fake / real). Each factory is a
+ * thin wrapper over {@link SingleNodeTestContext.setup} that fixes the prover mode and the defaults that go
+ * with it; tests pick the factory matching their topology and vary it through `opts`.
+ */ /**
+ * Proof-submission window (in epochs) so large the chain never prunes/reorgs in the test's lifetime.
+ * Tests that must keep unproven blocks alive for their whole run (no prover, or a hand-driven settler)
+ * set `aztecProofSubmissionEpochs` to this rather than picking an arbitrary large number.
+ */ export const NO_REORG_SUBMISSION_EPOCHS = 1024;
+/**
+ * The "12s floor" slot cadence: a 4s L1 slot with 3 L1 slots per L2 slot, i.e. a 12s L2 slot. Shared by
+ * the proving / partial-proof suites whose bodies wait in real wall-clock for the sequencer to build
+ * empty checkpoints (one per L2 slot) and so cannot warp the clock forward. 12s is the shortest L2 slot
+ * that still fits one block per checkpoint under the default 3s block-duration timing model (which needs
+ * S >= ~8.5s); an 8s slot derives 0 blocks per checkpoint and trips the timing-config guard. Running at
+ * this floor keeps those real-time waits as short as possible.
+ */ export const PROVING_SLOT_TIMING = {
+    ethereumSlotDuration: 4,
+    aztecSlotDurationInL1Slots: 3
+};
+/**
+ * Single sequencer plus the context's fake in-process prover node (`realProofs: false`,
+ * `aztecProofSubmissionEpochs: 1`, `syncChainTip: 'checkpointed'`). This is exactly today's
+ * {@link SingleNodeTestContext.setup} default, used by the proving/partial-proofs/reorg/recovery suites.
+ */ export function setupWithProver(opts = {}) {
+    return SingleNodeTestContext.setup(opts);
+}
+/**
+ * Single production sequencer with **no prover node**, used by the block-building/sequencer/sync suites.
+ *
+ * Dropping the prover requires raising `aztecProofSubmissionEpochs` to a high value
+ * ({@link NO_REORG_SUBMISSION_EPOCHS}): with the context's default window of `1` and no prover producing
+ * proofs, unproven blocks get pruned out from under the test after an epoch — so the high window keeps the
+ * blocks alive. Also defaults the PXE to `syncChainTip: 'proposed'` (rather than the context's
+ * `'checkpointed'`) since these tests assert on freshly proposed, not-yet-checkpointed blocks.
+ *
+ * Defaults `aztecEpochDuration` to `32` (the production default). These tests were written against the raw
+ * `setup()` helper, which deployed with the 32-slot production epoch; the context's own default of `6`
+ * lands an epoch boundary mid-test, where proposer selection changes and the propose for the boundary slot
+ * silently reverts (no checkpoint lands, the chain stops advancing). The 32-slot epoch keeps the boundary
+ * out past the short runs these tests need. All three (`startProverNode`, the proof window, the epoch) and
+ * `pxeOpts` can be overridden via `opts` — tests that need a shorter epoch (e.g. governance signalling) set
+ * their own.
+ */ export function setupBlockProducer(opts = {}) {
+    return SingleNodeTestContext.setup({
+        startProverNode: false,
+        aztecProofSubmissionEpochs: NO_REORG_SUBMISSION_EPOCHS,
+        aztecEpochDuration: 32,
+        ...opts,
+        pxeOpts: {
+            syncChainTip: 'proposed',
+            ...opts.pxeOpts
+        }
+    });
+}

package/dest/single-node/single_node_test_context.d.ts

@@ -0,0 +1,374 @@
+import type { InitialAccountData } from '@aztec/accounts/testing';
+import type { Archiver } from '@aztec/archiver';
+import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import type { CheatCodes } from '@aztec/aztec/testing';
+import { EpochCache } from '@aztec/epoch-cache';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { Delayer } from '@aztec/ethereum/l1-tx-utils';
+import { ChainMonitor } from '@aztec/ethereum/test';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
+import { TestContract } from '@aztec/noir-test-contracts.js/Test';
+import type { ProverNodeConfig, ProverNodeDeps } from '@aztec/prover-node';
+import type { PXEConfig } from '@aztec/pxe/config';
+import { type Sequencer, type SequencerClient, type SequencerEvents, SequencerState } from '@aztec/sequencer-client';
+import { type BlockParameter, EthAddress } from '@aztec/stdlib/block';
+import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import type { SlashingProtectionDatabase } from '@aztec/validator-ha-signer/types';
+import type { Hex } from 'viem';
+import { type EndToEndContext, type SetupOptions } from '../fixtures/utils.js';
+export declare const WORLD_STATE_CHECKPOINT_HISTORY = 2;
+export declare const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
+export declare const ARCHIVER_POLL_INTERVAL = 50;
+/**
+ * Default L1 (ethereum) slot duration in seconds for single-node e2e tests. Kept at 8s, the fast-profile
+ * boundary (`FAST_PROFILE_ETHEREUM_SLOT_DURATION`): at 8s the proposer still uses the production operational
+ * budgets (fast-profile clamping only kicks in strictly below 8s), so the default single-node L2 slot is
+ * `2 x 8 = 16s`. CI previously ran at 12s (24s L2 slots); unifying it with the local value removes a
+ * CI-vs-local cadence asymmetry and cuts every default-cadence single-node suite by a third.
+ */
+export declare const DEFAULT_L1_BLOCK_TIME = 8;
+export type SingleNodeTestOpts = Partial<SetupOptions> & {
+    numberOfAccounts?: number;
+    pxeOpts?: Partial<PXEConfig>;
+    aztecSlotDurationInL1Slots?: number;
+    /** Skip creating/registering the hardcoded account during setup (for tests that handle accounts themselves). */
+    skipHardcodedAccount?: boolean;
+    /**
+     * Force the hardcoded-account fast-path even when an initial sequencer is running. Useful for
+     * tests with tight per-block gas budgets that can't fit a full account-deploy tx.
+     */
+    useHardcodedAccount?: boolean;
+};
+export type TrackedSequencerEvent = {
+    [K in keyof SequencerEvents]: Parameters<SequencerEvents[K]>[0] & {
+        type: K;
+        sequencerIndex: number;
+        validator: EthAddress;
+    };
+}[keyof SequencerEvents];
+/** A `block-proposed` sequencer event captured for the pipelining-offset assertion. */
+export type BlockProposedEvent = {
+    blockNumber: BlockNumber;
+    slot: SlotNumber;
+    buildSlot: SlotNumber;
+};
+/**
+ * The 24s-slot reorg cadence shared by every reorg/prune/HA test, regardless of single-node vs
+ * multi-validator topology: a 24s L2 slot, 5s blocks, and a 4-slot epoch. The 5s block duration is chosen
+ * so the fast-profile budgets both reorg profiles run under (eth < 8s: p2p 0.5s, prepare 0.5s, init 1s)
+ * still fit ~3 full block sub-slots per checkpoint — `floor((24 - 1 - 5 - 2*0.5 - 0.5) / 5) = 3` — which
+ * the l1-reorgs suites' `assertMultipleBlocksPerSlot(2)` assertions require. The two concrete reorg
+ * profiles ({@link FAST_REORG_TIMING}, {@link MULTI_VALIDATOR_REORG_TIMING}) extend this with their topology's L1
+ * slot duration and any extra knobs. Kept timing-only — `maxSpeedUpAttempts`, `cancelTxOnTimeout`, and
+ * `aztecProofSubmissionEpochs` encode per-test scenario intent and stay explicit at the call site.
+ */
+export declare const REORG_TIMING_BASE: {
+    readonly aztecSlotDuration: 24;
+    readonly blockDurationMs: 5000;
+    readonly aztecEpochDuration: 4;
+};
+/**
+ * Timing-only profile shared by the fast single-node L1-reorg tests (`proving/optimistic`'s reorg
+ * cases and `l1-reorgs/`). Extends {@link REORG_TIMING_BASE} with mainnet-style 32-slot anvil epochs
+ * and a 4s L1 slot. Note: `ethereumSlotDuration` stays at 4 here (not unified to
+ * {@link MULTI_VALIDATOR_REORG_TIMING}'s 6) — at eth=6 the proof-submission-window timing in the
+ * proof-removal/proof-restore reorg assertions in `l1-reorgs/blocks` starves and times out, so the 4s
+ * L1 slot is required for the single-node reorg path. Tests that need a different epoch length (e.g. 8
+ * for the "with replacement" case) override `aztecEpochDuration` after the spread.
+ */
+export declare const FAST_REORG_TIMING: {
+    readonly aztecSlotDuration: 24;
+    readonly blockDurationMs: 5000;
+    readonly aztecEpochDuration: 4;
+    readonly ethereumSlotDuration: 4;
+    readonly anvilSlotsInAnEpoch: 32;
+};
+/**
+ * Timing-only profile naming the 24s/6s reorg-and-prune cadence copied verbatim across the
+ * multi-validator recovery and high-availability tests (`recovery/proposal_failure_recovery`,
+ * `recovery/equivocation_recovery`, `high-availability/ha_sync`,
+ * `high-availability/ha_checkpoint_handoff`). The multi-validator analogue of
+ * {@link FAST_REORG_TIMING}, adding the 0.5s attestation-propagation budget those committee tests
+ * need. Timing-only: committee size, `aztecProofSubmissionEpochs`, and the slasher block stay
+ * per-test. Spread BEFORE per-test overrides so a test can still bump e.g. `aztecEpochDuration`.
+ */
+export declare const MULTI_VALIDATOR_REORG_TIMING: {
+    readonly aztecSlotDuration: 24;
+    readonly blockDurationMs: 5000;
+    readonly aztecEpochDuration: 4;
+    readonly ethereumSlotDuration: 6;
+    readonly attestationPropagationTime: 0.5;
+};
+/**
+ * Timing-only profile naming the 24s/12s multi-validator block-production cadence copied across
+ * `block-production/` (`simple`, `first_slot`, and `proof_boundary`). Uses `aztecSlotDurationInL1Slots: 2`
+ * rather than an explicit `aztecSlotDuration: 24` so the L2 slot stays coupled to `ethereumSlotDuration`
+ * if a test overrides eth. The 4s block duration keeps enough full block sub-slots per checkpoint under
+ * the production budgets these eth=12 tests run with (init 1s, prepare 1s, min-block 2s, p2p =
+ * attestationPropagationTime): `floor((24 - 1 - 4 - 2P - 1) / 4)` = 4 blocks at P<=1, 3 blocks at P=2
+ * (the default). Deliberately omits `attestationPropagationTime` (per-scenario: default 2, 0.5, or 1) —
+ * set it per test. `high_tps` pins the old 36s/6s cadence at its own call site because its 2-txs-x-2.5s
+ * per-block budget does not fit a 4s block. Spread BEFORE per-test overrides.
+ */
+export declare const MULTI_VALIDATOR_BLOCK_PRODUCTION_TIMING: {
+    readonly ethereumSlotDuration: 12;
+    readonly aztecSlotDurationInL1Slots: 2;
+    readonly blockDurationMs: 4000;
+};
+/**
+ * Timing-only profile naming the 72s wide-slot multiple-blocks-per-slot cadence copied across the
+ * block-production and recovery tests (`block-production/`'s `setupBlockProductionWithProver`, `block-production/blob_promotion`,
+ * `recovery/pipeline_prune`). A-914:
+ * pipelined multiple-blocks-per-slot needs this 72s/12s cadence (not the tighter 36s/4s), otherwise non-proposer nodes hit
+ * `CheckpointNumberNotSequentialError` when the pipelined proposer races ahead of L1 confirmation. The
+ * larger `perBlockAllocationMultiplier` lets each of the several blocks per slot fit non-trivial txs.
+ * Spread BEFORE per-test overrides (e.g. `mockGossipSubNetworkLatency`, `maxTxsPerCheckpoint`).
+ */
+export declare const WIDE_SLOT_TIMING: {
+    readonly ethereumSlotDuration: 12;
+    readonly aztecSlotDuration: 72;
+    readonly blockDurationMs: 5500;
+    readonly aztecEpochDuration: 4;
+    readonly perBlockAllocationMultiplier: 8;
+    readonly aztecTargetCommitteeSize: 3;
+};
+/**
+ * Base class for the prod-sequencer single-node test topology: one node running the production
+ * sequencer with fast block times and short epochs, an optional fake-proof prover node, and the
+ * environment it runs in (in-proc anvil + L1 deploy). Owns node spawning
+ * (`createNonValidatorNode` / `createProverNode` incl. the mock-gossip `p2pServiceFactory` wiring,
+ * which is harmless with a single node), the `ChainMonitor`, and the epoch / proof-window / reorg
+ * waiters and assertion helpers shared by every test in the category.
+ *
+ * {@link MultiNodeTestContext} extends this with the N-validator topology (validator-node spawning,
+ * committee/proposal/attestation convergence helpers). Single-node-topology tests use this base
+ * directly from the sibling `single-node/` category.
+ */
+export declare class SingleNodeTestContext {
+    context: EndToEndContext;
+    l1Client: ExtendedViemWalletClient;
+    rollup: RollupContract;
+    constants: L1RollupConstants;
+    logger: Logger;
+    monitor: ChainMonitor;
+    epochCache: EpochCache;
+    proverDelayer: Delayer;
+    sequencerDelayer: Delayer;
+    proverNodes: AztecNodeService[];
+    nodes: AztecNodeService[];
+    epochDuration: number;
+    L1_BLOCK_TIME_IN_S: number;
+    L2_SLOT_DURATION_IN_S: number;
+    static setup<T extends SingleNodeTestContext>(this: new () => T, opts?: SingleNodeTestOpts): Promise<T>;
+    static getSlotDurations(opts?: SingleNodeTestOpts): {
+        ethereumSlotDuration: number;
+        aztecSlotDuration: number;
+        aztecEpochDuration: number;
+        aztecProofSubmissionEpochs: number;
+    };
+    setup(opts?: SingleNodeTestOpts): Promise<void>;
+    /**
+     * Populates the context-derived state (tracked nodes, L1 client, rollup, epoch cache, chain
+     * monitor, delayers, timing constants) from an already-built {@link EndToEndContext}. Split out of
+     * {@link setup} so prover-specific subclasses that build the environment with their own bespoke
+     * `setup(...)` opts (e.g. `FullProverTest`) can still reuse the base node/teardown machinery
+     * without inheriting the base's default node config. Slot/epoch durations are read from the
+     * resolved `context.config` so the recorded constants match whatever the environment was deployed
+     * with.
+     */
+    protected hydrateFromContext(context: EndToEndContext): Promise<void>;
+    teardown(): Promise<void>;
+    /**
+     * Computes InitialAccountData for a SchnorrHardcodedKeyAccountContract.
+     * This contract has a hardcoded signing key and no initializer, so it can be used without
+     * on-chain deployment. Pass the returned data in `additionallyFundedAccounts` so the address
+     * gets funded with fee juice in genesis.
+     */
+    static getHardcodedAccountData(secret: Fr, salt: Fr): Promise<InitialAccountData>;
+    /**
+     * Registers a SchnorrHardcodedKeyAccountContract in PXE. The account must have been funded
+     * at genesis (via getHardcodedAccountData). No on-chain deployment or block mining needed.
+     */
+    registerHardcodedAccount(accountData: InitialAccountData): Promise<AztecAddress>;
+    createProverNode(opts?: {
+        dontStart?: boolean;
+        proverNodeDeps?: Partial<ProverNodeDeps>;
+    } & Partial<ProverNodeConfig>): Promise<AztecNodeService>;
+    createNonValidatorNode(opts?: Partial<AztecNodeConfig>): Promise<AztecNodeService>;
+    protected createNode(opts?: Partial<AztecNodeConfig> & {
+        dontStartSequencer?: boolean;
+        slashingProtectionDb?: SlashingProtectionDatabase;
+    }): Promise<AztecNodeService>;
+    protected getNextPrivateKey(): Hex;
+    /** Waits until the epoch begins (ie until the immediately previous L1 block is mined). */
+    waitUntilEpochStarts(epoch: number): Promise<bigint>;
+    /**
+     * Waits until the next epoch boundary and returns that epoch's number. Anchors tests
+     * on a guaranteed-fresh epoch regardless of how much wall time `beforeEach` consumed —
+     * `waitUntilEpochStarts(1)` returns immediately when the chain has already advanced past
+     * slot 4, which under CI load can leave only seconds of the target epoch remaining.
+     *
+     * If the chain has more than two slots of headroom before the target boundary, warps
+     * the L1 clock to within two slots of the boundary instead of waiting in wall-clock.
+     * The two-slot tail is intentional — it lets the sequencer/builder settle so the first
+     * checkpoint of the target epoch lands correctly.
+     */
+    waitUntilNextEpochStarts(): Promise<EpochNumber>;
+    /**
+     * Warps the L1 clock to within `leadSlots` slots of the start of `epoch`, then waits for that boundary in
+     * wall-clock, skipping the dead stretch where the chain just advances one L1 block per slot until an epoch
+     * ends. Anything the post-warp assertions depend on must already be produced before calling this — warping
+     * the tail away does not change what gets proven, and the shared `TestDateProvider` moves the
+     * prover/node/sequencer clocks together so the epoch finalizes right after the warp. The `leadSlots` tail
+     * (default 2) is left in real time so the sequencer can publish the epoch's final checkpoint before the
+     * boundary, and so any post-warp sampler observes an in-epoch slot rather than the epoch's last slot.
+     * Forward-only, so a no-op when already within `leadSlots` of the boundary.
+     */
+    warpToEpochStart(epoch: number, opts?: {
+        leadSlots?: number;
+    }): Promise<bigint>;
+    /**
+     * Most of a proof-submission window is dead wall-clock time, so warp the L1 clock forward to `leadSlots`
+     * (default 2) L2 slots before the window's last slot. A subsequent
+     * {@link waitUntilLastSlotOfProofSubmissionWindow} then only sleeps out the few remaining real slots,
+     * leaving enough real time for any in-flight proving, pruning, and recovery to happen organically. Only
+     * warps forward, so it is a no-op when the chain is already within `leadSlots`+1 slots of the window end.
+     */
+    warpNearSubmissionWindowEnd(epoch: number, opts?: {
+        leadSlots?: number;
+    }): Promise<void>;
+    /** Waits until the given checkpoint number is mined. */
+    waitUntilCheckpointNumber(target: CheckpointNumber, timeout?: number): Promise<void>;
+    /** Waits until the given checkpoint number is marked as proven. */
+    waitUntilProvenCheckpointNumber(target: CheckpointNumber, timeout?: number): Promise<CheckpointNumber>;
+    /** Waits until the last slot of the proof submission window for a given epoch. */
+    waitUntilLastSlotOfProofSubmissionWindow(epochNumber: number | bigint): Promise<void>;
+    /**
+     * Timestamp one L1 block before L2 `slot` begins — the instant a pipelined proposer starts
+     * building for that slot. `opts.lead` overrides the default one-L1-block lead (e.g. when a test
+     * needs an extra block-duration margin to guarantee sub-slot 1 is reachable).
+     */
+    buildWindowTimestampForSlot(slot: SlotNumber, opts?: {
+        lead?: number;
+    }): bigint;
+    /**
+     * Warps the L1 clock to the build window of `slot` (one L1 block before the slot begins) with
+     * `resetBlockInterval`, so a pipelined proposer engages cleanly when its sequencer starts.
+     * @returns The slot warped to.
+     */
+    warpToBuildWindowForSlot(slot: SlotNumber): Promise<SlotNumber>;
+    /**
+     * Waits (in wall-clock, without warping) until the L1 clock reaches the build window of `slot`.
+     * For production-sequencer tests that can't warp. `opts.lead` extends the lead beyond the default
+     * one L1 block; `opts.timeout` bounds the wait (defaults to three L2 slots).
+     * @returns The slot waited for.
+     */
+    waitForBuildWindowForSlot(slot: SlotNumber, opts?: {
+        lead?: number;
+        timeout?: number;
+    }): Promise<SlotNumber>;
+    /** Waits for the aztec node to sync to the target block number. */
+    waitForNodeToSync(blockNumber: BlockNumber, type: 'proven' | 'finalized' | 'historic'): Promise<void>;
+    /**
+     * Waits until every prover node has submitted a proof for `epoch` (of length `epochLength`
+     * checkpoints) on L1. Polls `rollup.getHasSubmittedProof` for each prover registered in
+     * {@link proverNodes}.
+     */
+    waitForAllProversToSubmit(epoch: EpochNumber, epochLength: number, opts?: {
+        timeout?: number;
+    }): Promise<void>;
+    /** Registers the SpamContract on the given wallet. */
+    registerSpamContract(wallet: Wallet, salt?: Fr): Promise<SpamContract>;
+    /** Registers the TestContract on the given wallet. */
+    registerTestContract(wallet: Wallet, salt?: Fr): Promise<TestContract>;
+    /** 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: BlockParameter, expectedSuccess: boolean): Promise<void>;
+    /**
+     * Verifies that at least one checkpoint has `targetBlockCount` blocks and that block numbering is
+     * contiguous within every checkpoint (MBPS validation).
+     *
+     * Two optional wait modes (both poll before reading checkpoints):
+     *  - `opts.wait`: waits until some checkpoint reaches `targetBlockCount` blocks (the proposed-tip
+     *    MBPS setup case), and
+     *  - `opts.targetBlock`: waits until the archiver's checkpointed tip reaches that block number
+     *    (the pipeline-prune recovery case).
+     *
+     * Reads from `opts.archiver` when given (e.g. a specific validator node's block source); otherwise
+     * from the initial node's archiver.
+     * @returns The number of the first checkpoint with at least `targetBlockCount` blocks.
+     */
+    assertMultipleBlocksPerSlot(targetBlockCount: number, opts?: {
+        wait?: boolean;
+        targetBlock?: BlockNumber;
+        archiver?: Archiver;
+        timeout?: number;
+    }): Promise<CheckpointNumber>;
+    /**
+     * Asserts pipelining by comparing the build slot (from block-proposed events) against the
+     * submission slot (from block headers). With pipelining, the block is built in slot N but its
+     * header carries submission slot N+1. Also checks each block's coinbase matches the expected
+     * proposer for its submission slot. Reads checkpoints from `archiver` (typically a validator
+     * node's block source).
+     */
+    assertProposerPipelining(archiver: Archiver, blockProposedEvents: BlockProposedEvent[], logger: Logger): Promise<void>;
+    watchSequencerEvents(sequencers: SequencerClient[], getMetadata?: (i: number) => Record<string, any>, additionalFailEventKeys?: (keyof SequencerEvents)[]): {
+        failEvents: TrackedSequencerEvent[];
+        stateChanges: TrackedSequencerEvent[];
+    };
+    /**
+     * Resolves with the event args the first time `sequencer` emits `event` with args matching
+     * `match`. Rejects after `opts.timeout` ms (default 60s). Wraps the
+     * `executeTimeout(signal => new Promise(...))` one-shot subscription boilerplate, cleaning up
+     * the listener on both the resolve and the abort paths.
+     */
+    waitForSequencerEvent<E extends keyof SequencerEvents>(sequencer: Sequencer, event: E, match?: (args: Parameters<SequencerEvents[E]>[0]) => boolean, opts?: {
+        timeout?: number;
+    }): Promise<Parameters<SequencerEvents[E]>[0]>;
+    /** Returns the {@link SequencerClient} of each given node, throwing if any node has no sequencer. */
+    getSequencers(nodes: AztecNodeService[]): SequencerClient[];
+    /** Starts the sequencer on each given node in parallel. */
+    startSequencers(nodes: AztecNodeService[]): Promise<void>;
+    /**
+     * Resolves once `sequencer` is in `state`, returning immediately if it is already there. Use to
+     * flush in-flight work (e.g. wait for `IDLE` so pending L1 publishes have been issued) before
+     * sampling chain state. Builds on {@link waitForSequencerEvent} for the not-yet-there path.
+     */
+    waitForSequencerState(sequencer: Sequencer, state: SequencerState, opts?: {
+        timeout?: number;
+    }): Promise<void>;
+    assertNoFailuresFromSequencers(failEvents: TrackedSequencerEvent[]): void;
+    /**
+     * Warps the L1 clock to `target` with every given node's sequencer paused, then resumes them
+     * (pass `restart: false` to leave them paused, e.g. until some clock-driven effect is confirmed).
+     *
+     * Warping the shared date provider under live sequencers interrupts whatever iteration is mid-build,
+     * producing spurious `block-build-failed` / `checkpoint-error` events and dropped checkpoints. The
+     * sequencers are therefore paused first: the poll loop halts and the in-flight iteration, its pending L1
+     * submission, and any pending fallback vote all finish untouched before the warp, so nothing fires with a
+     * stale slot afterwards. Pausing leaves the validator clients (and their slashing-protection stores) and
+     * publishers running, so a later {@link SequencerClient.start} cleanly resumes; archivers, provers, and
+     * the chain monitor keep running throughout, so clock-driven effects of the warp (e.g. an orphan-block
+     * prune) still fire.
+     *
+     * The warp is performed here (rather than via a caller-supplied callback) so it happens only after the
+     * pause has drained. Draining can take several slots, so a `target` computed before the pause may already
+     * lie in the past by the time the sequencers are down. The warp is therefore skipped when the L1 clock has
+     * already reached or passed `target` — `evm_setNextBlockTimestamp` rejects a non-advancing timestamp, so
+     * warping there would throw "timestamp in the past".
+     */
+    warpWithSequencersPaused(nodes: AztecNodeService[], cheatCodes: CheatCodes, target: bigint, opts?: {
+        restart?: boolean;
+    }): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"single_node_test_context.d.ts","sourceRoot":"","sources":["../../src/single-node/single_node_test_context.ts"],"names":[],"mappings":"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"}

package/dest/single-node/single_node_test_context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single_node_test_context.d.ts","sourceRoot":"","sources":["../../src/single-node/single_node_test_context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,KAAK,eAAe,EAAE,gBAAgB,EAA0B,MAAM,mBAAmB,CAAC;AAEnG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGhD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,OAAO,EAA8D,MAAM,6BAA6B,CAAC;AAClH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAOzG,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACrH,OAAO,EAAE,KAAK,cAAc,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,6BAA6B,CAAC;AAErC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAGnF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAQhC,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,YAAY,EAIlB,MAAM,sBAAsB,CAAC;AAG9B,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAChD,eAAO,MAAM,gCAAgC,KAAK,CAAC;AACnD,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG;IACvD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC7B,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,gHAAgH;IAChH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;KACjC,CAAC,IAAI,MAAM,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;QAChE,IAAI,EAAE,CAAC,CAAC;QACR,cAAc,EAAE,MAAM,CAAC;QACvB,SAAS,EAAE,UAAU,CAAC;KACvB;CACF,CAAC,MAAM,eAAe,CAAC,CAAC;AAEzB,uFAAuF;AACvF,MAAM,MAAM,kBAAkB,GAAG;IAAE,WAAW,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,UAAU,CAAA;CAAE,CAAC;AAEvG;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAC;AAEX;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;;;;CAIpB,CAAC;AAEX;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B;;;;;;CAI/B,CAAC;AAEX;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uCAAuC;;;;CAI1C,CAAC;AAEX;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;;;;;;;CAOnB,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IACzB,OAAO,EAAG,eAAe,CAAC;IAC1B,QAAQ,EAAG,wBAAwB,CAAC;IACpC,MAAM,EAAG,cAAc,CAAC;IACxB,SAAS,EAAG,iBAAiB,CAAC;IAC9B,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAG,YAAY,CAAC;IACvB,UAAU,EAAG,UAAU,CAAC;IACxB,aAAa,EAAG,OAAO,CAAC;IACxB,gBAAgB,EAAG,OAAO,CAAC;IAE3B,WAAW,EAAE,gBAAgB,EAAE,CAAM;IACrC,KAAK,EAAE,gBAAgB,EAAE,CAAM;IAE/B,aAAa,EAAG,MAAM,CAAC;IAEvB,kBAAkB,EAAG,MAAM,CAAC;IAC5B,qBAAqB,EAAG,MAAM,CAAC;IAEtC,OAAoB,KAAK,CAAC,CAAC,SAAS,qBAAqB,EAAE,IAAI,EAAE,UAAU,CAAC,EAAE,IAAI,GAAE,kBAAuB,cAI1G;IAED,OAAc,gBAAgB,CAAC,IAAI,GAAE,kBAAuB;;;;;MAc3D;IAEY,KAAK,CAAC,IAAI,GAAE,kBAAuB,iBAsD/C;IAED;;;;;;;;OAQG;IACH,UAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAyC1E;IAEY,QAAQ,kBAKpB;IAED;;;;;OAKG;IACH,OAAoB,uBAAuB,CAAC,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAK7F;IAED;;;OAGG;IACU,wBAAwB,CAAC,WAAW,EAAE,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC,CAU5F;IAEY,gBAAgB,CAC3B,IAAI,GAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,gBAAgB,CAAM,6BAwCzG;IAEM,sBAAsB,CAAC,IAAI,GAAE,OAAO,CAAC,eAAe,CAAM,6BAGhE;IAED,UAAgB,UAAU,CACxB,IAAI,GAAE,OAAO,CAAC,eAAe,CAAC,GAAG;QAC/B,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,oBAAoB,CAAC,EAAE,0BAA0B,CAAC;KAC9C,6BAsCP;IAED,SAAS,CAAC,iBAAiB,IAAI,GAAG,CAGjC;IAED,0FAA0F;IAC7E,oBAAoB,CAAC,KAAK,EAAE,MAAM,mBAe9C;IAED;;;;;;;;;;OAUG;IACU,wBAAwB,IAAI,OAAO,CAAC,WAAW,CAAC,CAY5D;IAED;;;;;;;;;OASG;IACU,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAU/F;IAED;;;;;;OAMG;IACU,2BAA2B,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBxG;IAED,wDAAwD;IAC3C,yBAAyB,CAAC,MAAM,EAAE,gBAAgB,EAAE,OAAO,SAAM,iBAS7E;IAED,mEAAmE;IACtD,+BAA+B,CAAC,MAAM,EAAE,gBAAgB,EAAE,OAAO,SAAM,6BAUnF;IAED,kFAAkF;IACrE,wCAAwC,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,iBAajF;IAED;;;;OAIG;IACI,2BAA2B,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,MAAM,CAGzF;IAED;;;;OAIG;IACU,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAK3E;IAED;;;;;OAKG;IACU,yBAAyB,CACpC,IAAI,EAAE,UAAU,EAChB,IAAI,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO,GAC7C,OAAO,CAAC,UAAU,CAAC,CAMrB;IAED,mEAAmE;IACtD,iBAAiB,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,GAAG,WAAW,GAAG,UAAU,iBAoBjG;IAED;;;;OAIG;IACU,yBAAyB,CACpC,KAAK,EAAE,WAAW,EAClB,WAAW,EAAE,MAAM,EACnB,IAAI,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO,GAC9B,OAAO,CAAC,IAAI,CAAC,CAef;IAED,sDAAsD;IACzC,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,KAAU,yBAU/D;IAED,sDAAsD;IACzC,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,KAAU,yBAU/D;IAED,0GAA0G;IAC7F,cAAc;;;OAU1B;IAED,0EAA0E;IAC7D,mBAAmB,CAAC,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,iBASrF;IAED;;;;;;;;;;;;;OAaG;IACU,2BAA2B,CACtC,gBAAgB,EAAE,MAAM,EACxB,IAAI,GAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,WAAW,CAAC;QAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO,GAC9F,OAAO,CAAC,gBAAgB,CAAC,CA2D3B;IAED;;;;;;OAMG;IACU,wBAAwB,CACnC,QAAQ,EAAE,QAAQ,EAClB,mBAAmB,EAAE,kBAAkB,EAAE,EACzC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CA2Cf;IAEM,oBAAoB,CACzB,UAAU,EAAE,eAAe,EAAE,EAC7B,WAAW,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAc,EAC5D,uBAAuB,GAAE,CAAC,MAAM,eAAe,CAAC,EAAO;;;MA4DxD;IAED;;;;;OAKG;IACI,qBAAqB,CAAC,CAAC,SAAS,MAAM,eAAe,EAC1D,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,CAAC,EACR,KAAK,GAAE,CAAC,IAAI,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,OAAoB,EACxE,IAAI,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO,GAC9B,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAqB5C;IAED,qGAAqG;IAC9F,aAAa,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,eAAe,EAAE,CAQjE;IAED,2DAA2D;IAC9C,eAAe,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAErE;IAED;;;;OAIG;IACU,qBAAqB,CAChC,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,cAAc,EACrB,IAAI,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO,GAC9B,OAAO,CAAC,IAAI,CAAC,CAKf;IAEM,8BAA8B,CAAC,UAAU,EAAE,qBAAqB,EAAE,QAKxE;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACU,wBAAwB,CACnC,KAAK,EAAE,gBAAgB,EAAE,EACzB,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,IAAI,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAC/B,OAAO,CAAC,IAAI,CAAC,CAoBf;CACF"}