@aztec/pxe 0.0.1-commit.03f7ef2 → 0.0.1-commit.04852196a

package/src/notes/note_service.ts

@@ -5,16 +5,17 @@ import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdli
 import { type AztecNode, MAX_RPC_LEN } from '@aztec/stdlib/interfaces/client';
 import { Note, NoteDao, NoteStatus } from '@aztec/stdlib/note';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import type { TxHash } from '@aztec/stdlib/tx';
+import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
 
-import type { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
-import type { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
+import type { AccessScopes } from '../access_scopes.js';
+import type { NoteStore } from '../storage/note_store/note_store.js';
 
 export class NoteService {
   constructor(
-    private readonly noteDataProvider: NoteDataProvider,
+    private readonly noteStore: NoteStore,
     private readonly aztecNode: AztecNode,
-    private readonly anchorBlockDataProvider: AnchorBlockDataProvider,
+    private readonly anchorBlockHeader: BlockHeader,
+    private readonly jobId: string,
   ) {}
 
   /**
@@ -31,17 +32,20 @@ export class NoteService {
     owner: AztecAddress | undefined,
     storageSlot: Fr,
     status: NoteStatus,
-    scopes?: AztecAddress[],
+    scopes: AccessScopes,
   ) {
-    const noteDaos = await this.noteDataProvider.getNotes({
-      contractAddress,
-      owner,
-      storageSlot,
-      status,
-      scopes,
-    });
+    const noteDaos = await this.noteStore.getNotes(
+      {
+        contractAddress,
+        owner,
+        storageSlot,
+        status,
+        scopes,
+      },
+      this.jobId,
+    );
     return noteDaos.map(
-      ({ contractAddress, owner, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier, index }) => ({
+      ({ contractAddress, owner, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier }) => ({
         contractAddress,
         owner,
         storageSlot,
@@ -49,9 +53,8 @@ export class NoteService {
         noteNonce,
         note,
         noteHash,
+        isPending: false, // Note service deals only with settled notes
         siloedNullifier,
-        // PXE can use this index to get full MembershipWitness
-        index,
       }),
     );
   }
@@ -59,7 +62,7 @@ export class NoteService {
   /**
    * Looks for nullifiers of active contract notes and marks them as nullified if a nullifier is found.
    *
-   * Fetches notes from the NoteDataProvider and checks which nullifiers are present in the
+   * Fetches notes from the NoteStore and checks which nullifiers are present in the
    * onchain nullifier Merkle tree - up to the latest locally synced block. We use the
    * locally synced block instead of querying the chain's 'latest' block to ensure correctness:
    * notes are only marked nullified once their corresponding nullifier has been included in a
@@ -68,10 +71,10 @@ export class NoteService {
    *
    * @param contractAddress - The contract whose notes should be checked and nullified.
    */
-  public async syncNoteNullifiers(contractAddress: AztecAddress): Promise<void> {
-    const syncedBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+  public async syncNoteNullifiers(contractAddress: AztecAddress, scopes: AccessScopes): Promise<void> {
+    const anchorBlockHash = await this.anchorBlockHeader.hash();
 
-    const contractNotes = await this.noteDataProvider.getNotes({ contractAddress });
+    const contractNotes = await this.noteStore.getNotes({ contractAddress, scopes }, this.jobId);
 
     if (contractNotes.length === 0) {
       return;
@@ -92,7 +95,7 @@ export class NoteService {
     const nullifierIndexes = (
       await Promise.all(
         nullifierBatches.map(batch =>
-          this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, batch),
+          this.aztecNode.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, batch),
         ),
       )
     ).flat();
@@ -105,10 +108,10 @@ export class NoteService {
       })
       .filter(nullifier => nullifier !== undefined) as DataInBlock<Fr>[];
 
-    await this.noteDataProvider.applyNullifiers(foundNullifiers);
+    await this.noteStore.applyNullifiers(foundNullifiers, this.jobId);
   }
 
-  public async deliverNote(
+  public async validateAndStoreNote(
     contractAddress: AztecAddress,
     owner: AztecAddress,
     storageSlot: Fr,
@@ -120,7 +123,7 @@ export class NoteService {
     txHash: TxHash,
     recipient: AztecAddress,
   ): Promise<void> {
-    // We are going to store the new note in the NoteDataProvider, which will let us later return it via `getNotes`.
+    // We are going to store the new note in the NoteStore, which will let us later return it via `getNotes`.
     // There's two things we need to check before we do this however:
     //  - we must make sure the note does actually exist in the note hash tree
     //  - we need to check if the note has already been nullified
@@ -139,41 +142,32 @@ export class NoteService {
     // number which *should* be recent enough to be available, even for non-archive nodes.
     // Also note that the note should never be ahead of the synced block here since `fetchTaggedLogs` only processes
     // logs up to the synced block making this only an additional safety check.
-    const syncedBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+    const anchorBlockNumber = this.anchorBlockHeader.getBlockNumber();
+    const anchorBlockHash = await this.anchorBlockHeader.hash();
 
     // By computing siloed and unique note hashes ourselves we prevent contracts from interfering with the note storage
     // of other contracts, which would constitute a security breach.
     const uniqueNoteHash = await computeUniqueNoteHash(noteNonce, await siloNoteHash(contractAddress, noteHash));
     const siloedNullifier = await siloNullifier(contractAddress, nullifier);
 
-    const txEffect = await this.aztecNode.getTxEffect(txHash);
+    const [txEffect, [nullifierIndex]] = await Promise.all([
+      this.aztecNode.getTxEffect(txHash),
+      this.aztecNode.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, [siloedNullifier]),
+    ]);
     if (!txEffect) {
       throw new Error(`Could not find tx effect for tx hash ${txHash}`);
     }
 
-    if (txEffect.l2BlockNumber > syncedBlockNumber) {
-      throw new Error(`Could not find tx effect for tx hash ${txHash} as of block number ${syncedBlockNumber}`);
+    if (txEffect.l2BlockNumber > anchorBlockNumber) {
+      throw new Error(`Could not find tx effect for tx hash ${txHash} as of block number ${anchorBlockNumber}`);
     }
 
-    const noteInTx = txEffect.data.noteHashes.some(nh => nh.equals(uniqueNoteHash));
-    if (!noteInTx) {
+    // Find the index of the note hash in the noteHashes array to determine note ordering within the tx
+    const noteIndexInTx = txEffect.data.noteHashes.findIndex(nh => nh.equals(uniqueNoteHash));
+    if (noteIndexInTx === -1) {
       throw new Error(`Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present in tx ${txHash}`);
     }
 
-    // We store notes by their index in the global note hash tree, which has the convenient side effect of validating
-    // note existence in said tree. We concurrently also check if the note's nullifier exists, performing all node
-    // queries in a single round-trip.
-    const [[uniqueNoteHashTreeIndexInBlock], [nullifierIndex]] = await Promise.all([
-      this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NOTE_HASH_TREE, [uniqueNoteHash]),
-      this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, [siloedNullifier]),
-    ]);
-
-    if (uniqueNoteHashTreeIndexInBlock === undefined) {
-      throw new Error(
-        `Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present on the tree at block ${syncedBlockNumber} (from tx ${txHash})`,
-      );
-    }
-
     const noteDao = new NoteDao(
       new Note(content),
       contractAddress,
@@ -184,17 +178,19 @@ export class NoteService {
       noteHash,
       siloedNullifier,
       txHash,
-      uniqueNoteHashTreeIndexInBlock.l2BlockNumber,
-      uniqueNoteHashTreeIndexInBlock.l2BlockHash.toString(),
-      uniqueNoteHashTreeIndexInBlock.data,
+      txEffect.l2BlockNumber,
+      txEffect.l2BlockHash.toString(),
+      txEffect.txIndexInBlock,
+      noteIndexInTx,
     );
 
     // The note was found by `recipient`, so we use that as the scope when storing the note.
-    await this.noteDataProvider.addNotes([noteDao], recipient);
+    await this.noteStore.addNotes([noteDao], recipient, this.jobId);
 
     if (nullifierIndex !== undefined) {
+      // We found nullifier index which implies that the note has already been nullified.
       const { data: _, ...blockHashAndNum } = nullifierIndex;
-      await this.noteDataProvider.applyNullifiers([{ data: siloedNullifier, ...blockHashAndNum }]);
+      await this.noteStore.applyNullifiers([{ data: siloedNullifier, ...blockHashAndNum }], this.jobId);
     }
   }
 }

package/src/notes_filter.ts

@@ -0,0 +1,26 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { NoteStatus } from '@aztec/stdlib/note';
+
+import type { AccessScopes } from './access_scopes.js';
+
+/**
+ * A filter used to fetch notes.
+ * @remarks This filter is applied as an intersection of all its params.
+ */
+export type NotesFilter = {
+  /**
+   * The contract address the note belongs to.
+   * @remarks Providing a contract address is required as we need that information to trigger private state sync.
+   */
+  contractAddress: AztecAddress;
+  /** The owner of the note. */
+  owner?: AztecAddress;
+  /** The specific storage location of the note on the contract. */
+  storageSlot?: Fr;
+  /** The status of the note. Defaults to 'ACTIVE'. */
+  status?: NoteStatus;
+  /** The siloed nullifier for the note. */
+  siloedNullifier?: Fr;
+  scopes: AccessScopes;
+};

package/src/oracle_version.ts

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

package/src/private_kernel/hints/{compute_tx_include_by_timestamp.ts → compute_tx_expiration_timestamp.ts}

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

package/src/private_kernel/hints/index.ts

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