@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/keys/key_types.ts

@@ -0,0 +1,5 @@
+import type { GeneratorIndex } from '@aztec/constants';
+
+export type KeyGenerator = GeneratorIndex.NSK_M | GeneratorIndex.IVSK_M | GeneratorIndex.OVSK_M | GeneratorIndex.TSK_M;
+export type KeyPrefix = 'n' | 'iv' | 'ov' | 't';
+export const KEY_PREFIXES: KeyPrefix[] = ['n', 'iv', 'ov', 't'];

package/src/keys/public_key.ts

@@ -0,0 +1,4 @@
+import type { Point } from '@aztec/foundation/fields';
+
+/** Represents a user public key. */
+export type PublicKey = Point;

package/src/keys/public_keys.ts

@@ -0,0 +1,194 @@
+import {
+  DEFAULT_IVPK_M_X,
+  DEFAULT_IVPK_M_Y,
+  DEFAULT_NPK_M_X,
+  DEFAULT_NPK_M_Y,
+  DEFAULT_OVPK_M_X,
+  DEFAULT_OVPK_M_Y,
+  DEFAULT_TPK_M_X,
+  DEFAULT_TPK_M_Y,
+  GeneratorIndex,
+} from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr, Point } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, withoutHexPrefix } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import type { PublicKey } from './public_key.js';
+
+export class PublicKeys {
+  public constructor(
+    /** Master nullifier public key */
+    public masterNullifierPublicKey: PublicKey,
+    /** Master incoming viewing public key */
+    public masterIncomingViewingPublicKey: PublicKey,
+    /** Master outgoing viewing public key */
+    public masterOutgoingViewingPublicKey: PublicKey,
+    /** Master tagging viewing public key */
+    public masterTaggingPublicKey: PublicKey,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        masterNullifierPublicKey: schemas.Point,
+        masterIncomingViewingPublicKey: schemas.Point,
+        masterOutgoingViewingPublicKey: schemas.Point,
+        masterTaggingPublicKey: schemas.Point,
+      })
+      .transform(PublicKeys.from);
+  }
+
+  static from(fields: FieldsOf<PublicKeys>) {
+    return new PublicKeys(
+      fields.masterNullifierPublicKey,
+      fields.masterIncomingViewingPublicKey,
+      fields.masterOutgoingViewingPublicKey,
+      fields.masterTaggingPublicKey,
+    );
+  }
+
+  hash() {
+    return this.isEmpty()
+      ? Fr.ZERO
+      : poseidon2HashWithSeparator(
+          [
+            this.masterNullifierPublicKey,
+            this.masterIncomingViewingPublicKey,
+            this.masterOutgoingViewingPublicKey,
+            this.masterTaggingPublicKey,
+          ],
+          GeneratorIndex.PUBLIC_KEYS_HASH,
+        );
+  }
+
+  isEmpty() {
+    return (
+      this.masterNullifierPublicKey.isZero() &&
+      this.masterIncomingViewingPublicKey.isZero() &&
+      this.masterOutgoingViewingPublicKey.isZero() &&
+      this.masterTaggingPublicKey.isZero()
+    );
+  }
+
+  static default(): PublicKeys {
+    return new PublicKeys(
+      new Point(new Fr(DEFAULT_NPK_M_X), new Fr(DEFAULT_NPK_M_Y), false),
+      new Point(new Fr(DEFAULT_IVPK_M_X), new Fr(DEFAULT_IVPK_M_Y), false),
+      new Point(new Fr(DEFAULT_OVPK_M_X), new Fr(DEFAULT_OVPK_M_Y), false),
+      new Point(new Fr(DEFAULT_TPK_M_X), new Fr(DEFAULT_TPK_M_Y), false),
+    );
+  }
+
+  static async random(): Promise<PublicKeys> {
+    return new PublicKeys(await Point.random(), await Point.random(), await Point.random(), await Point.random());
+  }
+
+  /**
+   * Determines if this PublicKeys instance is equal to the given PublicKeys instance.
+   * Equality is based on the content of their respective buffers.
+   *
+   * @param other - The PublicKeys instance to compare against.
+   * @returns True if the buffers of both instances are equal, false otherwise.
+   */
+  equals(other: PublicKeys): boolean {
+    return (
+      this.masterNullifierPublicKey.equals(other.masterNullifierPublicKey) &&
+      this.masterIncomingViewingPublicKey.equals(other.masterIncomingViewingPublicKey) &&
+      this.masterOutgoingViewingPublicKey.equals(other.masterOutgoingViewingPublicKey) &&
+      this.masterTaggingPublicKey.equals(other.masterTaggingPublicKey)
+    );
+  }
+
+  /**
+   * Converts the PublicKeys instance into a Buffer.
+   * This method should be used when encoding the address for storage, transmission or serialization purposes.
+   *
+   * @returns A Buffer representation of the PublicKeys instance.
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer([
+      this.masterNullifierPublicKey,
+      this.masterIncomingViewingPublicKey,
+      this.masterOutgoingViewingPublicKey,
+      this.masterTaggingPublicKey,
+    ]);
+  }
+
+  /**
+   * Creates an PublicKeys instance from a given buffer or BufferReader.
+   * If the input is a Buffer, it wraps it in a BufferReader before processing.
+   * Throws an error if the input length is not equal to the expected size.
+   *
+   * @param buffer - The input buffer or BufferReader containing the address data.
+   * @returns - A new PublicKeys instance with the extracted address data.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): PublicKeys {
+    const reader = BufferReader.asReader(buffer);
+    const masterNullifierPublicKey = reader.readObject(Point);
+    const masterIncomingViewingPublicKey = reader.readObject(Point);
+    const masterOutgoingViewingPublicKey = reader.readObject(Point);
+    const masterTaggingPublicKey = reader.readObject(Point);
+    return new PublicKeys(
+      masterNullifierPublicKey,
+      masterIncomingViewingPublicKey,
+      masterOutgoingViewingPublicKey,
+      masterTaggingPublicKey,
+    );
+  }
+
+  toNoirStruct() {
+    // We need to use lowercase identifiers as those are what the noir interface expects
+    // eslint-disable-next-line camelcase
+    return {
+      // TODO(#6337): Directly dump account.publicKeys here
+      /* eslint-disable camelcase */
+      npk_m: this.masterNullifierPublicKey.toWrappedNoirStruct(),
+      ivpk_m: this.masterIncomingViewingPublicKey.toWrappedNoirStruct(),
+      ovpk_m: this.masterOutgoingViewingPublicKey.toWrappedNoirStruct(),
+      tpk_m: this.masterTaggingPublicKey.toWrappedNoirStruct(),
+      /* eslint-enable camelcase */
+    };
+  }
+
+  /**
+   * Serializes the payload to an array of fields
+   * @returns The fields of the payload
+   */
+  toFields(): Fr[] {
+    return [
+      ...this.masterNullifierPublicKey.toFields(),
+      ...this.masterIncomingViewingPublicKey.toFields(),
+      ...this.masterOutgoingViewingPublicKey.toFields(),
+      ...this.masterTaggingPublicKey.toFields(),
+    ];
+  }
+
+  // TOOD: This is used in foundation/src/abi/encoder. This is probably non-optimal but I did not want
+  // to spend too much time on the encoder now. It probably needs a refactor.
+  encodeToNoir(): Fr[] {
+    return this.toFields();
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): PublicKeys {
+    const reader = FieldReader.asReader(fields);
+    return new PublicKeys(
+      reader.readObject(Point),
+      reader.readObject(Point),
+      reader.readObject(Point),
+      reader.readObject(Point),
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(keys: string) {
+    return PublicKeys.fromBuffer(Buffer.from(withoutHexPrefix(keys), 'hex'));
+  }
+}

package/src/keys/utils.ts

@@ -0,0 +1,9 @@
+import { GeneratorIndex } from '@aztec/constants';
+
+import type { KeyGenerator, KeyPrefix } from './key_types.js';
+
+export function getKeyGenerator(prefix: KeyPrefix): KeyGenerator {
+  // We get enum key by capitalizing key prefix and concatenating it with 'SK_M'
+  const enumKey = `${prefix.toUpperCase()}SK_M`;
+  return GeneratorIndex[enumKey as keyof typeof GeneratorIndex] as KeyGenerator;
+}

package/src/logs/contract_class_log.ts

@@ -0,0 +1,112 @@
+import { CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { inspect } from 'util';
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+export class ContractClassLog {
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * CONTRACT_CLASS_LOG_SIZE_IN_FIELDS;
+
+  // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+  // public fields: Tuple<Fr, typeof CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS>
+  constructor(public contractAddress: AztecAddress, public fields: Fr[]) {
+    if (fields.length !== CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS) {
+      throw new Error(
+        `Invalid number of fields for ContractClassLog. Expected ${CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS}, got ${fields.length}`,
+      );
+    }
+  }
+
+  toFields(): Fr[] {
+    return [this.contractAddress.toField(), ...this.fields];
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+    // return new ContractClassLog(reader.readFieldArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS));
+    return new ContractClassLog(
+      reader.readObject(AztecAddress),
+      Array.from({ length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS }, () => reader.readField()),
+    );
+  }
+
+  isEmpty() {
+    return this.fields.every(f => f.isZero());
+  }
+
+  static empty() {
+    return new ContractClassLog(AztecAddress.ZERO, new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS).fill(Fr.ZERO));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.contractAddress, this.fields]);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+    // reader.readArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, Fr);
+    const address = reader.readObject(AztecAddress);
+    const fields = Array.from({ length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS }, () =>
+      reader.remainingBytes() == 0 ? Fr.ZERO : Fr.fromBuffer(reader),
+    );
+    return new ContractClassLog(address, fields);
+  }
+
+  clone() {
+    return ContractClassLog.fromBuffer(this.toBuffer());
+  }
+
+  static async random() {
+    // NB: Using half the maximum number of fields per log because max fields keeps overfilling blobs in tests.
+    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+    // makeTuple(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, Fr.random);
+    const fields = Array.from({ length: Math.ceil(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2) }, () => Fr.random());
+    return new ContractClassLog(
+      await AztecAddress.random(),
+      fields.concat(Array.from({ length: Math.floor(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2) }, () => Fr.ZERO)),
+    );
+  }
+
+  getEmittedLength() {
+    // This assumes that we cut trailing zeroes from the end of the log. In ts, these will always be added back.
+    // Does not include address and length prefix.
+    return this.getEmittedFields().length;
+  }
+
+  getEmittedFields() {
+    let lastZeroIndex = 0;
+    for (let i = this.fields.length - 1; i >= 0; i--) {
+      if (!this.fields[i].isZero() && lastZeroIndex == 0) {
+        lastZeroIndex = i + 1;
+        break;
+      }
+    }
+    return this.fields.slice(0, lastZeroIndex);
+  }
+
+  async hash() {
+    return await poseidon2Hash(this.getEmittedFields());
+  }
+
+  static get schema() {
+    return z
+      .object({
+        contractAddress: AztecAddress.schema,
+        fields: z.array(schemas.Fr),
+      })
+      .transform(({ contractAddress, fields }) => ContractClassLog.fromFields([contractAddress.toField(), ...fields]));
+  }
+
+  [inspect.custom](): string {
+    return `ContractClassLog {
+      fields: [${this.fields.map((x: Fr) => inspect(x)).join(', ')}],
+    }`;
+  }
+}

