@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.b9865e97

package/src/logs/tx_scoped_l2_log.ts

@@ -1,95 +0,0 @@
-import { BufferReader, boolToBuffer, numToUInt32BE } from '@aztec/foundation/serialize';
-
-import { z } from 'zod';
-
-import { TxHash } from '../tx/tx_hash.js';
-import { PrivateLog } from './private_log.js';
-import { PublicLog } from './public_log.js';
-
-// TODO(#14460): Split to private and public versions instead of having this weird mix.
-export class TxScopedL2Log {
-  constructor(
-    /*
-     * Hash of the tx where the log is included
-     */
-    public txHash: TxHash,
-    /*
-     * The next available leaf index for the note hash tree for this transaction. It is stored
-     * with the log so the noteHashIndex can be reconstructed after decryption.
-     */
-    public dataStartIndexForTx: number,
-    /*
-     * The index of the log in the transaction. Note that public and private logs are in separate arrays in the tx
-     * effect and for this reason these indices are independent (a private and public log can have the same index).
-     */
-    public logIndexInTx: number,
-    /*
-     * The block this log is included in
-     */
-    public blockNumber: number,
-    /*
-     * The log data as either a PrivateLog or PublicLog
-     */
-    public log: PrivateLog | PublicLog,
-  ) {}
-
-  get isFromPublic() {
-    return this.log instanceof PublicLog;
-  }
-
-  static get schema() {
-    return z
-      .object({
-        txHash: TxHash.schema,
-        dataStartIndexForTx: z.number(),
-        logIndexInTx: z.number(),
-        blockNumber: z.number(),
-        log: z.union([PrivateLog.schema, PublicLog.schema]),
-      })
-      .transform(
-        ({ txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log }) =>
-          new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log),
-      );
-  }
-
-  toBuffer() {
-    const isFromPublic = this.log instanceof PublicLog;
-    return Buffer.concat([
-      this.txHash.toBuffer(),
-      numToUInt32BE(this.dataStartIndexForTx),
-      numToUInt32BE(this.logIndexInTx),
-      numToUInt32BE(this.blockNumber),
-      boolToBuffer(isFromPublic),
-      this.log.toBuffer(),
-    ]);
-  }
-
-  static fromBuffer(buffer: Buffer) {
-    const reader = BufferReader.asReader(buffer);
-    const txHash = reader.readObject(TxHash);
-    const dataStartIndexForTx = reader.readNumber();
-    const logIndexInTx = reader.readNumber();
-    const blockNumber = reader.readNumber();
-    const isFromPublic = reader.readBoolean();
-    const log = isFromPublic ? PublicLog.fromBuffer(reader) : PrivateLog.fromBuffer(reader);
-
-    return new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log);
-  }
-
-  static async random(isFromPublic = Math.random() < 0.5) {
-    const log = isFromPublic ? await PublicLog.random() : PrivateLog.random();
-    return new TxScopedL2Log(TxHash.random(), 1, 1, 1, log);
-  }
-
-  equals(other: TxScopedL2Log) {
-    return (
-      this.txHash.equals(other.txHash) &&
-      this.dataStartIndexForTx === other.dataStartIndexForTx &&
-      this.logIndexInTx === other.logIndexInTx &&
-      this.blockNumber === other.blockNumber &&
-      ((this.log instanceof PublicLog && other.log instanceof PublicLog) ||
-        (this.log instanceof PrivateLog && other.log instanceof PrivateLog)) &&
-      this.log.equals(other.log as any)
-    );
-  }
-}

package/src/note/notes_filter.ts

@@ -1,35 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-
-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 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,
-  storageSlot: schemas.Fr.optional(),
-  status: z.nativeEnum(NoteStatus).optional(),
-  siloedNullifier: schemas.Fr.optional(),
-  scopes: z.array(schemas.AztecAddress).optional(),
-});

package/src/note/unique_note.ts

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

