@aztec/world-state 0.0.1-commit.9b94fc1 → 0.0.1-commit.d3ec352c

package/dest/synchronizer/server_world_state_synchronizer.js

@@ -1,14 +1,13 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
-import { SHA256Trunc } from '@aztec/foundation/crypto';
+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 { 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';
+import { findFirstBlocksInCheckpoints } from './utils.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.
@@ -35,7 +34,7 @@ import { WorldStateSynchronizerError } from './errors.js';
         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();
@@ -66,7 +65,7 @@ import { WorldStateSynchronizerError } from './errors.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
@@ -103,10 +102,10 @@ import { WorldStateSynchronizerError } from './errors.js';
     async status() {
         const summary = await this.merkleTreeDb.getStatusSummary();
         const status = {
-            latestBlockNumber: Number(summary.unfinalizedBlockNumber),
-            latestBlockHash: await this.getL2BlockHash(Number(summary.unfinalizedBlockNumber)) ?? '',
-            finalizedBlockNumber: Number(summary.finalizedBlockNumber),
-            oldestHistoricBlockNumber: Number(summary.oldestHistoricalBlock),
+            latestBlockNumber: summary.unfinalizedBlockNumber,
+            latestBlockHash: await this.getL2BlockHash(summary.unfinalizedBlockNumber) ?? '',
+            finalizedBlockNumber: summary.finalizedBlockNumber,
+            oldestHistoricBlockNumber: summary.oldestHistoricalBlock,
             treesAreSynched: summary.treesAreSynched
         };
         return {
@@ -150,7 +149,7 @@ import { WorldStateSynchronizerError } from './errors.js';
         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 = await this.l2BlockSource.getBlockNumber();
+            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();
@@ -173,7 +172,7 @@ import { WorldStateSynchronizerError } from './errors.js';
         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) {
@@ -186,19 +185,19 @@ import { WorldStateSynchronizerError } from './errors.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 unfinalizedBlockHash = await this.getL2BlockHash(Number(status.unfinalizedBlockNumber));
+        const unfinalizedBlockHash = await this.getL2BlockHash(status.unfinalizedBlockNumber);
         const latestBlockId = {
-            number: Number(status.unfinalizedBlockNumber),
+            number: status.unfinalizedBlockNumber,
             hash: unfinalizedBlockHash
         };
         return {
             latest: latestBlockId,
             finalized: {
-                number: Number(status.finalizedBlockNumber),
+                number: status.finalizedBlockNumber,
                 hash: ''
             },
             proven: {
-                number: Number(this.provenBlockNumber ?? status.finalizedBlockNumber),
+                number: this.provenBlockNumber ?? status.finalizedBlockNumber,
                 hash: ''
             }
         };
@@ -206,16 +205,16 @@ import { WorldStateSynchronizerError } from './errors.js';
     /** Handles an event emitted by the block stream. */ async handleBlockStreamEvent(event) {
         switch(event.type){
             case 'blocks-added':
-                await this.handleL2Blocks(event.blocks.map((b)=>b.block));
+                await this.handleL2Blocks(event.blocks.map((b)=>b.block.toL2Block()));
                 break;
             case 'chain-pruned':
-                await this.handleChainPruned(event.block.number);
+                await this.handleChainPruned(BlockNumber(event.block.number));
                 break;
             case 'chain-proven':
-                await this.handleChainProven(event.block.number);
+                await this.handleChainProven(BlockNumber(event.block.number));
                 break;
             case 'chain-finalized':
-                await this.handleChainFinalized(event.block.number);
+                await this.handleChainFinalized(BlockNumber(event.block.number));
                 break;
         }
     }
@@ -225,18 +224,19 @@ import { WorldStateSynchronizerError } from './errors.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(block.number));
-        const l1ToL2Messages = await Promise.all(messagePromises);
+        const firstBlocksInCheckpoints = await findFirstBlocksInCheckpoints(l2Blocks, this.l2BlockSource);
         let updateStatus = undefined;
-        for(let i = 0; i < l2Blocks.length; i++){
-            const [duration, result] = await elapsed(()=>this.handleL2Block(l2Blocks[i], l1ToL2Messages[i]));
-            this.log.info(`World state updated with L2 block ${l2Blocks[i].number}`, {
+        for (const block of l2Blocks){
+            const l1ToL2Messages = firstBlocksInCheckpoints.get(block.number) ?? [];
+            const isFirstBlock = firstBlocksInCheckpoints.has(block.number);
+            const [duration, result] = await elapsed(()=>this.handleL2Block(block, l1ToL2Messages, isFirstBlock));
+            this.log.info(`World state updated with L2 block ${block.number}`, {
                 eventName: 'l2-block-handled',
                 duration,
-                unfinalizedBlockNumber: result.summary.unfinalizedBlockNumber,
-                finalizedBlockNumber: result.summary.finalizedBlockNumber,
-                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;
         }
@@ -250,19 +250,14 @@ import { WorldStateSynchronizerError } from './errors.js';
    * @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.
-   */ 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);
+   */ async handleL2Block(l2Block, l1ToL2Messages, isFirstBlock) {
         // 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()),
             l1ToL2Messages: l1ToL2Messages.map((msg)=>msg.toString())
         });
-        const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
+        const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages, isFirstBlock);
         if (this.currentState === WorldStateRunningState.SYNCHING && l2Block.number >= this.latestBlockNumberAtStart) {
             this.setCurrentState(WorldStateRunningState.RUNNING);
             this.syncPromise.resolve();
@@ -271,12 +266,12 @@ import { WorldStateSynchronizerError } from './errors.js';
     }
     async handleChainFinalized(blockNumber) {
         this.log.verbose(`Finalized chain is now at block ${blockNumber}`);
-        const summary = await this.merkleTreeDb.setFinalized(BigInt(blockNumber));
+        const summary = await this.merkleTreeDb.setFinalized(blockNumber);
         if (this.historyToKeep === undefined) {
             return;
         }
-        const newHistoricBlock = summary.finalizedBlockNumber - BigInt(this.historyToKeep) + 1n;
-        if (newHistoricBlock <= 1) {
+        const newHistoricBlock = BlockNumber(summary.finalizedBlockNumber - this.historyToKeep + 1);
+        if (newHistoricBlock <= BlockNumber(1)) {
             return;
         }
         this.log.verbose(`Pruning historic blocks to ${newHistoricBlock}`);
@@ -284,13 +279,13 @@ import { WorldStateSynchronizerError } from './errors.js';
         this.log.debug(`World state summary `, status.summary);
     }
     handleChainProven(blockNumber) {
-        this.provenBlockNumber = BigInt(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);
@@ -302,16 +297,4 @@ import { WorldStateSynchronizerError } from './errors.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.toBuffer())) {
-            throw new Error('Obtained L1 to L2 messages failed to be hashed to the block inHash');
-        }
-    }
 }

package/dest/synchronizer/utils.d.ts

@@ -0,0 +1,11 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { L2BlockNew, L2BlockSource } from '@aztec/stdlib/block';
+import { type L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+/**
+ * Determine which blocks in the given array are the first block in a checkpoint.
+ * @param blocks - The candidate blocks, sorted by block number in ascending order.
+ * @param l2BlockSource - The L2 block source to use to fetch the checkpoints, block headers and L1->L2 messages.
+ * @returns A map of block numbers that begin a checkpoint to the L1->L2 messages for that checkpoint.
+ */
+export declare function findFirstBlocksInCheckpoints(blocks: L2BlockNew[], l2BlockSource: L2BlockSource & L1ToL2MessageSource): Promise<Map<number, Fr[]>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zeW5jaHJvbml6ZXIvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRXJFLE9BQU8sRUFBRSxLQUFLLG1CQUFtQixFQUFtQyxNQUFNLHlCQUF5QixDQUFDO0FBRXBHOzs7OztHQUtHO0FBQ0gsd0JBQXNCLDRCQUE0QixDQUNoRCxNQUFNLEVBQUUsVUFBVSxFQUFFLEVBQ3BCLGFBQWEsRUFBRSxhQUFhLEdBQUcsbUJBQW1CLEdBQ2pELE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FtRTVCIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/synchronizer/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAAE,KAAK,mBAAmB,EAAmC,MAAM,yBAAyB,CAAC;AAEpG;;;;;GAKG;AACH,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,UAAU,EAAE,EACpB,aAAa,EAAE,aAAa,GAAG,mBAAmB,GACjD,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,CAmE5B"}

package/dest/synchronizer/utils.js

@@ -0,0 +1,59 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+/**
+ * Determine which blocks in the given array are the first block in a checkpoint.
+ * @param blocks - The candidate blocks, sorted by block number in ascending order.
+ * @param l2BlockSource - The L2 block source to use to fetch the checkpoints, block headers and L1->L2 messages.
+ * @returns A map of block numbers that begin a checkpoint to the L1->L2 messages for that checkpoint.
+ */ export async function findFirstBlocksInCheckpoints(blocks, l2BlockSource) {
+    // Select the blocks that are the final block within each group of identical slot numbers.
+    let seenSlot;
+    const maybeLastBlocks = [
+        ...blocks
+    ].reverse().filter((b)=>{
+        if (b.header.globalVariables.slotNumber !== seenSlot) {
+            seenSlot = b.header.globalVariables.slotNumber;
+            return true;
+        }
+        return false;
+    }).reverse();
+    // Try to fetch the checkpoints for those blocks. If undefined (which should only occur for blocks.at(-1)),
+    // then the block is not the last one in a checkpoint.
+    // If we are not checking the inHashes below, only blocks.at(-1) would need its checkpoint header fetched.
+    const checkpointedBlocks = (await Promise.all(maybeLastBlocks.map(async (b)=>({
+            blockNumber: b.number,
+            // A checkpoint's archive root is the archive root of its last block.
+            checkpoint: await l2BlockSource.getCheckpointByArchive(b.archive.root)
+        })))).filter((b)=>b.checkpoint !== undefined);
+    // Verify that the L1->L2 messages hash to the checkpoint's inHash.
+    const checkpointedL1ToL2Messages = await Promise.all(checkpointedBlocks.map((b)=>l2BlockSource.getL1ToL2MessagesForCheckpoint(b.checkpoint.number)));
+    checkpointedBlocks.forEach((b, i)=>{
+        const computedInHash = computeInHashFromL1ToL2Messages(checkpointedL1ToL2Messages[i]);
+        const inHash = b.checkpoint.header.contentCommitment.inHash;
+        if (!computedInHash.equals(inHash)) {
+            throw new Error('Obtained L1 to L2 messages failed to be hashed to the checkpoint inHash');
+        }
+    });
+    // Compute the first block numbers, which should be right after each checkpointed block. Exclude blocks that haven't
+    // been added yet.
+    const firstBlockNumbers = checkpointedBlocks.map((b)=>BlockNumber(b.blockNumber + 1)).filter((n)=>n <= blocks.at(-1).number);
+    // Check if blocks[0] is the first block in a checkpoint.
+    if (blocks[0].number === 1) {
+        firstBlockNumbers.push(blocks[0].number);
+    } else {
+        const lastBlockHeader = await l2BlockSource.getBlockHeader(BlockNumber(blocks[0].number - 1));
+        if (!lastBlockHeader) {
+            throw new Error(`Failed to get block ${blocks[0].number - 1}`);
+        }
+        if (lastBlockHeader.globalVariables.slotNumber !== blocks[0].header.globalVariables.slotNumber) {
+            firstBlockNumbers.push(blocks[0].number);
+        }
+    }
+    // Fetch the L1->L2 messages for the first blocks and assign them to the map.
+    const messagesByBlockNumber = new Map();
+    await Promise.all(firstBlockNumbers.map(async (blockNumber)=>{
+        const l1ToL2Messages = await l2BlockSource.getL1ToL2Messages(blockNumber);
+        messagesByBlockNumber.set(blockNumber, l1ToL2Messages);
+    }));
+    return messagesByBlockNumber;
+}

package/dest/test/utils.d.ts

@@ -1,19 +1,32 @@
+import { BlockNumber, type CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
-import { L2Block } from '@aztec/stdlib/block';
+import { L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import type { NativeWorldStateService } from '../native/native_world_state.js';
-export declare function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations, maxEffects?: number | undefined): Promise<{
-    block: L2Block;
+export declare function mockBlock(blockNum: BlockNumber, size: number, fork: MerkleTreeWriteOperations, maxEffects?: number | undefined, numL1ToL2Messages?: number, isFirstBlock?: 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 mockL1ToL2Messages(numL1ToL2Messages: number): Fr[];
+export declare function mockCheckpoint(checkpointNumber: CheckpointNumber, { startBlockNumber, numBlocks, numTxsPerBlock, numL1ToL2Messages, fork }?: {
+    startBlockNumber?: BlockNumber;
+    numBlocks?: number;
+    numTxsPerBlock?: number;
+    numL1ToL2Messages?: number;
+    fork?: MerkleTreeWriteOperations;
+}): Promise<{
+    checkpoint: Checkpoint;
+    messages: Fr[];
+}>;
 export declare function assertSameState(forkA: MerkleTreeReadOperations, forkB: MerkleTreeReadOperations): Promise<void>;
 export declare function compareChains(left: MerkleTreeReadOperations, right: MerkleTreeReadOperations): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUM5QyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDOUMsT0FBTyxLQUFLLEVBRVYsd0JBQXdCLEVBQ3hCLHlCQUF5QixFQUMxQixNQUFNLGlDQUFpQyxDQUFDO0FBR3pDLE9BQU8sS0FBSyxFQUFFLHVCQUF1QixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFL0Usd0JBQXNCLFNBQVMsQ0FDN0IsUUFBUSxFQUFFLE1BQU0sRUFDaEIsSUFBSSxFQUFFLE1BQU0sRUFDWixJQUFJLEVBQUUseUJBQXlCLEVBQy9CLFVBQVUsR0FBRSxNQUFNLEdBQUcsU0FBZ0I7OztHQXNEdEM7QUFFRCx3QkFBc0IsY0FBYyxDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLHlCQUF5Qjs7O0dBaURyRjtBQUVELHdCQUFzQixVQUFVLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLHVCQUF1Qjs7O0dBY2hIO0FBRUQsd0JBQXNCLGVBQWUsQ0FBQyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsS0FBSyxFQUFFLHdCQUF3QixpQkFRckc7QUFFRCx3QkFBc0IsYUFBYSxDQUFDLElBQUksRUFBRSx3QkFBd0IsRUFBRSxLQUFLLEVBQUUsd0JBQXdCLGlCQVlsRyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sRUFBRSxXQUFXLEVBQUUsS0FBSyxnQkFBZ0IsRUFBYyxNQUFNLGlDQUFpQyxDQUFDO0FBRWpHLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUM5QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDakQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3RELE9BQU8sS0FBSyxFQUVWLHdCQUF3QixFQUN4Qix5QkFBeUIsRUFDMUIsTUFBTSxpQ0FBaUMsQ0FBQztBQUl6QyxPQUFPLEtBQUssRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRS9FLHdCQUFzQixTQUFTLENBQzdCLFFBQVEsRUFBRSxXQUFXLEVBQ3JCLElBQUksRUFBRSxNQUFNLEVBQ1osSUFBSSxFQUFFLHlCQUF5QixFQUMvQixVQUFVLEdBQUUsTUFBTSxHQUFHLFNBQWdCLEVBQ3JDLGlCQUFpQixHQUFFLE1BQTRDLEVBQy9ELFlBQVksR0FBRSxPQUFjOzs7R0F3RDdCO0FBRUQsd0JBQXNCLGNBQWMsQ0FBQyxRQUFRLEVBQUUsV0FBVyxFQUFFLElBQUksRUFBRSx5QkFBeUI7OztHQWlEMUY7QUFFRCx3QkFBc0IsVUFBVSxDQUM5QixJQUFJLEVBQUUsV0FBVyxFQUNqQixLQUFLLEVBQUUsTUFBTSxFQUNiLE1BQU0sRUFBRSxNQUFNLEVBQ2QsVUFBVSxFQUFFLHVCQUF1Qjs7O0dBZXBDO0FBRUQsd0JBQWdCLGtCQUFrQixDQUFDLGlCQUFpQixFQUFFLE1BQU0sUUFFM0Q7QUFFRCx3QkFBc0IsY0FBYyxDQUNsQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFDbEMsRUFDRSxnQkFBaUMsRUFDakMsU0FBYSxFQUNiLGNBQWtCLEVBQ2xCLGlCQUFxQixFQUNyQixJQUFJLEVBQ0wsR0FBRTtJQUNELGdCQUFnQixDQUFDLEVBQUUsV0FBVyxDQUFDO0lBQy9CLFNBQVMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNuQixjQUFjLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDeEIsaUJBQWlCLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDM0IsSUFBSSxDQUFDLEVBQUUseUJBQXlCLENBQUM7Q0FDN0I7OztHQXFCUDtBQUVELHdCQUFzQixlQUFlLENBQUMsS0FBSyxFQUFFLHdCQUF3QixFQUFFLEtBQUssRUFBRSx3QkFBd0IsaUJBUXJHO0FBRUQsd0JBQXNCLGFBQWEsQ0FBQyxJQUFJLEVBQUUsd0JBQXdCLEVBQUUsS0FBSyxFQUFFLHdCQUF3QixpQkFZbEcifQ==

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,EAEV,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,iCAAiC,CAAC;AAGzC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,yBAAyB,EAC/B,UAAU,GAAE,MAAM,GAAG,SAAgB;;;GAsDtC;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":"AAMA,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAc,MAAM,iCAAiC,CAAC;AAEjG,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,EAEV,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,iCAAiC,CAAC;AAIzC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,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,YAAY,GAAE,OAAc;;;GAwD7B;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,yBAAyB;;;GAiD1F;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,uBAAuB;;;GAepC;AAED,wBAAgB,kBAAkB,CAAC,iBAAiB,EAAE,MAAM,QAE3D;AAED,wBAAsB,cAAc,CAClC,gBAAgB,EAAE,gBAAgB,EAClC,EACE,gBAAiC,EACjC,SAAa,EACb,cAAkB,EAClB,iBAAqB,EACrB,IAAI,EACL,GAAE;IACD,gBAAgB,CAAC,EAAE,WAAW,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,IAAI,CAAC,EAAE,yBAAyB,CAAC;CAC7B;;;GAqBP;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,11 +1,19 @@
 import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
-import { L2Block } from '@aztec/stdlib/block';
+import { L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-export async function mockBlock(blockNum, size, fork, maxEffects = 1000) {
-    const l2Block = await L2Block.random(blockNum, size, undefined, undefined, undefined, undefined, maxEffects);
-    const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.random);
+export async function mockBlock(blockNum, size, fork, maxEffects = 1000, numL1ToL2Messages = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, isFirstBlock = true) {
+    const l2Block = await L2BlockNew.random(blockNum, {
+        txsPerBlock: size,
+        txOptions: {
+            maxEffects
+        }
+    });
+    const l1ToL2Messages = mockL1ToL2Messages(numL1ToL2Messages);
     {
         const insertData = async (treeId, data, subTreeHeight, fork)=>{
             for (const dataBatch of data){
@@ -15,7 +23,7 @@ export async function mockBlock(blockNum, size, fork, maxEffects = 1000) {
         const publicDataInsert = insertData(MerkleTreeId.PUBLIC_DATA_TREE, l2Block.body.txEffects.map((txEffect)=>txEffect.publicDataWrites.map((write)=>write.toBuffer())), 0, fork);
         const nullifierInsert = insertData(MerkleTreeId.NULLIFIER_TREE, l2Block.body.txEffects.map((txEffect)=>padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((nullifier)=>nullifier.toBuffer())), NULLIFIER_SUBTREE_HEIGHT, fork);
         const noteHashesPadded = l2Block.body.txEffects.flatMap((txEffect)=>padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
-        const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        const l1ToL2MessagesPadded = isFirstBlock ? 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([
@@ -27,7 +35,7 @@ export async function mockBlock(blockNum, size, fork, maxEffects = 1000) {
     }
     const state = await fork.getStateReference();
     l2Block.header.state = state;
-    await fork.updateArchive(l2Block.getBlockHeader());
+    await fork.updateArchive(l2Block.header);
     const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
     l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
     return {
@@ -36,7 +44,7 @@ export async function mockBlock(blockNum, size, fork, maxEffects = 1000) {
     };
 }
 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 = blockNum;
     // Sync the append only trees
@@ -57,7 +65,7 @@ export async function mockEmptyBlock(blockNum, fork) {
     }
     const state = await fork.getStateReference();
     l2Block.header.state = state;
-    await fork.updateArchive(l2Block.getBlockHeader());
+    await fork.updateArchive(l2Block.header);
     const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
     l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
     return {
@@ -66,11 +74,11 @@ export async function mockEmptyBlock(blockNum, fork) {
     };
 }
 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);
     }
@@ -80,6 +88,39 @@ export async function mockBlocks(from, count, numTxs, worldState) {
         messages: messagesArray
     };
 }
+export function mockL1ToL2Messages(numL1ToL2Messages) {
+    return Array(numL1ToL2Messages).fill(0).map(Fr.random);
+}
+export async function mockCheckpoint(checkpointNumber, { startBlockNumber = BlockNumber(1), numBlocks = 1, numTxsPerBlock = 1, numL1ToL2Messages = 1, fork } = {}) {
+    const slotNumber = SlotNumber(checkpointNumber * 10);
+    const blocksAndMessages = [];
+    for(let i = 0; i < numBlocks; i++){
+        const blockNumber = BlockNumber(startBlockNumber + i);
+        const { block, messages } = fork ? await mockBlock(blockNumber, numTxsPerBlock, fork, blockNumber === startBlockNumber ? numL1ToL2Messages : 0) : {
+            block: await L2BlockNew.random(blockNumber, {
+                txsPerBlock: numTxsPerBlock,
+                slotNumber
+            }),
+            messages: mockL1ToL2Messages(numL1ToL2Messages)
+        };
+        blocksAndMessages.push({
+            block,
+            messages
+        });
+    }
+    const messages = blocksAndMessages[0].messages;
+    const inHash = computeInHashFromL1ToL2Messages(messages);
+    const checkpoint = await Checkpoint.random(checkpointNumber, {
+        numBlocks: 0,
+        slotNumber,
+        inHash
+    });
+    checkpoint.blocks = blocksAndMessages.map(({ block })=>block);
+    return {
+        checkpoint,
+        messages
+    };
+}
 export async function assertSameState(forkA, forkB) {
     const nativeStateRef = await forkA.getStateReference();
     const nativeArchive = await forkA.getTreeInfo(MerkleTreeId.ARCHIVE);

package/dest/world-state-db/merkle_tree_db.d.ts

@@ -1,6 +1,7 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/fields';
 import type { IndexedTreeSnapshot, TreeSnapshot } from '@aztec/merkle-tree';
-import type { L2Block, L2BlockNew } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import type { ForkMerkleTreeOperations, MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
 import type { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { WorldStateStatusFull, WorldStateStatusSummary } from '../native/message.js';
@@ -33,10 +34,10 @@ export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations {
      * Handles a single L2 block (i.e. Inserts the new note hashes into the merkle tree).
      * @param block - The L2 block to handle.
      * @param l1ToL2Messages - The L1 to L2 messages for the block.
-     * @param isFirstBlock - Whether the block is the first block in a checkpoint. Temporary hack to only insert l1 to l2
-     * messages for the first block in a checkpoint. TODO(#17027) Remove this.
+     * @param isFirstBlock - Whether the block is the first block in a checkpoint. The messages are padded and inserted
+     * to the tree for the first block in a checkpoint.
      */
-    handleL2BlockAndMessages(block: L2Block | L2BlockNew, l1ToL2Messages: Fr[], isFirstBlock?: boolean): Promise<WorldStateStatusFull>;
+    handleL2BlockAndMessages(block: L2BlockNew, l1ToL2Messages: Fr[], isFirstBlock: boolean): Promise<WorldStateStatusFull>;
     /**
      * Gets a handle that allows reading the latest committed state
      */
@@ -46,19 +47,19 @@ export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations {
      * @param toBlockNumber The block number of the new oldest historical block
      * @returns The new WorldStateStatus
      */
-    removeHistoricalBlocks(toBlockNumber: bigint): Promise<WorldStateStatusFull>;
+    removeHistoricalBlocks(toBlockNumber: BlockNumber): Promise<WorldStateStatusFull>;
     /**
      * Removes all pending blocks down to but not including the given block number
      * @param toBlockNumber The block number of the new tip of the pending chain,
      * @returns The new WorldStateStatus
      */
-    unwindBlocks(toBlockNumber: bigint): Promise<WorldStateStatusFull>;
+    unwindBlocks(toBlockNumber: BlockNumber): Promise<WorldStateStatusFull>;
     /**
      * Advances the finalized block number to be the number provided
      * @param toBlockNumber The block number that is now the tip of the finalized chain
      * @returns The new WorldStateStatus
      */
-    setFinalized(toBlockNumber: bigint): Promise<WorldStateStatusSummary>;
+    setFinalized(toBlockNumber: BlockNumber): Promise<WorldStateStatusSummary>;
     /**
      * Gets the current status summary of the database.
      * @returns The current WorldStateStatus.
@@ -69,4 +70,4 @@ export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations {
     /** Deletes the db. */
     clear(): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVya2xlX3RyZWVfZGIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93b3JsZC1zdGF0ZS1kYi9tZXJrbGVfdHJlZV9kYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNuRCxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUM1RSxPQUFPLEtBQUssRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDL0QsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMxRyxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV4RCxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSx1QkFBdUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRTFGOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsZUFBTyxNQUFNLDJCQUEyQixRQUE0QixDQUFDO0FBRXJFLGVBQU8sTUFBTSw2QkFBNkIsUUFBbUQsQ0FBQztBQUU5RixNQUFNLE1BQU0sYUFBYSxHQUFHO0lBQzFCLENBQUMsWUFBWSxDQUFDLGNBQWMsQ0FBQyxFQUFFLG1CQUFtQixDQUFDO0lBQ25ELENBQUMsWUFBWSxDQUFDLGNBQWMsQ0FBQyxFQUFFLFlBQVksQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNoRCxDQUFDLFlBQVksQ0FBQyxnQkFBZ0IsQ0FBQyxFQUFFLG1CQUFtQixDQUFDO0lBQ3JELENBQUMsWUFBWSxDQUFDLHFCQUFxQixDQUFDLEVBQUUsWUFBWSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZELENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxFQUFFLFlBQVksQ0FBQyxFQUFFLENBQUMsQ0FBQztDQUMxQyxDQUFDO0FBRUYsTUFBTSxXQUFXLHVCQUF3QixTQUFRLHdCQUF3QjtJQUN2RTs7Ozs7O09BTUc7SUFDSCx3QkFBd0IsQ0FDdEIsS0FBSyxFQUFFLE9BQU8sR0FBRyxVQUFVLEVBQzNCLGNBQWMsRUFBRSxFQUFFLEVBQUUsRUFDcEIsWUFBWSxDQUFDLEVBQUUsT0FBTyxHQUNyQixPQUFPLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUVqQzs7T0FFRztJQUNILFlBQVksSUFBSSx3QkFBd0IsQ0FBQztJQUV6Qzs7OztPQUlHO0lBQ0gsc0JBQXNCLENBQUMsYUFBYSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUU3RTs7OztPQUlHO0lBQ0gsWUFBWSxDQUFDLGFBQWEsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLG9CQUFvQixDQUFDLENBQUM7SUFFbkU7Ozs7T0FJRztJQUNILFlBQVksQ0FBQyxhQUFhLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDO0lBRXRFOzs7T0FHRztJQUNILGdCQUFnQixJQUFJLE9BQU8sQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDO0lBRXJELHlCQUF5QjtJQUN6QixLQUFLLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBRXZCLHNCQUFzQjtJQUN0QixLQUFLLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0NBQ3hCIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dest/world-state-db/merkle_tree_db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merkle_tree_db.d.ts","sourceRoot":"","sources":["../../src/world-state-db/merkle_tree_db.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC1G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE1F;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,2BAA2B,QAA4B,CAAC;AAErE,eAAO,MAAM,6BAA6B,QAAmD,CAAC;AAE9F,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,mBAAmB,CAAC;IACnD,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IAChD,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE,mBAAmB,CAAC;IACrD,CAAC,YAAY,CAAC,qBAAqB,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IACvD,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;CAC1C,CAAC;AAEF,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACvE;;;;;;OAMG;IACH,wBAAwB,CACtB,KAAK,EAAE,OAAO,GAAG,UAAU,EAC3B,cAAc,EAAE,EAAE,EAAE,EACpB,YAAY,CAAC,EAAE,OAAO,GACrB,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEjC;;OAEG;IACH,YAAY,IAAI,wBAAwB,CAAC;IAEzC;;;;OAIG;IACH,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAE7E;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEnE;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAEtE;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAErD,yBAAyB;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB,sBAAsB;IACtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}
+{"version":3,"file":"merkle_tree_db.d.ts","sourceRoot":"","sources":["../../src/world-state-db/merkle_tree_db.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC1G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE1F;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,2BAA2B,QAA4B,CAAC;AAErE,eAAO,MAAM,6BAA6B,QAAmD,CAAC;AAE9F,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,mBAAmB,CAAC;IACnD,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IAChD,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE,mBAAmB,CAAC;IACrD,CAAC,YAAY,CAAC,qBAAqB,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IACvD,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;CAC1C,CAAC;AAEF,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACvE;;;;;;OAMG;IACH,wBAAwB,CACtB,KAAK,EAAE,UAAU,EACjB,cAAc,EAAE,EAAE,EAAE,EACpB,YAAY,EAAE,OAAO,GACpB,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEjC;;OAEG;IACH,YAAY,IAAI,wBAAwB,CAAC;IAEzC;;;;OAIG;IACH,sBAAsB,CAAC,aAAa,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAElF;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAExE;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,WAAW,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAE3E;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAErD,yBAAyB;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB,sBAAsB;IACtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/world-state",
-  "version": "0.0.1-commit.9b94fc1",
+  "version": "0.0.1-commit.d3ec352c",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -18,8 +18,8 @@
     "tsconfig": "./tsconfig.json"
   },
   "scripts": {
-    "build": "yarn clean && tsgo -b",
-    "build:dev": "tsgo -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
@@ -64,19 +64,19 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.9b94fc1",
-    "@aztec/foundation": "0.0.1-commit.9b94fc1",
-    "@aztec/kv-store": "0.0.1-commit.9b94fc1",
-    "@aztec/merkle-tree": "0.0.1-commit.9b94fc1",
-    "@aztec/native": "0.0.1-commit.9b94fc1",
-    "@aztec/protocol-contracts": "0.0.1-commit.9b94fc1",
-    "@aztec/stdlib": "0.0.1-commit.9b94fc1",
-    "@aztec/telemetry-client": "0.0.1-commit.9b94fc1",
+    "@aztec/constants": "0.0.1-commit.d3ec352c",
+    "@aztec/foundation": "0.0.1-commit.d3ec352c",
+    "@aztec/kv-store": "0.0.1-commit.d3ec352c",
+    "@aztec/merkle-tree": "0.0.1-commit.d3ec352c",
+    "@aztec/native": "0.0.1-commit.d3ec352c",
+    "@aztec/protocol-contracts": "0.0.1-commit.d3ec352c",
+    "@aztec/stdlib": "0.0.1-commit.d3ec352c",
+    "@aztec/telemetry-client": "0.0.1-commit.d3ec352c",
     "tslib": "^2.4.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.0.1-commit.9b94fc1",
+    "@aztec/archiver": "0.0.1-commit.d3ec352c",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/native/merkle_trees_facade.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import { serializeToBuffer } from '@aztec/foundation/serialize';
 import { type IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
@@ -191,14 +192,14 @@ export class MerkleTreesFacade implements MerkleTreeReadOperations {
   async getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(
     treeId: ID,
     leafIndices: bigint[],
-  ): Promise<(bigint | undefined)[]> {
+  ): Promise<(BlockNumber | undefined)[]> {
     const response = await this.instance.call(WorldStateMessageType.GET_BLOCK_NUMBERS_FOR_LEAF_INDICES, {
       treeId,
       revision: this.revision,
       leafIndices,
     });
 
-    return response.blockNumbers.map(x => (x === undefined || x === null ? undefined : BigInt(x)));
+    return response.blockNumbers.map(x => (x === undefined || x === null ? undefined : BlockNumber(Number(x))));
   }
 }