@aztec/pxe 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/tagging/recipient_sync/utils/find_highest_indexes.ts

@@ -0,0 +1,34 @@
+import { MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
+import type { TxScopedL2Log } from '@aztec/stdlib/logs';
+
+/**
+ * Finds the highest aged and the highest finalized tagging indexes.
+ */
+export function findHighestIndexes(
+  privateLogsWithIndexes: Array<{ log: TxScopedL2Log; taggingIndex: number }>,
+  currentTimestamp: bigint,
+  finalizedBlockNumber: number,
+): { highestAgedIndex: number | undefined; highestFinalizedIndex: number | undefined } {
+  let highestAgedIndex = undefined;
+  let highestFinalizedIndex = undefined;
+
+  for (const { log, taggingIndex } of privateLogsWithIndexes) {
+    const ageInSeconds = currentTimestamp - log.blockTimestamp;
+
+    if (
+      ageInSeconds >= BigInt(MAX_INCLUDE_BY_TIMESTAMP_DURATION) &&
+      (highestAgedIndex === undefined || taggingIndex > highestAgedIndex)
+    ) {
+      highestAgedIndex = taggingIndex;
+    }
+
+    if (
+      log.blockNumber <= finalizedBlockNumber &&
+      (highestFinalizedIndex === undefined || taggingIndex > highestFinalizedIndex)
+    ) {
+      highestFinalizedIndex = taggingIndex;
+    }
+  }
+
+  return { highestAgedIndex, highestFinalizedIndex };
+}

package/src/tagging/recipient_sync/utils/load_logs_for_range.ts

@@ -0,0 +1,49 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { DirectionalAppTaggingSecret, PreTag, TxScopedL2Log } from '@aztec/stdlib/logs';
+import { SiloedTag, Tag } from '@aztec/stdlib/logs';
+
+import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
+
+/**
+ * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range, `app` and
+ * `secret`. At most load logs from blocks up to and including `anchorBlockNumber`. `start` is inclusive and `end` is
+ * exclusive.
+ */
+export async function loadLogsForRange(
+  secret: DirectionalAppTaggingSecret,
+  app: AztecAddress,
+  aztecNode: AztecNode,
+  start: number,
+  end: number,
+  anchorBlockNumber: BlockNumber,
+  anchorBlockHash: BlockHash,
+): Promise<Array<{ log: TxScopedL2Log; taggingIndex: number }>> {
+  // Derive tags for the window
+  const preTags: PreTag[] = Array(end - start)
+    .fill(0)
+    .map((_, i) => ({ secret, index: start + i }));
+  const siloedTags = await Promise.all(preTags.map(preTag => Tag.compute(preTag))).then(tags =>
+    Promise.all(tags.map(tag => SiloedTag.compute(tag, app))),
+  );
+
+  // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
+  // pagination here.
+  const logs = await getAllPrivateLogsByTags(aztecNode, siloedTags, anchorBlockHash);
+
+  // Pair logs with their corresponding tagging indexes
+  const logsWithIndexes: Array<{ log: TxScopedL2Log; taggingIndex: number }> = [];
+  for (let i = 0; i < logs.length; i++) {
+    const logsForTag = logs[i];
+    const taggingIndex = preTags[i].index;
+    for (const log of logsForTag) {
+      if (log.blockNumber <= anchorBlockNumber) {
+        logsWithIndexes.push({ log, taggingIndex });
+      }
+    }
+  }
+
+  return logsWithIndexes;
+}

package/src/tagging/sender_sync/sync_sender_tagging_indexes.ts

@@ -0,0 +1,99 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+
+import type { SenderTaggingStore } from '../../storage/tagging_store/sender_tagging_store.js';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
+import { getStatusChangeOfPending } from './utils/get_status_change_of_pending.js';
+import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_tagging_indexes.js';
+
+/**
+ * Syncs tagging indexes. This function needs to be called whenever a private log is being sent.
+ *
+ * @param secret - The secret that's unique for (sender, recipient, contract) tuple while the direction of
+ * sender -> recipient matters.
+ * @param app - The address of the contract that the logs are tagged for. Needs to be provided because we perform
+ * second round of siloing in this function which is necessary because kernels do it as well (they silo first field
+ * of the private log which corresponds to the tag).
+ * @remarks When syncing the indexes as sender we don't care about the log contents - we only care about the highest
+ * pending and highest finalized indexes as that guides the next index choice when sending a log. The next index choice
+ * is simply the highest pending index plus one (or finalized if pending is undefined).
+ * @dev This function looks for new indexes, adds them to pending, then it checks status of each pending index and
+ * updates its status accordingly.
+ */
+export async function syncSenderTaggingIndexes(
+  secret: DirectionalAppTaggingSecret,
+  app: AztecAddress,
+  aztecNode: AztecNode,
+  taggingStore: SenderTaggingStore,
+  anchorBlockHash: BlockHash,
+  jobId: string,
+): Promise<void> {
+  // # Explanation of how syncing works
+  //
+  // When choosing an index, we select: highest pending index + 1 (or highest finalized index + 1 if no pending).
+  // If the chosen index is more than WINDOW_LEN from the highest finalized index, we throw an error. By having this
+  // hard limit we give a guarantee to a recipient that he doesn't need to look further than WINDOW_LEN ahead of the
+  // highest finalized index.
+  //
+  // This function synchronizes the finalized and pending indexes by iteratively querying the node for a window of
+  // indexes at a time, storing all those indexes as pending, and then checking the status of each pending index to
+  // update its finalization status accordingly. If we stumble upon a window with no indexes, we stop the loop.
+  //
+  // Stopping at that point is safe because of the limit described above - there can never be an index that is more
+  // than WINDOW_LEN from the highest finalized index.
+  //
+  // # Note on performance
+  // Each window advance requires two queries (logs + tx status). For example, syncing indexes 0–500 with a window of
+  // 100 takes at least 10 round trips (5 windows × 2 queries).
+
+  const finalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
+
+  let start = finalizedIndex === undefined ? 0 : finalizedIndex + 1;
+  let end = start + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN;
+
+  let previousFinalizedIndex = finalizedIndex;
+  let newFinalizedIndex = undefined;
+
+  while (true) {
+    // Load and store indexes for the current window. These indexes may already exist in the database if txs using
+    // them were previously sent from this PXE. Any duplicates are handled by the tagging data provider.
+    await loadAndStoreNewTaggingIndexes(secret, app, start, end, aztecNode, taggingStore, anchorBlockHash, jobId);
+
+    // Retrieve all indexes within the current window from storage and update their status accordingly.
+    const pendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);
+    if (pendingTxHashes.length === 0) {
+      break;
+    }
+
+    const { txHashesToFinalize, txHashesToDrop } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
+
+    await taggingStore.dropPendingIndexes(txHashesToDrop, jobId);
+    await taggingStore.finalizePendingIndexes(txHashesToFinalize, jobId);
+
+    // We check if the finalized index has been updated.
+    newFinalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
+    if (previousFinalizedIndex !== newFinalizedIndex) {
+      // A new finalized index was found, so we'll run the loop again. For example:
+      // - Previous finalized index: 10
+      // - New finalized index: 13
+      // - Window length: 10
+      //
+      // In the last iteration, we processed indexes 11-20. To avoid reprocessing the same logs,
+      // we'll only look at the new indexes 21-23:
+      //
+      //    Previous window: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+      //    New window:                                             [21, 22, 23]
+
+      const previousEnd = end;
+      // Add 1 because `end` is exclusive and the known finalized index is not included in the window.
+      end = newFinalizedIndex! + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+      start = previousEnd;
+      previousFinalizedIndex = newFinalizedIndex;
+    } else {
+      // No new finalized index was found, so we don't need to process the next window.
+      break;
+    }
+  }
+}

