@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/trees/nullifier_membership_witness.ts

@@ -0,0 +1,59 @@
+import { NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { SiblingPath } from '@aztec/foundation/trees';
+
+import { z } from 'zod';
+
+import { schemas } from '../schemas/index.js';
+import { NullifierLeafPreimage } from './nullifier_leaf.js';
+
+/**
+ * Nullifier membership witness.
+ * @remarks When this represents membership witness of a low nullifier it can be used to perform a nullifier
+ * non-inclusion proof by leveraging the "linked list structure" of leaves and proving that a lower nullifier
+ * is pointing to a bigger next value than the nullifier we are trying to prove non-inclusion for.
+ */
+export class NullifierMembershipWitness {
+  constructor(
+    /**
+     * The index of the nullifier in a tree.
+     */
+    public readonly index: bigint,
+    /**
+     * Preimage of the nullifier.
+     */
+    public readonly leafPreimage: NullifierLeafPreimage,
+    /**
+     * Sibling path to prove membership of the nullifier.
+     */
+    public readonly siblingPath: SiblingPath<typeof NULLIFIER_TREE_HEIGHT>,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        index: schemas.BigInt,
+        leafPreimage: NullifierLeafPreimage.schema,
+        siblingPath: SiblingPath.schemaFor(NULLIFIER_TREE_HEIGHT),
+      })
+      .transform(
+        ({ index, leafPreimage, siblingPath }) => new NullifierMembershipWitness(index, leafPreimage, siblingPath),
+      );
+  }
+
+  static random() {
+    return new NullifierMembershipWitness(
+      BigInt(Math.floor(Math.random() * 1000)),
+      NullifierLeafPreimage.random(),
+      SiblingPath.random(NULLIFIER_TREE_HEIGHT),
+    );
+  }
+
+  /**
+   * Returns a field array representation of a nullifier witness.
+   * @returns A field array representation of a nullifier witness.
+   */
+  public toFields(): Fr[] {
+    return [new Fr(this.index), ...this.leafPreimage.toFields(), ...this.siblingPath.toFields()];
+  }
+}

package/src/trees/protocol_contract_leaf.ts

@@ -0,0 +1,132 @@
+import { MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+
+import { z } from 'zod';
+
+/**
+ * Class containing the data of a preimage of a single leaf in the protocol contract tree.
+ * Note: It's called preimage because this data gets hashed before being inserted as a node into the `IndexedTree`.
+ * Note: Though this tree contains addresses, they are converted to fields to avoid unnecessary conversions in the tree.
+ */
+export class ProtocolContractLeafPreimage implements IndexedTreeLeafPreimage {
+  constructor(
+    /**
+     * Leaf value inside the indexed tree's linked list.
+     */
+    public address: Fr,
+    /**
+     * Next value inside the indexed tree's linked list.
+     */
+    public nextAddress: Fr,
+    /**
+     * Index of the next leaf in the indexed tree's linked list.
+     */
+    public nextIndex: bigint,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        address: schemas.Fr,
+        nextAddress: schemas.Fr,
+        nextIndex: schemas.BigInt,
+      })
+      .transform(
+        ({ address, nextAddress, nextIndex }) => new ProtocolContractLeafPreimage(address, nextAddress, nextIndex),
+      );
+  }
+
+  getKey(): bigint {
+    return this.address.toBigInt();
+  }
+
+  getNextKey(): bigint {
+    return this.nextAddress.toBigInt();
+  }
+
+  getNextIndex(): bigint {
+    return this.nextIndex;
+  }
+
+  asLeaf(): ProtocolContractLeaf {
+    return new ProtocolContractLeaf(this.address);
+  }
+
+  toBuffer(): Buffer {
+    return Buffer.concat(this.toHashInputs());
+  }
+
+  toHashInputs(): Buffer[] {
+    // Note: the protocol contract leaves only hash the value and next value.
+    return [Buffer.from(this.address.toBuffer()), Buffer.from(this.nextAddress.toBuffer())];
+  }
+
+  toFields(): Fr[] {
+    return [this.address, this.nextAddress, new Fr(this.nextIndex)];
+  }
+
+  static random() {
+    return new ProtocolContractLeafPreimage(
+      Fr.random(),
+      Fr.random(),
+      BigInt(Math.floor(Math.random() * 1000) % MAX_PROTOCOL_CONTRACTS),
+    );
+  }
+
+  static empty(): ProtocolContractLeafPreimage {
+    return new ProtocolContractLeafPreimage(Fr.ZERO, Fr.ZERO, 0n);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ProtocolContractLeafPreimage {
+    const reader = BufferReader.asReader(buffer);
+    return new ProtocolContractLeafPreimage(
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      toBigIntBE(reader.readBytes(32)),
+    );
+  }
+
+  static fromLeaf(leaf: ProtocolContractLeaf, nextKey: bigint, nextIndex: bigint): ProtocolContractLeafPreimage {
+    return new ProtocolContractLeafPreimage(leaf.address, new Fr(nextKey), nextIndex);
+  }
+}
+
+/**
+ * An address to be inserted or checked in the protocol contract tree.
+ */
+export class ProtocolContractLeaf implements IndexedTreeLeaf {
+  constructor(
+    /**
+     * Address value.
+     */
+    public address: Fr,
+  ) {}
+
+  getKey(): bigint {
+    return this.address.toBigInt();
+  }
+
+  toBuffer(): Buffer {
+    return this.address.toBuffer();
+  }
+
+  isEmpty(): boolean {
+    return this.address.isZero();
+  }
+
+  updateTo(_another: ProtocolContractLeaf): ProtocolContractLeaf {
+    throw new Error('Protocol contract tree is insert only');
+  }
+
+  static buildDummy(key: bigint): ProtocolContractLeaf {
+    return new ProtocolContractLeaf(new Fr(key));
+  }
+
+  static fromBuffer(buf: Buffer): ProtocolContractLeaf {
+    return new ProtocolContractLeaf(Fr.fromBuffer(buf));
+  }
+}

