@aztec/stdlib 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/logs/extended_directional_app_tagging_secret.ts

@@ -1,87 +0,0 @@
-import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
-import { type Fq, Fr } from '@aztec/foundation/curves/bn254';
-import type { Point } from '@aztec/foundation/curves/grumpkin';
-
-import { z } from 'zod';
-
-import { AztecAddress } from '../aztec-address/index.js';
-import type { CompleteAddress } from '../contract/complete_address.js';
-import { computeAddressSecret, computePreaddress } from '../keys/derivation.js';
-
-/**
- * Extended directional application tagging secret used for log tagging.
- *
- * "Extended" because it bundles the directional app tagging secret with the app (contract) address. This bundling was
- * done because where this type is used we commonly need access to both the secret and the address.
- *
- * "Directional" because the derived secret is bound to the recipient address: A→B differs from B→A even with the same
- * participants and app.
- *
- * Note: It's a bit unfortunate that this type resides in `stdlib` as the rest of the tagging functionality resides in
- * `pxe/src/tagging`. We need to use this type in `PreTag` that in turn is used by other types in stdlib hence there
- * doesn't seem to be a good way around this.
- */
-export class ExtendedDirectionalAppTaggingSecret {
-  private constructor(
-    public readonly secret: Fr,
-    public readonly app: AztecAddress,
-  ) {}
-
-  /**
-   * Derives shared tagging secret and from that, the app address and recipient derives the directional app tagging
-   * secret.
-   *
-   * @param localAddress - The complete address of entity A in the shared tagging secret derivation scheme
-   * @param localIvsk - The incoming viewing secret key of entity A
-   * @param externalAddress - The address of entity B in the shared tagging secret derivation scheme
-   * @param app - Contract address to silo the secret to
-   * @param recipient - Recipient of the log. Defines the "direction of the secret".
-   * @returns The secret that can be used along with an index to compute a tag to be included in a log.
-   */
-  static async compute(
-    localAddress: CompleteAddress,
-    localIvsk: Fq,
-    externalAddress: AztecAddress,
-    app: AztecAddress,
-    recipient: AztecAddress,
-  ): Promise<ExtendedDirectionalAppTaggingSecret> {
-    const taggingSecretPoint = await computeSharedTaggingSecret(localAddress, localIvsk, externalAddress);
-    const appTaggingSecret = await poseidon2Hash([taggingSecretPoint.x, taggingSecretPoint.y, app]);
-    const directionalAppTaggingSecret = await poseidon2Hash([appTaggingSecret, recipient]);
-
-    return new ExtendedDirectionalAppTaggingSecret(directionalAppTaggingSecret, app);
-  }
-
-  toString(): string {
-    return `${this.secret.toString()}:${this.app.toString()}`;
-  }
-
-  static fromString(str: string): ExtendedDirectionalAppTaggingSecret {
-    const [secretStr, appStr] = str.split(':');
-    return new ExtendedDirectionalAppTaggingSecret(Fr.fromString(secretStr), AztecAddress.fromString(appStr));
-  }
-}
-
-// Returns shared tagging secret computed with Diffie-Hellman key exchange.
-async function computeSharedTaggingSecret(
-  localAddress: CompleteAddress,
-  localIvsk: Fq,
-  externalAddress: AztecAddress,
-): Promise<Point> {
-  const knownPreaddress = await computePreaddress(await localAddress.publicKeys.hash(), localAddress.partialAddress);
-  // TODO: #8970 - Computation of address point from x coordinate might fail
-  const externalAddressPoint = await externalAddress.toAddressPoint();
-  // Given A (local complete address) -> B (external address) and h == preaddress
-  // Compute shared secret as S = (h_A + local_ivsk_A) * Addr_Point_B
-
-  // Beware! h_a + local_ivsk_a (also known as the address secret) can lead to an address point with a negative
-  // y-coordinate, since there's two possible candidates computeAddressSecret takes care of selecting the one that
-  // leads to a positive y-coordinate, which is the only valid address point
-  return Grumpkin.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, localIvsk));
-}
-
-export const ExtendedDirectionalAppTaggingSecretSchema = z.object({
-  secret: Fr.schema,
-  app: AztecAddress.schema,
-});

package/src/logs/extended_public_log.ts

@@ -1,94 +0,0 @@
-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/log_filter.ts

