@aztec/world-state 0.0.1-commit.b6e433891 → 0.0.1-commit.b8a057fa

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,4 +1,3 @@
-import { GENESIS_BLOCK_HEADER_HASH, INITIAL_CHECKPOINT_NUMBER, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -6,15 +5,13 @@ import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { elapsed } from '@aztec/foundation/timer';
 import {
   type BlockHash,
-  GENESIS_CHECKPOINT_HEADER_HASH,
+  EventDrivenL2BlockStream,
   type L2Block,
-  type L2BlockId,
   type L2BlockSource,
-  L2BlockStream,
   type L2BlockStreamEvent,
   type L2BlockStreamEventHandler,
   type L2BlockStreamLocalDataProvider,
-  type L2Tips,
+  type LocalChainTips,
 } from '@aztec/stdlib/block';
 import {
   WorldStateRunningState,
@@ -51,7 +48,7 @@ export class ServerWorldStateSynchronizer
   private currentState: WorldStateRunningState = WorldStateRunningState.IDLE;
 
   private syncPromise = promiseWithResolvers<void>();
-  protected blockStream: L2BlockStream | undefined;
+  protected blockStream: EventDrivenL2BlockStream | undefined;
 
   // 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
@@ -81,6 +78,46 @@ export class ServerWorldStateSynchronizer
     return this.merkleTreeDb.getSnapshot(blockNumber);
   }
 
+  public async getVerifiedSnapshot(blockNumber: BlockNumber, blockHash: BlockHash): Promise<MerkleTreeReadOperations> {
+    const snapshot = this.merkleTreeDb.getSnapshot(blockNumber);
+    // Block 0's snapshot is the pre-genesis archive view (size 0), so archive leaf 0 is not visible from it;
+    // verify against the initial header hash instead. For later blocks, read archive leaf `blockNumber` from the
+    // snapshot's own view so the exact handle we return is validated against the requested fork.
+    const actualHash =
+      blockNumber === BlockNumber.ZERO
+        ? (await this.merkleTreeCommitted.getInitialHeader().hash()).toString()
+        : (await snapshot.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(blockNumber)))?.toString();
+
+    if (actualHash === undefined) {
+      // A missing archive leaf means either the block's history has been pruned away (permanent: the block predates
+      // the oldest historical block kept by world state) or a reorg flipped the fork between the sync and this read
+      // (transient). Only the latter is worth retrying, so it alone surfaces as WorldStateSynchronizerError.
+      const { oldestHistoricalBlock } = await this.merkleTreeDb.getStatusSummary();
+      if (blockNumber < oldestHistoricalBlock) {
+        throw new Error(
+          `Unable to find leaf for block ${blockNumber} in the archive tree: world state history has been pruned to block ${oldestHistoricalBlock}`,
+        );
+      }
+      throw new WorldStateSynchronizerError(`Unable to read block hash at block ${blockNumber} to verify snapshot`, {
+        cause: { reason: 'block_not_available', targetBlockNumber: blockNumber },
+      });
+    }
+    if (actualHash !== blockHash.toString()) {
+      throw new WorldStateSynchronizerError(
+        `Block hash mismatch at block ${blockNumber} (expected ${blockHash} but got ${actualHash})`,
+        {
+          cause: {
+            reason: 'block_hash_mismatch',
+            targetBlockNumber: blockNumber,
+            expectedHash: blockHash.toString(),
+            actualHash,
+          },
+        },
+      );
+    }
+    return snapshot;
+  }
+
   public fork(blockNumber?: BlockNumber, opts?: { closeDelayMs?: number }): Promise<MerkleTreeWriteOperations> {
     return this.merkleTreeDb.fork(blockNumber, opts);
   }
@@ -123,9 +160,9 @@ export class ServerWorldStateSynchronizer
     return this.syncPromise.promise;
   }
 
