@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.5daedc8

package/dest/public/hinting_db_sources.js

@@ -0,0 +1,350 @@
+import { sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { AvmAppendLeavesHint, AvmBytecodeCommitmentHint, AvmCommitCheckpointHint, AvmContractClassHint, AvmContractDbCommitCheckpointHint, AvmContractDbCreateCheckpointHint, AvmContractDbRevertCheckpointHint, AvmContractInstanceHint, AvmCreateCheckpointHint, AvmDebugFunctionNameHint, AvmGetLeafPreimageHintNullifierTree, AvmGetLeafPreimageHintPublicDataTree, AvmGetLeafValueHint, AvmGetPreviousValueIndexHint, AvmGetSiblingPathHint, AvmRevertCheckpointHint, AvmSequentialInsertHintNullifierTree, AvmSequentialInsertHintPublicDataTree } from '@aztec/stdlib/avm';
+import { AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeaf, PublicDataTreeLeaf, getTreeName, merkleTreeIds } from '@aztec/stdlib/trees';
+import { TreeSnapshots } from '@aztec/stdlib/tx';
+import { strict as assert } from 'assert';
+/**
+ * A public contracts database that forwards requests and collects AVM hints.
+ */ export class HintingPublicContractsDB {
+    db;
+    hints;
+    static log = createLogger('simulator:hinting-public-contracts-db');
+    checkpointActionCounter;
+    nextCheckpointId;
+    checkpointStack;
+    constructor(db, hints){
+        this.db = db;
+        this.hints = hints;
+        this.checkpointActionCounter = 0;
+        this.nextCheckpointId = 1;
+        this.checkpointStack = [
+            0
+        ];
+    }
+    async getContractInstance(address, timestamp) {
+        const instance = await this.db.getContractInstance(address, timestamp);
+        if (instance) {
+            const hintKey = this.getHintKey();
+            this.hints.contractInstances.push(new AvmContractInstanceHint(hintKey, instance.address, instance.salt, instance.deployer, instance.currentContractClassId, instance.originalContractClassId, instance.initializationHash, instance.publicKeys));
+            HintingPublicContractsDB.log.trace(`[getContractInstance:${hintKey}] Added contract instance ${instance.address.toString()} to hints.`);
+        }
+        return instance;
+    }
+    async getContractClass(contractClassId) {
+        const contractClass = await this.db.getContractClass(contractClassId);
+        if (contractClass) {
+            const hintKey = this.getHintKey();
+            this.hints.contractClasses.push(new AvmContractClassHint(hintKey, contractClass.id, contractClass.artifactHash, contractClass.privateFunctionsRoot, contractClass.packedBytecode));
+            HintingPublicContractsDB.log.trace(`[getContractClass:${hintKey}] Added contract class ${contractClassId.toString()} to hints.`);
+        }
+        return contractClass;
+    }
+    async getBytecodeCommitment(contractClassId) {
+        const commitment = await this.db.getBytecodeCommitment(contractClassId);
+        if (commitment) {
+            const hintKey = this.getHintKey();
+            this.hints.bytecodeCommitments.push(new AvmBytecodeCommitmentHint(hintKey, contractClassId, commitment));
+            HintingPublicContractsDB.log.trace(`[getBytecodeCommitment:${hintKey}] Added bytecode commitment ${commitment.toString()} to hints for contract class ${contractClassId.toString()}.`);
+        }
+        return commitment;
+    }
+    async getDebugFunctionName(contractAddress, selector) {
+        const name = await this.db.getDebugFunctionName(contractAddress, selector);
+        if (name) {
+            HintingPublicContractsDB.log.debug(`[getDebugFunctionName] Adding debug function name ${name} to hints for contract ${contractAddress.toString()} and selector ${selector.toString()}.`);
+            // We hint selector as a field to make things way simpler in C++.
+            this.hints.debugFunctionNames.push(new AvmDebugFunctionNameHint(contractAddress, selector.toField(), name));
+        }
+        return name;
+    }
+    createCheckpoint() {
+        const hintKey = this.getHintKey();
+        this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        this.db.createCheckpoint();
+        const newCheckpointId = this.nextCheckpointId++;
+        this.checkpointStack.push(newCheckpointId);
+        this.hints.contractDbCreateCheckpointHints.push(new AvmContractDbCreateCheckpointHint(hintKey, oldCheckpointId, newCheckpointId));
+        HintingPublicContractsDB.log.trace(`[createCheckpoint:${hintKey}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId}.`);
+    }
+    commitCheckpoint() {
+        const hintKey = this.getHintKey();
+        this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        this.db.commitCheckpoint();
+        this.checkpointStack.pop();
+        const newCheckpointId = this.getCurrentCheckpointId();
+        this.hints.contractDbCommitCheckpointHints.push(new AvmContractDbCommitCheckpointHint(hintKey, oldCheckpointId, newCheckpointId));
+        HintingPublicContractsDB.log.trace(`[commitCheckpoint:${hintKey}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId}.`);
+    }
+    revertCheckpoint() {
+        const hintKey = this.getHintKey();
+        this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        this.db.revertCheckpoint();
+        this.checkpointStack.pop();
+        const newCheckpointId = this.getCurrentCheckpointId();
+        this.hints.contractDbRevertCheckpointHints.push(new AvmContractDbRevertCheckpointHint(hintKey, oldCheckpointId, newCheckpointId));
+        HintingPublicContractsDB.log.trace(`[revertCheckpoint:${hintKey}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId}.`);
+    }
+    // Private methods.
+    getHintKey() {
+        return this.checkpointActionCounter;
+    }
+    getCurrentCheckpointId() {
+        return this.checkpointStack[this.checkpointStack.length - 1];
+    }
+}
+/**
+ * A low-level merkle DB that collects hints.
+ */ export class HintingMerkleWriteOperations {
+    db;
+    hints;
+    static log = createLogger('simulator:hinting-merkle-db');
+    // This stack is only for debugging purposes.
+    // The top of the stack is the current checkpoint id.
+    // We need the stack to be non-empty and use 0 as an arbitrary initial checkpoint id.
+    // This is not necessarily a checkpoint that happened, but whatever tree state we start with.
+    checkpointStack;
+    nextCheckpointId;
+    checkpointActionCounter;
+    static async create(db, hints) {
+        const hintingTreesDB = new HintingMerkleWriteOperations(db, hints);
+        const startStateReference = await db.getStateReference();
+        hints.startingTreeRoots = new TreeSnapshots(startStateReference.l1ToL2MessageTree, startStateReference.partial.noteHashTree, startStateReference.partial.nullifierTree, startStateReference.partial.publicDataTree);
+        return hintingTreesDB;
+    }
+    // Use create() to instantiate.
+    constructor(db, hints){
+        this.db = db;
+        this.hints = hints;
+        this.checkpointStack = [
+            0
+        ];
+        this.nextCheckpointId = 1;
+        this.checkpointActionCounter = 0;
+    }
+    // Getters.
+    async getSiblingPath(treeId, index) {
+        const path = await this.db.getSiblingPath(treeId, index);
+        const key = await this.getHintKey(treeId);
+        this.hints.getSiblingPathHints.push(new AvmGetSiblingPathHint(key, treeId, index, path.toFields()));
+        return Promise.resolve(path);
+    }
+    async getPreviousValueIndex(treeId, value) {
+        const result = await this.db.getPreviousValueIndex(treeId, value);
+        if (result === undefined) {
+            throw new Error(`getPreviousValueIndex(${getTreeName(treeId)}, ${value}}) returned undefined. Possible wrong tree setup or corrupted state.`);
+        }
+        const key = await this.getHintKey(treeId);
+        this.hints.getPreviousValueIndexHints.push(new AvmGetPreviousValueIndexHint(key, treeId, new Fr(value), result.index, result.alreadyPresent));
+        return result;
+    }
+    async getLeafPreimage(treeId, index) {
+        const preimage = await this.db.getLeafPreimage(treeId, index);
+        if (preimage) {
+            const key = await this.getHintKey(treeId);
+            switch(treeId){
+                case MerkleTreeId.PUBLIC_DATA_TREE:
+                    this.hints.getLeafPreimageHintsPublicDataTree.push(new AvmGetLeafPreimageHintPublicDataTree(key, index, preimage));
+                    break;
+                case MerkleTreeId.NULLIFIER_TREE:
+                    this.hints.getLeafPreimageHintsNullifierTree.push(new AvmGetLeafPreimageHintNullifierTree(key, index, preimage));
+                    break;
+                default:
+                    // Use getLeafValue for the other trees.
+                    throw new Error('getLeafPreimage only supported for PublicDataTree and NullifierTree!');
+                    break;
+            }
+        }
+        return preimage;
+    }
+    async getLeafValue(treeId, index) {
+        // Use getLeafPreimage for PublicDataTree and NullifierTree.
+        assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+        const value = await this.db.getLeafValue(treeId, index);
+        if (value) {
+            const key = await this.getHintKey(treeId);
+            // We can cast to Fr because we know the type of the tree.
+            this.hints.getLeafValueHints.push(new AvmGetLeafValueHint(key, treeId, index, value));
+        }
+        return value;
+    }
+    // State modification.
+    // FIXME(fcarreiro): This is a horrible interface (in the merkle ops). It's receiving the leaves as buffers,
+    // from a leaf class that is NOT the one that will be used to write. Make this type safe.
+    async sequentialInsert(treeId, leaves) {
+        // Use appendLeaf for NoteHashTree and L1ToL2MessageTree.
+        assert(treeId == MerkleTreeId.PUBLIC_DATA_TREE || treeId == MerkleTreeId.NULLIFIER_TREE);
+        // We only support 1 leaf at a time for now. Can easily be extended.
+        assert(leaves.length === 1, 'sequentialInsert supports only one leaf at a time!');
+        const beforeState = await this.getHintKey(treeId);
+        const result = await this.db.sequentialInsert(treeId, leaves);
+        const afterState = await this.getHintKey(treeId);
+        HintingMerkleWriteOperations.logTreeChange('sequentialInsert', beforeState, afterState, treeId);
+        switch(treeId){
+            case MerkleTreeId.PUBLIC_DATA_TREE:
+                this.hints.sequentialInsertHintsPublicDataTree.push(new AvmSequentialInsertHintPublicDataTree(beforeState, afterState, treeId, PublicDataTreeLeaf.fromBuffer(leaves[0]), {
+                    leaf: result.lowLeavesWitnessData[0].leafPreimage,
+                    index: result.lowLeavesWitnessData[0].index,
+                    path: result.lowLeavesWitnessData[0].siblingPath.toFields()
+                }, {
+                    leaf: result.insertionWitnessData[0].leafPreimage,
+                    index: result.insertionWitnessData[0].index,
+                    path: result.insertionWitnessData[0].siblingPath.toFields()
+                }));
+                break;
+            case MerkleTreeId.NULLIFIER_TREE:
+                this.hints.sequentialInsertHintsNullifierTree.push(new AvmSequentialInsertHintNullifierTree(beforeState, afterState, treeId, NullifierLeaf.fromBuffer(leaves[0]), {
+                    leaf: result.lowLeavesWitnessData[0].leafPreimage,
+                    index: result.lowLeavesWitnessData[0].index,
+                    path: result.lowLeavesWitnessData[0].siblingPath.toFields()
+                }, {
+                    leaf: result.insertionWitnessData[0].leafPreimage,
+                    index: result.insertionWitnessData[0].index,
+                    path: result.insertionWitnessData[0].siblingPath.toFields()
+                }));
+                break;
+            default:
+                throw new Error('sequentialInsert only supported for PublicDataTree and NullifierTree!');
+                break;
+        }
+        return result;
+    }
+    async appendLeaves(treeId, leaves) {
+        // Use sequentialInsert for PublicDataTree and NullifierTree.
+        assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+        // We need to process each leaf individually because we need the sibling path after insertion, to be able to constraint the insertion.
+        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13380): This can be changed if the world state appendLeaves returns the sibling paths.
+        if (leaves.length === 1) {
+            await this.appendLeafInternal(treeId, leaves[0]);
+            return;
+        } else {
+            // TODO(dbanks12): NON-HINTING! We skip hinting here for now because:
+            // 1. We only ever append multiple leaves (for now) when padding (all empty leaves).
+            // 2. We don't need hints per-item when padding.
+            // 3. In order to get per-item hints today, you need to append one-at-a-time (mentioned above), which is VERY slow.
+            await this.db.appendLeaves(treeId, leaves);
+        }
+    }
+    async createCheckpoint() {
+        const actionCounter = this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        const treesStateHash = await this.getTreesStateHash();
+        await this.db.createCheckpoint();
+        this.checkpointStack.push(this.nextCheckpointId++);
+        const newCheckpointId = this.getCurrentCheckpointId();
+        this.hints.createCheckpointHints.push(new AvmCreateCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId));
+        HintingMerkleWriteOperations.log.trace(`[createCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`);
+    }
+    commitAllCheckpoints() {
+        throw new Error('commitAllCheckpoints is not supported in HintingMerkleWriteOperations.');
+    }
+    revertAllCheckpoints() {
+        throw new Error('revertAllCheckpoints is not supported in HintingMerkleWriteOperations.');
+    }
+    async commitCheckpoint() {
+        const actionCounter = this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        const treesStateHash = await this.getTreesStateHash();
+        await this.db.commitCheckpoint();
+        this.checkpointStack.pop();
+        const newCheckpointId = this.getCurrentCheckpointId();
+        this.hints.commitCheckpointHints.push(new AvmCommitCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId));
+        HintingMerkleWriteOperations.log.trace(`[commitCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`);
+    }
+    async revertCheckpoint() {
+        const actionCounter = this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        const treesStateHash = await this.getTreesStateHash();
+        const beforeState = {
+            [MerkleTreeId.PUBLIC_DATA_TREE]: await this.getHintKey(MerkleTreeId.PUBLIC_DATA_TREE),
+            [MerkleTreeId.NULLIFIER_TREE]: await this.getHintKey(MerkleTreeId.NULLIFIER_TREE),
+            [MerkleTreeId.NOTE_HASH_TREE]: await this.getHintKey(MerkleTreeId.NOTE_HASH_TREE),
+            [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: await this.getHintKey(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
+            [MerkleTreeId.ARCHIVE]: await this.getHintKey(MerkleTreeId.ARCHIVE)
+        };
+        await this.db.revertCheckpoint();
+        this.checkpointStack.pop();
+        const newCheckpointId = this.getCurrentCheckpointId();
+        const afterState = {
+            [MerkleTreeId.PUBLIC_DATA_TREE]: await this.getHintKey(MerkleTreeId.PUBLIC_DATA_TREE),
+            [MerkleTreeId.NULLIFIER_TREE]: await this.getHintKey(MerkleTreeId.NULLIFIER_TREE),
+            [MerkleTreeId.NOTE_HASH_TREE]: await this.getHintKey(MerkleTreeId.NOTE_HASH_TREE),
+            [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: await this.getHintKey(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
+            [MerkleTreeId.ARCHIVE]: await this.getHintKey(MerkleTreeId.ARCHIVE)
+        };
+        this.hints.revertCheckpointHints.push(AvmRevertCheckpointHint.create(actionCounter, oldCheckpointId, newCheckpointId, beforeState, afterState));
+        HintingMerkleWriteOperations.log.trace(`[revertCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`);
+        for (const treeId of merkleTreeIds()){
+            HintingMerkleWriteOperations.logTreeChange('revertCheckpoint', beforeState[treeId], afterState[treeId], treeId);
+        }
+    }
+    // Private methods.
+    async getHintKey(treeId) {
+        const treeInfo = await this.db.getTreeInfo(treeId);
+        return new AppendOnlyTreeSnapshot(Fr.fromBuffer(treeInfo.root), Number(treeInfo.size));
+    }
+    getCurrentCheckpointId() {
+        return this.checkpointStack[this.checkpointStack.length - 1];
+    }
+    // For logging/debugging purposes.
+    async getTreesStateHash() {
+        const stateReferenceFields = (await this.db.getStateReference()).toFields();
+        return Fr.fromBuffer(sha256Trunc(Buffer.concat(stateReferenceFields.map((field)=>field.toBuffer()))));
+    }
+    static logTreeChange(action, beforeState, afterState, treeId) {
+        const treeName = getTreeName(treeId);
+        HintingMerkleWriteOperations.log.trace(`[${action}] ${treeName} tree state: ${beforeState.root}, ${beforeState.nextAvailableLeafIndex} -> ${afterState.root}, ${afterState.nextAvailableLeafIndex}.`);
+    }
+    async appendLeafInternal(treeId, leaf) {
+        // Use sequentialInsert for PublicDataTree and NullifierTree.
+        assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+        const beforeState = await this.getHintKey(treeId);
+        await this.db.appendLeaves(treeId, [
+            leaf
+        ]);
+        const afterState = await this.getHintKey(treeId);
+        HintingMerkleWriteOperations.logTreeChange('appendLeaves', beforeState, afterState, treeId);
+        this.hints.appendLeavesHints.push(new AvmAppendLeavesHint(beforeState, afterState, treeId, [
+            leaf
+        ]));
+        return await this.getSiblingPath(treeId, BigInt(beforeState.nextAvailableLeafIndex));
+    }
+    // Non-hinted required methods from MerkleTreeWriteOperations interface
+    async getTreeInfo(treeId) {
+        return await this.db.getTreeInfo(treeId);
+    }
+    async getStateReference() {
+        return await this.db.getStateReference();
+    }
+    getInitialHeader() {
+        return this.db.getInitialHeader();
+    }
+    getRevision() {
+        return this.db.getRevision();
+    }
+    async updateArchive(header) {
+        return await this.db.updateArchive(header);
+    }
+    async batchInsert(treeId, leaves, subtreeHeight) {
+        return await this.db.batchInsert(treeId, leaves, subtreeHeight);
+    }
+    async close() {
+        return await this.db.close();
+    }
+    async findLeafIndices(treeId, values) {
+        return await this.db.findLeafIndices(treeId, values);
+    }
+    findSiblingPaths(treeId, values) {
+        return this.db.findSiblingPaths(treeId, values);
+    }
+    async findLeafIndicesAfter(treeId, values, startIndex) {
+        return await this.db.findLeafIndicesAfter(treeId, values, startIndex);
+    }
+    async getBlockNumbersForLeafIndices(treeId, leafIndices) {
+        return await this.db.getBlockNumbersForLeafIndices(treeId, leafIndices);
+    }
+}

package/dest/public/index.d.ts

@@ -1,10 +1,7 @@
-export * from '../common/db_interfaces.js';
-export * from './public_tx_simulator/public_tx_simulator.js';
-export { type EnqueuedPublicCallExecutionResult, type PublicFunctionCallResult } from './execution.js';
-export * from './public_db_sources.js';
+export { PublicContractsDB } from './public_db_sources.js';
+export { GuardedMerkleTreeOperations } from './public_processor/guarded_merkle_tree.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
-export { SideEffectTrace } from './side_effect_trace.js';
-export { getExecutionRequestsByPhase } from './utils.js';
-export { PublicTxSimulationTester } from './fixtures/index.js';
-export * from './avm/index.js';
-//# sourceMappingURL=index.d.ts.map
+export { PublicTxSimulator, TelemetryPublicTxSimulator } from './public_tx_simulator/index.js';
+export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';
+export { getCallRequestsWithCalldataByPhase } from './utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDM0QsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDeEYsT0FBTyxFQUFFLGVBQWUsRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ2pHLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQy9GLFlBQVksRUFBRSxjQUFjLEVBQUUscUJBQXFCLElBQUksdUJBQXVCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUMxRyxPQUFPLEVBQUUsa0NBQWtDLEVBQUUsTUFBTSxZQUFZLENBQUMifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/public/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8CAA8C,CAAC;AAC7D,OAAO,EAAE,KAAK,iCAAiC,EAAE,KAAK,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AACvG,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AACjG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/public/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,2CAA2C,CAAC;AACxF,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AACjG,OAAO,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAC/F,YAAY,EAAE,cAAc,EAAE,qBAAqB,IAAI,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC1G,OAAO,EAAE,kCAAkC,EAAE,MAAM,YAAY,CAAC"}

package/dest/public/index.js

@@ -1,8 +1,5 @@
-export * from '../common/db_interfaces.js';
-export * from './public_tx_simulator/public_tx_simulator.js';
-export * from './public_db_sources.js';
+export { PublicContractsDB } from './public_db_sources.js';
+export { GuardedMerkleTreeOperations } from './public_processor/guarded_merkle_tree.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
-export { SideEffectTrace } from './side_effect_trace.js';
-export { getExecutionRequestsByPhase } from './utils.js';
-export { PublicTxSimulationTester } from './fixtures/index.js';
-export * from './avm/index.js';
+export { PublicTxSimulator, TelemetryPublicTxSimulator } from './public_tx_simulator/index.js';
+export { getCallRequestsWithCalldataByPhase } from './utils.js';

package/dest/public/public_db_sources.d.ts

@@ -1,129 +1,79 @@
 import { Fr } from '@aztec/foundation/fields';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type ContractClassPublic, type ContractDataSource, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { MerkleTreeCheckpointOperations, MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
-import type { Tx } from '@aztec/stdlib/tx';
-import type { PublicContractsDB, PublicStateDB } from '../common/db_interfaces.js';
+import { type ContractClassPublic, type ContractDataSource, type ContractDeploymentData, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { TreeSnapshots, type Tx } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+import type { PublicContractsDBInterface, PublicStateDBInterface } from './db_interfaces.js';
 /**
- * Implements the PublicContractsDB using a ContractDataSource.
- * Progressively records contracts in transaction as they are processed in a block.
- * Separates block-level contract information (from processed/included txs) from the
- * current tx's contract information (which may be cleared on tx revert/death).
+ * Implements the PublicContractsDBInterface using a ContractDataSource.
+ * Uses a stack-based checkpoint model for managing contract state.
  */
-export declare class ContractsDataSourcePublicDB implements PublicContractsDB {
+export declare class PublicContractsDB implements PublicContractsDBInterface {
     private dataSource;
-    private currentTxNonRevertibleCache;
-    private currentTxRevertibleCache;
-    private blockCache;
-    private bytecodeCommitmentCache;
+    private contractStateStack;
     private log;
     constructor(dataSource: ContractDataSource);
-    /**
-     * Add new contracts from a transaction
-     * @param tx - The transaction to add contracts from.
-     */
+    addContracts(contractDeploymentData: ContractDeploymentData): Promise<void>;
     addNewContracts(tx: Tx): Promise<void>;
     /**
-     * Add non revertible contracts from a transaction
-     * @param tx - The transaction to add non revertible contracts from.
-     */
-    addNewNonRevertibleContracts(tx: Tx): Promise<void>;
-    /**
-     * Add revertible contracts from a transaction
-     * @param tx - The transaction to add revertible contracts from.
-     */
-    addNewRevertibleContracts(tx: Tx): Promise<void>;
-    /**
-     * Add non-revertible contract classes from a transaction
-     * For private-only txs, this will be all contract classes (found in tx.data.forPublic)
-     * @param tx - The transaction to add non-revertible contract classes from.
-     */
-    private addNonRevertibleContractClasses;
-    /**
-     * Add revertible contract classes from a transaction
-     * None for private-only txs.
-     * @param tx - The transaction to add revertible contract classes from.
-     */
-    private addRevertibleContractClasses;
-    /**
-     * Add non-revertible contract instances from a transaction
-     * For private-only txs, this will be all contract instances (found in tx.data.forRollup)
-     * @param tx - The transaction to add non-revertible contract instances from.
-     */
-    private addNonRevertibleContractInstances;
-    /**
-     * Add revertible contract instances from a transaction
-     * None for private-only txs.
-     * @param tx - The transaction to add revertible contract instances from.
-     */
-    private addRevertibleContractInstances;
-    /**
-     * Given a tx's siloed contract class logs, add the contract classes to the cache
-     * @param siloedContractClassLogs - Contract class logs to process
-     * @param cache - The cache to store the contract classes in
-     * @param cacheType - Type of cache (for logging)
+     * Creates a new checkpoint, copying the current state for upcoming modifications,
+     * and enabling rollbacks to current state in case of a revert.
      */
-    private addContractClassesFromLogs;
+    createCheckpoint(): void;
     /**
-     * Given a tx's contract instance logs, add the contract instances to the cache
-     * @param contractInstanceLogs - Contract instance logs to process
-     * @param cache - The cache to store the contract instances in
-     * @param cacheType - Type of cache (for logging)
+     * Commits the current checkpoint, accepting its state latest.
      */
-    private addContractInstancesFromLogs;
+    commitCheckpoint(): void;
     /**
-     * Clear new contracts from the current tx's cache
+     * 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.
      */
-    clearContractsForTx(): void;
+    commitCheckpointOkIfNone(): void;
     /**
-     * Commits the current transaction's cached contracts to the block-level cache.
-     * Then, clears the tx cache.
+     * Reverts the current checkpoint, discarding its state and rolling back
+     * to the state as of the latest checkpoint.
      */
-    commitContractsForTx(onlyNonRevertibles?: boolean): void;
-    getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+    revertCheckpoint(): void;
+    private getCurrentState;
+    getContractInstance(address: AztecAddress, timestamp: UInt64): Promise<ContractInstanceWithAddress | undefined>;
     getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined>;
     getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined>;
     getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+    private addContractClassesFromEvents;
+    private addContractInstancesFromEvents;
 }
 /**
- * A public state DB that reads and writes to the world state.
+ * 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 declare class WorldStateDB extends ContractsDataSourcePublicDB implements PublicStateDB, MerkleTreeCheckpointOperations {
-    db: MerkleTreeWriteOperations;
+export declare class PublicTreesDB implements PublicStateDBInterface {
+    private readonly db;
     private logger;
-    constructor(db: MerkleTreeWriteOperations, dataSource: ContractDataSource);
-    /**
-     * Checkpoints the current fork state
-     */
+    constructor(db: MerkleTreeWriteOperations);
+    storageRead(contract: AztecAddress, slot: Fr): Promise<Fr>;
+    storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
+    getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr>;
+    getNoteHash(leafIndex: bigint): Promise<Fr>;
+    writeNoteHash(noteHash: Fr): Promise<void>;
+    checkNullifierExists(nullifier: Fr): Promise<boolean>;
+    writeNullifier(siloedNullifier: Fr): Promise<void>;
+    padTree(treeId: MerkleTreeId, leavesToInsert: number): Promise<void>;
     createCheckpoint(): Promise<void>;
-    /**
-     * Commits the current checkpoint
-     */
     commitCheckpoint(): Promise<void>;
-    /**
-     * Reverts the current checkpoint
-     */
     revertCheckpoint(): Promise<void>;
-    getMerkleInterface(): MerkleTreeWriteOperations;
-    /**
-     * Reads a value from public storage, returning zero if none.
-     * @param contract - Owner of the storage.
-     * @param slot - Slot to read in the contract storage.
-     * @returns The current value in the storage slot.
-     */
-    storageRead(contract: AztecAddress, slot: Fr): Promise<Fr>;
-    /**
-     * Records a write to public storage.
-     * @param contract - Owner of the storage.
-     * @param slot - Slot to read in the contract storage.
-     * @param newValue - The new value to store.
-     * @returns The slot of the written leaf in the public data tree.
-     */
-    storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
-    getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined>;
-    getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined>;
-    getNullifierIndex(nullifier: Fr): Promise<bigint | undefined>;
+    getTreeSnapshots(): Promise<TreeSnapshots>;
 }
-export declare function readPublicState(db: MerkleTreeReadOperations, contract: AztecAddress, slot: Fr): Promise<Fr>;
-//# sourceMappingURL=public_db_sources.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

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

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