@aztec/archiver 0.0.1-commit.2b2662070 → 0.0.1-commit.2c0ee1788

package/src/store/data_stores.ts

@@ -0,0 +1,108 @@
+import type { L1BlockId } from '@aztec/ethereum/l1-types';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+
+import { join } from 'path';
+
+import { ArchiverContractDataSourceAdapter } from '../modules/contract_data_source_adapter.js';
+import { BlockStore } from './block_store.js';
+import { ContractClassStore } from './contract_class_store.js';
+import { ContractInstanceStore } from './contract_instance_store.js';
+import { FunctionNamesCache } from './function_names_cache.js';
+import { LogStore } from './log_store.js';
+import { MessageStore } from './message_store.js';
+
+export const ARCHIVER_DB_VERSION = 6;
+
+/**
+ * Represents the latest L1 block processed by the archiver for various objects in L2.
+ */
+export type ArchiverL1SynchPoint = {
+  /** Number of the last L1 block that added a new L2 checkpoint metadata.  */
+  blocksSynchedTo?: bigint;
+  /** Last L1 block checked for L1 to L2 messages. */
+  messagesSynchedTo?: L1BlockId;
+};
+
+/**
+ * Bundle of archiver-owned LMDB substores plus the in-memory caches that span them.
+ *
+ * Replaces the former `KVArchiverDataStore` pass-through wrapper. Callers reach into
+ * the relevant substore directly (e.g. `stores.blocks.getBlock`) and use
+ * {@link createArchiverDataStores} to wire them up against a shared KV store.
+ */
+export type ArchiverDataStores = {
+  /** The underlying key-value store. Use {@link AztecAsyncKVStore.transactionAsync} to compose updates atomically. */
+  db: AztecAsyncKVStore;
+  /** Blocks, checkpoints, tx effects, proven/finalized state. */
+  blocks: BlockStore;
+  /** Public, private and contract class logs. */
+  logs: LogStore;
+  /** L1 to L2 messages and message sync state. */
+  messages: MessageStore;
+  /** Contract classes (with bytecode commitments). */
+  contractClasses: ContractClassStore;
+  /** Contract instances and contract instance updates. */
+  contractInstances: ContractInstanceStore;
+  /** In-memory cache of public function selectors -> names. */
+  functionNames: FunctionNamesCache;
+};
+
+/** Options used by {@link createArchiverDataStores}. */
+export type CreateArchiverDataStoresOptions = {
+  /** Maximum number of logs returned per page when paginating tagged log queries. */
+  logsMaxPageSize?: number;
+};
+
+/**
+ * Wires up the archiver substores against a shared KV store and returns the
+ * {@link ArchiverDataStores} bundle.
+ */
+export function createArchiverDataStores(
+  db: AztecAsyncKVStore,
+  opts: CreateArchiverDataStoresOptions = {},
+): ArchiverDataStores {
+  const blocks = new BlockStore(db);
+  return {
+    db,
+    blocks,
+    logs: new LogStore(db, blocks, opts.logsMaxPageSize ?? 1000),
+    messages: new MessageStore(db),
+    contractClasses: new ContractClassStore(db),
+    contractInstances: new ContractInstanceStore(db),
+    functionNames: new FunctionNamesCache(),
+  };
+}
+
+/**
+ * Returns the L1 sync point of the archiver, combining the block sync point from {@link BlockStore}
+ * and the message sync point from {@link MessageStore}.
+ */
+export async function getArchiverSynchPoint(stores: ArchiverDataStores): Promise<ArchiverL1SynchPoint> {
+  const [blocksSynchedTo, messagesSynchedTo] = await Promise.all([
+    stores.blocks.getSynchedL1BlockNumber(),
+    stores.messages.getSynchedL1Block(),
+  ]);
+  return { blocksSynchedTo, messagesSynchedTo };
+}
+
+/**
+ * Backs up the underlying KV store to the given folder. Returns the path to the resulting db file.
+ */
+export async function backupArchiverDataStores(
+  stores: ArchiverDataStores,
+  path: string,
+  compress = true,
+): Promise<string> {
+  await stores.db.backupTo(path, compress);
+  return join(path, 'data.mdb');
+}
+
+/**
+ * Returns a {@link ContractDataSource} adapter over {@link ArchiverDataStores}.
+ * Used by contexts (e.g. offline epoch re-prover tools) that need a ContractDataSource
+ * but do not need a full archiver instance.
+ */
+export function createContractDataSource(stores: ArchiverDataStores): ContractDataSource {
+  return new ArchiverContractDataSourceAdapter(stores);
+}

