@aztec/stdlib 4.0.0-nightly.20260118 → 4.0.0-nightly.20260120

package/src/block/l2_block_code_to_purge.ts

@@ -1,81 +0,0 @@
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
-import { compact } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import { AztecAddress } from '../aztec-address/index.js';
-import { GasFees } from '../gas/gas_fees.js';
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { GlobalVariables } from '../tx/global_variables.js';
-import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { StateReference } from '../tx/state_reference.js';
-import { L2BlockHeader } from './l2_block_header.js';
-
-export function makeL2BlockHeader(
-  seed = 0,
-  blockNumber?: number,
-  slotNumber?: number,
-  overrides: Partial<FieldsOf<L2BlockHeader>> = {},
-) {
-  return new L2BlockHeader(
-    makeAppendOnlyTreeSnapshot(seed + 0x100),
-    overrides.blobsHash ?? new Fr(seed + 0x200),
-    overrides.inHash ?? new Fr(seed + 0x300),
-    overrides.epochOutHash ?? new Fr(seed + 0x400),
-    overrides.state ?? makeStateReference(seed + 0x600),
-    makeGlobalVariables((seed += 0x700), {
-      ...(blockNumber ? { blockNumber: BlockNumber(blockNumber) } : {}),
-      ...(slotNumber ? { slotNumber: SlotNumber(slotNumber) } : {}),
-    }),
-    new Fr(seed + 0x300),
-    new Fr(seed + 0x800),
-    new Fr(seed + 0x900),
-    new Fr(seed + 0xa00),
-  );
-}
-
-/**
- * Makes arbitrary append only tree snapshot.
- * @param seed - The seed to use for generating the append only tree snapshot.
- * @returns An append only tree snapshot.
- */
-export function makeAppendOnlyTreeSnapshot(seed = 1): AppendOnlyTreeSnapshot {
-  return new AppendOnlyTreeSnapshot(new Fr(seed), seed);
-}
-
-/**
- * Makes arbitrary state reference.
- * @param seed - The seed to use for generating the state reference.
- * @returns A state reference.
- */
-function makeStateReference(seed = 0): StateReference {
-  return new StateReference(makeAppendOnlyTreeSnapshot(seed), makePartialStateReference(seed + 1));
-}
-
-/**
- * Makes arbitrary partial state reference.
- * @param seed - The seed to use for generating the partial state reference.
- * @returns A partial state reference.
- */
-function makePartialStateReference(seed = 0): PartialStateReference {
-  return new PartialStateReference(
-    makeAppendOnlyTreeSnapshot(seed),
-    makeAppendOnlyTreeSnapshot(seed + 1),
-    makeAppendOnlyTreeSnapshot(seed + 2),
-  );
-}
-
-function makeGlobalVariables(seed = 1, overrides: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
-  return GlobalVariables.from({
-    chainId: new Fr(seed),
-    version: new Fr(seed + 1),
-    blockNumber: BlockNumber(seed + 2),
-    slotNumber: SlotNumber(seed + 3),
-    timestamp: BigInt(seed + 4),
-    coinbase: EthAddress.fromField(new Fr(seed + 5)),
-    feeRecipient: AztecAddress.fromField(new Fr(seed + 6)),
-    gasFees: new GasFees(seed + 7, seed + 8),
-    ...compact(overrides),
-  });
-}

package/src/block/l2_block_header.ts

