@aztec/pxe 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/dest/notes/note_service.d.ts

@@ -0,0 +1,48 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type AztecNode } from '@aztec/stdlib/interfaces/client';
+import { Note, NoteStatus } from '@aztec/stdlib/note';
+import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+import type { NoteStore } from '../storage/note_store/note_store.js';
+export declare class NoteService {
+    private readonly noteStore;
+    private readonly aztecNode;
+    private readonly anchorBlockHeader;
+    private readonly jobId;
+    constructor(noteStore: NoteStore, aztecNode: AztecNode, anchorBlockHeader: BlockHeader, jobId: string);
+    /**
+     * Retrieves a set of notes stored in the database for a given contract address and storage slot.
+     * The query result is paginated using 'limit' and 'offset' values.
+     * Returns an object containing an array of note data.
+     *
+     * @param owner - The owner of the notes. If undefined, returns notes for all known owners.
+     * @param status - The status of notes to fetch.
+     * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
+     */
+    getNotes(contractAddress: AztecAddress, owner: AztecAddress | undefined, storageSlot: Fr, status: NoteStatus, scopes?: AztecAddress[]): Promise<{
+        contractAddress: AztecAddress;
+        owner: AztecAddress;
+        storageSlot: Fr;
+        randomness: Fr;
+        noteNonce: Fr;
+        note: Note;
+        noteHash: Fr;
+        isPending: boolean;
+        siloedNullifier: Fr;
+    }[]>;
+    /**
+     * Looks for nullifiers of active contract notes and marks them as nullified if a nullifier is found.
+     *
+     * Fetches notes from the NoteStore and checks which nullifiers are present in the
+     * onchain nullifier Merkle tree - up to the latest locally synced block. We use the
+     * locally synced block instead of querying the chain's 'latest' block to ensure correctness:
+     * notes are only marked nullified once their corresponding nullifier has been included in a
+     * block up to which the PXE has synced.
+     * This allows recent nullifications to be processed even if the node is not an archive node.
+     *
+     * @param contractAddress - The contract whose notes should be checked and nullified.
+     */
+    syncNoteNullifiers(contractAddress: AztecAddress): Promise<void>;
+    validateAndStoreNote(contractAddress: AztecAddress, owner: AztecAddress, storageSlot: Fr, randomness: Fr, noteNonce: Fr, content: Fr[], noteHash: Fr, nullifier: Fr, txHash: TxHash, recipient: AztecAddress): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm90ZXMvbm90ZV9zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUdoRSxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQWUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsSUFBSSxFQUFXLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRS9ELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU1RCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUVyRSxxQkFBYSxXQUFXO0lBRXBCLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFDMUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUI7SUFDbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLO0lBSnhCLFlBQ21CLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsS0FBSyxFQUFFLE1BQU0sRUFDNUI7SUFFSjs7Ozs7Ozs7T0FRRztJQUNVLFFBQVEsQ0FDbkIsZUFBZSxFQUFFLFlBQVksRUFDN0IsS0FBSyxFQUFFLFlBQVksR0FBRyxTQUFTLEVBQy9CLFdBQVcsRUFBRSxFQUFFLEVBQ2YsTUFBTSxFQUFFLFVBQVUsRUFDbEIsTUFBTSxDQUFDLEVBQUUsWUFBWSxFQUFFOzs7Ozs7Ozs7O1NBeUJ4QjtJQUVEOzs7Ozs7Ozs7OztPQVdHO0lBQ1Usa0JBQWtCLENBQUMsZUFBZSxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBc0M1RTtJQUVZLG9CQUFvQixDQUMvQixlQUFlLEVBQUUsWUFBWSxFQUM3QixLQUFLLEVBQUUsWUFBWSxFQUNuQixXQUFXLEVBQUUsRUFBRSxFQUNmLFVBQVUsRUFBRSxFQUFFLEVBQ2QsU0FBUyxFQUFFLEVBQUUsRUFDYixPQUFPLEVBQUUsRUFBRSxFQUFFLEVBQ2IsUUFBUSxFQUFFLEVBQUUsRUFDWixTQUFTLEVBQUUsRUFBRSxFQUNiLE1BQU0sRUFBRSxNQUFNLEVBQ2QsU0FBUyxFQUFFLFlBQVksR0FDdEIsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXNFZjtDQUNGIn0=

package/dest/notes/note_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"note_service.d.ts","sourceRoot":"","sources":["../../src/notes/note_service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,IAAI,EAAW,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAErE,qBAAa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,YACmB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,WAAW,EAC9B,KAAK,EAAE,MAAM,EAC5B;IAEJ;;;;;;;;OAQG;IACU,QAAQ,CACnB,eAAe,EAAE,YAAY,EAC7B,KAAK,EAAE,YAAY,GAAG,SAAS,EAC/B,WAAW,EAAE,EAAE,EACf,MAAM,EAAE,UAAU,EAClB,MAAM,CAAC,EAAE,YAAY,EAAE;;;;;;;;;;SAyBxB;IAED;;;;;;;;;;;OAWG;IACU,kBAAkB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAsC5E;IAEY,oBAAoB,CAC/B,eAAe,EAAE,YAAY,EAC7B,KAAK,EAAE,YAAY,EACnB,WAAW,EAAE,EAAE,EACf,UAAU,EAAE,EAAE,EACd,SAAS,EAAE,EAAE,EACb,OAAO,EAAE,EAAE,EAAE,EACb,QAAQ,EAAE,EAAE,EACZ,SAAS,EAAE,EAAE,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,IAAI,CAAC,CAsEf;CACF"}

package/dest/notes/note_service.js

@@ -0,0 +1,147 @@
+import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { MAX_RPC_LEN } from '@aztec/stdlib/interfaces/client';
+import { Note, NoteDao } from '@aztec/stdlib/note';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+export class NoteService {
+    noteStore;
+    aztecNode;
+    anchorBlockHeader;
+    jobId;
+    constructor(noteStore, aztecNode, anchorBlockHeader, jobId){
+        this.noteStore = noteStore;
+        this.aztecNode = aztecNode;
+        this.anchorBlockHeader = anchorBlockHeader;
+        this.jobId = jobId;
+    }
+    /**
+   * Retrieves a set of notes stored in the database for a given contract address and storage slot.
+   * The query result is paginated using 'limit' and 'offset' values.
+   * Returns an object containing an array of note data.
+   *
+   * @param owner - The owner of the notes. If undefined, returns notes for all known owners.
+   * @param status - The status of notes to fetch.
+   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
+   */ async getNotes(contractAddress, owner, storageSlot, status, scopes) {
+        const noteDaos = await this.noteStore.getNotes({
+            contractAddress,
+            owner,
+            storageSlot,
+            status,
+            scopes
+        }, this.jobId);
+        return noteDaos.map(({ contractAddress, owner, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier })=>({
+                contractAddress,
+                owner,
+                storageSlot,
+                randomness,
+                noteNonce,
+                note,
+                noteHash,
+                isPending: false,
+                siloedNullifier
+            }));
+    }
+    /**
+   * Looks for nullifiers of active contract notes and marks them as nullified if a nullifier is found.
+   *
+   * Fetches notes from the NoteStore and checks which nullifiers are present in the
+   * onchain nullifier Merkle tree - up to the latest locally synced block. We use the
+   * locally synced block instead of querying the chain's 'latest' block to ensure correctness:
+   * notes are only marked nullified once their corresponding nullifier has been included in a
+   * block up to which the PXE has synced.
+   * This allows recent nullifications to be processed even if the node is not an archive node.
+   *
+   * @param contractAddress - The contract whose notes should be checked and nullified.
+   */ async syncNoteNullifiers(contractAddress) {
+        const anchorBlockHash = await this.anchorBlockHeader.hash();
+        const contractNotes = await this.noteStore.getNotes({
+            contractAddress
+        }, this.jobId);
+        if (contractNotes.length === 0) {
+            return;
+        }
+        const nullifiersToCheck = contractNotes.map((note)=>note.siloedNullifier);
+        const nullifierBatches = nullifiersToCheck.reduce((acc, nullifier)=>{
+            if (acc[acc.length - 1].length < MAX_RPC_LEN) {
+                acc[acc.length - 1].push(nullifier);
+            } else {
+                acc.push([
+                    nullifier
+                ]);
+            }
+            return acc;
+        }, [
+            []
+        ]);
+        const nullifierIndexes = (await Promise.all(nullifierBatches.map((batch)=>this.aztecNode.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, batch)))).flat();
+        const foundNullifiers = nullifiersToCheck.map((nullifier, i)=>{
+            if (nullifierIndexes[i] !== undefined) {
+                return {
+                    ...nullifierIndexes[i],
+                    ...{
+                        data: nullifier
+                    }
+                };
+            }
+        }).filter((nullifier)=>nullifier !== undefined);
+        await this.noteStore.applyNullifiers(foundNullifiers, this.jobId);
+    }
+    async validateAndStoreNote(contractAddress, owner, storageSlot, randomness, noteNonce, content, noteHash, nullifier, txHash, recipient) {
+        // We are going to store the new note in the NoteStore, which will let us later return it via `getNotes`.
+        // There's two things we need to check before we do this however:
+        //  - we must make sure the note does actually exist in the note hash tree
+        //  - we need to check if the note has already been nullified
+        //
+        // Failing to do either of the above would result in circuits getting either non-existent notes and failing to
+        // produce inclusion proofs for them, or getting nullified notes and producing duplicate nullifiers, both of which
+        // are catastrophic failure modes.
+        //
+        // Note that adding a note and removing it is *not* equivalent to never adding it in the first place. A nullifier
+        // emitted in a block that comes after note creation might result in the note being de-nullified by a chain reorg,
+        // so we must store both the note hash and nullifier block information.
+        // We avoid making node queries at 'latest' since we don't want to process notes or nullifiers that only exist ahead
+        // in time of the locally synced state.
+        // Note that while this technically results in historical queries, we perform it at the latest locally synced block
+        // number which *should* be recent enough to be available, even for non-archive nodes.
+        // Also note that the note should never be ahead of the synced block here since `fetchTaggedLogs` only processes
+        // logs up to the synced block making this only an additional safety check.
+        const anchorBlockNumber = this.anchorBlockHeader.getBlockNumber();
+        const anchorBlockHash = await this.anchorBlockHeader.hash();
+        // By computing siloed and unique note hashes ourselves we prevent contracts from interfering with the note storage
+        // of other contracts, which would constitute a security breach.
+        const uniqueNoteHash = await computeUniqueNoteHash(noteNonce, await siloNoteHash(contractAddress, noteHash));
+        const siloedNullifier = await siloNullifier(contractAddress, nullifier);
+        const [txEffect, [nullifierIndex]] = await Promise.all([
+            this.aztecNode.getTxEffect(txHash),
+            this.aztecNode.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, [
+                siloedNullifier
+            ])
+        ]);
+        if (!txEffect) {
+            throw new Error(`Could not find tx effect for tx hash ${txHash}`);
+        }
+        if (txEffect.l2BlockNumber > anchorBlockNumber) {
+            throw new Error(`Could not find tx effect for tx hash ${txHash} as of block number ${anchorBlockNumber}`);
+        }
+        // Find the index of the note hash in the noteHashes array to determine note ordering within the tx
+        const noteIndexInTx = txEffect.data.noteHashes.findIndex((nh)=>nh.equals(uniqueNoteHash));
+        if (noteIndexInTx === -1) {
+            throw new Error(`Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present in tx ${txHash}`);
+        }
+        const noteDao = new NoteDao(new Note(content), contractAddress, owner, storageSlot, randomness, noteNonce, noteHash, siloedNullifier, txHash, txEffect.l2BlockNumber, txEffect.l2BlockHash.toString(), txEffect.txIndexInBlock, noteIndexInTx);
+        // The note was found by `recipient`, so we use that as the scope when storing the note.
+        await this.noteStore.addNotes([
+            noteDao
+        ], recipient, this.jobId);
+        if (nullifierIndex !== undefined) {
+            // We found nullifier index which implies that the note has already been nullified.
+            const { data: _, ...blockHashAndNum } = nullifierIndex;
+            await this.noteStore.applyNullifiers([
+                {
+                    data: siloedNullifier,
+                    ...blockHashAndNum
+                }
+            ], this.jobId);
+        }
+    }
+}