package/src/tagging/sender_sync/utils/get_status_change_of_pending.ts

@@ -0,0 +1,36 @@
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { TxHash, TxStatus } from '@aztec/stdlib/tx';
+
+/**
+ * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized or
+ * dropped.
+ */
+export async function getStatusChangeOfPending(
+  pending: TxHash[],
+  aztecNode: AztecNode,
+): Promise<{ txHashesToFinalize: TxHash[]; txHashesToDrop: TxHash[] }> {
+  // Get receipts for all pending tx hashes.
+  const receipts = await Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash)));
+
+  const txHashesToFinalize: TxHash[] = [];
+  const txHashesToDrop: TxHash[] = [];
+
+  for (let i = 0; i < receipts.length; i++) {
+    const receipt = receipts[i];
+    const txHash = pending[i];
+
+    if (receipt.status === TxStatus.FINALIZED && receipt.hasExecutionSucceeded()) {
+      // Tx has been included in a block and the corresponding block is finalized --> we mark the indexes as
+      // finalized.
+      txHashesToFinalize.push(txHash);
+    } else if (receipt.isDropped() || receipt.hasExecutionReverted()) {
+      // Tx was dropped or reverted --> we drop the corresponding pending indexes.
+      // TODO(#17615): Don't drop pending indexes corresponding to non-revertible phases.
+      txHashesToDrop.push(txHash);
+    } else {
+      // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
+    }
+  }
+
+  return { txHashesToFinalize, txHashesToDrop };
+}

