@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/block/published_l2_block.d.ts

@@ -0,0 +1,143 @@
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import { L2Block } from './l2_block.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+export declare class L1PublishedData {
+    blockNumber: bigint;
+    timestamp: bigint;
+    blockHash: string;
+    constructor(blockNumber: bigint, timestamp: bigint, blockHash: string);
+    static get schema(): z.ZodObject<{
+        blockNumber: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+        timestamp: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+        blockHash: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        blockNumber: bigint;
+        timestamp: bigint;
+        blockHash: string;
+    }, {
+        blockNumber: string | number | bigint;
+        timestamp: string | number | bigint;
+        blockHash: string;
+    }>;
+    static random(): L1PublishedData;
+    static fromFields(fields: FieldsOf<L1PublishedData>): L1PublishedData;
+}
+export declare class PublishedL2Block {
+    block: L2Block;
+    l1: L1PublishedData;
+    attestations: CommitteeAttestation[];
+    constructor(block: L2Block, l1: L1PublishedData, attestations: CommitteeAttestation[]);
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        block: z.ZodEffects<z.ZodObject<{
+            archive: z.ZodEffects<z.ZodObject<{
+                root: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                root: import("@aztec/foundation/schemas").Fr;
+                nextAvailableLeafIndex: number;
+            }, {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            }>;
+            header: import("@aztec/foundation/schemas").ZodFor<import("./l2_block_header.js").L2BlockHeader>;
+            body: import("@aztec/foundation/schemas").ZodFor<import("./body.js").Body>;
+        }, "strip", z.ZodTypeAny, {
+            archive: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+            header: import("./l2_block_header.js").L2BlockHeader;
+            body: import("./body.js").Body;
+        }, {
+            archive: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            header?: any;
+            body?: any;
+        }>, L2Block, {
+            archive: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            header?: any;
+            body?: any;
+        }>;
+        l1: z.ZodObject<{
+            blockNumber: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+            timestamp: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+            blockHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            blockNumber: bigint;
+            timestamp: bigint;
+            blockHash: string;
+        }, {
+            blockNumber: string | number | bigint;
+            timestamp: string | number | bigint;
+            blockHash: string;
+        }>;
+        attestations: z.ZodArray<z.ZodEffects<z.ZodObject<{
+            address: z.ZodType<import("@aztec/foundation/schemas").EthAddress, any, string>;
+            signature: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, `0x${string}`, string>, `0x${string}`, string>, import("./proposal/committee_attestation.js").Signature, string>;
+        }, "strip", z.ZodTypeAny, {
+            address: import("@aztec/foundation/schemas").EthAddress;
+            signature: import("./proposal/committee_attestation.js").Signature;
+        }, {
+            address: string;
+            signature: string;
+        }>, CommitteeAttestation, {
+            address: string;
+            signature: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        block: L2Block;
+        l1: {
+            blockNumber: bigint;
+            timestamp: bigint;
+            blockHash: string;
+        };
+        attestations: CommitteeAttestation[];
+    }, {
+        block: {
+            archive: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            header?: any;
+            body?: any;
+        };
+        l1: {
+            blockNumber: string | number | bigint;
+            timestamp: string | number | bigint;
+            blockHash: string;
+        };
+        attestations: {
+            address: string;
+            signature: string;
+        }[];
+    }>, PublishedL2Block, {
+        block: {
+            archive: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            header?: any;
+            body?: any;
+        };
+        l1: {
+            blockNumber: string | number | bigint;
+            timestamp: string | number | bigint;
+            blockHash: string;
+        };
+        attestations: {
+            address: string;
+            signature: string;
+        }[];
+    }>;
+    static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedL2Block;
+    static fromFields(fields: FieldsOf<PublishedL2Block>): PublishedL2Block;
+    toBuffer(): Buffer;
+}
+//# sourceMappingURL=published_l2_block.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"published_l2_block.d.ts","sourceRoot":"","sources":["../../src/block/published_l2_block.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAC9E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAE3E,qBAAa,eAAe;IAEjB,WAAW,EAAE,MAAM;IACnB,SAAS,EAAE,MAAM;IACjB,SAAS,EAAE,MAAM;gBAFjB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM;IAG1B,MAAM,KAAK,MAAM;;;;;;;;;;;;OAMhB;IAED,MAAM,CAAC,MAAM;IAQb,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC;CAGpD;AAED,qBAAa,gBAAgB;IAElB,KAAK,EAAE,OAAO;IACd,EAAE,EAAE,eAAe;IACnB,YAAY,EAAE,oBAAoB,EAAE;gBAFpC,KAAK,EAAE,OAAO,EACd,EAAE,EAAE,eAAe,EACnB,YAAY,EAAE,oBAAoB,EAAE;IAG7C,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAQhB;IAED,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,YAAY,GAAG,gBAAgB;IAU1E,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC;IAI7C,QAAQ,IAAI,MAAM;CAU1B"}

