@aztec/stdlib 0.80.0 → 0.82.0

package/src/interfaces/pxe.ts

@@ -29,15 +29,9 @@ import { type LogFilter, LogFilterSchema } from '../logs/log_filter.js';
 import { UniqueNote } from '../note/extended_note.js';
 import { type NotesFilter, NotesFilterSchema } from '../note/notes_filter.js';
 import { AbiDecodedSchema, optional, schemas } from '../schemas/schemas.js';
-import {
-  PrivateExecutionResult,
-  Tx,
-  TxExecutionRequest,
-  TxHash,
-  TxProvingResult,
-  TxReceipt,
-  TxSimulationResult,
-} from '../tx/index.js';
+import { PrivateExecutionResult, Tx, TxExecutionRequest, TxHash, TxReceipt, TxSimulationResult } from '../tx/index.js';
+import { TxProfileResult } from '../tx/profiled_tx.js';
+import { TxProvingResult } from '../tx/proven_tx.js';
 import { TxEffect } from '../tx/tx_effect.js';
 import {
   type GetContractClassLogsResponse,
@@ -61,38 +55,6 @@ export interface PXE {
    */
   isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean>;
 
-  /**
-   * Insert an auth witness for a given message hash. Auth witnesses are used to authorize actions on
-   * behalf of a user. For instance, a token transfer initiated by a different address may request
-   * authorization from the user to move their tokens. This authorization is granted by the user
-   * account contract by verifying an auth witness requested to the execution oracle. Witnesses are
-   * usually a signature over a hash of the action to be authorized, but their actual contents depend
-   * on the account contract that consumes them.
-   *
-   * @param authWitness - The auth witness to insert. Composed of an identifier, which is the hash of
-   * the action to be authorized, and the actual witness as an array of fields, which are to be
-   * deserialized and processed by the account contract.
-   */
-  addAuthWitness(authWitness: AuthWitness): Promise<void>;
-
-  /**
-   * Fetches the serialized auth witness for a given message hash or returns undefined if not found.
-   * @param messageHash - The hash of the message for which to get the auth witness.
-   * @returns The serialized auth witness for the given message hash.
-   */
-  getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
-
-  /**
-   * Adds a capsule.
-   * @param contract - The address of the contract to add the capsule to.
-   * @param storageSlot - The storage slot to add the capsule to.
-   * @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(contract: AztecAddress, storageSlot: Fr, capsule: Fr[]): Promise<void>;
-
   /**
    * Registers a user account in PXE given its master encryption private key.
    * Once a new account is registered, the PXE Service will trial-decrypt all published notes on
@@ -166,14 +128,13 @@ export interface PXE {
   getContracts(): Promise<AztecAddress[]>;
 
   /**
-   * Creates a proving result based on the provided preauthenticated execution request and the results
-   * of executing the private part of the transaction. This will assemble the zero-knowledge proof for the private execution.
-   * It returns an object that contains the proof and public inputs of the tail circuit, which can be converted into a Tx ready to be sent to the network
+   * Proves the private portion of a simulated transaction, ready to send to the network
+   * (where valiators prove the public portion).
    *
    * @param txRequest - An authenticated tx request ready for proving
    * @param privateExecutionResult - The result of the private execution of the transaction
-   * @returns A transaction ready to be sent to the network for execution.
-   * @throws If the code for the functions executed in this transaction has not been made available via `addContracts`.
+   * @returns A result containing the proof and public inputs of the tail circuit.
+   * @throws If contract code not found, or public simulation reverts.
    * Also throws if simulatePublic is true and public simulation reverts.
    */
   proveTx(txRequest: TxExecutionRequest, privateExecutionResult: PrivateExecutionResult): Promise<TxProvingResult>;
@@ -193,10 +154,10 @@ export interface PXE {
    * @param simulatePublic - Whether to simulate the public part of the transaction.
    * @param msgSender - (Optional) The message sender to use for the simulation.
    * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
-   * @param profile - (Optional) If true, will run the private kernel prover with profiling enabled and include the result (gate count) in TxSimulationResult.
+   * @param skipFeeEnforcement - (Optional) If false, fees are enforced.
    * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will default to all.
    * @returns A simulated transaction result object that includes public and private return values.
-   * @throws If the code for the functions executed in this transaction has not been made available via `addContracts`.
+   * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
    * Also throws if simulatePublic is true and public simulation reverts.
    */
   simulateTx(
@@ -205,10 +166,24 @@ export interface PXE {
     msgSender?: AztecAddress,
     skipTxValidation?: boolean,
     skipFeeEnforcement?: boolean,
-    profile?: boolean,
     scopes?: AztecAddress[],
   ): Promise<TxSimulationResult>;
 
+  /**
+   * Profiles a transaction, reporting gate counts (unless disabled) and returns an execution trace.
+   *
+   * @param txRequest - An authenticated tx request ready for simulation
+   * @param msgSender - (Optional) The message sender to use for the simulation.
+   * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
+   * @returns A trace of the program execution with gate counts.
+   * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
+   */
+  profileTx(
+    txRequest: TxExecutionRequest,
+    profileMode: 'gates' | 'execution-steps' | 'full',
+    msgSender?: AztecAddress,
+  ): Promise<TxProfileResult>;
+
   /**
    * Sends a transaction to an Aztec node to be broadcasted to the network and mined.
    * @param tx - The transaction as created via `proveTx`.
@@ -305,6 +280,7 @@ export interface PXE {
     functionName: string,
     args: any[],
     to: AztecAddress,
+    authwits?: AuthWitness[],
     from?: AztecAddress,
     scopes?: AztecAddress[],
   ): Promise<AbiDecoded>;
@@ -454,12 +430,6 @@ const PXEInfoSchema = z.object({
 
 export const PXESchema: ApiSchemaFor<PXE> = {
   isL1ToL2MessageSynced: z.function().args(schemas.Fr).returns(z.boolean()),
-  addAuthWitness: z.function().args(AuthWitness.schema).returns(z.void()),
-  getAuthWitness: z
-    .function()
-    .args(schemas.Fr)
-    .returns(z.union([z.undefined(), z.array(schemas.Fr)])),
-  storeCapsule: z.function().args(schemas.AztecAddress, schemas.Fr, z.array(schemas.Fr)).returns(z.void()),
   registerAccount: z.function().args(schemas.Fr, schemas.Fr).returns(CompleteAddress.schema),
   getRegisteredAccounts: z.function().returns(z.array(CompleteAddress.schema)),
   registerSender: z.function().args(schemas.AztecAddress).returns(schemas.AztecAddress),
@@ -473,6 +443,14 @@ export const PXESchema: ApiSchemaFor<PXE> = {
   updateContract: z.function().args(schemas.AztecAddress, ContractArtifactSchema).returns(z.void()),
   getContracts: z.function().returns(z.array(schemas.AztecAddress)),
   proveTx: z.function().args(TxExecutionRequest.schema, PrivateExecutionResult.schema).returns(TxProvingResult.schema),
+  profileTx: z
+    .function()
+    .args(
+      TxExecutionRequest.schema,
+      z.union([z.literal('gates'), z.literal('full'), z.literal('execution-steps')]),
+      optional(schemas.AztecAddress),
+    )
+    .returns(TxProfileResult.schema),
   simulateTx: z
     .function()
     .args(
@@ -481,7 +459,6 @@ export const PXESchema: ApiSchemaFor<PXE> = {
       optional(schemas.AztecAddress),
       optional(z.boolean()),
       optional(z.boolean()),
-      optional(z.boolean()),
       optional(z.array(schemas.AztecAddress)),
     )
     .returns(TxSimulationResult.schema),
@@ -513,6 +490,7 @@ export const PXESchema: ApiSchemaFor<PXE> = {
       z.string(),
       z.array(z.any()),
       schemas.AztecAddress,
+      optional(z.array(AuthWitness.schema)),
       optional(schemas.AztecAddress),
       optional(z.array(schemas.AztecAddress)),
     )

package/src/kernel/index.ts

@@ -26,5 +26,5 @@ export * from './note_hash.js';
 export * from './private_log_data.js';
 export * from './private_call_request.js';
 export * from './private_validation_requests.js';
-export * from './private_kernel_prover_profile_result.js';
 export * from './private_kernel_simulated_output.js';
+export * from './private_kernel_prover_output.js';

package/src/kernel/private_kernel_prover_output.ts

@@ -0,0 +1,44 @@
+import { bufferSchema, mapSchema } from '@aztec/foundation/schemas';
+import type { WitnessMap } from '@aztec/noir-acvm_js';
+
+import { z } from 'zod';
+
+import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { VerificationKeyAsFields } from '../vks/verification_key.js';
+import type { PrivateKernelCircuitPublicInputs } from './private_kernel_circuit_public_inputs.js';
+import type { PrivateKernelTailCircuitPublicInputs } from './private_kernel_tail_circuit_public_inputs.js';
+
+export const PrivateExecutionStepSchema = z.object({
+  functionName: z.string(),
+  gateCount: z.number().optional(),
+  bytecode: bufferSchema,
+  witness: mapSchema(z.number(), z.string()),
+});
+
+/**
+ *  Represents either a simulated private kernel circuit or one of our application function circuits.
+ */
+export interface PrivateExecutionStep {
+  functionName: string;
+  gateCount?: number;
+  bytecode: Buffer;
+  witness: WitnessMap;
+}
+
+/** Represents the output of proven PrivateKernelSimulateOutput.*/
+export interface PrivateKernelExecutionProofOutput<
+  PublicInputsType extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
+> {
+  /** The public inputs used by the proof generation process. */
+  publicInputs: PublicInputsType;
+  /** The private IVC proof optimized for user devices. It will be consumed by an Aztec prover,
+   * which recursively verifies it through the "tube" circuit.*/
+  clientIvcProof: ClientIvcProof;
+  verificationKey: VerificationKeyAsFields;
+  /**
+   * The trace the clientIvcProof corresponds to.
+   * A trace of app circuits interleaved with private kernel circuits.
+   * If simulate is ran with profiling mode, also includes gate counts.
+   */
+  executionSteps: PrivateExecutionStep[];
+}

package/src/kernel/private_kernel_simulated_output.ts

@@ -1,31 +1,22 @@
 import type { WitnessMap } from '@aztec/noir-acvm_js';
 
-import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
 import type { VerificationKeyAsFields } from '../vks/verification_key.js';
 import type { PrivateKernelCircuitPublicInputs } from './private_kernel_circuit_public_inputs.js';
-import type { PrivateKernelProverProfileResult } from './private_kernel_prover_profile_result.js';
 import type { PrivateKernelTailCircuitPublicInputs } from './private_kernel_tail_circuit_public_inputs.js';
 
 /**
  * Represents the output of the proof creation process for init and inner private kernel circuit.
  * Contains the public inputs required for the init and inner private kernel circuit and the generated proof.
  */
-export type PrivateKernelSimulateOutput<
+export interface PrivateKernelSimulateOutput<
   PublicInputsType extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
-> = {
+> {
   /** The public inputs required for the proof generation process. */
   publicInputs: PublicInputsType;
-
-  clientIvcProof?: ClientIvcProof;
-
-  verificationKey: VerificationKeyAsFields;
-
   outputWitness: WitnessMap;
-
+  verificationKey: VerificationKeyAsFields;
   bytecode: Buffer;
-
-  profileResult?: PrivateKernelProverProfileResult;
-};
+}
 
 /**
  * Represents the output of the circuit simulation process for init and inner private kernel circuit.

package/src/logs/contract_class_log.ts

@@ -28,6 +28,14 @@ export class ContractClassLog {
     return [this.contractAddress.toField(), ...this.fields];
   }
 
+  equals(other: ContractClassLog) {
+    return (
+      this.contractAddress.equals(other.contractAddress) &&
+      this.fields.length === other.fields.length &&
+      this.fields.every((f, i) => f.equals(other.fields[i]))
+    );
+  }
+
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'

package/src/logs/l1_payload/index.ts

@@ -1,2 +1,2 @@
 export * from './encrypted_log_payload.js';
-export * from './l1_note_payload.js';
+export * from './shared_secret_derivation.js';

package/src/logs/log_with_tx_data.ts

@@ -1,8 +1,8 @@
 import { MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 
-// TypeScript representation of the Noir aztec::oracle::note_discovery::LogWithTxData struct. This is used as a response
-// for PXE's custom getLogByTag oracle.
+// TypeScript representation of the Noir aztec::oracle::message_discovery::LogWithTxData struct. This is used as a
+// response for PXE's custom getLogByTag oracle.
 export class LogWithTxData {
   constructor(
     public logContent: Fr[],

package/src/logs/private_log.ts

@@ -1,4 +1,4 @@
-import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
@@ -38,8 +38,8 @@ export class PrivateLog {
     return new PrivateLog(reader.readArray(PRIVATE_LOG_SIZE_IN_FIELDS, Fr));
   }
 
-  static random() {
-    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random));
+  static random(tag = Fr.random()) {
+    return PrivateLog.fromFields([tag, ...Array.from({ length: PRIVATE_LOG_SIZE_IN_FIELDS - 1 }, () => Fr.random())]);
   }
 
   getEmittedLength() {
@@ -54,6 +54,12 @@ export class PrivateLog {
   }
 
   static get schema() {
+    if (PUBLIC_LOG_DATA_SIZE_IN_FIELDS + 1 == PRIVATE_LOG_SIZE_IN_FIELDS) {
+      throw new Error(
+        'Constants got updated and schema for PublicLog matches that of PrivateLog. This needs to be updated now as Zod is no longer able to differentiate the 2 in TxScopedL2Log.',
+      );
+    }
+
     return z
       .object({
         fields: z.array(schemas.Fr),
@@ -61,6 +67,10 @@ export class PrivateLog {
       .transform(({ fields }) => PrivateLog.fromFields(fields));
   }
 
+  equals(other: PrivateLog) {
+    return this.fields.every((field, i) => field.equals(other.fields[i]));
+  }
+
   [inspect.custom](): string {
     return `PrivateLog {
       fields: [${this.fields.map(x => inspect(x)).join(', ')}],

package/src/logs/public_log.ts

@@ -1,4 +1,8 @@
-import { PUBLIC_LOG_DATA_SIZE_IN_FIELDS, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import {
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
+  PUBLIC_LOG_SIZE_IN_FIELDS,
+} from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
@@ -78,6 +82,12 @@ export class PublicLog {
   }
 
   static get schema(): ZodFor<PublicLog> {
+    if (PUBLIC_LOG_DATA_SIZE_IN_FIELDS + 1 == PRIVATE_LOG_SIZE_IN_FIELDS) {
+      throw new Error(
+        'Constants got updated and schema for PrivateLog matches that of PublicLog. This needs to be updated now as Zod is no longer able to differentiate the 2 in TxScopedL2Log.',
+      );
+    }
+
     return z
       .object({
         contractAddress: AztecAddress.schema,

package/src/logs/tx_scoped_l2_log.ts

@@ -1,10 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, boolToBuffer, numToUInt32BE } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
-import { schemas } from '../schemas/schemas.js';
 import { TxHash } from '../tx/tx_hash.js';
+import { PrivateLog } from './private_log.js';
+import { PublicLog } from './public_log.js';
 
 export class TxScopedL2Log {
   constructor(
@@ -22,53 +22,55 @@ export class TxScopedL2Log {
      */
     public blockNumber: number,
     /*
-     * Indicates if the log comes from the public logs stream (partial note)
+     * The log data as either a PrivateLog or PublicLog
      */
-    public isFromPublic: boolean,
-    /*
-     * The log data
-     */
-    public logData: Buffer,
+    public log: PrivateLog | PublicLog,
   ) {}
 
+  get isFromPublic() {
+    return this.log instanceof PublicLog;
+  }
+
   static get schema() {
     return z
       .object({
         txHash: TxHash.schema,
         dataStartIndexForTx: z.number(),
         blockNumber: z.number(),
-        isFromPublic: z.boolean(),
-        logData: schemas.Buffer,
+        log: z.union([PrivateLog.schema, PublicLog.schema]),
       })
       .transform(
-        ({ txHash, dataStartIndexForTx, blockNumber, isFromPublic, logData }) =>
-          new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, isFromPublic, logData),
+        ({ txHash, dataStartIndexForTx, blockNumber, log }) =>
+          new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, log),
       );
   }
 
   toBuffer() {
+    const isFromPublic = this.log instanceof PublicLog;
     return Buffer.concat([
       this.txHash.toBuffer(),
       numToUInt32BE(this.dataStartIndexForTx),
       numToUInt32BE(this.blockNumber),
-      boolToBuffer(this.isFromPublic),
-      this.logData,
+      boolToBuffer(isFromPublic),
+      this.log.toBuffer(),
     ]);
   }
 
   static fromBuffer(buffer: Buffer) {
     const reader = BufferReader.asReader(buffer);
-    return new TxScopedL2Log(
-      reader.readObject(TxHash),
-      reader.readNumber(),
-      reader.readNumber(),
-      reader.readBoolean(),
-      reader.readToEnd(),
-    );
+    const txHash = reader.readObject(TxHash);
+    const dataStartIndexForTx = reader.readNumber();
+    const blockNumber = reader.readNumber();
+    const isFromPublic = reader.readBoolean();
+    const log = isFromPublic ? PublicLog.fromBuffer(reader) : PrivateLog.fromBuffer(reader);
+
+    return new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, log);
   }
 
