@aztec/stdlib 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/dest/block/l2_block.js

@@ -1,29 +1,43 @@
-import { sha256, sha256ToField } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import { CheckpointNumber, CheckpointNumberSchema, IndexWithinCheckpoint, IndexWithinCheckpointSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 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 { makeAppendOnlyTreeSnapshot, makeHeader } from './l2_block_code_to_purge.js';
 /**
- * The data that makes up the rollup proof, with encoder decoder functions.
+ * An L2 block with a header and a body.
  */ export class L2Block {
     archive;
     header;
     body;
-    constructor(/** Snapshot of archive tree after the block is applied. */ archive, /** L2 block header. */ header, /** L2 block body. */ body){
+    checkpointNumber;
+    indexWithinCheckpoint;
+    constructor(/** Snapshot of archive tree after the block is applied. */ archive, /** Header of the block. */ header, /** L2 block body. */ body, /** Number of the checkpoint that the block belongs to. */ checkpointNumber, /** Index of the block within the checkpoint. */ indexWithinCheckpoint){
         this.archive = archive;
         this.header = header;
         this.body = body;
+        this.checkpointNumber = checkpointNumber;
+        this.indexWithinCheckpoint = indexWithinCheckpoint;
+    }
+    get number() {
+        return this.header.globalVariables.blockNumber;
+    }
+    get slot() {
+        return this.header.globalVariables.slotNumber;
+    }
+    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 L2Block(archive, header, body));
+            body: Body.schema,
+            checkpointNumber: CheckpointNumberSchema,
+            indexWithinCheckpoint: IndexWithinCheckpointSchema
+        }).transform(({ archive, header, body, checkpointNumber, indexWithinCheckpoint })=>new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint));
     }
     /**
    * Deserializes a block from a buffer
@@ -33,26 +47,58 @@ import { makeAppendOnlyTreeSnapshot, makeHeader } from './l2_block_code_to_purge
         const header = reader.readObject(BlockHeader);
         const archive = reader.readObject(AppendOnlyTreeSnapshot);
         const body = reader.readObject(Body);
-        return new L2Block(archive, header, body);
+        const checkpointNumber = CheckpointNumber(reader.readNumber());
+        const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
+        return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
     }
     /**
    * Serializes a block
    * @returns A serialized L2 block as a Buffer.
    */ toBuffer() {
-        return serializeToBuffer(this.header, this.archive, this.body);
+        return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
     }
     /**
-   * Deserializes L2 block from a buffer.
-   * @param str - A serialized L2 block.
-   * @returns Deserialized L2 block.
-   */ static fromString(str) {
-        return L2Block.fromBuffer(hexToBuffer(str));
+   * Returns the block's hash (hash of block header).
+   * @returns The block's hash.
+   */ hash() {
+        return this.header.hash();
     }
     /**
-   * Serializes a block to a string.
-   * @returns A serialized L2 block as a string.
-   */ toString() {
-        return bufferToHex(this.toBuffer());
+   * Checks if this block equals another block.
+   * @param other - The other block to compare with.
+   * @returns True if both blocks are equal.
+   */ equals(other) {
+        return this.archive.equals(other.archive) && this.header.equals(other.header) && this.body.equals(other.body) && this.checkpointNumber === other.checkpointNumber && this.indexWithinCheckpoint === other.indexWithinCheckpoint;
+    }
+    toBlobFields() {
+        const blockBlobData = this.toBlockBlobData();
+        return encodeBlockBlobData(blockBlobData);
+    }
+    toBlockBlobData() {
+        const isFirstBlock = this.indexWithinCheckpoint === 0;
+        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(header) {
+        return new L2Block(AppendOnlyTreeSnapshot.empty(), header ?? BlockHeader.empty(), Body.empty(), CheckpointNumber(0), IndexWithinCheckpoint(0));
     }
     /**
    * Creates an L2 block containing random data.
@@ -62,62 +108,18 @@ import { makeAppendOnlyTreeSnapshot, makeHeader } from './l2_block_code_to_purge
    * @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(l2BlockNum, txsPerBlock = 4, numPublicCallsPerTx = 3, numPublicLogsPerCall = 1, inHash = undefined, slotNumber = undefined) {
-        const body = await Body.random(txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall);
-        return new L2Block(makeAppendOnlyTreeSnapshot(l2BlockNum + 1), makeHeader(0, txsPerBlock, l2BlockNum, slotNumber ?? l2BlockNum, inHash), body);
-    }
-    /**
-   * Creates an L2 block containing empty data.
-   * @returns The L2 block.
-   */ static empty() {
-        return new L2Block(AppendOnlyTreeSnapshot.zero(), BlockHeader.empty(), Body.empty());
-    }
-    get number() {
-        return Number(this.header.globalVariables.blockNumber.toBigInt());
-    }
-    /**
-   * Returns the block's hash (hash of block header).
-   * @returns The block's hash.
-   */ hash() {
-        return this.header.hash();
-    }
-    /**
-   * Computes the public inputs hash for the L2 block.
-   * The same output as the hash of RootRollupPublicInputs.
-   * TODO(Miranda): Check where/if this is used (v diff now with epochs and blobs)
-   * @returns The public input hash for the L2 block as a field element.
-   */ // TODO(#4844)
-    getPublicInputsHash() {
-        const preimage = [
-            this.header.globalVariables,
-            AppendOnlyTreeSnapshot.zero(),
-            AppendOnlyTreeSnapshot.zero(),
-            AppendOnlyTreeSnapshot.zero(),
-            AppendOnlyTreeSnapshot.zero(),
-            this.header.lastArchive,
-            this.header.state.partial.noteHashTree,
-            this.header.state.partial.nullifierTree,
-            this.header.state.partial.publicDataTree,
-            this.header.state.l1ToL2MessageTree,
-            this.archive
-        ];
-        return sha256ToField(preimage);
-    }
-    /**
-   * Computes the start state hash (should equal contract data before block).
-   * @returns The start state hash for the L2 block.
-   */ // TODO(#4844)
-    getStartStateHash() {
-        const inputValue = serializeToBuffer(new Fr(Number(this.header.globalVariables.blockNumber.toBigInt()) - 1), AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero(), this.header.lastArchive);
-        return sha256(inputValue);
-    }
-    /**
-   * Computes the end state hash (should equal contract data after block).
-   * @returns The end state hash for the L2 block.
-   */ // TODO(#4844)
-    getEndStateHash() {
-        const inputValue = serializeToBuffer(this.header.globalVariables.blockNumber, this.header.state.partial.noteHashTree, this.header.state.partial.nullifierTree, this.header.state.partial.publicDataTree, this.header.state.l1ToL2MessageTree, this.archive);
-        return sha256(inputValue);
+   */ static async random(blockNumber, { checkpointNumber = CheckpointNumber(Number(blockNumber)), indexWithinCheckpoint = IndexWithinCheckpoint(0), 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 L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
     }
     /**
    * Returns stats used for logging.
@@ -127,13 +129,26 @@ import { makeAppendOnlyTreeSnapshot, makeHeader } from './l2_block_code_to_purge
             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((logSize, log)=>logSize + log.getEmittedLength(), 0), 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: this.header.globalVariables.timestamp.toNumber(),
+            blockTimestamp: Number(this.header.globalVariables.timestamp),
             ...logsStats
         };
     }
+    getPrivateLogs() {
+        return this.body.txEffects.map((txEffect)=>txEffect.privateLogs).flat();
+    }
+    toBlockInfo() {
+        return {
+            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
+        };
+    }
 }

package/dest/block/l2_block_info.d.ts

@@ -0,0 +1,46 @@
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+export type L2BlockInfo = {
+    blockHash?: Fr;
+    archive: Fr;
+    lastArchive: Fr;
+    blockNumber: BlockNumber;
+    slotNumber: SlotNumber;
+    txCount: number;
+    timestamp: bigint;
+};
+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.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, {
+    blockHash?: Fr | undefined;
+    archive: Fr;
+    lastArchive: Fr;
+    blockNumber: number & {
+        _branding: "BlockNumber";
+    };
+    slotNumber: number & {
+        _branding: "SlotNumber";
+    };
+    txCount: number;
+    timestamp: bigint;
+}, {
+    blockHash?: string | undefined;
+    archive: string;
+    lastArchive: string;
+    blockNumber: string | number | bigint;
+    slotNumber: string | number | bigint;
+    txCount: number;
+    timestamp: string | number | bigint;
+}>;
+export declare function serializeBlockInfo(blockInfo: L2BlockInfo): Buffer;
+export declare function deserializeBlockInfo(buffer: Buffer | BufferReader): L2BlockInfo;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDJfYmxvY2tfaW5mby5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Jsb2NrL2wyX2Jsb2NrX2luZm8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBcUIsVUFBVSxFQUFvQixNQUFNLGlDQUFpQyxDQUFDO0FBQy9HLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUVwRCxPQUFPLEVBQUUsWUFBWSxFQUFxQixNQUFNLDZCQUE2QixDQUFDO0FBRTlFLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsTUFBTSxNQUFNLFdBQVcsR0FBRztJQUN4QixTQUFTLENBQUMsRUFBRSxFQUFFLENBQUM7SUFDZixPQUFPLEVBQUUsRUFBRSxDQUFDO0lBQ1osV0FBVyxFQUFFLEVBQUUsQ0FBQztJQUNoQixXQUFXLEVBQUUsV0FBVyxDQUFDO0lBQ3pCLFVBQVUsRUFBRSxVQUFVLENBQUM7SUFDdkIsT0FBTyxFQUFFLE1BQU0sQ0FBQztJQUNoQixTQUFTLEVBQUUsTUFBTSxDQUFDO0NBQ25CLENBQUM7QUFFRix3QkFBZ0IsZUFBZSxDQUFDLFdBQVcsQ0FBQyxFQUFFLFdBQVcsR0FBRyxNQUFNLEdBQUcsV0FBVyxDQVUvRTtBQUVELGVBQU8sTUFBTSxlQUFlOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0VBUTFCLENBQUM7QUFFSCx3QkFBZ0Isa0JBQWtCLENBQUMsU0FBUyxFQUFFLFdBQVcsR0FBRyxNQUFNLENBVWpFO0FBRUQsd0JBQWdCLG9CQUFvQixDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLFdBQVcsQ0FZL0UifQ==

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

@@ -0,0 +1 @@
+{"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,gCAAgC,CAAC;AAEpD,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

@@ -0,0 +1,41 @@
+import { BlockNumber, BlockNumberSchema, SlotNumber, SlotNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+export function randomBlockInfo(blockNumber) {
+    return {
+        blockHash: Fr.random(),
+        archive: Fr.random(),
+        lastArchive: Fr.random(),
+        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))
+    };
+}
+export const BlockInfoSchema = z.object({
+    blockHash: schemas.Fr.optional(),
+    archive: schemas.Fr,
+    lastArchive: schemas.Fr,
+    blockNumber: BlockNumberSchema,
+    slotNumber: SlotNumberSchema,
+    txCount: z.number(),
+    timestamp: schemas.BigInt
+});
+export function serializeBlockInfo(blockInfo) {
+    return serializeToBuffer(blockInfo.blockHash ?? Fr.ZERO, blockInfo.archive, blockInfo.lastArchive, blockInfo.blockNumber, blockInfo.slotNumber, blockInfo.txCount, blockInfo.timestamp);
+}
+export function deserializeBlockInfo(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    const blockHash = reader.readObject(Fr);
+    return {
+        blockHash: blockHash.equals(Fr.ZERO) ? undefined : blockHash,
+        archive: reader.readObject(Fr),
+        lastArchive: reader.readObject(Fr),
+        blockNumber: BlockNumber(reader.readNumber()),
+        slotNumber: SlotNumber(reader.readNumber()),
+        txCount: reader.readNumber(),
+        timestamp: reader.readBigInt()
+    };
+}