@aztec/archiver 0.0.1-commit.b1c78909e → 0.0.1-commit.b2a5d0dd1

package/src/store/contract_class_store.ts

@@ -2,14 +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 { FunctionSelector } from '@aztec/stdlib/abi';
-import type {
-  ContractClassPublic,
-  ContractClassPublicWithBlockNumber,
-  ExecutablePrivateFunctionWithMembershipProof,
-  UtilityFunctionWithMembershipProof,
-} from '@aztec/stdlib/contract';
-import { Vector } from '@aztec/stdlib/types';
+import type { ContractClassPublic, ContractClassPublicWithBlockNumber } from '@aztec/stdlib/contract';
 
 /**
  * LMDB-based contract class storage for the archiver.
@@ -29,11 +22,15 @@ export class ContractClassStore {
     blockNumber: number,
   ): Promise<void> {
     await this.db.transactionAsync(async () => {
-      await this.#contractClasses.setIfNotExists(
-        contractClass.id.toString(),
+      const key = contractClass.id.toString();
+      if (await this.#contractClasses.hasAsync(key)) {
+        throw new Error(`Contract class ${key} already exists, cannot add again at block ${blockNumber}`);
+      }
+      await this.#contractClasses.set(
+        key,
         serializeContractClassPublic({ ...contractClass, l2BlockNumber: blockNumber }),
       );
-      await this.#bytecodeCommitments.setIfNotExists(contractClass.id.toString(), bytecodeCommitment.toBuffer());
+      await this.#bytecodeCommitments.set(key, bytecodeCommitment.toBuffer());
     });
   }
 
@@ -60,37 +57,6 @@ export class ContractClassStore {
   async getContractClassIds(): Promise<Fr[]> {
     return (await toArray(this.#contractClasses.keysAsync())).map(key => Fr.fromHexString(key));
   }
-
-  async addFunctions(
-    contractClassId: Fr,
-    newPrivateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
-    newUtilityFunctions: UtilityFunctionWithMembershipProof[],
-  ): Promise<boolean> {
-    await this.db.transactionAsync(async () => {
-      const existingClassBuffer = await this.#contractClasses.getAsync(contractClassId.toString());
-      if (!existingClassBuffer) {
-        throw new Error(`Unknown contract class ${contractClassId} when adding private functions to store`);
-      }
-
-      const existingClass = deserializeContractClassPublic(existingClassBuffer);
-      const { privateFunctions: existingPrivateFns, utilityFunctions: existingUtilityFns } = existingClass;
-
-      const updatedClass: Omit<ContractClassPublicWithBlockNumber, 'id'> = {
-        ...existingClass,
-        privateFunctions: [
-          ...existingPrivateFns,
-          ...newPrivateFunctions.filter(newFn => !existingPrivateFns.some(f => f.selector.equals(newFn.selector))),
-        ],
-        utilityFunctions: [
-          ...existingUtilityFns,
-          ...newUtilityFunctions.filter(newFn => !existingUtilityFns.some(f => f.selector.equals(newFn.selector))),
-        ],
-      };
-      await this.#contractClasses.set(contractClassId.toString(), serializeContractClassPublic(updatedClass));
-    });
-
-    return true;
-  }
 }
 
 function serializeContractClassPublic(contractClass: Omit<ContractClassPublicWithBlockNumber, 'id'>): Buffer {
@@ -98,83 +64,19 @@ function serializeContractClassPublic(contractClass: Omit<ContractClassPublicWit
     contractClass.l2BlockNumber,
     numToUInt8(contractClass.version),
     contractClass.artifactHash,
-    contractClass.privateFunctions.length,
-    contractClass.privateFunctions.map(serializePrivateFunction),
-    contractClass.utilityFunctions.length,
-    contractClass.utilityFunctions.map(serializeUtilityFunction),
     contractClass.packedBytecode.length,
     contractClass.packedBytecode,
     contractClass.privateFunctionsRoot,
   );
 }
 
-function serializePrivateFunction(fn: ExecutablePrivateFunctionWithMembershipProof): Buffer {
-  return serializeToBuffer(
-    fn.selector,
-    fn.vkHash,
-    fn.bytecode.length,
-    fn.bytecode,
-    fn.functionMetadataHash,
-    fn.artifactMetadataHash,
-    fn.utilityFunctionsTreeRoot,
-    new Vector(fn.privateFunctionTreeSiblingPath),
-    fn.privateFunctionTreeLeafIndex,
-    new Vector(fn.artifactTreeSiblingPath),
-    fn.artifactTreeLeafIndex,
-  );
-}
-
-function serializeUtilityFunction(fn: UtilityFunctionWithMembershipProof): Buffer {
-  return serializeToBuffer(
-    fn.selector,
-    fn.bytecode.length,
-    fn.bytecode,
-    fn.functionMetadataHash,
-    fn.artifactMetadataHash,
-    fn.privateFunctionsArtifactTreeRoot,
-    new Vector(fn.artifactTreeSiblingPath),
-    fn.artifactTreeLeafIndex,
-  );
-}
-
 function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPublicWithBlockNumber, 'id'> {
   const reader = BufferReader.asReader(buffer);
   return {
     l2BlockNumber: reader.readNumber(),
     version: reader.readUInt8() as 1,
     artifactHash: reader.readObject(Fr),
-    privateFunctions: reader.readVector({ fromBuffer: deserializePrivateFunction }),
-    utilityFunctions: reader.readVector({ fromBuffer: deserializeUtilityFunction }),
     packedBytecode: reader.readBuffer(),
     privateFunctionsRoot: reader.readObject(Fr),
   };
 }
-
-function deserializePrivateFunction(buffer: Buffer | BufferReader): ExecutablePrivateFunctionWithMembershipProof {
-  const reader = BufferReader.asReader(buffer);
-  return {
-    selector: reader.readObject(FunctionSelector),
-    vkHash: reader.readObject(Fr),
-    bytecode: reader.readBuffer(),
-    functionMetadataHash: reader.readObject(Fr),
-    artifactMetadataHash: reader.readObject(Fr),
-    utilityFunctionsTreeRoot: reader.readObject(Fr),
-    privateFunctionTreeSiblingPath: reader.readVector(Fr),
-    privateFunctionTreeLeafIndex: reader.readNumber(),
-    artifactTreeSiblingPath: reader.readVector(Fr),
-    artifactTreeLeafIndex: reader.readNumber(),
-  };
-}
-
-function deserializeUtilityFunction(buffer: Buffer | BufferReader): UtilityFunctionWithMembershipProof {
-  const reader = BufferReader.asReader(buffer);
-  return {
-    selector: reader.readObject(FunctionSelector),
-    bytecode: reader.readBuffer(),
-    functionMetadataHash: reader.readObject(Fr),
-    artifactMetadataHash: reader.readObject(Fr),
-    privateFunctionsArtifactTreeRoot: reader.readObject(Fr),
-    artifactTreeSiblingPath: reader.readVector(Fr),
-    artifactTreeLeafIndex: reader.readNumber(),
-  };
-}

package/src/store/contract_instance_store.ts

@@ -27,11 +27,14 @@ export class ContractInstanceStore {
 
   addContractInstance(contractInstance: ContractInstanceWithAddress, blockNumber: number): Promise<void> {
     return this.db.transactionAsync(async () => {
-      await this.#contractInstances.set(
-        contractInstance.address.toString(),
-        new SerializableContractInstance(contractInstance).toBuffer(),
-      );
-      await this.#contractInstancePublishedAt.set(contractInstance.address.toString(), blockNumber);
+      const key = contractInstance.address.toString();
+      if (await this.#contractInstances.hasAsync(key)) {
+        throw new Error(
+          `Contract instance at ${key} already exists (deployed at block ${await this.#contractInstancePublishedAt.getAsync(key)}), cannot add again at block ${blockNumber}`,
+        );
+      }
+      await this.#contractInstances.set(key, new SerializableContractInstance(contractInstance).toBuffer());
+      await this.#contractInstancePublishedAt.set(key, blockNumber);
     });
   }
 

package/src/store/kv_archiver_store.ts

@@ -10,18 +10,26 @@ import {
   type BlockData,
   BlockHash,
   CheckpointedL2Block,
+  type CommitteeAttestation,
   L2Block,
   type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
-import type { CheckpointData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type {
+  CheckpointData,
+  CommonCheckpointData,
+  L1PublishedData,
+  ProposedCheckpointData,
+  ProposedCheckpointInput,
+  PublishedCheckpoint,
+} from '@aztec/stdlib/checkpoint';
 import type {
   ContractClassPublic,
+  ContractClassPublicWithCommitment,
   ContractDataSource,
   ContractInstanceUpdateWithAddress,
   ContractInstanceWithAddress,
-  ExecutablePrivateFunctionWithMembershipProof,
-  UtilityFunctionWithMembershipProof,
 } from '@aztec/stdlib/contract';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import type { LogFilter, SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
 import type { BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
@@ -36,7 +44,7 @@ import { ContractInstanceStore } from './contract_instance_store.js';
 import { LogStore } from './log_store.js';
 import { MessageStore } from './message_store.js';
 
-export const ARCHIVER_DB_VERSION = 5;
+export const ARCHIVER_DB_VERSION = 6;
 export const MAX_FUNCTION_SIGNATURES = 1000;
 export const MAX_FUNCTION_NAME_LEN = 256;
 
@@ -166,19 +174,14 @@ export class KVArchiverDataStore implements ContractDataSource {
 
   /**
    * Add new contract classes from an L2 block to the store's list.
-   * @param data - List of contract classes to be added.
-   * @param bytecodeCommitments - Bytecode commitments for the contract classes.
+   * @param data - List of contract classes (with bytecode commitments) to be added.
    * @param blockNumber - Number of the L2 block the contracts were registered in.
    * @returns True if the operation is successful.
    */
