@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.d3ec352c

package/dest/block/l2_block_header.js

@@ -23,7 +23,8 @@ import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from
     totalFees;
     totalManaUsed;
     spongeBlobHash;
-    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, /** Hash of the sponge blob of the block. */ spongeBlobHash){
+    blockHeadersHash;
+    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, /** Hash of the sponge blob of the block. */ spongeBlobHash, /** Hash of the block headers in the checkpoint. */ blockHeadersHash){
         this.lastArchive = lastArchive;
         this.contentCommitment = contentCommitment;
         this.state = state;
@@ -31,6 +32,7 @@ import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from
         this.totalFees = totalFees;
         this.totalManaUsed = totalManaUsed;
         this.spongeBlobHash = spongeBlobHash;
+        this.blockHeadersHash = blockHeadersHash;
     }
     static get schema() {
         return z.object({
@@ -40,7 +42,8 @@ import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from
             globalVariables: GlobalVariables.schema,
             totalFees: schemas.Fr,
             totalManaUsed: schemas.Fr,
-            spongeBlobHash: schemas.Fr
+            spongeBlobHash: schemas.Fr,
+            blockHeadersHash: schemas.Fr
         }).transform(L2BlockHeader.from);
     }
     static getFields(fields) {
@@ -51,20 +54,21 @@ import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from
             fields.globalVariables,
             fields.totalFees,
             fields.totalManaUsed,
-            fields.spongeBlobHash
+            fields.spongeBlobHash,
+            fields.blockHeadersHash
         ];
     }
     static from(fields) {
         return new L2BlockHeader(...L2BlockHeader.getFields(fields));
     }
     getSlot() {
-        return this.globalVariables.slotNumber.toBigInt();
+        return this.globalVariables.slotNumber;
     }
     getBlockNumber() {
         return this.globalVariables.blockNumber;
     }
     getSize() {
-        return this.lastArchive.getSize() + this.contentCommitment.getSize() + this.state.getSize() + this.globalVariables.getSize() + this.totalFees.size + this.totalManaUsed.size + this.spongeBlobHash.size;
+        return this.lastArchive.getSize() + this.contentCommitment.getSize() + this.state.getSize() + this.globalVariables.getSize() + this.totalFees.size + this.totalManaUsed.size + this.spongeBlobHash.size + this.blockHeadersHash.size;
     }
     toBuffer() {
         return serializeToBuffer(...L2BlockHeader.getFields(this));
@@ -77,11 +81,11 @@ import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from
     }
     static fromBuffer(buffer) {
         const reader = BufferReader.asReader(buffer);
-        return new L2BlockHeader(reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(ContentCommitment), reader.readObject(StateReference), reader.readObject(GlobalVariables), reader.readObject(Fr), reader.readObject(Fr), reader.readObject(Fr));
+        return new L2BlockHeader(reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(ContentCommitment), reader.readObject(StateReference), reader.readObject(GlobalVariables), reader.readObject(Fr), reader.readObject(Fr), reader.readObject(Fr), reader.readObject(Fr));
     }
     static fromFields(fields) {
         const reader = FieldReader.asReader(fields);
-        return new L2BlockHeader(AppendOnlyTreeSnapshot.fromFields(reader), ContentCommitment.fromFields(reader), StateReference.fromFields(reader), GlobalVariables.fromFields(reader), reader.readField(), reader.readField(), reader.readField());
+        return new L2BlockHeader(AppendOnlyTreeSnapshot.fromFields(reader), ContentCommitment.fromFields(reader), StateReference.fromFields(reader), GlobalVariables.fromFields(reader), reader.readField(), reader.readField(), reader.readField(), reader.readField());
     }
     static empty(fields = {}) {
         return L2BlockHeader.from({
@@ -92,11 +96,12 @@ import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from
             totalFees: Fr.ZERO,
             totalManaUsed: Fr.ZERO,
             spongeBlobHash: Fr.ZERO,
+            blockHeadersHash: Fr.ZERO,
             ...fields
         });
     }
     isEmpty() {
-        return this.lastArchive.isEmpty() && this.contentCommitment.isEmpty() && this.state.isEmpty() && this.globalVariables.isEmpty() && this.totalFees.isZero() && this.totalManaUsed.isZero() && this.spongeBlobHash.isZero();
+        return this.lastArchive.isEmpty() && this.contentCommitment.isEmpty() && this.state.isEmpty() && this.globalVariables.isEmpty() && this.totalFees.isZero() && this.totalManaUsed.isZero() && this.spongeBlobHash.isZero() && this.blockHeadersHash.isZero();
     }
     /**
    * Serializes this instance into a string.
@@ -108,7 +113,7 @@ import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from
         return L2BlockHeader.fromBuffer(hexToBuffer(str));
     }
     toCheckpointHeader() {
-        return new CheckpointHeader(this.lastArchive.root, this.contentCommitment, this.globalVariables.slotNumber, this.globalVariables.timestamp, this.globalVariables.coinbase, this.globalVariables.feeRecipient, this.globalVariables.gasFees, this.totalManaUsed);
+        return new CheckpointHeader(this.lastArchive.root, this.blockHeadersHash, this.contentCommitment, this.globalVariables.slotNumber, this.globalVariables.timestamp, this.globalVariables.coinbase, this.globalVariables.feeRecipient, this.globalVariables.gasFees, this.totalManaUsed);
     }
     toBlockHeader() {
         return new BlockHeader(this.lastArchive, this.state, this.spongeBlobHash, this.globalVariables, this.totalFees, this.totalManaUsed);
@@ -121,7 +126,8 @@ import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from
             globalVariables: this.globalVariables.toInspect(),
             totalFees: this.totalFees.toBigInt(),
             totalManaUsed: this.totalManaUsed.toBigInt(),
-            spongeBlobHash: this.spongeBlobHash.toString()
+            spongeBlobHash: this.spongeBlobHash.toString(),
+            blockHeadersHash: this.blockHeadersHash.toString()
         };
     }
     [inspect.custom]() {
@@ -138,9 +144,10 @@ import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from
   totalFees: ${this.totalFees},
   totalManaUsed: ${this.totalManaUsed},
   spongeBlobHash: ${this.spongeBlobHash},
+  blockHeadersHash: ${this.blockHeadersHash},
 }`;
     }
     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) && this.spongeBlobHash.equals(other.spongeBlobHash);
+        return this.contentCommitment.equals(other.contentCommitment) && this.state.equals(other.state) && this.globalVariables.equals(other.globalVariables) && this.totalFees.equals(other.totalFees) && this.totalManaUsed.equals(other.totalManaUsed) && this.lastArchive.equals(other.lastArchive) && this.spongeBlobHash.equals(other.spongeBlobHash) && this.blockHeadersHash.equals(other.blockHeadersHash);
     }
 }

package/dest/block/l2_block_info.d.ts

@@ -1,3 +1,4 @@
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { z } from 'zod';
@@ -5,37 +6,41 @@ export type L2BlockInfo = {
     blockHash?: Fr;
     archive: Fr;
     lastArchive: Fr;
-    blockNumber: number;
-    slotNumber: number;
+    blockNumber: BlockNumber;
+    slotNumber: SlotNumber;
     txCount: number;
     timestamp: bigint;
 };
-export declare function randomBlockInfo(blockNumber?: number): L2BlockInfo;
+export declare function randomBlockInfo(blockNumber?: BlockNumber | number): L2BlockInfo;
 export declare const BlockInfoSchema: z.ZodObject<{
     blockHash: z.ZodOptional<z.ZodType<Fr, any, string>>;
     archive: z.ZodType<Fr, any, string>;
     lastArchive: z.ZodType<Fr, any, string>;
-    blockNumber: z.ZodNumber;
-    slotNumber: z.ZodNumber;
+    blockNumber: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodNumber>, BlockNumber, string | number | bigint>;
+    slotNumber: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodNumber>, SlotNumber, string | number | bigint>;
     txCount: z.ZodNumber;
     timestamp: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
 }, "strip", z.ZodTypeAny, {
-    blockNumber: number;
-    slotNumber: number;
-    timestamp: bigint;
-    lastArchive: Fr;
+    blockHash?: Fr | undefined;
     archive: Fr;
+    lastArchive: Fr;
+    blockNumber: number & {
+        _branding: "BlockNumber";
+    };
+    slotNumber: number & {
+        _branding: "SlotNumber";
+    };
     txCount: number;
-    blockHash?: Fr | undefined;
+    timestamp: bigint;
 }, {
-    blockNumber: number;
-    slotNumber: number;
-    timestamp: string | number | bigint;
-    lastArchive: string;
+    blockHash?: string | undefined;
     archive: string;
+    lastArchive: string;
+    blockNumber: string | number | bigint;
+    slotNumber: string | number | bigint;
     txCount: number;
-    blockHash?: string | undefined;
+    timestamp: string | number | bigint;
 }>;
 export declare function serializeBlockInfo(blockInfo: L2BlockInfo): Buffer;
 export declare function deserializeBlockInfo(buffer: Buffer | BufferReader): L2BlockInfo;
-//# sourceMappingURL=l2_block_info.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDJfYmxvY2tfaW5mby5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Jsb2NrL2wyX2Jsb2NrX2luZm8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBcUIsVUFBVSxFQUFvQixNQUFNLGlDQUFpQyxDQUFDO0FBQy9HLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUU5QyxPQUFPLEVBQUUsWUFBWSxFQUFxQixNQUFNLDZCQUE2QixDQUFDO0FBRTlFLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsTUFBTSxNQUFNLFdBQVcsR0FBRztJQUN4QixTQUFTLENBQUMsRUFBRSxFQUFFLENBQUM7SUFDZixPQUFPLEVBQUUsRUFBRSxDQUFDO0lBQ1osV0FBVyxFQUFFLEVBQUUsQ0FBQztJQUNoQixXQUFXLEVBQUUsV0FBVyxDQUFDO0lBQ3pCLFVBQVUsRUFBRSxVQUFVLENBQUM7SUFDdkIsT0FBTyxFQUFFLE1BQU0sQ0FBQztJQUNoQixTQUFTLEVBQUUsTUFBTSxDQUFDO0NBQ25CLENBQUM7QUFFRix3QkFBZ0IsZUFBZSxDQUFDLFdBQVcsQ0FBQyxFQUFFLFdBQVcsR0FBRyxNQUFNLEdBQUcsV0FBVyxDQVUvRTtBQUVELGVBQU8sTUFBTSxlQUFlOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0VBUTFCLENBQUM7QUFFSCx3QkFBZ0Isa0JBQWtCLENBQUMsU0FBUyxFQUFFLFdBQVcsR0FBRyxNQUFNLENBVWpFO0FBRUQsd0JBQWdCLG9CQUFvQixDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLFdBQVcsQ0FZL0UifQ==

package/dest/block/l2_block_info.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"l2_block_info.d.ts","sourceRoot":"","sources":["../../src/block/l2_block_info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,CAAC,EAAE,EAAE,CAAC;IACf,OAAO,EAAE,EAAE,CAAC;IACZ,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,WAAW,CAUjE;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;EAQ1B,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,WAAW,GAAG,MAAM,CAUjE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,WAAW,CAY/E"}
+{"version":3,"file":"l2_block_info.d.ts","sourceRoot":"","sources":["../../src/block/l2_block_info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAqB,UAAU,EAAoB,MAAM,iCAAiC,CAAC;AAC/G,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,CAAC,EAAE,EAAE,CAAC;IACf,OAAO,EAAE,EAAE,CAAC;IACZ,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,eAAe,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,WAAW,CAU/E;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ1B,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,WAAW,GAAG,MAAM,CAUjE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,WAAW,CAY/E"}

package/dest/block/l2_block_info.js

@@ -1,3 +1,4 @@
+import { BlockNumber, BlockNumberSchema, SlotNumber, SlotNumberSchema } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -7,8 +8,8 @@ export function randomBlockInfo(blockNumber) {
         blockHash: Fr.random(),
         archive: Fr.random(),
         lastArchive: Fr.random(),
-        blockNumber: blockNumber ?? Math.floor(Math.random() * 100000) + 1,
-        slotNumber: Math.floor(Math.random() * 100000) + 1,
+        blockNumber: BlockNumber(blockNumber ?? Math.floor(Math.random() * 100000) + 1),
+        slotNumber: SlotNumber(Math.floor(Math.random() * 100000) + 1),
         txCount: Math.floor(Math.random() * 100),
         timestamp: BigInt(Math.floor(Date.now() / 1000))
     };
@@ -17,8 +18,8 @@ export const BlockInfoSchema = z.object({
     blockHash: schemas.Fr.optional(),
     archive: schemas.Fr,
     lastArchive: schemas.Fr,
-    blockNumber: z.number(),
-    slotNumber: z.number(),
+    blockNumber: BlockNumberSchema,
+    slotNumber: SlotNumberSchema,
     txCount: z.number(),
     timestamp: schemas.BigInt
 });
@@ -32,8 +33,8 @@ export function deserializeBlockInfo(buffer) {
         blockHash: blockHash.equals(Fr.ZERO) ? undefined : blockHash,
         archive: reader.readObject(Fr),
         lastArchive: reader.readObject(Fr),
-        blockNumber: reader.readNumber(),
-        slotNumber: reader.readNumber(),
+        blockNumber: BlockNumber(reader.readNumber()),
+        slotNumber: SlotNumber(reader.readNumber()),
         txCount: reader.readNumber(),
         timestamp: reader.readBigInt()
     };

package/dest/block/l2_block_new.d.ts

@@ -0,0 +1,110 @@
+import { type BlockBlobData } from '@aztec/blob-lib/encoding';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader } from '../tx/block_header.js';
+import { Body } from './body.js';
+import type { L2BlockInfo } from './l2_block_info.js';
+/**
+ * An L2 block with a header and a body.
+ * TODO: Delete the existing `L2Block` class and rename this to `L2Block`.
+ */
+export declare class L2BlockNew {
+    archive: AppendOnlyTreeSnapshot;
+    header: BlockHeader;
+    body: Body;
+    private blockHash;
+    constructor(
+    /** Snapshot of archive tree after the block is applied. */
+    archive: AppendOnlyTreeSnapshot, 
+    /** Header of the block. */
+    header: BlockHeader, 
+    /** L2 block body. */
+    body: Body, blockHash?: Fr | undefined);
+    get number(): BlockNumber;
+    get timestamp(): bigint;
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        archive: z.ZodEffects<z.ZodObject<{
+            root: z.ZodType<Fr, any, string>;
+            nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>, AppendOnlyTreeSnapshot, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>;
+        header: import("../schemas/schemas.js").ZodFor<BlockHeader>;
+        body: import("../schemas/schemas.js").ZodFor<Body>;
+    }, "strip", z.ZodTypeAny, {
+        archive: AppendOnlyTreeSnapshot;
+        header: BlockHeader;
+        body: Body;
+    }, {
+        archive: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+        header?: any;
+        body?: any;
+    }>, L2BlockNew, {
+        archive: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+        header?: any;
+        body?: any;
+    }>;
+    /**
+     * Deserializes a block from a buffer
+     * @returns A deserialized L2 block.
+     */
+    static fromBuffer(buf: Buffer | BufferReader): L2BlockNew;
+    /**
+     * Serializes a block
+     * @returns A serialized L2 block as a Buffer.
+     */
+    toBuffer(): Buffer<ArrayBufferLike>;
+    /**
+     * Returns the block's hash (hash of block header).
+     * @returns The block's hash.
+     */
+    hash(): Promise<Fr>;
+    toBlobFields(isFirstBlock: boolean): Fr[];
+    toBlockBlobData(isFirstBlock: boolean): BlockBlobData;
+    static empty(): L2BlockNew;
+    /**
+     * Creates an L2 block containing random data.
+     * @param l2BlockNum - The number of the L2 block.
+     * @param txsPerBlock - The number of transactions to include in the block.
+     * @param numPublicCallsPerTx - The number of public function calls to include in each transaction.
+     * @param numPublicLogsPerCall - The number of public logs per 1 public function invocation.
+     * @param inHash - The hash of the L1 to L2 messages subtree which got inserted in this block.
+     * @returns The L2 block.
+     */
+    static random(blockNumber: BlockNumber, { txsPerBlock, txOptions, makeTxOptions, ...blockHeaderOverrides }?: {
+        txsPerBlock?: number;
+        txOptions?: Partial<Parameters<typeof Body.random>[0]>;
+        makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
+    } & Partial<Parameters<typeof BlockHeader.random>[0]>): Promise<L2BlockNew>;
+    /**
+     * Returns stats used for logging.
+     * @returns Stats on tx count, number, and log size and count.
+     */
+    getStats(): {
+        privateLogCount: number;
+        publicLogCount: number;
+        contractClassLogCount: number;
+        contractClassLogSize: number;
+        txCount: number;
+        blockNumber: BlockNumber;
+        blockTimestamp: number;
+    };
+    toBlockInfo(): L2BlockInfo;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/block/l2_block_new.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l2_block_new.d.ts","sourceRoot":"","sources":["../../src/block/l2_block_new.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAuB,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;GAGG;AACH,qBAAa,UAAU;IAGZ,OAAO,EAAE,sBAAsB;IAE/B,MAAM,EAAE,WAAW;IAEnB,IAAI,EAAE,IAAI;IACjB,OAAO,CAAC,SAAS;IAPnB;IACE,2DAA2D;IACpD,OAAO,EAAE,sBAAsB;IACtC,2BAA2B;IACpB,MAAM,EAAE,WAAW;IAC1B,qBAAqB;IACd,IAAI,EAAE,IAAI,EACT,SAAS,GAAE,EAAE,GAAG,SAAqB,EAC3C;IAEJ,IAAI,MAAM,IAAI,WAAW,CAExB;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAQhB;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,cAO3C;IAED;;;OAGG;IACH,QAAQ,4BAEP;IAED;;;OAGG;IACU,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC,CAK/B;IAEM,YAAY,CAAC,YAAY,EAAE,OAAO,GAAG,EAAE,EAAE,CAG/C;IAEM,eAAe,CAAC,YAAY,EAAE,OAAO,GAAG,aAAa,CAqB3D;IAED,MAAM,CAAC,KAAK,eAEX;IAED;;;;;;;;OAQG;IACH,OAAa,MAAM,CACjB,WAAW,EAAE,WAAW,EACxB,EACE,WAAe,EACf,SAAc,EACd,aAAa,EACb,GAAG,oBAAoB,EACxB,GAAE;QACD,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACvD,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KACjF,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAM,GACzD,OAAO,CAAC,UAAU,CAAC,CAKrB;IAED;;;OAGG;IACH,QAAQ;;;;;;;;MAqBP;IAED,WAAW,IAAI,WAAW,CAUzB;CACF"}

package/dest/block/l2_block_new.js

@@ -0,0 +1,138 @@
+import { encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader } from '../tx/block_header.js';
+import { Body } from './body.js';
+/**
+ * An L2 block with a header and a body.
+ * TODO: Delete the existing `L2Block` class and rename this to `L2Block`.
+ */ export class L2BlockNew {
+    archive;
+    header;
+    body;
+    blockHash;
+    constructor(/** Snapshot of archive tree after the block is applied. */ archive, /** Header of the block. */ header, /** L2 block body. */ body, blockHash = undefined){
+        this.archive = archive;
+        this.header = header;
+        this.body = body;
+        this.blockHash = blockHash;
+    }
+    get number() {
+        return this.header.globalVariables.blockNumber;
+    }
+    get timestamp() {
+        return this.header.globalVariables.timestamp;
+    }
+    static get schema() {
+        return z.object({
+            archive: AppendOnlyTreeSnapshot.schema,
+            header: BlockHeader.schema,
+            body: Body.schema
+        }).transform(({ archive, header, body })=>new L2BlockNew(archive, header, body));
+    }
+    /**
+   * Deserializes a block from a buffer
+   * @returns A deserialized L2 block.
+   */ static fromBuffer(buf) {
+        const reader = BufferReader.asReader(buf);
+        const header = reader.readObject(BlockHeader);
+        const archive = reader.readObject(AppendOnlyTreeSnapshot);
+        const body = reader.readObject(Body);
+        return new L2BlockNew(archive, header, body);
+    }
+    /**
+   * Serializes a block
+   * @returns A serialized L2 block as a Buffer.
+   */ toBuffer() {
+        return serializeToBuffer(this.header, this.archive, this.body);
+    }
+    /**
+   * Returns the block's hash (hash of block header).
+   * @returns The block's hash.
+   */ async hash() {
+        if (this.blockHash === undefined) {
+            this.blockHash = await this.header.hash();
+        }
+        return this.blockHash;
+    }
+    toBlobFields(isFirstBlock) {
+        const blockBlobData = this.toBlockBlobData(isFirstBlock);
+        return encodeBlockBlobData(blockBlobData);
+    }
+    toBlockBlobData(isFirstBlock) {
+        return {
+            blockEndMarker: {
+                numTxs: this.body.txEffects.length,
+                timestamp: this.header.globalVariables.timestamp,
+                blockNumber: this.number
+            },
+            blockEndStateField: {
+                l1ToL2MessageNextAvailableLeafIndex: this.header.state.l1ToL2MessageTree.nextAvailableLeafIndex,
+                noteHashNextAvailableLeafIndex: this.header.state.partial.noteHashTree.nextAvailableLeafIndex,
+                nullifierNextAvailableLeafIndex: this.header.state.partial.nullifierTree.nextAvailableLeafIndex,
+                publicDataNextAvailableLeafIndex: this.header.state.partial.publicDataTree.nextAvailableLeafIndex,
+                totalManaUsed: this.header.totalManaUsed.toBigInt()
+            },
+            lastArchiveRoot: this.header.lastArchive.root,
+            noteHashRoot: this.header.state.partial.noteHashTree.root,
+            nullifierRoot: this.header.state.partial.nullifierTree.root,
+            publicDataRoot: this.header.state.partial.publicDataTree.root,
+            l1ToL2MessageRoot: isFirstBlock ? this.header.state.l1ToL2MessageTree.root : undefined,
+            txs: this.body.toTxBlobData()
+        };
+    }
+    static empty() {
+        return new L2BlockNew(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty());
+    }
+    /**
+   * Creates an L2 block containing random data.
+   * @param l2BlockNum - The number of the L2 block.
+   * @param txsPerBlock - The number of transactions to include in the block.
+   * @param numPublicCallsPerTx - The number of public function calls to include in each transaction.
+   * @param numPublicLogsPerCall - The number of public logs per 1 public function invocation.
+   * @param inHash - The hash of the L1 to L2 messages subtree which got inserted in this block.
+   * @returns The L2 block.
+   */ static async random(blockNumber, { txsPerBlock = 1, txOptions = {}, makeTxOptions, ...blockHeaderOverrides } = {}) {
+        const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
+        const header = BlockHeader.random({
+            blockNumber,
+            ...blockHeaderOverrides
+        });
+        const body = await Body.random({
+            txsPerBlock,
+            makeTxOptions,
+            ...txOptions
+        });
+        return new L2BlockNew(archive, header, body);
+    }
+    /**
+   * Returns stats used for logging.
+   * @returns Stats on tx count, number, and log size and count.
+   */ getStats() {
+        const logsStats = {
+            privateLogCount: this.body.txEffects.reduce((logCount, txEffect)=>logCount + txEffect.privateLogs.length, 0),
+            publicLogCount: this.body.txEffects.reduce((logCount, txEffect)=>logCount + txEffect.publicLogs.length, 0),
+            contractClassLogCount: this.body.txEffects.reduce((logCount, txEffect)=>logCount + txEffect.contractClassLogs.length, 0),
+            contractClassLogSize: this.body.txEffects.reduce((totalLogSize, txEffect)=>totalLogSize + txEffect.contractClassLogs.reduce((acc, log)=>acc + log.emittedLength, 0), 0)
+        };
+        return {
+            txCount: this.body.txEffects.length,
+            blockNumber: this.number,
+            blockTimestamp: Number(this.header.globalVariables.timestamp),
+            ...logsStats
+        };
+    }
+    toBlockInfo() {
+        return {
+            blockHash: this.blockHash,
+            archive: this.archive.root,
+            lastArchive: this.header.lastArchive.root,
+            blockNumber: this.number,
+            slotNumber: this.header.getSlot(),
+            txCount: this.body.txEffects.length,
+            timestamp: this.header.globalVariables.timestamp
+        };
+    }
+}