@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.5476d83

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/inbox_leaf.ts

@@ -22,7 +22,22 @@ export class InboxLeaf {
     return new InboxLeaf(index, leaf);
   }
 
-  static smallestIndexFromL2Block(l2block: bigint): bigint {
-    return (l2block - BigInt(INITIAL_L2_BLOCK_NUM)) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  static smallestIndexFromL2Block(l2blockNumber: number): bigint {
+    return BigInt(l2blockNumber - INITIAL_L2_BLOCK_NUM) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  }
+
+  /**
+   * Returns the range of valid indices for a given L2 block.
+   * Start index is inclusive, end index is exclusive.
+   */
+  static indexRangeFromL2Block(l2blockNumber: number): [bigint, bigint] {
+    const start = this.smallestIndexFromL2Block(l2blockNumber);
+    const end = start + BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    return [start, end];
+  }
+
+  /** Returns the L2 block number for a given leaf index */
+  static l2BlockFromIndex(index: bigint): number {
+    return Number(index / BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)) + INITIAL_L2_BLOCK_NUM;
   }
 }

package/src/messaging/index.ts

@@ -1,6 +1,9 @@
+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';
 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,5 +1,7 @@
 import type { Fr } from '@aztec/foundation/fields';
 
+import type { L2Tips } from '../block/l2_block_source.js';
+
 /**
  * Interface of classes allowing for the retrieval of L1 to L2 messages.
  */
@@ -9,7 +11,7 @@ export interface L1ToL2MessageSource {
    * @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: bigint): Promise<Fr[]>;
+  getL1ToL2Messages(blockNumber: number): Promise<Fr[]>;
 
   /**
    * Gets the L1 to L2 message index in the L1 to L2 message tree.
@@ -23,4 +25,9 @@ export interface L1ToL2MessageSource {
    * @returns The number of the latest L2 block processed by the implementation.
    */
   getBlockNumber(): Promise<number>;
+
+  /**
+   * Returns the tips of the L2 chain.
+   */
+  getL2Tips(): Promise<L2Tips>;
 }

package/src/messaging/l2_to_l1_membership.ts

@@ -0,0 +1,98 @@
+import { Fr } from '@aztec/foundation/fields';
+import { SiblingPath, UnbalancedMerkleTreeCalculator, computeUnbalancedShaRoot } from '@aztec/foundation/trees';
+
+export interface MessageRetrieval {
+  getL2ToL1Messages(l2BlockNumber: number): Promise<Fr[][] | undefined>;
+}
+
+export type L2ToL1MembershipWitness = {
+  root: Fr;
+  leafIndex: bigint;
+  siblingPath: SiblingPath<number>;
+};
+
+export async function computeL2ToL1MembershipWitness(
+  messageRetriever: MessageRetrieval,
+  l2BlockNumber: number,
+  message: Fr,
+): Promise<L2ToL1MembershipWitness | undefined> {
+  const messagesForAllTxs = await messageRetriever.getL2ToL1Messages(l2BlockNumber);
+  if (!messagesForAllTxs) {
+    return undefined;
+  }
+
+  return computeL2ToL1MembershipWitnessFromMessagesForAllTxs(messagesForAllTxs, message);
+}
+
+// TODO: Allow to specify the message to consume by its index or by an offset, in case there are multiple messages with
+// the same value.
+export function computeL2ToL1MembershipWitnessFromMessagesForAllTxs(
+  messagesForAllTxs: Fr[][],
+  message: Fr,
+): L2ToL1MembershipWitness {
+  // Find index of message in subtree and index of tx in a block.
+  let messageIndexInTx = -1;
+  const txIndex = messagesForAllTxs.findIndex(messages => {
+    messageIndexInTx = messages.findIndex(msg => msg.equals(message));
+    return messageIndexInTx !== -1;
+  });
+
+  if (txIndex === -1) {
+    throw new Error('The L2ToL1Message you are trying to prove inclusion of does not exist');
+  }
+
+  // Get the txOutHash and the sibling path of the message in the tx subtree.
+  const txMessages = messagesForAllTxs[txIndex];
+  const txOutHashTree = UnbalancedMerkleTreeCalculator.create(txMessages.map(msg => msg.toBuffer()));
+  const txOutHash = txOutHashTree.getRoot();
+  const messagePathInSubtree = txOutHashTree.getSiblingPath(message.toBuffer());
+
+  // Calculate txOutHash for all txs.
+  const txSubtreeRoots = messagesForAllTxs.map((messages, i) => {
+    // For a tx with no messages, we have to set an out hash of 0 to match what the circuit does.
+    if (messages.length === 0) {
+      return Fr.ZERO;
+    }
+
+    if (i === txIndex) {
+      return Fr.fromBuffer(txOutHash);
+    }
+
+    const root = computeUnbalancedShaRoot(messages.map(msg => msg.toBuffer()));
+    return Fr.fromBuffer(root);
+  });
+
+  // Construct the top tree.
+  // The leaves of this tree are the `txOutHashes`.
+  // 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.
+  const valueToCompress = Buffer.alloc(32);
+  const topTree = UnbalancedMerkleTreeCalculator.create(
+    txSubtreeRoots.map(root => root.toBuffer()),
+    valueToCompress,
+  );
+  const root = Fr.fromBuffer(topTree.getRoot());
+
+  // Compute the combined sibling path by appending the tx subtree path to the top tree path.
+  const txPathInTopTree = topTree.getSiblingPath(txOutHash);
+  const combinedPath = messagePathInSubtree.toBufferArray().concat(txPathInTopTree.toBufferArray());
+
+  // Compute the combined index.
+  // It is the index of the message in the balanced tree at its current height.
+  const txLeafIndexAtLevel = topTree.getLeafLocation(txIndex).index;
+  const messageLeafPosition = txOutHashTree.getLeafLocation(messageIndexInTx);
+  const numLeavesInLeftSubtrees = txLeafIndexAtLevel * (1 << messageLeafPosition.level);
+  const combinedIndex = numLeavesInLeftSubtrees + messageLeafPosition.index;
+
+  return {
+    root,
+    leafIndex: BigInt(combinedIndex),
+    siblingPath: new SiblingPath(combinedPath.length, combinedPath),
+  };
+}
+
+export function getL2ToL1MessageLeafId(
+  membershipWitness: Pick<L2ToL1MembershipWitness, 'leafIndex' | 'siblingPath'>,
+): bigint {
+  return 2n ** BigInt(membershipWitness.siblingPath.pathSize) + membershipWitness.leafIndex;
+}