@@ -1,36 +0,0 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
-
-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 { LogId } from './log_id.js';
-
-/**
- * Log filter used to fetch L2 logs.
- * @remarks This filter is applied as an intersection of all it's params.
- */
-export type LogFilter = {
-  /** Hash of a transaction from which to fetch the logs. */
-  txHash?: TxHash;
-  /** The block number from which to start fetching logs (inclusive). */
-  fromBlock?: number;
-  /** The block number until which to fetch logs (not inclusive). */
-  toBlock?: number;
-  /** Log id after which to start fetching logs. */
-  afterLog?: LogId;
-  /** The contract address to filter logs by. */
-  contractAddress?: AztecAddress;
-  /** The tag (first field of the log) to filter logs by. */
-  tag?: Fr;
-};
-
-export const LogFilterSchema: ZodFor<LogFilter> = z.object({
-  txHash: TxHash.schema.optional(),
-  fromBlock: schemas.Integer.optional(),
-  toBlock: schemas.Integer.optional(),
-  afterLog: LogId.schema.optional(),
-  contractAddress: schemas.AztecAddress.optional(),
-  tag: schemas.Fr.optional(),
-});

package/src/logs/log_id.ts

@@ -1,125 +0,0 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader } from '@aztec/foundation/serialize';
-
-import { z } from 'zod';
-
-import { BlockHash } from '../block/block_hash.js';
-import { schemas } from '../schemas/index.js';
-import { TxHash } from '../tx/tx_hash.js';
-
-/** A globally unique log id. */
-export class LogId {
-  constructor(
-    /** The block number the log was emitted in. */
-    public readonly blockNumber: BlockNumber,
-    /** The hash of the block the log was emitted in. */
-    public readonly blockHash: BlockHash,
-    /** The hash of the transaction the log was emitted in. */
-    public readonly txHash: TxHash,
-    /** 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. */
-    public readonly logIndex: number,
-  ) {
-    if (!Number.isInteger(blockNumber) || blockNumber < INITIAL_L2_BLOCK_NUM) {
-      throw new Error(`Invalid block number: ${blockNumber}`);
-    }
-    if (!Number.isInteger(txIndex)) {
-      throw new Error(`Invalid tx index: ${txIndex}`);
-    }
-    if (!Number.isInteger(logIndex)) {
-      throw new Error(`Invalid log index: ${logIndex}`);
-    }
-  }
-
-  static random() {
-    return new LogId(
-      BlockNumber(Math.floor(Math.random() * 1000) + 1),
-      BlockHash.random(),
-      TxHash.random(),
-      Math.floor(Math.random() * 1000),
-      Math.floor(Math.random() * 100),
-    );
-  }
-
-  static get schema() {
-    return z
-      .object({
-        blockNumber: BlockNumberSchema,
-        blockHash: BlockHash.schema,
-        txHash: TxHash.schema,
-        txIndex: schemas.Integer,
-        logIndex: schemas.Integer,
-      })
-      .transform(
-        ({ blockNumber, blockHash, txHash, txIndex, logIndex }) =>
-          new LogId(blockNumber, blockHash, txHash, txIndex, logIndex),
-      );
-  }
-
-  /**
-   * Serializes log id to a buffer.
-   * @returns A buffer containing the serialized log id.
-   */
-  public toBuffer(): Buffer {
-    return Buffer.concat([
-      toBufferBE(BigInt(this.blockNumber), 4),
-      this.blockHash.toBuffer(),
-      this.txHash.toBuffer(),
-      toBufferBE(BigInt(this.txIndex), 4),
-      toBufferBE(BigInt(this.logIndex), 4),
-    ]);
-  }
-
-  /**
-   * Creates a LogId from a buffer.
-   * @param buffer - A buffer containing the serialized log id.
-   * @returns A log id.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader): LogId {
-    const reader = BufferReader.asReader(buffer);
-
-    const blockNumber = BlockNumber(reader.readNumber());
-    const blockHash = new BlockHash(reader.readObject(Fr));
-    const txHash = reader.readObject(TxHash);
-    const txIndex = reader.readNumber();
-    const logIndex = reader.readNumber();
-
-    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
-  }
-
-  /**
-   * Converts the LogId instance to a string.
-   * @returns A string representation of the log id.
-   */
-  public toString(): string {
-    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}-${this.blockHash.toString()}-${this.txHash.toString()}`;
-  }
-
-  /**
-   * Creates a LogId from a string.
-   * @param data - A string representation of a log id.
-   * @returns A log id.
-   */
-  static fromString(data: string): LogId {
-    const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash, rawTxHash] = data.split('-');
-    const blockNumber = BlockNumber(Number(rawBlockNumber));
-    const blockHash = BlockHash.fromString(rawBlockHash);
-    const txHash = TxHash.fromString(rawTxHash);
-    const txIndex = Number(rawTxIndex);
-    const logIndex = Number(rawLogIndex);
-
-    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
-  }
-
-  /**
-   * Serializes log id to a human readable string.
-   * @returns A human readable representation of the log id.
-   */
-  public toHumanReadable(): string {
-    return `logId: (blockNumber: ${this.blockNumber}, blockHash: ${this.blockHash.toString()}, txHash: ${this.txHash.toString()}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
-  }
-}

