@aztec/stdlib 0.0.1-commit.fcb71a6 → 0.0.1-commit.fffb133c

package/src/block/l2_block_header.ts

@@ -1,246 +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, ContentCommitment, 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,
-    /** Hash of the body of an L2 block. */
-    public contentCommitment: ContentCommitment,
-    /** 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,
-        contentCommitment: ContentCommitment.schema,
-        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.contentCommitment,
-      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.contentCommitment.getSize() +
-      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(ContentCommitment),
-      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),
-      ContentCommitment.fromFields(reader),
-      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(),
-      contentCommitment: ContentCommitment.empty(),
-      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.contentCommitment.isEmpty() &&
-      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.contentCommitment,
-      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(),
-      contentCommitment: this.contentCommitment.toInspect(),
-      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)},
-  contentCommitment.blobsHash: ${inspect(this.contentCommitment.blobsHash)},
-  contentCommitment.inHash: ${inspect(this.contentCommitment.inHash)},
-  contentCommitment.outHash: ${inspect(this.contentCommitment.outHash)},
-  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.contentCommitment.equals(other.contentCommitment) &&
-      this.state.equals(other.state) &&
-      this.globalVariables.equals(other.globalVariables) &&
-      this.totalFees.equals(other.totalFees) &&
-      this.totalManaUsed.equals(other.totalManaUsed) &&
-      this.lastArchive.equals(other.lastArchive) &&
-      this.spongeBlobHash.equals(other.spongeBlobHash) &&
-      this.blockHeadersHash.equals(other.blockHeadersHash)
-    );
-  }
-}

package/src/block/l2_block_new.ts

@@ -1,207 +0,0 @@
-import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
-import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import { z } from 'zod';
-
-import type { PrivateLog } from '../logs/private_log.js';
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { BlockHeader } from '../tx/block_header.js';
-import { Body } from './body.js';
-import type { L2BlockInfo } from './l2_block_info.js';
-
-/**
- * An L2 block with a header and a body.
- * TODO: Delete the existing `L2Block` class and rename this to `L2Block`.
- */
-export class L2BlockNew {
-  constructor(
-    /** Snapshot of archive tree after the block is applied. */
-    public archive: AppendOnlyTreeSnapshot,
-    /** Header of the block. */
-    public header: BlockHeader,
-    /** L2 block body. */
-    public body: Body,
-    /** Number of the checkpoint that the block belongs to. */
-    public checkpointNumber: CheckpointNumber,
-    /** Index of the block within the checkpoint. */
-    public indexWithinCheckpoint: number,
-  ) {}
-
-  get number(): BlockNumber {
-    return this.header.globalVariables.blockNumber;
-  }
-
-  get timestamp(): bigint {
-    return this.header.globalVariables.timestamp;
-  }
-
-  static get schema() {
-    return z
-      .object({
-        archive: AppendOnlyTreeSnapshot.schema,
-        header: BlockHeader.schema,
-        body: Body.schema,
-        checkpointNumber: CheckpointNumberSchema,
-        indexWithinCheckpoint: z.number(),
-      })
-      .transform(
-        ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
-          new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint),
-      );
-  }
-
-  /**
-   * Deserializes a block from a buffer
-   * @returns A deserialized L2 block.
-   */
-  static fromBuffer(buf: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buf);
-    const header = reader.readObject(BlockHeader);
-    const archive = reader.readObject(AppendOnlyTreeSnapshot);
-    const body = reader.readObject(Body);
-    const checkpointNumber = CheckpointNumber(reader.readNumber());
-    const indexWithinCheckpoint = reader.readNumber();
-
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
-  }
-
-  /**
-   * Serializes a block
-   * @returns A serialized L2 block as a Buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
-  }
-
-  /**
-   * Returns the block's hash (hash of block header).
-   * @returns The block's hash.
-   */
-  public hash(): Promise<Fr> {
-    return this.header.hash();
-  }
-
-  /**
-   * Checks if this block equals another block.
-   * @param other - The other block to compare with.
-   * @returns True if both blocks are equal.
-   */
-  public equals(other: this): boolean {
-    return (
-      this.archive.equals(other.archive) &&
-      this.header.equals(other.header) &&
-      this.body.equals(other.body) &&
-      this.checkpointNumber === other.checkpointNumber &&
-      this.indexWithinCheckpoint === other.indexWithinCheckpoint
-    );
-  }
-
-  public toBlobFields(): Fr[] {
-    const blockBlobData = this.toBlockBlobData();
-    return encodeBlockBlobData(blockBlobData);
-  }
-
-  public toBlockBlobData(): BlockBlobData {
-    const isFirstBlock = this.indexWithinCheckpoint === 0;
-    return {
-      blockEndMarker: {
-        numTxs: this.body.txEffects.length,
-        timestamp: this.header.globalVariables.timestamp,
-        blockNumber: this.number,
-      },
-      blockEndStateField: {
-        l1ToL2MessageNextAvailableLeafIndex: this.header.state.l1ToL2MessageTree.nextAvailableLeafIndex,
-        noteHashNextAvailableLeafIndex: this.header.state.partial.noteHashTree.nextAvailableLeafIndex,
-        nullifierNextAvailableLeafIndex: this.header.state.partial.nullifierTree.nextAvailableLeafIndex,
-        publicDataNextAvailableLeafIndex: this.header.state.partial.publicDataTree.nextAvailableLeafIndex,
-        totalManaUsed: this.header.totalManaUsed.toBigInt(),
-      },
-      lastArchiveRoot: this.header.lastArchive.root,
-      noteHashRoot: this.header.state.partial.noteHashTree.root,
-      nullifierRoot: this.header.state.partial.nullifierTree.root,
-      publicDataRoot: this.header.state.partial.publicDataTree.root,
-      l1ToL2MessageRoot: isFirstBlock ? this.header.state.l1ToL2MessageTree.root : undefined,
-      txs: this.body.toTxBlobData(),
-    };
-  }
-
-  static empty() {
-    return new L2BlockNew(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty(), CheckpointNumber(0), 0);
-  }
-
-  /**
-   * Creates an L2 block containing random data.
-   * @param l2BlockNum - The number of the L2 block.
-   * @param txsPerBlock - The number of transactions to include in the block.
-   * @param numPublicCallsPerTx - The number of public function calls to include in each transaction.
-   * @param numPublicLogsPerCall - The number of public logs per 1 public function invocation.
-   * @param inHash - The hash of the L1 to L2 messages subtree which got inserted in this block.
-   * @returns The L2 block.
-   */
-  static async random(
-    blockNumber: BlockNumber,
-    {
-      checkpointNumber = CheckpointNumber(Number(blockNumber)),
-      indexWithinCheckpoint = 0,
-      txsPerBlock = 1,
-      txOptions = {},
-      makeTxOptions,
-      ...blockHeaderOverrides
-    }: {
-      checkpointNumber?: CheckpointNumber;
-      indexWithinCheckpoint?: number;
-      txsPerBlock?: number;
-      txOptions?: Partial<Parameters<typeof Body.random>[0]>;
-      makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
-    } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
-  ): Promise<L2BlockNew> {
-    const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
-    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
-    const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
-  }
-
-  /**
-   * Returns stats used for logging.
-   * @returns Stats on tx count, number, and log size and count.
-   */
-  getStats() {
-    const logsStats = {
-      privateLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.privateLogs.length, 0),
-      publicLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.publicLogs.length, 0),
-      contractClassLogCount: this.body.txEffects.reduce(
-        (logCount, txEffect) => logCount + txEffect.contractClassLogs.length,
-        0,
-      ),
-      contractClassLogSize: this.body.txEffects.reduce(
-        (totalLogSize, txEffect) =>
-          totalLogSize + txEffect.contractClassLogs.reduce((acc, log) => acc + log.emittedLength, 0),
-        0,
-      ),
-    };
-
-    return {
-      txCount: this.body.txEffects.length,
-      blockNumber: this.number,
-      blockTimestamp: Number(this.header.globalVariables.timestamp),
-      ...logsStats,
-    };
-  }
-
-  getPrivateLogs(): PrivateLog[] {
-    return this.body.txEffects.map(txEffect => txEffect.privateLogs).flat();
-  }
-
-  toBlockInfo(): L2BlockInfo {
-    return {
-      archive: this.archive.root,
-      lastArchive: this.header.lastArchive.root,
-      blockNumber: this.number,
-      slotNumber: this.header.getSlot(),
-      txCount: this.body.txEffects.length,
-      timestamp: this.header.globalVariables.timestamp,
-    };
-  }
-}

