@aztec-labs/simulator 6.0.0-nightly.20260829

package/dest/public/public_db_sources.js

@@ -0,0 +1,297 @@
+import { L1_TO_L2_MSG_TREE_LEAF_COUNT, NOTE_HASH_TREE_LEAF_COUNT, NULLIFIER_SUBTREE_HEIGHT, PUBLIC_DATA_SUBTREE_HEIGHT } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { Timer } from '@aztec-labs/foundation/timer';
+import { ContractClassPublishedEvent } from '@aztec-labs/protocol-contracts/class-registry';
+import { ContractInstancePublishedEvent } from '@aztec-labs/protocol-contracts/instance-registry';
+import { PublicDataWrite } from '@aztec-labs/stdlib/avm';
+import { AllContractDeploymentData, computePublicBytecodeCommitment } from '@aztec-labs/stdlib/contract';
+import { computePublicDataTreeLeafSlot } from '@aztec-labs/stdlib/hash';
+import { MerkleTreeId, NullifierLeaf, PublicDataTreeLeaf, getTreeName } from '@aztec-labs/stdlib/trees';
+import { TreeSnapshots } from '@aztec-labs/stdlib/tx';
+import { strict as assert } from 'assert';
+import { ContractsDbCheckpoint } from './contracts_db_checkpoint.js';
+import { L1ToL2MessageIndexOutOfRangeError, NoteHashIndexOutOfRangeError } from './side_effect_errors.js';
+/**
+ * Implements the PublicContractsDBInterface using a ContractDataSource.
+ * Uses a stack-based checkpoint model for managing contract state.
+ */ export class PublicContractsDB {
+    dataSource;
+    contractStateStack;
+    log;
+    constructor(dataSource, bindings){
+        this.dataSource = dataSource;
+        this.contractStateStack = [
+            new ContractsDbCheckpoint()
+        ];
+        this.log = createLogger('simulator:contracts-data-source', bindings);
+    }
+    /** Parses raw contract deployment data and inserts the resulting contracts into the current checkpoint. */ addContractsFromLogs(contractDeploymentData) {
+        const currentState = this.getCurrentState();
+        this.addContractClassesFromEvents(ContractClassPublishedEvent.extractContractClassEvents(contractDeploymentData.getContractClassLogs()), currentState);
+        this.addContractInstancesFromEvents(ContractInstancePublishedEvent.extractContractInstanceEvents(contractDeploymentData.getPrivateLogs()), currentState);
+    }
+    addNewContracts(tx) {
+        const contractDeploymentData = AllContractDeploymentData.fromTx(tx);
+        this.addContractsFromLogs(contractDeploymentData.getNonRevertibleContractDeploymentData());
+        this.addContractsFromLogs(contractDeploymentData.getRevertibleContractDeploymentData());
+    }
+    /** Inserts typed contract instances directly into the current checkpoint. */ addContracts(contractInstances) {
+        const currentState = this.getCurrentState();
+        for (const instance of contractInstances ?? []){
+            currentState.addInstance(instance.address, instance);
+        }
+    }
+    /**
+   * Creates a new checkpoint, copying the current state for upcoming modifications,
+   * and enabling rollbacks to current state in case of a revert.
+   */ createCheckpoint() {
+        const currentState = this.getCurrentState();
+        const newState = currentState.fork();
+        this.contractStateStack.push(newState);
+    }
+    /**
+   * Commits the current checkpoint, accepting its state latest.
+   */ commitCheckpoint() {
+        if (this.contractStateStack.length <= 1) {
+            throw new Error('No checkpoint to commit');
+        }
+        const topState = this.contractStateStack.pop();
+        this.contractStateStack[this.contractStateStack.length - 1] = topState;
+    }
+    /**
+   * Commits the current checkpoint, not erroring if there is no checkpoint
+   * to commit. This is useful to do a sanity commit at the end of tx execution,
+   * doing nothing if the checkpoint was already reverted, but truly committing
+   * otherwise.
+   */ commitCheckpointOkIfNone() {
+        if (this.contractStateStack.length <= 1) {
+            return;
+        }
+        const topState = this.contractStateStack.pop();
+        this.contractStateStack[this.contractStateStack.length - 1] = topState;
+    }
+    /**
+   * Reverts the current checkpoint, discarding its state and rolling back
+   * to the state as of the latest checkpoint.
+   */ revertCheckpoint() {
+        if (this.contractStateStack.length <= 1) {
+            throw new Error('No checkpoint to revert');
+        }
+        this.contractStateStack.pop();
+    }
+    getCurrentState() {
+        return this.contractStateStack[this.contractStateStack.length - 1];
+    }
+    // TODO(fcarreiro/alvaro): This method currently needs a blockNumber. Since this class
+    // is only ever used for a given block, it should be possible to construct it with the
+    // block number and then forget about it. However, since this class (and interface) is
+    // currently more externally exposed than we'd want to, Facundo preferred to not add it
+    // to the constructor right now. If we can make this class more private, we should
+    // reconsider this. A litmus test is in how many places we need to initialize with a
+    // dummy block number (tests or not) and pass block numbers to `super`.
+    // Note: Block number got changed to timestamp so this comment ^ is outdated. Keeping
+    // the comment as is as I am not part of the AVM cabal.
+    async getContractInstance(address, timestamp) {
+        const currentState = this.getCurrentState();
+        return currentState.getInstance(address) ?? await this.dataSource.getContract(address, timestamp);
+    }
+    async getContractClass(contractClassId) {
+        const currentState = this.getCurrentState();
+        return currentState.getClass(contractClassId) ?? await this.dataSource.getContractClass(contractClassId);
+    }
+    async getBytecodeCommitment(contractClassId) {
+        const currentState = this.getCurrentState();
+        const commitment = currentState.getBytecodeCommitment(contractClassId) ?? await this.dataSource.getBytecodeCommitment(contractClassId);
+        if (commitment !== undefined) {
+            return commitment;
+        }
+        // Not in the current state or the store, compute it here
+        // Get the contract class
+        const contractClass = await this.getContractClass(contractClassId);
+        if (contractClass === undefined) {
+            // cannot compute bytecode commitment if contract class is not found
+            return undefined;
+        }
+        const value = await computePublicBytecodeCommitment(contractClass.packedBytecode);
+        // Add to cache (current checkpoint state) so we don't compute again
+        currentState.addBytecodeCommitment(contractClassId, value);
+        return value;
+    }
+    async getDebugFunctionName(address, selector) {
+        return await this.dataSource.getDebugFunctionName(address, selector);
+    }
+    addContractClassesFromEvents(contractClassEvents, state) {
+        for (const event of contractClassEvents){
+            this.log.debug(`Adding class ${event.contractClassId.toString()} to contract state`);
+            const contractClass = event.toContractClassPublic();
+            state.addClass(event.contractClassId, contractClass);
+        }
+    }
+    addContractInstancesFromEvents(contractInstanceEvents, state) {
+        contractInstanceEvents.forEach((e)=>{
+            this.log.debug(`Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to contract state`);
+            state.addInstance(e.address, e.toContractInstance());
+        });
+    }
+}
+/**
+ * A high-level class that provides access to the merkle trees.
+ *
+ * This class is just a helper wrapper around a merkle db. Anything that you can do with it
+ * can also be done directly with the merkle db. This class should NOT be exposed or used
+ * outside of `simulator/src/public`.
+ *
+ * NOTE: This class is currently written in such a way that it would generate the
+ * necessary hints if used with a hinting merkle db. This is a bit of a leak of concepts.
+ * Eventually we can have everything depend on a config/factory at the TxSimulator level
+ * to decide whether to use hints or not (same with tracing, etc).
+ */ export class PublicTreesDB {
+    db;
+    logger;
+    constructor(db, bindings){
+        this.db = db;
+        this.logger = createLogger('simulator:public-trees-db', bindings);
+    }
+    async storageRead(contract, slot) {
+        const timer = new Timer();
+        const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
+        const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+        if (!lowLeafResult) {
+            throw new Error('Low leaf not found');
+        }
+        // TODO: We need this for the hints. See class comment for more details.
+        await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+        // Unconditionally fetching the preimage for the hints. Move it to the hinting layer?
+        const preimage = await this.db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+        const result = lowLeafResult.alreadyPresent ? preimage.leaf.value : Fr.ZERO;
+        this.logger.debug(`Storage read (contract=${contract}, slot=${slot}, value=${result})`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'storage-read'
+        });
+        return result;
+    }
+    async storageWrite(contract, slot, newValue) {
+        const timer = new Timer();
+        const leafSlot = await computePublicDataTreeLeafSlot(contract, slot);
+        const publicDataWrite = new PublicDataWrite(leafSlot, newValue);
+        await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
+            publicDataWrite.toBuffer()
+        ]);
+        this.logger.debug(`Storage write (contract=${contract}, slot=${slot}, value=${newValue})`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'storage-write'
+        });
+    }
+    async getL1ToL2LeafValue(leafIndex) {
+        const timer = new Timer();
+        if (leafIndex > L1_TO_L2_MSG_TREE_LEAF_COUNT) {
+            throw new L1ToL2MessageIndexOutOfRangeError(Number(leafIndex));
+        }
+        const leafValue = await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+        assert(leafValue !== undefined, 'Unexpected null response from l1 to l2 message tree');
+        // TODO: We need this for the hints. See class comment for more details.
+        await this.db.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+        this.logger.debug(`Fetched L1 to L2 message leaf value (leafIndex=${leafIndex}, value=${leafValue})`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'get-l1-to-l2-message-leaf-value'
+        });
+        return leafValue;
+    }
+    async getNoteHash(leafIndex) {
+        const timer = new Timer();
+        if (leafIndex > NOTE_HASH_TREE_LEAF_COUNT) {
+            throw new NoteHashIndexOutOfRangeError(Number(leafIndex));
+        }
+        const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+        assert(leafValue !== undefined, 'Unexpected null response from note hash tree');
+        // TODO: We need this for the hints. See class comment for more details.
+        await this.db.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+        this.logger.debug(`Fetched note hash leaf value (leafIndex=${leafIndex}, value=${leafValue})`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'get-note-hash'
+        });
+        return leafValue;
+    }
+    async writeNoteHash(noteHash) {
+        const timer = new Timer();
+        await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [
+            noteHash
+        ]);
+        this.logger.debug(`Wrote note hash (noteHash=${noteHash})`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'write-note-hash'
+        });
+    }
+    async checkNullifierExists(nullifier) {
+        const timer = new Timer();
+        const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
+        if (!lowLeafResult) {
+            throw new Error('Low leaf not found');
+        }
+        // TODO: We need this for the hints. See class comment for more details.
+        await this.db.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
+        // TODO: We need this for the hints. See class comment for more details.
+        await this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
+        const exists = lowLeafResult.alreadyPresent;
+        this.logger.debug(`Checked nullifier exists (nullifier=${nullifier}, exists=${exists})`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'check-nullifier-exists'
+        });
+        return exists;
+    }
+    async writeNullifier(siloedNullifier) {
+        const timer = new Timer();
+        await this.db.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [
+            siloedNullifier.toBuffer()
+        ]);
+        this.logger.debug(`Wrote nullifier (nullifier=${siloedNullifier})`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'write-nullifier'
+        });
+    }
+    async padTree(treeId, leavesToInsert) {
+        const timer = new Timer();
+        switch(treeId){
+            // Indexed trees.
+            case MerkleTreeId.NULLIFIER_TREE:
+                await this.db.batchInsert(treeId, Array(leavesToInsert).fill(NullifierLeaf.empty().toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
+                break;
+            case MerkleTreeId.PUBLIC_DATA_TREE:
+                await this.db.batchInsert(treeId, Array(leavesToInsert).fill(PublicDataTreeLeaf.empty().toBuffer()), PUBLIC_DATA_SUBTREE_HEIGHT);
+                break;
+            // Append-only trees.
+            case MerkleTreeId.L1_TO_L2_MESSAGE_TREE:
+            case MerkleTreeId.NOTE_HASH_TREE:
+                await this.db.appendLeaves(treeId, Array(leavesToInsert).fill(Fr.ZERO));
+                break;
+            default:
+                throw new Error(`Padding not supported for tree ${treeId}`);
+        }
+        this.logger.debug(`Padded tree (tree=${getTreeName(treeId)}, leavesToInsert=${leavesToInsert})`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'pad-tree'
+        });
+    }
+    async createCheckpoint() {
+        await this.db.createCheckpoint();
+    }
+    async commitCheckpoint() {
+        await this.db.commitCheckpoint();
+    }
+    async revertCheckpoint() {
+        await this.db.revertCheckpoint();
+    }
+    async getTreeSnapshots() {
+        const stateReference = await this.db.getStateReference();
+        return new TreeSnapshots(stateReference.l1ToL2MessageTree, stateReference.partial.noteHashTree, stateReference.partial.nullifierTree, stateReference.partial.publicDataTree);
+    }
+}

