@aztec/archiver 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/dest/modules/outbox_trees_resolver.d.ts

@@ -0,0 +1,64 @@
+import type { OutboxContract } from '@aztec/ethereum/contracts';
+import type { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { CheckpointData } from '@aztec/stdlib/checkpoint';
+import { type L2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
+import type { IndexedTxEffect, TxHash } from '@aztec/stdlib/tx';
+/**
+ * Archiver-side view of the data the resolver needs to assemble a witness. The archiver implements
+ * each of these natively, so no L2 RPC plumbing is required.
+ */
+export interface OutboxTreesArchiverView {
+    getBlocks(query: {
+        epoch: EpochNumber;
+        onlyCheckpointed: true;
+    }): Promise<L2Block[]>;
+    getBlock(query: {
+        number: BlockNumber;
+    }): Promise<L2Block | undefined>;
+    getCheckpointsData(query: {
+        epoch: EpochNumber;
+    }): Promise<CheckpointData[]>;
+    getTxEffect(txHash: TxHash): Promise<IndexedTxEffect | undefined>;
+}
+/**
+ * Holds an in-memory cache of per-epoch Outbox roots used to build L2-to-L1 message membership
+ * witnesses, plus the single-flight registry that dedupes concurrent fetches.
+ *
+ * Roots are fetched lazily on request and cached against the node's synced L1 block: a cached entry
+ * is reused only while the synced L1 block is unchanged, and re-fetched from L1 once the node
+ * advances. The cache is intentionally not persisted — entries are valid for at most one L1 slot, so
+ * there is nothing worth carrying across restarts. The four merkle-tree levels are rebuilt per
+ * request from the archiver's raw L2 data via `computeL2ToL1MembershipWitness`; no trees or
+ * intermediate out-hashes are cached.
+ *
+ * TODO: Re-add permanent caching for sealed-and-L1-finalized epochs so their roots can be frozen
+ * and served without any L1 read once they can no longer change. That logic was dropped here to keep
+ * the cache simple; it would likely want a persisted store again.
+ */
+export declare class OutboxTreesResolver {
+    #private;
+    private readonly outbox;
+    private readonly archiver;
+    private readonly store;
+    private readonly getSyncedL1BlockNumber;
+    private readonly epochDuration;
+    private readonly log;
+    constructor(outbox: OutboxContract, archiver: OutboxTreesArchiverView, store: AztecAsyncKVStore, getSyncedL1BlockNumber: () => Promise<bigint | undefined>, epochDuration: number, log?: Logger);
+    /**
+     * Builds the L2-to-L1 membership witness for `message` in tx `txHash`. Returns `undefined` if the
+     * tx isn't yet in a block/epoch, or if the Outbox holds no covering partial-proof root for the
+     * tx's checkpoint as of the node's synced L1 block — callers should retry in that case.
+     */
+    getL2ToL1MembershipWitness(txHash: TxHash, message: Fr, messageIndexInTx?: number): Promise<L2ToL1MembershipWitness | undefined>;
+    /**
+     * Builds the node-shaped adapter handed to `computeL2ToL1MembershipWitness`. The helper invokes
+     * `getL2ToL1Messages` / `getBlock` / `getCheckpointsData`; `getTxReceipt` is part of the helper's
+     * node type but is never invoked because we always pass an already-resolved receipt.
+     */
+    private makeNodeView;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/modules/outbox_trees_resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox_trees_resolver.d.ts","sourceRoot":"","sources":["../../src/modules/outbox_trees_resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EAAE,KAAK,uBAAuB,EAAkC,MAAM,yBAAyB,CAAC;AACvG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEhE;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,gBAAgB,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IACrF,QAAQ,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;IACvE,kBAAkB,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAC7E,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAAC;CACnE;AAUD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,mBAAmB;;IAW5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,sBAAsB;IACvC,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG;IANtB,YACmB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,uBAAuB,EACjC,KAAK,EAAE,iBAAiB,EACxB,sBAAsB,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,EACzD,aAAa,EAAE,MAAM,EACrB,GAAG,GAAE,MAAwC,EAG/D;IAED;;;;OAIG;IACU,0BAA0B,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,EAAE,EACX,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CA6D9C;IAiED;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAYrB"}

package/dest/modules/outbox_trees_resolver.js

@@ -0,0 +1,184 @@
+import { chunkBy } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { computeL2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
+/**
+ * Holds an in-memory cache of per-epoch Outbox roots used to build L2-to-L1 message membership
+ * witnesses, plus the single-flight registry that dedupes concurrent fetches.
+ *
+ * Roots are fetched lazily on request and cached against the node's synced L1 block: a cached entry
+ * is reused only while the synced L1 block is unchanged, and re-fetched from L1 once the node
+ * advances. The cache is intentionally not persisted — entries are valid for at most one L1 slot, so
+ * there is nothing worth carrying across restarts. The four merkle-tree levels are rebuilt per
+ * request from the archiver's raw L2 data via `computeL2ToL1MembershipWitness`; no trees or
+ * intermediate out-hashes are cached.
+ *
+ * TODO: Re-add permanent caching for sealed-and-L1-finalized epochs so their roots can be frozen
+ * and served without any L1 read once they can no longer change. That logic was dropped here to keep
+ * the cache simple; it would likely want a persisted store again.
+ */ export class OutboxTreesResolver {
+    outbox;
+    archiver;
+    store;
+    getSyncedL1BlockNumber;
+    epochDuration;
+    log;
+    /** In-memory cache of per-epoch Outbox roots, keyed by epoch number. */ #cache;
+    /** Single-flight registry for in-flight roots fetches, keyed by epoch number. */ #pending;
+    /** Adapter exposing the slice of the node API that `computeL2ToL1MembershipWitness` requires. */ #node;
+    constructor(outbox, archiver, store, getSyncedL1BlockNumber, epochDuration, log = createLogger('archiver:outbox')){
+        this.outbox = outbox;
+        this.archiver = archiver;
+        this.store = store;
+        this.getSyncedL1BlockNumber = getSyncedL1BlockNumber;
+        this.epochDuration = epochDuration;
+        this.log = log;
+        this.#cache = new Map();
+        this.#pending = new Map();
+        this.#node = this.makeNodeView();
+    }
+    /**
+   * Builds the L2-to-L1 membership witness for `message` in tx `txHash`. Returns `undefined` if the
+   * tx isn't yet in a block/epoch, or if the Outbox holds no covering partial-proof root for the
+   * tx's checkpoint as of the node's synced L1 block — callers should retry in that case.
+   */ async getL2ToL1MembershipWitness(txHash, message, messageIndexInTx) {
+        // Read the tx effect once up front only to learn which epoch's Outbox roots to fetch. The roots
+        // read hits L1, so it stays outside the store transaction below: holding the archiver's writer
+        // lock across a network round-trip would stall block sync.
+        const indexed = await this.archiver.getTxEffect(txHash);
+        if (!indexed) {
+            this.log.trace(`No tx effect for tx, no witness available`, {
+                txHash
+            });
+            return undefined;
+        }
+        // Derive the epoch from the tx's slot the same way the node assembles a mined receipt, so the
+        // witness helper sees the same view a `getTxReceipt` caller would.
+        const epochNumber = getEpochAtSlot(indexed.slotNumber, {
+            epochDuration: this.epochDuration
+        });
+        const roots = await this.#getRoots(epochNumber);
+        if (roots === undefined) {
+            return undefined;
+        }
+        const syncedBefore = await this.getSyncedL1BlockNumber();
+        try {
+            // Assemble the witness inside a single store transaction so every archiver read it depends on
+            // (the tx effect, the epoch's blocks, the target block and the checkpoint metadata) observes one
+            // consistent snapshot. `transactionAsync` serializes against writers, and the substore reads
+            // below bind to it automatically, so no store commit can land mid-assembly and splice together
+            // two different chain states — which would otherwise surface as a spurious "message does not
+            // exist" error even when the tx-effect index is healthy.
+            return await this.store.transactionAsync(async ()=>{
+                // Re-read the tx effect within the snapshot so the receipt's block number and tx index stay
+                // consistent with the block and checkpoint data read while building the witness. The epoch is
+                // reused from the pre-transaction read (it selected the roots above); if a reorg moved the tx
+                // to a different epoch in between, the block lookups simply miss and the helper returns
+                // undefined for the caller to retry.
+                const indexedInSnapshot = await this.archiver.getTxEffect(txHash);
+                if (!indexedInSnapshot) {
+                    return undefined;
+                }
+                const receipt = {
+                    txHash,
+                    epochNumber,
+                    blockNumber: indexedInSnapshot.l2BlockNumber,
+                    txIndexInBlock: indexedInSnapshot.txIndexInBlock
+                };
+                return await computeL2ToL1MembershipWitness(this.#node, roots, message, receipt, messageIndexInTx);
+            });
+        } catch (err) {
+            // The helper throws if the locally-assembled epoch root disagrees with the cached Outbox root.
+            // The cached roots are pinned to the node's synced L1 block, but the block / checkpoint data is
+            // read from a store snapshot taken after that fetch, so if the archiver advanced in between the
+            // two can reflect different heights and produce a transient mismatch. When the synced block moved
+            // during assembly we treat the mismatch as transient and return undefined so the caller can
+            // retry; a mismatch at a stable synced block is a genuine node/L1 disagreement and must surface.
+            const syncedAfter = await this.getSyncedL1BlockNumber();
+            if (syncedBefore !== syncedAfter && err instanceof Error && err.message.includes('does not match Outbox')) {
+                this.log.debug(`Transient outbox root mismatch during sync, returning no witness`, {
+                    txHash,
+                    epoch: epochNumber
+                });
+                return undefined;
+            }
+            throw err;
+        }
+    }
+    /**
+   * Lazily returns the per-epoch Outbox roots, reusing the cached entry while the node's synced L1
+   * block is unchanged and re-fetching from L1 once it advances. Returns `undefined` if the node has
+   * not established a synced L1 block yet. Concurrent requests for the same epoch share a single
+   * in-flight fetch via {@link #pending}.
+   */ #getRoots(epoch) {
+        const inFlight = this.#pending.get(epoch);
+        if (inFlight) {
+            return inFlight;
+        }
+        const promise = this.#refreshRoots(epoch).finally(()=>{
+            this.#pending.delete(epoch);
+        });
+        this.#pending.set(epoch, promise);
+        return promise;
+    }
+    /**
+   * Single-flight body for {@link #getRoots}. Re-reads the cached entry and synced block here —
+   * rather than capturing them before winning the {@link #pending} slot — so a late entrant that
+   * missed the slot cannot overwrite a fresher entry the previous winner just wrote.
+   */ async #refreshRoots(epoch) {
+        const synced = await this.getSyncedL1BlockNumber();
+        if (synced === undefined) {
+            // The archiver has no synced L1 block yet, so there is no consistent height to read the Outbox
+            // at. The caller retries once the node has synced.
+            return undefined;
+        }
+        const cached = this.#cache.get(epoch);
+        if (cached && cached.fetchedAtL1Block === synced) {
+            return cached.roots;
+        }
+        // TODO: Re-add permanent caching for sealed-and-L1-finalized epochs so we can skip the L1 read
+        // entirely once an epoch's roots can no longer change. For now the cache is valid only for the
+        // current synced L1 block and we re-query the Outbox whenever the node advances.
+        const roots = await this.outbox.getRoots(epoch, {
+            blockNumber: synced
+        });
+        this.#cache.set(epoch, {
+            roots,
+            fetchedAtL1Block: synced
+        });
+        this.log.trace(`Fetched outbox roots for epoch ${epoch}`, {
+            epoch,
+            syncedL1Block: synced,
+            nonZeroRoots: roots.filter((r)=>!r.isZero()).length
+        });
+        return roots;
+    }
+    /**
+   * Returns the L2-to-L1 messages in `epoch`, organized as `checkpoint[] → block[] → tx[] →
+   * message[]`. Mirrors `AztecNodeService.getL2ToL1Messages` so the resolver can run off the
+   * archiver directly without going through the node RPC surface.
+   */ async #getL2ToL1Messages(epoch) {
+        const blocks = await this.archiver.getBlocks({
+            epoch,
+            onlyCheckpointed: true
+        });
+        const blocksInCheckpoints = chunkBy(blocks, (block)=>block.header.globalVariables.slotNumber);
+        return blocksInCheckpoints.map((slotBlocks)=>slotBlocks.map((block)=>block.body.txEffects.map((txEffect)=>txEffect.l2ToL1Msgs)));
+    }
+    /**
+   * Builds the node-shaped adapter handed to `computeL2ToL1MembershipWitness`. The helper invokes
+   * `getL2ToL1Messages` / `getBlock` / `getCheckpointsData`; `getTxReceipt` is part of the helper's
+   * node type but is never invoked because we always pass an already-resolved receipt.
+   */ makeNodeView() {
+        return {
+            getL2ToL1Messages: (epoch)=>this.#getL2ToL1Messages(epoch),
+            getBlock: (param)=>this.archiver.getBlock({
+                    number: param
+                }),
+            getCheckpointsData: (query)=>this.archiver.getCheckpointsData(query),
+            getTxReceipt: ()=>{
+                throw new Error('OutboxTreesResolver always passes a resolved receipt; getTxReceipt must not be called');
+            }
+        };
+    }
+}

