@aztec/world-state 0.7.2 → 0.7.4

package/dest/synchroniser/server_world_state_synchroniser.d.ts

@@ -0,0 +1,55 @@
+import { L2BlockSource } from '@aztec/types';
+import { MerkleTreeOperations, MerkleTrees } from '../index.js';
+import { WorldStateConfig } from './config.js';
+import { WorldStateStatus, WorldStateSynchroniser } from './world_state_synchroniser.js';
+/**
+ * Synchronises the world state with the L2 blocks from a L2BlockSource.
+ * The synchroniser will download the L2 blocks from the L2BlockSource and insert the new commitments into the merkle
+ * tree.
+ */
+export declare class ServerWorldStateSynchroniser implements WorldStateSynchroniser {
+    private merkleTreeDb;
+    private l2BlockSource;
+    private log;
+    private currentL2BlockNum;
+    private latestBlockNumberAtStart;
+    private l2BlockDownloader;
+    private syncPromise;
+    private syncResolve?;
+    private jobQueue;
+    private stopping;
+    private runningPromise;
+    private currentState;
+    constructor(merkleTreeDb: MerkleTrees, l2BlockSource: L2BlockSource, config: WorldStateConfig, log?: import("@aztec/foundation/log").DebugLogger);
+    getLatest(): MerkleTreeOperations;
+    getCommitted(): MerkleTreeOperations;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    status(): Promise<WorldStateStatus>;
+    /**
+     * Forces an immediate sync
+     * @param minBlockNumber - The minimum block number that we must sync to
+     * @returns A promise that resolves once the sync has completed.
+     */
+    syncImmediate(minBlockNumber?: number): Promise<void>;
+    /**
+     * Checks for the availability of new blocks and processes them.
+     */
+    private collectAndProcessBlocks;
+    /**
+     * Handles a list of L2 blocks (i.e. Inserts the new commitments into the merkle tree).
+     * @param l2Blocks - The L2 blocks to handle.
+     */
+    private handleL2Blocks;
+    /**
+     * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
+     * @param l2Block - The L2 block to handle.
+     */
+    private handleL2Block;
+    /**
+     * Method to set the value of the current state.
+     * @param newState - New state value.
+     */
+    private setCurrentState;
+}
+//# sourceMappingURL=server_world_state_synchroniser.d.ts.map

package/dest/synchroniser/server_world_state_synchroniser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server_world_state_synchroniser.d.ts","sourceRoot":"","sources":["../../src/synchroniser/server_world_state_synchroniser.ts"],"names":[],"mappings":"AAEA,OAAO,EAA8B,aAAa,EAAE,MAAM,cAAc,CAAC;AAEzE,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAA0B,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEjH;;;;GAIG;AACH,qBAAa,4BAA6B,YAAW,sBAAsB;IAavE,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,aAAa;IAErB,OAAO,CAAC,GAAG;IAfb,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,wBAAwB,CAAK;IAErC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,WAAW,CAAC,CAAyB;IAC7C,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,YAAY,CAAuD;gBAGjE,YAAY,EAAE,WAAW,EACzB,aAAa,EAAE,aAAa,EACpC,MAAM,EAAE,gBAAgB,EAChB,GAAG,8CAAyC;IAS/C,SAAS,IAAI,oBAAoB;IAIjC,YAAY,IAAI,oBAAoB;IAI9B,KAAK;IAwCL,IAAI;IAUV,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAQ1C;;;;OAIG;IACU,aAAa,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoClE;;OAEG;YACW,uBAAuB;IAMrC;;;OAGG;YACW,cAAc;IAM5B;;;OAGG;YACW,aAAa;IAc3B;;;OAGG;IACH,OAAO,CAAC,eAAe;CAIxB"}

package/dest/synchroniser/server_world_state_synchroniser.js

