@aztec/stdlib 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/src/logs/message_context.ts

@@ -1,62 +0,0 @@
-import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/curves/bn254';
-
-import type { AztecAddress } from '../aztec-address/index.js';
-import type { TxEffect } from '../tx/tx_effect.js';
-import type { TxHash } from '../tx/tx_hash.js';
-
-/**
- * Additional information needed to process a message.
- *
- * All messages exist in the context of a transaction, and information about that transaction is typically required
- * in order to perform validation, store results, etc. For example, messages containing notes require knowledge of note
- * hashes and the first nullifier in order to find the note's nonce.
- *
- * A TS version of `message_context.nr`.
- */
-export class MessageContext {
-  constructor(
-    public txHash: TxHash,
-    public uniqueNoteHashesInTx: Fr[],
-    public firstNullifierInTx: Fr,
-    public recipient: AztecAddress,
-  ) {}
-
-  toFields(): Fr[] {
-    return [
-      this.txHash.hash,
-      ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
-      this.firstNullifierInTx,
-      this.recipient.toField(),
-    ];
-  }
-
-  toNoirStruct() {
-    /* eslint-disable camelcase */
-    return {
-      tx_hash: this.txHash.hash,
-      unique_note_hashes_in_tx: this.uniqueNoteHashesInTx,
-      first_nullifier_in_tx: this.firstNullifierInTx,
-      recipient: this.recipient,
-    };
-    /* eslint-enable camelcase */
-  }
-
-  static fromTxEffectAndRecipient(txEffect: TxEffect, recipient: AztecAddress): MessageContext {
-    return new MessageContext(txEffect.txHash, txEffect.noteHashes, txEffect.nullifiers[0], recipient);
-  }
-}
-
-/**
- * Helper function to serialize a bounded vector according to Noir's BoundedVec format
- * @param values - The values to serialize
- * @param maxLength - The maximum length of the bounded vector
- * @returns The serialized bounded vector as Fr[]
- * @dev Copied over from pending_tagged_log.ts.
- */
-function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
-  const lengthDiff = maxLength - values.length;
-  const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
-  const storage = values.concat(zeroPaddingArray);
-  return [...storage, new Fr(values.length)];
-}

package/src/logs/pending_tagged_log.ts

@@ -1,41 +0,0 @@
-import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/curves/bn254';
-
-import type { AztecAddress } from '../aztec-address/index.js';
-import type { TxHash } from '../tx/tx_hash.js';
-import { MessageContext } from './message_context.js';
-
-/**
- * Represents a pending tagged log as it is stored in the pending tagged log array to which the fetchTaggedLogs oracle
- * inserts found private logs. A TS version of `pending_tagged_log.nr`.
- */
-export class PendingTaggedLog {
-  private context: MessageContext;
-
-  constructor(
-    public log: Fr[],
-    txHash: TxHash,
-    uniqueNoteHashesInTx: Fr[],
-    firstNullifierInTx: Fr,
-    recipient: AztecAddress,
-  ) {
-    this.context = new MessageContext(txHash, uniqueNoteHashesInTx, firstNullifierInTx, recipient);
-  }
-
-  toFields(): Fr[] {
-    return [...serializeBoundedVec(this.log, PRIVATE_LOG_SIZE_IN_FIELDS), ...this.context.toFields()];
-  }
-}
-
-/**
- * Helper function to serialize a bounded vector according to Noir's BoundedVec format
- * @param values - The values to serialize
- * @param maxLength - The maximum length of the bounded vector
- * @returns The serialized bounded vector as Fr[]
- */
-function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
-  const lengthDiff = maxLength - values.length;
-  const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
-  const storage = values.concat(zeroPaddingArray);
-  return [...storage, new Fr(values.length)];
-}

package/src/logs/tx_scoped_l2_log.ts

@@ -1,98 +0,0 @@
-import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
-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);
-  }
-
-  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/note/notes_filter.ts

@@ -1,38 +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 { NoteStatus } from './note_status.js';
-
-/**
- * A filter used to fetch notes.
- * @remarks This filter is applied as an intersection of all its params.
- */
-export type NotesFilter = {
-  /**
-   * 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 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'. */
-  status?: NoteStatus;
-  /** The siloed nullifier for the note. */
-  siloedNullifier?: Fr;
-  /** The scopes in which to get notes from. This defaults to all scopes. */
-  scopes?: AztecAddress[];
-};
-
-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(),
-  scopes: z.array(schemas.AztecAddress).optional(),
-});

package/src/slashing/empire.ts