package/src/messaging/l2_to_l1_message.ts

@@ -1,25 +1,25 @@
-import { L2_TO_L1_MESSAGE_LENGTH, SCOPED_L2_TO_L1_MESSAGE_LENGTH } from '@aztec/constants';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 
 export class L2ToL1Message {
-  constructor(public recipient: EthAddress, public content: Fr, public counter: number) {}
+  constructor(
+    public recipient: EthAddress,
+    public content: Fr,
+  ) {}
 
   static get schema() {
     return z
       .object({
         recipient: schemas.EthAddress,
         content: schemas.Fr,
-        counter: z.number().int().nonnegative(),
       })
-      .transform(({ recipient, content, counter }) => new L2ToL1Message(recipient, content, counter));
+      .transform(({ recipient, content }) => new L2ToL1Message(recipient, content));
   }
 
   /**
@@ -27,7 +27,18 @@ export class L2ToL1Message {
    * @returns An instance of L2ToL1Message with empty fields.
    */
   static empty(): L2ToL1Message {
-    return new L2ToL1Message(EthAddress.ZERO, Fr.zero(), 0);
+    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));
   }
 
   /**
@@ -36,9 +47,7 @@ export class L2ToL1Message {
    * @returns True if both recipient and content are equal.
    */
   equals(other: L2ToL1Message): boolean {
-    return (
-      this.recipient.equals(other.recipient) && this.content.equals(other.content) && this.counter === other.counter
-    );
+    return this.recipient.equals(other.recipient) && this.content.equals(other.content);
   }
 
   /**
@@ -46,7 +55,7 @@ export class L2ToL1Message {
    * @returns The buffer.
    */
   toBuffer(): Buffer {
-    return serializeToBuffer(this.recipient, this.content, this.counter);
+    return serializeToBuffer(this.recipient, this.content);
   }
 
   /**
@@ -54,13 +63,7 @@ export class L2ToL1Message {
    * @returns An array of fields representing the serialized message.
    */
   toFields(): Fr[] {
-    const fields = [this.recipient.toField(), this.content, new Fr(this.counter)];
-    if (fields.length !== L2_TO_L1_MESSAGE_LENGTH) {
-      throw new Error(
-        `Invalid number of fields for L2ToL1Message. Expected ${L2_TO_L1_MESSAGE_LENGTH}, got ${fields.length}`,
-      );
-    }
-    return fields;
+    return [this.recipient.toField(), this.content];
   }
 
   /**
@@ -70,7 +73,7 @@ export class L2ToL1Message {
    */
   static fromFields(fields: Fr[] | FieldReader): L2ToL1Message {
     const reader = FieldReader.asReader(fields);
-    return new L2ToL1Message(reader.readObject(EthAddress), reader.readField(), reader.readU32());
+    return new L2ToL1Message(reader.readObject(EthAddress), reader.readField());
   }
 
   /**
@@ -80,7 +83,7 @@ export class L2ToL1Message {
    */
   static fromBuffer(buffer: Buffer | BufferReader): L2ToL1Message {
     const reader = BufferReader.asReader(buffer);
-    return new L2ToL1Message(reader.readObject(EthAddress), reader.readObject(Fr), reader.readNumber());
+    return new L2ToL1Message(reader.readObject(EthAddress), reader.readObject(Fr));
   }
 
   /**
@@ -88,16 +91,61 @@ export class L2ToL1Message {
    * @returns True if both recipient and content are zero.
    */
   isEmpty(): boolean {
-    return this.recipient.isZero() && this.content.isZero() && !this.counter;
+    return this.recipient.isZero() && this.content.isZero();
   }
 
