@aztec/stdlib 0.0.1-commit.fcb71a6 → 0.0.1-commit.fffb133c

package/dest/block/l2_block.js

@@ -1,148 +1,82 @@
-import { encodeBlockBlobData, encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
-import { CheckpointNumber } from '@aztec/foundation/branded-types';
+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 { Checkpoint } from '../checkpoint/checkpoint.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
-import { makeAppendOnlyTreeSnapshot, makeL2BlockHeader } from './l2_block_code_to_purge.js';
-import { L2BlockHeader } from './l2_block_header.js';
-import { L2BlockNew } from './l2_block_new.js';
 /**
- * The data that makes up the rollup proof, with encoder decoder functions.
- *
- * @deprecated Use `L2BlockNew` instead.
+ * An L2 block with a header and a body.
  */ export class L2Block {
     archive;
     header;
     body;
-    blockHash;
-    constructor(/** Snapshot of archive tree after the block is applied. */ archive, /** L2 block header. */ header, /** L2 block body. */ body, blockHash = undefined){
+    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.blockHash = blockHash;
+        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: L2BlockHeader.schema,
-            body: Body.schema
-        }).transform(({ archive, header, body })=>new L2Block(archive, header, body));
+            header: BlockHeader.schema,
+            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
    * @returns A deserialized L2 block.
    */ static fromBuffer(buf) {
         const reader = BufferReader.asReader(buf);
-        const header = reader.readObject(L2BlockHeader);
+        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);
-    }
-    /**
-   * Deserializes L2 block from a buffer.
-   * @param str - A serialized L2 block.
-   * @returns Deserialized L2 block.
-   */ static fromString(str) {
-        return L2Block.fromBuffer(hexToBuffer(str));
-    }
-    /**
-   * Serializes a block to a string.
-   * @returns A serialized L2 block as a string.
-   */ toString() {
-        return bufferToHex(this.toBuffer());
-    }
-    /**
-   * 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(l2BlockNum, txsPerBlock = 4, numPublicCallsPerTx = 3, numPublicLogsPerCall = 1, inHash = undefined, slotNumber = undefined, maxEffects = undefined) {
-        const body = await Body.random({
-            txsPerBlock,
-            numPublicCallsPerTx,
-            numPublicLogsPerCall,
-            maxEffects
-        });
-        return new L2Block(makeAppendOnlyTreeSnapshot(l2BlockNum + 1), makeL2BlockHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, {}, inHash), body);
-    }
-    /**
-   * Creates an L2 block containing empty data.
-   * @returns The L2 block.
-   */ static empty() {
-        return new L2Block(AppendOnlyTreeSnapshot.empty(), L2BlockHeader.empty(), Body.empty());
-    }
-    get number() {
-        return this.header.getBlockNumber();
-    }
-    get slot() {
-        return this.header.getSlot();
-    }
-    get timestamp() {
-        return this.header.globalVariables.timestamp;
+        return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
     }
     /**
    * Returns the block's hash (hash of block header).
    * @returns The block's hash.
    */ async hash() {
-        if (this.blockHash === undefined) {
-            this.blockHash = await this.getBlockHeader().hash();
-        }
-        return this.blockHash;
+        const blockHash = await this.header.hash();
+        return blockHash.toField();
     }
     /**
-   * @deprecated
-   * This only works when there's one block per checkpoint.
-   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
-   */ getCheckpointHeader() {
-        return this.header.toCheckpointHeader();
-    }
-    // Temporary helper to get the actual block header.
-    getBlockHeader() {
-        return this.header.toBlockHeader();
-    }
-    toL2Block() {
-        return new L2BlockNew(this.archive, this.getBlockHeader(), this.body, CheckpointNumber.fromBlockNumber(this.number), 0);
-    }
-    toCheckpoint() {
-        return new Checkpoint(this.archive, this.getCheckpointHeader(), [
-            this.toL2Block()
-        ], CheckpointNumber.fromBlockNumber(this.number));
-    }
-    static fromCheckpoint(checkpoint) {
-        const checkpointHeader = checkpoint.header;
-        const block = checkpoint.blocks.at(-1);
-        const header = new L2BlockHeader(new AppendOnlyTreeSnapshot(checkpointHeader.lastArchiveRoot, block.number), checkpointHeader.contentCommitment, block.header.state, block.header.globalVariables, block.header.totalFees, checkpointHeader.totalManaUsed, block.header.spongeBlobHash, checkpointHeader.blockHeadersHash);
-        return new L2Block(checkpoint.archive, header, block.body);
-    }
-    /**
-   * @deprecated
-   * This only works when there's one block per checkpoint.
-   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
-   */ getCheckpointBlobFields() {
-        const blockBlobData = this.toBlockBlobData();
-        return encodeCheckpointBlobDataFromBlocks([
-            blockBlobData
-        ]);
+   * 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() {
-        // There's only one L2Block per checkpoint, so it's always the first block in the checkpoint.
-        const isFirstBlock = true;
+        const isFirstBlock = this.indexWithinCheckpoint === 0;
         return {
             blockEndMarker: {
                 numTxs: this.body.txEffects.length,
@@ -164,6 +98,30 @@ import { L2BlockNew } from './l2_block_new.js';
             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.
+   * @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, { 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.
    * @returns Stats on tx count, number, and log size and count.
@@ -181,9 +139,11 @@ import { L2BlockNew } from './l2_block_new.js';
             ...logsStats
         };
     }
+    getPrivateLogs() {
+        return this.body.txEffects.map((txEffect)=>txEffect.privateLogs).flat();
+    }
     toBlockInfo() {
         return {
-            blockHash: this.blockHash,
             archive: this.archive.root,
             lastArchive: this.header.lastArchive.root,
             blockNumber: this.number,
@@ -192,7 +152,4 @@ import { L2BlockNew } from './l2_block_new.js';
             timestamp: this.header.globalVariables.timestamp
         };
     }
-    equals(other) {
-        return this.archive.equals(other.archive) && this.header.equals(other.header) && this.body.equals(other.body);
-    }
 }