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

package/dest/block/proposal/attestations_and_signers.js

@@ -0,0 +1,99 @@
+import { hexToBuffer } from '@aztec/foundation/string';
+import { encodeAbiParameters, parseAbiParameters } from 'viem';
+import { z } from 'zod';
+import { CommitteeAttestation } from './committee_attestation.js';
+export class CommitteeAttestationsAndSigners {
+    attestations;
+    constructor(attestations){
+        this.attestations = attestations;
+    }
+    static get schema() {
+        return z.object({
+            attestations: CommitteeAttestation.schema.array()
+        }).transform((obj)=>new CommitteeAttestationsAndSigners(obj.attestations));
+    }
+    getPayloadToSign(domainSeparator) {
+        const abi = parseAbiParameters('uint8,(bytes,bytes),address[]');
+        const packed = this.getPackedAttestations();
+        const encodedData = encodeAbiParameters(abi, [
+            domainSeparator,
+            [
+                packed.signatureIndices,
+                packed.signaturesOrAddresses
+            ],
+            this.getSigners().map((s)=>s.toString())
+        ]);
+        return hexToBuffer(encodedData);
+    }
+    static empty() {
+        return new CommitteeAttestationsAndSigners([]);
+    }
+    toString() {
+        throw new Error('Not implemented');
+    }
+    getSigners() {
+        return this.attestations.filter((a)=>!a.signature.isEmpty()).map((a)=>a.address);
+    }
+    getSignedAttestations() {
+        return this.attestations.filter((a)=>!a.signature.isEmpty());
+    }
+    /**
+   * Packs an array of committee attestations into the format expected by the Solidity contract
+   *
+   * @param attestations - Array of committee attestations with addresses and signatures
+   * @returns Packed attestations with bitmap and tightly packed signature/address data
+   */ getPackedAttestations() {
+        const length = this.attestations.length;
+        const attestations = this.attestations.map((a)=>a.toViem());
+        // Calculate bitmap size (1 bit per attestation, rounded up to nearest byte)
+        const bitmapSize = Math.ceil(length / 8);
+        const signatureIndices = new Uint8Array(bitmapSize);
+        // Calculate total data size needed
+        let totalDataSize = 0;
+        for(let i = 0; i < length; i++){
+            const signature = attestations[i].signature;
+            // Check if signature is empty (v = 0)
+            const isEmpty = signature.v === 0;
+            if (!isEmpty) {
+                totalDataSize += 65; // v (1) + r (32) + s (32)
+            } else {
+                totalDataSize += 20; // address only
+            }
+        }
+        const signaturesOrAddresses = new Uint8Array(totalDataSize);
+        let dataIndex = 0;
+        // Pack the data
+        for(let i = 0; i < length; i++){
+            const attestation = attestations[i];
+            const signature = attestation.signature;
+            // Check if signature is empty
+            const isEmpty = signature.v === 0;
+            if (!isEmpty) {
+                // Set bit in bitmap (bit 7-0 in each byte, left to right)
+                const byteIndex = Math.floor(i / 8);
+                const bitIndex = 7 - i % 8;
+                signatureIndices[byteIndex] |= 1 << bitIndex;
+                // Pack signature: v + r + s
+                signaturesOrAddresses[dataIndex] = signature.v;
+                dataIndex++;
+                // Pack r (32 bytes)
+                const rBytes = Buffer.from(signature.r.slice(2), 'hex');
+                signaturesOrAddresses.set(rBytes, dataIndex);
+                dataIndex += 32;
+                // Pack s (32 bytes)
+                const sBytes = Buffer.from(signature.s.slice(2), 'hex');
+                signaturesOrAddresses.set(sBytes, dataIndex);
+                dataIndex += 32;
+            } else {
+                // Pack address only (20 bytes)
+                const addrBytes = Buffer.from(attestation.addr.slice(2), 'hex');
+                signaturesOrAddresses.set(addrBytes, dataIndex);
+                dataIndex += 20;
+            }
+        }
+        return {
+            signatureIndices: `0x${Buffer.from(signatureIndices).toString('hex')}`,
+            signaturesOrAddresses: `0x${Buffer.from(signaturesOrAddresses).toString('hex')}`
+        };
+    }
+}

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

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

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

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

package/dest/block/proposal/index.js

@@ -1 +1,2 @@
 export * from './committee_attestation.js';
+export * from './attestations_and_signers.js';

package/dest/block/published_l2_block.d.ts

@@ -1,5 +1,6 @@
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
-import { BlockAttestation } from '../p2p/block_attestation.js';
 import { L2Block } from './l2_block.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 export declare class L1PublishedData {