package/src/logs/extended_contract_class_log.ts

@@ -0,0 +1,87 @@
+import type { ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import isEqual from 'lodash.isequal';
+import { z } from 'zod';
+
+import { ContractClassLog } from './contract_class_log.js';
+import { LogId } from './log_id.js';
+
+/**
+ * Represents an individual contract class log entry extended with info about the block and tx it was emitted in.
+ */
+export class ExtendedContractClassLog {
+  constructor(
+    /** Globally unique id of the log. */
+    public readonly id: LogId,
+    /** The data contents of the log. */
+    public readonly log: ContractClassLog,
+  ) {}
+
+  static async random() {
+    return new ExtendedContractClassLog(LogId.random(), await ContractClassLog.random());
+  }
+
+  static get schema(): ZodFor<ExtendedContractClassLog> {
+    return z
+      .object({
+        id: LogId.schema,
+        log: ContractClassLog.schema,
+      })
+      .transform(ExtendedContractClassLog.from);
+  }
+
+  static from(fields: FieldsOf<ExtendedContractClassLog>) {
+    return new ExtendedContractClassLog(fields.id, fields.log);
+  }
+
+  /**
+   * Serializes log to a buffer.
+   * @returns A buffer containing the serialized log.
+   */
+  public toBuffer(): Buffer {
+    return Buffer.concat([this.id.toBuffer(), this.log.toBuffer()]);
+  }
+
+  /**
+   * Serializes log to a string.
+   * @returns A string containing the serialized log.
+   */
+  public toString(): string {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Checks if two ExtendedContractClassLog objects are equal.
+   * @param other - Another ExtendedContractClassLog object to compare with.
+   * @returns True if the two objects are equal, false otherwise.
+   */
+  public equals(other: ExtendedContractClassLog): boolean {
+    return isEqual(this, other);
+  }
+
+  /**
+   * Deserializes log from a buffer.
+   * @param buffer - The buffer or buffer reader containing the log.
+   * @returns Deserialized instance of `Log`.
+   */
+  public static fromBuffer(buffer: Buffer | BufferReader): ExtendedContractClassLog {
+    const reader = BufferReader.asReader(buffer);
+
+    const logId = LogId.fromBuffer(reader);
+    const log = ContractClassLog.fromBuffer(reader);
+
+    return new ExtendedContractClassLog(logId, log);
+  }
+
+  /**
+   * Deserializes `ExtendedContractClassLog` object from a hex string representation.
+   * @param data - A hex string representation of the log.
+   * @returns An `ExtendedContractClassLog` object.
+   */
+  public static fromString(data: string): ExtendedContractClassLog {
+    return ExtendedContractClassLog.fromBuffer(hexToBuffer(data));
+  }
+}

package/src/logs/extended_public_log.ts

@@ -0,0 +1,94 @@
+import { BufferReader } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import isEqual from 'lodash.isequal';
+import { z } from 'zod';
+
+import { LogId } from './log_id.js';
+import { PublicLog } from './public_log.js';
+
+/**
+ * Represents an individual public log entry extended with info about the block and tx it was emitted in.
+ */
+export class ExtendedPublicLog {
+  constructor(
+    /** Globally unique id of the log. */
+    public readonly id: LogId,
+    /** The data contents of the log. */
+    public readonly log: PublicLog,
+  ) {}
+
+  static async random() {
+    return new ExtendedPublicLog(LogId.random(), await PublicLog.random());
+  }
+
+  static get schema() {
+    return z
+      .object({
+        id: LogId.schema,
+        log: PublicLog.schema,
+      })
+      .transform(ExtendedPublicLog.from);
+  }
+
+  static from(fields: FieldsOf<ExtendedPublicLog>) {
+    return new ExtendedPublicLog(fields.id, fields.log);
+  }
+
+  /**
+   * Serializes log to a buffer.
+   * @returns A buffer containing the serialized log.
+   */
+  public toBuffer(): Buffer {
+    return Buffer.concat([this.id.toBuffer(), this.log.toBuffer()]);
+  }
+
+  /**
+   * Serializes log to a string.
+   * @returns A string containing the serialized log.
+   */
+  public toString(): string {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Serializes log to a human readable string.
+   * @returns A human readable representation of the log.
+   */
+  public toHumanReadable(): string {
+    return `${this.id.toHumanReadable()}, ${this.log.toHumanReadable()}`;
+  }
+
+  /**
+   * Checks if two ExtendedPublicLog objects are equal.
+   * @param other - Another ExtendedPublicLog object to compare with.
+   * @returns True if the two objects are equal, false otherwise.
+   */
+  public equals(other: ExtendedPublicLog): boolean {
+    return isEqual(this, other);
+  }
+
+  /**
+   * Deserializes log from a buffer.
+   * @param buffer - The buffer or buffer reader containing the log.
+   * @returns Deserialized instance of `Log`.
+   */
+  public static fromBuffer(buffer: Buffer | BufferReader): ExtendedPublicLog {
+    const reader = BufferReader.asReader(buffer);
+
+    const logId = LogId.fromBuffer(reader);
+    const log = PublicLog.fromBuffer(reader);
+
+    return new ExtendedPublicLog(logId, log);
+  }
+
+  /**
+   * Deserializes `ExtendedPublicLog` object from a hex string representation.
+   * @param data - A hex string representation of the log.
+   * @returns An `ExtendedPublicLog` object.
+   */
+  public static fromString(data: string): ExtendedPublicLog {
+    return ExtendedPublicLog.fromBuffer(hexToBuffer(data));
+  }
+}

package/src/logs/index.ts

@@ -0,0 +1,11 @@
+export * from './log_with_tx_data.js';
+export * from './indexed_tagging_secret.js';
+export * from './contract_class_log.js';
+export * from './public_log.js';
+export * from './private_log.js';
+export * from './log_id.js';
+export * from './log_filter.js';
+export * from './extended_public_log.js';
+export * from './extended_contract_class_log.js';
+export * from './l1_payload/index.js';
+export * from './tx_scoped_l2_log.js';

package/src/logs/indexed_tagging_secret.ts

@@ -0,0 +1,45 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+
+export class IndexedTaggingSecret {
+  constructor(public appTaggingSecret: Fr, public index: number) {
+    if (index < 0) {
+      throw new Error('IndexedTaggingSecret index out of bounds');
+    }
+  }
+
+  toFields(): Fr[] {
+    return [this.appTaggingSecret, new Fr(this.index)];
+  }
+
+  static fromFields(serialized: Fr[]) {
+    return new this(serialized[0], serialized[1].toNumber());
+  }
+
+  /**
+   * Computes the tag based on the app tagging secret, recipient and index.
+   * @dev By including the recipient we achieve "directionality" of the tag (when sending a note in the other
+   * direction, the tag will be different).
+   * @param recipient The recipient of the note
+   * @returns The tag.
+   */
+  computeTag(recipient: AztecAddress) {
+    return poseidon2Hash([this.appTaggingSecret, recipient, this.index]);
+  }
+
+  /**
+   * Computes the siloed tag.
+   * @dev We do this second layer of siloing (one was already done as the tagging secret is app-siloed) because kernels
+   * do that to protect against contract impersonation attacks. This extra layer of siloing in kernels ensures that
+   * a malicious contract cannot emit a note with a tag corresponding to another contract.
+   * @param recipient The recipient of the note
+   * @param app The app address
+   * @returns The siloed tag.
+   */
+  async computeSiloedTag(recipient: AztecAddress, app: AztecAddress) {
+    const tag = await this.computeTag(recipient);
+    return poseidon2Hash([app, tag]);
+  }
+}