package/dest/block/published_l2_block.js

@@ -0,0 +1,63 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt } from '@aztec/foundation/crypto';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { L2Block } from './l2_block.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+export class L1PublishedData {
+    blockNumber;
+    timestamp;
+    blockHash;
+    constructor(blockNumber, timestamp, blockHash){
+        this.blockNumber = blockNumber;
+        this.timestamp = timestamp;
+        this.blockHash = blockHash;
+    }
+    static get schema() {
+        return z.object({
+            blockNumber: schemas.BigInt,
+            timestamp: schemas.BigInt,
+            blockHash: z.string()
+        });
+    }
+    static random() {
+        return new L1PublishedData(randomBigInt(1000n) + 1n, BigInt(Math.floor(Date.now() / 1000)), Buffer32.random().toString());
+    }
+    static fromFields(fields) {
+        return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
+    }
+}
+export class PublishedL2Block {
+    block;
+    l1;
+    attestations;
+    constructor(block, l1, attestations){
+        this.block = block;
+        this.l1 = l1;
+        this.attestations = attestations;
+    }
+    static get schema() {
+        return z.object({
+            block: L2Block.schema,
+            l1: L1PublishedData.schema,
+            attestations: z.array(CommitteeAttestation.schema)
+        }).transform((obj)=>PublishedL2Block.fromFields(obj));
+    }
+    static fromBuffer(bufferOrReader) {
+        const reader = BufferReader.asReader(bufferOrReader);
+        const block = reader.readObject(L2Block);
+        const l1BlockNumber = reader.readBigInt();
+        const l1BlockHash = reader.readString();
+        const l1Timestamp = reader.readBigInt();
+        const attestations = reader.readVector(CommitteeAttestation);
+        return new PublishedL2Block(block, new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash), attestations);
+    }
+    static fromFields(fields) {
+        return new PublishedL2Block(fields.block, fields.l1, fields.attestations);
+    }
+    toBuffer() {
+        return serializeToBuffer(this.block, this.l1.blockNumber, this.l1.blockHash, this.l1.timestamp, this.attestations.length, this.attestations);
+    }
+}

package/dest/block/test/index.d.ts

@@ -0,0 +1,2 @@
+export * from './l2_tips_store_test_suite.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/block/test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/block/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC"}

package/dest/block/test/index.js

@@ -0,0 +1 @@
+export * from './l2_tips_store_test_suite.js';

package/dest/block/test/l2_tips_store_test_suite.d.ts

@@ -0,0 +1,3 @@
+import type { L2TipsStore } from '../l2_block_stream/index.js';
+export declare function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>): void;
+//# sourceMappingURL=l2_tips_store_test_suite.d.ts.map

package/dest/block/test/l2_tips_store_test_suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l2_tips_store_test_suite.d.ts","sourceRoot":"","sources":["../../../src/block/test/l2_tips_store_test_suite.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE/D,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,QA8ExE"}

package/dest/block/test/l2_tips_store_test_suite.js