package/src/store/function_names_cache.ts

@@ -0,0 +1,37 @@
+import { createLogger } from '@aztec/foundation/log';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+
+const MAX_FUNCTION_SIGNATURES = 1000;
+const MAX_FUNCTION_NAME_LEN = 256;
+
+/**
+ * In-memory cache mapping public function selectors to function names.
+ *
+ * Populated opportunistically (e.g. by PXE registering signatures from artifacts) so the
+ * archiver can attach human-readable names to logs and traces. Bounded by
+ * {@link MAX_FUNCTION_SIGNATURES} to avoid unbounded growth from untrusted callers.
+ */
+export class FunctionNamesCache {
+  private readonly log = createLogger('archiver:data-stores');
+  private readonly names: Map<string, string> = new Map();
+
+  /** Adds the given public function signatures to the cache. */
+  public async register(signatures: string[]): Promise<void> {
+    for (const sig of signatures) {
+      if (this.names.size > MAX_FUNCTION_SIGNATURES) {
+        return;
+      }
+      try {
+        const selector = await FunctionSelector.fromSignature(sig);
+        this.names.set(selector.toString(), sig.slice(0, sig.indexOf('(')).slice(0, MAX_FUNCTION_NAME_LEN));
+      } catch {
+        this.log.warn(`Failed to parse signature: ${sig}. Ignoring`);
+      }
+    }
+  }
+
+  /** Looks up a function name for the given selector, or returns undefined if not registered. */
+  public get(selector: FunctionSelector): string | undefined {
+    return this.names.get(selector.toString());
+  }
+}

package/src/store/l2_tips_cache.ts

