@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/checkpoint/checkpoint_data.d.ts

@@ -0,0 +1,97 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { z } from 'zod';
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { L1PublishedData } from './published_checkpoint.js';
+/** Base type for checkpoint data */
+export type CommonCheckpointData = {
+    checkpointNumber: CheckpointNumber;
+    header: CheckpointHeader;
+    startBlock: BlockNumber;
+    blockCount: number;
+};
+/** Data stored with checkpoint data after publishing on l1 */
+export type L1EnrichedCheckpointData = {
+    attestations: CommitteeAttestation[];
+    l1: L1PublishedData;
+};
+/** Data stored alongside checkpoint data in storage */
+export type StorageEnrichedCheckpointData = {
+    archive: AppendOnlyTreeSnapshot;
+    checkpointOutHash: Fr;
+    /** Fee asset price modifier in basis points. Defaults to 0 (no change) when not explicitly set. */
+    feeAssetPriceModifier: bigint;
+};
+/** Data stored only with proposed checkpoint data  */
+export type ProposedOnlyCheckpointData = {
+    totalManaUsed: bigint;
+    feeAssetPriceModifier: bigint;
+};
+/** Lightweight checkpoint metadata without full block data. */
+export type CheckpointData = CommonCheckpointData & StorageEnrichedCheckpointData & L1EnrichedCheckpointData;
+/** Input for setting a proposed checkpoint. The archive and checkpointOutHash are computed
+ *  internally by the block store from the stored blocks. */
+export type ProposedCheckpointInput = CommonCheckpointData & ProposedOnlyCheckpointData;
+/** Full data for a proposed checkpoint (proposed but not yet L1-confirmed).
+ *  Includes fee-relevant fields used during pipelining to compute the fee header override. */
+export type ProposedCheckpointData = ProposedCheckpointInput & StorageEnrichedCheckpointData;
+export declare const ProposedCheckpointDataSchema: z.ZodObject<{
+    checkpointNumber: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<CheckpointNumber, number>>;
+    header: import("@aztec/foundation/schemas").ZodFor<CheckpointHeader>;
+    archive: z.ZodPipe<z.ZodObject<{
+        root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+    }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+        root: Fr;
+        nextAvailableLeafIndex: number;
+    }>>;
+    checkpointOutHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+    startBlock: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodPipe<z.ZodBigInt, z.ZodTransform<number, bigint>>, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>, z.ZodTransform<BlockNumber, number>>;
+    blockCount: z.ZodNumber;
+    totalManaUsed: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+    feeAssetPriceModifier: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+}, z.core.$strip>;
+export declare const CheckpointDataSchema: z.ZodPipe<z.ZodObject<{
+    checkpointNumber: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<CheckpointNumber, number>>;
+    header: import("@aztec/foundation/schemas").ZodFor<CheckpointHeader>;
+    archive: z.ZodPipe<z.ZodObject<{
+        root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+    }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+        root: Fr;
+        nextAvailableLeafIndex: number;
+    }>>;
+    checkpointOutHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+    startBlock: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodPipe<z.ZodBigInt, z.ZodTransform<number, bigint>>, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>, z.ZodTransform<BlockNumber, number>>;
+    blockCount: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+    feeAssetPriceModifier: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+    attestations: z.ZodArray<z.ZodPipe<z.ZodObject<{
+        address: z.ZodType<import("@aztec/foundation/eth-address").EthAddress, string, z.core.$ZodTypeInternals<import("@aztec/foundation/eth-address").EthAddress, string>>;
+        signature: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<import("../block/proposal/committee_attestation.js").Signature, `0x${string}`>>;
+    }, z.core.$strip>, z.ZodTransform<CommitteeAttestation, {
+        address: import("@aztec/foundation/eth-address").EthAddress;
+        signature: import("../block/proposal/committee_attestation.js").Signature;
+    }>>>;
+    l1: z.ZodPipe<z.ZodObject<{
+        blockNumber: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+        timestamp: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+        blockHash: z.ZodString;
+    }, z.core.$strip>, z.ZodTransform<L1PublishedData, {
+        blockNumber: bigint;
+        timestamp: bigint;
+        blockHash: string;
+    }>>;
+}, z.core.$strip>, z.ZodTransform<CheckpointData, {
+    checkpointNumber: CheckpointNumber;
+    header: CheckpointHeader;
+    archive: AppendOnlyTreeSnapshot;
+    checkpointOutHash: Fr;
+    startBlock: BlockNumber;
+    blockCount: number;
+    feeAssetPriceModifier: bigint;
+    attestations: CommitteeAttestation[];
+    l1: L1PublishedData;
+}>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2twb2ludF9kYXRhLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hlY2twb2ludC9jaGVja3BvaW50X2RhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLFdBQVcsRUFFWCxnQkFBZ0IsRUFFakIsTUFBTSxpQ0FBaUMsQ0FBQztBQUN6QyxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFHcEQsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUNsRixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNsRSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUMvRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFNUQsb0NBQW9DO0FBQ3BDLE1BQU0sTUFBTSxvQkFBb0IsR0FBRztJQUNqQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsQ0FBQztJQUNuQyxNQUFNLEVBQUUsZ0JBQWdCLENBQUM7SUFDekIsVUFBVSxFQUFFLFdBQVcsQ0FBQztJQUN4QixVQUFVLEVBQUUsTUFBTSxDQUFDO0NBQ3BCLENBQUM7QUFFRiw4REFBOEQ7QUFDOUQsTUFBTSxNQUFNLHdCQUF3QixHQUFHO0lBQ3JDLFlBQVksRUFBRSxvQkFBb0IsRUFBRSxDQUFDO0lBQ3JDLEVBQUUsRUFBRSxlQUFlLENBQUM7Q0FDckIsQ0FBQztBQUVGLHVEQUF1RDtBQUN2RCxNQUFNLE1BQU0sNkJBQTZCLEdBQUc7SUFDMUMsT0FBTyxFQUFFLHNCQUFzQixDQUFDO0lBQ2hDLGlCQUFpQixFQUFFLEVBQUUsQ0FBQztJQUN0QixtR0FBbUc7SUFDbkcscUJBQXFCLEVBQUUsTUFBTSxDQUFDO0NBQy9CLENBQUM7QUFFRixzREFBc0Q7QUFDdEQsTUFBTSxNQUFNLDBCQUEwQixHQUFHO0lBQ3ZDLGFBQWEsRUFBRSxNQUFNLENBQUM7SUFDdEIscUJBQXFCLEVBQUUsTUFBTSxDQUFDO0NBQy9CLENBQUM7QUFFRiwrREFBK0Q7QUFDL0QsTUFBTSxNQUFNLGNBQWMsR0FBRyxvQkFBb0IsR0FBRyw2QkFBNkIsR0FBRyx3QkFBd0IsQ0FBQztBQUU3Rzs0REFDNEQ7QUFDNUQsTUFBTSxNQUFNLHVCQUF1QixHQUFHLG9CQUFvQixHQUFHLDBCQUEwQixDQUFDO0FBRXhGOzhGQUM4RjtBQUM5RixNQUFNLE1BQU0sc0JBQXNCLEdBQUcsdUJBQXVCLEdBQUcsNkJBQTZCLENBQUM7QUFFN0YsZUFBTyxNQUFNLDRCQUE0Qjs7Ozs7Ozs7Ozs7Ozs7O2lCQVN2QyxDQUFDO0FBRUgsZUFBTyxNQUFNLG9CQUFvQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXdCOUIsQ0FBQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint_data.d.ts","sourceRoot":"","sources":["../../src/checkpoint/checkpoint_data.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EAEX,gBAAgB,EAEjB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGpD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,oCAAoC;AACpC,MAAM,MAAM,oBAAoB,GAAG;IACjC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,MAAM,EAAE,gBAAgB,CAAC;IACzB,UAAU,EAAE,WAAW,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,8DAA8D;AAC9D,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,EAAE,EAAE,eAAe,CAAC;CACrB,CAAC;AAEF,uDAAuD;AACvD,MAAM,MAAM,6BAA6B,GAAG;IAC1C,OAAO,EAAE,sBAAsB,CAAC;IAChC,iBAAiB,EAAE,EAAE,CAAC;IACtB,mGAAmG;IACnG,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,sDAAsD;AACtD,MAAM,MAAM,0BAA0B,GAAG;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG,oBAAoB,GAAG,6BAA6B,GAAG,wBAAwB,CAAC;AAE7G;4DAC4D;AAC5D,MAAM,MAAM,uBAAuB,GAAG,oBAAoB,GAAG,0BAA0B,CAAC;AAExF;8FAC8F;AAC9F,MAAM,MAAM,sBAAsB,GAAG,uBAAuB,GAAG,6BAA6B,CAAC;AAE7F,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;iBASvC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwB9B,CAAC"}

