@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/interfaces/world_state.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from './merkle_tree_operations.js';
+/**
+ * Defines the possible states of the world state synchronizer.
+ */
+export declare enum WorldStateRunningState {
+    IDLE = 0,
+    SYNCHING = 1,
+    RUNNING = 2,
+    STOPPED = 3
+}
+export interface WorldStateSyncStatus {
+    latestBlockNumber: number;
+    latestBlockHash: string;
+    finalisedBlockNumber: number;
+    oldestHistoricBlockNumber: number;
+    treesAreSynched: boolean;
+}
+/**
+ * Defines the status of the world state synchronizer.
+ */
+export interface WorldStateSynchronizerStatus {
+    /**
+     * The current state of the world state synchronizer.
+     */
+    state: WorldStateRunningState;
+    /**
+     * The block numbers that the world state synchronizer is synced to.
+     */
+    syncSummary: WorldStateSyncStatus;
+}
+/** Provides writeable forks of the world state at a given block number. */
+export interface ForkMerkleTreeOperations {
+    /** Forks the world state at the given block number, defaulting to the latest one. */
+    fork(block?: number): Promise<MerkleTreeWriteOperations>;
+    /** Gets a handle that allows reading the state as it was at the given block number. */
+    getSnapshot(blockNumber: number): MerkleTreeReadOperations;
+}
+/** Defines the interface for a world state synchronizer. */
+export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
+    /**
+     * Starts the synchronizer.
+     * @returns A promise that resolves once the initial sync is completed.
+     */
+    start(): void;
+    /**
+     * Returns the current status of the synchronizer.
+     * @returns The current status of the synchronizer.
+     */
+    status(): Promise<WorldStateSynchronizerStatus>;
+    /**
+     * Stops the synchronizer.
+     */
+    stop(): Promise<void>;
+    /**
+     * Forces an immediate sync to an optionally provided minimum block number
+     * @param minBlockNumber - The minimum block number that we must sync to
+     * @returns A promise that resolves with the block number the world state was synced to
+     */
+    syncImmediate(minBlockNumber?: number): Promise<number>;
+    /**
+     * Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data.
+     */
+    getCommitted(): MerkleTreeReadOperations;
+}
+export declare const WorldStateSyncStatusSchema: z.ZodObject<{
+    finalisedBlockNumber: z.ZodNumber;
+    latestBlockNumber: z.ZodNumber;
+    latestBlockHash: z.ZodString;
+    oldestHistoricBlockNumber: z.ZodNumber;
+    treesAreSynched: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    finalisedBlockNumber: number;
+    latestBlockNumber: number;
+    latestBlockHash: string;
+    oldestHistoricBlockNumber: number;
+    treesAreSynched: boolean;
+}, {
+    finalisedBlockNumber: number;
+    latestBlockNumber: number;
+    latestBlockHash: string;
+    oldestHistoricBlockNumber: number;
+    treesAreSynched: boolean;
+}>;
+//# sourceMappingURL=world_state.d.ts.map

package/dest/interfaces/world_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world_state.d.ts","sourceRoot":"","sources":["../../src/interfaces/world_state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAEvG;;GAEG;AACH,oBAAY,sBAAsB;IAChC,IAAI,IAAA;IACJ,QAAQ,IAAA;IACR,OAAO,IAAA;IACP,OAAO,IAAA;CACR;AAED,MAAM,WAAW,oBAAoB;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;OAEG;IACH,KAAK,EAAE,sBAAsB,CAAC;IAC9B;;OAEG;IACH,WAAW,EAAE,oBAAoB,CAAC;CACnC;AAED,2EAA2E;AAC3E,MAAM,WAAW,wBAAwB;IACvC,qFAAqF;IACrF,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;IAEzD,uFAAuF;IACvF,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,wBAAwB,CAAC;CAC5D;AAED,4DAA4D;AAC5D,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACtE;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;OAGG;IACH,MAAM,IAAI,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAEhD;;OAEG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtB;;;;OAIG;IACH,aAAa,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAExD;;OAEG;IACH,YAAY,IAAI,wBAAwB,CAAC;CAC1C;AAED,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;EAMK,CAAC"}

package/dest/interfaces/world_state.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+/**
+ * Defines the possible states of the world state synchronizer.
+ */ export var WorldStateRunningState = /*#__PURE__*/ function(WorldStateRunningState) {
+    WorldStateRunningState[WorldStateRunningState["IDLE"] = 0] = "IDLE";
+    WorldStateRunningState[WorldStateRunningState["SYNCHING"] = 1] = "SYNCHING";
+    WorldStateRunningState[WorldStateRunningState["RUNNING"] = 2] = "RUNNING";
+    WorldStateRunningState[WorldStateRunningState["STOPPED"] = 3] = "STOPPED";
+    return WorldStateRunningState;
+}({});
+export const WorldStateSyncStatusSchema = z.object({
+    finalisedBlockNumber: z.number(),
+    latestBlockNumber: z.number(),
+    latestBlockHash: z.string(),
+    oldestHistoricBlockNumber: z.number(),
+    treesAreSynched: z.boolean()
+});