package/src/trees/public_data_leaf.ts

@@ -0,0 +1,164 @@
+import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+
+import { z } from 'zod';
+
+/**
+ * Class containing the data of a preimage of a single leaf in the public data tree.
+ * Note: It's called preimage because this data gets hashed before being inserted as a node into the `IndexedTree`.
+ */
+export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
+  constructor(
+    /**
+     * The slot of the leaf
+     */
+    public slot: Fr,
+    /**
+     * The value of the leaf
+     */
+    public value: Fr,
+    /**
+     * Next value inside the indexed tree's linked list.
+     */
+    public nextSlot: Fr,
+    /**
+     * Index of the next leaf in the indexed tree's linked list.
+     */
+    public nextIndex: bigint,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        slot: schemas.Fr,
+        value: schemas.Fr,
+        nextSlot: schemas.Fr,
+        nextIndex: schemas.BigInt,
+      })
+      .transform(
+        ({ slot, value, nextSlot, nextIndex }) => new PublicDataTreeLeafPreimage(slot, value, nextSlot, nextIndex),
+      );
+  }
+
+  getKey(): bigint {
+    return this.slot.toBigInt();
+  }
+
+  getNextKey(): bigint {
+    return this.nextSlot.toBigInt();
+  }
+
+  getNextIndex(): bigint {
+    return this.nextIndex;
+  }
+
+  asLeaf(): PublicDataTreeLeaf {
+    return new PublicDataTreeLeaf(this.slot, this.value);
+  }
+
+  toBuffer(): Buffer {
+    return Buffer.concat(this.toHashInputs());
+  }
+
+  toHashInputs(): Buffer[] {
+    return [
+      Buffer.from(this.slot.toBuffer()),
+      Buffer.from(this.value.toBuffer()),
+      Buffer.from(toBufferBE(this.nextIndex, 32)),
+      Buffer.from(this.nextSlot.toBuffer()),
+    ];
+  }
+
+  clone(): PublicDataTreeLeafPreimage {
+    return new PublicDataTreeLeafPreimage(this.slot, this.value, this.nextSlot, this.nextIndex);
+  }
+
+  static random() {
+    return new PublicDataTreeLeafPreimage(
+      Fr.random(),
+      Fr.random(),
+      Fr.random(),
+      BigInt(Math.floor(Math.random() * 1000)),
+    );
+  }
+
+  static empty(): PublicDataTreeLeafPreimage {
+    return new PublicDataTreeLeafPreimage(Fr.ZERO, Fr.ZERO, Fr.ZERO, 0n);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PublicDataTreeLeafPreimage {
+    const reader = BufferReader.asReader(buffer);
+    const slot = Fr.fromBuffer(reader);
+    const value = Fr.fromBuffer(reader);
+    const nextIndex = toBigIntBE(reader.readBytes(32));
+    const nextSlot = Fr.fromBuffer(reader);
+    return new PublicDataTreeLeafPreimage(slot, value, nextSlot, nextIndex);
+  }
+
+  static fromLeaf(leaf: PublicDataTreeLeaf, nextKey: bigint, nextIndex: bigint): PublicDataTreeLeafPreimage {
+    return new PublicDataTreeLeafPreimage(leaf.slot, leaf.value, new Fr(nextKey), nextIndex);
+  }
+
+  static clone(preimage: PublicDataTreeLeafPreimage): PublicDataTreeLeafPreimage {
+    return new PublicDataTreeLeafPreimage(preimage.slot, preimage.value, preimage.nextSlot, preimage.nextIndex);
+  }
+}
+
+/**
+ * A leaf in the public data indexed tree.
+ */
+export class PublicDataTreeLeaf implements IndexedTreeLeaf {
+  constructor(
+    /**
+     * The slot the value is stored in
+     */
+    public slot: Fr,
+    /**
+     * The value stored in the slot
+     */
+    public value: Fr,
+  ) {}
+
+  getKey(): bigint {
+    return this.slot.toBigInt();
+  }
+
+  toBuffer() {
+    return serializeToBuffer([this.slot, this.value]);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicDataTreeLeaf(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+  }
+
+  equals(another: PublicDataTreeLeaf): boolean {
+    return this.slot.equals(another.slot) && this.value.equals(another.value);
+  }
+
+  toString(): string {
+    return `PublicDataTreeLeaf(${this.slot.toString()}, ${this.value.toString()})`;
+  }
+
+  isEmpty(): boolean {
+    return this.slot.isZero() && this.value.isZero();
+  }
+
+  updateTo(another: PublicDataTreeLeaf): PublicDataTreeLeaf {
+    if (!this.slot.equals(another.slot)) {
+      throw new Error('Invalid update: slots do not match');
+    }
+    return new PublicDataTreeLeaf(this.slot, another.value);
+  }
+
+  static buildDummy(key: bigint): PublicDataTreeLeaf {
+    return new PublicDataTreeLeaf(new Fr(key), new Fr(0));
+  }
+
+  static empty(): PublicDataTreeLeaf {
+    return new PublicDataTreeLeaf(Fr.ZERO, Fr.ZERO);
+  }
+}

package/src/trees/public_data_witness.ts

@@ -0,0 +1,103 @@
+import { PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import { SiblingPath } from '@aztec/foundation/trees';
+
+import { z } from 'zod';
+
+import { schemas } from '../schemas/schemas.js';
+import { PublicDataTreeLeafPreimage } from './public_data_leaf.js';
+
+/**
+ * Public data witness.
+ * @remarks This allows to prove either:
+ * - That a slot in the public data tree is empty (0 value) if it falls within the range of the leaf.
+ * - The current value of a slot in the public data tree if it matches exactly the slot of the leaf.
+ */
+export class PublicDataWitness {
+  constructor(
+    /**
+     * The index of the leaf in the public data tree.
+     */
+    public readonly index: bigint,
+    /**
+     * Preimage of a low leaf. All the slots in the range of the leaf are empty, and the current value of the
+     * leaf slot is stored in the leaf.
+     */
+    public readonly leafPreimage: PublicDataTreeLeafPreimage,
+    /**
+     * Sibling path to prove membership of the leaf.
+     */
+    public readonly siblingPath: SiblingPath<typeof PUBLIC_DATA_TREE_HEIGHT>,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        index: schemas.BigInt,
+        leafPreimage: PublicDataTreeLeafPreimage.schema,
+        siblingPath: SiblingPath.schemaFor(PUBLIC_DATA_TREE_HEIGHT),
+      })
+      .transform(({ index, leafPreimage, siblingPath }) => new PublicDataWitness(index, leafPreimage, siblingPath));
+  }
+
+  /**
+   * Returns a field array representation of a public data witness.
+   * @returns A field array representation of a public data witness.
+   */
+  public toFields(): Fr[] {
+    return [
+      new Fr(this.index),
+      new Fr(this.leafPreimage.slot),
+      new Fr(this.leafPreimage.value),
+      new Fr(this.leafPreimage.nextIndex),
+      new Fr(this.leafPreimage.nextSlot),
+      ...this.siblingPath.toFields(),
+    ];
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.index, this.leafPreimage, this.siblingPath]);
+  }
+
+  /**
+   * Returns a string representation of the TxEffect object.
+   */
+  toString(): string {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static random() {
+    return new PublicDataWitness(
+      BigInt(Math.floor(Math.random() * 1000)),
+      PublicDataTreeLeafPreimage.random(),
+      SiblingPath.random(PUBLIC_DATA_TREE_HEIGHT),
+    );
+  }
+
+  /**
+   * Deserializes an PublicDataWitness object from a buffer.
+   * @param buf - Buffer or BufferReader to deserialize.
+   * @returns An instance of PublicDataWitness.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): PublicDataWitness {
+    const reader = BufferReader.asReader(buffer);
+
+    return new PublicDataWitness(
+      toBigIntBE(reader.readBytes(32)),
+      reader.readObject(PublicDataTreeLeafPreimage),
+      SiblingPath.fromBuffer(reader.readBytes(4 + 32 * PUBLIC_DATA_TREE_HEIGHT)),
+    );
+  }
+
+  /**
+   * Deserializes an PublicDataWitness object from a string.
+   * @param str - String to deserialize.
+   * @returns An instance of PublicDataWitness.
+   */
+  static fromString(str: string) {
+    return PublicDataWitness.fromBuffer(hexToBuffer(str));
+  }
+}