@@ -0,0 +1,163 @@
+import { SerialQueue } from '@aztec/foundation/fifo';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { L2BlockDownloader } from '@aztec/types';
+import { MerkleTreeOperationsFacade } from '../merkle-tree/merkle_tree_operations_facade.js';
+import { WorldStateRunningState } from './world_state_synchroniser.js';
+/**
+ * Synchronises the world state with the L2 blocks from a L2BlockSource.
+ * The synchroniser will download the L2 blocks from the L2BlockSource and insert the new commitments into the merkle
+ * tree.
+ */
+export class ServerWorldStateSynchroniser {
+    constructor(merkleTreeDb, l2BlockSource, config, log = createDebugLogger('aztec:world_state')) {
+        this.merkleTreeDb = merkleTreeDb;
+        this.l2BlockSource = l2BlockSource;
+        this.log = log;
+        this.currentL2BlockNum = 0;
+        this.latestBlockNumberAtStart = 0;
+        this.syncPromise = Promise.resolve();
+        this.syncResolve = undefined;
+        this.jobQueue = new SerialQueue();
+        this.stopping = false;
+        this.runningPromise = Promise.resolve();
+        this.currentState = WorldStateRunningState.IDLE;
+        this.l2BlockDownloader = new L2BlockDownloader(l2BlockSource, config.l2QueueSize, config.worldStateBlockCheckIntervalMS);
+    }
+    getLatest() {
+        return new MerkleTreeOperationsFacade(this.merkleTreeDb, true);
+    }
+    getCommitted() {
+        return new MerkleTreeOperationsFacade(this.merkleTreeDb, false);
+    }
+    async start() {
+        if (this.currentState === WorldStateRunningState.STOPPED) {
+            throw new Error('Synchroniser already stopped');
+        }
+        if (this.currentState !== WorldStateRunningState.IDLE) {
+            return this.syncPromise;
+        }
+        // get the current latest block number
+        this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
+        const blockToDownloadFrom = this.currentL2BlockNum + 1;
+        // if there are blocks to be retrieved, go to a synching state
+        if (blockToDownloadFrom <= this.latestBlockNumberAtStart) {
+            this.setCurrentState(WorldStateRunningState.SYNCHING);
+            this.syncPromise = new Promise(resolve => {
+                this.syncResolve = resolve;
+            });
+            this.log(`Starting sync from ${blockToDownloadFrom}, latest block ${this.latestBlockNumberAtStart}`);
+        }
+        else {
+            // if no blocks to be retrieved, go straight to running
+            this.setCurrentState(WorldStateRunningState.RUNNING);
+            this.syncPromise = Promise.resolve();
+            this.log(`Next block ${blockToDownloadFrom} already beyond latest block at ${this.latestBlockNumberAtStart}`);
+        }
+        // start looking for further blocks
+        const blockProcess = async () => {
+            while (!this.stopping) {
+                await this.jobQueue.put(() => this.collectAndProcessBlocks());
+            }
+        };
+        this.jobQueue.start();
+        this.runningPromise = blockProcess();
+        this.l2BlockDownloader.start(blockToDownloadFrom);
+        this.log(`Started block downloader from block ${blockToDownloadFrom}`);
+        return this.syncPromise;
+    }
+    async stop() {
+        this.log('Stopping world state...');
+        this.stopping = true;
+        await this.l2BlockDownloader.stop();
+        await this.jobQueue.cancel();
+        await this.merkleTreeDb.stop();
+        await this.runningPromise;
+        this.setCurrentState(WorldStateRunningState.STOPPED);
+    }
+    status() {
+        const status = {
+            syncedToL2Block: this.currentL2BlockNum,
+            state: this.currentState,
+        };
+        return Promise.resolve(status);
+    }
+    /**
+     * Forces an immediate sync
+     * @param minBlockNumber - The minimum block number that we must sync to
+     * @returns A promise that resolves once the sync has completed.
+     */
+    async syncImmediate(minBlockNumber) {
+        if (this.currentState !== WorldStateRunningState.RUNNING) {
+            throw new Error(`World State is not running, unable to perform sync`);
+        }
+        // If we have been given a block number to sync to and we have reached that number
+        // then return.
+        if (minBlockNumber !== undefined && minBlockNumber <= this.currentL2BlockNum) {
+            return;
+        }
+        const blockToSyncTo = minBlockNumber === undefined ? 'latest' : `${minBlockNumber}`;
+        this.log(`World State at block ${this.currentL2BlockNum}, told to sync to block ${blockToSyncTo}...`);
+        // ensure any outstanding block updates are completed first.
+        await this.jobQueue.syncPoint();
+        while (true) {
+            // Check the block number again
+            if (minBlockNumber !== undefined && minBlockNumber <= this.currentL2BlockNum) {
+                return;
+            }
+            // Poll for more blocks
+            const numBlocks = await this.l2BlockDownloader.pollImmediate();
+            this.log(`Block download immediate poll yielded ${numBlocks} blocks`);
+            if (numBlocks) {
+                // More blocks were received, process them and go round again
+                await this.jobQueue.put(() => this.collectAndProcessBlocks());
+                continue;
+            }
+            // No blocks are available, if we have been given a block number then we can't achieve it
+            if (minBlockNumber !== undefined) {
+                throw new Error(`Unable to sync to block number ${minBlockNumber}, currently synced to block ${this.currentL2BlockNum}`);
+            }
+            return;
+        }
+    }
+    /**
+     * Checks for the availability of new blocks and processes them.
+     */
+    async collectAndProcessBlocks() {
+        // This request for blocks will timeout after 1 second if no blocks are received
+        const blocks = await this.l2BlockDownloader.getL2Blocks(1);
+        await this.handleL2Blocks(blocks);
+    }
+    /**
+     * Handles a list of L2 blocks (i.e. Inserts the new commitments into the merkle tree).
+     * @param l2Blocks - The L2 blocks to handle.
+     */
+    async handleL2Blocks(l2Blocks) {
+        for (const l2Block of l2Blocks) {
+            await this.handleL2Block(l2Block);
+        }
+    }
+    /**
+     * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
+     * @param l2Block - The L2 block to handle.
+     */
+    async handleL2Block(l2Block) {
+        await this.merkleTreeDb.handleL2Block(l2Block);
+        this.currentL2BlockNum = l2Block.number;
+        if (this.currentState === WorldStateRunningState.SYNCHING &&
+            this.currentL2BlockNum >= this.latestBlockNumberAtStart) {
+            this.setCurrentState(WorldStateRunningState.RUNNING);
+            if (this.syncResolve !== undefined) {
+                this.syncResolve();
+            }
+        }
+    }
+    /**
+     * Method to set the value of the current state.
+     * @param newState - New state value.
+     */
+    setCurrentState(newState) {
+        this.currentState = newState;
+        this.log(`Moved to state ${WorldStateRunningState[this.currentState]}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/synchroniser/server_world_state_synchroniser.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server_world_state_synchroniser.test.d.ts.map

package/dest/synchroniser/server_world_state_synchroniser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server_world_state_synchroniser.test.d.ts","sourceRoot":"","sources":["../../src/synchroniser/server_world_state_synchroniser.test.ts"],"names":[],"mappings":""}

package/dest/synchroniser/server_world_state_synchroniser.test.js

@@ -0,0 +1,317 @@
+import { AppendOnlyTreeSnapshot, CircuitsWasm, Fr, GlobalVariables, MAX_NEW_COMMITMENTS_PER_TX, MAX_NEW_CONTRACTS_PER_TX, MAX_NEW_L2_TO_L1_MSGS_PER_CALL, MAX_NEW_NULLIFIERS_PER_TX, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { INITIAL_LEAF, Pedersen } from '@aztec/merkle-tree';
+import { ContractData, L2Block, L2BlockL2Logs, MerkleTreeId, PublicDataWrite, SiblingPath, } from '@aztec/types';
+import { jest } from '@jest/globals';
+import times from 'lodash.times';
+import { ServerWorldStateSynchroniser } from './server_world_state_synchroniser.js';
+import { WorldStateRunningState } from './world_state_synchroniser.js';
+const LATEST_BLOCK_NUMBER = 5;
+const getLatestBlockNumber = () => LATEST_BLOCK_NUMBER;
+let nextBlocks = [];
+const consumeNextBlocks = () => {
+    const blocks = nextBlocks;
+    nextBlocks = [];
+    return Promise.resolve(blocks);
+};
+const getMockTreeSnapshot = () => {
+    return new AppendOnlyTreeSnapshot(Fr.random(), 16);
+};
+const getMockContractData = () => {
+    return ContractData.random();
+};
+const getMockGlobalVariables = () => {
+    return GlobalVariables.from({
+        chainId: Fr.random(),
+        version: Fr.random(),
+        blockNumber: Fr.random(),
+        timestamp: Fr.random(),
+    });
+};
+const getMockL1ToL2MessagesData = () => {
+    return new Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).map(() => Fr.random());
+};
+const getMockBlock = (blockNumber, newContractsCommitments) => {
+    const newEncryptedLogs = L2BlockL2Logs.random(1, 2, 3);
+    const block = L2Block.fromFields({
+        number: blockNumber,
+        globalVariables: getMockGlobalVariables(),
+        startPrivateDataTreeSnapshot: getMockTreeSnapshot(),
+        startNullifierTreeSnapshot: getMockTreeSnapshot(),
+        startContractTreeSnapshot: getMockTreeSnapshot(),
+        startPublicDataTreeRoot: Fr.random(),
+        startL1ToL2MessagesTreeSnapshot: getMockTreeSnapshot(),
+        startHistoricBlocksTreeSnapshot: getMockTreeSnapshot(),
+        endPrivateDataTreeSnapshot: getMockTreeSnapshot(),
+        endNullifierTreeSnapshot: getMockTreeSnapshot(),
+        endContractTreeSnapshot: getMockTreeSnapshot(),
+        endPublicDataTreeRoot: Fr.random(),
+        endL1ToL2MessagesTreeSnapshot: getMockTreeSnapshot(),
+        endHistoricBlocksTreeSnapshot: getMockTreeSnapshot(),
+        newCommitments: times(MAX_NEW_COMMITMENTS_PER_TX, Fr.random),
+        newNullifiers: times(MAX_NEW_NULLIFIERS_PER_TX, Fr.random),
+        newContracts: newContractsCommitments?.map(x => Fr.fromBuffer(x)) ?? [Fr.random()],
+        newContractData: times(MAX_NEW_CONTRACTS_PER_TX, getMockContractData),
+        newPublicDataWrites: times(MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite.random),
+        newL1ToL2Messages: getMockL1ToL2MessagesData(),
+        newL2ToL1Msgs: times(MAX_NEW_L2_TO_L1_MSGS_PER_CALL, Fr.random),
+        newEncryptedLogs,
+    });
+    return block;
+};
+const createSynchroniser = (merkleTreeDb, rollupSource, blockCheckInterval = 100) => {
+    const worldStateConfig = {
+        worldStateBlockCheckIntervalMS: blockCheckInterval,
+        l2QueueSize: 1000,
+    };
+    return new ServerWorldStateSynchroniser(merkleTreeDb, rollupSource, worldStateConfig);
+};
+const log = createDebugLogger('aztec:server_world_state_synchroniser_test');
+describe('server_world_state_synchroniser', () => {
+    const rollupSource = {
+        getBlockNumber: jest.fn().mockImplementation(getLatestBlockNumber),
+        getL2Blocks: jest.fn().mockImplementation(consumeNextBlocks),
+    };
+    const merkleTreeDb = {
+        getTreeInfo: jest
+            .fn()
+            .mockImplementation(() => Promise.resolve({ treeId: MerkleTreeId.CONTRACT_TREE, root: Buffer.alloc(32, 0), size: 0n })),
+        appendLeaves: jest.fn().mockImplementation(() => Promise.resolve()),
+        updateLeaf: jest.fn().mockImplementation(() => Promise.resolve()),
+        getSiblingPath: jest.fn().mockImplementation(() => {
+            return async () => {
+                const wasm = await CircuitsWasm.get();
+                const pedersen = new Pedersen(wasm);
+                SiblingPath.ZERO(32, INITIAL_LEAF, pedersen);
+            }; //Promise.resolve();
+        }),
+        updateHistoricBlocksTree: jest.fn().mockImplementation(() => Promise.resolve()),
+        commit: jest.fn().mockImplementation(() => Promise.resolve()),
+        rollback: jest.fn().mockImplementation(() => Promise.resolve()),
+        handleL2Block: jest.fn().mockImplementation(() => Promise.resolve()),
+        stop: jest.fn().mockImplementation(() => Promise.resolve()),
+    };
+    const performInitialSync = async (server) => {
+        // test initial state
+        let status = await server.status();
+        expect(status.syncedToL2Block).toEqual(0);
+        expect(status.state).toEqual(WorldStateRunningState.IDLE);
+        // create the initial blocks
+        nextBlocks = Array(LATEST_BLOCK_NUMBER)
+            .fill(0)
+            .map((_, index) => getMockBlock(index + 1));
+        // start the sync process and await it
+        await server.start().catch(err => log.error('Sync not completed: ', err));
+        status = await server.status();
+        expect(status.syncedToL2Block).toBe(LATEST_BLOCK_NUMBER);
+    };
+    it('can be constructed', () => {
+        expect(() => createSynchroniser(merkleTreeDb, rollupSource)).not.toThrow();
+    });
+    it('updates sync progress', async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource);
+        // test initial state
+        let status = await server.status();
+        expect(status.syncedToL2Block).toEqual(0);
+        expect(status.state).toEqual(WorldStateRunningState.IDLE);
+        // create an initial block
+        let currentBlockNumber = 0;
+        nextBlocks = [getMockBlock(currentBlockNumber + 1)];
+        // start the sync process but don't await
+        server.start().catch(err => log.error('Sync not completed: ', err));
+        // now setup a loop to monitor the sync progress and push new blocks in
+        while (currentBlockNumber <= LATEST_BLOCK_NUMBER) {
+            status = await server.status();
+            expect(status.syncedToL2Block >= currentBlockNumber || status.syncedToL2Block <= currentBlockNumber + 1).toBeTruthy();
+            if (status.syncedToL2Block === LATEST_BLOCK_NUMBER) {
+                break;
+            }
+            expect(status.state >= WorldStateRunningState.IDLE || status.state <= WorldStateRunningState.SYNCHING).toBeTruthy();
+            if (status.syncedToL2Block === currentBlockNumber) {
+                await sleep(100);
+                continue;
+            }
+            currentBlockNumber++;
+            nextBlocks = [getMockBlock(currentBlockNumber + 1)];
+        }
+        // check the status agian, should be fully synced
+        status = await server.status();
+        expect(status.state).toEqual(WorldStateRunningState.RUNNING);
+        expect(status.syncedToL2Block).toEqual(LATEST_BLOCK_NUMBER);
+        // stop the synchroniser
+        await server.stop();
+        // check the final status
+        status = await server.status();
+        expect(status.state).toEqual(WorldStateRunningState.STOPPED);
+        expect(status.syncedToL2Block).toEqual(LATEST_BLOCK_NUMBER);
+    });
+    it('enables blocking until synced', async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource);
+        let currentBlockNumber = 0;
+        const newBlocks = async () => {
+            while (currentBlockNumber <= LATEST_BLOCK_NUMBER) {
+                await sleep(100);
+                nextBlocks = [...nextBlocks, getMockBlock(++currentBlockNumber)];
+            }
+        };
+        // kick off the background queueing of blocks
+        const newBlockPromise = newBlocks();
+        // kick off the synching
+        const syncPromise = server.start();
+        // await the synching
+        await syncPromise;
+        await newBlockPromise;
+        let status = await server.status();
+        expect(status.state).toEqual(WorldStateRunningState.RUNNING);
+        expect(status.syncedToL2Block).toEqual(LATEST_BLOCK_NUMBER);
+        await server.stop();
+        status = await server.status();
+        expect(status.state).toEqual(WorldStateRunningState.STOPPED);
+        expect(status.syncedToL2Block).toEqual(LATEST_BLOCK_NUMBER);
+    });
+    it('handles multiple calls to start', async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource);
+        let currentBlockNumber = 0;
+        const newBlocks = async () => {
+            while (currentBlockNumber < LATEST_BLOCK_NUMBER) {
+                await sleep(100);
+                const newBlock = getMockBlock(++currentBlockNumber);
+                nextBlocks = [...nextBlocks, newBlock];
+            }
+        };
+        // kick off the background queueing of blocks
+        const newBlockPromise = newBlocks();
+        // kick off the synching
+        await server.start();
+        // call start again, should get back the same promise
+        await server.start();
+        // wait until the block production has finished
+        await newBlockPromise;
+        await server.stop();
+    });
+    it('immediately syncs if no new blocks', async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource);
+        rollupSource.getBlockNumber.mockImplementationOnce(() => {
+            return Promise.resolve(0);
+        });
+        // kick off the synching
+        const syncPromise = server.start();
+        // it should already be synced, no need to push new blocks
+        await syncPromise;
+        const status = await server.status();
+        expect(status.state).toBe(WorldStateRunningState.RUNNING);
+        expect(status.syncedToL2Block).toBe(0);
+        await server.stop();
+    });
+    it("can't be started if already stopped", async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource);
+        rollupSource.getBlockNumber.mockImplementationOnce(() => {
+            return Promise.resolve(0);
+        });
+        // kick off the synching
+        const syncPromise = server.start();
+        await syncPromise;
+        await server.stop();
+        await expect(server.start()).rejects.toThrow();
+    });
+    it('adds the received L2 blocks', async () => {
+        merkleTreeDb.handleL2Block.mockReset();
+        const server = createSynchroniser(merkleTreeDb, rollupSource);
+        const totalBlocks = LATEST_BLOCK_NUMBER + 1;
+        nextBlocks = Array(totalBlocks)
+            .fill(0)
+            .map((_, index) => getMockBlock(index, [Buffer.alloc(32, index)]));
+        // sync the server
+        await server.start();
+        expect(merkleTreeDb.handleL2Block).toHaveBeenCalledTimes(totalBlocks);
+        await server.stop();
+    });
+    it('can immediately sync to latest', async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource, 10000);
+        await performInitialSync(server);
+        // the server should now be asleep for a long time
+        // we will add a new block and force an immediate sync
+        nextBlocks = [getMockBlock(LATEST_BLOCK_NUMBER + 1)];
+        await server.syncImmediate();
+        let status = await server.status();
+        expect(status.syncedToL2Block).toBe(LATEST_BLOCK_NUMBER + 1);
+        nextBlocks = [getMockBlock(LATEST_BLOCK_NUMBER + 2), getMockBlock(LATEST_BLOCK_NUMBER + 3)];
+        await server.syncImmediate();
+        status = await server.status();
+        expect(status.syncedToL2Block).toBe(LATEST_BLOCK_NUMBER + 3);
+        // stop the synchroniser
+        await server.stop();
+        // check the final status
+        status = await server.status();
+        expect(status.state).toEqual(WorldStateRunningState.STOPPED);
+        expect(status.syncedToL2Block).toEqual(LATEST_BLOCK_NUMBER + 3);
+    });
+    it('can immediately sync to a minimum block number', async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource, 10000);
+        await performInitialSync(server);
+        // the server should now be asleep for a long time
+        // we will add 20 blocks and force a sync to at least LATEST + 5
+        nextBlocks = Array(20)
+            .fill(0)
+            .map((_, index) => getMockBlock(index + 1 + LATEST_BLOCK_NUMBER));
+        await server.syncImmediate(LATEST_BLOCK_NUMBER + 5);
+        // we should have synced all of the blocks
+        let status = await server.status();
+        expect(status.syncedToL2Block).toBe(LATEST_BLOCK_NUMBER + 20);
+        // stop the synchroniser
+        await server.stop();
+        // check the final status
+        status = await server.status();
+        expect(status.state).toEqual(WorldStateRunningState.STOPPED);
+        expect(status.syncedToL2Block).toEqual(LATEST_BLOCK_NUMBER + 20);
+    });
+    it('can immediately sync to a minimum block in the past', async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource, 10000);
+        await performInitialSync(server);
+        // syncing to a block in the past should succeed
+        await server.syncImmediate(LATEST_BLOCK_NUMBER - 1);
+        // syncing to the current block should succeed
+        await server.syncImmediate(LATEST_BLOCK_NUMBER);
+        // we should have synced all of the blocks
+        let status = await server.status();
+        expect(status.syncedToL2Block).toBe(LATEST_BLOCK_NUMBER);
+        // stop the synchroniser
+        await server.stop();
+        // check the final status
+        status = await server.status();
+        expect(status.state).toEqual(WorldStateRunningState.STOPPED);
+        expect(status.syncedToL2Block).toEqual(LATEST_BLOCK_NUMBER);
+    });
+    it('throws if you try to sync to an unavailable block', async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource, 10000);
+        await performInitialSync(server);
+        // the server should now be asleep for a long time
+        // we will add 2 blocks and force a sync to at least LATEST + 5
+        nextBlocks = Array(2)
+            .fill(0)
+            .map((_, index) => getMockBlock(index + 1 + LATEST_BLOCK_NUMBER));
+        await expect(server.syncImmediate(LATEST_BLOCK_NUMBER + 5)).rejects.toThrow(`Unable to sync to block number ${LATEST_BLOCK_NUMBER + 5}, currently synced to block ${LATEST_BLOCK_NUMBER + 2}`);
+        let status = await server.status();
+        expect(status.syncedToL2Block).toBe(LATEST_BLOCK_NUMBER + 2);
+        // stop the synchroniser
+        await server.stop();
+        // check the final status
+        status = await server.status();
+        expect(status.state).toEqual(WorldStateRunningState.STOPPED);
+        expect(status.syncedToL2Block).toEqual(LATEST_BLOCK_NUMBER + 2);
+    });
+    it('throws if you try to immediate sync when not running', async () => {
+        const server = createSynchroniser(merkleTreeDb, rollupSource, 10000);
+        // test initial state
+        const status = await server.status();
+        expect(status.syncedToL2Block).toEqual(0);
+        expect(status.state).toEqual(WorldStateRunningState.IDLE);
+        // create an initial block
+        nextBlocks = Array(LATEST_BLOCK_NUMBER)
+            .fill(0)
+            .map((_, index) => getMockBlock(index + 1));
+        await expect(server.syncImmediate()).rejects.toThrow(`World State is not running, unable to perform sync`);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server_world_state_synchroniser.test.js","sourceRoot":"","sources":["../../src/synchroniser/server_world_state_synchroniser.test.ts"],"names":[],"mappings":"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"}

package/dest/synchroniser/world_state_synchroniser.d.ts

@@ -0,0 +1,59 @@
+import { MerkleTreeOperations } from '../index.js';
+/**
+ * Defines the possible states of the world state synchroniser.
+ */
+export declare enum WorldStateRunningState {
+    IDLE = 0,
+    SYNCHING = 1,
+    RUNNING = 2,
+    STOPPED = 3
+}
+/**
+ * Defines the status of the world state synchroniser.
+ */
+export interface WorldStateStatus {
+    /**
+     * The current state of the world state synchroniser.
+     */
+    state: WorldStateRunningState;
+    /**
+     * The block number that the world state synchroniser is synced to.
+     */
+    syncedToL2Block: number;
+}
+/**
+ * Defines the interface for a world state synchroniser.
+ */
+export interface WorldStateSynchroniser {
+    /**
+     * Starts the synchroniser.
+     * @returns A promise that resolves once the initial sync is completed.
+     */
+    start(): void;
+    /**
+     * Returns the current status of the synchroniser.
+     * @returns The current status of the synchroniser.
+     */
+    status(): Promise<WorldStateStatus>;
+    /**
+     * Stops the synchroniser.
+     */
+    stop(): Promise<void>;
+    /**
+     * Forces an immediate sync to an optionally provided minimum block number
+     * @param minBlockNumber - The minimum block number that we must sync to
+     * @returns A promise that resolves once the sync has completed.
+     */
+    syncImmediate(minBlockNumber?: number): Promise<void>;
+    /**
+     * Returns an instance of MerkleTreeOperations that will include uncommitted data.
+     * @returns An instance of MerkleTreeOperations that will include uncommitted data.
+     */
+    getLatest(): MerkleTreeOperations;
+    /**
+     * Returns an instance of MerkleTreeOperations that will not include uncommitted data.
+     * @returns An instance of MerkleTreeOperations that will not include uncommitted data.
+     */
+    getCommitted(): MerkleTreeOperations;
+}
+//# sourceMappingURL=world_state_synchroniser.d.ts.map

package/dest/synchroniser/world_state_synchroniser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world_state_synchroniser.d.ts","sourceRoot":"","sources":["../../src/synchroniser/world_state_synchroniser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnD;;GAEG;AACH,oBAAY,sBAAsB;IAChC,IAAI,IAAA;IACJ,QAAQ,IAAA;IACR,OAAO,IAAA;IACP,OAAO,IAAA;CACR;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,KAAK,EAAE,sBAAsB,CAAC;IAC9B;;OAEG;IACH,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;OAGG;IACH,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEpC;;OAEG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtB;;;;OAIG;IACH,aAAa,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtD;;;OAGG;IACH,SAAS,IAAI,oBAAoB,CAAC;IAElC;;;OAGG;IACH,YAAY,IAAI,oBAAoB,CAAC;CACtC"}