@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/checkpoint/checkpoint_info.js

@@ -0,0 +1,34 @@
+import { CheckpointNumber, CheckpointNumberSchema, SlotNumber, SlotNumberSchema } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/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-labs/foundation/branded-types';
+import type { Fr } from '@aztec-labs/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2twb2ludF9yZWV4ZWN1dGlvbl90cmFja2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hlY2twb2ludC9jaGVja3BvaW50X3JlZXhlY3V0aW9uX3RyYWNrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDekYsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFFOUQ7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxNQUFNLGtCQUFrQixHQUFHLE9BQU8sR0FBRyxTQUFTLEdBQUcsYUFBYSxDQUFDO0FBMkJyRSxxQkFBYSw0QkFBNEI7SUFDdkMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQW1EO0lBQ2hGLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFnQztJQUV2RDs7Ozs7OztPQU9HO0lBQ0ksYUFBYSxDQUNsQixJQUFJLEVBQUUsVUFBVSxFQUNoQixXQUFXLEVBQUUsRUFBRSxFQUNmLE9BQU8sRUFBRSxrQkFBa0IsRUFDM0IsZ0JBQWdCLENBQUMsRUFBRSxnQkFBZ0IsR0FDbEMsSUFBSSxDQXVCTjtJQUVEOzs7Ozs7Ozs7OztPQVdHO0lBQ0ksa0JBQWtCLENBQUMsSUFBSSxFQUFFLFVBQVUsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLE9BQU8sR0FBRyxJQUFJLENBYW5HO0lBRUQ7OztPQUdHO0lBQ0ksYUFBYSxDQUFDLGdCQUFnQixFQUFFLGdCQUFnQixFQUFFLFdBQVcsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUVqRjtJQUVELGdHQUFnRztJQUN6RixpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLGtCQUFrQixHQUFHLFNBQVMsQ0FFekU7SUFFRDs7Ozs7Ozs7O09BU0c7SUFDSSxxQkFBcUIsQ0FBQyxJQUFJLEVBQUUsVUFBVSxFQUFFLHFCQUFxQixFQUFFLE1BQU0sR0FBRyxPQUFPLEdBQUcsU0FBUyxDQUVqRztJQUVELHNFQUFzRTtJQUMvRCxZQUFZLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLEdBQUcsSUFBSSxDQTRCNUQ7Q0FDRiJ9

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,sCAAsC,CAAC;AACzF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAE9D;;;;;;;;;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-labs/foundation/buffer';
+import type { Fr } from '@aztec-labs/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlnZXN0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hlY2twb2ludC9kaWdlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDOUQsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFHOUQsT0FBTyxFQUFFLEtBQUssNEJBQTRCLEVBQXNDLE1BQU0sMkJBQTJCLENBQUM7QUFDbEgsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFbEU7Ozs7OztHQU1HO0FBQ0gsd0JBQWdCLDhCQUE4QixDQUFDLElBQUksRUFBRTtJQUNuRCxNQUFNLEVBQUUsZ0JBQWdCLENBQUM7SUFDekIsV0FBVyxFQUFFLEVBQUUsQ0FBQztJQUNoQixxQkFBcUIsRUFBRSxNQUFNLENBQUM7SUFDOUIsZ0JBQWdCLEVBQUUsNEJBQTRCLENBQUM7Q0FDaEQsR0FBRyxRQUFRLENBUVgifQ==

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,+BAA+B,CAAC;AAC9D,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAG9D,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

@@ -0,0 +1,11 @@
+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_inbox_rolling_hash.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jaGVja3BvaW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGVBQWUsQ0FBQyJ9

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,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qCAAqC,CAAC;AACpD,cAAc,aAAa,CAAC;AAC5B,cAAc,6CAA6C,CAAC;AAC5D,cAAc,qCAAqC,CAAC;AACpD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,eAAe,CAAC"}

package/dest/checkpoint/index.js

@@ -0,0 +1,10 @@
+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_inbox_rolling_hash.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_inbox_rolling_hash.d.ts