package/src/tx/block_header.ts

@@ -0,0 +1,197 @@
+import { BLOCK_HEADER_LENGTH, GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+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 { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { ContentCommitment } from './content_commitment.js';
+import { GlobalVariables } from './global_variables.js';
+import { StateReference } from './state_reference.js';
+
+/** A header of an L2 block. */
+export class BlockHeader {
+  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,
+  ) {}
+
+  static get schema(): ZodFor<BlockHeader> {
+    return z
+      .object({
+        lastArchive: AppendOnlyTreeSnapshot.schema,
+        contentCommitment: ContentCommitment.schema,
+        state: StateReference.schema,
+        globalVariables: GlobalVariables.schema,
+        totalFees: schemas.Fr,
+        totalManaUsed: schemas.Fr,
+      })
+      .transform(BlockHeader.from);
+  }
+
+  static getFields(fields: FieldsOf<BlockHeader>) {
+    // Note: The order here must match the order in the HeaderLib solidity library.
+    return [
+      fields.lastArchive,
+      fields.contentCommitment,
+      fields.state,
+      fields.globalVariables,
+      fields.totalFees,
+      fields.totalManaUsed,
+    ] as const;
+  }
+
+  static from(fields: FieldsOf<BlockHeader>) {
+    return new BlockHeader(...BlockHeader.getFields(fields));
+  }
+
+  getSlot() {
+    return this.globalVariables.slotNumber.toBigInt();
+  }
+
+  getSize() {
+    return (
+      this.lastArchive.getSize() +
+      this.contentCommitment.getSize() +
+      this.state.getSize() +
+      this.globalVariables.getSize() +
+      this.totalFees.size +
+      this.totalManaUsed.size
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...BlockHeader.getFields(this));
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...BlockHeader.getFields(this));
+    if (fields.length !== BLOCK_HEADER_LENGTH) {
+      throw new Error(`Invalid number of fields for Header. Expected ${BLOCK_HEADER_LENGTH}, got ${fields.length}`);
+    }
+    return fields;
+  }
+
+  clone(): BlockHeader {
+    return BlockHeader.fromBuffer(this.toBuffer());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): BlockHeader {
+    const reader = BufferReader.asReader(buffer);
+
+    return new BlockHeader(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(ContentCommitment),
+      reader.readObject(StateReference),
+      reader.readObject(GlobalVariables),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+    );
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): BlockHeader {
+    const reader = FieldReader.asReader(fields);
+
+    return new BlockHeader(
+      AppendOnlyTreeSnapshot.fromFields(reader),
+      ContentCommitment.fromFields(reader),
+      StateReference.fromFields(reader),
+      GlobalVariables.fromFields(reader),
+      reader.readField(),
+      reader.readField(),
+    );
+  }
+
+  static empty(fields: Partial<FieldsOf<BlockHeader>> = {}): BlockHeader {
+    return BlockHeader.from({
+      lastArchive: AppendOnlyTreeSnapshot.zero(),
+      contentCommitment: ContentCommitment.empty(),
+      state: StateReference.empty(),
+      globalVariables: GlobalVariables.empty(),
+      totalFees: Fr.ZERO,
+      totalManaUsed: Fr.ZERO,
+      ...fields,
+    });
+  }
+
+  isEmpty(): boolean {
+    return (
+      this.lastArchive.isZero() &&
+      this.contentCommitment.isEmpty() &&
+      this.state.isEmpty() &&
+      this.globalVariables.isEmpty() &&
+      this.totalFees.isZero() &&
+      this.totalManaUsed.isZero()
+    );
+  }
+
+  /**
+   * Serializes this instance into a string.
+   * @returns Encoded string.
+   */
+  public toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string): BlockHeader {
+    return BlockHeader.fromBuffer(hexToBuffer(str));
+  }
+
+  hash(): Promise<Fr> {
+    return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
+  }
+
+  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(),
+    };
+  }
+
+  [inspect.custom]() {
+    return `Header {
+  lastArchive: ${inspect(this.lastArchive)},
+  contentCommitment.numTxs: ${this.contentCommitment.numTxs.toNumber()},
+  contentCommitment.blobsHash: ${this.contentCommitment.blobsHash.toString('hex')},
+  contentCommitment.inHash: ${this.contentCommitment.inHash.toString('hex')},
+  contentCommitment.outHash: ${this.contentCommitment.outHash.toString('hex')},
+  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},
+}`;
+  }
+
+  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)
+    );
+  }
+}