@@ -1,135 +0,0 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Signature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import { z } from 'zod';
-
-import type { ZodFor } from '../schemas/index.js';
-import { ConsensusPayload } from './consensus_payload.js';
-import { Gossipable } from './gossipable.js';
-import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from './signature_utils.js';
-import { TopicType } from './topic_type.js';
-
-export class BlockAttestationHash extends Buffer32 {
-  constructor(hash: Buffer) {
-    super(hash);
-  }
-}
-
-/**
- * BlockAttestation
- *
- * A validator that has attested to seeing the contents of a block
- * will produce a block attestation over the header of the block
- */
-export class BlockAttestation extends Gossipable {
-  static override p2pTopic = TopicType.block_attestation;
-
-  private sender: EthAddress | undefined;
-  private proposer: EthAddress | undefined;
-
-  constructor(
-    /** The payload of the message, and what the signature is over */
-    public readonly payload: ConsensusPayload,
-
-    /** The signature of the block attester */
-    public readonly signature: Signature,
-
-    /** The signature from the block proposer */
-    public readonly proposerSignature: Signature,
-  ) {
-    super();
-  }
-
-  static get schema(): ZodFor<BlockAttestation> {
-    return z
-      .object({
-        payload: ConsensusPayload.schema,
-        signature: Signature.schema,
-        proposerSignature: Signature.schema,
-      })
-      .transform(obj => new BlockAttestation(obj.payload, obj.signature, obj.proposerSignature));
-  }
-
-  override generateP2PMessageIdentifier(): Promise<Buffer32> {
-    return Promise.resolve(new BlockAttestationHash(keccak256(this.signature.toBuffer())));
-  }
-
-  get archive(): Fr {
-    return this.payload.archive;
-  }
-
-  get slotNumber(): Fr {
-    return this.payload.header.slotNumber;
-  }
-
-  /**
-   * Lazily evaluate and cache the signer of the attestation
-   * @returns The signer of the attestation, or undefined if signature recovery fails
-   */
-  getSender(): EthAddress | undefined {
-    if (!this.sender) {
-      // Recover the sender from the attestation
-      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockAttestation);
-      // Cache the sender for later use
-      this.sender = tryRecoverAddress(hashed, this.signature);
-    }
-
-    return this.sender;
-  }
-
-  /**
-   * Lazily evaluate and cache the proposer of the block
-   * @returns The proposer of the block
-   */
-  getProposer(): EthAddress | undefined {
-    if (!this.proposer) {
-      // Recover the proposer from the proposal signature
-      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
-      // Cache the proposer for later use
-      this.proposer = tryRecoverAddress(hashed, this.proposerSignature);
-    }
-
-    return this.proposer;
-  }
-
-  getPayload(): Buffer {
-    return this.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation);
-  }
-
-  toBuffer(): Buffer {
-    return serializeToBuffer([this.payload, this.signature, this.proposerSignature]);
-  }
-
-  static fromBuffer(buf: Buffer | BufferReader): BlockAttestation {
-    const reader = BufferReader.asReader(buf);
-    return new BlockAttestation(
-      reader.readObject(ConsensusPayload),
-      reader.readObject(Signature),
-      reader.readObject(Signature),
-    );
-  }
-
-  static empty(): BlockAttestation {
-    return new BlockAttestation(ConsensusPayload.empty(), Signature.empty(), Signature.empty());
-  }
-
-  static random(): BlockAttestation {
-    return new BlockAttestation(ConsensusPayload.random(), Signature.random(), Signature.random());
-  }
-
-  getSize(): number {
-    return this.payload.getSize() + this.signature.getSize() + this.proposerSignature.getSize();
-  }
-
-  toInspect() {
-    return {
-      payload: this.payload.toInspect(),
-      signature: this.signature.toString(),
-      proposerSignature: this.proposerSignature.toString(),
-    };
-  }
-}

package/src/slashing/empire.ts

@@ -1,100 +0,0 @@
-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 = 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 = 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: {
-      const slot = offense.epochOrSlot;
-      const detectedSlot = 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 = epoch + 1n;
-      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
-    }
-    default: {
-      const _: never = offense.offenseType;
-      throw new Error(`Unknown offense type: ${offense.offenseType}`);
-    }
-  }
-}

package/src/tx/content_commitment.ts

@@ -1,104 +0,0 @@
-import type { ViemContentCommitment } from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
-import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
-import { bufferToHex } from '@aztec/foundation/string';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import { z } from 'zod';
-
-export class ContentCommitment {
-  constructor(
-    public blobsHash: Fr,
-    public inHash: Fr,
-    public outHash: Fr,
-  ) {}
-
-  static get schema() {
-    return z
-      .object({
-        blobsHash: schemas.Fr,
-        inHash: schemas.Fr,
-        outHash: schemas.Fr,
-      })
-      .transform(({ blobsHash, inHash, outHash }) => new ContentCommitment(blobsHash, inHash, outHash));
-  }
-
-  static getFields(fields: FieldsOf<ContentCommitment>) {
-    return [fields.blobsHash, fields.inHash, fields.outHash] as const;
-  }
-
-  getSize() {
-    return this.toBuffer().length;
-  }
-
-  toBuffer() {
-    return serializeToBuffer(...ContentCommitment.getFields(this));
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader): ContentCommitment {
-    const reader = BufferReader.asReader(buffer);
-
-    return new ContentCommitment(reader.readObject(Fr), reader.readObject(Fr), reader.readObject(Fr));
-  }
-
-  toInspect() {
-    return {
-      blobsHash: this.blobsHash.toString(),
-      inHash: this.inHash.toString(),
-      outHash: this.outHash.toString(),
-    };
-  }
-
-  toViem(): ViemContentCommitment {
-    return {
-      blobsHash: this.blobsHash.toString(),
-      inHash: this.inHash.toString(),
-      outHash: this.outHash.toString(),
-    };
-  }
-
-  static fromViem(contentCommitment: ViemContentCommitment) {
-    return new ContentCommitment(
-      Fr.fromString(contentCommitment.blobsHash),
-      Fr.fromString(contentCommitment.inHash),
-      Fr.fromString(contentCommitment.outHash),
-    );
-  }
-
-  toFields(): Fr[] {
-    return serializeToFields(...ContentCommitment.getFields(this));
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): ContentCommitment {
-    const reader = FieldReader.asReader(fields);
-    return new ContentCommitment(reader.readField(), reader.readField(), reader.readField());
-  }
-
-  static random(): ContentCommitment {
-    return new ContentCommitment(Fr.random(), Fr.random(), Fr.random());
-  }
-
-  static empty(): ContentCommitment {
-    return new ContentCommitment(Fr.zero(), Fr.zero(), Fr.zero());
-  }
-
-  isEmpty(): boolean {
-    return this.blobsHash.isZero() && this.inHash.isZero() && this.outHash.isZero();
-  }
-
-  public toString(): string {
-    return bufferToHex(this.toBuffer());
-  }
-
-  static fromString(str: string): ContentCommitment {
-    const buffer = Buffer.from(str.replace(/^0x/i, ''), 'hex');
-    return ContentCommitment.fromBuffer(buffer);
-  }
-
-  public equals(other: this): boolean {
-    return (
-      this.blobsHash.equals(other.blobsHash) && this.inHash.equals(other.inHash) && this.outHash.equals(other.outHash)
-    );
-  }
-}