package/dest/oracle_version.d.ts

@@ -0,0 +1,3 @@
+export declare const ORACLE_VERSION = 11;
+export declare const ORACLE_INTERFACE_HASH = "20c4d02d8cd5e448c11001a5f72ea2e0927630aeda75e537550872a9627bf40b";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JhY2xlX3ZlcnNpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9vcmFjbGVfdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQSxlQUFPLE1BQU0sY0FBYyxLQUFLLENBQUM7QUFLakMsZUFBTyxNQUFNLHFCQUFxQixxRUFBcUUsQ0FBQyJ9

package/dest/oracle_version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oracle_version.d.ts","sourceRoot":"","sources":["../src/oracle_version.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,KAAK,CAAC;AAKjC,eAAO,MAAM,qBAAqB,qEAAqE,CAAC"}

package/dest/oracle_version.js

@@ -0,0 +1,11 @@
+/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need
+/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible
+/// versions of Aztec.nr and PXE. The Noir counterpart is in `noir-projects/aztec-nr/aztec/src/oracle/version.nr`.
+///
+/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called
+/// and if the oracle version is incompatible an error is thrown.
+export const ORACLE_VERSION = 11;
+/// This hash is computed as by hashing the Oracle interface and it is used to detect when the Oracle interface changes,
+/// which in turn implies that you need to update the ORACLE_VERSION constant in this file and in
+/// `noir-projects/aztec-nr/aztec/src/oracle/version.nr`.
+export const ORACLE_INTERFACE_HASH = '20c4d02d8cd5e448c11001a5f72ea2e0927630aeda75e537550872a9627bf40b';