@@ -0,0 +1,106 @@
+import { times } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { PublishedL2Block } from '@aztec/stdlib/block';
+import { jestExpect as expect } from '@jest/expect';
+export function testL2TipsStore(makeTipsStore) {
+    let tipsStore;
+    beforeEach(async ()=>{
+        tipsStore = await makeTipsStore();
+    });
+    const makeBlock = (number)=>PublishedL2Block.fromFields({
+            block: {
+                number,
+                hash: ()=>Promise.resolve(new Fr(number))
+            },
+            l1: {
+                blockNumber: BigInt(number),
+                blockHash: `0x${number}`,
+                timestamp: BigInt(number)
+            },
+            attestations: []
+        });
+    const makeBlockId = (number)=>({
+            number,
+            hash: new Fr(number).toString()
+        });
+    const makeTip = (number)=>({
+            number,
+            hash: number === 0 ? undefined : new Fr(number).toString()
+        });
+    const makeTips = (latest, proven, finalized)=>({
+            latest: makeTip(latest),
+            proven: makeTip(proven),
+            finalized: makeTip(finalized)
+        });
+    it('returns zero if no tips are stored', async ()=>{
+        const tips = await tipsStore.getL2Tips();
+        expect(tips).toEqual(makeTips(0, 0, 0));
+    });
+    it('stores chain tips', async ()=>{
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: times(20, (i)=>makeBlock(i + 1))
+        });
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-finalized',
+            block: makeBlockId(5)
+        });
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-proven',
+            block: makeBlockId(8)
+        });
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-pruned',
+            block: makeBlockId(10)
+        });
+        const tips = await tipsStore.getL2Tips();
+        expect(tips).toEqual(makeTips(10, 8, 5));
+    });
+    it('sets latest tip from blocks added', async ()=>{
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: times(3, (i)=>makeBlock(i + 1))
+        });
+        const tips = await tipsStore.getL2Tips();
+        expect(tips).toEqual(makeTips(3, 0, 0));
+        expect(await tipsStore.getL2BlockHash(1)).toEqual(new Fr(1).toString());
+        expect(await tipsStore.getL2BlockHash(2)).toEqual(new Fr(2).toString());
+        expect(await tipsStore.getL2BlockHash(3)).toEqual(new Fr(3).toString());
+    });
+    it('clears block hashes when setting finalized chain', async ()=>{
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: times(5, (i)=>makeBlock(i + 1))
+        });
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-proven',
+            block: makeBlockId(3)
+        });
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-finalized',
+            block: makeBlockId(3)
+        });
+        const tips = await tipsStore.getL2Tips();
+        expect(tips).toEqual(makeTips(5, 3, 3));
+        expect(await tipsStore.getL2BlockHash(1)).toBeUndefined();
+        expect(await tipsStore.getL2BlockHash(2)).toBeUndefined();
+        expect(await tipsStore.getL2BlockHash(3)).toEqual(new Fr(3).toString());
+        expect(await tipsStore.getL2BlockHash(4)).toEqual(new Fr(4).toString());
+        expect(await tipsStore.getL2BlockHash(5)).toEqual(new Fr(5).toString());
+    });
+    // Regression test for #13142
+    it('does not blow up when setting proven chain on an unseen block number', async ()=>{
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: [
+                makeBlock(5)
+            ]
+        });
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-proven',
+            block: makeBlockId(3)
+        });
+        const tips = await tipsStore.getL2Tips();
+        expect(tips).toEqual(makeTips(5, 3, 0));
+    });
+}

package/dest/block/validate_block_result.d.ts

