@aztec/archiver 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

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,
     });
   }
 }

package/src/test/mock_l2_block_source.ts

@@ -55,7 +55,6 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   private provenBlockNumber: number = 0;
   private finalizedBlockNumber: number = 0;
   private checkpointedBlockNumber: number = 0;
-  private proposedCheckpointBlockNumber: number = 0;
 
   private initialHeader: BlockHeader = BlockHeader.empty();
   private initialHeaderHash: BlockHash = GENESIS_BLOCK_HEADER_HASH;
@@ -164,7 +163,6 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     });
     // Keep tip numbers consistent with remaining blocks.
     this.checkpointedBlockNumber = Math.min(this.checkpointedBlockNumber, maxBlockNum);
-    this.proposedCheckpointBlockNumber = Math.min(this.proposedCheckpointBlockNumber, maxBlockNum);
     this.provenBlockNumber = Math.min(this.provenBlockNumber, maxBlockNum);
     this.finalizedBlockNumber = Math.min(this.finalizedBlockNumber, maxBlockNum);
     this.log.verbose(`Removed ${numBlocks} blocks from the mock L2 block source`);
@@ -181,17 +179,9 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     this.finalizedBlockNumber = finalizedBlockNumber;
   }
 
-  public setProposedCheckpointBlockNumber(blockNumber: number) {
-    this.proposedCheckpointBlockNumber = blockNumber;
-  }
-
   public setCheckpointedBlockNumber(checkpointedBlockNumber: number) {
     const prevCheckpointed = this.checkpointedBlockNumber;
     this.checkpointedBlockNumber = checkpointedBlockNumber;
-    // Proposed checkpoint is always at least as advanced as checkpointed
-    if (this.proposedCheckpointBlockNumber < checkpointedBlockNumber) {
-      this.proposedCheckpointBlockNumber = checkpointedBlockNumber;
-    }
     // Auto-create single-block checkpoints for newly checkpointed blocks that don't have one yet.
     // This handles blocks added via addProposedBlocks that are now being marked as checkpointed.
     const newCheckpoints: Checkpoint[] = [];
@@ -255,10 +245,6 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return block ? block.header.globalVariables.blockNumber : undefined;
   }
 
-  public getProposedCheckpointL2BlockNumber() {
-    return Promise.resolve(BlockNumber(this.proposedCheckpointBlockNumber));
-  }
-
   public getCheckpoint(query: CheckpointQuery): Promise<PublishedCheckpoint | undefined> {
     const checkpoint = this.resolveCheckpointQuery(query);
     if (!checkpoint) {
@@ -337,6 +323,13 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     if ('from' in query) {
       return this.checkpointList.slice(query.from - 1, query.from - 1 + query.limit);
     }
+    if ('fromSlot' in query) {
+      const matching = this.checkpointList.filter(c =>
+        query.reverse ? c.header.slotNumber <= query.fromSlot : c.header.slotNumber >= query.fromSlot,
+      );
+      const nearestFirst = query.reverse ? matching.reverse() : matching;
+      return nearestFirst.slice(0, query.limit);
+    }
     return this.getCheckpointsInEpoch(query.epoch);
   }
 
@@ -373,19 +366,17 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   }
 
   async getL2Tips(): Promise<L2Tips> {
-    const [latest, proven, finalized, checkpointed, proposedCheckpoint] = [
+    const [latest, proven, finalized, checkpointed] = [
       await this.getBlockNumber(),
       this.provenBlockNumber,
       this.finalizedBlockNumber,
       this.checkpointedBlockNumber,
-      await this.getProposedCheckpointL2BlockNumber(),
     ] as const;
 
     const latestBlock = this.l2Blocks[latest - 1];
     const provenBlock = this.l2Blocks[proven - 1];
     const finalizedBlock = this.l2Blocks[finalized - 1];
     const checkpointedBlock = this.l2Blocks[checkpointed - 1];
-    const proposedCheckpointBlock = this.l2Blocks[proposedCheckpoint - 1];
 
     // For genesis tips (block number 0) report the dynamic initial header hash so consumers
     // running L2BlockStream against this mock agree at block 0 with their local tip store.
@@ -413,10 +404,6 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
       number: BlockNumber(checkpointed),
       hash: await tipHash(checkpointedBlock, checkpointed),
     };
-    const proposedCheckpointBlockId = {
-      number: BlockNumber(proposedCheckpoint),
-      hash: await tipHash(proposedCheckpointBlock, proposedCheckpoint),
-    };
 
     const makeTipId = (blockId: typeof latestBlockId) => {
       const checkpointNumber = this.findCheckpointNumberForBlock(blockId.number) ?? CheckpointNumber(0);
@@ -435,7 +422,6 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
       checkpointed: makeTipId(checkpointedBlockId),
       proven: makeTipId(provenBlockId),
       finalized: makeTipId(finalizedBlockId),
-      proposedCheckpoint: makeTipId(proposedCheckpointBlockId),
     };
   }
 

