@aztec/world-state 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/dest/synchronizer/server_world_state_synchronizer.d.ts

@@ -1,13 +1,14 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type Logger } from '@aztec/foundation/log';
 import type { L2BlockSource, L2BlockStream, L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider, L2Tips } from '@aztec/stdlib/block';
 import { type WorldStateSynchronizer, type WorldStateSynchronizerStatus } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { SnapshotDataKeys } from '@aztec/stdlib/snapshots';
 import { type MerkleTreeReadOperations, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
 import type { MerkleTreeAdminDatabase } from '../world-state-db/merkle_tree_db.js';
 import type { WorldStateConfig } from './config.js';
+export type { SnapshotDataKeys };
 /**
  * Synchronizes the world state with the L2 blocks from a L2BlockSource via a block stream.
  * The synchronizer will download the L2 blocks from the L2BlockSource and update the merkle trees.
@@ -26,39 +27,36 @@ export declare class ServerWorldStateSynchronizer implements WorldStateSynchroni
     private latestBlockHashQuery;
     private syncPromise;
     protected blockStream: L2BlockStream | undefined;
-    constructor(merkleTreeDb: MerkleTreeAdminDatabase, l2BlockSource: L2BlockSource & L1ToL2MessageSource, config: WorldStateConfig, instrumentation?: WorldStateInstrumentation, log?: import("@aztec/foundation/log").Logger);
+    private provenBlockNumber;
+    constructor(merkleTreeDb: MerkleTreeAdminDatabase, l2BlockSource: L2BlockSource & L1ToL2MessageSource, config: WorldStateConfig, instrumentation?: WorldStateInstrumentation, log?: Logger);
     getCommitted(): MerkleTreeReadOperations;
-    getSnapshot(blockNumber: number): MerkleTreeReadOperations;
-    fork(blockNumber?: number): Promise<MerkleTreeWriteOperations>;
+    getSnapshot(blockNumber: BlockNumber): MerkleTreeReadOperations;
+    fork(blockNumber?: BlockNumber, opts?: {
+        closeDelayMs?: number;
+    }): Promise<MerkleTreeWriteOperations>;
+    backupTo(dstPath: string, compact?: boolean): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>>;
+    clear(): Promise<void>;
     start(): Promise<void | import("@aztec/foundation/promise").PromiseWithResolvers<void>>;
     protected createBlockStream(): L2BlockStream;
     stop(): Promise<void>;
     status(): Promise<WorldStateSynchronizerStatus>;
-    getLatestBlockNumber(): Promise<number>;
+    getLatestBlockNumber(): Promise<BlockNumber>;
+    stopSync(): Promise<void>;
+    resumeSync(): void;
     /**
      * Forces an immediate sync.
-     * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it. Throws if cannot be reached.
+     * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
+     * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
      * @returns A promise that resolves with the block number the world state was synced to
      */
-    syncImmediate(targetBlockNumber?: number): Promise<number>;
+    syncImmediate(targetBlockNumber?: BlockNumber, skipThrowIfTargetNotReached?: boolean): Promise<BlockNumber>;
     /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */
-    getL2BlockHash(number: number): Promise<string | undefined>;
+    getL2BlockHash(number: BlockNumber): Promise<string | undefined>;
     /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */
     getL2Tips(): Promise<L2Tips>;
     /** Handles an event emitted by the block stream. */
     handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
-    /**
-     * Handles a list of L2 blocks (i.e. Inserts the new note hashes into the merkle tree).
-     * @param l2Blocks - The L2 blocks to handle.
-     * @returns Whether the block handled was produced by this same node.
-     */
     private handleL2Blocks;
-    /**
-     * Handles a single L2 block (i.e. Inserts the new note hashes into the merkle tree).
-     * @param l2Block - The L2 block to handle.
-     * @param l1ToL2Messages - The L1 to L2 messages for the block.
-     * @returns Whether the block handled was produced by this same node.
-     */
     private handleL2Block;
     private handleChainFinalized;
     private handleChainProven;
@@ -68,12 +66,5 @@ export declare class ServerWorldStateSynchronizer implements WorldStateSynchroni
      * @param newState - New state value.
      */
     private setCurrentState;
-    /**
-     * Verifies that the L1 to L2 messages hash to the block inHash.
-     * @param l1ToL2Messages - The L1 to L2 messages for the block.
-     * @param inHash - The inHash of the block.
-     * @throws If the L1 to L2 messages do not hash to the block inHash.
-     */
-    protected verifyMessagesHashToInHash(l1ToL2Messages: Fr[], inHash: Buffer): Promise<void>;
 }