@@ -0,0 +1,222 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { type L2BlockInfo } from './l2_block_info.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+/** Subtype for invalid block validation results */
+export type ValidateBlockNegativeResult = {
+    valid: false;
+    /** Identifiers from the invalid block */
+    block: L2BlockInfo;
+    /** Committee members at the epoch this block was proposed */
+    committee: EthAddress[];
+    /** Epoch in which this block was proposed */
+    epoch: bigint;
+    /** Proposer selection seed for the epoch */
+    seed: bigint;
+    /** List of committee members who signed this block proposal */
+    attestors: EthAddress[];
+    /** Committee attestations for this block as they were posted to L1 */
+    attestations: CommitteeAttestation[];
+    /** Reason for the block being invalid: not enough attestations were posted */
+    reason: 'insufficient-attestations';
+} | {
+    valid: false;
+    /** Identifiers from the invalid block */
+    block: L2BlockInfo;
+    /** Committee members at the epoch this block was proposed */
+    committee: EthAddress[];
+    /** Epoch in which this block was proposed */
+    epoch: bigint;
+    /** Proposer selection seed for the epoch */
+    seed: bigint;
+    /** List of committee members who signed this block proposal */
+    attestors: EthAddress[];
+    /** Committee attestations for this block as they were posted to L1 */
+    attestations: CommitteeAttestation[];
+    /** Reason for the block being invalid: an invalid attestation was posted */
+    reason: 'invalid-attestation';
+    /** Index in the attestations array of the invalid attestation posted */
+    invalidIndex: number;
+};
+/** Result type for validating a block attestations */
+export type ValidateBlockResult = {
+    valid: true;
+} | ValidateBlockNegativeResult;
+export declare const ValidateBlockResultSchema: z.ZodUnion<[z.ZodObject<{
+    valid: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, {
+    valid: true;
+}, {
+    valid: true;
+}>, z.ZodObject<{
+    valid: z.ZodLiteral<false>;
+    block: z.ZodObject<{
+        blockHash: z.ZodOptional<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>>;
+        archive: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+        lastArchive: z.ZodType<import("@aztec/foundation/schemas").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: import("@aztec/foundation/schemas").Fr;
+        archive: import("@aztec/foundation/schemas").Fr;
+        txCount: number;
+        blockHash?: import("@aztec/foundation/schemas").Fr | undefined;
+    }, {
+        blockNumber: number;
+        slotNumber: number;
+        timestamp: string | number | bigint;
+        lastArchive: string;
+        archive: string;
+        txCount: number;
+        blockHash?: string | undefined;
+    }>;
+    committee: z.ZodArray<z.ZodType<EthAddress, any, string>, "many">;
+    epoch: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    seed: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    attestors: z.ZodArray<z.ZodType<EthAddress, any, string>, "many">;
+    attestations: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        address: z.ZodType<EthAddress, any, string>;
+        signature: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, `0x${string}`, string>, `0x${string}`, string>, import("./proposal/committee_attestation.js").Signature, string>;
+    }, "strip", z.ZodTypeAny, {
+        address: EthAddress;
+        signature: import("./proposal/committee_attestation.js").Signature;
+    }, {
+        address: string;
+        signature: string;
+    }>, CommitteeAttestation, {
+        address: string;
+        signature: string;
+    }>, "many">;
+    reason: z.ZodLiteral<"insufficient-attestations">;
+}, "strip", z.ZodTypeAny, {
+    valid: false;
+    block: {
+        blockNumber: number;
+        slotNumber: number;
+        timestamp: bigint;
+        lastArchive: import("@aztec/foundation/schemas").Fr;
+        archive: import("@aztec/foundation/schemas").Fr;
+        txCount: number;
+        blockHash?: import("@aztec/foundation/schemas").Fr | undefined;
+    };
+    attestations: CommitteeAttestation[];
+    committee: EthAddress[];
+    epoch: bigint;
+    seed: bigint;
+    attestors: EthAddress[];
+    reason: "insufficient-attestations";
+}, {
+    valid: false;
+    block: {
+        blockNumber: number;
+        slotNumber: number;
+        timestamp: string | number | bigint;
+        lastArchive: string;
+        archive: string;
+        txCount: number;
+        blockHash?: string | undefined;
+    };
+    attestations: {
+        address: string;
+        signature: string;
+    }[];
+    committee: string[];
+    epoch: string | number | bigint;
+    seed: string | number | bigint;
+    attestors: string[];
+    reason: "insufficient-attestations";
+}>, z.ZodObject<{
+    valid: z.ZodLiteral<false>;
+    block: z.ZodObject<{
+        blockHash: z.ZodOptional<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>>;
+        archive: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+        lastArchive: z.ZodType<import("@aztec/foundation/schemas").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: import("@aztec/foundation/schemas").Fr;
+        archive: import("@aztec/foundation/schemas").Fr;
+        txCount: number;
+        blockHash?: import("@aztec/foundation/schemas").Fr | undefined;
+    }, {
+        blockNumber: number;
+        slotNumber: number;
+        timestamp: string | number | bigint;
+        lastArchive: string;
+        archive: string;
+        txCount: number;
+        blockHash?: string | undefined;
+    }>;
+    committee: z.ZodArray<z.ZodType<EthAddress, any, string>, "many">;
+    epoch: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    seed: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    attestors: z.ZodArray<z.ZodType<EthAddress, any, string>, "many">;
+    attestations: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        address: z.ZodType<EthAddress, any, string>;
+        signature: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, `0x${string}`, string>, `0x${string}`, string>, import("./proposal/committee_attestation.js").Signature, string>;
+    }, "strip", z.ZodTypeAny, {
+        address: EthAddress;
+        signature: import("./proposal/committee_attestation.js").Signature;
+    }, {
+        address: string;
+        signature: string;
+    }>, CommitteeAttestation, {
+        address: string;
+        signature: string;
+    }>, "many">;
+    reason: z.ZodLiteral<"invalid-attestation">;
+    invalidIndex: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    valid: false;
+    block: {
+        blockNumber: number;
+        slotNumber: number;
+        timestamp: bigint;
+        lastArchive: import("@aztec/foundation/schemas").Fr;
+        archive: import("@aztec/foundation/schemas").Fr;
+        txCount: number;
+        blockHash?: import("@aztec/foundation/schemas").Fr | undefined;
+    };
+    attestations: CommitteeAttestation[];
+    committee: EthAddress[];
+    epoch: bigint;
+    seed: bigint;
+    attestors: EthAddress[];
+    reason: "invalid-attestation";
+    invalidIndex: number;
+}, {
+    valid: false;
+    block: {
+        blockNumber: number;
+        slotNumber: number;
+        timestamp: string | number | bigint;
+        lastArchive: string;
+        archive: string;
+        txCount: number;
+        blockHash?: string | undefined;
+    };
+    attestations: {
+        address: string;
+        signature: string;
+    }[];
+    committee: string[];
+    epoch: string | number | bigint;
+    seed: string | number | bigint;
+    attestors: string[];
+    reason: "invalid-attestation";
+    invalidIndex: number;
+}>]>;
+export declare function serializeValidateBlockResult(result: ValidateBlockResult): Buffer;
+export declare function deserializeValidateBlockResult(bufferOrReader: Buffer | BufferReader): ValidateBlockResult;
+//# sourceMappingURL=validate_block_result.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate_block_result.d.ts","sourceRoot":"","sources":["../../src/block/validate_block_result.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAmB,KAAK,WAAW,EAA4C,MAAM,oBAAoB,CAAC;AACjH,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAE3E,mDAAmD;AACnD,MAAM,MAAM,2BAA2B,GACnC;IACE,KAAK,EAAE,KAAK,CAAC;IACb,yCAAyC;IACzC,KAAK,EAAE,WAAW,CAAC;IACnB,6DAA6D;IAC7D,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB,sEAAsE;IACtE,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,8EAA8E;IAC9E,MAAM,EAAE,2BAA2B,CAAC;CACrC,GACD;IACE,KAAK,EAAE,KAAK,CAAC;IACb,yCAAyC;IACzC,KAAK,EAAE,WAAW,CAAC;IACnB,6DAA6D;IAC7D,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB,sEAAsE;IACtE,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,4EAA4E;IAC5E,MAAM,EAAE,qBAAqB,CAAC;IAC9B,wEAAwE;IACxE,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEN,sDAAsD;AACtD,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,GAAG,2BAA2B,CAAC;AAEhF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuBE,CAAC;AAEzC,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAqBhF;AAED,wBAAgB,8BAA8B,CAAC,cAAc,EAAE,MAAM,GAAG,YAAY,GAAG,mBAAmB,CAsBzG"}