@@ -0,0 +1,21 @@
+import { CheckpointNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { L2BlockSource } from '../block/l2_block_source.js';
+import type { ProposedCheckpointData } from './checkpoint_data.js';
+/**
+ * Returns the inbox rolling hash chain-start for `checkpointNumber`: the `inboxRollingHash` of the immediately
+ * preceding checkpoint. Unlike the epoch out-hash tree, the rolling-hash chain is continuous across epoch boundaries,
+ * so the parent is always `checkpointNumber - 1` regardless of epoch. The genesis checkpoint (and the first checkpoint
+ * built on it) starts the chain at zero.
+ *
+ * Under proposer pipelining the parent may not be confirmed on L1 yet, so the locally-known proposed checkpoint is
+ * preferred when it is the parent, mirroring `getPreviousCheckpointOutHashes`.
+ */
+export declare function getPreviousCheckpointInboxRollingHash(input: {
+    blockSource: Pick<L2BlockSource, 'getCheckpointData' | 'getProposedCheckpointData'>;
+    checkpointNumber: CheckpointNumber;
+    proposedCheckpointData?: ProposedCheckpointData;
+    log?: Logger;
+}): Promise<Fr>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldmlvdXNfY2hlY2twb2ludF9pbmJveF9yb2xsaW5nX2hhc2guZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jaGVja3BvaW50L3ByZXZpb3VzX2NoZWNrcG9pbnRfaW5ib3hfcm9sbGluZ19oYXNoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ3hFLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUV6RCxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRW5FOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLHFDQUFxQyxDQUFDLEtBQUssRUFBRTtJQUNqRSxXQUFXLEVBQUUsSUFBSSxDQUFDLGFBQWEsRUFBRSxtQkFBbUIsR0FBRywyQkFBMkIsQ0FBQyxDQUFDO0lBQ3BGLGdCQUFnQixFQUFFLGdCQUFnQixDQUFDO0lBQ25DLHNCQUFzQixDQUFDLEVBQUUsc0JBQXNCLENBQUM7SUFDaEQsR0FBRyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2QsR0FBRyxPQUFPLENBQUMsRUFBRSxDQUFDLENBd0JkIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"previous_checkpoint_inbox_rolling_hash.d.ts","sourceRoot":"","sources":["../../src/checkpoint/previous_checkpoint_inbox_rolling_hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACxE,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;;;;;;;GAQG;AACH,wBAAsB,qCAAqC,CAAC,KAAK,EAAE;IACjE,WAAW,EAAE,IAAI,CAAC,aAAa,EAAE,mBAAmB,GAAG,2BAA2B,CAAC,CAAC;IACpF,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,EAAE,CAAC,CAwBd"}

package/dest/checkpoint/previous_checkpoint_inbox_rolling_hash.js

@@ -0,0 +1,34 @@
+import { CheckpointNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+/**
+ * Returns the inbox rolling hash chain-start for `checkpointNumber`: the `inboxRollingHash` of the immediately
+ * preceding checkpoint. Unlike the epoch out-hash tree, the rolling-hash chain is continuous across epoch boundaries,
+ * so the parent is always `checkpointNumber - 1` regardless of epoch. The genesis checkpoint (and the first checkpoint
+ * built on it) starts the chain at zero.
+ *
+ * Under proposer pipelining the parent may not be confirmed on L1 yet, so the locally-known proposed checkpoint is
+ * preferred when it is the parent, mirroring `getPreviousCheckpointOutHashes`.
+ */ export async function getPreviousCheckpointInboxRollingHash(input) {
+    const { blockSource, checkpointNumber, proposedCheckpointData, log } = input;
+    if (checkpointNumber <= 1) {
+        return Fr.ZERO;
+    }
+    const parent = CheckpointNumber(checkpointNumber - 1);
+    if (proposedCheckpointData?.checkpointNumber === parent) {
+        log?.debug(`Using pipelined parent cp ${parent} inbox rolling hash for cp ${checkpointNumber}`);
+        return proposedCheckpointData.header.inboxRollingHash;
+    }
+    const confirmed = await blockSource.getCheckpointData({
+        number: parent
+    });
+    if (confirmed) {
+        return confirmed.header.inboxRollingHash;
+    }
+    const proposed = await blockSource.getProposedCheckpointData({
+        number: parent
+    });
+    if (proposed) {
+        return proposed.header.inboxRollingHash;
+    }
+    throw new Error(`Cannot source inbox rolling hash for parent checkpoint ${parent} of checkpoint ${checkpointNumber}`);
+}

package/dest/checkpoint/previous_checkpoint_out_hashes.d.ts

@@ -0,0 +1,33 @@
+import { CheckpointNumber, type EpochNumber } from '@aztec-labs/foundation/branded-types';
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Logger } from '@aztec-labs/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldmlvdXNfY2hlY2twb2ludF9vdXRfaGFzaGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hlY2twb2ludC9wcmV2aW91c19jaGVja3BvaW50X291dF9oYXNoZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLEtBQUssV0FBVyxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDMUYsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDOUQsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFekQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDakUsT0FBTyxFQUFFLEtBQUssaUJBQWlCLEVBQWtCLE1BQU0sMkJBQTJCLENBQUM7QUFDbkYsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVuRTs7Ozs7Ozs7Ozs7Ozs7OztHQWdCRztBQUNILHdCQUFzQiw4QkFBOEIsQ0FBQyxLQUFLLEVBQUU7SUFDMUQsV0FBVyxFQUFFLElBQUksQ0FBQyxhQUFhLEVBQUUsb0JBQW9CLEdBQUcsMkJBQTJCLENBQUMsQ0FBQztJQUNyRixLQUFLLEVBQUUsV0FBVyxDQUFDO0lBQ25CLGdCQUFnQixFQUFFLGdCQUFnQixDQUFDO0lBQ25DLFdBQVcsRUFBRSxJQUFJLENBQUMsaUJBQWlCLEVBQUUsZUFBZSxDQUFDLENBQUM7SUFDdEQsaUJBQWlCLEVBQUUsT0FBTyxDQUFDO0lBQzNCLHNCQUFzQixDQUFDLEVBQUUsc0JBQXNCLENBQUM7SUFDaEQsR0FBRyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2QsR0FBRyxPQUFPLENBQUMsRUFBRSxFQUFFLENBQUMsQ0EyQmhCIn0=

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,sCAAsC,CAAC;AAC1F,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,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-labs/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
+    ];
+}