-  static random() {
-    return new TxScopedL2Log(TxHash.random(), 1, 1, false, Fr.random().toBuffer());
+  static async random() {
+    const isFromPublic = Math.random() < 0.5;
+    const log = isFromPublic ? await PublicLog.random() : PrivateLog.random();
+    return new TxScopedL2Log(TxHash.random(), 1, 1, log);
   }
 
   equals(other: TxScopedL2Log) {
@@ -76,8 +78,9 @@ export class TxScopedL2Log {
       this.txHash.equals(other.txHash) &&
       this.dataStartIndexForTx === other.dataStartIndexForTx &&
       this.blockNumber === other.blockNumber &&
-      this.isFromPublic === other.isFromPublic &&
-      this.logData.equals(other.logData)
+      ((this.log instanceof PublicLog && other.log instanceof PublicLog) ||
+        (this.log instanceof PrivateLog && other.log instanceof PrivateLog)) &&
+      this.log.equals(other.log as any)
     );
   }
 }

package/src/noir/index.ts

@@ -75,7 +75,7 @@ export interface NoirCompiledContract {
 }
 
 /**
- * The compilation result of an Aztec.nr contract.
+ * The compilation result of a protocol (non-contract) circuit.
  */
 export interface NoirCompiledCircuit {
   /** The hash of the circuit. */
@@ -92,6 +92,11 @@ export interface NoirCompiledCircuit {
   file_map: DebugFileMap;
 }
 
+export interface NoirCompiledCircuitWithName extends NoirCompiledCircuit {
+  /** The name of the circuit. */
+  name: string;
+}
+
 /**
  * The debug metadata of an Aztec.nr contract.
  */

package/src/note/extended_note.ts

@@ -4,7 +4,6 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { z } from 'zod';
 
-import { NoteSelector } from '../abi/note_selector.js';
 import { AztecAddress } from '../aztec-address/index.js';
 import { type ZodFor, schemas } from '../schemas/index.js';
 import { TxHash } from '../tx/tx_hash.js';
@@ -17,54 +16,43 @@ export class ExtendedNote {
   constructor(
     /** The note as emitted from the Noir contract. */
     public note: Note,
-    /** The owner whose public key was used to encrypt the note. */
-    public owner: AztecAddress,
+    /** The address whose public key was used to encrypt the note. */
+    public recipient: AztecAddress,
     /** The contract address this note is created in. */
     public contractAddress: AztecAddress,
     /** The specific storage location of the note on the contract. */
     public storageSlot: Fr,
-    /** The type identifier of the note on the contract. */
-    public noteTypeId: NoteSelector,
     /** The hash of the tx the note was created in. */
     public txHash: TxHash,
   ) {}
 
   toBuffer(): Buffer {
-    return serializeToBuffer([
-      this.note,
-      this.owner,
-      this.contractAddress,
-      this.storageSlot,
-      this.noteTypeId,
-      this.txHash,
-    ]);
+    return serializeToBuffer([this.note, this.recipient, this.contractAddress, this.storageSlot, this.txHash]);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
 
     const note = reader.readObject(Note);
-    const owner = reader.readObject(AztecAddress);
+    const recipient = reader.readObject(AztecAddress);
     const contractAddress = reader.readObject(AztecAddress);
     const storageSlot = reader.readObject(Fr);
-    const noteTypeId = reader.readObject(NoteSelector);
     const txHash = reader.readObject(TxHash);
 
-    return new this(note, owner, contractAddress, storageSlot, noteTypeId, txHash);
+    return new this(note, recipient, contractAddress, storageSlot, txHash);
   }
 
   static get schema(): ZodFor<ExtendedNote> {
     return z
       .object({
         note: Note.schema,
-        owner: schemas.AztecAddress,
+        recipient: schemas.AztecAddress,
         contractAddress: schemas.AztecAddress,
         storageSlot: schemas.Fr,
-        noteTypeId: schemas.NoteSelector,
         txHash: TxHash.schema,
       })
-      .transform(({ note, owner, contractAddress, storageSlot, noteTypeId, txHash }) => {
-        return new ExtendedNote(note, owner, contractAddress, storageSlot, noteTypeId, txHash);
+      .transform(({ note, recipient, contractAddress, storageSlot, txHash }) => {
+        return new ExtendedNote(note, recipient, contractAddress, storageSlot, txHash);
       });
   }
 
@@ -82,7 +70,6 @@ export class ExtendedNote {
       await AztecAddress.random(),
       await AztecAddress.random(),
       Fr.random(),
-      NoteSelector.random(),
       TxHash.random(),
     );
   }
@@ -92,45 +79,41 @@ export class UniqueNote extends ExtendedNote {
   constructor(
     /** The note as emitted from the Noir contract. */
     note: Note,
-    /** The owner whose public key was used to encrypt the note. */
-    owner: AztecAddress,
+    /** The recipient whose public key was used to encrypt the note. */
+    recipient: AztecAddress,
     /** The contract address this note is created in. */
     contractAddress: AztecAddress,
     /** The specific storage location of the note on the contract. */
     storageSlot: Fr,
-    /** The type identifier of the note on the contract. */
-    noteTypeId: NoteSelector,
     /** The hash of the tx the note was created in. */
     txHash: TxHash,
     /** The nonce of the note. */
     public nonce: Fr,
   ) {
-    super(note, owner, contractAddress, storageSlot, noteTypeId, txHash);
+    super(note, recipient, contractAddress, storageSlot, txHash);
   }
 
   static override get schema() {
     return z
       .object({
         note: Note.schema,
-        owner: schemas.AztecAddress,
+        recipient: schemas.AztecAddress,
         contractAddress: schemas.AztecAddress,
         storageSlot: schemas.Fr,
-        noteTypeId: schemas.NoteSelector,
         txHash: TxHash.schema,
         nonce: schemas.Fr,
       })
-      .transform(({ note, owner, contractAddress, storageSlot, noteTypeId, txHash, nonce }) => {
-        return new UniqueNote(note, owner, contractAddress, storageSlot, noteTypeId, txHash, nonce);
+      .transform(({ note, recipient, contractAddress, storageSlot, txHash, nonce }) => {
+        return new UniqueNote(note, recipient, contractAddress, storageSlot, txHash, nonce);
       });
   }
 
   override toBuffer(): Buffer {
     return serializeToBuffer([
       this.note,
-      this.owner,
+      this.recipient,
       this.contractAddress,
       this.storageSlot,
-      this.noteTypeId,
       this.txHash,
       this.nonce,
     ]);
@@ -142,7 +125,6 @@ export class UniqueNote extends ExtendedNote {
       await AztecAddress.random(),
       await AztecAddress.random(),
       Fr.random(),
-      NoteSelector.random(),
       TxHash.random(),
       Fr.random(),
     );
@@ -152,14 +134,13 @@ export class UniqueNote extends ExtendedNote {
     const reader = BufferReader.asReader(buffer);
 
     const note = reader.readObject(Note);
-    const owner = reader.readObject(AztecAddress);
+    const recipient = reader.readObject(AztecAddress);
     const contractAddress = reader.readObject(AztecAddress);
     const storageSlot = reader.readObject(Fr);
-    const noteTypeId = reader.readObject(NoteSelector);
     const txHash = reader.readObject(TxHash);
     const nonce = reader.readObject(Fr);
 
-    return new this(note, owner, contractAddress, storageSlot, noteTypeId, txHash, nonce);
+    return new this(note, recipient, contractAddress, storageSlot, txHash, nonce);
   }
 
   static override fromString(str: string) {

package/src/note/notes_filter.ts

@@ -18,8 +18,8 @@ export type NotesFilter = {
   contractAddress?: AztecAddress;
   /** The specific storage location of the note on the contract. */
   storageSlot?: Fr;
-  /** The owner of the note (whose public key was used to encrypt the note). */
-  owner?: AztecAddress;
+  /** The recipient of the note (whose public key was used to encrypt the note). */
+  recipient?: AztecAddress;
   /** The status of the note. Defaults to 'ACTIVE'. */
   status?: NoteStatus;
   /** The siloed nullifier for the note. */
@@ -32,7 +32,7 @@ export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
   txHash: TxHash.schema.optional(),
   contractAddress: schemas.AztecAddress.optional(),
   storageSlot: schemas.Fr.optional(),
-  owner: schemas.AztecAddress.optional(),
+  recipient: schemas.AztecAddress.optional(),
   status: z.nativeEnum(NoteStatus).optional(),
   siloedNullifier: schemas.Fr.optional(),
   scopes: z.array(schemas.AztecAddress).optional(),