package/dest/block/validate_block_result.js

@@ -0,0 +1,83 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { BlockInfoSchema, deserializeBlockInfo, serializeBlockInfo } from './l2_block_info.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+export const ValidateBlockResultSchema = z.union([
+    z.object({
+        valid: z.literal(true)
+    }),
+    z.object({
+        valid: z.literal(false),
+        block: BlockInfoSchema,
+        committee: z.array(schemas.EthAddress),
+        epoch: schemas.BigInt,
+        seed: schemas.BigInt,
+        attestors: z.array(schemas.EthAddress),
+        attestations: z.array(CommitteeAttestation.schema),
+        reason: z.literal('insufficient-attestations')
+    }),
+    z.object({
+        valid: z.literal(false),
+        block: BlockInfoSchema,
+        committee: z.array(schemas.EthAddress),
+        epoch: schemas.BigInt,
+        seed: schemas.BigInt,
+        attestors: z.array(schemas.EthAddress),
+        attestations: z.array(CommitteeAttestation.schema),
+        reason: z.literal('invalid-attestation'),
+        invalidIndex: z.number()
+    })
+]);
+export function serializeValidateBlockResult(result) {
+    if (result.valid) {
+        return serializeToBuffer(true);
+    }
+    const l2Block = serializeBlockInfo(result.block);
+    return serializeToBuffer(result.valid, result.reason, l2Block.length, l2Block, result.committee.length, result.committee, result.epoch, result.seed ?? 0n, result.attestors.length, result.attestors, result.attestations.length, result.attestations, result.reason === 'invalid-attestation' ? result.invalidIndex : 0);
+}
+export function deserializeValidateBlockResult(bufferOrReader) {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const valid = reader.readBoolean();
+    if (valid) {
+        return {
+            valid
+        };
+    }
+    const reason = reader.readString();
+    const block = deserializeBlockInfo(reader.readBuffer());
+    const committee = reader.readVector(EthAddress);
+    const epoch = reader.readBigInt();
+    const seed = reader.readBigInt();
+    const attestors = reader.readVector(EthAddress);
+    const attestations = reader.readVector(CommitteeAttestation);
+    const invalidIndex = reader.readNumber();
+    if (reason === 'insufficient-attestations') {
+        return {
+            valid,
+            reason,
+            block,
+            committee,
+            epoch,
+            seed,
+            attestors,
+            attestations: attestations
+        };
+    } else if (reason === 'invalid-attestation') {
+        return {
+            valid,
+            reason,
+            block,
+            committee,
+            epoch,
+            seed,
+            attestors,
+            invalidIndex,
+            attestations: attestations
+        };
+    } else {
+        const _ = reason;
+        throw new Error(`Unknown reason: ${reason}`);
+    }
+}