package/dest/checkpoint/published_checkpoint.d.ts

@@ -0,0 +1,103 @@
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { z } from 'zod';
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { Checkpoint } from './checkpoint.js';
+export declare class L1PublishedData {
+    blockNumber: bigint;
+    timestamp: bigint;
+    blockHash: string;
+    constructor(blockNumber: bigint, timestamp: bigint, blockHash: string);
+    static get schema(): 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;
+    }>>;
+    static random(): L1PublishedData;
+    static fromFields(fields: FieldsOf<L1PublishedData>): L1PublishedData;
+    static fromBuffer(bufferOrReader: Buffer | BufferReader): L1PublishedData;
+    toBuffer(): Buffer;
+}
+export declare class PublishedCheckpoint {
+    /** The checkpoint itself. */
+    checkpoint: Checkpoint;
+    /** Info on when this checkpoint was published on L1. */
+    l1: L1PublishedData;
+    /** The attestations for the last block in the checkpoint. */
+    attestations: CommitteeAttestation[];
+    constructor(
+    /** The checkpoint itself. */
+    checkpoint: Checkpoint, 
+    /** Info on when this checkpoint was published on L1. */
+    l1: L1PublishedData, 
+    /** The attestations for the last block in the checkpoint. */
+    attestations: CommitteeAttestation[]);
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        checkpoint: z.ZodPipe<z.ZodObject<{
+            archive: z.ZodPipe<z.ZodObject<{
+                root: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+                nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+            }, z.core.$strip>, z.ZodTransform<import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                root: import("@aztec-labs/foundation/schemas").Fr;
+                nextAvailableLeafIndex: number;
+            }>>;
+            header: import("@aztec-labs/foundation/schemas").ZodFor<import("../rollup/checkpoint_header.js").CheckpointHeader>;
+            blocks: z.ZodArray<z.ZodPipe<z.ZodObject<{
+                archive: z.ZodPipe<z.ZodObject<{
+                    root: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+                    nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+                }, z.core.$strip>, z.ZodTransform<import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: import("@aztec-labs/foundation/schemas").Fr;
+                    nextAvailableLeafIndex: number;
+                }>>;
+                header: import("@aztec-labs/foundation/schemas").ZodFor<import("../tx/block_header.js").BlockHeader>;
+                body: import("@aztec-labs/foundation/schemas").ZodFor<import("../block/body.js").Body>;
+                checkpointNumber: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<import("@aztec-labs/foundation/branded-types").CheckpointNumber, number>>;
+                indexWithinCheckpoint: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<import("@aztec-labs/foundation/branded-types").IndexWithinCheckpoint, number>>;
+            }, z.core.$strip>, z.ZodTransform<import("../block/l2_block.js").L2Block, {
+                archive: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+                header: import("../tx/block_header.js").BlockHeader;
+                body: import("../block/body.js").Body;
+                checkpointNumber: import("@aztec-labs/foundation/branded-types").CheckpointNumber;
+                indexWithinCheckpoint: import("@aztec-labs/foundation/branded-types").IndexWithinCheckpoint;
+            }>>>;
+            number: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<import("@aztec-labs/foundation/branded-types").CheckpointNumber, number>>;
+            feeAssetPriceModifier: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<Checkpoint, {
+            archive: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+            header: import("../rollup/checkpoint_header.js").CheckpointHeader;
+            blocks: import("../block/l2_block.js").L2Block[];
+            number: import("@aztec-labs/foundation/branded-types").CheckpointNumber;
+            feeAssetPriceModifier: bigint;
+        }>>;
+        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;
+        }>>;
+        attestations: z.ZodArray<z.ZodPipe<z.ZodObject<{
+            address: z.ZodType<import("@aztec-labs/foundation/eth-address").EthAddress, string, z.core.$ZodTypeInternals<import("@aztec-labs/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-labs/foundation/eth-address").EthAddress;
+            signature: import("../block/proposal/committee_attestation.js").Signature;
+        }>>>;
+    }, z.core.$strip>, z.ZodTransform<PublishedCheckpoint, {
+        checkpoint: Checkpoint;
+        l1: L1PublishedData;
+        attestations: CommitteeAttestation[];
+    }>>;
+    static getFields(fields: FieldsOf<PublishedCheckpoint>): readonly [Checkpoint, L1PublishedData, CommitteeAttestation[]];
+    static from(fields: FieldsOf<PublishedCheckpoint>): PublishedCheckpoint;
+    static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedCheckpoint;
+    toBuffer(): Buffer;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGlzaGVkX2NoZWNrcG9pbnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jaGVja3BvaW50L3B1Ymxpc2hlZF9jaGVja3BvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sRUFBRSxZQUFZLEVBQXFCLE1BQU0sa0NBQWtDLENBQUM7QUFDbkYsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDN0QsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUVsRixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFN0MscUJBQWEsZUFBZTtJQUVqQixXQUFXLEVBQUUsTUFBTTtJQUNuQixTQUFTLEVBQUUsTUFBTTtJQUNqQixTQUFTLEVBQUUsTUFBTTtJQUgxQixZQUNTLFdBQVcsRUFBRSxNQUFNLEVBQ25CLFNBQVMsRUFBRSxNQUFNLEVBQ2pCLFNBQVMsRUFBRSxNQUFNLEVBQ3RCO0lBRUosTUFBTSxLQUFLLE1BQU07Ozs7Ozs7O1FBUWhCO0lBRUQsTUFBTSxDQUFDLE1BQU0sb0JBTVo7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsZUFBZSxDQUFDLG1CQUVsRDtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsY0FBYyxFQUFFLE1BQU0sR0FBRyxZQUFZLEdBQUcsZUFBZSxDQU14RTtJQUVNLFFBQVEsSUFBSSxNQUFNLENBRXhCO0NBQ0Y7QUFFRCxxQkFBYSxtQkFBbUI7SUFFNUIsNkJBQTZCO0lBQ3RCLFVBQVUsRUFBRSxVQUFVO0lBQzdCLHdEQUF3RDtJQUNqRCxFQUFFLEVBQUUsZUFBZTtJQUMxQiw2REFBNkQ7SUFDdEQsWUFBWSxFQUFFLG9CQUFvQixFQUFFO0lBTjdDO0lBQ0UsNkJBQTZCO0lBQ3RCLFVBQVUsRUFBRSxVQUFVO0lBQzdCLHdEQUF3RDtJQUNqRCxFQUFFLEVBQUUsZUFBZTtJQUMxQiw2REFBNkQ7SUFDdEQsWUFBWSxFQUFFLG9CQUFvQixFQUFFLEVBQ3pDO0lBRUosTUFBTSxLQUFLLE1BQU07Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7UUFRaEI7SUFFRCxNQUFNLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsbUJBQW1CLENBQUMsa0VBRXJEO0lBRUQsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLG1CQUFtQixDQUFDLHVCQUVoRDtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsY0FBYyxFQUFFLE1BQU0sR0FBRyxZQUFZLEdBQUcsbUJBQW1CLENBWTVFO0lBRU0sUUFBUSxJQUFJLE1BQU0sQ0FTeEI7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"published_checkpoint.d.ts","sourceRoot":"","sources":["../../src/checkpoint/published_checkpoint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AACnF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,qBAAa,eAAe;IAEjB,WAAW,EAAE,MAAM;IACnB,SAAS,EAAE,MAAM;IACjB,SAAS,EAAE,MAAM;IAH1B,YACS,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACtB;IAEJ,MAAM,KAAK,MAAM;;;;;;;;QAQhB;IAED,MAAM,CAAC,MAAM,oBAMZ;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,mBAElD;IAED,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe,CAMxE;IAEM,QAAQ,IAAI,MAAM,CAExB;CACF;AAED,qBAAa,mBAAmB;IAE5B,6BAA6B;IACtB,UAAU,EAAE,UAAU;IAC7B,wDAAwD;IACjD,EAAE,EAAE,eAAe;IAC1B,6DAA6D;IACtD,YAAY,EAAE,oBAAoB,EAAE;IAN7C;IACE,6BAA6B;IACtB,UAAU,EAAE,UAAU;IAC7B,wDAAwD;IACjD,EAAE,EAAE,eAAe;IAC1B,6DAA6D;IACtD,YAAY,EAAE,oBAAoB,EAAE,EACzC;IAEJ,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAQhB;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,mBAAmB,CAAC,kEAErD;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,mBAAmB,CAAC,uBAEhD;IAED,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,YAAY,GAAG,mBAAmB,CAY5E;IAEM,QAAQ,IAAI,MAAM,CASxB;CACF"}