package/src/contract/contract_class_metadata.ts

@@ -1,8 +0,0 @@
-import type { ContractArtifact } from '../abi/abi.js';
-import type { ContractClassWithId } from './interfaces/contract_class.js';
-
-export interface ContractClassMetadata {
-  contractClass?: ContractClassWithId | undefined;
-  isContractClassPubliclyRegistered: boolean;
-  artifact?: ContractArtifact | undefined;
-}

package/src/contract/contract_metadata.ts

@@ -1,7 +0,0 @@
-import type { ContractInstanceWithAddress } from './interfaces/contract_instance.js';
-
-export interface ContractMetadata {
-  contractInstance?: ContractInstanceWithAddress | undefined;
-  isContractInitialized: boolean;
-  isContractPublished: boolean;
-}

package/src/tx/content_commitment.ts

@@ -1,113 +0,0 @@
-import type { ViemContentCommitment } from '@aztec/ethereum/contracts';
-import { Fr } from '@aztec/foundation/curves/bn254';
-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;
-  }
-
-  static from(fields: FieldsOf<ContentCommitment>) {
-    return new ContentCommitment(...ContentCommitment.getFields(fields));
-  }
-
-  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(overrides: Partial<FieldsOf<ContentCommitment>> = {}): ContentCommitment {
-    return ContentCommitment.from({
-      blobsHash: Fr.random(),
-      inHash: Fr.random(),
-      outHash: Fr.random(),
-      ...overrides,
-    });
-  }
-
-  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)
-    );
-  }
-}