package/src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts

@@ -0,0 +1,84 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+import { SiloedTag, Tag } from '@aztec/stdlib/logs';
+import { TxHash } from '@aztec/stdlib/tx';
+
+import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_tagging_store.js';
+import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
+
+/**
+ * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
+ * @remarks This function is one of two places by which a pending index can get to the tagging data provider. The other
+ * place is when a tx is being sent from this PXE.
+ * @param secret - The directional app tagging secret that's unique for (sender, recipient, contract) tuple.
+ * @param app - The address of the contract that the logs are tagged for. Used for siloing tags to match
+ * kernel circuit behavior.
+ * @param start - The starting index (inclusive) of the window to process.
+ * @param end - The ending index (exclusive) of the window to process.
+ * @param aztecNode - The Aztec node instance to query for logs.
+ * @param taggingStore - The data provider to store pending indexes.
+ * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
+ * preserving way.
+ */
+export async function loadAndStoreNewTaggingIndexes(
+  secret: DirectionalAppTaggingSecret,
+  app: AztecAddress,
+  start: number,
+  end: number,
+  aztecNode: AztecNode,
+  taggingStore: SenderTaggingStore,
+  anchorBlockHash: BlockHash,
+  jobId: string,
+) {
+  // We compute the tags for the current window of indexes
+  const preTagsForWindow: PreTag[] = Array(end - start)
+    .fill(0)
+    .map((_, i) => ({ secret, index: start + i }));
+  const siloedTagsForWindow = await Promise.all(
+    preTagsForWindow.map(async preTag => SiloedTag.compute(await Tag.compute(preTag), app)),
+  );
+
+  const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
+  const highestIndexMap = getTxHighestIndexMap(txsForTags, preTagsForWindow);
+
+  // Now we iterate over the map, reconstruct the preTags and tx hash and store them in the db.
+  for (const [txHashStr, highestIndex] of highestIndexMap.entries()) {
+    const txHash = TxHash.fromString(txHashStr);
+    await taggingStore.storePendingIndexes([{ secret, index: highestIndex }], txHash, jobId);
+  }
+}
+
+// Returns txs that used the given tags. A tag might have been used in multiple txs and for this reason we return
+// an array for each tag.
+async function getTxsContainingTags(
+  tags: SiloedTag[],
+  aztecNode: AztecNode,
+  anchorBlockHash: BlockHash,
+): Promise<TxHash[][]> {
+  // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
+  // pagination here.
+  const allLogs = await getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash);
+  return allLogs.map(logs => logs.map(log => log.txHash));
+}
+
+// Returns a map of txHash to the highest index for that txHash.
+function getTxHighestIndexMap(txHashesForTags: TxHash[][], preTagsForWindow: PreTag[]): Map<string, number> {
+  if (txHashesForTags.length !== preTagsForWindow.length) {
+    throw new Error(
+      `Number of tx hashes arrays does not match number of pre-tags. ${txHashesForTags.length} !== ${preTagsForWindow.length}`,
+    );
+  }
+
+  const highestIndexMap = new Map<string, number>();
+  for (let i = 0; i < txHashesForTags.length; i++) {
+    const taggingIndex = preTagsForWindow[i].index;
+    const txHashesForTag = txHashesForTags[i];
+    for (const txHash of txHashesForTag) {
+      const key = txHash.toString();
+      highestIndexMap.set(key, Math.max(highestIndexMap.get(key) ?? 0, taggingIndex));
+    }
+  }
+  return highestIndexMap;
+}

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_oracle/index.js