package/dest/checkpoint/checkpoint_data.js

@@ -0,0 +1,38 @@
+import { BlockNumberSchema, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { schemas } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { L1PublishedData } from './published_checkpoint.js';
+export const ProposedCheckpointDataSchema = z.object({
+    checkpointNumber: CheckpointNumberSchema,
+    header: CheckpointHeader.schema,
+    archive: AppendOnlyTreeSnapshot.schema,
+    checkpointOutHash: schemas.Fr,
+    startBlock: BlockNumberSchema,
+    blockCount: z.number(),
+    totalManaUsed: schemas.BigInt,
+    feeAssetPriceModifier: schemas.BigInt
+});
+export const CheckpointDataSchema = z.object({
+    checkpointNumber: CheckpointNumberSchema,
+    header: CheckpointHeader.schema,
+    archive: AppendOnlyTreeSnapshot.schema,
+    checkpointOutHash: schemas.Fr,
+    startBlock: BlockNumberSchema,
+    blockCount: schemas.Integer,
+    feeAssetPriceModifier: schemas.BigInt,
+    attestations: z.array(CommitteeAttestation.schema),
+    l1: L1PublishedData.schema
+}).transform((obj)=>({
+        checkpointNumber: obj.checkpointNumber,
+        header: obj.header,
+        archive: obj.archive,
+        checkpointOutHash: obj.checkpointOutHash,
+        startBlock: obj.startBlock,
+        blockCount: obj.blockCount,
+        feeAssetPriceModifier: obj.feeAssetPriceModifier,
+        attestations: obj.attestations,
+        l1: obj.l1
+    }));

package/dest/checkpoint/checkpoint_info.d.ts

@@ -0,0 +1,22 @@
+import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+export type CheckpointInfo = {
+    archive: Fr;
+    lastArchive: Fr;
+    slotNumber: SlotNumber;
+    checkpointNumber: CheckpointNumber;
+    timestamp: bigint;
+};
+export declare function randomCheckpointInfo(checkpointNumber?: CheckpointNumber | number): CheckpointInfo;
+export declare const CheckpointInfoSchema: z.ZodObject<{
+    archive: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+    lastArchive: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+    slotNumber: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<SlotNumber, number>>;
+    checkpointNumber: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<CheckpointNumber, number>>;
+    timestamp: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+}, z.core.$strip>;
+export declare function serializeCheckpointInfo(info: CheckpointInfo): Buffer;
+export declare function deserializeCheckpointInfo(buffer: Buffer | BufferReader): CheckpointInfo;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2twb2ludF9pbmZvLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hlY2twb2ludC9jaGVja3BvaW50X2luZm8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLGdCQUFnQixFQUVoQixVQUFVLEVBRVgsTUFBTSxpQ0FBaUMsQ0FBQztBQUN6QyxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFcEQsT0FBTyxFQUFFLFlBQVksRUFBcUIsTUFBTSw2QkFBNkIsQ0FBQztBQUU5RSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLE1BQU0sTUFBTSxjQUFjLEdBQUc7SUFDM0IsT0FBTyxFQUFFLEVBQUUsQ0FBQztJQUNaLFdBQVcsRUFBRSxFQUFFLENBQUM7SUFDaEIsVUFBVSxFQUFFLFVBQVUsQ0FBQztJQUN2QixnQkFBZ0IsRUFBRSxnQkFBZ0IsQ0FBQztJQUNuQyxTQUFTLEVBQUUsTUFBTSxDQUFDO0NBQ25CLENBQUM7QUFFRix3QkFBZ0Isb0JBQW9CLENBQUMsZ0JBQWdCLENBQUMsRUFBRSxnQkFBZ0IsR0FBRyxNQUFNLEdBQUcsY0FBYyxDQVFqRztBQUVELGVBQU8sTUFBTSxvQkFBb0I7Ozs7OztpQkFNL0IsQ0FBQztBQUVILHdCQUFnQix1QkFBdUIsQ0FBQyxJQUFJLEVBQUUsY0FBYyxHQUFHLE1BQU0sQ0FFcEU7QUFFRCx3QkFBZ0IseUJBQXlCLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxZQUFZLEdBQUcsY0FBYyxDQVN2RiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint_info.d.ts","sourceRoot":"","sources":["../../src/checkpoint/checkpoint_info.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,UAAU,EAEX,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,EAAE,CAAC;IACZ,WAAW,EAAE,EAAE,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,GAAG,MAAM,GAAG,cAAc,CAQjG;AAED,eAAO,MAAM,oBAAoB;;;;;;iBAM/B,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAEpE;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,cAAc,CASvF"}

package/dest/checkpoint/checkpoint_info.js

@@ -0,0 +1,34 @@
+import { CheckpointNumber, CheckpointNumberSchema, SlotNumber, SlotNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+export function randomCheckpointInfo(checkpointNumber) {
+    return {
+        archive: Fr.random(),
+        lastArchive: Fr.random(),
+        slotNumber: SlotNumber(Math.floor(Math.random() * 100000) + 1),
+        checkpointNumber: CheckpointNumber(checkpointNumber ?? Math.floor(Math.random() * 100000) + 1),
+        timestamp: BigInt(Math.floor(Date.now() / 1000))
+    };
+}
+export const CheckpointInfoSchema = z.object({
+    archive: schemas.Fr,
+    lastArchive: schemas.Fr,
+    slotNumber: SlotNumberSchema,
+    checkpointNumber: CheckpointNumberSchema,
+    timestamp: schemas.BigInt
+});
+export function serializeCheckpointInfo(info) {
+    return serializeToBuffer(info.archive, info.lastArchive, info.slotNumber, info.checkpointNumber, info.timestamp);
+}
+export function deserializeCheckpointInfo(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return {
+        archive: reader.readObject(Fr),
+        lastArchive: reader.readObject(Fr),
+        slotNumber: SlotNumber(reader.readNumber()),
+        checkpointNumber: CheckpointNumber(reader.readNumber()),
+        timestamp: reader.readBigInt()
+    };
+}

package/dest/checkpoint/checkpoint_reexecution_tracker.d.ts

@@ -0,0 +1,60 @@
+import type { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+/**
+ * Outcome of attempting to re-execute a checkpoint proposal locally.
+ *
+ * - `valid`        — re-execution succeeded and the computed checkpoint matched the proposal.
+ * - `invalid`      — the proposal disagreed with the computed checkpoint, or violated a deterministic
+ *                    constraint (limits, signatures, etc).
+ * - `unvalidated`  — the local node could not complete validation for non-deterministic reasons
+ *                    (missing blocks/txs, timeouts, infra errors). Treated as proposer-fault for
+ *                    slashing but surfaced separately for telemetry.
+ */
+export type ReexecutionOutcome = 'valid' | 'invalid' | 'unvalidated';
+export declare class CheckpointReexecutionTracker {
+    private readonly byCheckpoint;
+    private readonly bySlot;
+    /**
+     * Record the outcome of evaluating a checkpoint proposal.
+     * @param slot - Slot the proposal was for. Always required.
+     * @param archiveRoot - Archive root in the proposal.
+     * @param outcome - Outcome of evaluation.
+     * @param checkpointNumber - Checkpoint number, if known. Required for `valid` outcomes; optional
+     *   for `invalid`/`unvalidated` because some early rejections fire before blocks are loaded.
+     */
+    recordOutcome(slot: SlotNumber, archiveRoot: Fr, outcome: ReexecutionOutcome, checkpointNumber?: CheckpointNumber): void;
+    /**
+     * Record whether the local node successfully collected the transactions for a block proposal.
+     * Called from the validator's proposal handler immediately after tx collection completes
+     * (regardless of whether re-execution will subsequently succeed). The data-withholding
+     * watcher consults these records as an authoritative signal: tx availability now is too
+     * weak (txs may have been evicted from the mempool by the time the watcher runs), but a
+     * record that the txs *were* available at proposal time still vouches for the proposer.
+     *
+     * @param slot - Slot the block proposal was for.
+     * @param indexWithinCheckpoint - Index of the block within its enclosing checkpoint.
+     * @param collected - True if every tx in the proposal was collected locally before deadline.
+     */
+    recordTxsCollected(slot: SlotNumber, indexWithinCheckpoint: number, collected: boolean): void;
+    /**
+     * Returns true if the given (checkpoint number, archive root) has been successfully
+     * re-executed locally (outcome `valid`).
+     */
+    hasReexecuted(checkpointNumber: CheckpointNumber, archiveRoot: Fr): boolean;
+    /** Returns the recorded outcome for a given slot, or undefined if no proposal was evaluated. */
+    getOutcomeForSlot(slot: SlotNumber): ReexecutionOutcome | undefined;
+    /**
+     * Returns the recorded tx-collection result for a block proposal at the given slot and
+     * `indexWithinCheckpoint`, or `undefined` if no record exists.
+     *
+     * Three-valued by design:
+     *   - `true`      — we collected every tx for this block proposal before the deadline.
+     *   - `false`     — we tried and failed (missing txs at the deadline).
+     *   - `undefined` — no record (e.g. we never saw the block proposal). Callers should fall
+     *                   back to a current-state check (e.g. mempool probe) for this case.
+     */
+    getTxsCollectedRecord(slot: SlotNumber, indexWithinCheckpoint: number): boolean | undefined;
+    /** Drops entries for checkpoints with `number < checkpointNumber`. */
+    removeBefore(checkpointNumber: CheckpointNumber): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2twb2ludF9yZWV4ZWN1dGlvbl90cmFja2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hlY2twb2ludC9jaGVja3BvaW50X3JlZXhlY3V0aW9uX3RyYWNrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsVUFBVSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDcEYsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFekQ7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxNQUFNLGtCQUFrQixHQUFHLE9BQU8sR0FBRyxTQUFTLEdBQUcsYUFBYSxDQUFDO0FBMkJyRSxxQkFBYSw0QkFBNEI7SUFDdkMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQW1EO0lBQ2hGLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFnQztJQUV2RDs7Ozs7OztPQU9HO0lBQ0ksYUFBYSxDQUNsQixJQUFJLEVBQUUsVUFBVSxFQUNoQixXQUFXLEVBQUUsRUFBRSxFQUNmLE9BQU8sRUFBRSxrQkFBa0IsRUFDM0IsZ0JBQWdCLENBQUMsRUFBRSxnQkFBZ0IsR0FDbEMsSUFBSSxDQXVCTjtJQUVEOzs7Ozs7Ozs7OztPQVdHO0lBQ0ksa0JBQWtCLENBQUMsSUFBSSxFQUFFLFVBQVUsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLE9BQU8sR0FBRyxJQUFJLENBYW5HO0lBRUQ7OztPQUdHO0lBQ0ksYUFBYSxDQUFDLGdCQUFnQixFQUFFLGdCQUFnQixFQUFFLFdBQVcsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUVqRjtJQUVELGdHQUFnRztJQUN6RixpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLGtCQUFrQixHQUFHLFNBQVMsQ0FFekU7SUFFRDs7Ozs7Ozs7O09BU0c7SUFDSSxxQkFBcUIsQ0FBQyxJQUFJLEVBQUUsVUFBVSxFQUFFLHFCQUFxQixFQUFFLE1BQU0sR0FBRyxPQUFPLEdBQUcsU0FBUyxDQUVqRztJQUVELHNFQUFzRTtJQUMvRCxZQUFZLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLEdBQUcsSUFBSSxDQTRCNUQ7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint_reexecution_tracker.d.ts","sourceRoot":"","sources":["../../src/checkpoint/checkpoint_reexecution_tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACpF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,GAAG,aAAa,CAAC;AA2BrE,qBAAa,4BAA4B;IACvC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmD;IAChF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IAEvD;;;;;;;OAOG;IACI,aAAa,CAClB,IAAI,EAAE,UAAU,EAChB,WAAW,EAAE,EAAE,EACf,OAAO,EAAE,kBAAkB,EAC3B,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,IAAI,CAuBN;IAED;;;;;;;;;;;OAWG;IACI,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CAanG;IAED;;;OAGG;IACI,aAAa,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,WAAW,EAAE,EAAE,GAAG,OAAO,CAEjF;IAED,gGAAgG;IACzF,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,kBAAkB,GAAG,SAAS,CAEzE;IAED;;;;;;;;;OASG;IACI,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAEjG;IAED,sEAAsE;IAC/D,YAAY,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CA4B5D;CACF"}

package/dest/checkpoint/checkpoint_reexecution_tracker.js

@@ -0,0 +1,108 @@
+export class CheckpointReexecutionTracker {
+    byCheckpoint = new Map();
+    bySlot = new Map();
+    /**
+   * Record the outcome of evaluating a checkpoint proposal.
+   * @param slot - Slot the proposal was for. Always required.
+   * @param archiveRoot - Archive root in the proposal.
+   * @param outcome - Outcome of evaluation.
+   * @param checkpointNumber - Checkpoint number, if known. Required for `valid` outcomes; optional
+   *   for `invalid`/`unvalidated` because some early rejections fire before blocks are loaded.
+   */ recordOutcome(slot, archiveRoot, outcome, checkpointNumber) {
+        const archiveRootStr = archiveRoot.toString();
+        // Preserve any per-block txsCollected already accumulated for this slot.
+        const existing = this.bySlot.get(slot);
+        const entry = {
+            checkpointNumber,
+            archiveRoot: archiveRootStr,
+            slot,
+            outcome,
+            txsCollected: existing?.txsCollected ?? new Map()
+        };
+        if (checkpointNumber !== undefined) {
+            let archives = this.byCheckpoint.get(checkpointNumber);
+            if (!archives) {
+                archives = new Map();
+                this.byCheckpoint.set(checkpointNumber, archives);
+            }
+            archives.set(archiveRootStr, entry);
+        }
+        this.bySlot.set(slot, entry);
+    }
+    /**
+   * Record whether the local node successfully collected the transactions for a block proposal.
+   * Called from the validator's proposal handler immediately after tx collection completes
+   * (regardless of whether re-execution will subsequently succeed). The data-withholding
+   * watcher consults these records as an authoritative signal: tx availability now is too
+   * weak (txs may have been evicted from the mempool by the time the watcher runs), but a
+   * record that the txs *were* available at proposal time still vouches for the proposer.
+   *
+   * @param slot - Slot the block proposal was for.
+   * @param indexWithinCheckpoint - Index of the block within its enclosing checkpoint.
+   * @param collected - True if every tx in the proposal was collected locally before deadline.
+   */ recordTxsCollected(slot, indexWithinCheckpoint, collected) {
+        let entry = this.bySlot.get(slot);
+        if (!entry) {
+            entry = {
+                checkpointNumber: undefined,
+                archiveRoot: undefined,
+                slot,
+                outcome: undefined,
+                txsCollected: new Map()
+            };
+            this.bySlot.set(slot, entry);
+        }
+        entry.txsCollected.set(indexWithinCheckpoint, collected);
+    }
+    /**
+   * Returns true if the given (checkpoint number, archive root) has been successfully
+   * re-executed locally (outcome `valid`).
+   */ hasReexecuted(checkpointNumber, archiveRoot) {
+        return this.byCheckpoint.get(checkpointNumber)?.get(archiveRoot.toString())?.outcome === 'valid';
+    }
+    /** Returns the recorded outcome for a given slot, or undefined if no proposal was evaluated. */ getOutcomeForSlot(slot) {
+        return this.bySlot.get(slot)?.outcome;
+    }
+    /**
+   * Returns the recorded tx-collection result for a block proposal at the given slot and
+   * `indexWithinCheckpoint`, or `undefined` if no record exists.
+   *
+   * Three-valued by design:
+   *   - `true`      — we collected every tx for this block proposal before the deadline.
+   *   - `false`     — we tried and failed (missing txs at the deadline).
+   *   - `undefined` — no record (e.g. we never saw the block proposal). Callers should fall
+   *                   back to a current-state check (e.g. mempool probe) for this case.
+   */ getTxsCollectedRecord(slot, indexWithinCheckpoint) {
+        return this.bySlot.get(slot)?.txsCollected.get(indexWithinCheckpoint);
+    }
+    /** Drops entries for checkpoints with `number < checkpointNumber`. */ removeBefore(checkpointNumber) {
+        // Track the highest slot among checkpoints we're pruning. Once we know it, any slot
+        // strictly below that watermark is older than the most recently pruned checkpoint and
+        // can be dropped from `bySlot` too — including slot-only entries (no checkpoint number)
+        // which would otherwise leak, because removing by checkpoint number can't reach them.
+        let maxRemovedSlot;
+        for (const [n, archives] of this.byCheckpoint){
+            if (n < checkpointNumber) {
+                for (const entry of archives.values()){
+                    // Only drop the slot index if it still points at the entry we're removing.
+                    if (this.bySlot.get(entry.slot) === entry) {
+                        this.bySlot.delete(entry.slot);
+                    }
+                    if (maxRemovedSlot === undefined || entry.slot > maxRemovedSlot) {
+                        maxRemovedSlot = entry.slot;
+                    }
+                }
+                this.byCheckpoint.delete(n);
+            }
+        }
+        if (maxRemovedSlot !== undefined) {
+            for (const slot of [
+                ...this.bySlot.keys()
+            ]){
+                if (slot < maxRemovedSlot) {
+                    this.bySlot.delete(slot);
+                }
+            }
+        }
+    }
+}

package/dest/checkpoint/digest.d.ts

@@ -0,0 +1,18 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { type CoordinationSignatureContext } from '../p2p/signature_utils.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+/**
+ * Computes the EIP-712 payload digest for a checkpoint proposal — the digest validators sign
+ * and the L1 contract verifies during `propose()`. Mirrors `ProposeLib.digest(ProposePayload)` on L1.
+ *
+ * The result is the same `bytes32` that gets stored in `tempCheckpointLogs[checkpointNumber].payloadDigest`,
+ * so this helper is also reused when constructing simulation state overrides for pipelined proposals.
+ */
+export declare function computeCheckpointPayloadDigest(args: {
+    header: CheckpointHeader;
+    archiveRoot: Fr;
+    feeAssetPriceModifier: bigint;
+    signatureContext: CoordinationSignatureContext;
+}): Buffer32;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlnZXN0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hlY2twb2ludC9kaWdlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFHekQsT0FBTyxFQUFFLEtBQUssNEJBQTRCLEVBQXNDLE1BQU0sMkJBQTJCLENBQUM7QUFDbEgsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFbEU7Ozs7OztHQU1HO0FBQ0gsd0JBQWdCLDhCQUE4QixDQUFDLElBQUksRUFBRTtJQUNuRCxNQUFNLEVBQUUsZ0JBQWdCLENBQUM7SUFDekIsV0FBVyxFQUFFLEVBQUUsQ0FBQztJQUNoQixxQkFBcUIsRUFBRSxNQUFNLENBQUM7SUFDOUIsZ0JBQWdCLEVBQUUsNEJBQTRCLENBQUM7Q0FDaEQsR0FBRyxRQUFRLENBUVgifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"digest.d.ts","sourceRoot":"","sources":["../../src/checkpoint/digest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGzD,OAAO,EAAE,KAAK,4BAA4B,EAAsC,MAAM,2BAA2B,CAAC;AAClH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAElE;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE;IACnD,MAAM,EAAE,gBAAgB,CAAC;IACzB,WAAW,EAAE,EAAE,CAAC;IAChB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,gBAAgB,EAAE,4BAA4B,CAAC;CAChD,GAAG,QAAQ,CAQX"}

package/dest/checkpoint/digest.js

@@ -0,0 +1,12 @@
+import { ConsensusPayload } from '../p2p/consensus_payload.js';
+import { getHashedSignaturePayloadTypedData } from '../p2p/signature_utils.js';
+/**
+ * Computes the EIP-712 payload digest for a checkpoint proposal — the digest validators sign
+ * and the L1 contract verifies during `propose()`. Mirrors `ProposeLib.digest(ProposePayload)` on L1.
+ *
+ * The result is the same `bytes32` that gets stored in `tempCheckpointLogs[checkpointNumber].payloadDigest`,
+ * so this helper is also reused when constructing simulation state overrides for pipelined proposals.
+ */ export function computeCheckpointPayloadDigest(args) {
+    const consensusPayload = new ConsensusPayload(args.header, args.archiveRoot, args.feeAssetPriceModifier, args.signatureContext);
+    return getHashedSignaturePayloadTypedData(consensusPayload);
+}

package/dest/checkpoint/index.d.ts

@@ -1,2 +1,10 @@
-export * from './checkpoint_body.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './checkpoint.js';
+export * from './checkpoint_data.js';
+export * from './checkpoint_info.js';
+export * from './checkpoint_reexecution_tracker.js';
+export * from './digest.js';
+export * from './previous_checkpoint_out_hashes.js';
+export * from './published_checkpoint.js';
+export * from './simulation_overrides.js';
+export * from './validate.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jaGVja3BvaW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxlQUFlLENBQUMifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/checkpoint/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/checkpoint/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qCAAqC,CAAC;AACpD,cAAc,aAAa,CAAC;AAC5B,cAAc,qCAAqC,CAAC;AACpD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,eAAe,CAAC"}

package/dest/checkpoint/index.js

@@ -1 +1,9 @@
-export * from './checkpoint_body.js';
+export * from './checkpoint.js';
+export * from './checkpoint_data.js';
+export * from './checkpoint_info.js';
+export * from './checkpoint_reexecution_tracker.js';
+export * from './digest.js';
+export * from './previous_checkpoint_out_hashes.js';
+export * from './published_checkpoint.js';
+export * from './simulation_overrides.js';
+export * from './validate.js';

package/dest/checkpoint/previous_checkpoint_out_hashes.d.ts

@@ -0,0 +1,33 @@
+import { CheckpointNumber, type EpochNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { Logger } from '@aztec/foundation/log';
+import type { L2BlockSource } from '../block/l2_block_source.js';
+import { type L1RollupConstants } from '../epoch-helpers/index.js';
+import type { ProposedCheckpointData } from './checkpoint_data.js';
+/**
+ * Returns the out hashes (in epoch order) of all checkpoints in `epoch` that precede
+ * `checkpointNumber`, used to compute the `epochOutHash` baked into that checkpoint's header.
+ *
+ * Under proposer pipelining the parent checkpoint may not be confirmed on L1 by the time the
+ * builder runs, so the on-chain archiver query (`getCheckpointsData`) is missing it and the
+ * resulting `epochOutHash` would diverge from what other validators (and L1) compute after the
+ * parent lands. To avoid that, the parent's `checkpointOutHash` is spliced in from the locally
+ * known proposed checkpoint when:
+ *   - pipelining is enabled,
+ *   - the archiver lookup is genuinely short (its last entry is not already cp `N-1`),
+ *   - and the proposed cp `N-1` is in the same target epoch (otherwise we're at an epoch boundary
+ *     and the previous-epoch cps must be excluded).
+ *
+ * Callers may either pass the already-loaded `proposedCheckpointData` (the proposer has it on
+ * hand) or leave it undefined, in which case it's fetched via `getProposedCheckpointData`.
+ */
+export declare function getPreviousCheckpointOutHashes(input: {
+    blockSource: Pick<L2BlockSource, 'getCheckpointsData' | 'getProposedCheckpointData'>;
+    epoch: EpochNumber;
+    checkpointNumber: CheckpointNumber;
+    l1Constants: Pick<L1RollupConstants, 'epochDuration'>;
+    pipeliningEnabled: boolean;
+    proposedCheckpointData?: ProposedCheckpointData;
+    log?: Logger;
+}): Promise<Fr[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldmlvdXNfY2hlY2twb2ludF9vdXRfaGFzaGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hlY2twb2ludC9wcmV2aW91c19jaGVja3BvaW50X291dF9oYXNoZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLEtBQUssV0FBVyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDckYsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDakUsT0FBTyxFQUFFLEtBQUssaUJBQWlCLEVBQWtCLE1BQU0sMkJBQTJCLENBQUM7QUFDbkYsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVuRTs7Ozs7Ozs7Ozs7Ozs7OztHQWdCRztBQUNILHdCQUFzQiw4QkFBOEIsQ0FBQyxLQUFLLEVBQUU7SUFDMUQsV0FBVyxFQUFFLElBQUksQ0FBQyxhQUFhLEVBQUUsb0JBQW9CLEdBQUcsMkJBQTJCLENBQUMsQ0FBQztJQUNyRixLQUFLLEVBQUUsV0FBVyxDQUFDO0lBQ25CLGdCQUFnQixFQUFFLGdCQUFnQixDQUFDO0lBQ25DLFdBQVcsRUFBRSxJQUFJLENBQUMsaUJBQWlCLEVBQUUsZUFBZSxDQUFDLENBQUM7SUFDdEQsaUJBQWlCLEVBQUUsT0FBTyxDQUFDO0lBQzNCLHNCQUFzQixDQUFDLEVBQUUsc0JBQXNCLENBQUM7SUFDaEQsR0FBRyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2QsR0FBRyxPQUFPLENBQUMsRUFBRSxFQUFFLENBQUMsQ0EyQmhCIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"previous_checkpoint_out_hashes.d.ts","sourceRoot":"","sources":["../../src/checkpoint/previous_checkpoint_out_hashes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,KAAK,iBAAiB,EAAkB,MAAM,2BAA2B,CAAC;AACnF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,8BAA8B,CAAC,KAAK,EAAE;IAC1D,WAAW,EAAE,IAAI,CAAC,aAAa,EAAE,oBAAoB,GAAG,2BAA2B,CAAC,CAAC;IACrF,KAAK,EAAE,WAAW,CAAC;IACnB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAC;IACtD,iBAAiB,EAAE,OAAO,CAAC;IAC3B,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CA2BhB"}

package/dest/checkpoint/previous_checkpoint_out_hashes.js

@@ -0,0 +1,45 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { getEpochAtSlot } from '../epoch-helpers/index.js';
+/**
+ * Returns the out hashes (in epoch order) of all checkpoints in `epoch` that precede
+ * `checkpointNumber`, used to compute the `epochOutHash` baked into that checkpoint's header.
+ *
+ * Under proposer pipelining the parent checkpoint may not be confirmed on L1 by the time the
+ * builder runs, so the on-chain archiver query (`getCheckpointsData`) is missing it and the
+ * resulting `epochOutHash` would diverge from what other validators (and L1) compute after the
+ * parent lands. To avoid that, the parent's `checkpointOutHash` is spliced in from the locally
+ * known proposed checkpoint when:
+ *   - pipelining is enabled,
+ *   - the archiver lookup is genuinely short (its last entry is not already cp `N-1`),
+ *   - and the proposed cp `N-1` is in the same target epoch (otherwise we're at an epoch boundary
+ *     and the previous-epoch cps must be excluded).
+ *
+ * Callers may either pass the already-loaded `proposedCheckpointData` (the proposer has it on
+ * hand) or leave it undefined, in which case it's fetched via `getProposedCheckpointData`.
+ */ export async function getPreviousCheckpointOutHashes(input) {
+    const { blockSource, epoch, checkpointNumber, l1Constants, pipeliningEnabled, log } = input;
+    const checkpointed = (await blockSource.getCheckpointsData({
+        epoch
+    })).filter((c)=>c.checkpointNumber < checkpointNumber).sort((a, b)=>a.checkpointNumber - b.checkpointNumber);
+    if (!pipeliningEnabled || checkpointNumber === 0) {
+        return checkpointed.map((c)=>c.checkpointOutHash);
+    }
+    const parentCheckpoint = CheckpointNumber(checkpointNumber - 1);
+    if (checkpointed.at(-1)?.checkpointNumber === parentCheckpoint) {
+        return checkpointed.map((c)=>c.checkpointOutHash);
+    }
+    const proposedParent = input.proposedCheckpointData ?? await blockSource.getProposedCheckpointData({
+        number: parentCheckpoint
+    });
+    if (!proposedParent || proposedParent.checkpointNumber !== parentCheckpoint) {
+        return checkpointed.map((c)=>c.checkpointOutHash);
+    }
+    if (getEpochAtSlot(proposedParent.header.slotNumber, l1Constants) !== epoch) {
+        return checkpointed.map((c)=>c.checkpointOutHash);
+    }
+    log?.debug(`Splicing pipelined parent cp ${parentCheckpoint} outHash for cp ${checkpointNumber}`);
+    return [
+        ...checkpointed.map((c)=>c.checkpointOutHash),
+        proposedParent.checkpointOutHash
+    ];
+}