-  protected createBlockStream(): L2BlockStream {
+  protected createBlockStream(): EventDrivenL2BlockStream {
     const logger = createLogger('world-state:block_stream');
-    return new L2BlockStream(this.l2BlockSource, this, this, logger, {
+    return new EventDrivenL2BlockStream(this.l2BlockSource, this, this, logger, {
       pollIntervalMS: this.config.worldStateBlockCheckIntervalMS,
       batchSize: this.config.worldStateBlockRequestBatchSize,
       ignoreCheckpoints: true,
@@ -266,8 +303,12 @@ export class ServerWorldStateSynchronizer
     return this.merkleTreeCommitted.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(number)).then(leaf => leaf?.toString());
   }
 
-  /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */
-  public async getL2Tips(): Promise<L2Tips> {
+  /**
+   * Returns the proposed, proven, and finalized block tips of the chain. World state drives its block stream with
+   * `ignoreCheckpoints`, so it does not track checkpointed blocks or checkpoints and omits `checkpointed` from the tips
+   * it reports.
+   */
+  public async getL2Tips(): Promise<LocalChainTips> {
     const status = await this.merkleTreeDb.getStatusSummary();
     const unfinalizedBlockHashPromise = this.getL2BlockHash(status.unfinalizedBlockNumber);
     const finalizedBlockHashPromise = this.getL2BlockHash(status.finalizedBlockNumber);
@@ -281,25 +322,13 @@ export class ServerWorldStateSynchronizer
       finalizedBlockHashPromise,
       provenBlockHashPromise,
     ]);
-    const latestBlockId: L2BlockId = { number: status.unfinalizedBlockNumber, hash: unfinalizedBlockHash! };
-
-    // World state doesn't track checkpointed blocks or checkpoints themselves.
-    // but we use a block stream so we need to provide 'local' L2Tips.
-    // We configure the block stream to ignore checkpoints and set checkpoint values to genesis here.
-    const genesisCheckpointHeaderHash = GENESIS_CHECKPOINT_HEADER_HASH.toString();
     return {
-      proposed: latestBlockId,
-      checkpointed: {
-        block: { number: INITIAL_L2_BLOCK_NUM, hash: GENESIS_BLOCK_HEADER_HASH.toString() },
-        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
-      },
+      proposed: { number: status.unfinalizedBlockNumber, hash: unfinalizedBlockHash },
       finalized: {
-        block: { number: status.finalizedBlockNumber, hash: finalizedBlockHash ?? '' },
-        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
+        block: { number: status.finalizedBlockNumber, hash: finalizedBlockHash },
       },
       proven: {
-        block: { number: provenBlockNumber, hash: provenBlockHash ?? '' },
-        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
+        block: { number: provenBlockNumber, hash: provenBlockHash },
       },
     };
   }
@@ -319,6 +348,15 @@ export class ServerWorldStateSynchronizer
       case 'chain-finalized':
         await this.handleChainFinalized(event.block.number);
         break;
+      // World state runs in block mode with ignoreCheckpoints: it tracks tips via blocks-added/pruned/proven/finalized
+      // and ignores the thin tip events (it never anchors on them).
+      case 'chain-proposed':
+      case 'chain-checkpointed':
+        break;
+      default: {
+        const _: never = event;
+        break;
+      }
     }
   }
 
@@ -404,29 +442,26 @@ export class ServerWorldStateSynchronizer
     if (this.historyToKeep === undefined) {
       return;
     }
-    // Get the checkpointed block for the finalized block number
-    const finalisedCheckpoint = await this.l2BlockSource.getCheckpointedBlock(summary.finalizedBlockNumber);
-    if (finalisedCheckpoint === undefined) {
+    const finalisedBlockData = await this.l2BlockSource.getBlockData({ number: summary.finalizedBlockNumber });
+    if (finalisedBlockData === undefined) {
       this.log.warn(
         `Failed to retrieve checkpointed block for finalized block number: ${summary.finalizedBlockNumber}`,
       );
       return;
     }
     // Compute the required historic checkpoint number
-    const newHistoricCheckpointNumber = finalisedCheckpoint.checkpointNumber - this.historyToKeep + 1;
+    const newHistoricCheckpointNumber = finalisedBlockData.checkpointNumber - this.historyToKeep + 1;
     if (newHistoricCheckpointNumber <= 1) {
       return;
     }
     // Retrieve the historic checkpoint
-    const historicCheckpoints = await this.l2BlockSource.getCheckpoints(
-      CheckpointNumber(newHistoricCheckpointNumber),
-      1,
-    );
-    if (historicCheckpoints.length === 0 || historicCheckpoints[0] === undefined) {
+    const historicCheckpoint = await this.l2BlockSource.getCheckpoint({
+      number: CheckpointNumber(newHistoricCheckpointNumber),
+    });
+    if (!historicCheckpoint) {
       this.log.warn(`Failed to retrieve checkpoint number ${newHistoricCheckpointNumber} from Archiver`);
       return;
     }
-    const historicCheckpoint = historicCheckpoints[0];
     if (historicCheckpoint.checkpoint.blocks.length === 0 || historicCheckpoint.checkpoint.blocks[0] === undefined) {
       this.log.warn(`Retrieved checkpoint number ${newHistoricCheckpointNumber} has no blocks!`);
       return;
@@ -453,7 +488,9 @@ export class ServerWorldStateSynchronizer
   private async handleChainPruned(blockNumber: BlockNumber) {
     this.log.info(`Chain pruned to block ${blockNumber}`);
     const status = await this.merkleTreeDb.unwindBlocks(blockNumber);
-    this.provenBlockNumber = undefined;
+    if (this.provenBlockNumber !== undefined && this.provenBlockNumber > blockNumber) {
+      this.provenBlockNumber = undefined;
+    }
     this.instrumentation.updateWorldStateMetrics(status);
   }
 

package/src/test/utils.ts

@@ -60,7 +60,16 @@ export async function updateBlockState(block: L2Block, l1ToL2Messages: Fr[], for
   await Promise.all([publicDataInsert, nullifierInsert, noteHashInsert, messageInsert]);
 
   const state = await fork.getStateReference();
-  block.header = BlockHeader.from({ ...block.header, state });
+
+  // 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);

package/src/testing.ts

@@ -3,22 +3,22 @@ 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/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/src/native/world_state_ops_queue.ts

@@ -1,190 +0,0 @@
-import { promiseWithResolvers } from '@aztec/foundation/promise';
-
-import { WorldStateMessageType } from './message.js';
-
-/**
- * This is the implementation for queueing requests to the world state.
- * Requests need to be queued for the world state to ensure that writes are correctly ordered
- * and reads return the correct data.
- * Due to the nature of the NAPI we can't really do this there.
- *
- * The rules for queueing are as follows:
- *
- * 1. Reads of committed state never need to be queued. LMDB uses MVCC to ensure readers see a consistent view of the DB.
- * 2. Reads of uncommitted state can happen concurrently with other reads of uncommitted state on the same fork (or reads of committed state)
- * 3. All writes require exclusive access to their respective fork
- *
- */
-
-type WorldStateOp = {
-  requestId: number;
-  mutating: boolean;
-  request: () => Promise<any>;
-  promise: PromiseWithResolvers<any>;
-};
-
-// 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 {
-  private requests: WorldStateOp[] = [];
-  private inFlightMutatingCount = 0;
-  private inFlightCount = 0;
-  private stopPromise?: Promise<void>;
-  private stopResolve?: () => void;
-  private requestId = 0;
-  private ops: Map<number, WorldStateOp> = 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
-  public execute(request: () => Promise<any>, messageType: WorldStateMessageType, committedOnly: boolean) {
-    if (this.stopResolve !== undefined) {
-      throw new Error('Unable to send request to world state, queue already stopped');
-    }
-
-    const op: WorldStateOp = {
-      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
-  private executeMutating(op: WorldStateOp) {
-    // 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
-  private executeNonMutatingUncommitted(op: WorldStateOp) {
-    // 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);
-    }
-  }
-
-  private executeNonMutatingCommitted(op: WorldStateOp) {
-    // 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);
-      });
-  }
-
-  private checkAndEnqueue(completedOp: WorldStateOp) {
-    // 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);
-        }
-        // this request is mutating, we need to stop here
-        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();
-    }
-  }
-
-  private sendEnqueuedRequest(op: WorldStateOp) {
-    // 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);
-      });
-  }
-
-  public 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;
-  }
-}