package/src/logs/tx_scoped_l2_log.ts

@@ -1,114 +0,0 @@
-import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
-import { times } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { schemas as foundationSchemas } from '@aztec/foundation/schemas';
-import {
-  BufferReader,
-  bigintToUInt64BE,
-  numToUInt32BE,
-  serializeArrayOfBufferableToVector,
-} from '@aztec/foundation/serialize';
-
-import { z } from 'zod';
-
-import { schemas } from '../schemas/schemas.js';
-import { TxHash } from '../tx/tx_hash.js';
-import type { UInt64 } from '../types/shared.js';
-
-export class TxScopedL2Log {
-  constructor(
-    /*
-     * Hash of the tx where the log is included
-     */
-    public txHash: TxHash,
-    /*
-     * The block this log is included in
-     */
-    public blockNumber: BlockNumber,
-    /*
-     * The timestamp of the block this log is included in
-     */
-    public blockTimestamp: UInt64,
-    /*
-     * The log data as an array of field elements
-     */
-    public logData: Fr[],
-    /*
-     * The note hashes from the tx effect
-     */
-    public noteHashes: Fr[],
-    /*
-     * The first nullifier from the tx effect. Used for nonce discovery when processing notes from logs.
-     *
-     * (Note nonces are computed as `hash(firstNullifier, noteIndexInTx)`.)
-     */
-    public firstNullifier: Fr,
-  ) {}
-
-  static get schema() {
-    return z
-      .object({
-        txHash: TxHash.schema,
-        blockNumber: BlockNumberSchema,
-        blockTimestamp: schemas.UInt64,
-        logData: z.array(foundationSchemas.Fr),
-        noteHashes: z.array(foundationSchemas.Fr),
-        firstNullifier: foundationSchemas.Fr,
-      })
-      .transform(
-        ({ txHash, blockNumber, blockTimestamp, logData, noteHashes, firstNullifier }) =>
-          new TxScopedL2Log(txHash, blockNumber, blockTimestamp, logData, noteHashes, firstNullifier),
-      );
-  }
-
-  toBuffer() {
-    return Buffer.concat([
-      this.txHash.toBuffer(),
-      numToUInt32BE(this.blockNumber),
-      bigintToUInt64BE(this.blockTimestamp),
-      serializeArrayOfBufferableToVector(this.logData),
-      serializeArrayOfBufferableToVector(this.noteHashes),
-      this.firstNullifier.toBuffer(),
-    ]);
-  }
-
-  static fromBuffer(buffer: Buffer) {
-    const reader = BufferReader.asReader(buffer);
-    const txHash = reader.readObject(TxHash);
-    const blockNumber = BlockNumber(reader.readNumber());
-    const blockTimestamp = reader.readUInt64();
-    const logData = reader.readVector(Fr);
-    const noteHashes = reader.readVector(Fr);
-    const firstNullifier = reader.readObject(Fr);
-
-    return new TxScopedL2Log(txHash, blockNumber, blockTimestamp, logData, noteHashes, firstNullifier);
-  }
-
-  static getBlockNumberFromBuffer(buffer: Buffer) {
-    return BlockNumber(buffer.readUint32BE(Fr.SIZE_IN_BYTES));
-  }
-
-  static random() {
-    return new TxScopedL2Log(
-      TxHash.fromField(Fr.random()),
-      BlockNumber(Math.floor(Math.random() * 100000) + 1),
-      BigInt(Math.floor(Date.now() / 1000)),
-      times(3, Fr.random),
-      times(3, Fr.random),
-      Fr.random(),
-    );
-  }
-
-  equals(other: TxScopedL2Log) {
-    return (
-      this.txHash.equals(other.txHash) &&
-      this.blockNumber === other.blockNumber &&
-      this.blockTimestamp === other.blockTimestamp &&
-      this.logData.length === other.logData.length &&
-      this.logData.every((f, i) => f.equals(other.logData[i])) &&
-      this.noteHashes.length === other.noteHashes.length &&
-      this.noteHashes.every((h, i) => h.equals(other.noteHashes[i])) &&
-      this.firstNullifier.equals(other.firstNullifier)
-    );
-  }
-}

package/src/slashing/empire.ts