package/src/test/mock_structs.ts

@@ -269,7 +269,10 @@ export function makePublicLogTag(blockNumber: number, txIndex: number, logIndex:
 }
 
 /** Creates a PublicLog with fields derived from the tag. */
-export function makePublicLog(tag: Tag, contractAddress: AztecAddress = AztecAddress.fromNumber(543254)): PublicLog {
+export function makePublicLog(
+  tag: Tag,
+  contractAddress: AztecAddress = AztecAddress.fromNumberUnsafe(543254),
+): PublicLog {
   return PublicLog.from({
     contractAddress,
     fields: new Array(10).fill(null).map((_, i) => (!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i)))),
@@ -281,7 +284,7 @@ export function makePublicLogs(
   blockNumber: number,
   txIndex: number,
   numLogsPerTx: number,
-  contractAddress: AztecAddress = AztecAddress.fromNumber(543254),
+  contractAddress: AztecAddress = AztecAddress.fromNumberUnsafe(543254),
 ): PublicLog[] {
   return times(numLogsPerTx, logIndex => {
     const tag = makePublicLogTag(blockNumber, txIndex, logIndex);

package/src/test/noop_l1_archiver.ts

@@ -7,7 +7,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { FunctionsOf } from '@aztec/foundation/types';
-import type { ArchiverEmitter, BlockHash } from '@aztec/stdlib/block';
+import type { ArchiverEmitter, BlockHash, L2Block } from '@aztec/stdlib/block';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import { type TelemetryClient, type Tracer, getTelemetryClient } from '@aztec/telemetry-client';
@@ -21,6 +21,10 @@ import type { ArchiverL1Synchronizer } from '../modules/l1_synchronizer.js';
 import type { ArchiverDataStores } from '../store/data_stores.js';
 import { L2TipsCache } from '../store/l2_tips_cache.js';
 
+type NoopL1ArchiverConfigOverrides = Partial<{
+  skipOrphanProposedBlockPruning: boolean;
+}>;
+
 /** Noop L1 synchronizer for testing without L1 connectivity. */
 class NoopL1Synchronizer implements FunctionsOf<ArchiverL1Synchronizer> {
   public readonly tracer: Tracer;
@@ -39,8 +43,8 @@ class NoopL1Synchronizer implements FunctionsOf<ArchiverL1Synchronizer> {
   testEthereumNodeSynced(): Promise<void> {
     return Promise.resolve();
   }
-  syncFromL1(_initialSyncComplete: boolean): Promise<void> {
-    return Promise.resolve();
+  syncFromL1(_initialSyncComplete: boolean): Promise<L2Block[]> {
+    return Promise.resolve([]);
   }
 }
 
@@ -58,6 +62,7 @@ export class NoopL1Archiver extends Archiver {
     initialBlockHash: BlockHash,
     l2TipsCache: L2TipsCache,
     dateProvider: DateProvider = new DateProvider(),
+    configOverrides: NoopL1ArchiverConfigOverrides = {},
   ) {
     // Create mocks for L1 clients
     const publicClient = mock<ViemPublicClient>();
@@ -93,8 +98,11 @@ export class NoopL1Archiver extends Archiver {
         maxAllowedEthClientDriftSeconds: 300,
         ethereumAllowNoDebugHosts: true, // Skip trace validation
         skipHistoricalLogsCheck: true, // Skip historical logs validation
-        orphanProposedBlockPruneGraceSeconds: 2,
-        enableOrphanProposedBlockPruning: true,
+        checkpointProposalSyncGrace: 4,
+        orphanPruneNoProposalTolerance: 1,
+        skipOrphanProposedBlockPruning: true,
+        blockDuration: 2,
+        ...configOverrides,
       },
       blobClient,
       instrumentation,
@@ -128,6 +136,7 @@ export async function createNoopL1Archiver(
   telemetry: TelemetryClient = getTelemetryClient(),
   initialHeader: BlockHeader,
   dateProvider?: DateProvider,
+  configOverrides?: NoopL1ArchiverConfigOverrides,
 ): Promise<NoopL1Archiver> {
   const instrumentation = await ArchiverInstrumentation.new(telemetry, () => dataStores.db.estimateSize());
   // Mirror the production factory: precompute the dynamic genesis block hash from the injected
@@ -144,5 +153,6 @@ export async function createNoopL1Archiver(
     initialBlockHash,
     l2TipsCache,
     dateProvider,
+    configOverrides,
   );
 }