@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/dest/block/l2_block_header.js

@@ -0,0 +1,146 @@
+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 { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from '../tx/index.js';
+/**
+ * TO BE DELETED
+ *
+ * A header of an L2 block combining the block header and the checkpoint header.
+ * This is a temporary workaround to avoid changing too many things before building in chunks is properly implemented.
+ * This works for now because we only have one block per checkpoint.
+ *
+ * @deprecated Use BlockHeader or CheckpointHeader instead.
+ */ export class L2BlockHeader {
+    lastArchive;
+    contentCommitment;
+    state;
+    globalVariables;
+    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){
+        this.lastArchive = lastArchive;
+        this.contentCommitment = contentCommitment;
+        this.state = state;
+        this.globalVariables = globalVariables;
+        this.totalFees = totalFees;
+        this.totalManaUsed = totalManaUsed;
+        this.spongeBlobHash = spongeBlobHash;
+    }
+    static get schema() {
+        return z.object({
+            lastArchive: AppendOnlyTreeSnapshot.schema,
+            contentCommitment: ContentCommitment.schema,
+            state: StateReference.schema,
+            globalVariables: GlobalVariables.schema,
+            totalFees: schemas.Fr,
+            totalManaUsed: schemas.Fr,
+            spongeBlobHash: schemas.Fr
+        }).transform(L2BlockHeader.from);
+    }
+    static getFields(fields) {
+        return [
+            fields.lastArchive,
+            fields.contentCommitment,
+            fields.state,
+            fields.globalVariables,
+            fields.totalFees,
+            fields.totalManaUsed,
+            fields.spongeBlobHash
+        ];
+    }
+    static from(fields) {
+        return new L2BlockHeader(...L2BlockHeader.getFields(fields));
+    }
+    getSlot() {
+        return this.globalVariables.slotNumber.toBigInt();
+    }
+    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;
+    }
+    toBuffer() {
+        return serializeToBuffer(...L2BlockHeader.getFields(this));
+    }
+    toFields() {
+        return serializeToFields(...L2BlockHeader.getFields(this));
+    }
+    clone() {
+        return L2BlockHeader.fromBuffer(this.toBuffer());
+    }
+    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));
+    }
+    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());
+    }
+    static empty(fields = {}) {
+        return L2BlockHeader.from({
+            lastArchive: AppendOnlyTreeSnapshot.empty(),
+            contentCommitment: ContentCommitment.empty(),
+            state: StateReference.empty(),
+            globalVariables: GlobalVariables.empty(),
+            totalFees: Fr.ZERO,
+            totalManaUsed: Fr.ZERO,
+            spongeBlobHash: 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();
+    }
+    /**
+   * Serializes this instance into a string.
+   * @returns Encoded string.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static fromString(str) {
+        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);
+    }
+    toBlockHeader() {
+        return new BlockHeader(this.lastArchive, this.state, this.spongeBlobHash, this.globalVariables, this.totalFees, this.totalManaUsed);
+    }
+    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(),
+            spongeBlobHash: this.spongeBlobHash.toString()
+        };
+    }
+    [inspect.custom]() {
+        return `L2BlockHeader {
+  lastArchive: ${inspect(this.lastArchive)},
+  contentCommitment.blobsHash: ${inspect(this.contentCommitment.blobsHash)},
+  contentCommitment.inHash: ${inspect(this.contentCommitment.inHash)},
+  contentCommitment.outHash: ${inspect(this.contentCommitment.outHash)},
+  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},
+  spongeBlobHash: ${this.spongeBlobHash},
+}`;
+    }
+    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);
+    }
+}

package/dest/block/l2_block_info.d.ts

@@ -0,0 +1,41 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+export type L2BlockInfo = {
+    blockHash?: Fr;
+    archive: Fr;
+    lastArchive: Fr;
+    blockNumber: number;
+    slotNumber: number;
+    txCount: number;
+    timestamp: bigint;
+};
+export declare function randomBlockInfo(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;
+    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;
+    archive: Fr;
+    txCount: number;
+    blockHash?: Fr | undefined;
+}, {
+    blockNumber: number;
+    slotNumber: number;
+    timestamp: string | number | bigint;
+    lastArchive: string;
+    archive: string;
+    txCount: number;
+    blockHash?: string | undefined;
+}>;
+export declare function serializeBlockInfo(blockInfo: L2BlockInfo): Buffer;
+export declare function deserializeBlockInfo(buffer: Buffer | BufferReader): L2BlockInfo;
+//# sourceMappingURL=l2_block_info.d.ts.map

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,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"}

package/dest/block/l2_block_info.js

@@ -0,0 +1,40 @@
+import { Fr } from '@aztec/foundation/fields';
+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 ?? Math.floor(Math.random() * 100000) + 1,
+        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: z.number(),
+    slotNumber: z.number(),
+    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: reader.readNumber(),
+        slotNumber: reader.readNumber(),
+        txCount: reader.readNumber(),
+        timestamp: reader.readBigInt()
+    };
+}