@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/trees/public_data_leaf.js

@@ -0,0 +1,166 @@
+import { toBigIntBE, toBufferBE } from '@aztec-labs/foundation/bigint-buffer';
+import { poseidon2Hash } from '@aztec-labs/foundation/crypto/poseidon';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+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 {
+    leaf;
+    nextKey;
+    nextIndex;
+    constructor(/**
+     * The leaf (slot, value).
+     */ leaf, /**
+     * Next key (slot) inside the indexed tree's linked list.
+     */ nextKey, /**
+     * Index of the next leaf in the indexed tree's linked list.
+     */ nextIndex){
+        this.leaf = leaf;
+        this.nextKey = nextKey;
+        this.nextIndex = nextIndex;
+    }
+    static get schema() {
+        return z.object({
+            leaf: PublicDataTreeLeaf.schema,
+            nextKey: schemas.Fr,
+            nextIndex: schemas.BigInt
+        }).transform(({ leaf, nextKey, nextIndex })=>new PublicDataTreeLeafPreimage(leaf, nextKey, nextIndex));
+    }
+    /**
+   * Creates a PublicDataTreeLeafPreimage from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicDataTreeLeafPreimage fields
+   * @returns A PublicDataTreeLeafPreimage instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof PublicDataTreeLeafPreimage) {
+            return obj;
+        }
+        return new PublicDataTreeLeafPreimage(PublicDataTreeLeaf.fromPlainObject(obj.leaf), Fr.fromPlainObject(obj.nextKey), typeof obj.nextIndex === 'bigint' ? obj.nextIndex : BigInt(obj.nextIndex));
+    }
+    static get leafSchema() {
+        return PublicDataTreeLeaf.schema;
+    }
+    getKey() {
+        return this.leaf.getKey();
+    }
+    getNextKey() {
+        return this.nextKey.toBigInt();
+    }
+    getNextIndex() {
+        return this.nextIndex;
+    }
+    asLeaf() {
+        return this.leaf;
+    }
+    toBuffer() {
+        return Buffer.concat(this.toHashInputs());
+    }
+    toHashInputs() {
+        return [
+            ...this.leaf.toHashInputs(),
+            Buffer.from(this.nextKey.toBuffer()),
+            Buffer.from(toBufferBE(this.nextIndex, 32))
+        ];
+    }
+    hash() {
+        return poseidon2Hash(this.toHashInputs());
+    }
+    clone() {
+        return new PublicDataTreeLeafPreimage(this.leaf.clone(), this.nextKey, this.nextIndex);
+    }
+    static random() {
+        return new PublicDataTreeLeafPreimage(PublicDataTreeLeaf.buildDummy(BigInt(Math.floor(Math.random() * 1000))), Fr.random(), BigInt(Math.floor(Math.random() * 1000)));
+    }
+    static empty() {
+        return new PublicDataTreeLeafPreimage(PublicDataTreeLeaf.empty(), Fr.ZERO, 0n);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PublicDataTreeLeafPreimage(PublicDataTreeLeaf.fromBuffer(reader), Fr.fromBuffer(reader), toBigIntBE(reader.readBytes(32)));
+    }
+    static fromLeaf(leaf, nextKey, nextIndex) {
+        return new PublicDataTreeLeafPreimage(leaf, new Fr(nextKey), nextIndex);
+    }
+    static clone(preimage) {
+        return preimage.clone();
+    }
+}
+/**
+ * A leaf in the public data indexed tree.
+ */ export class PublicDataTreeLeaf {
+    slot;
+    value;
+    constructor(/**
+     * The slot the value is stored in
+     */ slot, /**
+     * The value stored in the slot
+     */ value){
+        this.slot = slot;
+        this.value = value;
+    }
+    getKey() {
+        return this.slot.toBigInt();
+    }
+    toBuffer() {
+        return serializeToBuffer([
+            this.slot,
+            this.value
+        ]);
+    }
+    clone() {
+        return new PublicDataTreeLeaf(this.slot, this.value);
+    }
+    toHashInputs() {
+        return [
+            this.slot.toBuffer(),
+            this.value.toBuffer()
+        ];
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PublicDataTreeLeaf(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+    }
+    equals(another) {
+        return this.slot.equals(another.slot) && this.value.equals(another.value);
+    }
+    toString() {
+        return `PublicDataTreeLeaf(${this.slot.toString()}, ${this.value.toString()})`;
+    }
+    isEmpty() {
+        return this.slot.isZero() && this.value.isZero();
+    }
+    updateTo(another) {
+        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) {
+        return new PublicDataTreeLeaf(new Fr(key), new Fr(0));
+    }
+    static empty() {
+        return new PublicDataTreeLeaf(Fr.ZERO, Fr.ZERO);
+    }
+    static get schema() {
+        return z.object({
+            slot: schemas.Fr,
+            value: schemas.Fr
+        }).transform(({ slot, value })=>new PublicDataTreeLeaf(slot, value));
+    }
+    /**
+   * Creates a PublicDataTreeLeaf from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicDataTreeLeaf fields
+   * @returns A PublicDataTreeLeaf instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof PublicDataTreeLeaf) {
+            return obj;
+        }
+        return new PublicDataTreeLeaf(Fr.fromPlainObject(obj.slot), Fr.fromPlainObject(obj.value));
+    }
+}

package/dest/trees/public_data_witness.d.ts

@@ -0,0 +1,83 @@
+import { PUBLIC_DATA_TREE_HEIGHT } from '@aztec-labs/constants';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+import { MembershipWitness, SiblingPath } from '@aztec-labs/foundation/trees';
+import { z } from 'zod';
+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 declare class PublicDataWitness {
+    /**
+     * The index of the leaf in the public data tree.
+     */
+    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.
+     */
+    readonly leafPreimage: PublicDataTreeLeafPreimage;
+    /**
+     * Sibling path to prove membership of the leaf.
+     */
+    readonly siblingPath: SiblingPath<typeof PUBLIC_DATA_TREE_HEIGHT>;
+    constructor(
+    /**
+     * The index of the leaf in the public data tree.
+     */
+    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.
+     */
+    leafPreimage: PublicDataTreeLeafPreimage, 
+    /**
+     * Sibling path to prove membership of the leaf.
+     */
+    siblingPath: SiblingPath<typeof PUBLIC_DATA_TREE_HEIGHT>);
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        index: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+        leafPreimage: z.ZodPipe<z.ZodObject<{
+            leaf: z.ZodPipe<z.ZodObject<{
+                slot: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+                value: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+            }, z.core.$strip>, z.ZodTransform<import("./public_data_leaf.js").PublicDataTreeLeaf, {
+                slot: import("@aztec-labs/foundation/schemas").Fr;
+                value: import("@aztec-labs/foundation/schemas").Fr;
+            }>>;
+            nextKey: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+            nextIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<PublicDataTreeLeafPreimage, {
+            leaf: import("./public_data_leaf.js").PublicDataTreeLeaf;
+            nextKey: import("@aztec-labs/foundation/schemas").Fr;
+            nextIndex: bigint;
+        }>>;
+        siblingPath: z.ZodPipe<import("../schemas/schemas.js").ZodFor<Buffer<ArrayBufferLike>>, z.ZodTransform<SiblingPath<40>, Buffer<ArrayBufferLike>>>;
+    }, z.core.$strip>, z.ZodTransform<PublicDataWitness, {
+        index: bigint;
+        leafPreimage: PublicDataTreeLeafPreimage;
+        siblingPath: SiblingPath<40>;
+    }>>;
+    toBuffer(): Buffer;
+    /**
+     * Returns a string representation of the TxEffect object.
+     */
+    toString(): string;
+    static random(): PublicDataWitness;
+    withoutPreimage(): MembershipWitness<typeof 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;
+    /**
+     * Deserializes an PublicDataWitness object from a string.
+     * @param str - String to deserialize.
+     * @returns An instance of PublicDataWitness.
+     */
+    static fromString(str: string): PublicDataWitness;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2RhdGFfd2l0bmVzcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RyZWVzL3B1YmxpY19kYXRhX3dpdG5lc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFaEUsT0FBTyxFQUFFLFlBQVksRUFBcUIsTUFBTSxrQ0FBa0MsQ0FBQztBQUVuRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsV0FBVyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDOUUsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUd4QixPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVuRTs7Ozs7R0FLRztBQUNILHFCQUFhLGlCQUFpQjtJQUUxQjs7T0FFRzthQUNhLEtBQUssRUFBRSxNQUFNO0lBQzdCOzs7T0FHRzthQUNhLFlBQVksRUFBRSwwQkFBMEI7SUFDeEQ7O09BRUc7YUFDYSxXQUFXLEVBQUUsV0FBVyxDQUFDLE9BQU8sdUJBQXVCLENBQUM7SUFiMUU7SUFDRTs7T0FFRztJQUNhLEtBQUssRUFBRSxNQUFNO0lBQzdCOzs7T0FHRztJQUNhLFlBQVksRUFBRSwwQkFBMEI7SUFDeEQ7O09BRUc7SUFDYSxXQUFXLEVBQUUsV0FBVyxDQUFDLE9BQU8sdUJBQXVCLENBQUMsRUFDdEU7SUFFSixNQUFNLEtBQUssTUFBTTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztRQVFoQjtJQUVELFFBQVEsSUFBSSxNQUFNLENBRWpCO0lBRUQ7O09BRUc7SUFDSCxRQUFRLElBQUksTUFBTSxDQUVqQjtJQUVELE1BQU0sQ0FBQyxNQUFNLHNCQU1aO0lBRU0sZUFBZSxJQUFJLGlCQUFpQixDQUFDLE9BQU8sdUJBQXVCLENBQUMsQ0FFMUU7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxpQkFBaUIsQ0FRbEU7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxxQkFFNUI7Q0FDRiJ9

package/dest/trees/public_data_witness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_data_witness.d.ts","sourceRoot":"","sources":["../../src/trees/public_data_witness.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AAEnF,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAEnE;;;;;GAKG;AACH,qBAAa,iBAAiB;IAE1B;;OAEG;aACa,KAAK,EAAE,MAAM;IAC7B;;;OAGG;aACa,YAAY,EAAE,0BAA0B;IACxD;;OAEG;aACa,WAAW,EAAE,WAAW,CAAC,OAAO,uBAAuB,CAAC;IAb1E;IACE;;OAEG;IACa,KAAK,EAAE,MAAM;IAC7B;;;OAGG;IACa,YAAY,EAAE,0BAA0B;IACxD;;OAEG;IACa,WAAW,EAAE,WAAW,CAAC,OAAO,uBAAuB,CAAC,EACtE;IAEJ,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;QAQhB;IAED,QAAQ,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,QAAQ,IAAI,MAAM,CAEjB;IAED,MAAM,CAAC,MAAM,sBAMZ;IAEM,eAAe,IAAI,iBAAiB,CAAC,OAAO,uBAAuB,CAAC,CAE1E;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,iBAAiB,CAQlE;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,qBAE5B;CACF"}

package/dest/trees/public_data_witness.js

@@ -0,0 +1,70 @@
+import { PUBLIC_DATA_TREE_HEIGHT } from '@aztec-labs/constants';
+import { toBigIntBE } from '@aztec-labs/foundation/bigint-buffer';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+import { MembershipWitness, SiblingPath } from '@aztec-labs/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 {
+    index;
+    leafPreimage;
+    siblingPath;
+    constructor(/**
+     * The index of the leaf in the public data tree.
+     */ index, /**
+     * 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.
+     */ leafPreimage, /**
+     * Sibling path to prove membership of the leaf.
+     */ siblingPath){
+        this.index = index;
+        this.leafPreimage = leafPreimage;
+        this.siblingPath = siblingPath;
+    }
+    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));
+    }
+    toBuffer() {
+        return serializeToBuffer([
+            this.index,
+            this.leafPreimage,
+            this.siblingPath
+        ]);
+    }
+    /**
+   * Returns a string representation of the TxEffect object.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static random() {
+        return new PublicDataWitness(BigInt(Math.floor(Math.random() * 1000)), PublicDataTreeLeafPreimage.random(), SiblingPath.random(PUBLIC_DATA_TREE_HEIGHT));
+    }
+    withoutPreimage() {
+        return new MembershipWitness(PUBLIC_DATA_TREE_HEIGHT, this.index, this.siblingPath.toTuple());
+    }
+    /**
+   * Deserializes an PublicDataWitness object from a buffer.
+   * @param buf - Buffer or BufferReader to deserialize.
+   * @returns An instance of PublicDataWitness.
+   */ static fromBuffer(buffer) {
+        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) {
+        return PublicDataWitness.fromBuffer(hexToBuffer(str));
+    }
+}