package/dest/checkpoint/published_checkpoint.js

@@ -0,0 +1,81 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { randomBigInt } from '@aztec-labs/foundation/crypto/random';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { z } from 'zod';
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
+import { Checkpoint } from './checkpoint.js';
+export class L1PublishedData {
+    blockNumber;
+    timestamp;
+    blockHash;
+    constructor(blockNumber, timestamp, blockHash){
+        this.blockNumber = blockNumber;
+        this.timestamp = timestamp;
+        this.blockHash = blockHash;
+    }
+    static get schema() {
+        return z.object({
+            blockNumber: schemas.BigInt,
+            timestamp: schemas.BigInt,
+            blockHash: z.string()
+        }).transform((obj)=>L1PublishedData.fromFields(obj));
+    }
+    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);
+    }
+    static fromBuffer(bufferOrReader) {
+        const reader = BufferReader.asReader(bufferOrReader);
+        const l1BlockNumber = reader.readBigInt();
+        const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
+        const l1Timestamp = reader.readBigInt();
+        return new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash);
+    }
+    toBuffer() {
+        return serializeToBuffer(this.blockNumber, this.blockHash, this.timestamp);
+    }
+}
+export class PublishedCheckpoint {
+    checkpoint;
+    l1;
+    attestations;
+    constructor(/** The checkpoint itself. */ checkpoint, /** Info on when this checkpoint was published on L1. */ l1, /** The attestations for the last block in the checkpoint. */ attestations){
+        this.checkpoint = checkpoint;
+        this.l1 = l1;
+        this.attestations = attestations;
+    }
+    static get schema() {
+        return z.object({
+            checkpoint: Checkpoint.schema,
+            l1: L1PublishedData.schema,
+            attestations: z.array(CommitteeAttestation.schema)
+        }).transform((obj)=>PublishedCheckpoint.from(obj));
+    }
+    static getFields(fields) {
+        return [
+            fields.checkpoint,
+            fields.l1,
+            fields.attestations
+        ];
+    }
+    static from(fields) {
+        return new PublishedCheckpoint(...PublishedCheckpoint.getFields(fields));
+    }
+    static fromBuffer(bufferOrReader) {
+        const reader = BufferReader.asReader(bufferOrReader);
+        const checkpoint = reader.readObject(Checkpoint);
+        const l1BlockNumber = reader.readBigInt();
+        const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
+        const l1Timestamp = reader.readBigInt();
+        const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
+        return new PublishedCheckpoint(checkpoint, new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash), attestations);
+    }
+    toBuffer() {
+        return serializeToBuffer(this.checkpoint, this.l1.blockNumber, this.l1.blockHash, this.l1.timestamp, this.attestations.length, this.attestations);
+    }
+}