@@ -21,13 +22,14 @@ export declare class L1PublishedData {
         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.ZodObject<{
+    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>;
@@ -42,11 +44,11 @@ export declare class PublishedL2Block {
                 root: string;
                 nextAvailableLeafIndex: string | number | bigint;
             }>;
-            header: import("@aztec/foundation/schemas").ZodFor<import("../tx/block_header.js").BlockHeader>;
+            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("../tx/block_header.js").BlockHeader;
+            header: import("./l2_block_header.js").L2BlockHeader;
             body: import("./body.js").Body;
         }, {
             archive: {
@@ -115,7 +117,27 @@ export declare class PublishedL2Block {
             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;
 }
-export declare function getAttestationsFromPublishedL2Block(block: Pick<PublishedL2Block, 'attestations' | 'block'>): BlockAttestation[];
 //# sourceMappingURL=published_l2_block.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"published_l2_block.d.ts","sourceRoot":"","sources":["../../src/block/published_l2_block.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,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;CAOd;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAMhB;CACF;AAED,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,cAAc,GAAG,OAAO,CAAC,GACtD,gBAAgB,EAAE,CAKpB"}
+{"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

@@ -2,9 +2,8 @@
 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 { BlockAttestation } from '../p2p/block_attestation.js';
-import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { L2Block } from './l2_block.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 export class L1PublishedData {
@@ -26,6 +25,9 @@ export class L1PublishedData {
     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;
@@ -41,10 +43,21 @@ export class PublishedL2Block {
             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);
     }
-}
-export function getAttestationsFromPublishedL2Block(block) {
-    const payload = ConsensusPayload.fromBlock(block.block);
-    return block.attestations.filter((attestation)=>!attestation.signature.isEmpty()).map((attestation)=>new BlockAttestation(block.block.number, payload, attestation.signature));
 }

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

@@ -1 +1 @@
-{"version":3,"file":"l2_tips_store_test_suite.d.ts","sourceRoot":"","sources":["../../../src/block/test/l2_tips_store_test_suite.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE/D,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,QA6ExE"}
+{"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

@@ -1,17 +1,16 @@
 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)=>({
+    const makeBlock = (number)=>PublishedL2Block.fromFields({
             block: {
                 number,
-                header: {
-                    hash: ()=>Promise.resolve(new Fr(number))
-                }
+                hash: ()=>Promise.resolve(new Fr(number))
             },
             l1: {
                 blockNumber: BigInt(number),

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

package/dest/checkpoint/index.js

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

package/dest/config/node-rpc-config.d.ts

@@ -3,6 +3,8 @@ export declare const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig>;
 export type NodeRPCConfig = {
     /** Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`. */
     rpcSimulatePublicMaxGasLimit: number;
+    /** Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. */
+    rpcSimulatePublicMaxDebugLogMemoryReads: number;
     /** Maximum allowed batch size for JSON RPC batch requests. */
     rpcMaxBatchSize: number;
     /** The maximum body size the RPC server will accept */

package/dest/config/node-rpc-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-rpc-config.d.ts","sourceRoot":"","sources":["../../src/config/node-rpc-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,0BAA0B,CAAC;AAEvF,eAAO,MAAM,qBAAqB,EAAE,kBAAkB,CAAC,aAAa,CAgBnE,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,uFAAuF;IACvF,4BAA4B,EAAE,MAAM,CAAC;IACrC,8DAA8D;IAC9D,eAAe,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC"}
+{"version":3,"file":"node-rpc-config.d.ts","sourceRoot":"","sources":["../../src/config/node-rpc-config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,0BAA0B,CAAC;AAEvF,eAAO,MAAM,qBAAqB,EAAE,kBAAkB,CAAC,aAAa,CAsBnE,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,uFAAuF;IACvF,4BAA4B,EAAE,MAAM,CAAC;IACrC,mHAAmH;IACnH,uCAAuC,EAAE,MAAM,CAAC;IAChD,8DAA8D;IAC9D,eAAe,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC"}

package/dest/config/node-rpc-config.js

@@ -1,3 +1,4 @@
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
 import { numberConfigHelper } from '@aztec/foundation/config';
 export const nodeRpcConfigMappings = {
     rpcSimulatePublicMaxGasLimit: {
@@ -5,6 +6,11 @@ export const nodeRpcConfigMappings = {
         description: 'Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`.',
         ...numberConfigHelper(10e9)
     },
+    rpcSimulatePublicMaxDebugLogMemoryReads: {
+        env: 'RPC_SIMULATE_PUBLIC_MAX_DEBUG_LOG_MEMORY_READS',
+        description: 'Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. ',
+        ...numberConfigHelper(DEFAULT_MAX_DEBUG_LOG_MEMORY_READS)
+    },
     rpcMaxBatchSize: {
         env: 'RPC_MAX_BATCH_SIZE',
         description: 'Maximum allowed batch size for JSON RPC batch requests.',

package/dest/contract/contract_address.d.ts

@@ -3,7 +3,7 @@ import { type FunctionAbi, FunctionSelector } from '../abi/index.js';
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { ContractInstance } from './interfaces/contract_instance.js';
 /**
- * Returns the deployment address for a given contract instance as defined on the [Protocol Specs](../../../../docs/docs/protocol-specs/addresses-and-keys/specification.md).
+ * Returns the deployment address for a given contract instance.
  * ```
  * salted_initialization_hash = pedersen([salt, initialization_hash, deployer], GENERATOR__SALTED_INITIALIZATION_HASH)
  * partial_address = pedersen([contract_class_id, salted_initialization_hash], GENERATOR__CONTRACT_PARTIAL_ADDRESS_V1)

package/dest/contract/contract_address.js

@@ -6,7 +6,7 @@ import { computeVarArgsHash } from '../hash/hash.js';
 import { computeAddress } from '../keys/index.js';
 // TODO(@spalladino): Review all generator indices in this file
 /**
- * Returns the deployment address for a given contract instance as defined on the [Protocol Specs](../../../../docs/docs/protocol-specs/addresses-and-keys/specification.md).
+ * Returns the deployment address for a given contract instance.
  * ```
  * salted_initialization_hash = pedersen([salt, initialization_hash, deployer], GENERATOR__SALTED_INITIALIZATION_HASH)
  * partial_address = pedersen([contract_class_id, salted_initialization_hash], GENERATOR__CONTRACT_PARTIAL_ADDRESS_V1)