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

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,7 @@ 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());
   }
 
   /**
@@ -36,9 +36,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 +44,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 +52,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 +62,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 +72,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,40 +80,77 @@ 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 ScopedL2ToL1Message {
-  constructor(public message: L2ToL1Message, public contractAddress: AztecAddress) {}
+export class CountedL2ToL1Message {
+  constructor(
+    public message: L2ToL1Message,
+    public counter: number,
+  ) {}
 
   static get schema() {
     return z
       .object({
         message: L2ToL1Message.schema,
-        contractAddress: AztecAddress.schema,
+        counter: z.number().int().nonnegative(),
       })
-      .transform(({ message, contractAddress }) => new ScopedL2ToL1Message(message, contractAddress));
+      .transform(({ message, counter }) => new CountedL2ToL1Message(message, counter));
   }
 
-  static getFields(fields: FieldsOf<ScopedL2ToL1Message>) {
-    return [fields.message, fields.contractAddress] as const;
+  static empty() {
+    return new CountedL2ToL1Message(L2ToL1Message.empty(), 0);
   }
 
-  static empty() {
-    return new ScopedL2ToL1Message(L2ToL1Message.empty(), AztecAddress.ZERO);
+  isEmpty(): boolean {
+    return this.message.isEmpty() && !this.counter;
   }
 
-  equals(other: ScopedL2ToL1Message): boolean {
-    return this.message.equals(other.message) && this.contractAddress.equals(other.contractAddress);
+  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.contractAddress);
+    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,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        message: L2ToL1Message.schema,
+        contractAddress: AztecAddress.schema,
+      })
+      .transform(({ message, contractAddress }) => new ScopedL2ToL1Message(message, contractAddress));
+  }
+
+  static empty() {
+    return new ScopedL2ToL1Message(L2ToL1Message.empty(), AztecAddress.ZERO);
+  }
+
+  isEmpty(): boolean {
+    return this.message.isEmpty() && this.contractAddress.isZero();
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -129,22 +158,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/noir/index.ts

@@ -10,6 +10,7 @@ import type {
 
 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';
@@ -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 './unique_note.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]));
+  }
 }

package/src/note/notes_filter.ts

@@ -4,7 +4,6 @@ import { z } from 'zod';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import { type ZodFor, schemas } from '../schemas/index.js';
-import { TxHash } from '../tx/tx_hash.js';
 import { NoteStatus } from './note_status.js';
 
 /**
@@ -12,14 +11,13 @@ import { NoteStatus } from './note_status.js';
  * @remarks This filter is applied as an intersection of all its params.
  */
 export type NotesFilter = {
-  /** Hash of a transaction from which to fetch the notes. */
-  txHash?: TxHash;
-  /** The contract address the note belongs to. */
-  contractAddress?: AztecAddress;
+  /**
+   * 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 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 status of the note. Defaults to 'ACTIVE'. */
   status?: NoteStatus;
   /** The siloed nullifier for the note. */
@@ -29,10 +27,8 @@ export type NotesFilter = {
 };
 
 export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
-  txHash: TxHash.schema.optional(),
-  contractAddress: schemas.AztecAddress.optional(),
+  contractAddress: schemas.AztecAddress,
   storageSlot: schemas.Fr.optional(),
-  owner: schemas.AztecAddress.optional(),
   status: z.nativeEnum(NoteStatus).optional(),
   siloedNullifier: schemas.Fr.optional(),
   scopes: z.array(schemas.AztecAddress).optional(),

package/src/note/unique_note.ts

@@ -0,0 +1,88 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+import { type ZodFor, schemas } from '../schemas/index.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { Note } from './note.js';
+
+/**
+ * A note with contextual data and a nonce that makes it unique.
+ */
+export class UniqueNote {
+  constructor(
+    /** The note as emitted from the Noir contract. */
+    public note: Note,
+    /** The recipient 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 hash of the tx the note was created in. */
+    public txHash: TxHash,
+    /** The nonce that was injected into the note hash preimage in order to guarantee uniqueness. */
+    public noteNonce: Fr,
+  ) {}
+
+  static get schema(): ZodFor<UniqueNote> {
+    return z
+      .object({
+        note: Note.schema,
+        recipient: schemas.AztecAddress,
+        contractAddress: schemas.AztecAddress,
+        storageSlot: schemas.Fr,
+        txHash: TxHash.schema,
+        noteNonce: schemas.Fr,
+      })
+      .transform(({ note, recipient, contractAddress, storageSlot, txHash, noteNonce }) => {
+        return new UniqueNote(note, recipient, contractAddress, storageSlot, txHash, noteNonce);
+      });
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([
+      this.note,
+      this.recipient,
+      this.contractAddress,
+      this.storageSlot,
+      this.txHash,
+      this.noteNonce,
+    ]);
+  }
+
+  static async random() {
+    return new UniqueNote(
+      Note.random(),
+      await AztecAddress.random(),
+      await AztecAddress.random(),
+      Fr.random(),
+      TxHash.random(),
+      Fr.random(),
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+
+    const note = reader.readObject(Note);
+    const recipient = reader.readObject(AztecAddress);
+    const contractAddress = reader.readObject(AztecAddress);
+    const storageSlot = reader.readObject(Fr);
+    const txHash = reader.readObject(TxHash);
+    const noteNonce = reader.readObject(Fr);
+
+    return new UniqueNote(note, recipient, contractAddress, storageSlot, txHash, noteNonce);
+  }
+
+  static fromString(str: string) {
+    return UniqueNote.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+}

package/src/p2p/attestation_utils.ts

@@ -0,0 +1,35 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import { CommitteeAttestation } from '../block/index.js';
+import type { BlockAttestation } from './block_attestation.js';
+
+/**
+ * Returns attestation signatures in the order of a series of provided ethereum addresses
+ * The rollup smart contract expects attestations to appear in the order of the committee
+ * @todo: perform this logic within the memory attestation store instead?
+ */
+export function orderAttestations(
+  attestations: BlockAttestation[],
+  orderAddresses: EthAddress[],
+): CommitteeAttestation[] {
+  // Create a map of sender addresses to BlockAttestations
+  const attestationMap = new Map<string, CommitteeAttestation>();
+
+  for (const attestation of attestations) {
+    const sender = attestation.getSender();
+    if (sender) {
+      attestationMap.set(
+        sender.toString(),
+        CommitteeAttestation.fromAddressAndSignature(sender, attestation.signature),
+      );
+    }
+  }
+
+  // Create the ordered array based on the orderAddresses, else return an empty attestation
+  const orderedAttestations = orderAddresses.map(address => {
+    const addressString = address.toString();
+    return attestationMap.get(addressString) || CommitteeAttestation.fromAddress(address);
+  });
+
+  return orderedAttestations;
+}