@aztec/world-state 0.1.0-alpha11

package/dest/synchroniser/server_world_state_synchroniser.d.ts

@@ -0,0 +1,62 @@
+import { L2BlockSource } from '@aztec/types';
+import { MerkleTreeDb, MerkleTreeOperations } from '../index.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 stopping;
+    private runningPromise;
+    private currentState;
+    constructor(merkleTreeDb: MerkleTreeDb, l2BlockSource: L2BlockSource, log?: import("@aztec/foundation/log").DebugLogger);
+    /**
+     * 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;
+    /**
+     * Starts the synchroniser.
+     * @returns A promise that resolves once the initial sync is completed.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the synchroniser.
+     */
+    stop(): Promise<void>;
+    /**
+     * Returns the current status of the synchroniser.
+     * @returns The current status of the synchroniser.
+     */
+    status(): Promise<WorldStateStatus>;
+    /**
+     * 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":"AAAA,OAAO,EAA8B,aAAa,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,EAA0B,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAIjH;;;;GAIG;AACH,qBAAa,4BAA6B,YAAW,sBAAsB;IAWvE,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,GAAG;IAZb,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,wBAAwB,CAAK;IACrC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,WAAW,CAAC,CAAyB;IAC7C,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,YAAY,CAAuD;gBAGjE,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,aAAa,EAC5B,GAAG,8CAAyC;IAMtD;;;OAGG;IACI,SAAS,IAAI,oBAAoB;IAIxC;;;OAGG;IACI,YAAY,IAAI,oBAAoB;IAI3C;;;OAGG;IACU,KAAK;IAwClB;;OAEG;IACU,IAAI;IAQjB;;;OAGG;IACI,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAQ1C;;;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,134 @@
+import { L2BlockDownloader } from '@aztec/types';
+import { MerkleTreeOperationsFacade } from '../merkle-tree/merkle_tree_operations_facade.js';
+import { WorldStateRunningState } from './world_state_synchroniser.js';
+import { getConfigEnvVars } from './config.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+/**
+ * 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, 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.stopping = false;
+        this.runningPromise = Promise.resolve();
+        this.currentState = WorldStateRunningState.IDLE;
+        const config = getConfigEnvVars();
+        this.l2BlockDownloader = new L2BlockDownloader(l2BlockSource, config.l2QueueSize, config.checkInterval);
+    }
+    /**
+     * Returns an instance of MerkleTreeOperations that will include uncommitted data.
+     * @returns An instance of MerkleTreeOperations that will include uncommitted data.
+     */
+    getLatest() {
+        return new MerkleTreeOperationsFacade(this.merkleTreeDb, true);
+    }
+    /**
+     * Returns an instance of MerkleTreeOperations that will not include uncommitted data.
+     * @returns An instance of MerkleTreeOperations that will not include uncommitted data.
+     */
+    getCommitted() {
+        return new MerkleTreeOperationsFacade(this.merkleTreeDb, false);
+    }
+    /**
+     * Starts the synchroniser.
+     * @returns A promise that resolves once the initial sync is completed.
+     */
+    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.getBlockHeight();
+        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) {
+                const blocks = await this.l2BlockDownloader.getL2Blocks();
+                await this.handleL2Blocks(blocks);
+            }
+        };
+        this.runningPromise = blockProcess();
+        this.l2BlockDownloader.start(blockToDownloadFrom);
+        this.log(`Started block downloader from block ${blockToDownloadFrom}`);
+        return this.syncPromise;
+    }
+    /**
+     * Stops the synchroniser.
+     */
+    async stop() {
+        this.log('Stopping world state...');
+        this.stopping = true;
+        await this.l2BlockDownloader.stop();
+        await this.runningPromise;
+        this.setCurrentState(WorldStateRunningState.STOPPED);
+    }
+    /**
+     * Returns the current status of the synchroniser.
+     * @returns The current status of the synchroniser.
+     */
+    status() {
+        const status = {
+            syncedToL2Block: this.currentL2BlockNum,
+            state: this.currentState,
+        };
+        return Promise.resolve(status);
+    }
+    /**
+     * 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,215 @@
+import { AppendOnlyTreeSnapshot, CircuitsWasm, GlobalVariables, KERNEL_NEW_COMMITMENTS_LENGTH, KERNEL_NEW_CONTRACTS_LENGTH, KERNEL_NEW_NULLIFIERS_LENGTH, KERNEL_PUBLIC_DATA_UPDATE_REQUESTS_LENGTH, NEW_L2_TO_L1_MSGS_LENGTH, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, } from '@aztec/circuits.js';
+import { INITIAL_LEAF, Pedersen, SiblingPath } from '@aztec/merkle-tree';
+import { ContractData, L2Block, L2BlockL2Logs, MerkleTreeId, PublicDataWrite } from '@aztec/types';
+import { jest } from '@jest/globals';
+import { ServerWorldStateSynchroniser } from './server_world_state_synchroniser.js';
+import { WorldStateRunningState } from './world_state_synchroniser.js';
+import { Fr } from '@aztec/foundation/fields';
+import { sleep } from '@aztec/foundation/sleep';
+import { createLogger } from '@aztec/foundation/log';
+import times from 'lodash.times';
+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(),
+        startTreeOfHistoricPrivateDataTreeRootsSnapshot: getMockTreeSnapshot(),
+        startTreeOfHistoricContractTreeRootsSnapshot: getMockTreeSnapshot(),
+        startPublicDataTreeRoot: Fr.random(),
+        startL1ToL2MessageTreeSnapshot: getMockTreeSnapshot(),
+        startTreeOfHistoricL1ToL2MessageTreeRootsSnapshot: getMockTreeSnapshot(),
+        endPrivateDataTreeSnapshot: getMockTreeSnapshot(),
+        endNullifierTreeSnapshot: getMockTreeSnapshot(),
+        endContractTreeSnapshot: getMockTreeSnapshot(),
+        endTreeOfHistoricPrivateDataTreeRootsSnapshot: getMockTreeSnapshot(),
+        endTreeOfHistoricContractTreeRootsSnapshot: getMockTreeSnapshot(),
+        endPublicDataTreeRoot: Fr.random(),
+        endL1ToL2MessageTreeSnapshot: getMockTreeSnapshot(),
+        endTreeOfHistoricL1ToL2MessageTreeRootsSnapshot: getMockTreeSnapshot(),
+        newCommitments: times(KERNEL_NEW_COMMITMENTS_LENGTH, Fr.random),
+        newNullifiers: times(KERNEL_NEW_NULLIFIERS_LENGTH, Fr.random),
+        newContracts: newContractsCommitments?.map(x => Fr.fromBuffer(x)) ?? [Fr.random()],
+        newContractData: times(KERNEL_NEW_CONTRACTS_LENGTH, getMockContractData),
+        newPublicDataWrites: times(KERNEL_PUBLIC_DATA_UPDATE_REQUESTS_LENGTH, PublicDataWrite.random),
+        newL1ToL2Messages: getMockL1ToL2MessagesData(),
+        newL2ToL1Msgs: times(NEW_L2_TO_L1_MSGS_LENGTH, Fr.random),
+        newEncryptedLogs,
+    });
+    return block;
+};
+const createSynchroniser = (merkleTreeDb, rollupSource) => new ServerWorldStateSynchroniser(merkleTreeDb, rollupSource);
+const log = createLogger('aztec:server_world_state_synchroniser_test');
+describe('server_world_state_synchroniser', () => {
+    const rollupSource = {
+        getBlockHeight: 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();
+        }),
+        updateHistoricRootsTrees: jest.fn().mockImplementation(() => Promise.resolve()),
+        commit: jest.fn().mockImplementation(() => Promise.resolve()),
+        rollback: jest.fn().mockImplementation(() => Promise.resolve()),
+        handleL2Block: jest.fn().mockImplementation(() => Promise.resolve()),
+    };
+    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('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.getBlockHeight.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.getBlockHeight.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();
+    });
+});
+//# 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,34 @@
+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 {
+    start(): void;
+    status(): Promise<WorldStateStatus>;
+    stop(): Promise<void>;
+    getLatest(): MerkleTreeOperations;
+    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,KAAK,IAAI,IAAI,CAAC;IACd,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACpC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,SAAS,IAAI,oBAAoB,CAAC;IAClC,YAAY,IAAI,oBAAoB,CAAC;CACtC"}

package/dest/synchroniser/world_state_synchroniser.js

@@ -0,0 +1,11 @@
+/**
+ * Defines the possible states of the world state synchroniser.
+ */
+export var WorldStateRunningState;
+(function (WorldStateRunningState) {
+    WorldStateRunningState[WorldStateRunningState["IDLE"] = 0] = "IDLE";
+    WorldStateRunningState[WorldStateRunningState["SYNCHING"] = 1] = "SYNCHING";
+    WorldStateRunningState[WorldStateRunningState["RUNNING"] = 2] = "RUNNING";
+    WorldStateRunningState[WorldStateRunningState["STOPPED"] = 3] = "STOPPED";
+})(WorldStateRunningState || (WorldStateRunningState = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGRfc3RhdGVfc3luY2hyb25pc2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N5bmNocm9uaXNlci93b3JsZF9zdGF0ZV9zeW5jaHJvbmlzZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBWSxzQkFLWDtBQUxELFdBQVksc0JBQXNCO0lBQ2hDLG1FQUFJLENBQUE7SUFDSiwyRUFBUSxDQUFBO0lBQ1IseUVBQU8sQ0FBQTtJQUNQLHlFQUFPLENBQUE7QUFDVCxDQUFDLEVBTFcsc0JBQXNCLEtBQXRCLHNCQUFzQixRQUtqQyJ9

package/dest/utils.d.ts

@@ -0,0 +1,12 @@
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+import { IWasmModule } from '@aztec/foundation/wasm';
+/**
+ * Computes the index in the public data tree for a given contract and storage slot.
+ * @param contract - Address of the contract who owns the storage.
+ * @param slot - Slot within the contract storage.
+ * @param bbWasm - Wasm module for computing the hash.
+ * @returns The leaf index of the public data tree that maps to this storage slot.
+ */
+export declare function computePublicDataTreeLeafIndex(contract: AztecAddress, slot: Fr, wasm: IWasmModule): bigint;
+//# sourceMappingURL=utils.d.ts.map

package/dest/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAQ1G"}

package/dest/utils.js

@@ -0,0 +1,14 @@
+import { GeneratorIndex } from '@aztec/circuits.js';
+import { pedersenCompressWithHashIndex } from '@aztec/circuits.js/barretenberg';
+import { toBigInt } from '@aztec/foundation/serialize';
+/**
+ * Computes the index in the public data tree for a given contract and storage slot.
+ * @param contract - Address of the contract who owns the storage.
+ * @param slot - Slot within the contract storage.
+ * @param bbWasm - Wasm module for computing the hash.
+ * @returns The leaf index of the public data tree that maps to this storage slot.
+ */
+export function computePublicDataTreeLeafIndex(contract, slot, wasm) {
+    return toBigInt(pedersenCompressWithHashIndex(wasm, [contract, slot].map(f => f.toBuffer()), GeneratorIndex.PUBLIC_LEAF_INDEX));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3BELE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBR2hGLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUl2RDs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsOEJBQThCLENBQUMsUUFBc0IsRUFBRSxJQUFRLEVBQUUsSUFBaUI7SUFDaEcsT0FBTyxRQUFRLENBQ2IsNkJBQTZCLENBQzNCLElBQUksRUFDSixDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsUUFBUSxFQUFFLENBQUMsRUFDdkMsY0FBYyxDQUFDLGlCQUFpQixDQUNqQyxDQUNGLENBQUM7QUFDSixDQUFDIn0=