-  async addContractClasses(
-    data: ContractClassPublic[],
-    bytecodeCommitments: Fr[],
-    blockNumber: BlockNumber,
-  ): Promise<boolean> {
+  async addContractClasses(data: ContractClassPublicWithCommitment[], blockNumber: BlockNumber): Promise<boolean> {
     return (
       await Promise.all(
-        data.map((c, i) => this.#contractClassStore.addContractClass(c, bytecodeCommitments[i], blockNumber)),
+        data.map(c => this.#contractClassStore.addContractClass(c, c.publicBytecodeCommitment, blockNumber)),
       )
     ).every(Boolean);
   }
@@ -193,15 +196,6 @@ export class KVArchiverDataStore implements ContractDataSource {
     return this.#contractClassStore.getBytecodeCommitment(contractClassId);
   }
 
-  /** Adds private functions to a contract class. */
-  addFunctions(
-    contractClassId: Fr,
-    privateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
-    utilityFunctions: UtilityFunctionWithMembershipProof[],
-  ): Promise<boolean> {
-    return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, utilityFunctions);
-  }
-
   /**
    * Add new contract instances from an L2 block to the store's list.
    * @param data - List of contract instances to be added.
@@ -268,7 +262,7 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @returns The number of the latest block
    */
   getLatestBlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getLatestBlockNumber();
+    return this.#blockStore.getLatestL2BlockNumber();
   }
 
   /**
@@ -408,8 +402,11 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param txHash - The hash of a tx we try to get the receipt for.
    * @returns The requested tx receipt (or undefined if not found).
    */
-  getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
-    return this.#blockStore.getSettledTxReceipt(txHash);
+  getSettledTxReceipt(
+    txHash: TxHash,
+    l1Constants?: Pick<L1RollupConstants, 'epochDuration'>,
+  ): Promise<TxReceipt | undefined> {
+    return this.#blockStore.getSettledTxReceipt(txHash, l1Constants);
   }
 
   /**
@@ -470,10 +467,11 @@ export class KVArchiverDataStore implements ContractDataSource {
    * array implies no logs match that tag.
    * @param tags - The tags to search for.
    * @param page - The page number (0-indexed) for pagination. Returns at most 10 logs per tag per page.
+   * @param upToBlockNumber - If set, only return logs from blocks up to and including this block number.
    */
-  getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]> {
+  getPrivateLogsByTags(tags: SiloedTag[], page?: number, upToBlockNumber?: BlockNumber): Promise<TxScopedL2Log[][]> {
     try {
-      return this.#logStore.getPrivateLogsByTags(tags, page);
+      return this.#logStore.getPrivateLogsByTags(tags, page, upToBlockNumber);
     } catch (err) {
       return Promise.reject(err);
     }
@@ -485,14 +483,16 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param contractAddress - The contract address to search logs for.
    * @param tags - The tags to search for.
    * @param page - The page number (0-indexed) for pagination. Returns at most 10 logs per tag per page.
+   * @param upToBlockNumber - If set, only return logs from blocks up to and including this block number.
    */
   getPublicLogsByTagsFromContract(
     contractAddress: AztecAddress,
     tags: Tag[],
     page?: number,
+    upToBlockNumber?: BlockNumber,
   ): Promise<TxScopedL2Log[][]> {
     try {
-      return this.#logStore.getPublicLogsByTagsFromContract(contractAddress, tags, page);
+      return this.#logStore.getPublicLogsByTagsFromContract(contractAddress, tags, page, upToBlockNumber);
     } catch (err) {
       return Promise.reject(err);
     }
@@ -560,13 +560,6 @@ export class KVArchiverDataStore implements ContractDataSource {
     await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
   }
 
-  /**
-   * Stores the l1 block that messages have been synched until
-   */
-  async setMessageSynchedL1Block(l1Block: L1BlockId) {
-    await this.#messageStore.setSynchedL1Block(l1Block);
-  }
-
   /**
    * Returns the number of the most recent proven block
    * @returns The number of the most recent proven block
@@ -599,6 +592,11 @@ export class KVArchiverDataStore implements ContractDataSource {
     return this.#messageStore.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
   }
 
+  /** Atomically updates the message sync state: the L1 sync point and the inbox tree-in-progress marker. */
+  public setMessageSyncState(l1Block: L1BlockId, treeInProgress: bigint | undefined): Promise<void> {
+    return this.#messageStore.setMessageSyncState(l1Block, treeInProgress);
+  }
+
   /** Returns an async iterator to all L1 to L2 messages on the range. */
   public iterateL1ToL2Messages(range: CustomRange<bigint> = {}): AsyncIterableIterator<InboxMessage> {
     return this.#messageStore.iterateL1ToL2Messages(range);
@@ -619,6 +617,51 @@ export class KVArchiverDataStore implements ContractDataSource {
     return this.#blockStore.setPendingChainValidationStatus(status);
   }
 
+  /**
+   * Gets the L2 block number of the proposed checkpoint.
+   * @returns The block number of the proposed checkpoint, or the checkpointed block number if none.
+   */
+  public getProposedCheckpointL2BlockNumber(): Promise<BlockNumber> {
+    return this.#blockStore.getProposedCheckpointL2BlockNumber();
+  }
+
+  /** Returns the checkpoint data at the proposed tip */
+  public getProposedCheckpoint(): Promise<CommonCheckpointData | undefined> {
+    return this.#blockStore.getProposedCheckpoint();
+  }
+
+  /** Returns the proposed checkpoint data, or undefined if no proposed checkpoint exists. No fallback to confirmed. */
+  public getProposedCheckpointOnly(): Promise<ProposedCheckpointData | undefined> {
+    return this.#blockStore.getProposedCheckpointOnly();
+  }
+
+  /**
+   * Set proposed checkpoint
+   * @param proposedCheckpoint
+   * @returns
+   */
+  public setProposedCheckpoint(proposedCheckpoint: ProposedCheckpointInput): Promise<void> {
+    return this.#blockStore.setProposedCheckpoint(proposedCheckpoint);
+  }
+
+  /** Deletes the proposed checkpoint from storage. */
+  public deleteProposedCheckpoint(): Promise<void> {
+    return this.#blockStore.deleteProposedCheckpoint();
+  }
+
+  /**
+   * Promotes the proposed checkpoint to a confirmed checkpoint entry.
+   * Should only be called after the checkpoint has been validated.
+   * @param expectedArchiveRoot - The archive root to match against the proposed checkpoint, to guard against races.
+   */
+  public promoteProposedToCheckpointed(
+    l1: L1PublishedData,
+    attestations: CommitteeAttestation[],
+    expectedArchiveRoot: Fr,
+  ): Promise<void> {
+    return this.#blockStore.promoteProposedToCheckpointed(l1, attestations, expectedArchiveRoot);
+  }
+
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.

package/src/store/l2_tips_cache.ts

@@ -1,6 +1,12 @@
-import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
-import { type BlockData, type CheckpointId, GENESIS_CHECKPOINT_HEADER_HASH, type L2Tips } from '@aztec/stdlib/block';
+import {
+  type BlockData,
+  type CheckpointId,
+  GENESIS_BLOCK_HEADER_HASH,
+  GENESIS_CHECKPOINT_HEADER_HASH,
+  type L2Tips,
+} from '@aztec/stdlib/block';
 
 import type { BlockStore } from './block_store.js';
 
@@ -26,9 +32,16 @@ export class L2TipsCache {
   }
 
   private async loadFromStore(): Promise<L2Tips> {
-    const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber] = await Promise.all([
-      this.blockStore.getLatestBlockNumber(),
+    const [
+      latestBlockNumber,
+      provenBlockNumber,
+      proposedCheckpointBlockNumber,
+      checkpointedBlockNumber,
+      finalizedBlockNumber,
+    ] = await Promise.all([
+      this.blockStore.getLatestL2BlockNumber(),
       this.blockStore.getProvenBlockNumber(),
+      this.blockStore.getProposedCheckpointL2BlockNumber(),
       this.blockStore.getCheckpointedL2BlockNumber(),
       this.blockStore.getFinalizedL2BlockNumber(),
     ]);
@@ -42,19 +55,34 @@ export class L2TipsCache {
     const getBlockData = (blockNumber: BlockNumber) =>
       blockNumber > beforeInitialBlockNumber ? this.blockStore.getBlockData(blockNumber) : genesisBlockHeader;
 
-    const [latestBlockData, provenBlockData, checkpointedBlockData, finalizedBlockData] = await Promise.all(
-      [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber].map(getBlockData),
-    );
+    const [latestBlockData, provenBlockData, proposedCheckpointBlockData, checkpointedBlockData, finalizedBlockData] =
+      await Promise.all(
+        [
+          latestBlockNumber,
+          provenBlockNumber,
+          proposedCheckpointBlockNumber,
+          checkpointedBlockNumber,
+          finalizedBlockNumber,
+        ].map(getBlockData),
+      );
 
-    if (!latestBlockData || !provenBlockData || !finalizedBlockData || !checkpointedBlockData) {
+    if (
+      !latestBlockData ||
+      !provenBlockData ||
+      !finalizedBlockData ||
+      !checkpointedBlockData ||
+      !proposedCheckpointBlockData
+    ) {
       throw new Error('Failed to load block data for L2 tips');
     }
 
-    const [provenCheckpointId, finalizedCheckpointId, checkpointedCheckpointId] = await Promise.all([
-      this.getCheckpointIdForBlock(provenBlockData),
-      this.getCheckpointIdForBlock(finalizedBlockData),
-      this.getCheckpointIdForBlock(checkpointedBlockData),
-    ]);
+    const [provenCheckpointId, finalizedCheckpointId, proposedCheckpointId, checkpointedCheckpointId] =
+      await Promise.all([
+        this.getCheckpointIdForBlock(provenBlockData),
+        this.getCheckpointIdForBlock(finalizedBlockData),
+        this.getCheckpointIdForProposedCheckpoint(checkpointedBlockData),
+        this.getCheckpointIdForBlock(checkpointedBlockData),
+      ]);
 
     return {
       proposed: { number: latestBlockNumber, hash: latestBlockData.blockHash.toString() },
@@ -62,6 +90,10 @@ export class L2TipsCache {
         block: { number: provenBlockNumber, hash: provenBlockData.blockHash.toString() },
         checkpoint: provenCheckpointId,
       },
+      proposedCheckpoint: {
+        block: { number: proposedCheckpointBlockNumber, hash: proposedCheckpointBlockData.blockHash.toString() },
+        checkpoint: proposedCheckpointId,
+      },
       finalized: {
         block: { number: finalizedBlockNumber, hash: finalizedBlockData.blockHash.toString() },
         checkpoint: finalizedCheckpointId,
@@ -73,6 +105,19 @@ export class L2TipsCache {
     };
   }
 
+  private async getCheckpointIdForProposedCheckpoint(
+    checkpointedBlockData: Pick<BlockData, 'checkpointNumber'>,
+  ): Promise<CheckpointId> {
+    const checkpointData = await this.blockStore.getProposedCheckpointOnly();
+    if (!checkpointData) {
+      return this.getCheckpointIdForBlock(checkpointedBlockData);
+    }
+    return {
+      number: checkpointData.checkpointNumber,
+      hash: checkpointData.header.hash().toString(),
+    };
+  }
+
   private async getCheckpointIdForBlock(blockData: Pick<BlockData, 'checkpointNumber'>): Promise<CheckpointId> {
     const checkpointData = await this.blockStore.getCheckpointData(blockData.checkpointNumber);
     if (!checkpointData) {