package/dest/checkpoint/checkpoint_body.d.ts

@@ -0,0 +1,4 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { TxEffect } from '../tx/tx_effect.js';
+export declare function getCheckpointBlobFields(txEffectsInBlocks: TxEffect[][]): Fr[];
+//# sourceMappingURL=checkpoint_body.d.ts.map

package/dest/checkpoint/checkpoint_body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint_body.d.ts","sourceRoot":"","sources":["../../src/checkpoint/checkpoint_body.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,wBAAgB,uBAAuB,CAAC,iBAAiB,EAAE,QAAQ,EAAE,EAAE,QAItE"}

package/dest/checkpoint/checkpoint_body.js

@@ -0,0 +1,9 @@
+import { Fr } from '@aztec/foundation/fields';
+import { getBlockBlobFields } from '../block/body.js';
+export function getCheckpointBlobFields(txEffectsInBlocks) {
+    const blockBlobFields = txEffectsInBlocks.map((blockTxEffects)=>getBlockBlobFields(blockTxEffects)).flat();
+    const totalNumBlobFields = blockBlobFields.length + 1; // +1 for the prefix indicating the number of total blob fields in a checkpoint.
+    return [
+        new Fr(totalNumBlobFields)
+    ].concat(blockBlobFields);
+}

package/dest/checkpoint/index.d.ts

@@ -0,0 +1,2 @@
+export * from './checkpoint_body.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/checkpoint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/checkpoint/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}