@aztec/world-state 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/test/utils.ts

@@ -4,129 +4,109 @@ import {
   NULLIFIER_SUBTREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
 } from '@aztec/constants';
-import { BlockNumber, type CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { asyncMap } from '@aztec/foundation/async-map';
+import { BlockNumber, type CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { L2BlockNew } from '@aztec/stdlib/block';
-import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { L2Block } from '@aztec/stdlib/block';
 import type {
   IndexedTreeId,
   MerkleTreeReadOperations,
   MerkleTreeWriteOperations,
 } from '@aztec/stdlib/interfaces/server';
-import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import { mockCheckpointAndMessages, mockL1ToL2Messages } from '@aztec/stdlib/testing';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { NativeWorldStateService } from '../native/native_world_state.js';
 
-export async function mockBlock(
-  blockNum: BlockNumber,
-  size: number,
-  fork: MerkleTreeWriteOperations,
-  maxEffects: number | undefined = 1000, // Defaults to the maximum tx effects.
-  numL1ToL2Messages: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-  isFirstBlock: boolean = true,
-) {
-  const l2Block = await L2BlockNew.random(blockNum, { txsPerBlock: size, txOptions: { maxEffects } });
-  const l1ToL2Messages = mockL1ToL2Messages(numL1ToL2Messages);
+export async function updateBlockState(block: L2Block, l1ToL2Messages: Fr[], fork: MerkleTreeWriteOperations) {
+  const insertData = async (
+    treeId: IndexedTreeId,
+    data: Buffer[][],
+    subTreeHeight: number,
+    fork: MerkleTreeWriteOperations,
+  ) => {
+    for (const dataBatch of data) {
+      await fork.batchInsert(treeId, dataBatch, subTreeHeight);
+    }
+  };
 
-  {
-    const insertData = async (
-      treeId: IndexedTreeId,
-      data: Buffer[][],
-      subTreeHeight: number,
-      fork: MerkleTreeWriteOperations,
-    ) => {
-      for (const dataBatch of data) {
-        await fork.batchInsert(treeId, dataBatch, subTreeHeight);
-      }
-    };
-
-    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 = isFirstBlock
+  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<Fr, number>(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 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);
+
+  // Capture the archive root *before* appending this block so the header's lastArchive chains off the previous block.
+  // sync_block now verifies lastArchive against the committed archive root, so a block carrying an unchained value
+  // (e.g. the random lastArchive from L2Block.random) would be rejected as a divergence from the canonical chain.
+  const previousArchive = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+  block.header = BlockHeader.from({
+    ...block.header,
+    state,
+    lastArchive: new AppendOnlyTreeSnapshot(Fr.fromBuffer(previousArchive.root), Number(previousArchive.size)),
+  });
+  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: BlockNumber,
+  size: number,
+  fork: MerkleTreeWriteOperations,
+  maxEffects: number | undefined = 1000, // Defaults to the maximum tx effects.
+  numL1ToL2Messages: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  isFirstBlockInCheckpoint: boolean = true,
+) {
+  const block = await L2Block.random(blockNum, {
+    indexWithinCheckpoint: isFirstBlockInCheckpoint ? IndexWithinCheckpoint(0) : IndexWithinCheckpoint(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: BlockNumber, fork: MerkleTreeWriteOperations) {
-  const l2Block = L2BlockNew.empty();
+  const l2Block = L2Block.empty();
   const l1ToL2Messages = Array(16).fill(0).map(Fr.zero);
 
   l2Block.header.globalVariables.blockNumber = 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<Fr, number>(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));
+  await updateBlockState(l2Block, l1ToL2Messages, fork);
 
   return {
     block: l2Block,
@@ -155,44 +135,15 @@ export async function mockBlocks(
   return { blocks, messages: messagesArray };
 }
 
-export function mockL1ToL2Messages(numL1ToL2Messages: number) {
-  return Array(numL1ToL2Messages).fill(0).map(Fr.random);
-}
-
 export async function mockCheckpoint(
   checkpointNumber: CheckpointNumber,
-  {
-    startBlockNumber = BlockNumber(1),
-    numBlocks = 1,
-    numTxsPerBlock = 1,
-    numL1ToL2Messages = 1,
-    fork,
-  }: {
-    startBlockNumber?: BlockNumber;
-    numBlocks?: number;
-    numTxsPerBlock?: number;
-    numL1ToL2Messages?: number;
-    fork?: MerkleTreeWriteOperations;
-  } = {},
+  fork: MerkleTreeWriteOperations,
+  options: Partial<Parameters<typeof mockCheckpointAndMessages>[1]> = {},
 ) {
-  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);
-
+  const { checkpoint, messages } = await mockCheckpointAndMessages(checkpointNumber, options);
+  await asyncMap(checkpoint.blocks, async (block, i) => {
+    await updateBlockState(block, i === 0 ? messages : [], fork);
+  });
   return { checkpoint, messages };
 }
 

package/src/testing.ts

@@ -1,24 +1,24 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 
 import { NativeWorldStateService } from './native/index.js';
 
-async function generateGenesisValues(prefilledPublicData: PublicDataTreeLeaf[]) {
-  if (!prefilledPublicData.length) {
+async function generateGenesisValues(genesis: GenesisData) {
+  if (!genesis.prefilledPublicData.length && genesis.genesisTimestamp === 0n) {
     return {
       genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT),
     };
   }
 
-  // Create a temporary world state to compute the genesis values.
-  const ws = await NativeWorldStateService.tmp(
-    undefined /* rollupAddress */,
-    true /* cleanupTmpDir */,
-    prefilledPublicData,
-  );
+  // Compute the genesis values on a throwaway world state. The archive root derives only from the
+  // prefilled public data and the genesis timestamp, so the fsync-off ephemeral store (no version
+  // manager, no crash-recoverability) produces an identical root while skipping the fsync overhead
+  // that `tmp` pays. close() removes the tmpdir.
+  const ws = await NativeWorldStateService.ephemeral(genesis);
   const genesisArchiveRoot = new Fr((await ws.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
   await ws.close();
 
@@ -33,6 +33,7 @@ export async function getGenesisValues(
   initialAccounts: AztecAddress[],
   initialAccountFeeJuice = defaultInitialAccountFeeJuice,
   genesisPublicData: PublicDataTreeLeaf[] = [],
+  genesisTimestamp: bigint = 0n,
 ) {
   // Top up the accounts with fee juice.
   let prefilledPublicData = await Promise.all(
@@ -46,11 +47,12 @@ export async function getGenesisValues(
 
   prefilledPublicData.sort((a, b) => (b.slot.lt(a.slot) ? 1 : -1));
 
-  const { genesisArchiveRoot } = await generateGenesisValues(prefilledPublicData);
+  const genesis: GenesisData = { prefilledPublicData, genesisTimestamp };
+  const { genesisArchiveRoot } = await generateGenesisValues(genesis);
 
   return {
     genesisArchiveRoot,
-    prefilledPublicData,
+    genesis,
     fundingNeeded: BigInt(initialAccounts.length) * initialAccountFeeJuice.toBigInt(),
   };
 }

package/src/world-state-db/merkle_tree_db.ts

@@ -1,10 +1,12 @@
 import { MAX_NULLIFIERS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX } from '@aztec/constants';
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/fields';
-import type { IndexedTreeSnapshot, TreeSnapshot } from '@aztec/merkle-tree';
-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 { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { L2Block } from '@aztec/stdlib/block';
+import type {
+  ForkMerkleTreeOperations,
+  MerkleTreeReadOperations,
+  ReadonlyWorldStateAccess,
+} from '@aztec/stdlib/interfaces/server';
 
 import type { WorldStateStatusFull, WorldStateStatusSummary } from '../native/message.js';
 
@@ -27,27 +29,13 @@ export const INITIAL_NULLIFIER_TREE_SIZE = 2 * MAX_NULLIFIERS_PER_TX;
 
 export const INITIAL_PUBLIC_DATA_TREE_SIZE = 2 * MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX;
 
-export type TreeSnapshots = {
-  [MerkleTreeId.NULLIFIER_TREE]: IndexedTreeSnapshot;
-  [MerkleTreeId.NOTE_HASH_TREE]: TreeSnapshot<Fr>;
-  [MerkleTreeId.PUBLIC_DATA_TREE]: IndexedTreeSnapshot;
-  [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: TreeSnapshot<Fr>;
-  [MerkleTreeId.ARCHIVE]: TreeSnapshot<Fr>;
-};
-
-export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations {
+export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations, ReadonlyWorldStateAccess {
   /**
    * 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. The messages are padded and inserted
-   * to the tree for the first block in a checkpoint.
    */
-  handleL2BlockAndMessages(
-    block: L2BlockNew,
-    l1ToL2Messages: Fr[],
-    isFirstBlock: boolean,
-  ): Promise<WorldStateStatusFull>;
+  handleL2BlockAndMessages(block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull>;
 
   /**
    * Gets a handle that allows reading the latest committed state

package/dest/native/world_state_ops_queue.d.ts

@@ -1,19 +0,0 @@
-import { WorldStateMessageType } from './message.js';
-export declare const MUTATING_MSG_TYPES: Set<WorldStateMessageType>;
-export declare class WorldStateOpsQueue {
-    private requests;
-    private inFlightMutatingCount;
-    private inFlightCount;
-    private stopPromise?;
-    private stopResolve?;
-    private requestId;
-    private ops;
-    execute(request: () => Promise<any>, messageType: WorldStateMessageType, committedOnly: boolean): Promise<any>;
-    private executeMutating;
-    private executeNonMutatingUncommitted;
-    private executeNonMutatingCommitted;
-    private checkAndEnqueue;
-    private sendEnqueuedRequest;
-    stop(): Promise<void>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGRfc3RhdGVfb3BzX3F1ZXVlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbmF0aXZlL3dvcmxkX3N0YXRlX29wc19xdWV1ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUF5QnJELGVBQU8sTUFBTSxrQkFBa0IsNEJBZ0I3QixDQUFDO0FBR0gscUJBQWEsa0JBQWtCO0lBQzdCLE9BQU8sQ0FBQyxRQUFRLENBQXNCO0lBQ3RDLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBSztJQUNsQyxPQUFPLENBQUMsYUFBYSxDQUFLO0lBQzFCLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBZ0I7SUFDcEMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQUFhO0lBQ2pDLE9BQU8sQ0FBQyxTQUFTLENBQUs7SUFDdEIsT0FBTyxDQUFDLEdBQUcsQ0FBd0M7SUFJNUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxXQUFXLEVBQUUscUJBQXFCLEVBQUUsYUFBYSxFQUFFLE9BQU8sZ0JBc0JyRztJQUdELE9BQU8sQ0FBQyxlQUFlO0lBV3ZCLE9BQU8sQ0FBQyw2QkFBNkI7SUFZckMsT0FBTyxDQUFDLDJCQUEyQjtJQVVuQyxPQUFPLENBQUMsZUFBZTtJQXlDdkIsT0FBTyxDQUFDLG1CQUFtQjtJQWdCcEIsSUFBSSxrQkFnQlY7Q0FDRiJ9

package/dest/native/world_state_ops_queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"world_state_ops_queue.d.ts","sourceRoot":"","sources":["../../src/native/world_state_ops_queue.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAyBrD,eAAO,MAAM,kBAAkB,4BAgB7B,CAAC;AAGH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,WAAW,CAAC,CAAgB;IACpC,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,GAAG,CAAwC;IAI5C,OAAO,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,qBAAqB,EAAE,aAAa,EAAE,OAAO,gBAsBrG;IAGD,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,6BAA6B;IAYrC,OAAO,CAAC,2BAA2B;IAUnC,OAAO,CAAC,eAAe;IAyCvB,OAAO,CAAC,mBAAmB;IAgBpB,IAAI,kBAgBV;CACF"}

package/dest/native/world_state_ops_queue.js

@@ -1,146 +0,0 @@
-import { promiseWithResolvers } from '@aztec/foundation/promise';
-import { WorldStateMessageType } from './message.js';
-// These are the set of message types that implement mutating operations
-// Messages of these types require exclusive access to their given forks
-export const MUTATING_MSG_TYPES = new Set([
-    WorldStateMessageType.APPEND_LEAVES,
-    WorldStateMessageType.BATCH_INSERT,
-    WorldStateMessageType.SEQUENTIAL_INSERT,
-    WorldStateMessageType.UPDATE_ARCHIVE,
-    WorldStateMessageType.COMMIT,
-    WorldStateMessageType.ROLLBACK,
-    WorldStateMessageType.SYNC_BLOCK,
-    WorldStateMessageType.CREATE_FORK,
-    WorldStateMessageType.DELETE_FORK,
-    WorldStateMessageType.FINALIZE_BLOCKS,
-    WorldStateMessageType.UNWIND_BLOCKS,
-    WorldStateMessageType.REMOVE_HISTORICAL_BLOCKS,
-    WorldStateMessageType.CREATE_CHECKPOINT,
-    WorldStateMessageType.COMMIT_CHECKPOINT,
-    WorldStateMessageType.REVERT_CHECKPOINT
-]);
-// This class implements the per-fork operation queue
-export class WorldStateOpsQueue {
-    requests = [];
-    inFlightMutatingCount = 0;
-    inFlightCount = 0;
-    stopPromise;
-    stopResolve;
-    requestId = 0;
-    ops = new Map();
-    // The primary public api, this is where an operation is queued
-    // We return a promise that will ultimately be resolved/rejected with the response/error generated by the 'request' argument
-    execute(request, messageType, committedOnly) {
-        if (this.stopResolve !== undefined) {
-            throw new Error('Unable to send request to world state, queue already stopped');
-        }
-        const op = {
-            requestId: this.requestId++,
-            mutating: MUTATING_MSG_TYPES.has(messageType),
-            request,
-            promise: promiseWithResolvers()
-        };
-        this.ops.set(op.requestId, op);
-        // Perform the appropriate action based upon the queueing rules
-        if (op.mutating) {
-            this.executeMutating(op);
-        } else if (committedOnly === false) {
-            this.executeNonMutatingUncommitted(op);
-        } else {
-            this.executeNonMutatingCommitted(op);
-        }
-        return op.promise.promise;
-    }
-    // Mutating requests need exclusive access
-    executeMutating(op) {
-        // If nothing is in flight then we send the request immediately
-        // Otherwise add to the queue
-        if (this.inFlightCount === 0) {
-            this.sendEnqueuedRequest(op);
-        } else {
-            this.requests.push(op);
-        }
-    }
-    // Non mutating requests including uncommitted state
-    executeNonMutatingUncommitted(op) {
-        // If there are no mutating requests in flight and there is nothing queued
-        // then send the request immediately
-        // If a mutating request is in flight then we must wait
-        // If a mutating request is not in flight but something is queued then it must be a mutating request
-        if (this.inFlightMutatingCount == 0 && this.requests.length == 0) {
-            this.sendEnqueuedRequest(op);
-        } else {
-            this.requests.push(op);
-        }
-    }
-    executeNonMutatingCommitted(op) {
-        // This is a non-mutating request for committed data
-        // It can always be sent
-        op.request().then(op.promise.resolve, op.promise.reject).finally(()=>{
-            this.ops.delete(op.requestId);
-        });
-    }
-    checkAndEnqueue(completedOp) {
-        // As request has completed
-        // First we decrements the relevant in flight counters
-        if (completedOp.mutating) {
-            --this.inFlightMutatingCount;
-        }
-        --this.inFlightCount;
-        // If there are still requests in flight then do nothing further
-        if (this.inFlightCount != 0) {
-            return;
-        }
-        // No requests in flight, send next queued requests
-        // We loop and send:
-        // 1 mutating request if it is next in the queue
-        // As many non-mutating requests as we encounter until
-        // we exhaust the queue or we reach a mutating request
-        while(this.requests.length > 0){
-            const next = this.requests[0];
-            if (next.mutating) {
-                if (this.inFlightCount == 0) {
-                    // send the mutating request
-                    this.requests.shift();
-                    this.sendEnqueuedRequest(next);
-                }
-                break;
-            } else {
-                // not mutating, send and go round again
-                this.requests.shift();
-                this.sendEnqueuedRequest(next);
-            }
-        }
-        // If the queue is empty, there is nothing in flight and we have been told to stop, then resolve the stop promise
-        if (this.inFlightCount == 0 && this.stopResolve !== undefined) {
-            this.stopResolve();
-        }
-    }
-    sendEnqueuedRequest(op) {
-        // Here we increment the in flight counts before sending
-        ++this.inFlightCount;
-        if (op.mutating) {
-            ++this.inFlightMutatingCount;
-        }
-        // Make the request and pass the response/error through to the stored promise
-        op.request().then(op.promise.resolve, op.promise.reject).finally(()=>{
-            this.checkAndEnqueue(op);
-            this.ops.delete(op.requestId);
-        });
-    }
-    stop() {
-        // If there is already a stop promise then return it
-        if (this.stopPromise) {
-            return this.stopPromise;
-        }
-        // Otherwise create a new one and capture the resolve method
-        this.stopPromise = new Promise((resolve)=>{
-            this.stopResolve = resolve;
-        });
-        // If no outstanding requests then immediately resolve the promise
-        if (this.requests.length == 0 && this.inFlightCount == 0 && this.stopResolve !== undefined) {
-            this.stopResolve();
-        }
-        return this.stopPromise;
-    }
-}

package/dest/synchronizer/utils.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,59 +0,0 @@
-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;
-}