@@ -1,268 +0,0 @@
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
-import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import { inspect } from 'util';
-import { z } from 'zod';
-
-import { CheckpointHeader } from '../rollup/checkpoint_header.js';
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { BlockHeader, GlobalVariables, StateReference } from '../tx/index.js';
-
-/**
- * TO BE DELETED
- *
- * A header of an L2 block combining the block header and the checkpoint header.
- * This is a temporary workaround to avoid changing too many things before building in chunks is properly implemented.
- * This works for now because we only have one block per checkpoint.
- *
- * @deprecated Use BlockHeader or CheckpointHeader instead.
- */
-export class L2BlockHeader {
-  constructor(
-    /** Snapshot of archive before the block is applied. */
-    public lastArchive: AppendOnlyTreeSnapshot,
-    public blobsHash: Fr,
-    public inHash: Fr,
-    /** Root of the epoch out hash tree. Leaves are the out hashes of this block and all previous blocks in the epoch. */
-    public epochOutHash: Fr,
-    /** State reference. */
-    public state: StateReference,
-    /** Global variables of an L2 block. */
-    public globalVariables: GlobalVariables,
-    /** Total fees in the block, computed by the root rollup circuit */
-    public totalFees: Fr,
-    /** Total mana used in the block, computed by the root rollup circuit */
-    public totalManaUsed: Fr,
-    /** Hash of the sponge blob of the block. */
-    public spongeBlobHash: Fr,
-    /** Hash of the block headers in the checkpoint. */
-    public blockHeadersHash: Fr,
-  ) {}
-
-  static get schema(): ZodFor<L2BlockHeader> {
-    return z
-      .object({
-        lastArchive: AppendOnlyTreeSnapshot.schema,
-        blobsHash: schemas.Fr,
-        inHash: schemas.Fr,
-        epochOutHash: schemas.Fr,
-        state: StateReference.schema,
-        globalVariables: GlobalVariables.schema,
-        totalFees: schemas.Fr,
-        totalManaUsed: schemas.Fr,
-        spongeBlobHash: schemas.Fr,
-        blockHeadersHash: schemas.Fr,
-      })
-      .transform(L2BlockHeader.from);
-  }
-
-  static getFields(fields: FieldsOf<L2BlockHeader>) {
-    return [
-      fields.lastArchive,
-      fields.blobsHash,
-      fields.inHash,
-      fields.epochOutHash,
-      fields.state,
-      fields.globalVariables,
-      fields.totalFees,
-      fields.totalManaUsed,
-      fields.spongeBlobHash,
-      fields.blockHeadersHash,
-    ] as const;
-  }
-
-  static from(fields: FieldsOf<L2BlockHeader>) {
-    return new L2BlockHeader(...L2BlockHeader.getFields(fields));
-  }
-
-  getSlot(): SlotNumber {
-    return this.globalVariables.slotNumber;
-  }
-
-  getBlockNumber() {
-    return this.globalVariables.blockNumber;
-  }
-
-  getSize() {
-    return (
-      this.lastArchive.getSize() +
-      this.blobsHash.size +
-      this.inHash.size +
-      this.epochOutHash.size +
-      this.state.getSize() +
-      this.globalVariables.getSize() +
-      this.totalFees.size +
-      this.totalManaUsed.size +
-      this.spongeBlobHash.size +
-      this.blockHeadersHash.size
-    );
-  }
-
-  toBuffer() {
-    return serializeToBuffer(...L2BlockHeader.getFields(this));
-  }
-
-  toFields(): Fr[] {
-    return serializeToFields(...L2BlockHeader.getFields(this));
-  }
-
-  clone() {
-    return L2BlockHeader.fromBuffer(this.toBuffer());
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-
-    return new L2BlockHeader(
-      reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(Fr),
-      reader.readObject(Fr),
-      reader.readObject(Fr),
-      reader.readObject(StateReference),
-      reader.readObject(GlobalVariables),
-      reader.readObject(Fr),
-      reader.readObject(Fr),
-      reader.readObject(Fr),
-      reader.readObject(Fr),
-    );
-  }
-
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-
-    return new L2BlockHeader(
-      AppendOnlyTreeSnapshot.fromFields(reader),
-      reader.readField(),
-      reader.readField(),
-      reader.readField(),
-      StateReference.fromFields(reader),
-      GlobalVariables.fromFields(reader),
-      reader.readField(),
-      reader.readField(),
-      reader.readField(),
-      reader.readField(),
-    );
-  }
-
-  static empty(fields: Partial<FieldsOf<L2BlockHeader>> = {}) {
-    return L2BlockHeader.from({
-      lastArchive: AppendOnlyTreeSnapshot.empty(),
-      blobsHash: Fr.ZERO,
-      inHash: Fr.ZERO,
-      epochOutHash: Fr.ZERO,
-      state: StateReference.empty(),
-      globalVariables: GlobalVariables.empty(),
-      totalFees: Fr.ZERO,
-      totalManaUsed: Fr.ZERO,
-      spongeBlobHash: Fr.ZERO,
-      blockHeadersHash: Fr.ZERO,
-      ...fields,
-    });
-  }
-
-  isEmpty(): boolean {
-    return (
-      this.lastArchive.isEmpty() &&
-      this.blobsHash.isZero() &&
-      this.inHash.isZero() &&
-      this.epochOutHash.isZero() &&
-      this.state.isEmpty() &&
-      this.globalVariables.isEmpty() &&
-      this.totalFees.isZero() &&
-      this.totalManaUsed.isZero() &&
-      this.spongeBlobHash.isZero() &&
-      this.blockHeadersHash.isZero()
-    );
-  }
-
-  /**
-   * Serializes this instance into a string.
-   * @returns Encoded string.
-   */
-  public toString() {
-    return bufferToHex(this.toBuffer());
-  }
-
-  static fromString(str: string) {
-    return L2BlockHeader.fromBuffer(hexToBuffer(str));
-  }
-
-  toCheckpointHeader() {
-    return new CheckpointHeader(
-      this.lastArchive.root,
-      this.blockHeadersHash,
-      this.blobsHash,
-      this.inHash,
-      this.epochOutHash,
-      this.globalVariables.slotNumber,
-      this.globalVariables.timestamp,
-      this.globalVariables.coinbase,
-      this.globalVariables.feeRecipient,
-      this.globalVariables.gasFees,
-      this.totalManaUsed,
-    );
-  }
-
-  toBlockHeader() {
-    return new BlockHeader(
-      this.lastArchive,
-      this.state,
-      this.spongeBlobHash,
-      this.globalVariables,
-      this.totalFees,
-      this.totalManaUsed,
-    );
-  }
-
-  toInspect() {
-    return {
-      lastArchive: this.lastArchive.root.toString(),
-      blobsHash: this.blobsHash.toString(),
-      inHash: this.inHash.toString(),
-      epochOutHash: this.epochOutHash.toString(),
-      state: this.state.toInspect(),
-      globalVariables: this.globalVariables.toInspect(),
-      totalFees: this.totalFees.toBigInt(),
-      totalManaUsed: this.totalManaUsed.toBigInt(),
-      spongeBlobHash: this.spongeBlobHash.toString(),
-      blockHeadersHash: this.blockHeadersHash.toString(),
-    };
-  }
-
-  [inspect.custom]() {
-    return `L2BlockHeader {
-  lastArchive: ${inspect(this.lastArchive)},
-  blobsHash: ${inspect(this.blobsHash)},
-  inHash: ${inspect(this.inHash)},
-  epochOutHash: ${inspect(this.epochOutHash)},
-  state.l1ToL2MessageTree: ${inspect(this.state.l1ToL2MessageTree)},
-  state.noteHashTree: ${inspect(this.state.partial.noteHashTree)},
-  state.nullifierTree: ${inspect(this.state.partial.nullifierTree)},
-  state.publicDataTree: ${inspect(this.state.partial.publicDataTree)},
-  globalVariables: ${inspect(this.globalVariables)},
-  totalFees: ${this.totalFees},
-  totalManaUsed: ${this.totalManaUsed},
-  spongeBlobHash: ${this.spongeBlobHash},
-  blockHeadersHash: ${this.blockHeadersHash},
-}`;
-  }
-
-  public equals(other: this): boolean {
-    return (
-      this.lastArchive.equals(other.lastArchive) &&
-      this.blobsHash.equals(other.blobsHash) &&
-      this.inHash.equals(other.inHash) &&
-      this.epochOutHash.equals(other.epochOutHash) &&
-      this.state.equals(other.state) &&
-      this.globalVariables.equals(other.globalVariables) &&
-      this.totalFees.equals(other.totalFees) &&
-      this.totalManaUsed.equals(other.totalManaUsed) &&
-      this.spongeBlobHash.equals(other.spongeBlobHash) &&
-      this.blockHeadersHash.equals(other.blockHeadersHash)
-    );
-  }
-}