package/dest/kernel/combined_constant_data.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { BlockHeader } from '../tx/block_header.js';
+import { GlobalVariables } from '../tx/global_variables.js';
+import type { TxConstantData } from '../tx/tx_constant_data.js';
+import { TxContext } from '../tx/tx_context.js';
+/**
+ * Data that is constant/not modified by neither of the kernels.
+ */
+export declare class CombinedConstantData {
+    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
+    historicalHeader: BlockHeader;
+    /**
+     * Context of the transaction.
+     *
+     * Note: `chainId` and `version` in txContext are not redundant to the values in
+     * self.historical_header.global_variables because they can be different in case of a protocol upgrade. In such
+     * a situation we could be using header from a block before the upgrade took place but be using the updated
+     * protocol to execute and prove the transaction.
+     */
+    txContext: TxContext;
+    /**
+     * Root of the vk tree for the protocol circuits.
+     */
+    vkTreeRoot: Fr;
+    /**
+     * Root of the tree for the protocol contracts.
+     */
+    protocolContractTreeRoot: Fr;
+    /** Present when output by a public kernel, empty otherwise. */
+    globalVariables: GlobalVariables;
+    constructor(
+    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
+    historicalHeader: BlockHeader, 
+    /**
+     * Context of the transaction.
+     *
+     * Note: `chainId` and `version` in txContext are not redundant to the values in
+     * self.historical_header.global_variables because they can be different in case of a protocol upgrade. In such
+     * a situation we could be using header from a block before the upgrade took place but be using the updated
+     * protocol to execute and prove the transaction.
+     */
+    txContext: TxContext, 
+    /**
+     * Root of the vk tree for the protocol circuits.
+     */
+    vkTreeRoot: Fr, 
+    /**
+     * Root of the tree for the protocol contracts.
+     */
+    protocolContractTreeRoot: Fr, 
+    /** Present when output by a public kernel, empty otherwise. */
+    globalVariables: GlobalVariables);
+    static combine(TxConstantData: TxConstantData, globalVariables: GlobalVariables): CombinedConstantData;
+    static get schema(): ZodFor<CombinedConstantData>;
+    toBuffer(): Buffer;
+    clone(): CombinedConstantData;
+    getSize(): number;
+    static from({ historicalHeader, txContext, vkTreeRoot, protocolContractTreeRoot, globalVariables, }: FieldsOf<CombinedConstantData>): CombinedConstantData;
+    /**
+     * Deserializes from a buffer or reader, corresponding to a write in cpp.
+     * @param buffer - Buffer or buffer reader to read from.
+     * @returns A new instance of CombinedConstantData.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): CombinedConstantData;
+    static fromFields(fields: Fr[] | FieldReader): CombinedConstantData;
+    static empty(): CombinedConstantData;
+}
+//# sourceMappingURL=combined_constant_data.d.ts.map

package/dest/kernel/combined_constant_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combined_constant_data.d.ts","sourceRoot":"","sources":["../../src/kernel/combined_constant_data.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,MAAM,EAAyB,MAAM,2BAA2B,CAAC;AAC/E,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAC3F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAIxD,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD;;GAEG;AACH,qBAAa,oBAAoB;IAE7B,6GAA6G;IACtG,gBAAgB,EAAE,WAAW;IACpC;;;;;;;OAOG;IACI,SAAS,EAAE,SAAS;IAC3B;;OAEG;IACI,UAAU,EAAE,EAAE;IACrB;;OAEG;IACI,wBAAwB,EAAE,EAAE;IACnC,+DAA+D;IACxD,eAAe,EAAE,eAAe;;IApBvC,6GAA6G;IACtG,gBAAgB,EAAE,WAAW;IACpC;;;;;;;OAOG;IACI,SAAS,EAAE,SAAS;IAC3B;;OAEG;IACI,UAAU,EAAE,EAAE;IACrB;;OAEG;IACI,wBAAwB,EAAE,EAAE;IACnC,+DAA+D;IACxD,eAAe,EAAE,eAAe;IAGzC,MAAM,CAAC,OAAO,CAAC,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,eAAe;IAU/E,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,oBAAoB,CAAC,CAWhD;IAED,QAAQ;IAUR,KAAK,IAAI,oBAAoB;IAI7B,OAAO;IAUP,MAAM,CAAC,IAAI,CAAC,EACV,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,wBAAwB,EACxB,eAAe,GAChB,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,oBAAoB;IAIxD;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,oBAAoB;IAWtE,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,oBAAoB;IAWnE,MAAM,CAAC,KAAK;CAGb"}

package/dest/kernel/combined_constant_data.js

@@ -0,0 +1,73 @@
+import { Fr } from '@aztec/foundation/fields';
+import { hexSchemaFor, schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { BlockHeader } from '../tx/block_header.js';
+import { GlobalVariables } from '../tx/global_variables.js';
+import { TxContext } from '../tx/tx_context.js';
+/**
+ * Data that is constant/not modified by neither of the kernels.
+ */ export class CombinedConstantData {
+    historicalHeader;
+    txContext;
+    vkTreeRoot;
+    protocolContractTreeRoot;
+    globalVariables;
+    constructor(/** Header of a block whose state is used during execution (not the block the transaction is included in). */ historicalHeader, /**
+     * Context of the transaction.
+     *
+     * Note: `chainId` and `version` in txContext are not redundant to the values in
+     * self.historical_header.global_variables because they can be different in case of a protocol upgrade. In such
+     * a situation we could be using header from a block before the upgrade took place but be using the updated
+     * protocol to execute and prove the transaction.
+     */ txContext, /**
+     * Root of the vk tree for the protocol circuits.
+     */ vkTreeRoot, /**
+     * Root of the tree for the protocol contracts.
+     */ protocolContractTreeRoot, /** Present when output by a public kernel, empty otherwise. */ globalVariables){
+        this.historicalHeader = historicalHeader;
+        this.txContext = txContext;
+        this.vkTreeRoot = vkTreeRoot;
+        this.protocolContractTreeRoot = protocolContractTreeRoot;
+        this.globalVariables = globalVariables;
+    }
+    static combine(TxConstantData, globalVariables) {
+        return new CombinedConstantData(TxConstantData.historicalHeader, TxConstantData.txContext, TxConstantData.vkTreeRoot, TxConstantData.protocolContractTreeRoot, globalVariables);
+    }
+    static get schema() {
+        return z.object({
+            historicalHeader: BlockHeader.schema,
+            txContext: TxContext.schema,
+            vkTreeRoot: schemas.Fr,
+            protocolContractTreeRoot: schemas.Fr,
+            globalVariables: GlobalVariables.schema
+        }).transform(CombinedConstantData.from).or(hexSchemaFor(CombinedConstantData));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.historicalHeader, this.txContext, this.vkTreeRoot, this.protocolContractTreeRoot, this.globalVariables);
+    }
+    clone() {
+        return CombinedConstantData.fromBuffer(this.toBuffer());
+    }
+    getSize() {
+        return this.historicalHeader.getSize() + this.txContext.getSize() + this.vkTreeRoot.size + this.protocolContractTreeRoot.size + this.globalVariables.getSize();
+    }
+    static from({ historicalHeader, txContext, vkTreeRoot, protocolContractTreeRoot, globalVariables }) {
+        return new CombinedConstantData(historicalHeader, txContext, vkTreeRoot, protocolContractTreeRoot, globalVariables);
+    }
+    /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer or buffer reader to read from.
+   * @returns A new instance of CombinedConstantData.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new CombinedConstantData(reader.readObject(BlockHeader), reader.readObject(TxContext), Fr.fromBuffer(reader), Fr.fromBuffer(reader), reader.readObject(GlobalVariables));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new CombinedConstantData(reader.readObject(BlockHeader), reader.readObject(TxContext), reader.readField(), reader.readField(), reader.readObject(GlobalVariables));
+    }
+    static empty() {
+        return new CombinedConstantData(BlockHeader.empty(), TxContext.empty(), Fr.ZERO, Fr.ZERO, GlobalVariables.empty());
+    }
+}