-//# sourceMappingURL=server_world_state_synchronizer.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

package/dest/synchronizer/server_world_state_synchronizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server_world_state_synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/server_world_state_synchronizer.ts"],"names":[],"mappings":";;AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAMnD,OAAO,KAAK,EAGV,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,yBAAyB,EACzB,8BAA8B,EAC9B,MAAM,EACP,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EAClC,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAAgB,KAAK,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAGlH,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAElF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;GAIG;AACH,qBAAa,4BACX,YAAW,sBAAsB,EAAE,8BAA8B,EAAE,yBAAyB;IAa1F,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAftB,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA2B;IAE/D,OAAO,CAAC,wBAAwB,CAAK;IACrC,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,YAAY,CAAuD;IAC3E,OAAO,CAAC,oBAAoB,CAA4E;IAExG,OAAO,CAAC,WAAW,CAAgC;IACnD,SAAS,CAAC,WAAW,EAAE,aAAa,GAAG,SAAS,CAAC;gBAG9B,YAAY,EAAE,uBAAuB,EACrC,aAAa,EAAE,aAAa,GAAG,mBAAmB,EAClD,MAAM,EAAE,gBAAgB,EACjC,eAAe,4BAAsD,EAC5D,GAAG,yCAA8B;IAW7C,YAAY,IAAI,wBAAwB;IAIxC,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,wBAAwB;IAI1D,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAIxD,KAAK;IAgClB,SAAS,CAAC,iBAAiB,IAAI,aAAa;IAU/B,IAAI;IASJ,MAAM,IAAI,OAAO,CAAC,4BAA4B,CAAC;IAe/C,oBAAoB;IAIjC;;;;OAIG;IACU,aAAa,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAwBvE,oGAAoG;IACvF,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAexE,gGAAgG;IACnF,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAYzC,oDAAoD;IACvC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB7E;;;;OAIG;YACW,cAAc;IAyB5B;;;;;OAKG;YACW,aAAa;YAuBb,oBAAoB;IAelC,OAAO,CAAC,iBAAiB;YAKX,iBAAiB;IAO/B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAKvB;;;;;OAKG;cACa,0BAA0B,CAAC,cAAc,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM;CAahF"}
+{"version":3,"file":"server_world_state_synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/server_world_state_synchronizer.ts"],"names":[],"mappings":"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"}

package/dest/synchronizer/server_world_state_synchronizer.js

