@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/rollup/checkpoint_header.ts

@@ -0,0 +1,297 @@
+import type { ViemHeader } from '@aztec/ethereum/contracts';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } 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 { AztecAddress } from '../aztec-address/index.js';
+import { GasFees } from '../gas/index.js';
+import { schemas } from '../schemas/index.js';
+import type { GlobalVariables } from '../tx/global_variables.js';
+import type { UInt64 } from '../types/shared.js';
+
+/**
+ * Header of a checkpoint. A checkpoint is a collection of blocks submitted to L1 all within the same slot.
+ * This header is verified as-is in the rollup circuits, posted to the L1 rollup contract, stored in the archiver,
+ * and exposed via the Aztec Node API. See `CheckpointData` for a struct that includes the header plus extra metadata.
+ */
+export class CheckpointHeader {
+  constructor(
+    /** Root of the archive tree before this block is added. */
+    public lastArchiveRoot: Fr,
+    /** Hash of the headers of all blocks in this checkpoint. */
+    public blockHeadersHash: Fr,
+    /** Hash of the blobs in the checkpoint. */
+    public blobsHash: Fr,
+    /** Root of the l1 to l2 messages subtree. */
+    public inHash: Fr,
+    /**
+     * The root of the epoch out hash balanced tree. The out hash of the first checkpoint in the epoch is inserted at
+     * index 0, the second at index 1, and so on.
+     * Note: This is not necessarily the final epoch out hash. It includes only the out hashes of checkpoints up to and
+     * including the current checkpoint. Any subsequent checkpoints added to the same epoch are not reflected in this
+     * value.
+     */
+    public epochOutHash: Fr,
+    /** Slot number of the L2 block */
+    public slotNumber: SlotNumber,
+    /** Timestamp of the L2 block. */
+    public timestamp: UInt64,
+    /** Recipient of block reward. */
+    public coinbase: EthAddress,
+    /** Address to receive fees. */
+    public feeRecipient: AztecAddress,
+    /** Global gas prices for this block. */
+    public gasFees: GasFees,
+    /** Total mana used in the block, computed by the root rollup circuit */
+    public totalManaUsed: Fr,
+  ) {}
+
+  static get schema(): ZodFor<CheckpointHeader> {
+    return z
+      .object({
+        lastArchiveRoot: schemas.Fr,
+        blockHeadersHash: schemas.Fr,
+        blobsHash: schemas.Fr,
+        inHash: schemas.Fr,
+        epochOutHash: schemas.Fr,
+        slotNumber: schemas.SlotNumber,
+        timestamp: schemas.BigInt,
+        coinbase: schemas.EthAddress,
+        feeRecipient: schemas.AztecAddress,
+        gasFees: GasFees.schema,
+        totalManaUsed: schemas.Fr,
+      })
+      .transform(CheckpointHeader.from);
+  }
+
+  static getFields(fields: FieldsOf<CheckpointHeader>) {
+    return [
+      fields.lastArchiveRoot,
+      fields.blockHeadersHash,
+      fields.blobsHash,
+      fields.inHash,
+      fields.epochOutHash,
+      fields.slotNumber,
+      fields.timestamp,
+      fields.coinbase,
+      fields.feeRecipient,
+      fields.gasFees,
+      fields.totalManaUsed,
+    ] as const;
+  }
+
+  static from(fields: FieldsOf<CheckpointHeader>) {
+    return new CheckpointHeader(...CheckpointHeader.getFields(fields));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+
+    return new CheckpointHeader(
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      SlotNumber(Fr.fromBuffer(reader).toNumber()),
+      reader.readUInt64(),
+      reader.readObject(EthAddress),
+      reader.readObject(AztecAddress),
+      reader.readObject(GasFees),
+      reader.readObject(Fr),
+    );
+  }
+
+  equals(other: CheckpointHeader) {
+    return (
+      this.lastArchiveRoot.equals(other.lastArchiveRoot) &&
+      this.blockHeadersHash.equals(other.blockHeadersHash) &&
+      this.blobsHash.equals(other.blobsHash) &&
+      this.inHash.equals(other.inHash) &&
+      this.epochOutHash.equals(other.epochOutHash) &&
+      this.slotNumber === other.slotNumber &&
+      this.timestamp === other.timestamp &&
+      this.coinbase.equals(other.coinbase) &&
+      this.feeRecipient.equals(other.feeRecipient) &&
+      this.gasFees.equals(other.gasFees) &&
+      this.totalManaUsed.equals(other.totalManaUsed)
+    );
+  }
+
+  /** Returns true if the global variables match those in the checkpoint header. */
+  matchesGlobalVariables(other: GlobalVariables) {
+    return (
+      this.coinbase.equals(other.coinbase) &&
+      this.feeRecipient.equals(other.feeRecipient) &&
+      this.gasFees.equals(other.gasFees) &&
+      this.slotNumber === other.slotNumber &&
+      this.timestamp === other.timestamp
+    );
+  }
+
+  toBuffer() {
+    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
+    return serializeToBuffer([
+      this.lastArchiveRoot,
+      this.blockHeadersHash,
+      this.blobsHash,
+      this.inHash,
+      this.epochOutHash,
+      new Fr(this.slotNumber),
+      bigintToUInt64BE(this.timestamp),
+      this.coinbase,
+      this.feeRecipient,
+      this.gasFees,
+      this.totalManaUsed,
+    ]);
+  }
+
+  hash(): Fr {
+    return sha256ToField([this.toBuffer()]);
+  }
+
+  static empty(fields: Partial<FieldsOf<CheckpointHeader>> = {}) {
+    return CheckpointHeader.from({
+      lastArchiveRoot: Fr.ZERO,
+      blockHeadersHash: Fr.ZERO,
+      blobsHash: Fr.ZERO,
+      inHash: Fr.ZERO,
+      epochOutHash: Fr.ZERO,
+      slotNumber: SlotNumber.ZERO,
+      timestamp: 0n,
+      coinbase: EthAddress.ZERO,
+      feeRecipient: AztecAddress.ZERO,
+      gasFees: GasFees.empty(),
+      totalManaUsed: Fr.ZERO,
+      ...fields,
+    });
+  }
+
+  static random(overrides: Partial<FieldsOf<CheckpointHeader>> = {}): CheckpointHeader {
+    return CheckpointHeader.from({
+      lastArchiveRoot: Fr.random(),
+      blockHeadersHash: Fr.random(),
+      blobsHash: Fr.random(),
+      inHash: Fr.random(),
+      epochOutHash: Fr.random(),
+      slotNumber: SlotNumber(Math.floor(Math.random() * 1000) + 1),
+      timestamp: BigInt(Math.floor(Date.now() / 1000)),
+      coinbase: EthAddress.random(),
+      feeRecipient: new AztecAddress(Fr.random()),
+      gasFees: GasFees.random(),
+      totalManaUsed: new Fr(BigInt(Math.floor(Math.random() * 1000000))),
+      ...overrides,
+    });
+  }
+
+  isEmpty(): boolean {
+    return (
+      this.lastArchiveRoot.isZero() &&
+      this.blockHeadersHash.isZero() &&
+      this.blobsHash.isZero() &&
+      this.inHash.isZero() &&
+      this.epochOutHash.isZero() &&
+      this.slotNumber === 0 &&
+      this.timestamp === 0n &&
+      this.coinbase.isZero() &&
+      this.feeRecipient.isZero() &&
+      this.gasFees.isEmpty() &&
+      this.totalManaUsed.isZero()
+    );
+  }
+
+  /**
+   * Serializes this instance into a string.
+   * @returns Encoded string.
+   */
+  public toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return CheckpointHeader.fromBuffer(hexToBuffer(str));
+  }
+
+  static fromViem(header: ViemHeader) {
+    return new CheckpointHeader(
+      Fr.fromString(header.lastArchiveRoot),
+      Fr.fromString(header.blockHeadersHash),
+      Fr.fromString(header.blobsHash),
+      Fr.fromString(header.inHash),
+      Fr.fromString(header.outHash),
+      SlotNumber.fromBigInt(header.slotNumber),
+      header.timestamp,
+      new EthAddress(hexToBuffer(header.coinbase)),
+      new AztecAddress(hexToBuffer(header.feeRecipient)),
+      new GasFees(header.gasFees.feePerDaGas, header.gasFees.feePerL2Gas),
+      new Fr(header.totalManaUsed),
+    );
+  }
+
+  /**
+   * Returns the slot number as a SlotNumber branded type.
+   * @deprecated Use slotNumber directly instead.
+   */
+  getSlotNumber(): SlotNumber {
+    return this.slotNumber;
+  }
+
+  toViem(): ViemHeader {
+    return {
+      lastArchiveRoot: this.lastArchiveRoot.toString(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      outHash: this.epochOutHash.toString(),
+      slotNumber: BigInt(this.slotNumber),
+      timestamp: this.timestamp,
+      coinbase: this.coinbase.toString(),
+      feeRecipient: `0x${this.feeRecipient.toBuffer().toString('hex').padStart(64, '0')}`,
+      gasFees: {
+        feePerDaGas: this.gasFees.feePerDaGas,
+        feePerL2Gas: this.gasFees.feePerL2Gas,
+      },
+      totalManaUsed: this.totalManaUsed.toBigInt(),
+    };
+  }
+
+  toInspect() {
+    return {
+      lastArchive: this.lastArchiveRoot.toString(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      epochOutHash: this.epochOutHash.toString(),
+      slotNumber: this.slotNumber,
+      timestamp: this.timestamp,
+      coinbase: this.coinbase.toString(),
+      feeRecipient: this.feeRecipient.toString(),
+      gasFees: this.gasFees.toInspect(),
+      totalManaUsed: this.totalManaUsed.toBigInt(),
+    };
+  }
+
+  [inspect.custom]() {
+    return `Header {
+  lastArchiveRoot: ${this.lastArchiveRoot.toString()},
+  blockHeadersHash: ${this.blockHeadersHash.toString()},
+  blobsHash: ${inspect(this.blobsHash)},
+  inHash: ${inspect(this.inHash)},
+  epochOutHash: ${inspect(this.epochOutHash)},
+  slotNumber: ${this.slotNumber},
+  timestamp: ${this.timestamp},
+  coinbase: ${this.coinbase.toString()},
+  feeRecipient: ${this.feeRecipient.toString()},
+  gasFees: { da:${this.gasFees.feePerDaGas}, l2:${this.gasFees.feePerL2Gas} },
+  totalManaUsed: ${this.totalManaUsed.toBigInt()},
+}`;
+  }
+}

package/src/rollup/checkpoint_merge_rollup_private_inputs.ts

@@ -0,0 +1,49 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { CheckpointRollupPublicInputs } from './checkpoint_rollup_public_inputs.js';
+
+/**
+ * Represents inputs of the checkpoint merge rollup circuit.
+ */
+export class CheckpointMergeRollupPrivateInputs {
+  constructor(
+    /**
+     * Previous rollup data from the 2 checkpoint root or merge rollup circuits that preceded this checkpoint merge rollup circuit.
+     */
+    public previousRollups: [
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
+    ],
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.previousRollups);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CheckpointMergeRollupPrivateInputs([
+      ProofData.fromBuffer(reader, CheckpointRollupPublicInputs),
+      ProofData.fromBuffer(reader, CheckpointRollupPublicInputs),
+    ]);
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return CheckpointMergeRollupPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(CheckpointMergeRollupPrivateInputs);
+  }
+}