@@ -1,103 +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: {
-      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}`);
-    }
-  }
-}

package/src/update-checker/update-checker.ts

@@ -1,166 +0,0 @@
-import { RegistryContract } from '@aztec/ethereum/contracts';
-import type { ViemClient } from '@aztec/ethereum/types';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
-import { fileURLToPath } from '@aztec/foundation/url';
-
-import { EventEmitter } from 'events';
-import { readFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { isDeepStrictEqual } from 'util';
-import { z } from 'zod';
-
-const updateConfigSchema = z.object({
-  version: z.string().optional(),
-  publicTelemetry: z.any().optional(),
-  config: z.any().optional(),
-});
-
-export type EventMap = {
-  newRollupVersion: [{ currentVersion: bigint; latestVersion: bigint }];
-  newNodeVersion: [{ currentVersion: string; latestVersion: string }];
-  updateNodeConfig: [object];
-  updatePublicTelemetryConfig: [object];
-};
-
-type Config = {
-  baseURL: URL;
-  nodeVersion?: string;
-  checkIntervalMs?: number;
-  registryContractAddress: EthAddress;
-  publicClient: ViemClient;
-  fetch?: typeof fetch;
-};
-
-export class UpdateChecker extends EventEmitter<EventMap> {
-  private runningPromise: RunningPromise;
-  private lastPatchedConfig: object = {};
-  private lastPatchedPublicTelemetryConfig: object = {};
-
-  constructor(
-    private updatesUrl: URL,
-    private nodeVersion: string | undefined,
-    private rollupVersion: bigint,
-    private fetch: typeof globalThis.fetch,
-    private getLatestRollupVersion: () => Promise<bigint>,
-    private checkIntervalMs = 10 * 60_000, // every 10 mins
-    private log = createLogger('foundation:update-check'),
-  ) {
-    super();
-    this.runningPromise = new RunningPromise(this.runChecks, this.log, this.checkIntervalMs);
-  }
-
-  public static async new(config: Config): Promise<UpdateChecker> {
-    const registryContract = new RegistryContract(config.publicClient, config.registryContractAddress);
-    const getLatestRollupVersion = () => registryContract.getRollupVersions().then(versions => versions.at(-1)!);
-
-    return new UpdateChecker(
-      config.baseURL,
-      config.nodeVersion ?? getPackageVersion(),
-      await getLatestRollupVersion(),
-      config.fetch ?? fetch,
-      getLatestRollupVersion,
-      config.checkIntervalMs,
-    );
-  }
-
-  public start(): void {
-    if (this.runningPromise.isRunning()) {
-      this.log.debug(`Can't start update checker again`);
-      return;
-    }
-
-    this.log.info('Starting update checker', {
-      nodeVersion: this.nodeVersion,
-      rollupVersion: this.rollupVersion,
-    });
-    this.runningPromise.start();
-  }
-
-  public stop(): Promise<void> {
-    if (!this.runningPromise.isRunning()) {
-      this.log.debug(`Can't stop update checker because it is not running`);
-      return Promise.resolve();
-    }
-    return this.runningPromise.stop();
-  }
-
-  public trigger(): Promise<void> {
-    return this.runningPromise.trigger();
-  }
-
-  private runChecks = async (): Promise<void> => {
-    await Promise.all([this.checkRollupVersion(), this.checkConfig()]);
-  };
-
-  private async checkRollupVersion(): Promise<void> {
-    try {
-      const canonicalRollupVersion = await this.getLatestRollupVersion();
-      if (canonicalRollupVersion !== this.rollupVersion) {
-        this.log.debug('New canonical rollup version', {
-          currentVersion: this.rollupVersion,
-          latestVersion: canonicalRollupVersion,
-        });
-        this.emit('newRollupVersion', { currentVersion: this.rollupVersion, latestVersion: canonicalRollupVersion });
-      }
-    } catch (err) {
-      this.log.warn(`Failed to check if there is a new rollup`, err);
-    }
-  }
-
-  private async checkConfig(): Promise<void> {
-    try {
-      const response = await this.fetch(this.updatesUrl);
-      const body = await response.json();
-      if (!response.ok) {
-        this.log.warn(`Unexpected HTTP response checking for updates`, {
-          status: response.status,
-          body: await response.text(),
-          url: this.updatesUrl,
-        });
-      }
-
-      const { version, config, publicTelemetry } = updateConfigSchema.parse(body);
-
-      if (this.nodeVersion && version && version !== this.nodeVersion) {
-        this.log.debug('New node version', { currentVersion: this.nodeVersion, latestVersion: version });
-        this.emit('newNodeVersion', { currentVersion: this.nodeVersion, latestVersion: version });
-      }
-
-      if (config && Object.keys(config).length > 0 && !isDeepStrictEqual(config, this.lastPatchedConfig)) {
-        this.log.debug('New node config', { config });
-        this.lastPatchedConfig = config;
-        this.emit('updateNodeConfig', config);
-      }
-
-      if (
-        publicTelemetry &&
-        Object.keys(publicTelemetry).length > 0 &&
-        !isDeepStrictEqual(publicTelemetry, this.lastPatchedPublicTelemetryConfig)
-      ) {
-        this.log.debug('New metrics config', { config });
-        this.lastPatchedPublicTelemetryConfig = publicTelemetry;
-        this.emit('updatePublicTelemetryConfig', publicTelemetry);
-      }
-    } catch (err) {
-      this.log.warn(`Failed to check if there is an update`, err);
-    }
-  }
-}
-
-/**
- * Returns package version.
- */
-export function getPackageVersion(): string | undefined {
-  try {
-    const releasePleaseManifestPath = resolve(
-      dirname(fileURLToPath(import.meta.url)),
-      '../../../../.release-please-manifest.json',
-    );
-    const version = JSON.parse(readFileSync(releasePleaseManifestPath).toString())['.'];
-    return version;
-  } catch {
-    return undefined;
-  }
-}