-  scope(contractAddress: AztecAddress) {
+  scope(contractAddress: AztecAddress): ScopedL2ToL1Message {
     return new ScopedL2ToL1Message(this, contractAddress);
   }
 }
 
+export class CountedL2ToL1Message {
+  constructor(
+    public message: L2ToL1Message,
+    public counter: number,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        message: L2ToL1Message.schema,
+        counter: z.number().int().nonnegative(),
+      })
+      .transform(({ message, counter }) => new CountedL2ToL1Message(message, counter));
+  }
+
+  static empty() {
+    return new CountedL2ToL1Message(L2ToL1Message.empty(), 0);
+  }
+
+  isEmpty(): boolean {
+    return this.message.isEmpty() && !this.counter;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CountedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readNumber());
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.message, this.counter);
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new CountedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readU32());
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(this.message, this.counter);
+  }
+}
+
 export class ScopedL2ToL1Message {
-  constructor(public message: L2ToL1Message, public contractAddress: AztecAddress) {}
+  constructor(
+    public message: L2ToL1Message,
+    public contractAddress: AztecAddress,
+  ) {}
 
   static get schema() {
     return z
@@ -108,20 +156,26 @@ export class ScopedL2ToL1Message {
       .transform(({ message, contractAddress }) => new ScopedL2ToL1Message(message, contractAddress));
   }
 
-  static getFields(fields: FieldsOf<ScopedL2ToL1Message>) {
-    return [fields.message, fields.contractAddress] as const;
-  }
-
   static empty() {
     return new ScopedL2ToL1Message(L2ToL1Message.empty(), AztecAddress.ZERO);
   }
 
-  equals(other: ScopedL2ToL1Message): boolean {
-    return this.message.equals(other.message) && this.contractAddress.equals(other.contractAddress);
+  /**
+   * 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),
+    );
   }
 
-  toBuffer(): Buffer {
-    return serializeToBuffer(this.message, this.contractAddress);
+  isEmpty(): boolean {
+    return this.message.isEmpty() && this.contractAddress.isZero();
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -129,22 +183,58 @@ export class ScopedL2ToL1Message {
     return new ScopedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readObject(AztecAddress));
   }
 
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.message, this.contractAddress);
+  }
+
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     return new ScopedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readObject(AztecAddress));
   }
 
   toFields(): Fr[] {
-    const fields = serializeToFields(...ScopedL2ToL1Message.getFields(this));
-    if (fields.length !== SCOPED_L2_TO_L1_MESSAGE_LENGTH) {
-      throw new Error(
-        `Invalid number of fields for ScopedL2ToL1Message. Expected ${SCOPED_L2_TO_L1_MESSAGE_LENGTH}, got ${fields.length}`,
-      );
-    }
-    return fields;
+    return serializeToFields(this.message, this.contractAddress);
+  }
+}
+
+export class ScopedCountedL2ToL1Message {
+  constructor(
+    public inner: CountedL2ToL1Message,
+    public contractAddress: AztecAddress,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        inner: CountedL2ToL1Message.schema,
+        contractAddress: AztecAddress.schema,
+      })
+      .transform(({ inner, contractAddress }) => new ScopedCountedL2ToL1Message(inner, contractAddress));
+  }
+
+  static empty() {
+    return new ScopedCountedL2ToL1Message(CountedL2ToL1Message.empty(), AztecAddress.ZERO);
   }
 
   isEmpty(): boolean {
-    return this.message.isEmpty() && this.contractAddress.isZero();
+    return this.inner.isEmpty() && this.contractAddress.isZero();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new ScopedCountedL2ToL1Message(reader.readObject(CountedL2ToL1Message), reader.readObject(AztecAddress));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.inner, this.contractAddress);
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new ScopedCountedL2ToL1Message(reader.readObject(CountedL2ToL1Message), reader.readObject(AztecAddress));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(this.inner, this.contractAddress);
   }
 }

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,11 +8,12 @@ import type {
   DebugInfo,
 } from '../abi/abi.js';
 
-export const AZTEC_PRIVATE_ATTRIBUTE = 'private';
-export const AZTEC_PUBLIC_ATTRIBUTE = 'public';
-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 {
@@ -36,7 +37,7 @@ export interface NoirFunctionAbi {
 /**
  * The compilation result of an Aztec.nr function.
  */
-export interface NoirFunctionEntry {
+interface NoirFunctionEntry {
   /** The name of the function. */
   name: string;
   /** Whether the function is unconstrained. */
@@ -63,6 +64,8 @@ export interface NoirFunctionEntry {
 export interface NoirCompiledContract {
   /** The name of the contract. */
   name: string;
+  /** Is the contract's public bytecode transpiled? */
+  transpiled?: boolean;
   /** The functions of the contract. */
   functions: NoirFunctionEntry[];
   /** The events of the contract */
@@ -75,7 +78,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. */
@@ -86,12 +89,26 @@ export interface NoirCompiledCircuit {
   abi: NoirFunctionAbi;
   /** The bytecode of the circuit in base64. */
   bytecode: string;
+  /** The verification key of the circuit. */
+  verificationKey: {
+    /** hex-encoded binary */
+    bytes: string;
+    /** list of hex-encoded fields */
+    fields: string[];
+    /** The hex-encoded hash. */
+    hash: string;
+  };
   /** The debug information, compressed and base64 encoded. */
   debug_symbols: string;
   /** The map of file ID to the source code and path of the file. */
   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/index.ts

@@ -1,5 +1,5 @@
 export * from './comparator.js';
-export * from './extended_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.ts

@@ -1,16 +1,72 @@
+import { randomInt } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
-import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { Payload } from '../logs/l1_payload/payload.js';
+import { schemas } from '../schemas/index.js';
+import { Vector } from '../types/shared.js';
 
-export class Note extends Payload {
-  static override get schema() {
+/**
+ * The Note class represents a Note emitted from a Noir contract as a vector of Fr (finite field) elements.
+ * This data also represents a preimage to a note hash.
+ */
+export class Note extends Vector<Fr> {
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
     return schemas.Buffer.transform(Note.fromBuffer);
   }
 
-  static override fromBuffer(buffer: Buffer | BufferReader) {
+  /**
+   * Create a Note instance from a Buffer or BufferReader.
+   * The input 'buffer' can be either a Buffer containing the serialized Fr elements or a BufferReader instance.
+   * This function reads the Fr elements in the buffer and constructs a Note with them.
+   *
+   * @param buffer - The Buffer or BufferReader containing the serialized Fr elements.
+   * @returns A Note instance containing the deserialized Fr elements.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new Note(reader.readVector(Fr));
   }
+
+  /**
+   * Generates a random Note instance with a variable number of items.
+   * The number of items is determined by a random value between 1 and 10 (inclusive).
+   * Each item in the Note is generated using the Fr.random() method.
+   *
+   * @returns A randomly generated Note instance.
+   */
+  static random() {
+    const numItems = randomInt(10) + 1;
+    const items = Array.from({ length: numItems }, () => Fr.random());
+    return new Note(items);
+  }
+
+  /**
+   * Returns a hex representation of the note.
+   * @returns A hex string with the vector length as first element.
+   */
+  override toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Creates a new Note instance from a hex string.
+   * @param str - Hex representation.
+   * @returns A Note instance.
+   */
+  static fromString(str: string) {
+    return Note.fromBuffer(hexToBuffer(str));
+  }
+
+  get length() {
+    return this.items.length;
+  }
+
+  equals(other: Note) {
+    return this.items.every((item, index) => item.equals(other.items[index]));
+  }
 }