@@ -1,13 +1,12 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { elapsed } from '@aztec/foundation/timer';
-import { MerkleTreeCalculator } from '@aztec/foundation/trees';
-import { SHA256Trunc } from '@aztec/merkle-tree';
 import { WorldStateRunningState } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { TraceableL2BlockStream, getTelemetryClient } from '@aztec/telemetry-client';
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
+import { WorldStateSynchronizerError } from './errors.js';
 /**
  * Synchronizes the world state with the L2 blocks from a L2BlockSource via a block stream.
  * The synchronizer will download the L2 blocks from the L2BlockSource and update the merkle trees.
@@ -25,13 +24,16 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     latestBlockHashQuery;
     syncPromise;
     blockStream;
+    // WorldState doesn't track the proven block number, it only tracks the latest tips of the pending chain and the finalized chain
+    // store the proven block number here, in the synchronizer, so that we don't end up spamming the logs with 'chain-proved' events
+    provenBlockNumber;
     constructor(merkleTreeDb, l2BlockSource, config, instrumentation = new WorldStateInstrumentation(getTelemetryClient()), log = createLogger('world_state')){
         this.merkleTreeDb = merkleTreeDb;
         this.l2BlockSource = l2BlockSource;
         this.config = config;
         this.instrumentation = instrumentation;
         this.log = log;
-        this.latestBlockNumberAtStart = 0;
+        this.latestBlockNumberAtStart = BlockNumber.ZERO;
         this.currentState = WorldStateRunningState.IDLE;
         this.latestBlockHashQuery = undefined;
         this.syncPromise = promiseWithResolvers();
@@ -45,8 +47,14 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     getSnapshot(blockNumber) {
         return this.merkleTreeDb.getSnapshot(blockNumber);
     }
-    fork(blockNumber) {
-        return this.merkleTreeDb.fork(blockNumber);
+    fork(blockNumber, opts) {
+        return this.merkleTreeDb.fork(blockNumber, opts);
+    }
+    backupTo(dstPath, compact) {
+        return this.merkleTreeDb.backupTo(dstPath, compact);
+    }
+    clear() {
+        return this.merkleTreeDb.clear();
     }
     async start() {
         if (this.currentState === WorldStateRunningState.STOPPED) {
@@ -56,7 +64,7 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
             return this.syncPromise;
         }
         // Get the current latest block number
-        this.latestBlockNumberAtStart = await (this.config.worldStateProvenBlocksOnly ? this.l2BlockSource.getProvenBlockNumber() : this.l2BlockSource.getBlockNumber());
+        this.latestBlockNumberAtStart = BlockNumber(await (this.config.worldStateProvenBlocksOnly ? this.l2BlockSource.getProvenBlockNumber() : this.l2BlockSource.getBlockNumber()));
         const blockToDownloadFrom = await this.getLatestBlockNumber() + 1;
         if (blockToDownloadFrom <= this.latestBlockNumberAtStart) {
             // If there are blocks to be retrieved, go to a synching state
@@ -93,10 +101,10 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     async status() {
         const summary = await this.merkleTreeDb.getStatusSummary();
         const status = {
-            latestBlockNumber: Number(summary.unfinalisedBlockNumber),
-            latestBlockHash: await this.getL2BlockHash(Number(summary.unfinalisedBlockNumber)) ?? '',
-            finalisedBlockNumber: Number(summary.finalisedBlockNumber),
-            oldestHistoricBlockNumber: Number(summary.oldestHistoricalBlock),
+            latestBlockNumber: summary.unfinalizedBlockNumber,
+            latestBlockHash: await this.getL2BlockHash(summary.unfinalizedBlockNumber) ?? '',
+            finalizedBlockNumber: summary.finalizedBlockNumber,
+            oldestHistoricBlockNumber: summary.oldestHistoricalBlock,
             treesAreSynched: summary.treesAreSynched
         };
         return {
@@ -107,31 +115,63 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     async getLatestBlockNumber() {
         return (await this.getL2Tips()).latest.number;
     }
+    async stopSync() {
+        this.log.debug('Stopping sync...');
+        await this.blockStream?.stop();
+        this.log.info('Stopped sync');
+    }
+    resumeSync() {
+        if (!this.blockStream) {
+            throw new Error('Cannot resume sync as block stream is not initialized');
+        }
+        this.log.debug('Resuming sync...');
+        this.blockStream.start();
+        this.log.info('Resumed sync');
+    }
     /**
    * Forces an immediate sync.
-   * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it. Throws if cannot be reached.
+   * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
+   * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
    * @returns A promise that resolves with the block number the world state was synced to
-   */ async syncImmediate(targetBlockNumber) {
-        if (this.currentState !== WorldStateRunningState.RUNNING || this.blockStream === undefined) {
+   */ async syncImmediate(targetBlockNumber, skipThrowIfTargetNotReached) {
+        if (this.currentState !== WorldStateRunningState.RUNNING) {
             throw new Error(`World State is not running. Unable to perform sync.`);
         }
+        if (this.blockStream === undefined) {
+            throw new Error('Block stream is not initialized. Unable to perform sync.');
+        }
         // If we have been given a block number to sync to and we have reached that number then return
         const currentBlockNumber = await this.getLatestBlockNumber();
         if (targetBlockNumber !== undefined && targetBlockNumber <= currentBlockNumber) {
             return currentBlockNumber;
         }
         this.log.debug(`World State at ${currentBlockNumber} told to sync to ${targetBlockNumber ?? 'latest'}`);
+        // If the archiver is behind the target block, force an archiver sync
+        if (targetBlockNumber) {
+            const archiverLatestBlock = BlockNumber(await this.l2BlockSource.getBlockNumber());
+            if (archiverLatestBlock < targetBlockNumber) {
+                this.log.debug(`Archiver is at ${archiverLatestBlock} behind target block ${targetBlockNumber}.`);
+                await this.l2BlockSource.syncImmediate();
+            }
+        }
         // Force the block stream to sync against the archiver now
         await this.blockStream.sync();
         // If we have been given a block number to sync to and we have not reached that number then fail
         const updatedBlockNumber = await this.getLatestBlockNumber();
-        if (targetBlockNumber !== undefined && targetBlockNumber > updatedBlockNumber) {
-            throw new Error(`Unable to sync to block number ${targetBlockNumber} (last synced is ${updatedBlockNumber})`);
+        if (!skipThrowIfTargetNotReached && targetBlockNumber !== undefined && targetBlockNumber > updatedBlockNumber) {
+            throw new WorldStateSynchronizerError(`Unable to sync to block number ${targetBlockNumber} (last synced is ${updatedBlockNumber})`, {
+                cause: {
+                    reason: 'block_not_available',
+                    previousBlockNumber: currentBlockNumber,
+                    updatedBlockNumber,
+                    targetBlockNumber
+                }
+            });
         }
         return updatedBlockNumber;
     }
     /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */ async getL2BlockHash(number) {
-        if (number === 0) {
+        if (number === BlockNumber.ZERO) {
             return (await this.merkleTreeCommitted.getInitialHeader().hash()).toString();
         }
         if (this.latestBlockHashQuery?.hash === undefined || number !== this.latestBlockHashQuery.blockNumber) {
@@ -144,41 +184,37 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     }
     /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */ async getL2Tips() {
         const status = await this.merkleTreeDb.getStatusSummary();
-        const unfinalisedBlockHash = await this.getL2BlockHash(Number(status.unfinalisedBlockNumber));
+        const unfinalizedBlockHash = await this.getL2BlockHash(status.unfinalizedBlockNumber);
         const latestBlockId = {
-            number: Number(status.unfinalisedBlockNumber),
-            hash: unfinalisedBlockHash
+            number: status.unfinalizedBlockNumber,
+            hash: unfinalizedBlockHash
         };
         return {
             latest: latestBlockId,
             finalized: {
-                number: Number(status.finalisedBlockNumber),
+                number: status.finalizedBlockNumber,
                 hash: ''
             },
             proven: {
-                number: Number(status.finalisedBlockNumber),
+                number: this.provenBlockNumber ?? status.finalizedBlockNumber,
                 hash: ''
             }
         };
     }
     /** Handles an event emitted by the block stream. */ async handleBlockStreamEvent(event) {
-        try {
-            switch(event.type){
-                case 'blocks-added':
-                    await this.handleL2Blocks(event.blocks);
-                    break;
-                case 'chain-pruned':
-                    await this.handleChainPruned(event.blockNumber);
-                    break;
-                case 'chain-proven':
-                    await this.handleChainProven(event.blockNumber);
-                    break;
-                case 'chain-finalized':
-                    await this.handleChainFinalized(event.blockNumber);
-                    break;
-            }
-        } catch (err) {
-            this.log.error('Error processing block stream', err);
+        switch(event.type){
+            case 'blocks-added':
+                await this.handleL2Blocks(event.blocks.map((b)=>b.block.toL2Block()));
+                break;
+            case 'chain-pruned':
+                await this.handleChainPruned(event.block.number);
+                break;
+            case 'chain-proven':
+                await this.handleChainProven(event.block.number);
+                break;
+            case 'chain-finalized':
+                await this.handleChainFinalized(event.block.number);
+                break;
         }
     }
     /**
@@ -187,18 +223,22 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
    * @returns Whether the block handled was produced by this same node.
    */ async handleL2Blocks(l2Blocks) {
         this.log.trace(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1).number}`);
-        const messagePromises = l2Blocks.map((block)=>this.l2BlockSource.getL1ToL2Messages(BigInt(block.number)));
-        const l1ToL2Messages = await Promise.all(messagePromises);
+        // Fetch the L1->L2 messages for the first block in a checkpoint.
+        const messagesForBlocks = new Map();
+        await Promise.all(l2Blocks.filter((b)=>b.indexWithinCheckpoint === 0).map(async (block)=>{
+            const l1ToL2Messages = await this.l2BlockSource.getL1ToL2Messages(block.checkpointNumber);
+            messagesForBlocks.set(block.number, l1ToL2Messages);
+        }));
         let updateStatus = undefined;
-        for(let i = 0; i < l2Blocks.length; i++){
-            const [duration, result] = await elapsed(()=>this.handleL2Block(l2Blocks[i], l1ToL2Messages[i]));
-            this.log.verbose(`World state updated with L2 block ${l2Blocks[i].number}`, {
+        for (const block of l2Blocks){
+            const [duration, result] = await elapsed(()=>this.handleL2Block(block, messagesForBlocks.get(block.number) ?? []));
+            this.log.info(`World state updated with L2 block ${block.number}`, {
                 eventName: 'l2-block-handled',
                 duration,
-                unfinalisedBlockNumber: result.summary.unfinalisedBlockNumber,
-                finalisedBlockNumber: result.summary.finalisedBlockNumber,
-                oldestHistoricBlock: result.summary.oldestHistoricalBlock,
-                ...l2Blocks[i].getStats()
+                unfinalizedBlockNumber: BigInt(result.summary.unfinalizedBlockNumber),
+                finalizedBlockNumber: BigInt(result.summary.finalizedBlockNumber),
+                oldestHistoricBlock: BigInt(result.summary.oldestHistoricalBlock),
+                ...block.getStats()
             });
             updateStatus = result;
         }
@@ -213,12 +253,6 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
    * @param l1ToL2Messages - The L1 to L2 messages for the block.
    * @returns Whether the block handled was produced by this same node.
    */ async handleL2Block(l2Block, l1ToL2Messages) {
-        // First we check that the L1 to L2 messages hash to the block inHash.
-        // Note that we cannot optimize this check by checking the root of the subtree after inserting the messages
-        // to the real L1_TO_L2_MESSAGE_TREE (like we do in merkleTreeDb.handleL2BlockAndMessages(...)) because that
-        // tree uses pedersen and we don't have access to the converted root.
-        await this.verifyMessagesHashToInHash(l1ToL2Messages, l2Block.header.contentCommitment.inHash);
-        // If the above check succeeds, we can proceed to handle the block.
         this.log.trace(`Pushing L2 block ${l2Block.number} to merkle tree db `, {
             blockNumber: l2Block.number,
             blockHash: await l2Block.hash().then((h)=>h.toString()),
@@ -233,26 +267,28 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     }
     async handleChainFinalized(blockNumber) {
         this.log.verbose(`Finalized chain is now at block ${blockNumber}`);
-        const summary = await this.merkleTreeDb.setFinalised(BigInt(blockNumber));
+        const summary = await this.merkleTreeDb.setFinalized(blockNumber);
         if (this.historyToKeep === undefined) {
             return;
         }
-        const newHistoricBlock = summary.finalisedBlockNumber - BigInt(this.historyToKeep) + 1n;
+        const newHistoricBlock = summary.finalizedBlockNumber - this.historyToKeep + 1;
         if (newHistoricBlock <= 1) {
             return;
         }
         this.log.verbose(`Pruning historic blocks to ${newHistoricBlock}`);
-        const status = await this.merkleTreeDb.removeHistoricalBlocks(newHistoricBlock);
+        const status = await this.merkleTreeDb.removeHistoricalBlocks(BlockNumber(newHistoricBlock));
         this.log.debug(`World state summary `, status.summary);
     }
     handleChainProven(blockNumber) {
+        this.provenBlockNumber = blockNumber;
         this.log.debug(`Proven chain is now at block ${blockNumber}`);
         return Promise.resolve();
     }
     async handleChainPruned(blockNumber) {
         this.log.warn(`Chain pruned to block ${blockNumber}`);
-        const status = await this.merkleTreeDb.unwindBlocks(BigInt(blockNumber));
+        const status = await this.merkleTreeDb.unwindBlocks(blockNumber);
         this.latestBlockHashQuery = undefined;
+        this.provenBlockNumber = undefined;
         this.instrumentation.updateWorldStateMetrics(status);
     }
     /**
@@ -262,16 +298,4 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
         this.currentState = newState;
         this.log.debug(`Moved to state ${WorldStateRunningState[this.currentState]}`);
     }
-    /**
-   * Verifies that the L1 to L2 messages hash to the block inHash.
-   * @param l1ToL2Messages - The L1 to L2 messages for the block.
-   * @param inHash - The inHash of the block.
-   * @throws If the L1 to L2 messages do not hash to the block inHash.
-   */ async verifyMessagesHashToInHash(l1ToL2Messages, inHash) {
-        const treeCalculator = await MerkleTreeCalculator.create(L1_TO_L2_MSG_SUBTREE_HEIGHT, Buffer.alloc(32), (lhs, rhs)=>Promise.resolve(new SHA256Trunc().hash(lhs, rhs)));
-        const root = await treeCalculator.computeTreeRoot(l1ToL2Messages.map((msg)=>msg.toBuffer()));
-        if (!root.equals(inHash)) {
-            throw new Error('Obtained L1 to L2 messages failed to be hashed to the block inHash');
-        }
-    }
 }

package/dest/test/index.d.ts

@@ -1,2 +1,2 @@
 export * from './utils.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsWUFBWSxDQUFDIn0=

package/dest/test/utils.d.ts

@@ -1,19 +1,26 @@
-import { Fr } from '@aztec/foundation/fields';
-import { L2Block } from '@aztec/stdlib/block';
+import { BlockNumber, type CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { L2BlockNew } from '@aztec/stdlib/block';
 import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { mockCheckpointAndMessages } from '@aztec/stdlib/testing';
 import type { NativeWorldStateService } from '../native/native_world_state.js';
-export declare function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations): Promise<{
-    block: L2Block;
+export declare function updateBlockState(block: L2BlockNew, l1ToL2Messages: Fr[], fork: MerkleTreeWriteOperations): Promise<void>;
+export declare function mockBlock(blockNum: BlockNumber, size: number, fork: MerkleTreeWriteOperations, maxEffects?: number | undefined, numL1ToL2Messages?: number, isFirstBlockInCheckpoint?: boolean): Promise<{
+    block: L2BlockNew;
     messages: Fr[];
 }>;
-export declare function mockEmptyBlock(blockNum: number, fork: MerkleTreeWriteOperations): Promise<{
-    block: L2Block;
+export declare function mockEmptyBlock(blockNum: BlockNumber, fork: MerkleTreeWriteOperations): Promise<{
+    block: L2BlockNew;
     messages: Fr[];
 }>;
-export declare function mockBlocks(from: number, count: number, numTxs: number, worldState: NativeWorldStateService): Promise<{
-    blocks: L2Block[];
+export declare function mockBlocks(from: BlockNumber, count: number, numTxs: number, worldState: NativeWorldStateService): Promise<{
+    blocks: L2BlockNew[];
     messages: Fr[][];
 }>;
+export declare function mockCheckpoint(checkpointNumber: CheckpointNumber, fork: MerkleTreeWriteOperations, options?: Partial<Parameters<typeof mockCheckpointAndMessages>[1]>): Promise<{
+    checkpoint: import("../../../stdlib/dest/checkpoint/checkpoint.js").Checkpoint;
+    messages: Fr[];
+}>;
 export declare function assertSameState(forkA: MerkleTreeReadOperations, forkB: MerkleTreeReadOperations): Promise<void>;
 export declare function compareChains(left: MerkleTreeReadOperations, right: MerkleTreeReadOperations): Promise<void>;
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLE9BQU8sRUFBRSxXQUFXLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRXJGLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDakQsT0FBTyxLQUFLLEVBRVYsd0JBQXdCLEVBQ3hCLHlCQUF5QixFQUMxQixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLE9BQU8sRUFBRSx5QkFBeUIsRUFBc0IsTUFBTSx1QkFBdUIsQ0FBQztBQUl0RixPQUFPLEtBQUssRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRS9FLHdCQUFzQixnQkFBZ0IsQ0FBQyxLQUFLLEVBQUUsVUFBVSxFQUFFLGNBQWMsRUFBRSxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUseUJBQXlCLGlCQThDOUc7QUFFRCx3QkFBc0IsU0FBUyxDQUM3QixRQUFRLEVBQUUsV0FBVyxFQUNyQixJQUFJLEVBQUUsTUFBTSxFQUNaLElBQUksRUFBRSx5QkFBeUIsRUFDL0IsVUFBVSxHQUFFLE1BQU0sR0FBRyxTQUFnQixFQUNyQyxpQkFBaUIsR0FBRSxNQUE0QyxFQUMvRCx3QkFBd0IsR0FBRSxPQUFjOzs7R0FlekM7QUFFRCx3QkFBc0IsY0FBYyxDQUFDLFFBQVEsRUFBRSxXQUFXLEVBQUUsSUFBSSxFQUFFLHlCQUF5Qjs7O0dBWTFGO0FBRUQsd0JBQXNCLFVBQVUsQ0FDOUIsSUFBSSxFQUFFLFdBQVcsRUFDakIsS0FBSyxFQUFFLE1BQU0sRUFDYixNQUFNLEVBQUUsTUFBTSxFQUNkLFVBQVUsRUFBRSx1QkFBdUI7OztHQWVwQztBQUVELHdCQUFzQixjQUFjLENBQ2xDLGdCQUFnQixFQUFFLGdCQUFnQixFQUNsQyxJQUFJLEVBQUUseUJBQXlCLEVBQy9CLE9BQU8sR0FBRSxPQUFPLENBQUMsVUFBVSxDQUFDLE9BQU8seUJBQXlCLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBTTs7O0dBT3ZFO0FBRUQsd0JBQXNCLGVBQWUsQ0FBQyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsS0FBSyxFQUFFLHdCQUF3QixpQkFRckc7QUFFRCx3QkFBc0IsYUFBYSxDQUFDLElBQUksRUFBRSx3QkFBd0IsRUFBRSxLQUFLLEVBQUUsd0JBQXdCLGlCQVlsRyJ9

package/dest/test/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAG3G,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB;;;GA+C9F;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB;;;GAiDrF;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,uBAAuB;;;GAchH;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAQrG;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAYlG"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAErF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAEV,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,yBAAyB,EAAsB,MAAM,uBAAuB,CAAC;AAItF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,yBAAyB,iBA8C9G;AAED,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,WAAW,EACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,yBAAyB,EAC/B,UAAU,GAAE,MAAM,GAAG,SAAgB,EACrC,iBAAiB,GAAE,MAA4C,EAC/D,wBAAwB,GAAE,OAAc;;;GAezC;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,yBAAyB;;;GAY1F;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,uBAAuB;;;GAepC;AAED,wBAAsB,cAAc,CAClC,gBAAgB,EAAE,gBAAgB,EAClC,IAAI,EAAE,yBAAyB,EAC/B,OAAO,GAAE,OAAO,CAAC,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAM;;;GAOvE;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAQrG;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAYlG"}

package/dest/test/utils.js

@@ -1,73 +1,70 @@
 import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { asyncMap } from '@aztec/foundation/async-map';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { L2Block } from '@aztec/stdlib/block';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { L2BlockNew } from '@aztec/stdlib/block';
+import { mockCheckpointAndMessages, mockL1ToL2Messages } from '@aztec/stdlib/testing';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-export async function mockBlock(blockNum, size, fork) {
-    const l2Block = await L2Block.random(blockNum, size);
-    const l1ToL2Messages = Array(16).fill(0).map(Fr.random);
-    // Sync the append only trees
-    {
-        const noteHashesPadded = l2Block.body.txEffects.flatMap((txEffect)=>padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
-        await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
-        const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-        await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-    }
-    // Sync the indexed trees
-    {
-        // We insert the public data tree leaves with one batch per tx to avoid updating the same key twice
-        for (const txEffect of l2Block.body.txEffects){
-            await fork.batchInsert(MerkleTreeId.PUBLIC_DATA_TREE, txEffect.publicDataWrites.map((write)=>write.toBuffer()), 0);
-            const nullifiersPadded = padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX);
-            await fork.batchInsert(MerkleTreeId.NULLIFIER_TREE, nullifiersPadded.map((nullifier)=>nullifier.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
+import { BlockHeader } from '@aztec/stdlib/tx';
+export async function updateBlockState(block, l1ToL2Messages, fork) {
+    const insertData = async (treeId, data, subTreeHeight, fork)=>{
+        for (const dataBatch of data){
+            await fork.batchInsert(treeId, dataBatch, subTreeHeight);
         }
-    }
+    };
+    const publicDataInsert = insertData(MerkleTreeId.PUBLIC_DATA_TREE, block.body.txEffects.map((txEffect)=>txEffect.publicDataWrites.map((write)=>write.toBuffer())), 0, fork);
+    const nullifierInsert = insertData(MerkleTreeId.NULLIFIER_TREE, block.body.txEffects.map((txEffect)=>padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((nullifier)=>nullifier.toBuffer())), NULLIFIER_SUBTREE_HEIGHT, fork);
+    const noteHashesPadded = block.body.txEffects.flatMap((txEffect)=>padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
+    const l1ToL2MessagesPadded = block.indexWithinCheckpoint === 0 ? padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP) : l1ToL2Messages;
+    const noteHashInsert = fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
+    const messageInsert = fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+    await Promise.all([
+        publicDataInsert,
+        nullifierInsert,
+        noteHashInsert,
+        messageInsert
+    ]);
     const state = await fork.getStateReference();
-    l2Block.header.state = state;
-    await fork.updateArchive(l2Block.header);
+    block.header = BlockHeader.from({
+        ...block.header,
+        state
+    });
+    await fork.updateArchive(block.header);
     const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
-    l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
+    block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
+}
+export async function mockBlock(blockNum, size, fork, maxEffects = 1000, numL1ToL2Messages = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, isFirstBlockInCheckpoint = true) {
+    const block = await L2BlockNew.random(blockNum, {
+        indexWithinCheckpoint: isFirstBlockInCheckpoint ? 0 : 1,
+        txsPerBlock: size,
+        txOptions: {
+            maxEffects
+        }
+    });
+    const l1ToL2Messages = mockL1ToL2Messages(numL1ToL2Messages);
+    await updateBlockState(block, l1ToL2Messages, fork);
     return {
-        block: l2Block,
+        block,
         messages: l1ToL2Messages
     };
 }
 export async function mockEmptyBlock(blockNum, fork) {
-    const l2Block = L2Block.empty();
+    const l2Block = L2BlockNew.empty();
     const l1ToL2Messages = Array(16).fill(0).map(Fr.zero);
-    l2Block.header.globalVariables.blockNumber = new Fr(blockNum);
-    // Sync the append only trees
-    {
-        const noteHashesPadded = l2Block.body.txEffects.flatMap((txEffect)=>padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
-        await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
-        const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-        await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-    }
-    // Sync the indexed trees
-    {
-        // We insert the public data tree leaves with one batch per tx to avoid updating the same key twice
-        for (const txEffect of l2Block.body.txEffects){
-            await fork.batchInsert(MerkleTreeId.PUBLIC_DATA_TREE, txEffect.publicDataWrites.map((write)=>write.toBuffer()), 0);
-            const nullifiersPadded = padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX);
-            await fork.batchInsert(MerkleTreeId.NULLIFIER_TREE, nullifiersPadded.map((nullifier)=>nullifier.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
-        }
-    }
-    const state = await fork.getStateReference();
-    l2Block.header.state = state;
-    await fork.updateArchive(l2Block.header);
-    const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
-    l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
+    l2Block.header.globalVariables.blockNumber = blockNum;
+    await updateBlockState(l2Block, l1ToL2Messages, fork);
     return {
         block: l2Block,
         messages: l1ToL2Messages
     };
 }
 export async function mockBlocks(from, count, numTxs, worldState) {
-    const tempFork = await worldState.fork(from - 1);
+    const tempFork = await worldState.fork(BlockNumber(from - 1));
     const blocks = [];
     const messagesArray = [];
     for(let blockNumber = from; blockNumber < from + count; blockNumber++){
-        const { block, messages } = await mockBlock(blockNumber, numTxs, tempFork);
+        const { block, messages } = await mockBlock(BlockNumber(blockNumber), numTxs, tempFork);
         blocks.push(block);
         messagesArray.push(messages);
     }
@@ -77,6 +74,16 @@ export async function mockBlocks(from, count, numTxs, worldState) {
         messages: messagesArray
     };
 }
+export async function mockCheckpoint(checkpointNumber, fork, options = {}) {
+    const { checkpoint, messages } = await mockCheckpointAndMessages(checkpointNumber, options);
+    await asyncMap(checkpoint.blocks, async (block, i)=>{
+        await updateBlockState(block, i === 0 ? messages : [], fork);
+    });
+    return {
+        checkpoint,
+        messages
+    };
+}
 export async function assertSameState(forkA, forkB) {
     const nativeStateRef = await forkA.getStateReference();
     const nativeArchive = await forkA.getTreeInfo(MerkleTreeId.ARCHIVE);

package/dest/testing.d.ts

@@ -1,10 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 export declare const defaultInitialAccountFeeJuice: Fr;
 export declare function getGenesisValues(initialAccounts: AztecAddress[], initialAccountFeeJuice?: Fr, genesisPublicData?: PublicDataTreeLeaf[]): Promise<{
     genesisArchiveRoot: Fr;
-    genesisBlockHash: Fr;
     prefilledPublicData: PublicDataTreeLeaf[];
+    fundingNeeded: bigint;
 }>;
-//# sourceMappingURL=testing.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3Rlc3RpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sRUFBZ0Isa0JBQWtCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQXlCdkUsZUFBTyxNQUFNLDZCQUE2QixJQUFxQixDQUFDO0FBRWhFLHdCQUFzQixnQkFBZ0IsQ0FDcEMsZUFBZSxFQUFFLFlBQVksRUFBRSxFQUMvQixzQkFBc0IsS0FBZ0MsRUFDdEQsaUJBQWlCLEdBQUUsa0JBQWtCLEVBQU87Ozs7R0FxQjdDIn0=

package/dest/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAgB,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AA6BvE,eAAO,MAAM,6BAA6B,IAAqB,CAAC;AAEhE,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,YAAY,EAAE,EAC/B,sBAAsB,KAAgC,EACtD,iBAAiB,GAAE,kBAAkB,EAAO;;;;GAqB7C"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAgB,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAyBvE,eAAO,MAAM,6BAA6B,IAAqB,CAAC;AAEhE,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,YAAY,EAAE,EAC/B,sBAAsB,KAAgC,EACtD,iBAAiB,GAAE,kBAAkB,EAAO;;;;GAqB7C"}