@@ -108,7 +108,7 @@ export class L2TipsCache {
   private async getCheckpointIdForProposedCheckpoint(
     checkpointedBlockData: Pick<BlockData, 'checkpointNumber'>,
   ): Promise<CheckpointId> {
-    const checkpointData = await this.blockStore.getProposedCheckpointOnly();
+    const checkpointData = await this.blockStore.getLastProposedCheckpoint();
     if (!checkpointData) {
       return this.getCheckpointIdForBlock(checkpointedBlockData);
     }

package/src/test/fake_l1_state.ts

@@ -15,12 +15,8 @@ import { CommitteeAttestation, CommitteeAttestationsAndSigners, L2Block } from '
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
-import { ConsensusPayload, SignatureDomainSeparator } from '@aztec/stdlib/p2p';
-import {
-  makeAndSignCommitteeAttestationsAndSigners,
-  makeCheckpointAttestationFromCheckpoint,
-  mockCheckpointAndMessages,
-} from '@aztec/stdlib/testing';
+import { ConsensusPayload, getHashedSignaturePayloadTypedData } from '@aztec/stdlib/p2p';
+import { mockCheckpointAndMessages } from '@aztec/stdlib/testing';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 
 import { type MockProxy, mock } from 'jest-mock-extended';
@@ -151,8 +147,10 @@ export class FakeL1State {
   // Computed from checkpoints based on L1 block visibility
   private pendingCheckpointNumber: CheckpointNumber = CheckpointNumber(0);
 
-  // The L1 block number reported as "finalized" (defaults to the start block)
-  private finalizedL1BlockNumber: bigint;
+  // The L1 block number reported as "finalized" (defaults to the start block).
+  // `undefined` simulates the startup window on a fresh devnet where
+  // `getBlock({ blockTag: 'finalized' })` fails with "finalized block not found".
+  private finalizedL1BlockNumber: bigint | undefined;
 
   constructor(private readonly config: FakeL1StateConfig) {
     this.l1BlockNumber = config.l1StartBlock;
@@ -288,8 +286,11 @@ export class FakeL1State {
     this.updatePendingCheckpointNumber();
   }
 
-  /** Sets the L1 block number that will be reported as "finalized". */
-  setFinalizedL1BlockNumber(blockNumber: bigint): void {
+  /**
+   * Sets the L1 block number that will be reported as "finalized". Pass `undefined` to
+   * simulate a chain that does not yet have a finalized block (devnet startup).
+   */
+  setFinalizedL1BlockNumber(blockNumber: bigint | undefined): void {
     this.finalizedL1BlockNumber = blockNumber;
   }
 
@@ -502,8 +503,8 @@ export class FakeL1State {
       Promise.resolve(this.getMessageSentLogs(fromBlock, toBlock)),
     );
 
-    mockInbox.getMessageSentEventByHash.mockImplementation((msgHash: string, l1BlockHash: string) =>
-      Promise.resolve(this.getMessageSentLogByHash(msgHash, l1BlockHash) as MessageSentLog),
+    mockInbox.getMessageSentEventByHash.mockImplementation((msgHash: string, aroundL1BlockNumber: bigint) =>
+      Promise.resolve(this.getMessageSentLogByHash(msgHash, aroundL1BlockNumber) as MessageSentLog),
     );
 
     return mockInbox;
@@ -514,11 +515,19 @@ export class FakeL1State {
     const publicClient = mock<ViemPublicClient>();
 
     publicClient.getChainId.mockResolvedValue(1);
+    // Several consumers (CalldataRetriever, ArchiverL1Synchronizer) derive the EIP-712 signing
+    // context from `publicClient.chain.id`. Pin it so it matches `getSignatureContext()` below.
+    (publicClient as unknown as { chain: { id: number } }).chain = { id: 1 };
     publicClient.getBlockNumber.mockImplementation(() => Promise.resolve(this.l1BlockNumber));
 
     publicClient.getBlock.mockImplementation((async (args: { blockNumber?: bigint; blockTag?: string } = {}) => {
       let blockNum: bigint;
       if (args.blockTag === 'finalized') {
+        if (this.finalizedL1BlockNumber === undefined) {
+          throw Object.assign(new Error('finalized block not found'), {
+            details: 'finalized block not found',
+          });
+        }
         blockNum = this.finalizedL1BlockNumber;
       } else {
         blockNum = args.blockNumber ?? (await publicClient.getBlockNumber());
@@ -544,10 +553,10 @@ export class FakeL1State {
   createMockBlobClient(): MockProxy<BlobClientInterface> {
     const blobClient = mock<BlobClientInterface>();
 
-    // The blockId is the transaction's blockHash, which we set to the checkpoint's archive root
+    // The blockId is the L1 block hash, which we derive from the L1 block number
     blobClient.getBlobSidecar.mockImplementation((blockId: `0x${string}`) =>
       Promise.resolve(
-        this.checkpoints.find(cpData => cpData.checkpoint.archive.root.toString() === blockId)?.blobs ?? [],
+        this.checkpoints.find(cpData => Buffer32.fromBigInt(cpData.l1BlockNumber).toString() === blockId)?.blobs ?? [],
       ),
     );
 
@@ -623,9 +632,12 @@ export class FakeL1State {
       }));
   }
 
-  private getMessageSentLogByHash(msgHash: string, l1BlockHash: string): MessageSentLog | undefined {
+  private getMessageSentLogByHash(msgHash: string, aroundL1BlockNumber: bigint): MessageSentLog | undefined {
     const msg = this.messages.find(
-      msg => msg.leaf.toString() === msgHash && Buffer32.fromBigInt(msg.l1BlockNumber).toString() === l1BlockHash,
+      msg =>
+        msg.leaf.toString() === msgHash &&
+        msg.l1BlockNumber >= aroundL1BlockNumber - 5n &&
+        msg.l1BlockNumber <= aroundL1BlockNumber + 5n,
     );
     if (!msg) {
       return undefined;
@@ -647,9 +659,11 @@ export class FakeL1State {
     checkpoint: Checkpoint,
     signers: Secp256k1Signer[],
   ): Promise<{ tx: Transaction; attestationsHash: Buffer32; payloadDigest: Buffer32 }> {
+    const signatureContext = this.getSignatureContext();
+    const consensusPayload = ConsensusPayload.fromCheckpoint(checkpoint, signatureContext);
+    const attestationDigest = getHashedSignaturePayloadTypedData(consensusPayload);
     const attestations = signers
-      .map(signer => makeCheckpointAttestationFromCheckpoint(checkpoint, signer))
-      .map(attestation => CommitteeAttestation.fromSignature(attestation.signature))
+      .map(signer => CommitteeAttestation.fromSignature(signer.sign(attestationDigest)))
       .map(committeeAttestation => committeeAttestation.toViem());
 
     const header = checkpoint.header.toViem();
@@ -657,11 +671,15 @@ export class FakeL1State {
     const archive = toHex(checkpoint.archive.root.toBuffer());
     const attestationsAndSigners = new CommitteeAttestationsAndSigners(
       attestations.map(attestation => CommitteeAttestation.fromViem(attestation)),
+      signatureContext,
     );
 
-    const attestationsAndSignersSignature = makeAndSignCommitteeAttestationsAndSigners(
-      attestationsAndSigners,
-      signers[0],
+    // Fall back to a random signer when no attesters are provided, so tests that
+    // don't care about the proposer identity (e.g. sync tests) still produce a
+    // valid-looking signature for the attestationsAndSigners struct.
+    const proposerSigner = signers[0] ?? Secp256k1Signer.random();
+    const attestationsAndSignersSignature = proposerSigner.sign(
+      getHashedSignaturePayloadTypedData(attestationsAndSigners),
     );
 
     const packedAttestations = attestationsAndSigners.getPackedAttestations();
@@ -702,9 +720,7 @@ export class FakeL1State {
     );
 
     // Compute payloadDigest (same logic as CalldataRetriever)
-    const consensusPayload = ConsensusPayload.fromCheckpoint(checkpoint);
-    const payloadToSign = consensusPayload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation);
-    const payloadDigest = Buffer32.fromString(keccak256(payloadToSign));
+    const payloadDigest = getHashedSignaturePayloadTypedData(consensusPayload);
 
     const tx = {
       input: multiCallInput,
@@ -716,6 +732,13 @@ export class FakeL1State {
     return { tx, attestationsHash, payloadDigest };
   }
 
+  private getSignatureContext() {
+    return {
+      chainId: 1,
+      rollupAddress: this.config.rollupAddress,
+    };
+  }
+
   /** Extracts the CommitteeAttestations struct definition from RollupAbi for hash computation. */
   private getCommitteeAttestationsStructDef(): AbiParameter {
     const proposeFunction = RollupAbi.find(item => item.type === 'function' && item.name === 'propose') as

package/src/test/mock_l2_block_source.ts

@@ -321,6 +321,26 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     };
   }
 
+  public getCheckpointData(_n: CheckpointNumber): Promise<CheckpointData | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  public getCheckpointDataRange(_from: CheckpointNumber, _limit: number): Promise<CheckpointData[]> {
+    return Promise.resolve([]);
+  }
+
+  public getCheckpointNumberBySlot(_slot: SlotNumber): Promise<CheckpointNumber | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  public async getBlockDataWithCheckpointContext(number: BlockNumber) {
+    const data = await this.getBlockData(number);
+    if (!data) {
+      return undefined;
+    }
+    return { data, checkpoint: undefined, l1: undefined, attestations: [] };
+  }
+
   public async getBlockDataByArchive(archive: Fr): Promise<BlockData | undefined> {
     const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
     if (!block) {
@@ -356,6 +376,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
           ),
           startBlock: checkpoint.blocks[0].number,
           blockCount: checkpoint.blocks.length,
+          feeAssetPriceModifier: checkpoint.feeAssetPriceModifier,
           attestations: [],
           l1: this.mockL1DataForCheckpoint(checkpoint),
         }),
@@ -558,11 +579,11 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve({ valid: true });
   }
 
-  getProposedCheckpoint(): Promise<ProposedCheckpointData | undefined> {
+  getLastCheckpoint(): Promise<ProposedCheckpointData | undefined> {
     return Promise.resolve(undefined);
   }
 
-  getProposedCheckpointOnly(): Promise<ProposedCheckpointData | undefined> {
+  getLastProposedCheckpoint(): Promise<ProposedCheckpointData | undefined> {
     return Promise.resolve(undefined);
   }
 

package/src/test/noop_l1_archiver.ts

@@ -16,7 +16,7 @@ import { EventEmitter } from 'node:events';
 import { Archiver } from '../archiver.js';
 import { ArchiverInstrumentation } from '../modules/instrumentation.js';
 import type { ArchiverL1Synchronizer } from '../modules/l1_synchronizer.js';
-import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
+import type { ArchiverDataStores } from '../store/data_stores.js';
 
 /** Noop L1 synchronizer for testing without L1 connectivity. */
 class NoopL1Synchronizer implements FunctionsOf<ArchiverL1Synchronizer> {
@@ -48,7 +48,7 @@ class NoopL1Synchronizer implements FunctionsOf<ArchiverL1Synchronizer> {
  */
 export class NoopL1Archiver extends Archiver {
   constructor(
-    dataStore: KVArchiverDataStore,
+    dataStores: ArchiverDataStores,
     l1Constants: L1RollupConstants & { genesisArchiveRoot: Fr },
     instrumentation: ArchiverInstrumentation,
   ) {
@@ -70,17 +70,20 @@ export class NoopL1Archiver extends Archiver {
       debugClient,
       rollup,
       {
+        rollupAddress: EthAddress.ZERO,
         registryAddress: EthAddress.ZERO,
+        inboxAddress: EthAddress.ZERO,
         governanceProposerAddress: EthAddress.ZERO,
         slashingProposerAddress: EthAddress.ZERO,
       },
-      dataStore,
+      dataStores,
       {
         pollingIntervalMs: 1000,
         batchSize: 100,
         skipValidateCheckpointAttestations: true,
         maxAllowedEthClientDriftSeconds: 300,
         ethereumAllowNoDebugHosts: true, // Skip trace validation
+        skipHistoricalLogsCheck: true, // Skip historical logs validation
       },
       blobClient,
       instrumentation,
@@ -105,10 +108,10 @@ export class NoopL1Archiver extends Archiver {
 
 /** Creates an archiver with mocked L1 connectivity for testing. */
 export async function createNoopL1Archiver(
-  dataStore: KVArchiverDataStore,
+  dataStores: ArchiverDataStores,
   l1Constants: L1RollupConstants & { genesisArchiveRoot: Fr },
   telemetry: TelemetryClient = getTelemetryClient(),
 ): Promise<NoopL1Archiver> {
-  const instrumentation = await ArchiverInstrumentation.new(telemetry, () => dataStore.estimateSize());
-  return new NoopL1Archiver(dataStore, l1Constants, instrumentation);
+  const instrumentation = await ArchiverInstrumentation.new(telemetry, () => dataStores.db.estimateSize());
+  return new NoopL1Archiver(dataStores, l1Constants, instrumentation);
 }