package/dest/tx/block_header.d.ts

@@ -0,0 +1,97 @@
+import { BlockNumber, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type ZodFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, BufferSink, FieldReader } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { inspect } from 'util';
+import { BlockHash } from '../block/block_hash.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { GlobalVariables } from './global_variables.js';
+import { StateReference } from './state_reference.js';
+/** A header of an L2 block. */
+export declare class BlockHeader {
+    /** Snapshot of archive before the block is applied. */
+    readonly lastArchive: AppendOnlyTreeSnapshot;
+    /** State reference. */
+    readonly state: StateReference;
+    /**
+     * Hash of the sponge blob after the tx effects of this block has been applied.
+     * May contain tx effects from the previous blocks in the same checkpoint.
+     */
+    readonly spongeBlobHash: Fr;
+    /** Global variables of an L2 block. */
+    readonly globalVariables: GlobalVariables;
+    /** Total fees in the block, computed by the root rollup circuit */
+    readonly totalFees: Fr;
+    /** Total mana used in the block, computed by the root rollup circuit */
+    readonly totalManaUsed: Fr;
+    private _cachedHash?;
+    constructor(
+    /** Snapshot of archive before the block is applied. */
+    lastArchive: AppendOnlyTreeSnapshot, 
+    /** State reference. */
+    state: StateReference, 
+    /**
+     * Hash of the sponge blob after the tx effects of this block has been applied.
+     * May contain tx effects from the previous blocks in the same checkpoint.
+     */
+    spongeBlobHash: Fr, 
+    /** Global variables of an L2 block. */
+    globalVariables: GlobalVariables, 
+    /** Total fees in the block, computed by the root rollup circuit */
+    totalFees: Fr, 
+    /** Total mana used in the block, computed by the root rollup circuit */
+    totalManaUsed: Fr);
+    static get schema(): ZodFor<BlockHeader>;
+    static getFields(fields: FieldsOf<BlockHeader>): readonly [AppendOnlyTreeSnapshot, StateReference, Fr, GlobalVariables, Fr, Fr];
+    static from(fields: FieldsOf<BlockHeader>): BlockHeader;
+    getSlot(): SlotNumber;
+    getBlockNumber(): BlockNumber;
+    getSize(): number;
+    toBuffer(): Buffer;
+    toBuffer(sink: BufferSink): void;
+    toFields(): Fr[];
+    clone(): BlockHeader;
+    static fromBuffer(buffer: Buffer | BufferReader): BlockHeader;
+    static fromFields(fields: Fr[] | FieldReader): BlockHeader;
+    static empty(fields?: Partial<FieldsOf<BlockHeader>>): BlockHeader;
+    isEmpty(): boolean;
+    /**
+     * Serializes this instance into a string.
+     * @returns Encoded string.
+     */
+    toString(): `0x${string}`;
+    static fromString(str: string): BlockHeader;
+    hash(): Promise<BlockHash>;
+    /** Manually set the hash for this block header if already computed */
+    setHash(hashed: BlockHash): void;
+    /** Recomputes the cached hash. Used for testing when header fields are mutated via unfreeze. */
+    recomputeHash(): Promise<BlockHash>;
+    static random(overrides?: Partial<FieldsOf<BlockHeader>> & Partial<FieldsOf<GlobalVariables>>): BlockHeader;
+    toInspect(): {
+        lastArchive: `0x${string}`;
+        state: {
+            l1ToL2MessageTree: `0x${string}`;
+            noteHashTree: `0x${string}`;
+            nullifierTree: `0x${string}`;
+            publicDataTree: `0x${string}`;
+        };
+        spongeBlobHash: bigint;
+        globalVariables: {
+            chainId: number;
+            version: number;
+            blockNumber: BlockNumber;
+            slotNumber: SlotNumber;
+            timestamp: bigint;
+            coinbase: `0x${string}`;
+            feeRecipient: `0x${string}`;
+            feePerDaGas: number;
+            feePerL2Gas: number;
+        };
+        totalFees: bigint;
+        totalManaUsed: bigint;
+    };
+    [inspect.custom](): string;
+    equals(other: this): boolean;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/tx/block_header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_header.d.ts","sourceRoot":"","sources":["../../src/tx/block_header.ts"],"names":[],"mappings":"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"}

package/dest/tx/block_header.js

@@ -0,0 +1,164 @@
+var _computedKey;
+import { BLOCK_HEADER_LENGTH, DomainSeparator } from '@aztec-labs/constants';
+import { poseidon2HashWithSeparator } from '@aztec-labs/foundation/crypto/poseidon';
+import { randomInt } from '@aztec-labs/foundation/crypto/random';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { BlockHash } from '../block/block_hash.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { GlobalVariables } from './global_variables.js';
+import { StateReference } from './state_reference.js';
+_computedKey = inspect.custom;
+/** A header of an L2 block. */ export class BlockHeader {
+    lastArchive;
+    state;
+    spongeBlobHash;
+    globalVariables;
+    totalFees;
+    totalManaUsed;
+    _cachedHash;
+    constructor(/** Snapshot of archive before the block is applied. */ lastArchive, /** State reference. */ state, /**
+     * Hash of the sponge blob after the tx effects of this block has been applied.
+     * May contain tx effects from the previous blocks in the same checkpoint.
+     */ spongeBlobHash, /** Global variables of an L2 block. */ globalVariables, /** Total fees in the block, computed by the root rollup circuit */ totalFees, /** Total mana used in the block, computed by the root rollup circuit */ totalManaUsed){
+        this.lastArchive = lastArchive;
+        this.state = state;
+        this.spongeBlobHash = spongeBlobHash;
+        this.globalVariables = globalVariables;
+        this.totalFees = totalFees;
+        this.totalManaUsed = totalManaUsed;
+    }
+    static get schema() {
+        return z.object({
+            lastArchive: AppendOnlyTreeSnapshot.schema,
+            state: StateReference.schema,
+            spongeBlobHash: schemas.Fr,
+            globalVariables: GlobalVariables.schema,
+            totalFees: schemas.Fr,
+            totalManaUsed: schemas.Fr
+        }).transform(BlockHeader.from);
+    }
+    static getFields(fields) {
+        return [
+            fields.lastArchive,
+            fields.state,
+            fields.spongeBlobHash,
+            fields.globalVariables,
+            fields.totalFees,
+            fields.totalManaUsed
+        ];
+    }
+    static from(fields) {
+        return new BlockHeader(...BlockHeader.getFields(fields));
+    }
+    getSlot() {
+        return this.globalVariables.slotNumber;
+    }
+    getBlockNumber() {
+        return this.globalVariables.blockNumber;
+    }
+    getSize() {
+        return this.lastArchive.getSize() + this.state.getSize() + this.spongeBlobHash.size + this.globalVariables.getSize() + this.totalFees.size + this.totalManaUsed.size;
+    }
+    toBuffer(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        serializeToSink(sink, ...BlockHeader.getFields(this));
+    }
+    toFields() {
+        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() {
+        return BlockHeader.fromBuffer(this.toBuffer());
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new BlockHeader(reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(StateReference), reader.readObject(Fr), reader.readObject(GlobalVariables), reader.readObject(Fr), reader.readObject(Fr));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new BlockHeader(AppendOnlyTreeSnapshot.fromFields(reader), StateReference.fromFields(reader), reader.readField(), GlobalVariables.fromFields(reader), reader.readField(), reader.readField());
+    }
+    static empty(fields = {}) {
+        return BlockHeader.from({
+            lastArchive: AppendOnlyTreeSnapshot.empty(),
+            state: StateReference.empty(),
+            spongeBlobHash: Fr.ZERO,
+            globalVariables: GlobalVariables.empty(),
+            totalFees: Fr.ZERO,
+            totalManaUsed: Fr.ZERO,
+            ...fields
+        });
+    }
+    isEmpty() {
+        return this.lastArchive.isEmpty() && this.state.isEmpty() && this.spongeBlobHash.isZero() && this.globalVariables.isEmpty() && this.totalFees.isZero() && this.totalManaUsed.isZero();
+    }
+    /**
+   * Serializes this instance into a string.
+   * @returns Encoded string.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static fromString(str) {
+        return BlockHeader.fromBuffer(hexToBuffer(str));
+    }
+    hash() {
+        if (!this._cachedHash) {
+            this._cachedHash = poseidon2HashWithSeparator(this.toFields(), DomainSeparator.BLOCK_HEADER_HASH).then((fr)=>new BlockHash(fr));
+        }
+        return this._cachedHash;
+    }
+    /** Manually set the hash for this block header if already computed */ setHash(hashed) {
+        this._cachedHash = Promise.resolve(hashed);
+    }
+    /** Recomputes the cached hash. Used for testing when header fields are mutated via unfreeze. */ recomputeHash() {
+        this._cachedHash = undefined;
+        return this.hash();
+    }
+    static random(overrides = {}) {
+        return BlockHeader.from({
+            lastArchive: AppendOnlyTreeSnapshot.random(),
+            state: StateReference.random(),
+            spongeBlobHash: Fr.random(),
+            globalVariables: GlobalVariables.random(overrides),
+            totalFees: new Fr(randomInt(100_000)),
+            totalManaUsed: new Fr(randomInt(100_000_000)),
+            ...overrides
+        });
+    }
+    toInspect() {
+        return {
+            lastArchive: this.lastArchive.root.toString(),
+            state: this.state.toInspect(),
+            spongeBlobHash: this.spongeBlobHash.toBigInt(),
+            globalVariables: this.globalVariables.toInspect(),
+            totalFees: this.totalFees.toBigInt(),
+            totalManaUsed: this.totalManaUsed.toBigInt()
+        };
+    }
+    [_computedKey]() {
+        return `Header {
+  lastArchive: ${inspect(this.lastArchive)},
+  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)},
+  spongeBlobHash: ${this.spongeBlobHash},
+  globalVariables: ${inspect(this.globalVariables)},
+  totalFees: ${this.totalFees},
+  totalManaUsed: ${this.totalManaUsed},
+}`;
+    }
+    equals(other) {
+        return this.lastArchive.equals(other.lastArchive) && this.state.equals(other.state) && this.spongeBlobHash.equals(other.spongeBlobHash) && this.globalVariables.equals(other.globalVariables) && this.totalFees.equals(other.totalFees) && this.totalManaUsed.equals(other.totalManaUsed);
+    }
+}