@aztec/pxe 0.0.1-commit.d3ec352c → 0.0.1-commit.d6f2b3f94

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/contract_function_simulator/execution_data_provider.d.ts

@@ -1,267 +0,0 @@
-import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Fr, Point } from '@aztec/foundation/fields';
-import type { FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2Block } from '@aztec/stdlib/block';
-import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
-import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
-import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
-import type { NoteStatus } from '@aztec/stdlib/note';
-import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-import type { BlockHeader, NodeStats } from '@aztec/stdlib/tx';
-import type { NoteData } from './oracle/interfaces.js';
-import type { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
-/**
- * Error thrown when a contract is not found in the database.
- */
-export declare class ContractNotFoundError extends Error {
-    constructor(contractAddress: string);
-}
-/**
- * Error thrown when a contract class is not found in the database.
- */
-export declare class ContractClassNotFoundError extends Error {
-    constructor(contractClassId: string);
-}
-export type ExecutionStats = {
-    /**
-     * Contains an entry for each RPC call performed during the execution
-     */
-    nodeRPCCalls: NodeStats;
-};
-/**
- * The interface for the data layer required to perform private and utility execution.
- */
-export interface ExecutionDataProvider {
-    /**
-     * Returns a contract instance associated with an address, if available.
-     * @param address - Address.
-     * @returns A contract instance.
-     */
-    getContractInstance(address: AztecAddress): Promise<ContractInstance>;
-    /**
-     * Retrieve the complete address associated to a given address.
-     * @param account - The account address.
-     * @returns A complete address associated with the input address.
-     * @throws An error if the account is not registered in the database.
-     */
-    getCompleteAddress(account: AztecAddress): Promise<CompleteAddress>;
-    /**
-     * Retrieve keys associated with a specific master public key and app address.
-     * @param pkMHash - The master public key hash.
-     * @returns A Promise that resolves to nullifier keys.
-     * @throws If the keys are not registered in the key store.
-     */
-    getKeyValidationRequest(pkMHash: Fr, contractAddress: AztecAddress): Promise<KeyValidationRequest>;
-    /**
-     * Retrieves a set of notes stored in the database for a given contract address and storage slot.
-     * The query result is paginated using 'limit' and 'offset' values.
-     * Returns an object containing an array of note data.
-     *
-     * @param contractAddress - The contract address of the notes.
-     * @param owner - The owner of the notes.
-     * @param storageSlot - The storage slot of the notes.
-     * @param status - The status of notes to fetch.
-     * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
-     * @returns A Promise that resolves to an array of note data.
-     */
-    getNotes(contractAddress: AztecAddress, owner: AztecAddress, storageSlot: Fr, status: NoteStatus, scopes?: AztecAddress[]): Promise<NoteData[]>;
-    /**
-     * Retrieve the artifact information of a specific function within a contract.
-     * The function is identified by its selector, which is a unique identifier generated from the function signature.
-     *
-     * @param contractAddress - The contract address.
-     * @param selector - The corresponding function selector.
-     * @returns A Promise that resolves to a FunctionArtifact object.
-     */
-    getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifactWithContractName>;
-    /**
-     * Generates a stable function name for debug purposes.
-     * @param contractAddress - The contract address.
-     * @param selector - The corresponding function selector.
-     */
-    getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string>;
-    /**
-     * Gets the index of a nullifier in the nullifier tree.
-     * @param nullifier - The nullifier.
-     * @returns - The index of the nullifier. Undefined if it does not exist in the tree.
-     */
-    getNullifierIndex(nullifier: Fr): Promise<bigint | undefined>;
-    /**
-     * Returns a nullifier membership witness for the given nullifier or undefined if not found.
-     * REFACTOR: Same as getL1ToL2MembershipWitness, can be combined with aztec-node method that does almost the same thing.
-     * @param nullifier - Nullifier we're looking for.
-     */
-    getNullifierMembershipWitnessAtLatestBlock(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-    /**
-     * Fetches a message from the db, given its key.
-     * @param contractAddress - Address of a contract by which the message was emitted.
-     * @param messageHash - Hash of the message.
-     * @param secret - Secret used to compute a nullifier.
-     * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
-     * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-     */
-    getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
-    /**
-     * Retrieve the latest block header synchronized by the execution data provider. This block header is referred
-     * to as the anchor block header in Aztec terminology and it defines the state that is used during private function
-     * execution.
-     * @returns The anchor block header.
-     */
-    getAnchorBlockHeader(): Promise<BlockHeader>;
-    /**
-     * Fetches the index and sibling path of a leaf at a given block from a given tree.
-     * @param blockNumber - The block number at which to get the membership witness.
-     * @param treeId - Id of the tree to get the sibling path from.
-     * @param leafValue - The leaf value
-     * @returns The index and sibling path concatenated [index, sibling_path]
-     */
-    getMembershipWitness(blockNumber: BlockNumber, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]>;
-    /**
-     * Returns a nullifier membership witness for a given nullifier at a given block.
-     * @param blockNumber - The block number at which to get the index.
-     * @param nullifier - Nullifier we try to find witness for.
-     * @returns The nullifier membership witness (if found).
-     */
-    getNullifierMembershipWitness(blockNumber: BlockNumber, nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-    /**
-     * Returns a low nullifier membership witness for a given nullifier at a given block.
-     * @param blockNumber - The block number at which to get the index.
-     * @param nullifier - Nullifier we try to find the low nullifier witness for.
-     * @returns The low nullifier membership witness (if found).
-     * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
-     * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
-     * we are trying to prove non-inclusion for.
-     */
-    getLowNullifierMembershipWitness(blockNumber: BlockNumber, nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-    /**
-     * Returns a witness for a given slot of the public data tree at a given block.
-     * @param blockNumber - The block number at which to get the witness.
-     * @param leafSlot - The slot of the public data in the public data tree.
-     */
-    getPublicDataWitness(blockNumber: BlockNumber, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
-    /**
-     * Gets the storage value at the given contract storage slot.
-     *
-     * @remarks The storage slot here refers to the slot as it is defined in Noir not the index in the merkle tree.
-     * Aztec's version of `eth_getStorageAt`.
-     *
-     * @param blockNumber - The block number at which to get the data.
-     * @param contract - Address of the contract to query.
-     * @param slot - Slot to query.
-     * @returns Storage value at the given contract slot.
-     * @throws If the contract is not deployed.
-     */
-    getPublicStorageAt(blockNumber: BlockNumber, contract: AztecAddress, slot: Fr): Promise<Fr>;
-    /**
-     * Fetch a block corresponding to the given block number.
-     * @param blockNumber - The block number of a block to fetch.
-     * @returns - The block corresponding to the given block number. Undefined if it does not exist.
-     */
-    getBlock(blockNumber: BlockNumber): Promise<L2Block | undefined>;
-    /**
-     * Assert that the oracle version is compatible with the expected version.
-     * @param version - The expected version.
-     */
-    assertCompatibleOracleVersion(version: number): void;
-    /**
-     * Calculates the directional app tagging secret for a given contract, sender and recipient.
-     * @param contractAddress - The contract address to silo the secret for
-     * @param sender - The address sending the note
-     * @param recipient - The address receiving the note
-     * @returns The directional app tagging secret
-     */
-    calculateDirectionalAppTaggingSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress): Promise<DirectionalAppTaggingSecret>;
-    /**
-     * Updates the local index of the shared tagging secret of a (sender, recipient, contract) tuple if a log with
-     * a larger index is found from the node.
-     * @param secret - The secret that's unique for (sender, recipient, contract) tuple while the direction
-     * of sender -> recipient matters.
-     * @param contractAddress - The address of the contract that the logs are tagged for. Needs to be provided to store
-     * because the function performs second round of siloing which is necessary because kernels do it as well (they silo
-     * first field of the private log which corresponds to the tag).
-     */
-    syncTaggedLogsAsSender(secret: DirectionalAppTaggingSecret, contractAddress: AztecAddress): Promise<void>;
-    /**
-     * 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 we never sent a log
-     * from this sender to a recipient in a given contract (implicitly included in the secret).
-     */
-    getLastUsedIndexAsSender(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
-    /**
-     * Synchronizes the private logs tagged with scoped addresses and all the senders in the address book. Stores the found
-     * logs in CapsuleArray ready for a later retrieval in Aztec.nr.
-     * @param contractAddress - The address of the contract that the logs are tagged for.
-     * @param pendingTaggedLogArrayBaseSlot - The base slot of the pending tagged log capsule array in which found logs will be stored.
-     * @param scopes - The scoped addresses to sync logs for. If not provided, all accounts in the address book will be
-     * synced.
-     */
-    syncTaggedLogs(contractAddress: AztecAddress, pendingTaggedLogArrayBaseSlot: Fr, scopes?: AztecAddress[]): Promise<void>;
-    /**
-     * Validates all note and event validation requests enqueued via `enqueue_note_for_validation` and
-     * `enqueue_event_for_validation`, inserting them into the note database and event store respectively, making them
-     * queryable via `get_notes` and `getPrivateEvents`.
-     *
-     * This automatically clears both validation request queues, so no further work needs to be done by the caller.
-     * @param contractAddress - The address of the contract that the logs are tagged for.
-     * @param noteValidationRequestsArrayBaseSlot - The base slot of capsule array containing note validation requests.
-     * @param eventValidationRequestsArrayBaseSlot - The base slot of capsule array containing event validation requests.
-     */
-    validateEnqueuedNotesAndEvents(contractAddress: AztecAddress, noteValidationRequestsArrayBaseSlot: Fr, eventValidationRequestsArrayBaseSlot: Fr): Promise<void>;
-    bulkRetrieveLogs(contractAddress: AztecAddress, logRetrievalRequestsArrayBaseSlot: Fr, logRetrievalResponsesArrayBaseSlot: Fr): Promise<void>;
-    /**
-     * Looks for nullifiers of active contract notes and marks them as nullified in the db if a nullifier is found.
-     */
-    syncNoteNullifiers(contractAddress: AztecAddress): Promise<void>;
-    /**
-     * Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `loadCapsule`.
-     * * If data was already stored at this slot, it is overwritten.
-     * @param contractAddress - The contract address to scope the data under.
-     * @param slot - The slot in the database in which to store the value. Slots need not be contiguous.
-     * @param capsule - An array of field elements representing the capsule.
-     * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle. It works similarly
-     * to public contract storage in that it's indexed by the contract address and storage slot but instead of the global
-     * network state it's backed by local PXE db.
-     */
-    storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void>;
-    /**
-     * Returns data previously stored via `storeCapsule` in the per-contract non-volatile database.
-     * @param contractAddress - The contract address under which the data is scoped.
-     * @param slot - The slot in the database to read.
-     * @returns The stored data or `null` if no data is stored under the slot.
-     */
-    loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
-    /**
-     * Deletes data in the per-contract non-volatile database. Does nothing if no data was present.
-     * @param contractAddress - The contract address under which the data is scoped.
-     * @param slot - The slot in the database to delete.
-     */
-    deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void>;
-    /**
-     * Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data
-     * structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.
-     * Supports overlapping source and destination regions (which will result in the overlapped source values being
-     * overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)
-     *
-     * @param contractAddress - The contract address under which the data is scoped.
-     * @param srcSlot - The first slot to copy from.
-     * @param dstSlot - The first slot to copy to.
-     * @param numEntries - The number of entries to copy.
-     */
-    copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
-    /**
-     * Retrieves the shared secret for a given address and ephemeral public key.
-     * @param address - The address to get the secret for.
-     * @param ephPk - The ephemeral public key to get the secret for.
-     * @returns The secret for the given address.
-     */
-    getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point>;
-    /**
-     * Returns the execution statistics collected during the simulator run.
-     * @returns The execution statistics.
-     */
-    getStats(): ExecutionStats;
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dest/contract_function_simulator/execution_data_provider.d.ts.map

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

package/dest/contract_function_simulator/execution_data_provider.js

@@ -1,14 +0,0 @@
-/**
- * Error thrown when a contract is not found in the database.
- */ export class ContractNotFoundError extends Error {
-    constructor(contractAddress){
-        super(`DB has no contract with address ${contractAddress}`);
-    }
-}
-/**
- * Error thrown when a contract class is not found in the database.
- */ export class ContractClassNotFoundError extends Error {
-    constructor(contractClassId){
-        super(`DB has no contract class with id ${contractClassId}`);
-    }
-}

package/dest/contract_function_simulator/proxied_node.d.ts

@@ -1,9 +0,0 @@
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { NodeStats } from '@aztec/stdlib/tx';
-export type ProxiedNode = AztecNode & {
-    getStats(): NodeStats;
-};
-export declare class ProxiedNodeFactory {
-    static create(node: AztecNode): ProxiedNode;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJveGllZF9ub2RlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3RfZnVuY3Rpb25fc2ltdWxhdG9yL3Byb3hpZWRfbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUtsRCxNQUFNLE1BQU0sV0FBVyxHQUFHLFNBQVMsR0FBRztJQUFFLFFBQVEsSUFBSSxTQUFTLENBQUE7Q0FBRSxDQUFDO0FBRWhFLHFCQUFhLGtCQUFrQjtJQUM3QixNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxTQUFTLGVBcUI1QjtDQUNGIn0=

package/dest/contract_function_simulator/proxied_node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proxied_node.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/proxied_node.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKlD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG;IAAE,QAAQ,IAAI,SAAS,CAAA;CAAE,CAAC;AAEhE,qBAAa,kBAAkB;IAC7B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,eAqB5B;CACF"}

package/dest/contract_function_simulator/proxied_node.js

@@ -1,27 +0,0 @@
-import { Timer } from '@aztec/foundation/timer';
-export class ProxiedNodeFactory {
-    static create(node) {
-        const stats = {};
-        return new Proxy(node, {
-            get (target, prop) {
-                if (prop === 'getStats') {
-                    return ()=>{
-                        return stats;
-                    };
-                } else {
-                    return async function(...args) {
-                        if (!stats[prop]) {
-                            stats[prop] = {
-                                times: []
-                            };
-                        }
-                        const timer = new Timer();
-                        const result = await target[prop].apply(target, args);
-                        stats[prop].times.push(timer.ms());
-                        return result;
-                    };
-                }
-            }
-        });
-    }
-}