@aztec/archiver 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/modules/validation.ts

@@ -1,16 +1,20 @@
 import type { EpochCache } from '@aztec/epoch-cache';
-import { EpochNumber } from '@aztec/foundation/branded-types';
+import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
+import { type CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
 import {
   type AttestationInfo,
+  type CommitteeAttestation,
   type ValidateCheckpointNegativeResult,
   type ValidateCheckpointResult,
   getAttestationInfoFromPayload,
 } from '@aztec/stdlib/block';
-import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { CheckpointInfo, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants, computeQuorum, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import { ConsensusPayload, type CoordinationSignatureContext } from '@aztec/stdlib/p2p';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 
 export type { ValidateCheckpointResult };
 
@@ -26,28 +30,79 @@ export function getAttestationInfoFromPublishedCheckpoint(
   return getAttestationInfoFromPayload(payload, attestations);
 }
 
+/** 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 async function validateCheckpointAttestations(
-  publishedCheckpoint: PublishedCheckpoint,
+export function validateCheckpointAttestationsFromCalldata(
+  checkpoint: CalldataCheckpointForAttestations,
   epochCache: EpochCache,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
   signatureContext: CoordinationSignatureContext,
   logger?: Logger,
 ): Promise<ValidateCheckpointResult> {
-  const attestorInfos = getAttestationInfoFromPublishedCheckpoint(publishedCheckpoint, signatureContext);
+  const payload = new ConsensusPayload(
+    checkpoint.header,
+    checkpoint.archiveRoot,
+    checkpoint.feeAssetPriceModifier,
+    signatureContext,
+  );
+  const checkpointInfo: 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: ConsensusPayload,
+  attestations: CommitteeAttestation[],
+  verbatimAttestations: ViemCommitteeAttestations,
+  checkpointInfo: CheckpointInfo,
+  epochCache: EpochCache,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+  logger?: Logger,
+): Promise<ValidateCheckpointResult> {
+  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: EpochNumber = getEpochAtSlot(slot, constants);
   const { committee, seed } = await epochCache.getCommitteeForEpoch(epoch);
-  const logData = { checkpointNumber: checkpoint.number, slot, epoch, headerHash, archiveRoot };
+  const logData = { 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()),
@@ -72,12 +127,13 @@ export async function validateCheckpointAttestations(
   const failedValidationResult = <TReason extends ValidateCheckpointNegativeResult['reason']>(reason: TReason) => ({
     valid: false as const,
     reason,
-    checkpoint: checkpoint.toCheckpointInfo(),
+    checkpoint: checkpointInfo,
     committee,
     seed,
     epoch,
     attestors,
     attestations,
+    verbatimAttestations,
   });
 
   for (let i = 0; i < attestorInfos.length; i++) {
@@ -123,7 +179,7 @@ export async function validateCheckpointAttestations(
   }
 
   logger?.debug(
-    `Checkpoint attestations validated successfully for checkpoint ${checkpoint.number} at slot ${slot}`,
+    `Checkpoint attestations validated successfully for checkpoint ${checkpointNumber} at slot ${slot}`,
     logData,
   );
   return { valid: true };

package/src/store/block_store.ts

@@ -30,7 +30,6 @@ import {
   type ProposedCheckpointInput,
   PublishedCheckpoint,
 } from '@aztec/stdlib/checkpoint';
-import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import {
@@ -38,8 +37,6 @@ import {
   type IndexedTxEffect,
   TxEffect,
   TxHash,
-  TxReceipt,
-  TxStatus,
   deserializeIndexedTxEffect,
   serializeIndexedTxEffect,
 } from '@aztec/stdlib/tx';
@@ -61,7 +58,7 @@ import {
   ProposedCheckpointPromotionNotSequentialError,
 } from '../errors.js';
 
-export { TxReceipt, type TxEffect, type TxHash } from '@aztec/stdlib/tx';
+export type { TxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
 type BlockIndexValue = [blockNumber: number, index: number];
 
@@ -309,12 +306,18 @@ export class BlockStore {
 
   /**
    * Append new checkpoints to the store's list.
+   * Checkpoints at the start of the batch that are already stored (e.g. re-included by an L1 reorg)
+   * are accepted if their archive root matches: their L1 metadata is updated but they are not
+   * re-inserted, and they are excluded from the returned array.
    * @param checkpoints - The L2 checkpoints to be added to the store.
-   * @returns True if the operation is successful.
+   * @returns The checkpoints that were actually inserted (excluding already-stored ones).
    */
-  async addCheckpoints(checkpoints: PublishedCheckpoint[], opts: { force?: boolean } = {}): Promise<boolean> {
+  async addCheckpoints(
+    checkpoints: PublishedCheckpoint[],
+    opts: { force?: boolean } = {},
+  ): Promise<PublishedCheckpoint[]> {
     if (checkpoints.length === 0) {
-      return true;
+      return [];
     }
 
     return await this.db.transactionAsync(async () => {
@@ -327,7 +330,7 @@ export class BlockStore {
       if (!opts.force && firstCheckpointNumber <= previousCheckpointNumber) {
         checkpoints = await this.skipOrUpdateAlreadyStoredCheckpoints(checkpoints, previousCheckpointNumber);
         if (checkpoints.length === 0) {
-          return true;
+          return [];
         }
         // Re-check sequentiality after skipping
         const newFirstNumber = checkpoints[0].checkpoint.number;
@@ -390,7 +393,7 @@ export class BlockStore {
       }
 
       await this.advanceSynchedL1BlockNumber(checkpoints[checkpoints.length - 1].l1.blockNumber);
-      return true;
+      return checkpoints;
     });
   }
 
@@ -521,6 +524,7 @@ export class BlockStore {
         l2BlockNumber: block.number,
         l2BlockHash: blockHash,
         txIndexInBlock: i,
+        slotNumber: block.header.globalVariables.slotNumber,
       };
       await this.#txEffects.set(txEffect.data.txHash.toString(), serializeIndexedTxEffect(txEffect));
     }
@@ -533,20 +537,58 @@ export class BlockStore {
   }
 
   /** Deletes a block and all associated data (tx effects, indices). */
-  private async deleteBlock(block: L2Block): Promise<void> {
+  private async deleteBlock(blockNumber: number, blockStorage: BlockStorage): Promise<void> {
     // Delete the block from the main blocks map
-    await this.#blocks.delete(block.number);
-
-    // Delete all tx effects for this block
-    await Promise.all(block.body.txEffects.map(tx => this.#txEffects.delete(tx.txHash.toString())));
+    await this.#blocks.delete(blockNumber);
+
+    const blockHash = bufferToHex(blockStorage.blockHash);
+
+    // Delete the tx effects of the block's txs, skipping entries that no longer point at this block: if
+    // another stored block also contains the tx, the entry points at that block, and deleting it here would
+    // orphan that block's index. Honest chains never store the same tx twice (duplicate nullifiers are
+    // rejected at build, re-execution, and world-state sync), so the store must not turn such a state into
+    // corruption of the surviving block if it ever appears.
+    const blockTxsBuffer = await this.#blockTxs.getAsync(blockHash);
+    if (blockTxsBuffer !== undefined) {
+      const reader = BufferReader.asReader(blockTxsBuffer);
+      const txHashes: string[] = [];
+      while (!reader.isEmpty()) {
+        txHashes.push(reader.readObject(TxHash).toString());
+      }
+      await Promise.all(txHashes.map(txHash => this.deleteTxEffect(txHash, blockStorage.blockHash)));
+    }
 
     // Delete block txs mapping
-    const blockHash = (await block.hash()).toString();
     await this.#blockTxs.delete(blockHash);
 
     // Clean up indices
     await this.#blockHashIndex.delete(blockHash);
-    await this.#blockArchiveIndex.delete(block.archive.root.toString());
+    await this.#blockArchiveIndex.delete(AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive).root.toString());
+  }
+
+  /** Deletes a tx effect only if it is still owned by (points at) the given block. */
+  private async deleteTxEffect(txHash: string, blockHash: Buffer): Promise<void> {
+    const stored = await this.#txEffects.getAsync(txHash);
+    if (stored === undefined) {
+      this.#log.warn(`Missing tx effect for tx ${txHash} while removing its block`, {
+        txHash,
+        blockHash: bufferToHex(blockHash),
+      });
+      return;
+    }
+    // An IndexedTxEffect starts with the owning block hash (32 bytes) — see getTxLocation.
+    if (!Buffer.from(stored.buffer, stored.byteOffset, 32).equals(blockHash)) {
+      // Fires only when two stored blocks listed the same tx — a state upstream validation should make
+      // unreachable. Keep the entry (it belongs to the surviving block) but flag the duplication loudly.
+      this.#log.warn(`Tx effect for tx ${txHash} is owned by a block other than the one being removed`, {
+        txHash,
+        removedBlockHash: bufferToHex(blockHash),
+        owningBlockHash: bufferToHex(Buffer.from(stored.buffer, stored.byteOffset, 32)),
+      });
+      return;
+    }
+
+    await this.#txEffects.delete(txHash);
   }
 
   /**
@@ -623,6 +665,26 @@ export class BlockStore {
     return checkpoints;
   }
 
+  /**
+   * Returns up to `limit` checkpoints anchored at `fromSlot`, ordered nearest-first, walking the slot index.
+   * With `reverse`, takes the checkpoints at or before `fromSlot` (descending by slot); otherwise the
+   * checkpoints at or after it (ascending). `limit: 1, reverse: true` yields the latest checkpoint at or
+   * before the slot in a single range scan.
+   */
+  async getCheckpointsBySlot(fromSlot: SlotNumber, limit: number, reverse: boolean): Promise<CheckpointData[]> {
+    // The KV range bounds are direction-dependent: forward is [start, end), reverse is (start, end], so a
+    // reverse scan uses `end: fromSlot` (inclusive) with no +1 to include the checkpoint at fromSlot itself.
+    const range = reverse ? { end: fromSlot, reverse: true, limit } : { start: fromSlot, limit };
+    const result: CheckpointData[] = [];
+    for await (const [, checkpointNumber] of this.#slotToCheckpoint.entriesAsync(range)) {
+      const checkpointStorage = await this.#checkpoints.getAsync(checkpointNumber);
+      if (checkpointStorage) {
+        result.push(this.checkpointDataFromCheckpointStorage(checkpointStorage));
+      }
+    }
+    return result;
+  }
+
   /** Returns checkpoint data for all checkpoints whose slot falls within the given range (inclusive). */
   async getCheckpointDataForSlotRange(startSlot: SlotNumber, endSlot: SlotNumber): Promise<CheckpointData[]> {
     const result: CheckpointData[] = [];
@@ -725,16 +787,24 @@ export class BlockStore {
 
       // Iterate from blockNumber + 1 to latestBlockNumber
       for (let bn = blockNumber + 1; bn <= latestBlockNumber; bn++) {
-        const block = await this.getBlock({ number: BlockNumber(bn) });
+        const blockStorage = await this.#blocks.getAsync(bn);
 
-        if (block === undefined) {
+        if (blockStorage === undefined) {
           this.#log.warn(`Cannot remove block ${bn} from the store since we don't have it`);
           continue;
         }
 
-        removedBlocks.push(block);
-        await this.deleteBlock(block);
-        this.#log.debug(`Removed block ${bn} ${(await block.hash()).toString()}`);
+        // Load the full block for the returned list when possible, but clean up from the raw row regardless:
+        // a block whose body can no longer be fully loaded must still release its row, tx effects, and indices,
+        // or later inserts at this number leave stale tx-effect entries pointing into the new chain.
+        const block = await this.getBlockFromBlockStorage(bn, blockStorage);
+        if (block !== undefined) {
+          removedBlocks.push(block);
+        } else {
+          this.#log.warn(`Removing block ${bn} whose body could not be fully loaded`);
+        }
+        await this.deleteBlock(bn, blockStorage);
+        this.#log.debug(`Removed block ${bn} ${bufferToHex(blockStorage.blockHash)}`);
       }
 
       return removedBlocks;
@@ -1092,56 +1162,6 @@ export class BlockStore {
     return deserializeIndexedTxEffect(buffer);
   }
 
-  /**
-   * Gets a receipt of a settled tx.
-   * @param txHash - The hash of a tx we try to get the receipt for.
-   * @returns The requested tx receipt (or undefined if not found).
-   */
-  async getSettledTxReceipt(
-    txHash: TxHash,
-    l1Constants?: Pick<L1RollupConstants, 'epochDuration'>,
-  ): Promise<TxReceipt | undefined> {
-    const txEffect = await this.getTxEffect(txHash);
-    if (!txEffect) {
-      return undefined;
-    }
-
-    const blockNumber = BlockNumber(txEffect.l2BlockNumber);
-
-    // Use existing archiver methods to determine finalization level
-    const [provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber, blockData] = await Promise.all([
-      this.getProvenBlockNumber(),
-      this.getCheckpointedL2BlockNumber(),
-      this.getFinalizedL2BlockNumber(),
-      this.getBlockData({ number: blockNumber }),
-    ]);
-
-    let status: TxStatus;
-    if (blockNumber <= finalizedBlockNumber) {
-      status = TxStatus.FINALIZED;
-    } else if (blockNumber <= provenBlockNumber) {
-      status = TxStatus.PROVEN;
-    } else if (blockNumber <= checkpointedBlockNumber) {
-      status = TxStatus.CHECKPOINTED;
-    } else {
-      status = TxStatus.PROPOSED;
-    }
-
-    const epochNumber =
-      blockData && l1Constants ? getEpochAtSlot(blockData.header.globalVariables.slotNumber, l1Constants) : undefined;
-
-    return new TxReceipt(
-      txHash,
-      status,
-      TxReceipt.executionResultFromRevertCode(txEffect.data.revertCode),
-      undefined,
-      txEffect.data.transactionFee.toBigInt(),
-      txEffect.l2BlockHash,
-      blockNumber,
-      epochNumber,
-    );
-  }
-
   /**
    * Looks up which block included the requested tx effect.
    * @param txHash - The txHash of the tx.
@@ -1167,8 +1187,9 @@ export class BlockStore {
    * attach effect data on demand without paying for a full {@link TxEffect} deserialization.
    *
    * The on-disk `IndexedTxEffect` layout starts with a fixed-length header
-   * (`blockHash(32) + l2BlockNumber(4) + txIndexInBlock(4) + revertCode(1) + txHash(32) + transactionFee(32)` =
-   * 105 bytes), followed by `noteHashes` and `nullifiers` (both u8-length-prefixed `Fr` vectors). We
+   * (`blockHash(32) + l2BlockNumber(4) + txIndexInBlock(4) + slotNumber(4) + revertCode(1) + txHash(32) +
+   * transactionFee(32)` = 109 bytes), followed by `noteHashes` and `nullifiers` (both u8-length-prefixed `Fr`
+   * vectors). We
    * skip the header, then read the two vectors, and stop — the large tail (`l2ToL1Msgs`,
    * `publicDataWrites`, `privateLogs`, `publicLogs`, `contractClassLogs`) is never touched.
    */
@@ -1180,8 +1201,9 @@ export class BlockStore {
           return [[], []];
         }
         const reader = BufferReader.asReader(buffer);
-        // Skip the fixed-length header: blockHash + l2BlockNumber + txIndexInBlock + revertCode + txHash + transactionFee.
-        reader.readBytes(32 + 4 + 4 + 1 + 32 + 32);
+        // Skip the fixed-length header: blockHash + l2BlockNumber + txIndexInBlock + slotNumber + revertCode +
+        // txHash + transactionFee.
+        reader.readBytes(32 + 4 + 4 + 4 + 1 + 32 + 32);
         const noteHashes = reader.readVectorUint8Prefix(Fr);
         const nullifiers = reader.readVectorUint8Prefix(Fr);
         return [noteHashes, nullifiers];
@@ -1217,14 +1239,13 @@ export class BlockStore {
   }
 
   /**
-   * Resolves all five L2 chain tips (proposed, proposedCheckpoint, checkpointed, proven, finalized)
-   * in a single read-only transaction so the snapshot is internally consistent. Each underlying
-   * record is read at most once: latest block, latest confirmed checkpoint, and latest pending
-   * checkpoint are each loaded directly (no separate "find the number, then look up data" hop),
-   * the proven/finalized checkpoint singletons are read once and their storage entries are
-   * reused if they coincide with the latest checkpoint, and per-tip block hashes are deduped
-   * when two tips land on the same block (e.g. finalized == proven, or proposedCheckpoint falls
-   * back to checkpointed when no pending checkpoint exists).
+   * Resolves all four L2 chain tips (proposed, checkpointed, proven, finalized) in a single
+   * read-only transaction so the snapshot is internally consistent. Each underlying record is
+   * read at most once: latest block and latest confirmed checkpoint are loaded directly (no
+   * separate "find the number, then look up data" hop), the proven/finalized checkpoint
+   * singletons are read once and their storage entries are reused if they coincide with the
+   * latest checkpoint, and per-tip block hashes are deduped when two tips land on the same block
+   * (e.g. finalized == proven).
    *
    * The result is guaranteed to satisfy `finalized <= proven <= checkpointed <= proposed` (by
    * block number). Genesis is represented by `(INITIAL_L2_BLOCK_NUM - 1)` and the supplied
@@ -1247,9 +1268,6 @@ export class BlockStore {
 
       // Load latest block and checkpoint entries
       const [latestBlockEntry] = await toArray(this.#blocks.entriesAsync({ reverse: true, limit: 1 }));
-      const [proposedCheckpointEntry] = await toArray(
-        this.#proposedCheckpoints.entriesAsync({ reverse: true, limit: 1 }),
-      );
       const [latestCheckpointEntry] = await toArray(this.#checkpoints.entriesAsync({ reverse: true, limit: 1 }));
       const latestCheckpointNumber = latestCheckpointEntry
         ? CheckpointNumber(latestCheckpointEntry[0])
@@ -1335,14 +1353,6 @@ export class BlockStore {
       const provenTip = await buildTipFromCheckpoint(provenCheckpoint);
       const finalizedTip = await buildTipFromCheckpoint(finalizedCheckpoint);
 
-      // Proposed checkpoint falls back to the checkpoint tip if it's not set. And if local storage is
-      // inconsistent and the proposed checkpoint is behind the checkpointed tip, we patch that and
-      // report the checkpointed tip as the proposed checkpoint to maintain the invariant.
-      const proposedCheckpointTip =
-        proposedCheckpointEntry === undefined || proposedCheckpointEntry[0] <= latestCheckpointNumber
-          ? checkpointedTip
-          : await buildTipFromCheckpoint(proposedCheckpointEntry[1]);
-
       // A checkpointed block past the latest stored block would mean a checkpoint
       // references blocks that aren't in blocks.
       if (proposedBlockId.number < checkpointedTip.block.number) {
@@ -1354,11 +1364,10 @@ export class BlockStore {
       // Assert that checkpoint numbers are increasing
       if (
         finalizedTip.checkpoint.number > provenTip.checkpoint.number ||
-        provenTip.checkpoint.number > checkpointedTip.checkpoint.number ||
-        checkpointedTip.checkpoint.number > proposedCheckpointTip.checkpoint.number
+        provenTip.checkpoint.number > checkpointedTip.checkpoint.number
       ) {
         throw new Error(
-          `Inconsistent checkpoint numbers in chain tips: finalized=${finalizedTip.checkpoint.number} proven=${provenTip.checkpoint.number} checkpointed=${checkpointedTip.checkpoint.number} proposed=${proposedCheckpointTip.checkpoint.number}`,
+          `Inconsistent checkpoint numbers in chain tips: finalized=${finalizedTip.checkpoint.number} proven=${provenTip.checkpoint.number} checkpointed=${checkpointedTip.checkpoint.number}`,
         );
       }
 
@@ -1366,17 +1375,15 @@ export class BlockStore {
       if (
         finalizedTip.block.number > provenTip.block.number ||
         provenTip.block.number > checkpointedTip.block.number ||
-        checkpointedTip.block.number > proposedCheckpointTip.block.number ||
-        proposedCheckpointTip.block.number > proposedBlockId.number
+        checkpointedTip.block.number > proposedBlockId.number
       ) {
         throw new Error(
-          `Inconsistent block numbers in chain tips: finalized=${finalizedTip.block.number} proven=${provenTip.block.number} checkpointed=${checkpointedTip.block.number} proposedCheckpoint=${proposedCheckpointTip.block.number} proposed=${proposedBlockId.number}`,
+          `Inconsistent block numbers in chain tips: finalized=${finalizedTip.block.number} proven=${provenTip.block.number} checkpointed=${checkpointedTip.block.number} proposed=${proposedBlockId.number}`,
         );
       }
 
       return {
         proposed: proposedBlockId,
-        proposedCheckpoint: proposedCheckpointTip,
         checkpointed: checkpointedTip,
         proven: provenTip,
         finalized: finalizedTip,

package/src/store/contract_class_store.ts

@@ -2,6 +2,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import { isProtocolContractClass } from '@aztec/protocol-contracts';
 import type {
   ContractClassPublic,
   ContractClassPublicWithBlockNumber,
@@ -49,7 +50,19 @@ export class ContractClassStore {
   ): Promise<void> {
     await this.db.transactionAsync(async () => {
       const key = contractClass.id.toString();
-      if (await this.#contractClasses.hasAsync(key)) {
+      const existing = await this.#contractClasses.getAsync(key);
+      if (existing !== undefined) {
+        // Protocol contracts are preloaded at block 0, so a later on-chain (re-)publish of a bundled
+        // protocol class id is valid and must be a no-op. Keep the existing block-0 entry untouched
+        // (do not bump its block number) so it survives reorgs of the publishing block.
+        if (isProtocolContractClass(contractClass.id)) {
+          return;
+        }
+        // An L1 reorg can re-present an already-stored checkpoint, replaying this class at the same
+        // block; treat that as a no-op. A duplicate at a different block still signals double-processing.
+        if (deserializeContractClassPublic(existing).l2BlockNumber === blockNumber) {
+          return;
+        }
         throw new Error(`Contract class ${key} already exists, cannot add again at block ${blockNumber}`);
       }
       await this.#contractClasses.set(
@@ -61,6 +74,11 @@ export class ContractClassStore {
   }
 
   async deleteContractClass(contractClass: ContractClassPublic, blockNumber: number): Promise<void> {
+    // Protocol contracts are preloaded at block 0 and must never be deleted, even when the block that
+    // (re-)published them on-chain is unwound by a reorg.
+    if (isProtocolContractClass(contractClass.id)) {
+      return;
+    }
     const restoredContractClass = await this.#contractClasses.getAsync(contractClass.id.toString());
     if (restoredContractClass && deserializeContractClassPublic(restoredContractClass).l2BlockNumber >= blockNumber) {
       await this.db.transactionAsync(async () => {

package/src/store/contract_instance_store.ts

@@ -1,5 +1,6 @@
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import { isProtocolContract } from '@aztec/protocol-contracts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
   type ContractInstanceUpdateWithAddress,
@@ -72,8 +73,19 @@ export class ContractInstanceStore {
     return this.db.transactionAsync(async () => {
       const key = contractInstance.address.toString();
       if (await this.#contractInstances.hasAsync(key)) {
+        // Protocol contracts are preloaded at block 0, so a later on-chain (re-)publish of a bundled
+        // protocol instance is valid and must be a no-op. Keep the existing block-0 entry untouched.
+        if (isProtocolContract(contractInstance.address)) {
+          return;
+        }
+        const existingBlockNumber = await this.#contractInstancePublishedAt.getAsync(key);
+        // An L1 reorg can re-present an already-stored checkpoint, replaying this instance at the same
+        // block; treat that as a no-op. A duplicate at a different block still signals double-processing.
+        if (existingBlockNumber === blockNumber) {
+          return;
+        }
         throw new Error(
-          `Contract instance at ${key} already exists (deployed at block ${await this.#contractInstancePublishedAt.getAsync(key)}), cannot add again at block ${blockNumber}`,
+          `Contract instance at ${key} already exists (deployed at block ${existingBlockNumber}), cannot add again at block ${blockNumber}`,
         );
       }
       await this.#contractInstances.set(key, new SerializableContractInstance(contractInstance).toBuffer());
@@ -82,6 +94,11 @@ export class ContractInstanceStore {
   }
 
   deleteContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void> {
+    // Protocol contracts are preloaded at block 0 and must never be deleted, even when the block that
+    // (re-)published them on-chain is unwound by a reorg.
+    if (isProtocolContract(contractInstance.address)) {
+      return Promise.resolve();
+    }
     return this.db.transactionAsync(async () => {
       await this.#contractInstances.delete(contractInstance.address.toString());
       await this.#contractInstancePublishedAt.delete(contractInstance.address.toString());

package/src/store/log_store.ts

@@ -26,6 +26,7 @@ import {
   endOfTxRange,
   fieldHex,
   incKey,
+  tagHexForLog,
 } from './log_store_codec.js';
 
 /**
@@ -100,7 +101,7 @@ export class LogStore {
           let publicLogIndexWithinTx = 0;
 
           for (const log of txEffect.privateLogs) {
-            const tagHex = fieldHex(log.fields[0]);
+            const tagHex = tagHexForLog(log.fields);
             const key = encodeKey(tagHex, blockNumber, txIndexWithinBlock, privateLogIndexWithinTx);
             const value = encodeValue({
               txHash,
@@ -115,7 +116,7 @@ export class LogStore {
 
           for (const log of txEffect.publicLogs) {
             const contractHex = fieldHex(log.contractAddress);
-            const tagHex = fieldHex(log.fields[0]);
+            const tagHex = tagHexForLog(log.fields);
             const key = encodeKey(
               encodePublicPrefix(contractHex, tagHex),
               blockNumber,

package/src/store/log_store_codec.ts

@@ -37,6 +37,17 @@ export function fieldHex(value: Fr | { toString: () => string }): string {
   return value.toString().slice(2);
 }
 
+/**
+ * Tag prefix for a log: the hex of its first field, or the empty string when the log carries no fields.
+ * A protocol-valid public log can have zero fields (e.g. a raw AVM `EMITPUBLICLOG` with `logSize = 0`),
+ * which has no tag to index by. Encoding it under the empty tag keeps it retrievable via the per-block
+ * read (and droppable on reorg) while never matching a real 64-hex-char tag query — instead of reading
+ * `fields[0]` off an empty array and aborting the whole block-ingestion transaction.
+ */
+export function tagHexForLog(fields: Fr[]): string {
+  return fields.length > 0 ? fieldHex(fields[0]) : '';
+}
+
 /** Encodes a number as 8-char zero-padded lowercase hex (matches a u32 big-endian byte buffer's lex order). */
 export function u32Hex(n: number): string {
   return n.toString(16).padStart(NUMERIC_HEX_LEN, '0');

package/src/test/fake_l1_state.ts

@@ -682,7 +682,7 @@ export class FakeL1State {
       getHashedSignaturePayloadTypedData(attestationsAndSigners),
     );
 
-    const packedAttestations = attestationsAndSigners.getPackedAttestations();
+    const verbatimAttestations = attestationsAndSigners.getPackedAttestations();
 
     const rollupInput = encodeFunctionData({
       abi: RollupAbi,
@@ -693,7 +693,7 @@ export class FakeL1State {
           archive,
           oracleInput: { feeAssetPriceModifier: 0n },
         },
-        packedAttestations,
+        verbatimAttestations,
         attestationsAndSigners.getSigners().map(signer => signer.toString()),
         attestationsAndSignersSignature.toViemSignature(),
         blobInput,
@@ -716,7 +716,7 @@ export class FakeL1State {
 
     // Compute attestationsHash (same logic as CalldataRetriever)
     const attestationsHash = Buffer32.fromString(
-      keccak256(encodeAbiParameters([this.getCommitteeAttestationsStructDef()], [packedAttestations])),
+      keccak256(encodeAbiParameters([this.getCommitteeAttestationsStructDef()], [verbatimAttestations])),
     );
 
     // Compute payloadDigest (same logic as CalldataRetriever)

package/src/test/mock_l1_to_l2_message_source.ts

@@ -44,7 +44,6 @@ export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
       checkpointed: tip,
       proven: tip,
       finalized: tip,
-      proposedCheckpoint: tip,
     });
   }
 }