package/dest/public/public_errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Any known (and checked) error that can be thrown during public execution.
+ * Includes AvmExecutionErrors and SideEffectErrors.
+ *
+ * AvmSimulator catches any checked errors before returning a boolean "reverted".
+ * Unchecked errors are generally the result of a bug. They are propagated and
+ * ultimately will be the resonsibility of PublicProcessor to handle.
+ */
+export declare abstract class CheckedPublicExecutionError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2Vycm9ycy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B1YmxpYy9wdWJsaWNfZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFDSCw4QkFBc0IsMkJBQTRCLFNBQVEsS0FBSztJQUM3RCxZQUFZLE9BQU8sRUFBRSxNQUFNLEVBRzFCO0NBQ0YifQ==

package/dest/public/public_errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_errors.d.ts","sourceRoot":"","sources":["../../src/public/public_errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,8BAAsB,2BAA4B,SAAQ,KAAK;IAC7D,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF"}

package/dest/public/public_errors.js

@@ -0,0 +1,13 @@
+/**
+ * Any known (and checked) error that can be thrown during public execution.
+ * Includes AvmExecutionErrors and SideEffectErrors.
+ *
+ * AvmSimulator catches any checked errors before returning a boolean "reverted".
+ * Unchecked errors are generally the result of a bug. They are propagated and
+ * ultimately will be the resonsibility of PublicProcessor to handle.
+ */ export class CheckedPublicExecutionError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'CheckedPublicExecutionError';
+    }
+}

