@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.d3ec352c

package/src/kernel/public_call_request.ts

@@ -97,6 +97,22 @@ export class PublicCallRequest {
     return new PublicCallRequest(AztecAddress.ZERO, AztecAddress.ZERO, false, Fr.ZERO);
   }
 
+  /**
+   * Creates a PublicCallRequest instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicCallRequest fields
+   * @returns A PublicCallRequest instance
+   */
+  static fromPlainObject(obj: any): PublicCallRequest {
+    return new PublicCallRequest(
+      AztecAddress.fromPlainObject(obj.msgSender),
+      AztecAddress.fromPlainObject(obj.contractAddress),
+      obj.isStaticCall,
+      Fr.fromPlainObject(obj.calldataHash),
+    );
+  }
+
   isEmpty(): boolean {
     return (
       this.msgSender.isZero() && this.contractAddress.isZero() && !this.isStaticCall && this.calldataHash.isEmpty()
@@ -180,6 +196,17 @@ export class PublicCallRequestArrayLengths {
     return new PublicCallRequestArrayLengths(0, 0, false);
   }
 
+  /**
+   * Creates a PublicCallRequestArrayLengths instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicCallRequestArrayLengths fields
+   * @returns A PublicCallRequestArrayLengths instance
+   */
+  static fromPlainObject(obj: any): PublicCallRequestArrayLengths {
+    return new PublicCallRequestArrayLengths(obj.setupCalls, obj.appLogicCalls, obj.teardownCall);
+  }
+
   [inspect.custom]() {
     return `PublicCallRequestArrayLengths {
       setupCalls: ${this.setupCalls}

package/src/keys/public_keys.ts

@@ -52,6 +52,25 @@ export class PublicKeys {
     );
   }
 
+  /**
+   * Creates a PublicKeys from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicKeys fields
+   * @returns A PublicKeys instance
+   */
+  static fromPlainObject(obj: any): PublicKeys {
+    if (obj instanceof PublicKeys) {
+      return obj;
+    }
+    return new PublicKeys(
+      Point.fromPlainObject(obj.masterNullifierPublicKey),
+      Point.fromPlainObject(obj.masterIncomingViewingPublicKey),
+      Point.fromPlainObject(obj.masterOutgoingViewingPublicKey),
+      Point.fromPlainObject(obj.masterTaggingPublicKey),
+    );
+  }
+
   hash() {
     return this.isEmpty()
       ? Fr.ZERO

package/src/logs/contract_class_log.ts

@@ -29,6 +29,20 @@ export class ContractClassLogFields {
       .transform(({ fields }) => new ContractClassLogFields(fields));
   }
 
+  /**
+   * Creates a ContractClassLogFields from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ContractClassLogFields fields
+   * @returns A ContractClassLogFields instance
+   */
+  static fromPlainObject(obj: any): ContractClassLogFields {
+    if (obj instanceof ContractClassLogFields) {
+      return obj;
+    }
+    return new ContractClassLogFields(obj.fields.map((f: any) => Fr.fromPlainObject(f)));
+  }
+
   toFields(): Fr[] {
     return this.fields;
   }
@@ -191,6 +205,24 @@ export class ContractClassLog {
       .transform(ContractClassLog.from);
   }
 
+  /**
+   * Creates a ContractClassLog from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ContractClassLog fields
+   * @returns A ContractClassLog instance
+   */
+  static fromPlainObject(obj: any): ContractClassLog {
+    if (obj instanceof ContractClassLog) {
+      return obj;
+    }
+    return new ContractClassLog(
+      AztecAddress.fromPlainObject(obj.contractAddress),
+      ContractClassLogFields.fromPlainObject(obj.fields),
+      obj.emittedLength,
+    );
+  }
+
   [inspect.custom](): string {
     return `ContractClassLog {
       contractAddress: ${this.contractAddress.toString()},

package/src/logs/debug_log.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
 import { type LogLevel, LogLevels } from '@aztec/foundation/log';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 
@@ -29,4 +29,23 @@ export class DebugLog {
         ({ contractAddress, level, message, fields }) => new DebugLog(contractAddress, level, message, fields),
       );
   }
+
+  /**
+   * Creates a DebugLog from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing DebugLog fields
+   * @returns A DebugLog instance
+   */
+  static fromPlainObject(obj: any): DebugLog {
+    if (obj instanceof DebugLog) {
+      return obj;
+    }
+    return new DebugLog(
+      AztecAddress.fromPlainObject(obj.contractAddress),
+      obj.level,
+      obj.message,
+      obj.fields.map((f: any) => Fr.fromPlainObject(f)),
+    );
+  }
 }

package/src/logs/log_id.ts

@@ -1,5 +1,6 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
 import { BufferReader } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
@@ -16,7 +17,7 @@ export class LogId {
    */
   constructor(
     /** The block number the log was emitted in. */
-    public readonly blockNumber: number,
+    public readonly blockNumber: BlockNumber,
     /** The index of a tx in a block the log was emitted in. */
     public readonly txIndex: number,
     /** The index of a log the tx was emitted in. */
@@ -35,7 +36,7 @@ export class LogId {
 
   static random() {
     return new LogId(
-      Math.floor(Math.random() * 1000) + 1,
+      BlockNumber(Math.floor(Math.random() * 1000) + 1),
       Math.floor(Math.random() * 1000),
       Math.floor(Math.random() * 100),
     );
@@ -44,7 +45,7 @@ export class LogId {
   static get schema() {
     return z
       .object({
-        blockNumber: schemas.Integer,
+        blockNumber: BlockNumberSchema,
         txIndex: schemas.Integer,
         logIndex: schemas.Integer,
       })
@@ -71,7 +72,7 @@ export class LogId {
   static fromBuffer(buffer: Buffer | BufferReader): LogId {
     const reader = BufferReader.asReader(buffer);
 
-    const blockNumber = reader.readNumber();
+    const blockNumber = BlockNumber(reader.readNumber());
     const txIndex = reader.readNumber();
     const logIndex = reader.readNumber();
 
@@ -93,7 +94,7 @@ export class LogId {
    */
   static fromString(data: string): LogId {
     const [rawBlockNumber, rawTxIndex, rawLogIndex] = data.split('-');
-    const blockNumber = Number(rawBlockNumber);
+    const blockNumber = BlockNumber(Number(rawBlockNumber));
     const txIndex = Number(rawTxIndex);
     const logIndex = Number(rawLogIndex);
 

package/src/logs/private_log.ts

@@ -49,12 +49,11 @@ export class PrivateLog {
   }
 
   toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength)].concat(this.getEmittedFields());
+    return this.getEmittedFields();
   }
 
-  static fromBlobFields(fields: Fr[] | FieldReader) {
+  static fromBlobFields(emittedLength: number, fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    const emittedLength = reader.readU32();
     const emittedFields = reader.readFieldArray(emittedLength);
     return new PrivateLog(padArrayEnd(emittedFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS), emittedLength);
   }
@@ -92,6 +91,23 @@ export class PrivateLog {
       .transform(({ fields, emittedLength }) => PrivateLog.fromFields(fields.concat(new Fr(emittedLength))));
   }
 
+  /**
+   * Creates a PrivateLog from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PrivateLog fields
+   * @returns A PrivateLog instance
+   */
+  static fromPlainObject(obj: any): PrivateLog {
+    if (obj instanceof PrivateLog) {
+      return obj;
+    }
+    return new PrivateLog(
+      obj.fields.map((f: any) => Fr.fromPlainObject(f)),
+      obj.emittedLength,
+    );
+  }
+
   equals(other: PrivateLog) {
     return this.fields.every((field, i) => field.equals(other.fields[i])) && this.emittedLength === other.emittedLength;
   }

package/src/logs/public_log.ts

@@ -99,6 +99,20 @@ export class FlatPublicLogs {
     return new FlatPublicLogs(0, Array(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH).fill(Fr.ZERO));
   }
 
+  /**
+   * Creates a FlatPublicLogs instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing FlatPublicLogs fields
+   * @returns A FlatPublicLogs instance
+   */
+  static fromPlainObject(obj: any): FlatPublicLogs {
+    return new FlatPublicLogs(
+      obj.length,
+      obj.payload.map((p: any) => Fr.fromPlainObject(p)),
+    );
+  }
+
   isEmpty() {
     return this.length === 0;
   }

package/src/logs/tx_scoped_l2_log.ts

@@ -1,3 +1,4 @@
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
 import { BufferReader, boolToBuffer, numToUInt32BE } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
@@ -26,7 +27,7 @@ export class TxScopedL2Log {
     /*
      * The block this log is included in
      */
-    public blockNumber: number,
+    public blockNumber: BlockNumber,
     /*
      * The log data as either a PrivateLog or PublicLog
      */
@@ -43,7 +44,7 @@ export class TxScopedL2Log {
         txHash: TxHash.schema,
         dataStartIndexForTx: z.number(),
         logIndexInTx: z.number(),
-        blockNumber: z.number(),
+        blockNumber: BlockNumberSchema,
         log: z.union([PrivateLog.schema, PublicLog.schema]),
       })
       .transform(
@@ -69,7 +70,7 @@ export class TxScopedL2Log {
     const txHash = reader.readObject(TxHash);
     const dataStartIndexForTx = reader.readNumber();
     const logIndexInTx = reader.readNumber();
-    const blockNumber = reader.readNumber();
+    const blockNumber = BlockNumber(reader.readNumber());
     const isFromPublic = reader.readBoolean();
     const log = isFromPublic ? PublicLog.fromBuffer(reader) : PrivateLog.fromBuffer(reader);
 
@@ -78,7 +79,7 @@ export class TxScopedL2Log {
 
   static async random(isFromPublic = Math.random() < 0.5) {
     const log = isFromPublic ? await PublicLog.random() : PrivateLog.random();
-    return new TxScopedL2Log(TxHash.random(), 1, 1, 1, log);
+    return new TxScopedL2Log(TxHash.random(), 1, 1, BlockNumber(1), log);
   }
 
   equals(other: TxScopedL2Log) {

package/src/messaging/in_hash.ts

@@ -0,0 +1,10 @@
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { computeBalancedShaRoot } from '@aztec/foundation/trees';
+
+/** Computes the inHash for a block's ContentCommitment given its l1 to l2 messages. */
+export function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages: Fr[]): Fr {
+  const l1ToL2Messages = padArrayEnd<Fr, number>(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  return new Fr(computeBalancedShaRoot(l1ToL2Messages.map(msg => msg.toBuffer())));
+}

package/src/messaging/index.ts

@@ -1,3 +1,4 @@
+export * from './in_hash.js';
 export * from './inbox_leaf.js';
 export * from './l1_to_l2_message.js';
 export * from './l1_to_l2_message_source.js';
@@ -5,3 +6,4 @@ export * from './l1_actor.js';
 export * from './l2_actor.js';
 export * from './l2_to_l1_message.js';
 export * from './l2_to_l1_membership.js';
+export * from './out_hash.js';

package/src/messaging/l1_to_l2_message_source.ts

@@ -1,3 +1,4 @@
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/fields';
 
 import type { L2Tips } from '../block/l2_block_source.js';
@@ -6,12 +7,19 @@ import type { L2Tips } from '../block/l2_block_source.js';
  * Interface of classes allowing for the retrieval of L1 to L2 messages.
  */
 export interface L1ToL2MessageSource {
+  /**
+   * Gets new L1 to L2 message (to be) included in a given checkpoint.
+   * @param checkpointNumber - Checkpoint number to get messages for.
+   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
+   */
+  getL1ToL2MessagesForCheckpoint(checkpointNumber: CheckpointNumber): Promise<Fr[]>;
+
   /**
    * Gets new L1 to L2 message (to be) included in a given block.
    * @param blockNumber - L2 block number to get messages for.
    * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
    */
-  getL1ToL2Messages(blockNumber: number): Promise<Fr[]>;
+  getL1ToL2Messages(blockNumber: BlockNumber): Promise<Fr[]>;
 
   /**
    * Gets the L1 to L2 message index in the L1 to L2 message tree.
@@ -24,7 +32,7 @@ export interface L1ToL2MessageSource {
    * Gets the number of the latest L2 block processed by the implementation.
    * @returns The number of the latest L2 block processed by the implementation.
    */
-  getBlockNumber(): Promise<number>;
+  getBlockNumber(): Promise<BlockNumber>;
 
   /**
    * Returns the tips of the L2 chain.

package/src/messaging/l2_to_l1_membership.ts

@@ -1,8 +1,9 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
-import { SiblingPath, UnbalancedMerkleTreeCalculator, computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
+import { SiblingPath, UnbalancedMerkleTreeCalculator, computeUnbalancedShaRoot } from '@aztec/foundation/trees';
 
 export interface MessageRetrieval {
-  getL2ToL1Messages(l2BlockNumber: number): Promise<Fr[][] | undefined>;
+  getL2ToL1Messages(l2BlockNumber: BlockNumber): Promise<Fr[][] | undefined>;
 }
 
 export type L2ToL1MembershipWitness = {
@@ -13,7 +14,7 @@ export type L2ToL1MembershipWitness = {
 
 export async function computeL2ToL1MembershipWitness(
   messageRetriever: MessageRetrieval,
-  l2BlockNumber: number,
+  l2BlockNumber: BlockNumber,
   message: Fr,
 ): Promise<L2ToL1MembershipWitness | undefined> {
   const messagesForAllTxs = await messageRetriever.getL2ToL1Messages(l2BlockNumber);
@@ -58,7 +59,7 @@ export function computeL2ToL1MembershipWitnessFromMessagesForAllTxs(
       return Fr.fromBuffer(txOutHash);
     }
 
-    const root = computeUnbalancedMerkleTreeRoot(messages.map(msg => msg.toBuffer()));
+    const root = computeUnbalancedShaRoot(messages.map(msg => msg.toBuffer()));
     return Fr.fromBuffer(root);
   });
 

package/src/messaging/l2_to_l1_message.ts

@@ -30,6 +30,17 @@ export class L2ToL1Message {
     return new L2ToL1Message(EthAddress.ZERO, Fr.zero());
   }
 
+  /**
+   * Creates an L2ToL1Message instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing L2ToL1Message fields
+   * @returns An L2ToL1Message instance
+   */
+  static fromPlainObject(obj: any): L2ToL1Message {
+    return new L2ToL1Message(EthAddress.fromPlainObject(obj.recipient), Fr.fromPlainObject(obj.content));
+  }
+
   /**
    * Checks if another L2ToL1Message is equal to this instance.
    * @param other Another L2ToL1Message instance to compare with.
@@ -149,6 +160,20 @@ export class ScopedL2ToL1Message {
     return new ScopedL2ToL1Message(L2ToL1Message.empty(), AztecAddress.ZERO);
   }
 
+  /**
+   * Creates a ScopedL2ToL1Message instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ScopedL2ToL1Message fields
+   * @returns A ScopedL2ToL1Message instance
+   */
+  static fromPlainObject(obj: any): ScopedL2ToL1Message {
+    return new ScopedL2ToL1Message(
+      L2ToL1Message.fromPlainObject(obj.message),
+      AztecAddress.fromPlainObject(obj.contractAddress),
+    );
+  }
+
   isEmpty(): boolean {
     return this.message.isEmpty() && this.contractAddress.isZero();
   }

package/src/messaging/out_hash.ts

@@ -0,0 +1,36 @@
+import { Fr } from '@aztec/foundation/fields';
+import { UnbalancedMerkleTreeCalculator, computeUnbalancedShaRoot } from '@aztec/foundation/trees';
+
+export function computeTxOutHash(messages: Fr[]): Fr {
+  if (!messages.length) {
+    return Fr.ZERO;
+  }
+  // Tx out hash is the root of the unbalanced merkle tree of all the messages.
+  // Zero hashes (which should not happen) are not compressed.
+  return Fr.fromBuffer(computeUnbalancedShaRoot(messages.map(msg => msg.toBuffer())));
+}
+
+export function computeBlockOutHash(messagesPerBlock: Fr[][]): Fr {
+  const txOutHashes = messagesPerBlock.map(messages => computeTxOutHash(messages));
+  return aggregateOutHashes(txOutHashes);
+}
+
+export function computeCheckpointOutHash(messagesForAllTxs: Fr[][][]): Fr {
+  const blockOutHashes = messagesForAllTxs.map(block => computeBlockOutHash(block));
+  return aggregateOutHashes(blockOutHashes);
+}
+
+// The root of this tree should match the `out_hash` calculated in the circuits. Zero hashes are compressed to reduce
+// cost if the non-zero leaves result in a shorter path.
+function aggregateOutHashes(outHashes: Fr[]): Fr {
+  if (!outHashes.length) {
+    return Fr.ZERO;
+  }
+
+  const valueToCompress = Buffer.alloc(32);
+  const tree = UnbalancedMerkleTreeCalculator.create(
+    outHashes.map(hash => hash.toBuffer()),
+    valueToCompress,
+  );
+  return Fr.fromBuffer(tree.getRoot());
+}

package/src/noir/index.ts

@@ -8,12 +8,12 @@ import type {
   DebugInfo,
 } from '../abi/abi.js';
 
-export const AZTEC_PRIVATE_ATTRIBUTE = 'private';
-export const AZTEC_PUBLIC_ATTRIBUTE = 'public';
-export const AZTEC_UTILITY_ATTRIBUTE = 'utility';
-export const AZTEC_INTERNAL_ATTRIBUTE = 'internal';
-export const AZTEC_INITIALIZER_ATTRIBUTE = 'initializer';
-export const AZTEC_VIEW_ATTRIBUTE = 'view';
+export const AZTEC_PRIVATE_ATTRIBUTE = 'abi_private';
+export const AZTEC_PUBLIC_ATTRIBUTE = 'abi_public';
+export const AZTEC_UTILITY_ATTRIBUTE = 'abi_utility';
+export const AZTEC_ONLY_SELF_ATTRIBUTE = 'abi_only_self';
+export const AZTEC_INITIALIZER_ATTRIBUTE = 'abi_initializer';
+export const AZTEC_VIEW_ATTRIBUTE = 'abi_view';
 
 /** The ABI of an Aztec.nr function. */
 export interface NoirFunctionAbi {

package/src/note/index.ts

@@ -1,5 +1,5 @@
 export * from './comparator.js';
-export * from './unique_note.js';
+export * from './note_dao.js';
 export * from './notes_filter.js';
 export * from './note_status.js';
 export * from './note.js';

package/src/note/note_dao.ts

@@ -0,0 +1,161 @@
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr, Point } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Note } from '@aztec/stdlib/note';
+import { TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * A Note Data Access Object, representing a note that was committed to the note hash tree, holding all of the
+ * information required to use it during execution and manage its state.
+ */
+export class NoteDao {
+  constructor(
+    // Note information
+
+    /** The packed content of the note, as will be returned in the getNotes oracle. */
+    public note: Note,
+    /** The address of the contract that created the note (i.e. the address used by the kernel during siloing). */
+    public contractAddress: AztecAddress,
+    /** The owner of the note - generally the account that can spend the note. */
+    public owner: AztecAddress,
+    /**
+     * The storage location of the note. This value is not used for anything in PXE, but we do index by storage slot
+     * since contracts typically make queries based on it.
+     */
+    public storageSlot: Fr,
+    /**
+     * The randomness injected to the note hash preimage.
+     */
+    public randomness: Fr,
+    /** The nonce that was injected into the note hash preimage in order to guarantee uniqueness. */
+    public noteNonce: Fr,
+
+    // Computed values
+    /**
+     * The inner hash (non-unique, non-siloed) of the note. Each contract determines how the note is hashed. Can
+     * be used alongside contractAddress and nonce to compute the uniqueNoteHash and the siloedNoteHash.
+     */
+    public noteHash: Fr,
+    /**
+     * The nullifier of the note, siloed by contract address.
+     * Note: Might be set as 0 if the note was added to PXE as nullified.
+     */
+    public siloedNullifier: Fr,
+
+    // Metadata
+    /** The hash of the tx in which this note was created. Knowing the tx hash allows for efficient node queries e.g.
+     *  when searching for txEffects.
+     */
+    public txHash: TxHash,
+    /** The L2 block number in which the tx with this note was included. Used for note management while processing
+     * reorgs.*/
+    public l2BlockNumber: BlockNumber,
+    /** The L2 block hash in which the tx with this note was included. Used for note management while processing
+     * reorgs.*/
+    public l2BlockHash: string,
+    /** The index of the leaf in the global note hash tree the note is stored at */
+    public index: bigint,
+  ) {}
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([
+      this.note,
+      this.contractAddress,
+      this.owner,
+      this.storageSlot,
+      this.randomness,
+      this.noteNonce,
+      this.noteHash,
+      this.siloedNullifier,
+      this.txHash,
+      this.l2BlockNumber,
+      Fr.fromHexString(this.l2BlockHash),
+      this.index,
+    ]);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+
+    const note = Note.fromBuffer(reader);
+    const contractAddress = AztecAddress.fromBuffer(reader);
+    const owner = AztecAddress.fromBuffer(reader);
+    const storageSlot = Fr.fromBuffer(reader);
+    const randomness = Fr.fromBuffer(reader);
+    const noteNonce = Fr.fromBuffer(reader);
+    const noteHash = Fr.fromBuffer(reader);
+    const siloedNullifier = Fr.fromBuffer(reader);
+    const txHash = reader.readObject(TxHash);
+    const l2BlockNumber = BlockNumber(reader.readNumber());
+    const l2BlockHash = Fr.fromBuffer(reader).toString();
+    const index = toBigIntBE(reader.readBytes(32));
+
+    return new NoteDao(
+      note,
+      contractAddress,
+      owner,
+      storageSlot,
+      randomness,
+      noteNonce,
+      noteHash,
+      siloedNullifier,
+      txHash,
+      l2BlockNumber,
+      l2BlockHash,
+      index,
+    );
+  }
+
+  toString() {
+    return '0x' + this.toBuffer().toString('hex');
+  }
+
+  static fromString(str: string) {
+    const hex = str.replace(/^0x/, '');
+    return NoteDao.fromBuffer(Buffer.from(hex, 'hex'));
+  }
+
+  /**
+   * Returns the size in bytes of the Note Dao.
+   * @returns - Its size in bytes.
+   */
+  public getSize() {
+    const indexSize = Math.ceil(Math.log2(Number(this.index)));
+    const noteSize = 4 + this.note.items.length * Fr.SIZE_IN_BYTES;
+    return (
+      noteSize + AztecAddress.SIZE_IN_BYTES * 2 + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + indexSize
+    );
+  }
+
+  static async random({
+    note = Note.random(),
+    contractAddress = undefined,
+    owner = undefined,
+    storageSlot = Fr.random(),
+    randomness = Fr.random(),
+    noteNonce = Fr.random(),
+    noteHash = Fr.random(),
+    siloedNullifier = Fr.random(),
+    txHash = TxHash.random(),
+    l2BlockNumber = BlockNumber(Math.floor(Math.random() * 1000)),
+    l2BlockHash = Fr.random().toString(),
+    index = Fr.random().toBigInt(),
+  }: Partial<NoteDao> = {}) {
+    return new NoteDao(
+      note,
+      contractAddress ?? (await AztecAddress.random()),
+      owner ?? (await AztecAddress.random()),
+      storageSlot,
+      randomness,
+      noteNonce,
+      noteHash,
+      siloedNullifier,
+      txHash,
+      l2BlockNumber,
+      l2BlockHash,
+      index,
+    );
+  }
+}

package/src/note/notes_filter.ts

@@ -16,6 +16,8 @@ export type NotesFilter = {
    * @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'. */
@@ -28,6 +30,7 @@ export type NotesFilter = {
 
 export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
   contractAddress: schemas.AztecAddress,
+  owner: schemas.AztecAddress.optional(),
   storageSlot: schemas.Fr.optional(),
   status: z.nativeEnum(NoteStatus).optional(),
   siloedNullifier: schemas.Fr.optional(),