package/src/rollup/checkpoint_rollup_public_inputs.ts

@@ -0,0 +1,161 @@
+import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
+import { MAX_CHECKPOINTS_PER_EPOCH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { EpochConstantData } from './epoch_constant_data.js';
+
+/**
+ * Output of the checkpoint root and checkpoint merge rollup circuits.
+ */
+export class CheckpointRollupPublicInputs {
+  constructor(
+    /**
+     * Constants for the entire epoch.
+     */
+    public constants: EpochConstantData,
+    /**
+     * Archive tree immediately before this checkpoint range.
+     */
+    public previousArchive: AppendOnlyTreeSnapshot,
+    /**
+     * Archive tree after adding this checkpoint range.
+     */
+    public newArchive: AppendOnlyTreeSnapshot,
+    /**
+     * The out hash tree snapshot immediately before this checkpoint range.
+     */
+    public previousOutHash: AppendOnlyTreeSnapshot,
+    /**
+     * The out hash tree snapshot after applying this checkpoint range.
+     */
+    public newOutHash: AppendOnlyTreeSnapshot,
+    /**
+     * The hashes of the headers of the constituent checkpoints.
+     */
+    public checkpointHeaderHashes: Tuple<Fr, typeof MAX_CHECKPOINTS_PER_EPOCH>,
+    /**
+     * The summed transaction fees and recipients of the constituent checkpoints.
+     */
+    public fees: Tuple<FeeRecipient, typeof MAX_CHECKPOINTS_PER_EPOCH>,
+    /**
+     * Accumulated opening proofs for all blobs before this checkpoint range.
+     */
+    public startBlobAccumulator: BlobAccumulator,
+    /**
+     * Accumulated opening proofs for all blobs after applying this checkpoint range.
+     */
+    public endBlobAccumulator: BlobAccumulator,
+    /**
+     * Final values z and gamma, shared across the epoch.
+     */
+    public finalBlobChallenges: FinalBlobBatchingChallenges,
+  ) {}
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CheckpointRollupPublicInputs(
+      reader.readObject(EpochConstantData),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
+      reader.readObject(BlobAccumulator),
+      reader.readObject(BlobAccumulator),
+      reader.readObject(FinalBlobBatchingChallenges),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.constants,
+      this.previousArchive,
+      this.newArchive,
+      this.previousOutHash,
+      this.newOutHash,
+      this.checkpointHeaderHashes,
+      this.fees,
+      this.startBlobAccumulator,
+      this.endBlobAccumulator,
+      this.finalBlobChallenges,
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return CheckpointRollupPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  toInspect() {
+    return {
+      checkpointHeaderHash: this.checkpointHeaderHashes[0].toString(),
+      previousArchiveRoot: this.previousArchive.root.toString(),
+      newArchiveRoot: this.newArchive.root.toString(),
+      previousOutHashRoot: this.previousOutHash.root.toString(),
+      newOutHashRoot: this.newOutHash.root.toString(),
+    };
+  }
+
+  /** Creates an instance from a hex string. */
+  static get schema() {
+    return bufferSchemaFor(CheckpointRollupPublicInputs);
+  }
+}
+
+export class FeeRecipient {
+  constructor(
+    public recipient: EthAddress,
+    public value: Fr,
+  ) {}
+
+  static fromBuffer(buffer: Buffer | BufferReader): FeeRecipient {
+    const reader = BufferReader.asReader(buffer);
+    return new FeeRecipient(reader.readObject(EthAddress), Fr.fromBuffer(reader));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.recipient, this.value);
+  }
+
+  static getFields(fields: FieldsOf<FeeRecipient>) {
+    return [fields.recipient, fields.value] as const;
+  }
+
+  toFields() {
+    return serializeToFields(...FeeRecipient.getFields(this));
+  }
+
+  static empty() {
+    return new FeeRecipient(EthAddress.ZERO, Fr.ZERO);
+  }
+
+  isEmpty() {
+    return this.value.isZero() && this.recipient.isZero();
+  }
+
+  toFriendlyJSON() {
+    if (this.isEmpty()) {
+      return {};
+    }
+    return { recipient: this.recipient.toString(), value: this.value.toString() };
+  }
+
+  static random() {
+    return new FeeRecipient(EthAddress.random(), Fr.random());
+  }
+}