package/dest/public/public_processor/guarded_merkle_tree.d.ts

@@ -0,0 +1,52 @@
+import type { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import type { IndexedTreeLeafPreimage, SiblingPath } from '@aztec-labs/foundation/trees';
+import type { BatchInsertionResult, IndexedTreeId, MerkleTreeId, MerkleTreeLeafType, MerkleTreeWriteOperations, SequentialInsertionResult, TreeHeights, TreeInfo } from '@aztec-labs/stdlib/trees';
+import type { BlockHeader, StateReference } from '@aztec-labs/stdlib/tx';
+import type { WorldStateRevision } from '@aztec-labs/stdlib/world-state';
+/**
+ * Wraps an instance of `MerkleTreeWriteOperations` to allow the sequencer to gate access.
+ * If transactions execution goes past the deadline, the simulator will continue to execute and update the world state
+ * The public processor however requires that the world state remain constant after the deadline in order to finalize the block
+ * The public processor provides this implementation of MerkleTreeWriteOperations to the simulator
+ */
+export declare class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
+    private target;
+    private isStopped;
+    private serialQueue;
+    constructor(target: MerkleTreeWriteOperations);
+    private guard;
+    private guardAndPush;
+    getUnderlyingFork(): MerkleTreeWriteOperations;
+    stop(): Promise<void>;
+    appendLeaves<ID extends MerkleTreeId>(treeId: ID, leaves: MerkleTreeLeafType<ID>[]): Promise<void>;
+    updateArchive(header: BlockHeader): Promise<void>;
+    batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number, ID extends IndexedTreeId>(treeId: ID, leaves: Buffer[], subtreeHeight: number): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>>;
+    sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(treeId: ID, leaves: Buffer[]): Promise<SequentialInsertionResult<TreeHeight>>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo>;
+    getStateReference(): Promise<StateReference>;
+    getInitialHeader(): BlockHeader;
+    getRevision(): WorldStateRevision;
+    getIpcPath(): string;
+    getSiblingPath<ID extends MerkleTreeId>(treeId: ID, index: bigint): Promise<SiblingPath<TreeHeights[ID]>>;
+    getPreviousValueIndex<ID extends IndexedTreeId>(treeId: ID, value: bigint): Promise<{
+        index: bigint;
+        alreadyPresent: boolean;
+    } | undefined>;
+    getLeafPreimage<ID extends IndexedTreeId>(treeId: ID, index: bigint): Promise<IndexedTreeLeafPreimage | undefined>;
+    findLeafIndices<ID extends MerkleTreeId>(treeId: ID, values: MerkleTreeLeafType<ID>[]): Promise<(bigint | undefined)[]>;
+    findLeafIndicesAfter<ID extends MerkleTreeId>(treeId: ID, values: MerkleTreeLeafType<ID>[], startIndex: bigint): Promise<(bigint | undefined)[]>;
+    getLeafValue<ID extends MerkleTreeId>(treeId: ID, index: bigint): Promise<MerkleTreeLeafType<typeof treeId> | undefined>;
+    getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(treeId: ID, leafIndices: bigint[]): Promise<(BlockNumber | undefined)[]>;
+    createCheckpoint(): Promise<number>;
+    commitCheckpoint(): Promise<void>;
+    revertCheckpoint(): Promise<void>;
+    commitAllCheckpointsTo(depth: number): Promise<void>;
+    revertAllCheckpointsTo(depth: number): Promise<void>;
+    findSiblingPaths<ID extends MerkleTreeId>(treeId: ID, values: MerkleTreeLeafType<ID>[]): Promise<({
+        path: SiblingPath<TreeHeights[ID]>;
+        index: bigint;
+    } | undefined)[]>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3VhcmRlZF9tZXJrbGVfdHJlZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9wdWJsaWNfcHJvY2Vzc29yL2d1YXJkZWRfbWVya2xlX3RyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFFeEUsT0FBTyxLQUFLLEVBQUUsdUJBQXVCLEVBQUUsV0FBVyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDekYsT0FBTyxLQUFLLEVBQ1Ysb0JBQW9CLEVBQ3BCLGFBQWEsRUFDYixZQUFZLEVBQ1osa0JBQWtCLEVBQ2xCLHlCQUF5QixFQUN6Qix5QkFBeUIsRUFDekIsV0FBVyxFQUNYLFFBQVEsRUFDVCxNQUFNLDBCQUEwQixDQUFDO0FBQ2xDLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN6RSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpFOzs7OztHQUtHO0FBRUgscUJBQWEsMkJBQTRCLFlBQVcseUJBQXlCO0lBSS9ELE9BQU8sQ0FBQyxNQUFNO0lBSDFCLE9BQU8sQ0FBQyxTQUFTLENBQVM7SUFDMUIsT0FBTyxDQUFDLFdBQVcsQ0FBcUI7SUFFeEMsWUFBb0IsTUFBTSxFQUFFLHlCQUF5QixFQUVwRDtJQUVELE9BQU8sQ0FBQyxLQUFLO0lBT2IsT0FBTyxDQUFDLFlBQVk7SUFRYixpQkFBaUIsSUFBSSx5QkFBeUIsQ0FFcEQ7SUFHSyxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQU0xQjtJQUdELFlBQVksQ0FBQyxFQUFFLFNBQVMsWUFBWSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsTUFBTSxFQUFFLGtCQUFrQixDQUFDLEVBQUUsQ0FBQyxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUVqRztJQUVELGFBQWEsQ0FBQyxNQUFNLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFaEQ7SUFDRCxXQUFXLENBQUMsVUFBVSxTQUFTLE1BQU0sRUFBRSx3QkFBd0IsU0FBUyxNQUFNLEVBQUUsRUFBRSxTQUFTLGFBQWEsRUFDdEcsTUFBTSxFQUFFLEVBQUUsRUFDVixNQUFNLEVBQUUsTUFBTSxFQUFFLEVBQ2hCLGFBQWEsRUFBRSxNQUFNLEdBQ3BCLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQyxVQUFVLEVBQUUsd0JBQXdCLENBQUMsQ0FBQyxDQUVyRTtJQUNELGdCQUFnQixDQUFDLFVBQVUsU0FBUyxNQUFNLEVBQUUsRUFBRSxTQUFTLGFBQWEsRUFDbEUsTUFBTSxFQUFFLEVBQUUsRUFDVixNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQ2YsT0FBTyxDQUFDLHlCQUF5QixDQUFDLFVBQVUsQ0FBQyxDQUFDLENBRWhEO0lBQ0QsS0FBSyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFckI7SUFFSyxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBRTNDO0lBQ0QsV0FBVyxDQUFDLE1BQU0sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUVuRDtJQUNELGlCQUFpQixJQUFJLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FFM0M7SUFDRCxnQkFBZ0IsSUFBSSxXQUFXLENBRTlCO0lBQ00sV0FBVyxJQUFJLGtCQUFrQixDQUV2QztJQUNNLFVBQVUsSUFBSSxNQUFNLENBRTFCO0lBQ0QsY0FBYyxDQUFDLEVBQUUsU0FBUyxZQUFZLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FFeEc7SUFDRCxxQkFBcUIsQ0FBQyxFQUFFLFNBQVMsYUFBYSxFQUM1QyxNQUFNLEVBQUUsRUFBRSxFQUNWLEtBQUssRUFBRSxNQUFNLEdBQ1osT0FBTyxDQUFDO1FBQUUsS0FBSyxFQUFFLE1BQU0sQ0FBQztRQUFDLGNBQWMsRUFBRSxPQUFPLENBQUE7S0FBRSxHQUFHLFNBQVMsQ0FBQyxDQUVqRTtJQUNELGVBQWUsQ0FBQyxFQUFFLFNBQVMsYUFBYSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsdUJBQXVCLEdBQUcsU0FBUyxDQUFDLENBRWpIO0lBQ0QsZUFBZSxDQUFDLEVBQUUsU0FBUyxZQUFZLEVBQ3JDLE1BQU0sRUFBRSxFQUFFLEVBQ1YsTUFBTSxFQUFFLGtCQUFrQixDQUFDLEVBQUUsQ0FBQyxFQUFFLEdBQy9CLE9BQU8sQ0FBQyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsRUFBRSxDQUFDLENBRWpDO0lBQ0Qsb0JBQW9CLENBQUMsRUFBRSxTQUFTLFlBQVksRUFDMUMsTUFBTSxFQUFFLEVBQUUsRUFDVixNQUFNLEVBQUUsa0JBQWtCLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFDaEMsVUFBVSxFQUFFLE1BQU0sR0FDakIsT0FBTyxDQUFDLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FFakM7SUFDRCxZQUFZLENBQUMsRUFBRSxTQUFTLFlBQVksRUFDbEMsTUFBTSxFQUFFLEVBQUUsRUFDVixLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLE1BQU0sQ0FBQyxHQUFHLFNBQVMsQ0FBQyxDQUV4RDtJQUNELDZCQUE2QixDQUFDLEVBQUUsU0FBUyxZQUFZLEVBQ25ELE1BQU0sRUFBRSxFQUFFLEVBQ1YsV0FBVyxFQUFFLE1BQU0sRUFBRSxHQUNwQixPQUFPLENBQUMsQ0FBQyxXQUFXLEdBQUcsU0FBUyxDQUFDLEVBQUUsQ0FBQyxDQUV0QztJQUNELGdCQUFnQixJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FFbEM7SUFDRCxnQkFBZ0IsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBRWhDO0lBQ0QsZ0JBQWdCLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUVoQztJQUNELHNCQUFzQixDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUVuRDtJQUNELHNCQUFzQixDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUVuRDtJQUNELGdCQUFnQixDQUFDLEVBQUUsU0FBUyxZQUFZLEVBQ3RDLE1BQU0sRUFBRSxFQUFFLEVBQ1YsTUFBTSxFQUFFLGtCQUFrQixDQUFDLEVBQUUsQ0FBQyxFQUFFLEdBQy9CLE9BQU8sQ0FBQyxDQUFDO1FBQUUsSUFBSSxFQUFFLFdBQVcsQ0FBQyxXQUFXLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUFDLEtBQUssRUFBRSxNQUFNLENBQUE7S0FBRSxHQUFHLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FFaEY7Q0FDRiJ9

package/dest/public/public_processor/guarded_merkle_tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guarded_merkle_tree.d.ts","sourceRoot":"","sources":["../../../src/public/public_processor/guarded_merkle_tree.ts"],"names":[],"mappings":"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"}

package/dest/public/public_processor/guarded_merkle_tree.js

@@ -0,0 +1,116 @@
+var _computedKey;
+import { SerialQueue } from '@aztec-labs/foundation/queue';
+_computedKey = Symbol.asyncDispose;
+/**
+ * Wraps an instance of `MerkleTreeWriteOperations` to allow the sequencer to gate access.
+ * If transactions execution goes past the deadline, the simulator will continue to execute and update the world state
+ * The public processor however requires that the world state remain constant after the deadline in order to finalize the block
+ * The public processor provides this implementation of MerkleTreeWriteOperations to the simulator
+ */ export class GuardedMerkleTreeOperations {
+    target;
+    isStopped;
+    serialQueue;
+    constructor(target){
+        this.target = target;
+        this.isStopped = false;
+        this.serialQueue = new SerialQueue();
+        this.serialQueue.start();
+    }
+    guard() {
+        if (this.isStopped) {
+            throw new Error('Merkle tree access has been stopped');
+        }
+    }
+    // Executes the provided function only if the guard is not stopped.
+    guardAndPush(fn) {
+        this.guard();
+        return this.serialQueue.put(()=>{
+            this.guard();
+            return fn();
+        });
+    }
+    getUnderlyingFork() {
+        return this.target;
+    }
+    // Stops all further access to the merkle trees via this object
+    async stop() {
+        await this.serialQueue.put(()=>{
+            this.isStopped = true;
+            return Promise.resolve();
+        });
+        return this.serialQueue.end();
+    }
+    // Proxy all methods to the target
+    appendLeaves(treeId, leaves) {
+        return this.guardAndPush(()=>this.target.appendLeaves(treeId, leaves));
+    }
+    updateArchive(header) {
+        return this.guardAndPush(()=>this.target.updateArchive(header));
+    }
+    batchInsert(treeId, leaves, subtreeHeight) {
+        return this.guardAndPush(()=>this.target.batchInsert(treeId, leaves, subtreeHeight));
+    }
+    sequentialInsert(treeId, leaves) {
+        return this.guardAndPush(()=>this.target.sequentialInsert(treeId, leaves));
+    }
+    close() {
+        return this.guardAndPush(()=>this.target.close());
+    }
+    async [_computedKey]() {
+        await this.close();
+    }
+    getTreeInfo(treeId) {
+        return this.guardAndPush(()=>this.target.getTreeInfo(treeId));
+    }
+    getStateReference() {
+        return this.guardAndPush(()=>this.target.getStateReference());
+    }
+    getInitialHeader() {
+        return this.target.getInitialHeader();
+    }
+    getRevision() {
+        return this.target.getRevision();
+    }
+    getIpcPath() {
+        return this.target.getIpcPath();
+    }
+    getSiblingPath(treeId, index) {
+        return this.guardAndPush(()=>this.target.getSiblingPath(treeId, index));
+    }
+    getPreviousValueIndex(treeId, value) {
+        return this.guardAndPush(()=>this.target.getPreviousValueIndex(treeId, value));
+    }
+    getLeafPreimage(treeId, index) {
+        return this.guardAndPush(()=>this.target.getLeafPreimage(treeId, index));
+    }
+    findLeafIndices(treeId, values) {
+        return this.guardAndPush(()=>this.target.findLeafIndices(treeId, values));
+    }
+    findLeafIndicesAfter(treeId, values, startIndex) {
+        return this.guardAndPush(()=>this.target.findLeafIndicesAfter(treeId, values, startIndex));
+    }
+    getLeafValue(treeId, index) {
+        return this.guardAndPush(()=>this.target.getLeafValue(treeId, index));
+    }
+    getBlockNumbersForLeafIndices(treeId, leafIndices) {
+        return this.guardAndPush(()=>this.target.getBlockNumbersForLeafIndices(treeId, leafIndices));
+    }
+    createCheckpoint() {
+        return this.guardAndPush(()=>this.target.createCheckpoint());
+    }
+    commitCheckpoint() {
+        return this.guardAndPush(()=>this.target.commitCheckpoint());
+    }
+    revertCheckpoint() {
+        return this.guardAndPush(()=>this.target.revertCheckpoint());
+    }
+    commitAllCheckpointsTo(depth) {
+        return this.guardAndPush(()=>this.target.commitAllCheckpointsTo(depth));
+    }
+    revertAllCheckpointsTo(depth) {
+        return this.guardAndPush(()=>this.target.revertAllCheckpointsTo(depth));
+    }
+    findSiblingPaths(treeId, values) {
+        return this.guardAndPush(()=>this.target.findSiblingPaths(treeId, values));
+    }
+}

package/dest/public/public_processor/public_processor.d.ts

@@ -0,0 +1,71 @@
+import { type Logger, type LoggerBindings } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { PublicSimulatorConfig } from '@aztec-labs/stdlib/avm';
+import type { ContractDataSource } from '@aztec-labs/stdlib/contract';
+import type { MerkleTreeWriteOperations, PublicProcessorLimits, PublicProcessorValidator, SequencerConfig } from '@aztec-labs/stdlib/interfaces/server';
+import { type DebugLog, type DebugLogStore } from '@aztec-labs/stdlib/logs';
+import { type FailedTx, GlobalVariables, NestedProcessReturnValues, type ProcessedTx, Tx } from '@aztec-labs/stdlib/tx';
+import { type TelemetryClient, type Traceable, type Tracer } from '@aztec-labs/telemetry-client';
+import type { AvmSimulator } from '../avm_simulator.js';
+import { PublicContractsDB } from '../public_db_sources.js';
+import { type PublicTxSimulatorConfig, type PublicTxSimulatorInterface } from '../public_tx_simulator/index.js';
+import { GuardedMerkleTreeOperations } from './guarded_merkle_tree.js';
+/**
+ * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
+ */
+export declare class PublicProcessorFactory {
+    private contractDataSource;
+    private avmSimulator;
+    private dateProvider;
+    protected telemetryClient: TelemetryClient;
+    private log;
+    constructor(contractDataSource: ContractDataSource, avmSimulator: AvmSimulator, dateProvider?: DateProvider, telemetryClient?: TelemetryClient, bindings?: LoggerBindings);
+    /**
+     * Creates a new instance of a PublicProcessor. The simulator it drives reads contract data from the fork's
+     * contracts DB, scoped by the fork id so AVM requests route to the right state.
+     *
+     * @param globalVariables - The global variables for the block being processed.
+     * @param contractsDB - Optional pre-populated contracts DB; a fresh one is constructed if omitted.
+     * @returns A new instance of a PublicProcessor.
+     */
+    create(merkleTree: MerkleTreeWriteOperations, globalVariables: GlobalVariables, config: PublicSimulatorConfig, contractsDB?: PublicContractsDB): PublicProcessor;
+    protected createPublicTxSimulator(forkId: number, globalVariables: GlobalVariables, contractsDB: PublicContractsDB, config?: Partial<PublicTxSimulatorConfig>): PublicTxSimulatorInterface;
+}
+/**
+ * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
+ * any public function calls in them. Txs with private calls only are unaffected.
+ */
+export declare class PublicProcessor implements Traceable {
+    protected globalVariables: GlobalVariables;
+    private guardedMerkleTree;
+    protected contractsDB: PublicContractsDB;
+    protected publicTxSimulator: PublicTxSimulatorInterface;
+    private dateProvider;
+    private log;
+    private opts;
+    private debugLogStore;
+    private metrics;
+    constructor(globalVariables: GlobalVariables, guardedMerkleTree: GuardedMerkleTreeOperations, contractsDB: PublicContractsDB, publicTxSimulator: PublicTxSimulatorInterface, dateProvider: DateProvider, telemetryClient: TelemetryClient | undefined, log: Logger, opts?: Pick<SequencerConfig, 'fakeProcessingDelayPerTxMs' | 'fakeThrowAfterProcessingTxCount'>, debugLogStore?: DebugLogStore);
+    get tracer(): Tracer;
+    /**
+     * Run each tx through the public circuit and the public kernel circuit if needed.
+     * @param txs - Txs to process.
+     * @param limits - Limits for processing the txs.
+     * @param validator - Pre-process validator and nullifier cache to use for processing the txs.
+     * @returns The list of processed txs with their circuit simulation outputs.
+     */
+    process(txs: Iterable<Tx> | AsyncIterable<Tx>, limits?: PublicProcessorLimits, validator?: PublicProcessorValidator): Promise<[ProcessedTx[], FailedTx[], Tx[], NestedProcessReturnValues[], DebugLog[]]>;
+    private checkWorldStateUnchanged;
+    private processTx;
+    private doTreeInsertionsForPrivateOnlyTx;
+    private processTxWithinDeadline;
+    private getProcessingSignal;
+    private performFeePaymentPublicDataWrite;
+    private processPrivateOnlyTx;
+    private processTxWithPublicCalls;
+    /**
+     * Generate the proving request for the AVM circuit.
+     */
+    private static generateProvingRequest;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/public/public_processor/public_processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_processor.d.ts","sourceRoot":"","sources":["../../../src/public/public_processor/public_processor.ts"],"names":[],"mappings":"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"}