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

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

@@ -0,0 +1 @@
+{"version":3,"file":"attestations_and_signers.d.ts","sourceRoot":"","sources":["../../../src/block/proposal/attestations_and_signers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAIjE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,QAAQ,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACvF,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE9E,qBAAa,+BAAgC,YAAW,QAAQ;IAC3C,YAAY,EAAE,oBAAoB,EAAE;IAAvD,YAAmB,YAAY,EAAE,oBAAoB,EAAE,EAAI;IAE3D,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;OAMhB;IAED,gBAAgB,CAAC,eAAe,EAAE,wBAAwB,GAAG,MAAM,CAWlE;IAED,MAAM,CAAC,KAAK,IAAI,+BAA+B,CAE9C;IAED,QAAQ,SAEP;IAED,UAAU,iBAET;IAED,qBAAqB,2BAEpB;IAED;;;;;OAKG;IACH,qBAAqB,IAAI,yBAAyB,CAgEjD;CACF;AAED;;;;;GAKG;AACH,qBAAa,wCAAyC,SAAQ,+BAA+B;IAGzF,OAAO,CAAC,OAAO;IAFjB,YACE,YAAY,EAAE,oBAAoB,EAAE,EAC5B,OAAO,EAAE,UAAU,EAAE,EAG9B;IAEQ,UAAU,IAAI,UAAU,EAAE,CAElC;CACF"}

package/dest/block/proposal/attestations_and_signers.js

@@ -0,0 +1,113 @@
+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')}`
+        };
+    }
+}
+/**
+ * Malicious extension of CommitteeAttestationsAndSigners that keeps separate attestations and
+ * signers. Used for tricking the L1 contract into accepting attestations by reconstructing
+ * the correct committee commitment (which relies on the signers, ignoring the signatures)
+ * with an invalid set of attestation signatures.
+ */ export class MaliciousCommitteeAttestationsAndSigners extends CommitteeAttestationsAndSigners {
+    signers;
+    constructor(attestations, signers){
+        super(attestations), this.signers = signers;
+    }
+    getSigners() {
+        return this.signers;
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+export { EthAddress, Signature };
+export declare class CommitteeAttestation {
+    readonly address: EthAddress;
+    readonly signature: Signature;
+    constructor(address: EthAddress, signature: Signature);
+    static get schema(): 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>, Signature, string>;
+    }, "strip", z.ZodTypeAny, {
+        address: EthAddress;
+        signature: Signature;
+    }, {
+        address: string;
+        signature: string;
+    }>, CommitteeAttestation, {
+        address: string;
+        signature: string;
+    }>;
+    static fromAddress(address: EthAddress): CommitteeAttestation;
+    static fromAddressAndSignature(address: EthAddress, signature: Signature): CommitteeAttestation;
+    static fromSignature(signature: Signature): CommitteeAttestation;
+    static fromViem(viem: ViemCommitteeAttestation): CommitteeAttestation;
+    static fromBuffer(buffer: Buffer | BufferReader): CommitteeAttestation;
+    static random(): CommitteeAttestation;
+    static empty(): CommitteeAttestation;
+    static fromPacked(packed: ViemCommitteeAttestations, committeeSize: number): CommitteeAttestation[];
+    toBuffer(): Buffer;
+    equals(other: CommitteeAttestation): boolean;
+    toViem(): ViemCommitteeAttestation;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWl0dGVlX2F0dGVzdGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmxvY2svcHJvcG9zYWwvY29tbWl0dGVlX2F0dGVzdGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLHdCQUF3QixFQUFFLHlCQUF5QixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDM0YsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzNELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM1RCxPQUFPLEVBQUUsWUFBWSxFQUFxQixNQUFNLDZCQUE2QixDQUFDO0FBRTlFLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLFVBQVUsRUFBRSxTQUFTLEVBQUUsQ0FBQztBQUVqQyxxQkFBYSxvQkFBb0I7YUFFYixPQUFPLEVBQUUsVUFBVTthQUNuQixTQUFTLEVBQUUsU0FBUztJQUZ0QyxZQUNrQixPQUFPLEVBQUUsVUFBVSxFQUNuQixTQUFTLEVBQUUsU0FBUyxFQUNsQztJQUVKLE1BQU0sS0FBSyxNQUFNOzs7Ozs7Ozs7Ozs7T0FPaEI7SUFHRCxNQUFNLENBQUMsV0FBVyxDQUFDLE9BQU8sRUFBRSxVQUFVLEdBQUcsb0JBQW9CLENBRTVEO0lBR0QsTUFBTSxDQUFDLHVCQUF1QixDQUFDLE9BQU8sRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLFNBQVMsR0FBRyxvQkFBb0IsQ0FFOUY7SUFFRCxNQUFNLENBQUMsYUFBYSxDQUFDLFNBQVMsRUFBRSxTQUFTLEdBQUcsb0JBQW9CLENBRS9EO0lBRUQsTUFBTSxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsd0JBQXdCLEdBQUcsb0JBQW9CLENBRXBFO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxvQkFBb0IsQ0FLckU7SUFFRCxNQUFNLENBQUMsTUFBTSxJQUFJLG9CQUFvQixDQUdwQztJQUVELE1BQU0sQ0FBQyxLQUFLLElBQUksb0JBQW9CLENBRW5DO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUseUJBQXlCLEVBQUUsYUFBYSxFQUFFLE1BQU0sR0FBRyxvQkFBb0IsRUFBRSxDQTZDbEc7SUFFRCxRQUFRLElBQUksTUFBTSxDQUVqQjtJQUVELE1BQU0sQ0FBQyxLQUFLLEVBQUUsb0JBQW9CLEdBQUcsT0FBTyxDQUUzQztJQUVELE1BQU0sSUFBSSx3QkFBd0IsQ0FLakM7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"committee_attestation.d.ts","sourceRoot":"","sources":["../../../src/block/proposal/committee_attestation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAC3F,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;AAEjC,qBAAa,oBAAoB;aAEb,OAAO,EAAE,UAAU;aACnB,SAAS,EAAE,SAAS;IAFtC,YACkB,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,SAAS,EAClC;IAEJ,MAAM,KAAK,MAAM;;;;;;;;;;;;OAOhB;IAGD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,oBAAoB,CAE5D;IAGD,MAAM,CAAC,uBAAuB,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,oBAAoB,CAE9F;IAED,MAAM,CAAC,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,oBAAoB,CAE/D;IAED,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,GAAG,oBAAoB,CAEpE;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,oBAAoB,CAKrE;IAED,MAAM,CAAC,MAAM,IAAI,oBAAoB,CAGpC;IAED,MAAM,CAAC,KAAK,IAAI,oBAAoB,CAEnC;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,yBAAyB,EAAE,aAAa,EAAE,MAAM,GAAG,oBAAoB,EAAE,CA6ClG;IAED,QAAQ,IAAI,MAAM,CAEjB;IAED,MAAM,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAE3C;IAED,MAAM,IAAI,wBAAwB,CAKjC;CACF"}

package/dest/block/proposal/committee_attestation.js

@@ -0,0 +1,101 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+export { EthAddress, Signature };
+export class CommitteeAttestation {
+    address;
+    signature;
+    constructor(address, signature){
+        this.address = address;
+        this.signature = signature;
+    }
+    static get schema() {
+        return z.object({
+            address: EthAddress.schema,
+            signature: Signature.schema
+        }).transform(({ address, signature })=>new CommitteeAttestation(address, signature));
+    }
+    // Create an empty attestation for an address that has not signed
+    static fromAddress(address) {
+        return new CommitteeAttestation(address, Signature.empty());
+    }
+    // Create an attestation from an address and a signature
+    static fromAddressAndSignature(address, signature) {
+        return new CommitteeAttestation(address, signature);
+    }
+    static fromSignature(signature) {
+        return new CommitteeAttestation(EthAddress.ZERO, signature);
+    }
+    static fromViem(viem) {
+        return new CommitteeAttestation(EthAddress.fromString(viem.addr), Signature.fromViemSignature(viem.signature));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const address = reader.readObject(EthAddress);
+        const signature = reader.readObject(Signature);
+        return new CommitteeAttestation(address, signature);
+    }
+    static random() {
+        // note: will be invalid
+        return new CommitteeAttestation(EthAddress.random(), Signature.random());
+    }
+    static empty() {
+        return new CommitteeAttestation(EthAddress.ZERO, Signature.empty());
+    }
+    static fromPacked(packed, committeeSize) {
+        const signatureIndicesBuffer = Buffer.from(packed.signatureIndices.slice(2), 'hex');
+        const dataBuffer = Buffer.from(packed.signaturesOrAddresses.slice(2), 'hex');
+        const attestations = [];
+        let dataIndex = 0;
+        for(let i = 0; i < committeeSize; i++){
+            // Check if this position has a signature
+            const byteIndex = Math.floor(i / 8);
+            const bitIndex = 7 - i % 8;
+            const hasSignature = byteIndex < signatureIndicesBuffer.length && (signatureIndicesBuffer[byteIndex] & 1 << bitIndex) !== 0;
+            if (hasSignature) {
+                // Extract signature: v (1 byte) + r (32 bytes) + s (32 bytes)
+                if (dataIndex + 65 > dataBuffer.length) {
+                    throw new Error(`Insufficient data for signature at position ${i}`);
+                }
+                const v = dataBuffer[dataIndex];
+                const r = `0x${dataBuffer.subarray(dataIndex + 1, dataIndex + 33).toString('hex')}`;
+                const s = `0x${dataBuffer.subarray(dataIndex + 33, dataIndex + 65).toString('hex')}`;
+                const signature = Signature.fromViemSignature({
+                    r,
+                    s,
+                    v
+                });
+                // For signed attestations, we use a zero address as the address is recovered from the signature
+                attestations.push(new CommitteeAttestation(EthAddress.ZERO, signature));
+                dataIndex += 65;
+            } else {
+                // Extract address (20 bytes)
+                if (dataIndex + 20 > dataBuffer.length) {
+                    throw new Error(`Insufficient data for address at position ${i}`);
+                }
+                const addressBytes = dataBuffer.subarray(dataIndex, dataIndex + 20);
+                const address = EthAddress.fromString(`0x${addressBytes.toString('hex')}`);
+                // For address-only attestations, use empty signature
+                attestations.push(new CommitteeAttestation(address, Signature.empty()));
+                dataIndex += 20;
+            }
+        }
+        return attestations;
+    }
+    toBuffer() {
+        return serializeToBuffer([
+            this.address,
+            this.signature
+        ]);
+    }
+    equals(other) {
+        return this.address.equals(other.address) && this.signature.equals(other.signature);
+    }
+    toViem() {
+        return {
+            addr: this.address.toString(),
+            signature: this.signature.toViemSignature()
+        };
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './committee_attestation.js';
+export * from './attestations_and_signers.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ibG9jay9wcm9wb3NhbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsK0JBQStCLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"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

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

package/dest/block/published_l2_block.d.ts

@@ -0,0 +1,130 @@
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import { L1PublishedData, PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
+import { L2Block } from './l2_block.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+/**
+ * @deprecated `PublishedCheckpoint` is what will be retrieved from L1.
+ * L2 blocks do not need to link to L1PublishedData directly.
+ * TODO: Create another type (AttestedL2Block?) for an L2 block and its attestations.
+ */
+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("../../../foundation/dest/fields/fields.js").Fr, any, string>;
+                nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                root: import("../../../foundation/dest/fields/fields.js").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("../schemas/schemas.js").ZodFor<import("./l2_block_header.js").L2BlockHeader>;
+            body: import("../schemas/schemas.js").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("./proposal/committee_attestation.js").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("./proposal/committee_attestation.js").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;
+    toPublishedCheckpoint(): PublishedCheckpoint;
+    static fromPublishedCheckpoint(checkpoint: PublishedCheckpoint): PublishedL2Block;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGlzaGVkX2wyX2Jsb2NrLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYmxvY2svcHVibGlzaGVkX2wyX2Jsb2NrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxZQUFZLEVBQXFCLE1BQU0sNkJBQTZCLENBQUM7QUFDOUUsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFeEQsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEVBQUUsZUFBZSxFQUFFLG1CQUFtQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDN0YsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN4QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUUzRTs7OztHQUlHO0FBQ0gscUJBQWEsZ0JBQWdCO0lBRWxCLEtBQUssRUFBRSxPQUFPO0lBQ2QsRUFBRSxFQUFFLGVBQWU7SUFDbkIsWUFBWSxFQUFFLG9CQUFvQixFQUFFO0lBSDdDLFlBQ1MsS0FBSyxFQUFFLE9BQU8sRUFDZCxFQUFFLEVBQUUsZUFBZSxFQUNuQixZQUFZLEVBQUUsb0JBQW9CLEVBQUUsRUFDekM7SUFFSixNQUFNLEtBQUssTUFBTTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztPQVFoQjtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsY0FBYyxFQUFFLE1BQU0sR0FBRyxZQUFZLEdBQUcsZ0JBQWdCLENBUXpFO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLGdCQUFnQixDQUFDLG9CQUVuRDtJQUVNLFFBQVEsSUFBSSxNQUFNLENBU3hCO0lBRU0scUJBQXFCLHdCQUUzQjtJQUVELE1BQU0sQ0FBQyx1QkFBdUIsQ0FBQyxVQUFVLEVBQUUsbUJBQW1CLG9CQUU3RDtDQUNGIn0=

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":"AACA,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,eAAe,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAC7F,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAE3E;;;;GAIG;AACH,qBAAa,gBAAgB;IAElB,KAAK,EAAE,OAAO;IACd,EAAE,EAAE,eAAe;IACnB,YAAY,EAAE,oBAAoB,EAAE;IAH7C,YACS,KAAK,EAAE,OAAO,EACd,EAAE,EAAE,eAAe,EACnB,YAAY,EAAE,oBAAoB,EAAE,EACzC;IAEJ,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAQhB;IAED,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,YAAY,GAAG,gBAAgB,CAQzE;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,oBAEnD;IAEM,QAAQ,IAAI,MAAM,CASxB;IAEM,qBAAqB,wBAE3B;IAED,MAAM,CAAC,uBAAuB,CAAC,UAAU,EAAE,mBAAmB,oBAE7D;CACF"}

package/dest/block/published_l2_block.js

@@ -0,0 +1,48 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { L1PublishedData, PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
+import { L2Block } from './l2_block.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+/**
+ * @deprecated `PublishedCheckpoint` is what will be retrieved from L1.
+ * L2 blocks do not need to link to L1PublishedData directly.
+ * TODO: Create another type (AttestedL2Block?) for an L2 block and its attestations.
+ */ 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);
+    }
+    toPublishedCheckpoint() {
+        return new PublishedCheckpoint(this.block.toCheckpoint(), this.l1, this.attestations);
+    }
+    static fromPublishedCheckpoint(checkpoint) {
+        return new PublishedL2Block(L2Block.fromCheckpoint(checkpoint.checkpoint), checkpoint.l1, checkpoint.attestations);
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './l2_tips_store_test_suite.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ibG9jay90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUMifQ==

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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDJfdGlwc19zdG9yZV90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmxvY2svdGVzdC9sMl90aXBzX3N0b3JlX3Rlc3Rfc3VpdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBTUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFL0Qsd0JBQWdCLGVBQWUsQ0FBQyxhQUFhLEVBQUUsTUFBTSxPQUFPLENBQUMsV0FBVyxDQUFDLFFBOEV4RSJ9

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,50 @@
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader } from '@aztec/foundation/serialize';
+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: EpochNumber;
+    /** 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: EpochNumber;
+    /** 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: ZodFor<ValidateBlockResult>;
+export declare function serializeValidateBlockResult(result: ValidateBlockResult): Buffer;
+export declare function deserializeValidateBlockResult(bufferOrReader: Buffer | BufferReader): ValidateBlockResult;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGVfYmxvY2tfcmVzdWx0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYmxvY2svdmFsaWRhdGVfYmxvY2tfcmVzdWx0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQXFCLE1BQU0saUNBQWlDLENBQUM7QUFDakYsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzNELE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBVyxNQUFNLDJCQUEyQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxZQUFZLEVBQXFCLE1BQU0sNkJBQTZCLENBQUM7QUFJOUUsT0FBTyxFQUFtQixLQUFLLFdBQVcsRUFBNEMsTUFBTSxvQkFBb0IsQ0FBQztBQUNqSCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUUzRSxtREFBbUQ7QUFDbkQsTUFBTSxNQUFNLDJCQUEyQixHQUNuQztJQUNFLEtBQUssRUFBRSxLQUFLLENBQUM7SUFDYix5Q0FBeUM7SUFDekMsS0FBSyxFQUFFLFdBQVcsQ0FBQztJQUNuQiw2REFBNkQ7SUFDN0QsU0FBUyxFQUFFLFVBQVUsRUFBRSxDQUFDO0lBQ3hCLDZDQUE2QztJQUM3QyxLQUFLLEVBQUUsV0FBVyxDQUFDO0lBQ25CLDRDQUE0QztJQUM1QyxJQUFJLEVBQUUsTUFBTSxDQUFDO0lBQ2IsK0RBQStEO0lBQy9ELFNBQVMsRUFBRSxVQUFVLEVBQUUsQ0FBQztJQUN4QixzRUFBc0U7SUFDdEUsWUFBWSxFQUFFLG9CQUFvQixFQUFFLENBQUM7SUFDckMsOEVBQThFO0lBQzlFLE1BQU0sRUFBRSwyQkFBMkIsQ0FBQztDQUNyQyxHQUNEO0lBQ0UsS0FBSyxFQUFFLEtBQUssQ0FBQztJQUNiLHlDQUF5QztJQUN6QyxLQUFLLEVBQUUsV0FBVyxDQUFDO0lBQ25CLDZEQUE2RDtJQUM3RCxTQUFTLEVBQUUsVUFBVSxFQUFFLENBQUM7SUFDeEIsNkNBQTZDO0lBQzdDLEtBQUssRUFBRSxXQUFXLENBQUM7SUFDbkIsNENBQTRDO0lBQzVDLElBQUksRUFBRSxNQUFNLENBQUM7SUFDYiwrREFBK0Q7SUFDL0QsU0FBUyxFQUFFLFVBQVUsRUFBRSxDQUFDO0lBQ3hCLHNFQUFzRTtJQUN0RSxZQUFZLEVBQUUsb0JBQW9CLEVBQUUsQ0FBQztJQUNyQyw0RUFBNEU7SUFDNUUsTUFBTSxFQUFFLHFCQUFxQixDQUFDO0lBQzlCLHdFQUF3RTtJQUN4RSxZQUFZLEVBQUUsTUFBTSxDQUFDO0NBQ3RCLENBQUM7QUFHTixzREFBc0Q7QUFDdEQsTUFBTSxNQUFNLG1CQUFtQixHQUFHO0lBQUUsS0FBSyxFQUFFLElBQUksQ0FBQTtDQUFFLEdBQUcsMkJBQTJCLENBQUM7QUFFaEYsZUFBTyxNQUFNLHlCQUF5QixFQUFFLE1BQU0sQ0FBQyxtQkFBbUIsQ0F1QmhFLENBQUM7QUFFSCx3QkFBZ0IsNEJBQTRCLENBQUMsTUFBTSxFQUFFLG1CQUFtQixHQUFHLE1BQU0sQ0FxQmhGO0FBRUQsd0JBQWdCLDhCQUE4QixDQUFDLGNBQWMsRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLG1CQUFtQixDQXNCekcifQ==

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,WAAW,EAAqB,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAI9E,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,WAAW,CAAC;IACnB,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,WAAW,CAAC;IACnB,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;AAGN,sDAAsD;AACtD,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,GAAG,2BAA2B,CAAC;AAEhF,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,mBAAmB,CAuBhE,CAAC;AAEH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAqBhF;AAED,wBAAgB,8BAA8B,CAAC,cAAc,EAAE,MAAM,GAAG,YAAY,GAAG,mBAAmB,CAsBzG"}