@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/trees/public_data_leaf.js

@@ -0,0 +1,130 @@
+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 { 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 {
+    slot;
+    value;
+    nextSlot;
+    nextIndex;
+    constructor(/**
+     * The slot of the leaf
+     */ slot, /**
+     * The value of the leaf
+     */ value, /**
+     * Next value inside the indexed tree's linked list.
+     */ nextSlot, /**
+     * Index of the next leaf in the indexed tree's linked list.
+     */ nextIndex){
+        this.slot = slot;
+        this.value = value;
+        this.nextSlot = nextSlot;
+        this.nextIndex = nextIndex;
+    }
+    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() {
+        return this.slot.toBigInt();
+    }
+    getNextKey() {
+        return this.nextSlot.toBigInt();
+    }
+    getNextIndex() {
+        return this.nextIndex;
+    }
+    asLeaf() {
+        return new PublicDataTreeLeaf(this.slot, this.value);
+    }
+    toBuffer() {
+        return Buffer.concat(this.toHashInputs());
+    }
+    toHashInputs() {
+        return [
+            Buffer.from(this.slot.toBuffer()),
+            Buffer.from(this.value.toBuffer()),
+            Buffer.from(toBufferBE(this.nextIndex, 32)),
+            Buffer.from(this.nextSlot.toBuffer())
+        ];
+    }
+    clone() {
+        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() {
+        return new PublicDataTreeLeafPreimage(Fr.ZERO, Fr.ZERO, Fr.ZERO, 0n);
+    }
+    static fromBuffer(buffer) {
+        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, nextKey, nextIndex) {
+        return new PublicDataTreeLeafPreimage(leaf.slot, leaf.value, new Fr(nextKey), nextIndex);
+    }
+    static clone(preimage) {
+        return new PublicDataTreeLeafPreimage(preimage.slot, preimage.value, preimage.nextSlot, preimage.nextIndex);
+    }
+}
+/**
+ * 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
+        ]);
+    }
+    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);
+    }
+}

package/dest/trees/public_data_witness.d.ts

@@ -0,0 +1,142 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { SiblingPath } from '@aztec/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.ZodEffects<z.ZodObject<{
+        index: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+        leafPreimage: z.ZodEffects<z.ZodObject<{
+            slot: z.ZodType<Fr, any, string>;
+            value: z.ZodType<Fr, any, string>;
+            nextSlot: z.ZodType<Fr, any, string>;
+            nextIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+        }, "strip", z.ZodTypeAny, {
+            value: Fr;
+            slot: Fr;
+            nextIndex: bigint;
+            nextSlot: Fr;
+        }, {
+            value: string;
+            slot: string;
+            nextIndex: string | number | bigint;
+            nextSlot: string;
+        }>, PublicDataTreeLeafPreimage, {
+            value: string;
+            slot: string;
+            nextIndex: string | number | bigint;
+            nextSlot: string;
+        }>;
+        siblingPath: z.ZodEffects<z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Buffer, string>, z.ZodEffects<z.ZodObject<{
+            type: z.ZodLiteral<"Buffer">;
+            data: z.ZodArray<z.ZodNumber, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "Buffer";
+            data: number[];
+        }, {
+            type: "Buffer";
+            data: number[]; /**
+             * Deserializes an PublicDataWitness object from a buffer.
+             * @param buf - Buffer or BufferReader to deserialize.
+             * @returns An instance of PublicDataWitness.
+             */
+        }>, Buffer, {
+            type: "Buffer";
+            data: number[];
+        }>]>, SiblingPath<40>, string | {
+            type: "Buffer";
+            data: number[];
+        }>, SiblingPath<40>, string | {
+            type: "Buffer";
+            data: number[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        index: bigint;
+        siblingPath: SiblingPath<40>;
+        leafPreimage: PublicDataTreeLeafPreimage;
+    }, {
+        index: string | number | bigint;
+        siblingPath: string | {
+            type: "Buffer";
+            data: number[];
+        };
+        leafPreimage: {
+            value: string;
+            slot: string;
+            nextIndex: string | number | bigint;
+            nextSlot: string;
+        };
+    }>, PublicDataWitness, {
+        index: string | number | bigint;
+        siblingPath: string | {
+            type: "Buffer";
+            data: number[];
+        };
+        leafPreimage: {
+            value: string;
+            slot: string;
+            nextIndex: string | number | bigint;
+            nextSlot: string;
+        };
+    }>;
+    /**
+     * Returns a field array representation of a public data witness.
+     * @returns A field array representation of a public data witness.
+     */
+    toFields(): Fr[];
+    toBuffer(): Buffer;
+    /**
+     * Returns a string representation of the TxEffect object.
+     */
+    toString(): string;
+    static random(): PublicDataWitness;
+    /**
+     * 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=public_data_witness.d.ts.map

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,kBAAkB,CAAC;AAE3D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,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;;IAZxE;;OAEG;IACa,KAAK,EAAE,MAAM;IAC7B;;;OAGG;IACa,YAAY,EAAE,0BAA0B;IACxD;;OAEG;IACa,WAAW,EAAE,WAAW,CAAC,OAAO,uBAAuB,CAAC;IAG1E,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA4CjB;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAxCF;IAED;;;OAGG;IACI,QAAQ,IAAI,EAAE,EAAE;IAWvB,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,MAAM;IAQb;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,iBAAiB;IAUnE;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM;CAG9B"}

package/dest/trees/public_data_witness.js

@@ -0,0 +1,81 @@
+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 {
+    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));
+    }
+    /**
+   * Returns a field array representation of a public data witness.
+   * @returns A field array representation of a public data witness.
+   */ toFields() {
+        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() {
+        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));
+    }
+    /**
+   * 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,90 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { inspect } from 'util';
+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 declare class BlockHeader {
+    /** Snapshot of archive before the block is applied. */
+    lastArchive: AppendOnlyTreeSnapshot;
+    /** Hash of the body of an L2 block. */
+    contentCommitment: ContentCommitment;
+    /** State reference. */
+    state: StateReference;
+    /** 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;
+    constructor(
+    /** Snapshot of archive before the block is applied. */
+    lastArchive: AppendOnlyTreeSnapshot, 
+    /** Hash of the body of an L2 block. */
+    contentCommitment: ContentCommitment, 
+    /** State reference. */
+    state: StateReference, 
+    /** 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, ContentCommitment, StateReference, GlobalVariables, Fr, Fr];
+    static from(fields: FieldsOf<BlockHeader>): BlockHeader;
+    getSlot(): bigint;
+    getSize(): number;
+    toBuffer(): Buffer;
+    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<Fr>;
+    toInspect(): {
+        lastArchive: `0x${string}`;
+        contentCommitment: {
+            numTxs: number;
+            blobsHash: `0x${string}`;
+            inHash: `0x${string}`;
+            outHash: `0x${string}`;
+        };
+        state: {
+            l1ToL2MessageTree: `0x${string}`;
+            noteHashTree: `0x${string}`;
+            nullifierTree: `0x${string}`;
+            publicDataTree: `0x${string}`;
+        };
+        globalVariables: {
+            chainId: number;
+            version: number;
+            blockNumber: number;
+            slotNumber: number;
+            timestamp: number;
+            coinbase: `0x${string}`;
+            feeRecipient: `0x${string}`;
+            feePerDaGas: number;
+            feePerL2Gas: number;
+        };
+        totalFees: bigint;
+        totalManaUsed: bigint;
+    };
+    [inspect.custom](): string;
+    equals(other: this): boolean;
+}
+//# sourceMappingURL=block_header.d.ts.map

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":";;;AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAwC,MAAM,6BAA6B,CAAC;AAE9G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAG/B,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,+BAA+B;AAC/B,qBAAa,WAAW;IAEpB,uDAAuD;IAChD,WAAW,EAAE,sBAAsB;IAC1C,uCAAuC;IAChC,iBAAiB,EAAE,iBAAiB;IAC3C,uBAAuB;IAChB,KAAK,EAAE,cAAc;IAC5B,uCAAuC;IAChC,eAAe,EAAE,eAAe;IACvC,mEAAmE;IAC5D,SAAS,EAAE,EAAE;IACpB,wEAAwE;IACjE,aAAa,EAAE,EAAE;;IAXxB,uDAAuD;IAChD,WAAW,EAAE,sBAAsB;IAC1C,uCAAuC;IAChC,iBAAiB,EAAE,iBAAiB;IAC3C,uBAAuB;IAChB,KAAK,EAAE,cAAc;IAC5B,uCAAuC;IAChC,eAAe,EAAE,eAAe;IACvC,mEAAmE;IAC5D,SAAS,EAAE,EAAE;IACpB,wEAAwE;IACjE,aAAa,EAAE,EAAE;IAG1B,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,WAAW,CAAC,CAWvC;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC;IAY9C,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC;IAIzC,OAAO;IAIP,OAAO;IAWP,QAAQ;IAIR,QAAQ,IAAI,EAAE,EAAE;IAQhB,KAAK,IAAI,WAAW;IAIpB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,WAAW;IAa7D,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,WAAW;IAa1D,MAAM,CAAC,KAAK,CAAC,MAAM,GAAE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAM,GAAG,WAAW;IAYtE,OAAO,IAAI,OAAO;IAWlB;;;OAGG;IACI,QAAQ;IAIf,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW;IAI3C,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC;IAInB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWT,CAAC,OAAO,CAAC,MAAM,CAAC;IAiBT,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;CAUpC"}

package/dest/tx/block_header.js

@@ -0,0 +1,134 @@
+import { BLOCK_HEADER_LENGTH, GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+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 {
+    lastArchive;
+    contentCommitment;
+    state;
+    globalVariables;
+    totalFees;
+    totalManaUsed;
+    constructor(/** Snapshot of archive before the block is applied. */ lastArchive, /** Hash of the body of an L2 block. */ contentCommitment, /** State reference. */ state, /** 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.contentCommitment = contentCommitment;
+        this.state = state;
+        this.globalVariables = globalVariables;
+        this.totalFees = totalFees;
+        this.totalManaUsed = totalManaUsed;
+    }
+    static get schema() {
+        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) {
+        // 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
+        ];
+    }
+    static from(fields) {
+        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() {
+        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(ContentCommitment), reader.readObject(StateReference), reader.readObject(GlobalVariables), reader.readObject(Fr), reader.readObject(Fr));
+    }
+    static fromFields(fields) {
+        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 = {}) {
+        return BlockHeader.from({
+            lastArchive: AppendOnlyTreeSnapshot.zero(),
+            contentCommitment: ContentCommitment.empty(),
+            state: StateReference.empty(),
+            globalVariables: GlobalVariables.empty(),
+            totalFees: Fr.ZERO,
+            totalManaUsed: Fr.ZERO,
+            ...fields
+        });
+    }
+    isEmpty() {
+        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.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static fromString(str) {
+        return BlockHeader.fromBuffer(hexToBuffer(str));
+    }
+    hash() {
+        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},
+}`;
+    }
+    equals(other) {
+        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);
+    }
+}

package/dest/tx/call_context.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { FunctionSelector } from '../abi/index.js';
+import { AztecAddress } from '../aztec-address/index.js';
+/**
+ * Call context.
+ */
+export declare class CallContext {
+    /**
+     * Address of the account which represents the entity who invoked the call.
+     */
+    msgSender: AztecAddress;
+    /**
+     * The contract address being called.
+     */
+    contractAddress: AztecAddress;
+    /**
+     * Function selector of the function being called.
+     */
+    functionSelector: FunctionSelector;
+    /**
+     * Determines whether the call is modifying state.
+     */
+    isStaticCall: boolean;
+    constructor(
+    /**
+     * Address of the account which represents the entity who invoked the call.
+     */
+    msgSender: AztecAddress, 
+    /**
+     * The contract address being called.
+     */
+    contractAddress: AztecAddress, 
+    /**
+     * Function selector of the function being called.
+     */
+    functionSelector: FunctionSelector, 
+    /**
+     * Determines whether the call is modifying state.
+     */
+    isStaticCall: boolean);
+    /**
+     * Returns a new instance of CallContext with zero msg sender, storage contract address.
+     * @returns A new instance of CallContext with zero msg sender, storage contract address.
+     */
+    static empty(): CallContext;
+    static random(): Promise<CallContext>;
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        msgSender: import("../schemas/index.js").ZodFor<AztecAddress>;
+        contractAddress: import("../schemas/index.js").ZodFor<AztecAddress>;
+        functionSelector: import("../schemas/index.js").ZodFor<FunctionSelector>;
+        isStaticCall: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        contractAddress: AztecAddress;
+        msgSender: AztecAddress;
+        functionSelector: FunctionSelector;
+        isStaticCall: boolean;
+    }, {
+        isStaticCall: boolean;
+        contractAddress?: any;
+        msgSender?: any;
+        functionSelector?: any;
+    }>, CallContext, {
+        isStaticCall: boolean;
+        contractAddress?: any;
+        msgSender?: any;
+        functionSelector?: any;
+    }>;
+    isEmpty(): boolean;
+    static from(fields: FieldsOf<CallContext>): CallContext;
+    static getFields(fields: FieldsOf<CallContext>): readonly [AztecAddress, AztecAddress, FunctionSelector, boolean];
+    /**
+     * Serialize this as a buffer.
+     * @returns The buffer.
+     */
+    toBuffer(): Buffer;
+    toFields(): Fr[];
+    /**
+     * Deserialize this from a buffer.
+     * @param buffer - The bufferable type from which to deserialize.
+     * @returns The deserialized instance of CallContext.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): CallContext;
+    static fromFields(fields: Fr[] | FieldReader): CallContext;
+    equals(callContext: CallContext): boolean;
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=call_context.d.ts.map