package/dest/private_kernel/hints/compute_tx_include_by_timestamp.d.ts

@@ -0,0 +1,4 @@
+import type { PrivateKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import type { UInt64 } from '@aztec/stdlib/types';
+export declare function computeTxIncludeByTimestamp(previousKernel: PrivateKernelCircuitPublicInputs, maxDuration?: number): UInt64;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHV0ZV90eF9pbmNsdWRlX2J5X3RpbWVzdGFtcC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3ByaXZhdGVfa2VybmVsL2hpbnRzL2NvbXB1dGVfdHhfaW5jbHVkZV9ieV90aW1lc3RhbXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUM3RSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQXFCbEQsd0JBQWdCLDJCQUEyQixDQUN6QyxjQUFjLEVBQUUsZ0NBQWdDLEVBQ2hELFdBQVcsU0FBb0MsR0FDOUMsTUFBTSxDQStCUiJ9

package/dest/private_kernel/hints/compute_tx_include_by_timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_tx_include_by_timestamp.d.ts","sourceRoot":"","sources":["../../../src/private_kernel/hints/compute_tx_include_by_timestamp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAqBlD,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,gCAAgC,EAChD,WAAW,SAAoC,GAC9C,MAAM,CA+BR"}

package/dest/private_kernel/hints/compute_tx_include_by_timestamp.js

@@ -0,0 +1,41 @@
+import { MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
+const ROUNDED_DURATIONS = [
+    3600,
+    1800,
+    1
+];
+function roundTimestamp(blockTimestamp, includeByTimestamp) {
+    return ROUNDED_DURATIONS.reduce((timestamp, duration)=>{
+        if (timestamp <= blockTimestamp) {
+            // The timestamp must be greater than the block timestamp.
+            // If it is too small, round it down again using a smaller duration.
+            const totalDuration = includeByTimestamp - blockTimestamp;
+            const roundedDuration = totalDuration - totalDuration % BigInt(duration);
+            return blockTimestamp + roundedDuration;
+        }
+        return timestamp;
+    }, 0n);
+}
+export function computeTxIncludeByTimestamp(previousKernel, maxDuration = MAX_INCLUDE_BY_TIMESTAMP_DURATION) {
+    if (maxDuration > MAX_INCLUDE_BY_TIMESTAMP_DURATION) {
+        throw new Error(`Custom max duration cannot be greater than the max allowed. Max allowed: ${MAX_INCLUDE_BY_TIMESTAMP_DURATION}. Custom value: ${maxDuration}.`);
+    }
+    const anchorBlockTimestamp = previousKernel.constants.anchorBlockHeader.globalVariables.timestamp;
+    const maxTimestamp = anchorBlockTimestamp + BigInt(maxDuration);
+    const includeByTimestamp = previousKernel.includeByTimestamp;
+    // If the includeByTimestamp set during the tx execution is greater than or equal to the max allowed duration,
+    // use the maximum allowed timestamp.
+    // Note: It shouldn't be larger than the max allowed duration, but we check for it anyway.
+    if (includeByTimestamp >= maxTimestamp) {
+        return maxTimestamp;
+    }
+    // Round it down to the nearest hour/min/second to reduce precision and avoid revealing the exact value.
+    // This makes it harder for others to infer what function calls may have been used to produce a specific timestamp.
+    const roundedTimestamp = roundTimestamp(anchorBlockTimestamp, includeByTimestamp);
+    // The tx can't be published if the timestamp is the same or less than the anchor block's timestamp.
+    // Future blocks will have a greater timestamp, so the tx would never be included.
+    if (roundedTimestamp <= anchorBlockTimestamp) {
+        throw new Error(`Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${includeByTimestamp}.`);
+    }
+    return roundedTimestamp;
+}

package/dest/private_kernel/hints/index.d.ts

@@ -0,0 +1,3 @@
+export * from './private_kernel_reset_private_inputs_builder.js';
+export * from './compute_tx_include_by_timestamp.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcml2YXRlX2tlcm5lbC9oaW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtEQUFrRCxDQUFDO0FBQ2pFLGNBQWMsc0NBQXNDLENBQUMifQ==

package/dest/private_kernel/hints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/private_kernel/hints/index.ts"],"names":[],"mappings":"AAAA,cAAc,kDAAkD,CAAC;AACjE,cAAc,sCAAsC,CAAC"}

package/dest/private_kernel/hints/index.js

@@ -0,0 +1,2 @@
+export * from './private_kernel_reset_private_inputs_builder.js';
+export * from './compute_tx_include_by_timestamp.js';

package/dest/private_kernel/hints/private_kernel_reset_private_inputs_builder.d.ts

@@ -0,0 +1,28 @@
+import { type PrivateKernelCircuitPublicInputs, PrivateKernelResetCircuitPrivateInputs, type PrivateKernelSimulateOutput } from '@aztec/stdlib/kernel';
+import { type PrivateCallExecutionResult } from '@aztec/stdlib/tx';
+import type { PrivateKernelOracle } from '../private_kernel_oracle.js';
+export declare class PrivateKernelResetPrivateInputsBuilder {
+    private previousKernelOutput;
+    private executionStack;
+    private noteHashNullifierCounterMap;
+    private splitCounter;
+    private previousKernel;
+    private nextIteration?;
+    private noteHashResetActions;
+    private nullifierResetActions;
+    private numTransientData?;
+    private transientDataSquashingHints;
+    private requestedDimensions;
+    constructor(previousKernelOutput: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>, executionStack: PrivateCallExecutionResult[], noteHashNullifierCounterMap: Map<number, number>, splitCounter: number);
+    needsReset(): boolean;
+    build(oracle: PrivateKernelOracle): Promise<PrivateKernelResetCircuitPrivateInputs>;
+    private reduceReadRequestActions;
+    private needsResetNoteHashReadRequests;
+    private needsResetNullifierReadRequests;
+    private needsResetNullifierKeys;
+    private needsResetTransientData;
+    private needsSiloNoteHashes;
+    private needsSiloNullifiers;
+    private needsSiloPrivateLogs;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9rZXJuZWxfcmVzZXRfcHJpdmF0ZV9pbnB1dHNfYnVpbGRlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3ByaXZhdGVfa2VybmVsL2hpbnRzL3ByaXZhdGVfa2VybmVsX3Jlc2V0X3ByaXZhdGVfaW5wdXRzX2J1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBZUEsT0FBTyxFQUtMLEtBQUssZ0NBQWdDLEVBRXJDLHNDQUFzQyxFQUd0QyxLQUFLLDJCQUEyQixFQWVqQyxNQUFNLHNCQUFzQixDQUFDO0FBQzlCLE9BQU8sRUFBRSxLQUFLLDBCQUEwQixFQUFpQixNQUFNLGtCQUFrQixDQUFDO0FBR2xGLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUE0Q3ZFLHFCQUFhLHNDQUFzQztJQVkvQyxPQUFPLENBQUMsb0JBQW9CO0lBQzVCLE9BQU8sQ0FBQyxjQUFjO0lBQ3RCLE9BQU8sQ0FBQywyQkFBMkI7SUFDbkMsT0FBTyxDQUFDLFlBQVk7SUFkdEIsT0FBTyxDQUFDLGNBQWMsQ0FBbUM7SUFFekQsT0FBTyxDQUFDLGFBQWEsQ0FBQyxDQUE2QjtJQUVuRCxPQUFPLENBQUMsb0JBQW9CLENBQXFFO0lBQ2pHLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBcUU7SUFDbEcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBQVM7SUFDbEMsT0FBTyxDQUFDLDJCQUEyQixDQUFrRTtJQUNyRyxPQUFPLENBQUMsbUJBQW1CLENBQStCO0lBRTFELFlBQ1Usb0JBQW9CLEVBQUUsMkJBQTJCLENBQUMsZ0NBQWdDLENBQUMsRUFDbkYsY0FBYyxFQUFFLDBCQUEwQixFQUFFLEVBQzVDLDJCQUEyQixFQUFFLEdBQUcsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLEVBQ2hELFlBQVksRUFBRSxNQUFNLEVBVzdCO0lBRUQsVUFBVSxJQUFJLE9BQU8sQ0FzQnBCO0lBRUssS0FBSyxDQUFDLE1BQU0sRUFBRSxtQkFBbUIsbURBK0V0QztJQUVELE9BQU8sQ0FBQyx3QkFBd0I7SUEyQmhDLE9BQU8sQ0FBQyw4QkFBOEI7SUF1RHRDLE9BQU8sQ0FBQywrQkFBK0I7SUF1RHZDLE9BQU8sQ0FBQyx1QkFBdUI7SUFhL0IsT0FBTyxDQUFDLHVCQUF1QjtJQXNFL0IsT0FBTyxDQUFDLG1CQUFtQjtJQWMzQixPQUFPLENBQUMsbUJBQW1CO0lBa0IzQixPQUFPLENBQUMsb0JBQW9CO0NBcUI3QiJ9

package/dest/private_kernel/hints/private_kernel_reset_private_inputs_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_kernel_reset_private_inputs_builder.d.ts","sourceRoot":"","sources":["../../../src/private_kernel/hints/private_kernel_reset_private_inputs_builder.ts"],"names":[],"mappings":"AAeA,OAAO,EAKL,KAAK,gCAAgC,EAErC,sCAAsC,EAGtC,KAAK,2BAA2B,EAejC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,0BAA0B,EAAiB,MAAM,kBAAkB,CAAC;AAGlF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AA4CvE,qBAAa,sCAAsC;IAY/C,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,2BAA2B;IACnC,OAAO,CAAC,YAAY;IAdtB,OAAO,CAAC,cAAc,CAAmC;IAEzD,OAAO,CAAC,aAAa,CAAC,CAA6B;IAEnD,OAAO,CAAC,oBAAoB,CAAqE;IACjG,OAAO,CAAC,qBAAqB,CAAqE;IAClG,OAAO,CAAC,gBAAgB,CAAC,CAAS;IAClC,OAAO,CAAC,2BAA2B,CAAkE;IACrG,OAAO,CAAC,mBAAmB,CAA+B;IAE1D,YACU,oBAAoB,EAAE,2BAA2B,CAAC,gCAAgC,CAAC,EACnF,cAAc,EAAE,0BAA0B,EAAE,EAC5C,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChD,YAAY,EAAE,MAAM,EAW7B;IAED,UAAU,IAAI,OAAO,CAsBpB;IAEK,KAAK,CAAC,MAAM,EAAE,mBAAmB,mDA+EtC;IAED,OAAO,CAAC,wBAAwB;IA2BhC,OAAO,CAAC,8BAA8B;IAuDtC,OAAO,CAAC,+BAA+B;IAuDvC,OAAO,CAAC,uBAAuB;IAa/B,OAAO,CAAC,uBAAuB;IAsE/B,OAAO,CAAC,mBAAmB;IAc3B,OAAO,CAAC,mBAAmB;IAkB3B,OAAO,CAAC,oBAAoB;CAqB7B"}

package/dest/private_kernel/hints/private_kernel_reset_private_inputs_builder.js

@@ -0,0 +1,277 @@
+import { MAX_KEY_VALIDATION_REQUESTS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { assertLength } from '@aztec/foundation/serialize';
+import { MembershipWitness } from '@aztec/foundation/trees';
+import { privateKernelResetDimensionsConfig } from '@aztec/noir-protocol-circuits-types/client';
+import { KeyValidationHint, PaddedSideEffects, PrivateKernelData, PrivateKernelResetCircuitPrivateInputs, PrivateKernelResetDimensions, PrivateKernelResetHints, ReadRequestActionEnum, ReadRequestResetActions, ScopedNoteHash, ScopedNullifier, TransientDataSquashingHint, buildNoteHashReadRequestHintsFromResetActions, buildNullifierReadRequestHintsFromResetActions, buildTransientDataHints, findPrivateKernelResetDimensions, getNoteHashReadRequestResetActions, getNullifierReadRequestResetActions, privateKernelResetDimensionNames } from '@aztec/stdlib/kernel';
+import { collectNested } from '@aztec/stdlib/tx';
+import { VkData } from '@aztec/stdlib/vks';
+function collectNestedReadRequests(executionStack, extractReadRequests) {
+    return collectNested(executionStack, (executionResult)=>{
+        return extractReadRequests(executionResult).getActiveItems();
+    });
+}
+function getNullifierMembershipWitnessResolver(oracle) {
+    return async (nullifier)=>{
+        const res = await oracle.getNullifierMembershipWitness(nullifier);
+        if (!res) {
+            throw new Error(`Cannot find the leaf for nullifier ${nullifier}.`);
+        }
+        const { index, siblingPath, leafPreimage } = res;
+        return {
+            membershipWitness: new MembershipWitness(NULLIFIER_TREE_HEIGHT, index, siblingPath.toTuple()),
+            leafPreimage
+        };
+    };
+}
+async function getMasterSecretKeysAndAppKeyGenerators(keyValidationRequests, numRequestsToVerify, oracle) {
+    const numRequestsToProcess = Math.min(keyValidationRequests.claimedLength, numRequestsToVerify);
+    const keysHints = await Promise.all(keyValidationRequests.array.slice(0, numRequestsToProcess).map(async ({ request })=>{
+        const secretKeys = await oracle.getMasterSecretKey(request.request.pkM);
+        return new KeyValidationHint(secretKeys);
+    }));
+    return padArrayEnd(keysHints, KeyValidationHint.empty(), MAX_KEY_VALIDATION_REQUESTS_PER_TX);
+}
+export class PrivateKernelResetPrivateInputsBuilder {
+    previousKernelOutput;
+    executionStack;
+    noteHashNullifierCounterMap;
+    splitCounter;
+    previousKernel;
+    // If there's no next iteration, it's the final reset.
+    nextIteration;
+    noteHashResetActions;
+    nullifierResetActions;
+    numTransientData;
+    transientDataSquashingHints;
+    requestedDimensions;
+    constructor(previousKernelOutput, executionStack, noteHashNullifierCounterMap, splitCounter){
+        this.previousKernelOutput = previousKernelOutput;
+        this.executionStack = executionStack;
+        this.noteHashNullifierCounterMap = noteHashNullifierCounterMap;
+        this.splitCounter = splitCounter;
+        this.previousKernel = previousKernelOutput.publicInputs;
+        this.requestedDimensions = PrivateKernelResetDimensions.empty();
+        this.noteHashResetActions = ReadRequestResetActions.empty(MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
+        this.nullifierResetActions = ReadRequestResetActions.empty(MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+        this.transientDataSquashingHints = makeTuple(MAX_NULLIFIERS_PER_TX, ()=>new TransientDataSquashingHint(MAX_NULLIFIERS_PER_TX, MAX_NOTE_HASHES_PER_TX));
+        this.nextIteration = executionStack[this.executionStack.length - 1]?.publicInputs;
+    }
+    needsReset() {
+        const fns = [
+            ()=>this.needsResetNoteHashReadRequests(),
+            ()=>this.needsResetNullifierReadRequests(),
+            ()=>this.needsResetNullifierKeys(),
+            ()=>this.needsResetTransientData()
+        ];
+        if (this.nextIteration) {
+            // If there's a next iteration, reset is needed only when data of a dimension is about to overflow.
+            // fns are executed until a dimension that needs reset is found.
+            return fns.some((fn)=>fn());
+        } else {
+            // Siloing is only needed after processing all iterations.
+            fns.push(...[
+                ()=>this.needsSiloNoteHashes(),
+                ()=>this.needsSiloNullifiers(),
+                ()=>this.needsSiloPrivateLogs()
+            ]);
+            // If there's no next iteration, reset is needed when any of the dimension has non empty data.
+            // All the fns should to be executed so that data in all dimensions will be reset.
+            const result = fns.map((fn)=>fn());
+            return result.some((r)=>r);
+        }
+    }
+    async build(oracle) {
+        if (privateKernelResetDimensionNames.every((name)=>!this.requestedDimensions[name])) {
+            throw new Error('Reset is not required.');
+        }
+        const isInner = !!this.nextIteration;
+        // "final" reset must be done at most once.
+        // Because the code that silo note hashes can't be run repeatedly.
+        // The dimensions found must be big enough to reset all values, i.e. empty remainder.
+        const allowRemainder = isInner;
+        const dimensions = findPrivateKernelResetDimensions(this.requestedDimensions, privateKernelResetDimensionsConfig, isInner, allowRemainder);
+        this.reduceReadRequestActions(this.noteHashResetActions, dimensions.NOTE_HASH_PENDING_READ, dimensions.NOTE_HASH_SETTLED_READ);
+        this.reduceReadRequestActions(this.nullifierResetActions, dimensions.NULLIFIER_PENDING_READ, dimensions.NULLIFIER_SETTLED_READ);
+        // Execute all the expensive node querying operations in parallel.
+        const [previousVkMembershipWitness, noteHashReadRequestHints, nullifierReadRequestHints, keyValidationHints] = await Promise.all([
+            oracle.getVkMembershipWitness(this.previousKernelOutput.verificationKey.keyAsFields),
+            buildNoteHashReadRequestHintsFromResetActions(oracle, this.previousKernel.validationRequests.noteHashReadRequests, this.previousKernel.end.noteHashes, this.noteHashResetActions),
+            buildNullifierReadRequestHintsFromResetActions({
+                getNullifierMembershipWitness: getNullifierMembershipWitnessResolver(oracle)
+            }, this.previousKernel.validationRequests.nullifierReadRequests, this.nullifierResetActions),
+            getMasterSecretKeysAndAppKeyGenerators(this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators, dimensions.KEY_VALIDATION, oracle)
+        ]);
+        const vkData = new VkData(this.previousKernelOutput.verificationKey, Number(previousVkMembershipWitness.leafIndex), previousVkMembershipWitness.siblingPath);
+        const previousKernelData = new PrivateKernelData(this.previousKernelOutput.publicInputs, vkData);
+        // TODO: Enable padding when we have a better idea what are the final amounts we should pad to.
+        const paddedSideEffects = PaddedSideEffects.empty();
+        return new PrivateKernelResetCircuitPrivateInputs(previousKernelData, paddedSideEffects, new PrivateKernelResetHints(noteHashReadRequestHints, nullifierReadRequestHints, keyValidationHints, this.transientDataSquashingHints), dimensions);
+    }
+    reduceReadRequestActions(resetActions, maxPending, maxSettled) {
+        let numPending = 0;
+        let numSettled = 0;
+        for(let i = 0; i < resetActions.actions.length; i++){
+            const action = resetActions.actions[i];
+            if (action === ReadRequestActionEnum.READ_AS_PENDING) {
+                if (numPending < maxPending) {
+                    numPending++;
+                } else {
+                    resetActions.actions[i] = ReadRequestActionEnum.SKIP;
+                }
+            } else if (action === ReadRequestActionEnum.READ_AS_SETTLED) {
+                if (numSettled < maxSettled) {
+                    numSettled++;
+                } else {
+                    resetActions.actions[i] = ReadRequestActionEnum.SKIP;
+                }
+            }
+        }
+        resetActions.pendingReadHints = resetActions.pendingReadHints.slice(0, maxPending);
+    }
+    needsResetNoteHashReadRequests(forceResetAll = false) {
+        const numCurr = this.previousKernel.validationRequests.noteHashReadRequests.claimedLength;
+        const numNext = this.nextIteration ? this.nextIteration.noteHashReadRequests.claimedLength : 0;
+        const maxAmountToKeep = !this.nextIteration || forceResetAll ? 0 : MAX_NOTE_HASH_READ_REQUESTS_PER_TX;
+        if (numCurr + numNext <= maxAmountToKeep) {
+            return false;
+        }
+        const futureNoteHashes = collectNested(this.executionStack, (executionResult)=>{
+            return executionResult.publicInputs.noteHashes.getActiveItems().map((noteHash)=>new ScopedNoteHash(noteHash, executionResult.publicInputs.callContext.contractAddress));
+        });
+        const resetActions = getNoteHashReadRequestResetActions(this.previousKernel.validationRequests.noteHashReadRequests, this.previousKernel.end.noteHashes, futureNoteHashes);
+        const numPendingReads = resetActions.pendingReadHints.length;
+        const numSettledReads = resetActions.actions.reduce((accum, action)=>accum + (action === ReadRequestActionEnum.READ_AS_SETTLED ? 1 : 0), 0);
+        if (!this.nextIteration) {
+            this.noteHashResetActions = resetActions;
+            this.requestedDimensions.NOTE_HASH_PENDING_READ = numPendingReads;
+            this.requestedDimensions.NOTE_HASH_SETTLED_READ = numSettledReads;
+        } else {
+            // Pick only one dimension to reset if next iteration is not empty.
+            if (numPendingReads > numSettledReads) {
+                this.requestedDimensions.NOTE_HASH_PENDING_READ = numPendingReads;
+                this.noteHashResetActions.actions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_PENDING ? action : ReadRequestActionEnum.SKIP), MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
+                this.noteHashResetActions.pendingReadHints = resetActions.pendingReadHints;
+            } else {
+                this.requestedDimensions.NOTE_HASH_SETTLED_READ = numSettledReads;
+                this.noteHashResetActions.actions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_SETTLED ? action : ReadRequestActionEnum.SKIP), MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
+            }
+        }
+        return true;
+    }
+    needsResetNullifierReadRequests(forceResetAll = false) {
+        const numCurr = this.previousKernel.validationRequests.nullifierReadRequests.claimedLength;
+        const numNext = this.nextIteration ? this.nextIteration.nullifierReadRequests.claimedLength : 0;
+        const maxAmountToKeep = !this.nextIteration || forceResetAll ? 0 : MAX_NULLIFIER_READ_REQUESTS_PER_TX;
+        if (numCurr + numNext <= maxAmountToKeep) {
+            return false;
+        }
+        const futureNullifiers = collectNested(this.executionStack, (executionResult)=>{
+            return executionResult.publicInputs.nullifiers.getActiveItems().map((nullifier)=>new ScopedNullifier(nullifier, executionResult.publicInputs.callContext.contractAddress));
+        });
+        const resetActions = getNullifierReadRequestResetActions(this.previousKernel.validationRequests.nullifierReadRequests, this.previousKernel.end.nullifiers, futureNullifiers);
+        const numPendingReads = resetActions.pendingReadHints.length;
+        const numSettledReads = resetActions.actions.reduce((accum, action)=>accum + (action === ReadRequestActionEnum.READ_AS_SETTLED ? 1 : 0), 0);
+        if (!this.nextIteration) {
+            this.nullifierResetActions = resetActions;
+            this.requestedDimensions.NULLIFIER_PENDING_READ = numPendingReads;
+            this.requestedDimensions.NULLIFIER_SETTLED_READ = numSettledReads;
+        } else {
+            // Pick only one dimension to reset if next iteration is not empty.
+            if (numPendingReads > numSettledReads) {
+                this.requestedDimensions.NULLIFIER_PENDING_READ = numPendingReads;
+                this.nullifierResetActions.actions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_PENDING ? action : ReadRequestActionEnum.SKIP), MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+                this.nullifierResetActions.pendingReadHints = resetActions.pendingReadHints;
+            } else {
+                this.requestedDimensions.NULLIFIER_SETTLED_READ = numSettledReads;
+                this.nullifierResetActions.actions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_SETTLED ? action : ReadRequestActionEnum.SKIP), MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+            }
+        }
+        return true;
+    }
+    needsResetNullifierKeys() {
+        const numCurr = this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators.claimedLength;
+        const numNext = this.nextIteration ? this.nextIteration.keyValidationRequestsAndGenerators.claimedLength : 0;
+        const maxAmountToKeep = !this.nextIteration ? 0 : MAX_KEY_VALIDATION_REQUESTS_PER_TX;
+        if (numCurr + numNext <= maxAmountToKeep) {
+            return false;
+        }
+        this.requestedDimensions.KEY_VALIDATION = numCurr;
+        return true;
+    }
+    needsResetTransientData() {
+        // Initialize this to 0 so that needsSilo can be run.
+        this.numTransientData = 0;
+        const nextAccumNoteHashes = this.previousKernel.end.noteHashes.claimedLength + (this.nextIteration?.noteHashes.claimedLength ?? 0);
+        const noteHashWillOverflow = nextAccumNoteHashes > MAX_NOTE_HASHES_PER_TX;
+        const nextAccumNullifiers = this.previousKernel.end.nullifiers.claimedLength + (this.nextIteration?.nullifiers.claimedLength ?? 0);
+        const nullifierWillOverflow = nextAccumNullifiers > MAX_NULLIFIERS_PER_TX;
+        const nextAccumLogs = this.previousKernel.end.privateLogs.claimedLength + (this.nextIteration?.privateLogs.claimedLength ?? 0);
+        const logsWillOverflow = nextAccumLogs > MAX_PRIVATE_LOGS_PER_TX;
+        if (this.nextIteration && !noteHashWillOverflow && !nullifierWillOverflow && !logsWillOverflow) {
+            return false;
+        }
+        const futureNoteHashReads = collectNestedReadRequests(this.executionStack, (executionResult)=>executionResult.publicInputs.noteHashReadRequests);
+        const futureNullifierReads = collectNestedReadRequests(this.executionStack, (executionResult)=>executionResult.publicInputs.nullifierReadRequests);
+        // TODO(#15902): Collect future logs and only allow squashing a note hash when all its logs have been emitted
+        // (i.e. none of the future logs are linked to the to-be-squashed note hashes).
+        if (this.nextIteration) {
+            // If it's not the final reset, only one dimension will be reset at a time.
+            // The note hashes and nullifiers for the remaining read requests can't be squashed.
+            futureNoteHashReads.push(...this.previousKernel.validationRequests.noteHashReadRequests.getActiveItems());
+            futureNullifierReads.push(...this.previousKernel.validationRequests.nullifierReadRequests.getActiveItems());
+        }
+        const { numTransientData, hints: transientDataSquashingHints } = buildTransientDataHints(this.previousKernel.end.noteHashes, this.previousKernel.end.nullifiers, futureNoteHashReads, futureNullifierReads, this.noteHashNullifierCounterMap, this.splitCounter);
+        if (this.nextIteration && !numTransientData) {
+            const forceResetAll = true;
+            const canClearReadRequests = noteHashWillOverflow && this.needsResetNoteHashReadRequests(forceResetAll) || nullifierWillOverflow && this.needsResetNullifierReadRequests(forceResetAll) || logsWillOverflow && this.needsResetNoteHashReadRequests(forceResetAll);
+            if (!canClearReadRequests) {
+                const overflownData = noteHashWillOverflow ? 'note hashes' : nullifierWillOverflow ? 'nullifiers' : 'private logs';
+                throw new Error(`Number of ${overflownData} exceeds the limit.`);
+            }
+            // Clearing the read requests might not be enough to squash the overflown data.
+            // In this case, the next iteration will fail at the above check.
+            return true;
+        }
+        this.numTransientData = numTransientData;
+        this.transientDataSquashingHints = transientDataSquashingHints;
+        this.requestedDimensions.TRANSIENT_DATA_SQUASHING = numTransientData;
+        return numTransientData > 0;
+    }
+    needsSiloNoteHashes() {
+        if (this.numTransientData === undefined) {
+            throw new Error('`needsResetTransientData` must be run before `needsSiloNoteHashes`.');
+        }
+        const numNoteHashes = this.previousKernel.end.noteHashes.getActiveItems().filter((n)=>!n.contractAddress.isZero()).length;
+        const numToSilo = Math.max(0, numNoteHashes - this.numTransientData);
+        this.requestedDimensions.NOTE_HASH_SILOING = numToSilo;
+        return numToSilo > 0;
+    }
+    needsSiloNullifiers() {
+        if (this.numTransientData === undefined) {
+            throw new Error('`needsResetTransientData` must be run before `needsSiloNullifiers`.');
+        }
+        const numNullifiers = this.previousKernel.end.nullifiers.getActiveItems().filter((n)=>!n.contractAddress.isZero()).length;
+        const numToSilo = Math.max(0, numNullifiers - this.numTransientData);
+        // Include the first nullifier if there's something to silo.
+        // The reset circuit checks that capped_size must be greater than or equal to all non-empty nullifiers.
+        // Which includes the first nullifier, even though its contract address is always zero and doesn't need siloing.
+        const cappedSize = numToSilo ? numToSilo + 1 : 0;
+        this.requestedDimensions.NULLIFIER_SILOING = cappedSize;
+        return numToSilo > 0;
+    }
+    needsSiloPrivateLogs() {
+        if (this.numTransientData === undefined) {
+            throw new Error('`needsResetTransientData` must be run before `needsSiloPrivateLogs`.');
+        }
+        const privateLogs = this.previousKernel.end.privateLogs;
+        const numLogs = privateLogs.getActiveItems().filter((l)=>!l.contractAddress.isZero()).length;
+        const noteHashes = this.previousKernel.end.noteHashes;
+        const squashedNoteHashCounters = this.transientDataSquashingHints.filter((h)=>h.noteHashIndex < noteHashes.claimedLength).map((h)=>noteHashes.array[h.noteHashIndex].counter);
+        const numSquashedLogs = privateLogs.getActiveItems().filter((l)=>squashedNoteHashCounters.includes(l.inner.noteHashCounter)).length;
+        const numToSilo = numLogs - numSquashedLogs;
+        this.requestedDimensions.PRIVATE_LOG_SILOING = numToSilo;
+        return numToSilo > 0;
+    }
+}

package/dest/private_kernel/index.d.ts

@@ -0,0 +1,3 @@
+export * from './private_kernel_execution_prover.js';
+export * from './private_kernel_oracle.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcml2YXRlX2tlcm5lbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsNEJBQTRCLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/private_kernel/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,4BAA4B,CAAC"}

package/dest/private_kernel/index.js

@@ -0,0 +1,2 @@
+export * from './private_kernel_execution_prover.js';
+export * from './private_kernel_oracle.js';