package/dest/modules/validation.d.ts

@@ -1,17 +1,40 @@
 import type { EpochCache } from '@aztec/epoch-cache';
+import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
+import { type CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
-import { type AttestationInfo, type ValidateCheckpointResult } from '@aztec/stdlib/block';
-import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { type AttestationInfo, type CommitteeAttestation, type ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { CheckpointInfo, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { ConsensusPayload, type CoordinationSignatureContext } from '@aztec/stdlib/p2p';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 export type { ValidateCheckpointResult };
 /**
  * Extracts attestation information from a published checkpoint.
  * Returns info for each attestation, preserving array indices.
  */
-export declare function getAttestationInfoFromPublishedCheckpoint({ checkpoint, attestations }: PublishedCheckpoint): AttestationInfo[];
+export declare function getAttestationInfoFromPublishedCheckpoint({ checkpoint, attestations }: PublishedCheckpoint, signatureContext: CoordinationSignatureContext): AttestationInfo[];
+/** The subset of a calldata-only checkpoint needed to validate its committee attestations. */
+export type CalldataCheckpointForAttestations = {
+    checkpointNumber: CheckpointNumber;
+    archiveRoot: Fr;
+    feeAssetPriceModifier: bigint;
+    header: CheckpointHeader;
+    attestations: CommitteeAttestation[];
+    /** The exact packed attestations tuple from L1 calldata, carried verbatim for byte-faithful invalidation. */
+    verbatimAttestations: ViemCommitteeAttestations;
+};
 /**
- * Validates the attestations submitted for the given checkpoint.
- * Returns true if the attestations are valid and sufficient, false otherwise.
+ * Validates the attestations of a checkpoint from L1 calldata only, without fetching or decoding its blobs.
+ * The signed consensus payload (header, archive root, fee asset price modifier) is fully available from
+ * calldata, so an invalid-attestation checkpoint can be rejected before any (possibly malformed) blob is
+ * fetched and decoded.
  */
-export declare function validateCheckpointAttestations(publishedCheckpoint: PublishedCheckpoint, epochCache: EpochCache, constants: Pick<L1RollupConstants, 'epochDuration'>, logger?: Logger): Promise<ValidateCheckpointResult>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vZHVsZXMvdmFsaWRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUdyRCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNwRCxPQUFPLEVBQ0wsS0FBSyxlQUFlLEVBRXBCLEtBQUssd0JBQXdCLEVBRTlCLE1BQU0scUJBQXFCLENBQUM7QUFDN0IsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNwRSxPQUFPLEVBQUUsS0FBSyxpQkFBaUIsRUFBa0IsTUFBTSw2QkFBNkIsQ0FBQztBQUdyRixZQUFZLEVBQUUsd0JBQXdCLEVBQUUsQ0FBQztBQUV6Qzs7O0dBR0c7QUFDSCx3QkFBZ0IseUNBQXlDLENBQUMsRUFDeEQsVUFBVSxFQUNWLFlBQVksRUFDYixFQUFFLG1CQUFtQixHQUFHLGVBQWUsRUFBRSxDQUd6QztBQUVEOzs7R0FHRztBQUNILHdCQUFzQiw4QkFBOEIsQ0FDbEQsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQ3hDLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLFNBQVMsRUFBRSxJQUFJLENBQUMsaUJBQWlCLEVBQUUsZUFBZSxDQUFDLEVBQ25ELE1BQU0sQ0FBQyxFQUFFLE1BQU0sR0FDZCxPQUFPLENBQUMsd0JBQXdCLENBQUMsQ0EyRm5DIn0=
+export declare function validateCheckpointAttestationsFromCalldata(checkpoint: CalldataCheckpointForAttestations, epochCache: EpochCache, constants: Pick<L1RollupConstants, 'epochDuration'>, signatureContext: CoordinationSignatureContext, logger?: Logger): Promise<ValidateCheckpointResult>;
+/**
+ * Core attestation validation over a consensus payload, its attestations, and checkpoint metadata --
+ * independent of whether the checkpoint's blocks have been decoded from blobs. Returns true if the
+ * attestations are valid and sufficient, false otherwise.
+ */
+export declare function validateAttestations(payload: ConsensusPayload, attestations: CommitteeAttestation[], verbatimAttestations: ViemCommitteeAttestations, checkpointInfo: CheckpointInfo, epochCache: EpochCache, constants: Pick<L1RollupConstants, 'epochDuration'>, logger?: Logger): Promise<ValidateCheckpointResult>;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/modules/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/modules/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,wBAAwB,EAE9B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,KAAK,iBAAiB,EAAkB,MAAM,6BAA6B,CAAC;AAGrF,YAAY,EAAE,wBAAwB,EAAE,CAAC;AAEzC;;;GAGG;AACH,wBAAgB,yCAAyC,CAAC,EACxD,UAAU,EACV,YAAY,EACb,EAAE,mBAAmB,GAAG,eAAe,EAAE,CAGzC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CA2FnC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/modules/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,iCAAiC,CAAC;AAErF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,oBAAoB,EAEzB,KAAK,wBAAwB,EAE9B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpF,OAAO,EAAE,KAAK,iBAAiB,EAAiC,MAAM,6BAA6B,CAAC;AACpG,OAAO,EAAE,gBAAgB,EAAE,KAAK,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AACxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,YAAY,EAAE,wBAAwB,EAAE,CAAC;AAEzC;;;GAGG;AACH,wBAAgB,yCAAyC,CACvD,EAAE,UAAU,EAAE,YAAY,EAAE,EAAE,mBAAmB,EACjD,gBAAgB,EAAE,4BAA4B,GAC7C,eAAe,EAAE,CAGnB;AAED,8FAA8F;AAC9F,MAAM,MAAM,iCAAiC,GAAG;IAC9C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,WAAW,EAAE,EAAE,CAAC;IAChB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,MAAM,EAAE,gBAAgB,CAAC;IACzB,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,6GAA6G;IAC7G,oBAAoB,EAAE,yBAAyB,CAAC;CACjD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,0CAA0C,CACxD,UAAU,EAAE,iCAAiC,EAC7C,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,gBAAgB,EAAE,4BAA4B,EAC9C,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CAuBnC;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,gBAAgB,EACzB,YAAY,EAAE,oBAAoB,EAAE,EACpC,oBAAoB,EAAE,yBAAyB,EAC/C,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CA4FnC"}

package/dest/modules/validation.js

@@ -1,34 +1,51 @@
 import { compactArray } from '@aztec/foundation/collection';
 import { getAttestationInfoFromPayload } from '@aztec/stdlib/block';
-import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { computeQuorum, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import { ConsensusPayload } from '@aztec/stdlib/p2p';
 /**
  * Extracts attestation information from a published checkpoint.
  * Returns info for each attestation, preserving array indices.
- */ export function getAttestationInfoFromPublishedCheckpoint({ checkpoint, attestations }) {
-    const payload = ConsensusPayload.fromCheckpoint(checkpoint);
+ */ export function getAttestationInfoFromPublishedCheckpoint({ checkpoint, attestations }, signatureContext) {
+    const payload = ConsensusPayload.fromCheckpoint(checkpoint, signatureContext);
     return getAttestationInfoFromPayload(payload, attestations);
 }
 /**
- * Validates the attestations submitted for the given checkpoint.
- * Returns true if the attestations are valid and sufficient, false otherwise.
- */ export async function validateCheckpointAttestations(publishedCheckpoint, epochCache, constants, logger) {
-    const attestorInfos = getAttestationInfoFromPublishedCheckpoint(publishedCheckpoint);
+ * Validates the attestations of a checkpoint from L1 calldata only, without fetching or decoding its blobs.
+ * The signed consensus payload (header, archive root, fee asset price modifier) is fully available from
+ * calldata, so an invalid-attestation checkpoint can be rejected before any (possibly malformed) blob is
+ * fetched and decoded.
+ */ export function validateCheckpointAttestationsFromCalldata(checkpoint, epochCache, constants, signatureContext, logger) {
+    const payload = new ConsensusPayload(checkpoint.header, checkpoint.archiveRoot, checkpoint.feeAssetPriceModifier, signatureContext);
+    const checkpointInfo = {
+        archive: checkpoint.archiveRoot,
+        lastArchive: checkpoint.header.lastArchiveRoot,
+        slotNumber: checkpoint.header.slotNumber,
+        checkpointNumber: checkpoint.checkpointNumber,
+        timestamp: checkpoint.header.timestamp
+    };
+    return validateAttestations(payload, checkpoint.attestations, checkpoint.verbatimAttestations, checkpointInfo, epochCache, constants, logger);
+}
+/**
+ * Core attestation validation over a consensus payload, its attestations, and checkpoint metadata --
+ * independent of whether the checkpoint's blocks have been decoded from blobs. Returns true if the
+ * attestations are valid and sufficient, false otherwise.
+ */ export async function validateAttestations(payload, attestations, verbatimAttestations, checkpointInfo, epochCache, constants, logger) {
+    const attestorInfos = getAttestationInfoFromPayload(payload, attestations);
     const attestors = compactArray(attestorInfos.map((info)=>'address' in info ? info.address : undefined));
-    const { checkpoint, attestations } = publishedCheckpoint;
-    const headerHash = checkpoint.header.hash();
-    const archiveRoot = checkpoint.archive.root.toString();
-    const slot = checkpoint.header.slotNumber;
+    const headerHash = payload.header.hash();
+    const archiveRoot = payload.archive.toString();
+    const slot = payload.header.slotNumber;
+    const checkpointNumber = checkpointInfo.checkpointNumber;
     const epoch = getEpochAtSlot(slot, constants);
     const { committee, seed } = await epochCache.getCommitteeForEpoch(epoch);
     const logData = {
-        checkpointNumber: checkpoint.number,
+        checkpointNumber,
         slot,
         epoch,
         headerHash,
         archiveRoot
     };
-    logger?.debug(`Validating attestations for checkpoint ${checkpoint.number} at slot ${slot} in epoch ${epoch}`, {
+    logger?.debug(`Validating attestations for checkpoint ${checkpointNumber} at slot ${slot} in epoch ${epoch}`, {
         committee: (committee ?? []).map((member)=>member.toString()),
         recoveredAttestors: attestorInfos,
         postedAttestations: attestations.map((a)=>(a.address.isZero() ? a.signature : a.address).toString()),
@@ -46,16 +63,17 @@ import { ConsensusPayload } from '@aztec/stdlib/p2p';
             valid: true
         };
     }
-    const requiredAttestationCount = Math.floor(committee.length * 2 / 3) + 1;
+    const requiredAttestationCount = computeQuorum(committee.length);
     const failedValidationResult = (reason)=>({
             valid: false,
             reason,
-            checkpoint: checkpoint.toCheckpointInfo(),
+            checkpoint: checkpointInfo,
             committee,
             seed,
             epoch,
             attestors,
-            attestations
+            attestations,
+            verbatimAttestations
         });
     for(let i = 0; i < attestorInfos.length; i++){
         const info = attestorInfos[i];
@@ -97,7 +115,7 @@ import { ConsensusPayload } from '@aztec/stdlib/p2p';
         });
         return failedValidationResult('insufficient-attestations');
     }
-    logger?.debug(`Checkpoint attestations validated successfully for checkpoint ${checkpoint.number} at slot ${slot}`, logData);
+    logger?.debug(`Checkpoint attestations validated successfully for checkpoint ${checkpointNumber} at slot ${slot}`, logData);
     return {
         valid: true
     };