@@ -1,76 +0,0 @@
-import { PUBLIC_DATA_TREE_HEIGHT, VK_TREE_HEIGHT } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
-import { MembershipWitness } from '@aztec/foundation/trees';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { computeContractClassIdPreimage, computeSaltedInitializationHash } from '@aztec/stdlib/contract';
-import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
-import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
-import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
-// TODO: Block number should not be "latest".
-// It should be fixed at the time the proof is being simulated. I.e., it should be the same as the value defined in the constant data.
-/**
- * A data oracle that provides information needed for simulating a transaction.
- */ export class KernelOracle {
-    contractDataProvider;
-    keyStore;
-    node;
-    blockNumber;
-    log;
-    constructor(contractDataProvider, keyStore, node, blockNumber = 'latest', log = createLogger('pxe:kernel_oracle')){
-        this.contractDataProvider = contractDataProvider;
-        this.keyStore = keyStore;
-        this.node = node;
-        this.blockNumber = blockNumber;
-        this.log = log;
-    }
-    async getContractAddressPreimage(address) {
-        const instance = await this.contractDataProvider.getContractInstance(address);
-        return {
-            saltedInitializationHash: await computeSaltedInitializationHash(instance),
-            ...instance
-        };
-    }
-    async getContractClassIdPreimage(contractClassId) {
-        const contractClass = await this.contractDataProvider.getContractClass(contractClassId);
-        return computeContractClassIdPreimage(contractClass);
-    }
-    async getFunctionMembershipWitness(contractClassId, selector) {
-        return await this.contractDataProvider.getFunctionMembershipWitness(contractClassId, selector);
-    }
-    getVkMembershipWitness(vk) {
-        const leafIndex = getVKIndex(vk);
-        return Promise.resolve(new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
-    }
-    async getNoteHashMembershipWitness(leafIndex) {
-        const path = await this.node.getNoteHashSiblingPath(this.blockNumber, leafIndex);
-        return new MembershipWitness(path.pathSize, leafIndex, path.toFields());
-    }
-    getNullifierMembershipWitness(nullifier) {
-        return this.node.getNullifierMembershipWitness(this.blockNumber, nullifier);
-    }
-    async getNoteHashTreeRoot() {
-        const header = await this.node.getBlockHeader(this.blockNumber);
-        if (!header) {
-            throw new Error(`No block header found for block number ${this.blockNumber}`);
-        }
-        return header.state.partial.noteHashTree.root;
-    }
-    getMasterSecretKey(masterPublicKey) {
-        return this.keyStore.getMasterSecretKey(masterPublicKey);
-    }
-    getDebugFunctionName(contractAddress, selector) {
-        return this.contractDataProvider.getDebugFunctionName(contractAddress, selector);
-    }
-    async getUpdatedClassIdHints(contractAddress) {
-        const { sharedMutableSlot, sharedMutableHashSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-        const hashLeafSlot = await computePublicDataTreeLeafSlot(ProtocolContractAddress.ContractInstanceDeployer, sharedMutableHashSlot);
-        const updatedClassIdWitness = await this.node.getPublicDataTreeWitness(this.blockNumber, hashLeafSlot);
-        if (!updatedClassIdWitness) {
-            throw new Error(`No public data tree witness found for ${hashLeafSlot}`);
-        }
-        const readStorage = (storageSlot)=>this.node.getPublicStorageAt(this.blockNumber, ProtocolContractAddress.ContractInstanceDeployer, storageSlot);
-        const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, readStorage);
-        return new UpdatedClassIdHints(new MembershipWitness(PUBLIC_DATA_TREE_HEIGHT, updatedClassIdWitness.index, updatedClassIdWitness.siblingPath.toTuple()), updatedClassIdWitness.leafPreimage, sharedMutableValues);
-    }
-}

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"}