@@ -1,104 +0,0 @@
-import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
-
-import { getRoundForSlot, getRoundsForEpoch } from './helpers.js';
-import type { Offense, OffenseIdentifier, SlashPayload, SlashPayloadRound, ValidatorSlash } from './types.js';
-import { OffenseType } from './types.js';
-
-/**
- * Returns true if the offense is uncontroversial as in it can be verified via L1 data alone,
- * and does not depend on the local view of the node of the L2 p2p network.
- * @param offense - The offense type to check
- */
-export function isOffenseUncontroversial(offense: OffenseType): boolean {
-  return (
-    offense === OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS ||
-    offense === OffenseType.PROPOSED_INCORRECT_ATTESTATIONS ||
-    offense === OffenseType.ATTESTED_DESCENDANT_OF_INVALID
-  );
-}
-
-/** Extracts offense identifiers (validator, epoch, offense type) from an Empire-based SlashPayload */
-export function getOffenseIdentifiersFromPayload(payload: SlashPayload | SlashPayloadRound): OffenseIdentifier[] {
-  return payload.slashes.flatMap((slash: ValidatorSlash) =>
-    slash.offenses.map(o => ({
-      validator: slash.validator,
-      offenseType: o.offenseType,
-      epochOrSlot: o.epochOrSlot,
-    })),
-  );
-}
-
-/** Creates ValidatorSlashes used to create an Empire-based SlashPayload from a set of Offenses */
-export function offensesToValidatorSlash(offenses: Offense[]): ValidatorSlash[] {
-  return offenses.map(offense => ({
-    validator: offense.validator,
-    amount: offense.amount,
-    offenses: [{ epochOrSlot: offense.epochOrSlot, offenseType: offense.offenseType }],
-  }));
-}
-
-/**
- * Sorts offense data by:
- * - Uncontroversial offenses first
- * - Slash amount (descending)
- * - Epoch or slot (ascending, ie oldest first)
- * - Validator address (ascending)
- * - Offense type (descending)
- */
-export function offenseDataComparator(a: Offense, b: Offense): number {
-  return (
-    Number(isOffenseUncontroversial(b.offenseType)) - Number(isOffenseUncontroversial(a.offenseType)) ||
-    Number(b.amount - a.amount) ||
-    Number(a.epochOrSlot - b.epochOrSlot) ||
-    a.validator.toString().localeCompare(b.validator.toString()) ||
-    Number(b.offenseType) - Number(a.offenseType)
-  );
-}
-
-/**
- * Returns the first round in which the offense is eligible for being included in an Empire-based slash payload.
- * Should be equal to to the first round that starts strictly after the offense becomes detectable.
- */
-export function getFirstEligibleRoundForOffense(
-  offense: OffenseIdentifier,
-  constants: { slashingRoundSize: number; epochDuration: number; proofSubmissionEpochs: number },
-): bigint {
-  // TODO(palla/slash): Check for off-by-ones
-  switch (offense.offenseType) {
-    // Inactivity is detected at the end of the epoch, so we flag it as detected in the first fresh round for the next epoch
-    case OffenseType.INACTIVITY: {
-      const epoch = offense.epochOrSlot;
-      const detectedEpoch = EpochNumber.fromBigInt(epoch + 1n);
-      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
-    }
-    // These offenses are detected once an epoch is pruned, which happens after the proof submission window
-    case OffenseType.VALID_EPOCH_PRUNED:
-    case OffenseType.DATA_WITHHOLDING: {
-      // TODO(palla/slash): Check for off-by-ones especially here
-      const epoch = offense.epochOrSlot;
-      const detectedEpoch = EpochNumber.fromBigInt(epoch + BigInt(constants.proofSubmissionEpochs));
-      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
-    }
-    // These offenses are detected immediately in the slot they occur, so we assume they are detected in the first round for the following slot
-    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
-    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
-    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
-    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
-    case OffenseType.DUPLICATE_PROPOSAL:
-    case OffenseType.DUPLICATE_ATTESTATION: {
-      const slot = offense.epochOrSlot;
-      const detectedSlot = SlotNumber.fromBigInt(slot + 1n);
-      return getRoundForSlot(detectedSlot, constants).round + 1n;
-    }
-    // Assume these are epoch-based offenses, even though we should never have to process these
-    case OffenseType.UNKNOWN: {
-      const epoch = offense.epochOrSlot;
-      const detectedEpoch = EpochNumber.fromBigInt(epoch + 1n);
-      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
-    }
-    default: {
-      const _: never = offense.offenseType;
-      throw new Error(`Unknown offense type: ${offense.offenseType}`);
-    }
-  }
-}