@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.21caa21

package/src/storage/tagging_data_provider/tagging_data_provider.ts

@@ -1,62 +1,90 @@
-import type { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { IndexedTaggingSecret } from '@aztec/stdlib/logs';
+import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
 
 export class TaggingDataProvider {
   #store: AztecAsyncKVStore;
   #addressBook: AztecAsyncMap<string, true>;
 
-  // Stores the last index used for each tagging secret, taking direction into account
-  // This is necessary to avoid reusing the same index for the same secret, which happens if
-  // sender and recipient are the same
-  #taggingSecretIndexesForSenders: AztecAsyncMap<string, number>;
-  #taggingSecretIndexesForRecipients: AztecAsyncMap<string, number>;
+  // Stores the last used index for each directional app tagging secret. Taking into account whether we are
+  // requesting the index as a sender or as a recipient because the sender and recipient can be in the same PXE.
+  #lastUsedIndexesAsSenders: AztecAsyncMap<string, number>;
+  #lastUsedIndexesAsRecipients: AztecAsyncMap<string, number>;
 
   constructor(store: AztecAsyncKVStore) {
     this.#store = store;
 
     this.#addressBook = this.#store.openMap('address_book');
 
-    this.#taggingSecretIndexesForSenders = this.#store.openMap('tagging_secret_indexes_for_senders');
-    this.#taggingSecretIndexesForRecipients = this.#store.openMap('tagging_secret_indexes_for_recipients');
+    this.#lastUsedIndexesAsSenders = this.#store.openMap('last_used_indexes_as_senders');
+    this.#lastUsedIndexesAsRecipients = this.#store.openMap('last_used_indexes_as_recipients');
   }
 
-  async setTaggingSecretsIndexesAsSender(indexedSecrets: IndexedTaggingSecret[]): Promise<void> {
-    await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForSenders);
-  }
-
-  async setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[]): Promise<void> {
-    await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForRecipients);
+  /**
+   * Sets the last used indexes when sending a log.
+   * @param preTags - The pre tags containing the directional app tagging secrets and the indexes that are to be
+   * updated in the db.
+   * @throws If any two pre tags contain the same directional app tagging secret
+   */
+  setLastUsedIndexesAsSender(preTags: PreTag[]) {
+    this.#assertUniqueSecrets(preTags, 'sender');
+
+    return Promise.all(
+      preTags.map(({ secret, index }) => this.#lastUsedIndexesAsSenders.set(secret.toString(), index)),
+    );
   }
 
-  async #setTaggingSecretsIndexes(indexedSecrets: IndexedTaggingSecret[], storageMap: AztecAsyncMap<string, number>) {
-    await Promise.all(
-      indexedSecrets.map(indexedSecret =>
-        storageMap.set(indexedSecret.appTaggingSecret.toString(), indexedSecret.index),
-      ),
+  /**
+   * Sets the last used indexes when looking for logs.
+   * @param preTags - The pre tags containing the directional app tagging secrets and the indexes that are to be
+   * updated in the db.
+   * @throws If any two pre tags contain the same directional app tagging secret
+   */
+  setLastUsedIndexesAsRecipient(preTags: PreTag[]) {
+    this.#assertUniqueSecrets(preTags, 'recipient');
+
+    return Promise.all(
+      preTags.map(({ secret, index }) => this.#lastUsedIndexesAsRecipients.set(secret.toString(), index)),
     );
   }
 
-  async getTaggingSecretsIndexesAsRecipient(appTaggingSecrets: Fr[]) {
-    return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForRecipients);
+  // It should never happen that we would receive any two pre tags on the input containing the same directional app
+  // tagging secret as everywhere we always just apply the largest index. Hence this check is a good way to catch
+  // bugs.
+  #assertUniqueSecrets(preTags: PreTag[], role: 'sender' | 'recipient'): void {
+    const secretStrings = preTags.map(({ secret }) => secret.toString());
+    const uniqueSecrets = new Set(secretStrings);
+    if (uniqueSecrets.size !== secretStrings.length) {
+      throw new Error(`Duplicate secrets found when setting last used indexes as ${role}`);
+    }
   }
 
-  async getTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[]) {
-    return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForSenders);
+  /**
+   * Returns the last used index when sending a log with a given secret.
+   * @param secret - The directional app tagging secret.
+   * @returns The last used index for the given directional app tagging secret, or undefined if not found.
+   */
+  async getLastUsedIndexesAsSender(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
+    return await this.#lastUsedIndexesAsSenders.getAsync(secret.toString());
   }
 
-  #getTaggingSecretsIndexes(appTaggingSecrets: Fr[], storageMap: AztecAsyncMap<string, number>): Promise<number[]> {
-    return Promise.all(appTaggingSecrets.map(async secret => (await storageMap.getAsync(`${secret.toString()}`)) ?? 0));
+  /**
+   * Returns the last used indexes when looking for logs as a recipient.
+   * @param secrets - The directional app tagging secrets to obtain the indexes for.
+   * @returns The last used indexes for the given directional app tagging secrets, or undefined if have never yet found
+   * a log for a given secret.
+   */
+  getLastUsedIndexesAsRecipient(secrets: DirectionalAppTaggingSecret[]): Promise<(number | undefined)[]> {
+    return Promise.all(secrets.map(secret => this.#lastUsedIndexesAsRecipients.getAsync(secret.toString())));
   }
 
   resetNoteSyncData(): Promise<void> {
     return this.#store.transactionAsync(async () => {
-      const recipients = await toArray(this.#taggingSecretIndexesForRecipients.keysAsync());
-      await Promise.all(recipients.map(recipient => this.#taggingSecretIndexesForRecipients.delete(recipient)));
-      const senders = await toArray(this.#taggingSecretIndexesForSenders.keysAsync());
-      await Promise.all(senders.map(sender => this.#taggingSecretIndexesForSenders.delete(sender)));
+      const keysForSenders = await toArray(this.#lastUsedIndexesAsSenders.keysAsync());
+      await Promise.all(keysForSenders.map(secret => this.#lastUsedIndexesAsSenders.delete(secret)));
+      const keysForRecipients = await toArray(this.#lastUsedIndexesAsRecipients.keysAsync());
+      await Promise.all(keysForRecipients.map(secret => this.#lastUsedIndexesAsRecipients.delete(secret)));
     });
   }
 

package/src/synchronizer/synchronizer.ts

@@ -1,6 +1,5 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import type { L2TipsStore } from '@aztec/kv-store/stores';
+import type { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
@@ -10,13 +9,11 @@ import type { SyncDataProvider } from '../storage/sync_data_provider/sync_data_p
 import type { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
 
 /**
- * The Synchronizer class manages the synchronization with the aztec node, allowing PXE to retrieve the
- * latest block header and handle reorgs.
- * It provides methods to trigger a sync and get the block number we are syncec to
- * details, and fetch transactions by hash.
+ * The Synchronizer class orchestrates synchronization between the PXE and Aztec node, maintaining an up-to-date
+ * view of the L2 chain state. It handles block header retrieval, chain reorganizations, and provides an interface
+ * for querying sync status.
  */
 export class Synchronizer implements L2BlockStreamEventHandler {
-  private initialSyncBlockNumber = INITIAL_L2_BLOCK_NUM - 1;
   private log: Logger;
   private isSyncing: Promise<void> | undefined;
   protected readonly blockStream: L2BlockStream;
@@ -26,8 +23,8 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     private syncDataProvider: SyncDataProvider,
     private noteDataProvider: NoteDataProvider,
     private taggingDataProvider: TaggingDataProvider,
-    private l2TipsStore: L2TipsStore,
-    config: Partial<Pick<PXEConfig, 'l2StartingBlock'>> = {},
+    private l2TipsStore: L2TipsKVStore,
+    config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>> = {},
     loggerOrSuffix?: string | Logger,
   ) {
     this.log =
@@ -37,9 +34,12 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     this.blockStream = this.createBlockStream(config);
   }
 
-  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2StartingBlock'>>) {
+  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>>) {
     return new L2BlockStream(this.node, this.l2TipsStore, this, createLogger('pxe:block_stream'), {
-      startingBlock: config.l2StartingBlock,
+      batchSize: config.l2BlockBatchSize,
+      // Skipping finalized blocks makes us sync much faster - we only need to download blocks other than the latest one
+      // in order to detect reorgs, and there can be no reorgs on finalized block, making this safe.
+      skipFinalized: true,
     });
   }
 
@@ -49,28 +49,27 @@ export class Synchronizer implements L2BlockStreamEventHandler {
 
     switch (event.type) {
       case 'blocks-added': {
-        const lastBlock = event.blocks.at(-1)!;
+        const lastBlock = event.blocks.at(-1)!.block;
         this.log.verbose(`Updated pxe last block to ${lastBlock.number}`, {
           blockHash: lastBlock.hash(),
           archive: lastBlock.archive.root.toString(),
           header: lastBlock.header.toInspect(),
         });
-        await this.syncDataProvider.setHeader(lastBlock.header);
+        await this.syncDataProvider.setHeader(lastBlock.getBlockHeader());
         break;
       }
       case 'chain-pruned': {
-        this.log.warn(`Pruning data after block ${event.blockNumber} due to reorg`);
+        this.log.warn(`Pruning data after block ${event.block.number} due to reorg`);
         // We first unnullify and then remove so that unnullified notes that were created after the block number end up deleted.
         const lastSynchedBlockNumber = await this.syncDataProvider.getBlockNumber();
-        await this.noteDataProvider.unnullifyNotesAfter(event.blockNumber, lastSynchedBlockNumber);
-        await this.noteDataProvider.removeNotesAfter(event.blockNumber);
+        await this.noteDataProvider.rollbackNotesAndNullifiers(event.block.number, lastSynchedBlockNumber);
         // Remove all note tagging indexes to force a full resync. This is suboptimal, but unless we track the
         // block number in which each index is used it's all we can do.
         await this.taggingDataProvider.resetNoteSyncData();
         // Update the header to the last block.
-        const newHeader = await this.node.getBlockHeader(event.blockNumber);
+        const newHeader = await this.node.getBlockHeader(event.block.number);
         if (!newHeader) {
-          this.log.error(`Block header not found for block number ${event.blockNumber} during chain prune`);
+          this.log.error(`Block header not found for block number ${event.block.number} during chain prune`);
         } else {
           await this.syncDataProvider.setHeader(newHeader);
         }
@@ -80,7 +79,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
   }
 
   /**
-   * Syncs PXE and the node by dowloading the metadata of the latest blocks, allowing simulations to use
+   * Syncs PXE and the node by downloading the metadata of the latest blocks, allowing simulations to use
    * recent data (e.g. notes), and handling any reorgs that might have occurred.
    */
   public async sync() {
@@ -105,7 +104,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
 
     try {
       currentHeader = await this.syncDataProvider.getBlockHeader();
-    } catch (e) {
+    } catch {
       this.log.debug('Header is not set, requesting from the node');
     }
     if (!currentHeader) {
@@ -115,7 +114,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     await this.blockStream.sync();
   }
 
-  public async getSynchedBlockNumber() {
-    return (await this.syncDataProvider.getBlockNumber()) ?? this.initialSyncBlockNumber;
+  public getSynchedBlockNumber() {
+    return this.syncDataProvider.getBlockNumber();
   }
 }

package/src/tagging/constants.ts

@@ -0,0 +1,2 @@
+// Half the size of the window we slide over the tagging indexes.
+export const WINDOW_HALF_SIZE = 10;

package/src/tagging/index.ts

@@ -0,0 +1,6 @@
+export * from './tag.js';
+export * from './constants.js';
+export * from './siloed_tag.js';
+export * from './utils.js';
+export { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+export { type PreTag } from '@aztec/stdlib/logs';

package/src/tagging/siloed_tag.ts

@@ -0,0 +1,22 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import type { Tag } from './tag.js';
+
+/**
+ * Represents a tag used in private log as it "appears on the chain" - that is the tag is siloed with a contract
+ * address that emitted the log.
+ */
+export class SiloedTag {
+  private constructor(public readonly value: Fr) {}
+
+  static async compute(tag: Tag, app: AztecAddress): Promise<SiloedTag> {
+    const siloedTag = await poseidon2Hash([app, tag.value]);
+    return new SiloedTag(siloedTag);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+}

package/src/tagging/tag.ts

@@ -0,0 +1,16 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+import type { PreTag } from '@aztec/stdlib/logs';
+
+/**
+ * Represents a tag of a private log. This is not the tag that "appears" on the chain as this tag is first siloed
+ * with a contract address by kernels before being included in the final log.
+ */
+export class Tag {
+  private constructor(public readonly value: Fr) {}
+
+  static async compute(preTag: PreTag): Promise<Tag> {
+    const tag = await poseidon2Hash([preTag.secret.value, preTag.index]);
+    return new Tag(tag);
+  }
+}

package/src/tagging/utils.ts

@@ -0,0 +1,31 @@
+import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+
+// TODO(benesjan): Make this return tags instead - this will moves some complexity from syncTaggedLogs
+export function getPreTagsForTheWindow(
+  secretsAndWindows: { secret: DirectionalAppTaggingSecret; leftMostIndex: number; rightMostIndex: number }[],
+): PreTag[] {
+  const secrets = [];
+  for (const secretAndWindow of secretsAndWindows) {
+    for (let i = secretAndWindow.leftMostIndex; i <= secretAndWindow.rightMostIndex; i++) {
+      secrets.push({ secret: secretAndWindow.secret, index: i });
+    }
+  }
+  return secrets;
+}
+
+/**
+ * Creates a map from directional app tagging secret to initial index.
+ * @param preTags - The pre tags to get the initial indexes map from.
+ * @returns The map from directional app tagging secret to initial index.
+ */
+export function getInitialIndexesMap(preTags: { secret: DirectionalAppTaggingSecret; index: number | undefined }[]): {
+  [k: string]: number;
+} {
+  const initialIndexes: { [k: string]: number } = {};
+
+  for (const preTag of preTags) {
+    initialIndexes[preTag.secret.toString()] = preTag.index ?? 0;
+  }
+
+  return initialIndexes;
+}

package/dest/bin/index.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env -S node --no-warnings
-export {};
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":""}

package/dest/bin/index.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env -S node --no-warnings
-import { createLogger } from '@aztec/foundation/log';
-import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
-import { getPXEServiceConfig } from '../config/index.js';
-import { createPXEService } from '../entrypoints/server/utils.js';
-import { startPXEHttpServer } from '../pxe_http/index.js';
-const { PXE_PORT = 8080, AZTEC_NODE_URL = 'http://localhost:8079' } = process.env;
-const logger = createLogger('pxe:service');
-/**
- * Create and start a new PXE HTTP Server
- */ async function main() {
-    logger.info(`Setting up PXE...`);
-    const pxeConfig = getPXEServiceConfig();
-    const nodeRpcClient = createAztecNodeClient(AZTEC_NODE_URL, {});
-    const pxeService = await createPXEService(nodeRpcClient, pxeConfig);
-    const shutdown = ()=>{
-        logger.info('Shutting down...');
-        process.exit(0);
-    };
-    process.once('SIGINT', shutdown);
-    process.once('SIGTERM', shutdown);
-    startPXEHttpServer(pxeService, PXE_PORT);
-    logger.info(`PXE listening on port ${PXE_PORT}`);
-}
-main().catch((err)=>{
-    logger.error(err);
-    process.exit(1);
-});

package/dest/entrypoints/client/pxe_creation_options.d.ts

@@ -1,11 +0,0 @@
-import type { Logger } from '@aztec/foundation/log';
-import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
-export type PXECreationOptions = {
-    loggers: {
-        store?: Logger;
-        pxe?: Logger;
-        prover?: Logger;
-    };
-    prover?: PrivateKernelProver;
-};
-//# sourceMappingURL=pxe_creation_options.d.ts.map

package/dest/entrypoints/client/pxe_creation_options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pxe_creation_options.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/client/pxe_creation_options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE3E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3D,MAAM,CAAC,EAAE,mBAAmB,CAAC;CAC9B,CAAC"}

package/dest/kernel_oracle/index.d.ts

@@ -1,45 +0,0 @@
-import { type NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
-import type { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
-import { MembershipWitness } from '@aztec/foundation/trees';
-import type { KeyStore } from '@aztec/key-store';
-import type { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockNumber } from '@aztec/stdlib/block';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
-import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
-import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
-import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
-import type { ProvingDataOracle } from './../kernel_prover/proving_data_oracle.js';
-/**
- * A data oracle that provides information needed for simulating a transaction.
- */
-export declare class KernelOracle implements ProvingDataOracle {
-    private contractDataProvider;
-    private keyStore;
-    private node;
-    private blockNumber;
-    private log;
-    constructor(contractDataProvider: ContractDataProvider, keyStore: KeyStore, node: AztecNode, blockNumber?: L2BlockNumber, log?: import("@aztec/foundation/log").Logger);
-    getContractAddressPreimage(address: AztecAddress): Promise<{
-        version: 1;
-        salt: Fr;
-        deployer: AztecAddress;
-        currentContractClassId: Fr;
-        originalContractClassId: Fr;
-        initializationHash: Fr;
-        publicKeys: import("@aztec/aztec.js").PublicKeys;
-        address: AztecAddress;
-        saltedInitializationHash: Fr;
-    }>;
-    getContractClassIdPreimage(contractClassId: Fr): Promise<import("@aztec/stdlib/contract").ContractClassIdPreimage>;
-    getFunctionMembershipWitness(contractClassId: Fr, selector: FunctionSelector): Promise<MembershipWitness<5>>;
-    getVkMembershipWitness(vk: VerificationKeyAsFields): Promise<MembershipWitness<6>>;
-    getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
-    getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-    getNoteHashTreeRoot(): Promise<Fr>;
-    getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinScalar>;
-    getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string>;
-    getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints>;
-}
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/kernel_oracle/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,EAA2C,MAAM,kBAAkB,CAAC;AACvG,OAAO,KAAK,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAG1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6DAA6D,CAAC;AACxG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AAInF;;GAEG;AACH,qBAAa,YAAa,YAAW,iBAAiB;IAElD,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,GAAG;gBAJH,oBAAoB,EAAE,oBAAoB,EAC1C,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,SAAS,EACf,WAAW,GAAE,aAAwB,EACrC,GAAG,yCAAoC;IAGpC,0BAA0B,CAAC,OAAO,EAAE,YAAY;;;;;;;;;;;IAQhD,0BAA0B,CAAC,eAAe,EAAE,EAAE;IAK9C,4BAA4B,CAAC,eAAe,EAAE,EAAE,EAAE,QAAQ,EAAE,gBAAgB;IAIlF,sBAAsB,CAAC,EAAE,EAAE,uBAAuB;IAKnD,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,CAAC;IAS/G,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC;IAIvF,mBAAmB,IAAI,OAAO,CAAC,EAAE,CAAC;IAQjC,kBAAkB,CAAC,eAAe,EAAE,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC;IAInE,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IAI1F,sBAAsB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA6BjG"}

package/dest/kernel_prover/hints/build_private_kernel_reset_private_inputs.d.ts

@@ -1,28 +0,0 @@
-import { type PrivateKernelCircuitPublicInputs, PrivateKernelResetCircuitPrivateInputs, type PrivateKernelSimulateOutput } from '@aztec/stdlib/kernel';
-import { type PrivateCallExecutionResult } from '@aztec/stdlib/tx';
-import type { ProvingDataOracle } from '../proving_data_oracle.js';
-export declare class PrivateKernelResetPrivateInputsBuilder {
-    private previousKernelOutput;
-    private executionStack;
-    private noteHashNullifierCounterMap;
-    private validationRequestsSplitCounter;
-    private previousKernel;
-    private nextIteration?;
-    private noteHashResetStates;
-    private nullifierResetStates;
-    private numTransientData?;
-    private transientDataIndexHints;
-    private requestedDimensions;
-    constructor(previousKernelOutput: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>, executionStack: PrivateCallExecutionResult[], noteHashNullifierCounterMap: Map<number, number>, validationRequestsSplitCounter: number);
-    needsReset(): boolean;
-    build(oracle: ProvingDataOracle, noteHashLeafIndexMap: Map<bigint, bigint>): Promise<PrivateKernelResetCircuitPrivateInputs>;
-    private reduceReadRequestStates;
-    private needsResetNoteHashReadRequests;
-    private needsResetNullifierReadRequests;
-    private needsResetNullifierKeys;
-    private needsResetTransientData;
-    private needsSiloNoteHashes;
-    private needsSiloNullifiers;
-    private needsSiloPrivateLogs;
-}
-//# sourceMappingURL=build_private_kernel_reset_private_inputs.d.ts.map

package/dest/kernel_prover/hints/build_private_kernel_reset_private_inputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build_private_kernel_reset_private_inputs.d.ts","sourceRoot":"","sources":["../../../src/kernel_prover/hints/build_private_kernel_reset_private_inputs.ts"],"names":[],"mappings":"AAeA,OAAO,EAGL,KAAK,gCAAgC,EAErC,sCAAsC,EAGtC,KAAK,2BAA2B,EAkBjC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,0BAA0B,EAAiB,MAAM,kBAAkB,CAAC;AAElF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAiDnE,qBAAa,sCAAsC;IAY/C,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,2BAA2B;IACnC,OAAO,CAAC,8BAA8B;IAdxC,OAAO,CAAC,cAAc,CAAmC;IAEzD,OAAO,CAAC,aAAa,CAAC,CAA6B;IAEnD,OAAO,CAAC,mBAAmB,CAAoE;IAC/F,OAAO,CAAC,oBAAoB,CAAoE;IAChG,OAAO,CAAC,gBAAgB,CAAC,CAAS;IAClC,OAAO,CAAC,uBAAuB,CAA8D;IAC7F,OAAO,CAAC,mBAAmB,CAA+B;gBAGhD,oBAAoB,EAAE,2BAA2B,CAAC,gCAAgC,CAAC,EACnF,cAAc,EAAE,0BAA0B,EAAE,EAC5C,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChD,8BAA8B,EAAE,MAAM;IAahD,UAAU,IAAI,OAAO;IAwBf,KAAK,CAAC,MAAM,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAgEhF,OAAO,CAAC,uBAAuB;IA2B/B,OAAO,CAAC,8BAA8B;IAoDtC,OAAO,CAAC,+BAA+B;IAoDvC,OAAO,CAAC,uBAAuB;IAiB/B,OAAO,CAAC,uBAAuB;IAmE/B,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,oBAAoB;CAmB7B"}