package/dest/kernel/hints/build_note_hash_read_request_hints.d.ts

@@ -0,0 +1,15 @@
+import { type MAX_NOTE_HASHES_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_TX, type NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
+import type { Tuple } from '@aztec/foundation/serialize';
+import type { MembershipWitness } from '@aztec/foundation/trees';
+import type { ScopedNoteHash } from '../note_hash.js';
+import type { ScopedReadRequest } from './read_request.js';
+import { ReadRequestResetStates } from './read_request_hints.js';
+export declare function isValidNoteHashReadRequest(readRequest: ScopedReadRequest, noteHash: ScopedNoteHash): boolean;
+export declare function getNoteHashReadRequestResetStates(noteHashReadRequests: Tuple<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>, noteHashes: Tuple<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>, futureNoteHashes: ScopedNoteHash[]): ReadRequestResetStates<typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>;
+export declare function buildNoteHashReadRequestHintsFromResetStates<PENDING extends number, SETTLED extends number>(oracle: {
+    getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
+}, noteHashReadRequests: Tuple<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>, noteHashes: Tuple<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>, resetStates: ReadRequestResetStates<typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>, noteHashLeafIndexMap: Map<bigint, bigint>, maxPending?: PENDING, maxSettled?: SETTLED): Promise<import("./note_hash_read_request_hints.js").NoteHashReadRequestHints<PENDING, SETTLED>>;
+export declare function buildNoteHashReadRequestHints<PENDING extends number, SETTLED extends number>(oracle: {
+    getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
+}, noteHashReadRequests: Tuple<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>, noteHashes: Tuple<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>, noteHashLeafIndexMap: Map<bigint, bigint>, futureNoteHashes: ScopedNoteHash[], maxPending?: PENDING, maxSettled?: SETTLED): Promise<import("./note_hash_read_request_hints.js").NoteHashReadRequestHints<PENDING, SETTLED>>;
+//# sourceMappingURL=build_note_hash_read_request_hints.d.ts.map

package/dest/kernel/hints/build_note_hash_read_request_hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_note_hash_read_request_hints.d.ts","sourceRoot":"","sources":["../../../src/kernel/hints/build_note_hash_read_request_hints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,sBAAsB,EAC3B,kCAAkC,EAClC,KAAK,qBAAqB,EAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAmB,sBAAsB,EAAoB,MAAM,yBAAyB,CAAC;AAGpG,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,iBAAiB,EAAE,QAAQ,EAAE,cAAc,WAMlG;AAED,wBAAgB,iCAAiC,CAC/C,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,EAAE,OAAO,kCAAkC,CAAC,EACzF,UAAU,EAAE,KAAK,CAAC,cAAc,EAAE,OAAO,sBAAsB,CAAC,EAChE,gBAAgB,EAAE,cAAc,EAAE,GACjC,sBAAsB,CAAC,OAAO,kCAAkC,CAAC,CAkCnE;AAED,wBAAsB,4CAA4C,CAAC,OAAO,SAAS,MAAM,EAAE,OAAO,SAAS,MAAM,EAC/G,MAAM,EAAE;IACN,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAAC;CAC3G,EACD,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,EAAE,OAAO,kCAAkC,CAAC,EACzF,UAAU,EAAE,KAAK,CAAC,cAAc,EAAE,OAAO,sBAAsB,CAAC,EAChE,WAAW,EAAE,sBAAsB,CAAC,OAAO,kCAAkC,CAAC,EAC9E,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,UAAU,GAAE,OAAuD,EACnE,UAAU,GAAE,OAAuD,mGA6BpE;AAED,wBAAsB,6BAA6B,CAAC,OAAO,SAAS,MAAM,EAAE,OAAO,SAAS,MAAM,EAChG,MAAM,EAAE;IACN,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAAC;CAC3G,EACD,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,EAAE,OAAO,kCAAkC,CAAC,EACzF,UAAU,EAAE,KAAK,CAAC,cAAc,EAAE,OAAO,sBAAsB,CAAC,EAChE,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,gBAAgB,EAAE,cAAc,EAAE,EAClC,UAAU,GAAE,OAAuD,EACnE,UAAU,GAAE,OAAuD,mGAYpE"}

package/dest/kernel/hints/build_note_hash_read_request_hints.js

@@ -0,0 +1,66 @@
+import { MAX_NOTE_HASH_READ_REQUESTS_PER_TX } from '@aztec/constants';
+import { countAccumulatedItems, getNonEmptyItems } from '../utils/order_and_comparison.js';
+import { NoteHashReadRequestHintsBuilder } from './note_hash_read_request_hints.js';
+import { PendingReadHint, ReadRequestResetStates, ReadRequestState } from './read_request_hints.js';
+import { ScopedValueCache } from './scoped_value_cache.js';
+export function isValidNoteHashReadRequest(readRequest, noteHash) {
+    return noteHash.value.equals(readRequest.value) && noteHash.contractAddress.equals(readRequest.contractAddress) && readRequest.counter > noteHash.counter;
+}
+export function getNoteHashReadRequestResetStates(noteHashReadRequests, noteHashes, futureNoteHashes) {
+    const resetStates = ReadRequestResetStates.empty(MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
+    const noteHashMap = new Map();
+    getNonEmptyItems(noteHashes).forEach((noteHash, index)=>{
+        const value = noteHash.value.toBigInt();
+        const arr = noteHashMap.get(value) ?? [];
+        arr.push({
+            noteHash,
+            index
+        });
+        noteHashMap.set(value, arr);
+    });
+    const futureNoteHashMap = new ScopedValueCache(futureNoteHashes);
+    const numReadRequests = countAccumulatedItems(noteHashReadRequests);
+    for(let i = 0; i < numReadRequests; ++i){
+        const readRequest = noteHashReadRequests[i];
+        const pendingNoteHash = noteHashMap.get(readRequest.value.toBigInt())?.find((n)=>isValidNoteHashReadRequest(readRequest, n.noteHash));
+        if (pendingNoteHash !== undefined) {
+            resetStates.states[i] = ReadRequestState.PENDING;
+            resetStates.pendingReadHints.push(new PendingReadHint(i, pendingNoteHash.index));
+        } else if (!futureNoteHashMap.get(readRequest).find((futureNoteHash)=>isValidNoteHashReadRequest(readRequest, futureNoteHash))) {
+            resetStates.states[i] = ReadRequestState.SETTLED;
+        }
+    }
+    return resetStates;
+}
+export async function buildNoteHashReadRequestHintsFromResetStates(oracle, noteHashReadRequests, noteHashes, resetStates, noteHashLeafIndexMap, maxPending = MAX_NOTE_HASH_READ_REQUESTS_PER_TX, maxSettled = MAX_NOTE_HASH_READ_REQUESTS_PER_TX) {
+    const builder = new NoteHashReadRequestHintsBuilder(maxPending, maxSettled);
+    resetStates.pendingReadHints.forEach((hint)=>{
+        builder.addPendingReadRequest(hint.readRequestIndex, hint.pendingValueIndex);
+    });
+    for(let i = 0; i < resetStates.states.length; i++){
+        if (resetStates.states[i] === ReadRequestState.SETTLED) {
+            const readRequest = noteHashReadRequests[i];
+            const leafIndex = noteHashLeafIndexMap.get(readRequest.value.toBigInt());
+            if (leafIndex === undefined) {
+                throw new Error('Read request is reading an unknown note hash.');
+            }
+            const membershipWitness = await oracle.getNoteHashMembershipWitness(leafIndex);
+            builder.addSettledReadRequest(i, membershipWitness, readRequest.value);
+        }
+    }
+    const noteHashMap = new Map();
+    getNonEmptyItems(noteHashes).forEach((noteHash, index)=>{
+        const value = noteHash.value.toBigInt();
+        const arr = noteHashMap.get(value) ?? [];
+        arr.push({
+            noteHash,
+            index
+        });
+        noteHashMap.set(value, arr);
+    });
+    return builder.toHints();
+}
+export async function buildNoteHashReadRequestHints(oracle, noteHashReadRequests, noteHashes, noteHashLeafIndexMap, futureNoteHashes, maxPending = MAX_NOTE_HASH_READ_REQUESTS_PER_TX, maxSettled = MAX_NOTE_HASH_READ_REQUESTS_PER_TX) {
+    const resetStates = getNoteHashReadRequestResetStates(noteHashReadRequests, noteHashes, futureNoteHashes);
+    return await buildNoteHashReadRequestHintsFromResetStates(oracle, noteHashReadRequests, noteHashes, resetStates, noteHashLeafIndexMap, maxPending, maxSettled);
+}

package/dest/kernel/hints/build_nullifier_read_request_hints.d.ts

@@ -0,0 +1,24 @@
+import { type MAX_NULLIFIERS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_TX, type NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/fields';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { type IndexedTreeLeafPreimage, MembershipWitness } from '@aztec/foundation/trees';
+import { Nullifier, type ScopedNullifier } from '../nullifier.js';
+import { ScopedReadRequest } from './read_request.js';
+import { ReadRequestResetStates } from './read_request_hints.js';
+export declare function isValidNullifierReadRequest(readRequest: ScopedReadRequest, nullifier: ScopedNullifier): boolean;
+interface NullifierMembershipWitnessWithPreimage {
+    membershipWitness: MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>;
+    leafPreimage: IndexedTreeLeafPreimage;
+}
+export declare function getNullifierReadRequestResetStates(nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>, nullifiers: Tuple<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>, futureNullifiers: ScopedNullifier[]): ReadRequestResetStates<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>;
+export declare function buildNullifierReadRequestHintsFromResetStates<PENDING extends number, SETTLED extends number>(oracle: {
+    getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitnessWithPreimage>;
+}, nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>, resetStates: ReadRequestResetStates<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>, maxPending?: PENDING, maxSettled?: SETTLED, siloed?: boolean): Promise<import("./nullifier_read_request_hints.js").NullifierReadRequestHints<PENDING, SETTLED>>;
+export declare function buildNullifierReadRequestHints<PENDING extends number, SETTLED extends number>(oracle: {
+    getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitnessWithPreimage>;
+}, nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>, nullifiers: Tuple<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>, futureNullifiers: ScopedNullifier[], maxPending?: PENDING, maxSettled?: SETTLED, siloed?: boolean): Promise<import("./nullifier_read_request_hints.js").NullifierReadRequestHints<PENDING, SETTLED>>;
+export declare function buildSiloedNullifierReadRequestHints<PENDING extends number, SETTLED extends number>(oracle: {
+    getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitnessWithPreimage>;
+}, nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>, nullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>, maxPending?: PENDING, maxSettled?: SETTLED): Promise<import("./nullifier_read_request_hints.js").NullifierReadRequestHints<PENDING, SETTLED>>;
+export {};
+//# sourceMappingURL=build_nullifier_read_request_hints.d.ts.map

package/dest/kernel/hints/build_nullifier_read_request_hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_nullifier_read_request_hints.d.ts","sourceRoot":"","sources":["../../../src/kernel/hints/build_nullifier_read_request_hints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,qBAAqB,EAC1B,kCAAkC,EAClC,KAAK,qBAAqB,EAC3B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,KAAK,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAI1F,OAAO,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlE,OAAO,EAAe,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAmB,sBAAsB,EAAoB,MAAM,yBAAyB,CAAC;AAGpG,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,iBAAiB,EAAE,SAAS,EAAE,eAAe,WAMrG;AAED,UAAU,sCAAsC;IAC9C,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,CAAC;IACnE,YAAY,EAAE,uBAAuB,CAAC;CACvC;AAED,wBAAgB,kCAAkC,CAChD,qBAAqB,EAAE,KAAK,CAAC,iBAAiB,EAAE,OAAO,kCAAkC,CAAC,EAC1F,UAAU,EAAE,KAAK,CAAC,eAAe,EAAE,OAAO,qBAAqB,CAAC,EAChE,gBAAgB,EAAE,eAAe,EAAE,GAClC,sBAAsB,CAAC,OAAO,kCAAkC,CAAC,CAkCnE;AAED,wBAAsB,6CAA6C,CAAC,OAAO,SAAS,MAAM,EAAE,OAAO,SAAS,MAAM,EAChH,MAAM,EAAE;IACN,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,sCAAsC,CAAC,CAAC;CAC/F,EACD,qBAAqB,EAAE,KAAK,CAAC,iBAAiB,EAAE,OAAO,kCAAkC,CAAC,EAC1F,WAAW,EAAE,sBAAsB,CAAC,OAAO,kCAAkC,CAAC,EAC9E,UAAU,GAAE,OAAuD,EACnE,UAAU,GAAE,OAAuD,EACnE,MAAM,UAAQ,oGAwBf;AAED,wBAAsB,8BAA8B,CAAC,OAAO,SAAS,MAAM,EAAE,OAAO,SAAS,MAAM,EACjG,MAAM,EAAE;IACN,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,sCAAsC,CAAC,CAAC;CAC/F,EACD,qBAAqB,EAAE,KAAK,CAAC,iBAAiB,EAAE,OAAO,kCAAkC,CAAC,EAC1F,UAAU,EAAE,KAAK,CAAC,eAAe,EAAE,OAAO,qBAAqB,CAAC,EAChE,gBAAgB,EAAE,eAAe,EAAE,EACnC,UAAU,GAAE,OAAuD,EACnE,UAAU,GAAE,OAAuD,EACnE,MAAM,UAAQ,oGAWf;AAED,wBAAsB,oCAAoC,CAAC,OAAO,SAAS,MAAM,EAAE,OAAO,SAAS,MAAM,EACvG,MAAM,EAAE;IACN,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,sCAAsC,CAAC,CAAC;CAC/F,EACD,qBAAqB,EAAE,KAAK,CAAC,iBAAiB,EAAE,OAAO,kCAAkC,CAAC,EAC1F,UAAU,EAAE,KAAK,CAAC,SAAS,EAAE,OAAO,qBAAqB,CAAC,EAC1D,UAAU,GAAE,OAAuD,EACnE,UAAU,GAAE,OAAuD,oGAiBpE"}

package/dest/kernel/hints/build_nullifier_read_request_hints.js

@@ -0,0 +1,67 @@
+import { MAX_NULLIFIER_READ_REQUESTS_PER_TX } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { AztecAddress } from '../../aztec-address/index.js';
+import { siloNullifier } from '../../hash/hash.js';
+import { Nullifier } from '../nullifier.js';
+import { countAccumulatedItems, getNonEmptyItems } from '../utils/order_and_comparison.js';
+import { NullifierReadRequestHintsBuilder } from './nullifier_read_request_hints.js';
+import { ReadRequest, ScopedReadRequest } from './read_request.js';
+import { PendingReadHint, ReadRequestResetStates, ReadRequestState } from './read_request_hints.js';
+import { ScopedValueCache } from './scoped_value_cache.js';
+export function isValidNullifierReadRequest(readRequest, nullifier) {
+    return readRequest.value.equals(nullifier.value) && nullifier.contractAddress.equals(readRequest.contractAddress) && readRequest.counter > nullifier.counter;
+}
+export function getNullifierReadRequestResetStates(nullifierReadRequests, nullifiers, futureNullifiers) {
+    const resetStates = ReadRequestResetStates.empty(MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+    const nullifierMap = new Map();
+    getNonEmptyItems(nullifiers).forEach((nullifier, index)=>{
+        const value = nullifier.value.toBigInt();
+        const arr = nullifierMap.get(value) ?? [];
+        arr.push({
+            nullifier,
+            index
+        });
+        nullifierMap.set(value, arr);
+    });
+    const futureNullifiersMap = new ScopedValueCache(futureNullifiers);
+    const numReadRequests = countAccumulatedItems(nullifierReadRequests);
+    for(let i = 0; i < numReadRequests; ++i){
+        const readRequest = nullifierReadRequests[i];
+        const pendingNullifier = nullifierMap.get(readRequest.value.toBigInt())?.find(({ nullifier })=>isValidNullifierReadRequest(readRequest, nullifier));
+        if (pendingNullifier !== undefined) {
+            resetStates.states[i] = ReadRequestState.PENDING;
+            resetStates.pendingReadHints.push(new PendingReadHint(i, pendingNullifier.index));
+        } else if (!futureNullifiersMap.get(readRequest).some((futureNullifier)=>isValidNullifierReadRequest(readRequest, futureNullifier))) {
+            resetStates.states[i] = ReadRequestState.SETTLED;
+        }
+    }
+    return resetStates;
+}
+export async function buildNullifierReadRequestHintsFromResetStates(oracle, nullifierReadRequests, resetStates, maxPending = MAX_NULLIFIER_READ_REQUESTS_PER_TX, maxSettled = MAX_NULLIFIER_READ_REQUESTS_PER_TX, siloed = false) {
+    const builder = new NullifierReadRequestHintsBuilder(maxPending, maxSettled);
+    resetStates.pendingReadHints.forEach((hint)=>{
+        builder.addPendingReadRequest(hint.readRequestIndex, hint.pendingValueIndex);
+    });
+    for(let i = 0; i < resetStates.states.length; i++){
+        if (resetStates.states[i] === ReadRequestState.SETTLED) {
+            const readRequest = nullifierReadRequests[i];
+            const siloedValue = siloed ? readRequest.value : await siloNullifier(readRequest.contractAddress, readRequest.value);
+            const membershipWitnessWithPreimage = await oracle.getNullifierMembershipWitness(siloedValue);
+            builder.addSettledReadRequest(i, membershipWitnessWithPreimage.membershipWitness, membershipWitnessWithPreimage.leafPreimage);
+        }
+    }
+    return builder.toHints();
+}
+export async function buildNullifierReadRequestHints(oracle, nullifierReadRequests, nullifiers, futureNullifiers, maxPending = MAX_NULLIFIER_READ_REQUESTS_PER_TX, maxSettled = MAX_NULLIFIER_READ_REQUESTS_PER_TX, siloed = false) {
+    const resetStates = getNullifierReadRequestResetStates(nullifierReadRequests, nullifiers, futureNullifiers);
+    return await buildNullifierReadRequestHintsFromResetStates(oracle, nullifierReadRequests, resetStates, maxPending, maxSettled, siloed);
+}
+export async function buildSiloedNullifierReadRequestHints(oracle, nullifierReadRequests, nullifiers, maxPending = MAX_NULLIFIER_READ_REQUESTS_PER_TX, maxSettled = MAX_NULLIFIER_READ_REQUESTS_PER_TX) {
+    // Nullifiers outputted from public kernels are already siloed while read requests are not.
+    // Siloing the read request values and set the contract addresses to zero to find the matching nullifier contexts.
+    const nonEmptyNullifierReadRequests = getNonEmptyItems(nullifierReadRequests);
+    const readRequests = await Promise.all(nonEmptyNullifierReadRequests.map(async (r)=>new ReadRequest(await siloNullifier(r.contractAddress, r.value), r.counter).scope(AztecAddress.ZERO)));
+    const siloedReadRequests = padArrayEnd(readRequests, ScopedReadRequest.empty(), MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+    const scopedNullifiers = nullifiers.map((n)=>new Nullifier(n.value, n.counter, n.noteHash).scope(AztecAddress.ZERO));
+    return buildNullifierReadRequestHints(oracle, siloedReadRequests, scopedNullifiers, [], maxPending, maxSettled, true);
+}

package/dest/kernel/hints/build_transient_data_hints.d.ts

@@ -0,0 +1,10 @@
+import type { Tuple } from '@aztec/foundation/serialize';
+import type { ScopedNoteHash } from '../note_hash.js';
+import type { ScopedNullifier } from '../nullifier.js';
+import type { ScopedReadRequest } from './read_request.js';
+import { TransientDataIndexHint } from './transient_data_index_hint.js';
+export declare function buildTransientDataHints<NOTE_HASHES_LEN extends number, NULLIFIERS_LEN extends number>(noteHashes: Tuple<ScopedNoteHash, NOTE_HASHES_LEN>, nullifiers: Tuple<ScopedNullifier, NULLIFIERS_LEN>, futureNoteHashReads: ScopedReadRequest[], futureNullifierReads: ScopedReadRequest[], noteHashNullifierCounterMap: Map<number, number>, validationRequestsSplitCounter: number, noteHashesLength?: NOTE_HASHES_LEN, nullifiersLength?: NULLIFIERS_LEN): {
+    numTransientData: number;
+    hints: Tuple<TransientDataIndexHint, NULLIFIERS_LEN>;
+};
+//# sourceMappingURL=build_transient_data_hints.d.ts.map

package/dest/kernel/hints/build_transient_data_hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_transient_data_hints.d.ts","sourceRoot":"","sources":["../../../src/kernel/hints/build_transient_data_hints.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAIvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAExE,wBAAgB,uBAAuB,CAAC,eAAe,SAAS,MAAM,EAAE,cAAc,SAAS,MAAM,EACnG,UAAU,EAAE,KAAK,CAAC,cAAc,EAAE,eAAe,CAAC,EAClD,UAAU,EAAE,KAAK,CAAC,eAAe,EAAE,cAAc,CAAC,EAClD,mBAAmB,EAAE,iBAAiB,EAAE,EACxC,oBAAoB,EAAE,iBAAiB,EAAE,EACzC,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChD,8BAA8B,EAAE,MAAM,EACtC,gBAAgB,GAAE,eAAsD,EACxE,gBAAgB,GAAE,cAAoD,GACrE;IAAE,gBAAgB,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC,sBAAsB,EAAE,cAAc,CAAC,CAAA;CAAE,CA2DpF"}

package/dest/kernel/hints/build_transient_data_hints.js

@@ -0,0 +1,51 @@
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { countAccumulatedItems } from '../utils/order_and_comparison.js';
+import { isValidNoteHashReadRequest } from './build_note_hash_read_request_hints.js';
+import { isValidNullifierReadRequest } from './build_nullifier_read_request_hints.js';
+import { ScopedValueCache } from './scoped_value_cache.js';
+import { TransientDataIndexHint } from './transient_data_index_hint.js';
+export function buildTransientDataHints(noteHashes, nullifiers, futureNoteHashReads, futureNullifierReads, noteHashNullifierCounterMap, validationRequestsSplitCounter, noteHashesLength = noteHashes.length, nullifiersLength = nullifiers.length) {
+    const futureNoteHashReadsMap = new ScopedValueCache(futureNoteHashReads);
+    const futureNullifierReadsMap = new ScopedValueCache(futureNullifierReads);
+    const nullifierIndexMap = new Map();
+    nullifiers.forEach((n, i)=>nullifierIndexMap.set(n.counter, i));
+    const hints = [];
+    const numNoteHashes = countAccumulatedItems(noteHashes);
+    for(let noteHashIndex = 0; noteHashIndex < numNoteHashes; noteHashIndex++){
+        const noteHash = noteHashes[noteHashIndex];
+        const noteHashNullifierCounter = noteHashNullifierCounterMap.get(noteHash.counter);
+        // The note hash might not be linked to a nullifier or it might be read in the future
+        if (!noteHashNullifierCounter || futureNoteHashReadsMap.get(noteHash).find((read)=>isValidNoteHashReadRequest(read, noteHash))) {
+            continue;
+        }
+        const nullifierIndex = nullifierIndexMap.get(noteHashNullifierCounter);
+        // We might not have the corresponding nullifier yet
+        if (nullifierIndex === undefined) {
+            continue;
+        }
+        const nullifier = nullifiers[nullifierIndex];
+        // Cannot nullify a non-revertible note hash with a revertible nullifier.
+        if (noteHash.counter < validationRequestsSplitCounter && nullifier.counter >= validationRequestsSplitCounter) {
+            continue;
+        }
+        // If the following errors show up, something's wrong with how we build the noteHashNullifierCounterMap in client_execution_context.ts.
+        if (nullifier.counter < noteHash.counter) {
+            throw new Error('Hinted nullifier has smaller counter than note hash.');
+        }
+        if (!nullifier.contractAddress.equals(noteHash.contractAddress)) {
+            throw new Error('Contract address of hinted note hash does not match.');
+        }
+        if (!nullifier.nullifiedNoteHash.equals(noteHash.value)) {
+            continue;
+        }
+        // The nullifier might be read in the future
+        if (futureNullifierReadsMap.get(nullifier).find((read)=>isValidNullifierReadRequest(read, nullifier))) {
+            continue;
+        }
+        hints.push(new TransientDataIndexHint(nullifierIndex, noteHashIndex));
+    }
+    return {
+        numTransientData: hints.length,
+        hints: padArrayEnd(hints, new TransientDataIndexHint(nullifiersLength, noteHashesLength), nullifiersLength)
+    };
+}

package/dest/kernel/hints/find_private_kernel_reset_dimensions.d.ts

@@ -0,0 +1,3 @@
+import { PrivateKernelResetDimensions, type PrivateKernelResetDimensionsConfig } from '../private_kernel_reset_dimensions.js';
+export declare function findPrivateKernelResetDimensions(requestedDimensions: PrivateKernelResetDimensions, config: PrivateKernelResetDimensionsConfig, isInner?: boolean, allowRemainder?: boolean): PrivateKernelResetDimensions;
+//# sourceMappingURL=find_private_kernel_reset_dimensions.d.ts.map

package/dest/kernel/hints/find_private_kernel_reset_dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find_private_kernel_reset_dimensions.d.ts","sourceRoot":"","sources":["../../../src/kernel/hints/find_private_kernel_reset_dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,KAAK,kCAAkC,EAExC,MAAM,uCAAuC,CAAC;AAmI/C,wBAAgB,gCAAgC,CAC9C,mBAAmB,EAAE,4BAA4B,EACjD,MAAM,EAAE,kCAAkC,EAC1C,OAAO,UAAQ,EACf,cAAc,UAAQ,gCA2BvB"}

package/dest/kernel/hints/find_private_kernel_reset_dimensions.js

@@ -0,0 +1,104 @@
+import { PrivateKernelResetDimensions, privateKernelResetDimensionNames } from '../private_kernel_reset_dimensions.js';
+function isDefined(value) {
+    return value !== undefined;
+}
+function computeCost(dimensions, config) {
+    return privateKernelResetDimensionNames.reduce((accum, name)=>accum + dimensions[name] * config.dimensions[name].cost, 0);
+}
+function getSize(dimensions) {
+    return privateKernelResetDimensionNames.reduce((accum, name)=>accum + dimensions[name], 0);
+}
+function getRemainder(requestedDimensions, foundDimensions) {
+    const remainder = PrivateKernelResetDimensions.empty();
+    let remainingDimensions = 0;
+    privateKernelResetDimensionNames.forEach((name)=>{
+        if (requestedDimensions[name] > foundDimensions[name]) {
+            remainingDimensions++;
+            remainder[name] = requestedDimensions[name] - foundDimensions[name];
+        }
+    });
+    return remainingDimensions ? remainder : undefined;
+}
+function pickFromValues(targetValue, values) {
+    // Find the min value in `values` that's greater than or equal to `targetValue`.
+    const minGte = values.reduce((prev, curr)=>curr >= targetValue && (prev === undefined || curr < prev) ? curr : prev, undefined);
+    // If no such value is found, returns the max value.
+    return minGte ?? Math.max(...values);
+}
+function pickCheapest(options) {
+    return options.reduce((prev, curr)=>curr.cost < prev.cost ? curr : prev, options[0]);
+}
+function pickSmallestRemainder(options) {
+    const optionsWithSize = options.filter((o)=>o.remainder).map((option)=>({
+            option,
+            size: getSize(option.remainder)
+        }));
+    return optionsWithSize.reduce((prev, curr)=>curr.size < prev.size ? curr : prev, optionsWithSize[0])?.option;
+}
+function pickBestOption(options) {
+    const optionsResetAll = options.filter((opt)=>!opt.remainder);
+    const optionsResetPartial = options.filter((opt)=>opt.remainder);
+    // The best option is the cheapest one that can reset all dimensions.
+    // If no such option exists, find one that can reset the most data.
+    return pickCheapest(optionsResetAll) || pickSmallestRemainder(optionsResetPartial);
+}
+function findVariant(requestedDimensions, config, isQualified) {
+    const variant = PrivateKernelResetDimensions.empty();
+    privateKernelResetDimensionNames.forEach((name)=>{
+        variant[name] = pickFromValues(requestedDimensions[name], config.dimensions[name].variants);
+    });
+    if (!isQualified(variant)) {
+        return;
+    }
+    return {
+        dimensions: variant,
+        cost: computeCost(variant, config),
+        remainder: getRemainder(requestedDimensions, variant)
+    };
+}
+function findStandalone(requestedDimensions, config, isQualified) {
+    const needsReset = privateKernelResetDimensionNames.filter((name)=>requestedDimensions[name] > 0);
+    if (needsReset.length !== 1) {
+        // At the moment, we only use standalone to reset one dimension when it's about to overflow.
+        return;
+    }
+    const name = needsReset[0];
+    const value = pickFromValues(requestedDimensions[name], config.dimensions[name].standalone);
+    if (!value) {
+        return;
+    }
+    const dimensions = PrivateKernelResetDimensions.from({
+        [name]: value
+    });
+    if (!isQualified(dimensions)) {
+        return;
+    }
+    return {
+        dimensions,
+        cost: computeCost(dimensions, config),
+        remainder: getRemainder(requestedDimensions, dimensions)
+    };
+}
+function findSpecialCase(requestedDimensions, config, isQualified) {
+    const specialCases = config.specialCases.map(PrivateKernelResetDimensions.fromValues);
+    const options = specialCases.filter(isQualified).map((dimensions)=>({
+            dimensions,
+            cost: computeCost(dimensions, config),
+            remainder: getRemainder(requestedDimensions, dimensions)
+        }));
+    return pickBestOption(options);
+}
+export function findPrivateKernelResetDimensions(requestedDimensions, config, isInner = false, allowRemainder = false) {
+    const requestedValues = requestedDimensions.toValues();
+    const isEnough = allowRemainder ? ()=>true : (dimensions)=>dimensions.toValues().every((v, i)=>v >= requestedValues[i]);
+    const isQualified = !isInner ? isEnough : (dimensions)=>dimensions.NOTE_HASH_SILOING_AMOUNT === 0 && dimensions.NULLIFIER_SILOING_AMOUNT === 0 && dimensions.PRIVATE_LOG_SILOING_AMOUNT === 0 && isEnough(dimensions);
+    const options = [
+        findVariant(requestedDimensions, config, isQualified),
+        findStandalone(requestedDimensions, config, isQualified),
+        findSpecialCase(requestedDimensions, config, isQualified)
+    ].filter(isDefined);
+    if (!options.length) {
+        throw new Error(`Cannot find an option for dimension: ${requestedDimensions.toValues()}`);
+    }
+    return pickBestOption(options).dimensions;
+}