@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.24de95ac

package/src/archiver/config.ts

@@ -1,62 +1,31 @@
 import { type BlobSinkConfig, blobSinkConfigMapping } from '@aztec/blob-sink/client';
 import {
-  type L1ContractAddresses,
   type L1ContractsConfig,
   type L1ReaderConfig,
+  l1ContractAddressesMapping,
   l1ContractsConfigMappings,
   l1ReaderConfigMappings,
 } from '@aztec/ethereum';
-import { type ConfigMappingsType, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
 import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import type { ArchiverSpecificConfig } from '@aztec/stdlib/interfaces/server';
 
 /**
+ * The archiver configuration.
  * There are 2 polling intervals used in this configuration. The first is the archiver polling interval, archiverPollingIntervalMS.
  * This is the interval between successive calls to eth_blockNumber via viem.
  * Results of calls to eth_blockNumber are cached by viem with this cache being updated periodically at the interval specified by viemPollingIntervalMS.
  * As a result the maximum observed polling time for new blocks will be viemPollingIntervalMS + archiverPollingIntervalMS.
  */
-
-/**
- * The archiver configuration.
- */
-export type ArchiverConfig = {
-  /** URL for an archiver service. If set, will return an archiver client as opposed to starting a new one. */
-  archiverUrl?: string;
-
-  /** URL for an L1 consensus client */
-  l1ConsensusHostUrl?: string;
-
-  /** The polling interval in ms for retrieving new L2 blocks and encrypted logs. */
-  archiverPollingIntervalMS?: number;
-
-  /** The number of L2 blocks the archiver will attempt to download at a time. */
-  archiverBatchSize?: number;
-
-  /** The polling interval viem uses in ms */
-  viemPollingIntervalMS?: number;
-
-  /** The deployed L1 contract addresses */
-  l1Contracts: L1ContractAddresses;
-
-  /** The max number of logs that can be obtained in 1 "getPublicLogs" call. */
-  maxLogs?: number;
-} & L1ReaderConfig &
-  L1ContractsConfig &
-  BlobSinkConfig &
-  ChainConfig;
+export type ArchiverConfig = ArchiverSpecificConfig & L1ReaderConfig & L1ContractsConfig & BlobSinkConfig & ChainConfig;
 
 export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
   ...blobSinkConfigMapping,
-  archiverUrl: {
-    env: 'ARCHIVER_URL',
-    description:
-      'URL for an archiver service. If set, will return an archiver client as opposed to starting a new one.',
-  },
-  l1ConsensusHostUrl: {
-    env: 'L1_CONSENSUS_HOST_URL',
-    description: 'URL for an L1 consensus client.',
-    parseEnv: (val: string) => val,
-  },
   archiverPollingIntervalMS: {
     env: 'ARCHIVER_POLLING_INTERVAL_MS',
     description: 'The polling interval in ms for retrieving new L2 blocks and encrypted logs.',
@@ -72,6 +41,15 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'The max number of logs that can be obtained in 1 "getPublicLogs" call.',
     ...numberConfigHelper(1_000),
   },
+  archiverStoreMapSizeKb: {
+    env: 'ARCHIVER_STORE_MAP_SIZE_KB',
+    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    description: 'The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb.',
+  },
+  skipValidateBlockAttestations: {
+    description: 'Whether to skip validating block attestations (use only for testing).',
+    ...booleanConfigHelper(false),
+  },
   ...chainConfigMappings,
   ...l1ReaderConfigMappings,
   viemPollingIntervalMS: {
@@ -80,6 +58,10 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     ...numberConfigHelper(1000),
   },
   ...l1ContractsConfigMappings,
+  l1Contracts: {
+    description: 'The deployed L1 contract addresses',
+    nested: l1ContractAddressesMapping,
+  },
 };
 
 /**

package/src/archiver/data_retrieval.ts

@@ -1,18 +1,25 @@
-import { Blob, BlobDeserializationError } from '@aztec/blob-lib';
+import { BlobDeserializationError, SpongeBlob, getBlobFieldsInCheckpoint } from '@aztec/blob-lib';
 import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import type { EpochProofPublicInputArgs, ViemPublicClient } from '@aztec/ethereum';
+import type {
+  EpochProofPublicInputArgs,
+  ViemClient,
+  ViemCommitteeAttestations,
+  ViemHeader,
+  ViemPublicClient,
+  ViemStateReference,
+} from '@aztec/ethereum';
 import { asyncPool } from '@aztec/foundation/async-pool';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { numToUInt32BE } from '@aztec/foundation/serialize';
-import { ForwarderAbi, type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { Body, L2Block } from '@aztec/stdlib/block';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
+import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { Body, CommitteeAttestation, L2Block, L2BlockHeader, PublishedL2Block } from '@aztec/stdlib/block';
 import { Proof } from '@aztec/stdlib/proofs';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { BlockHeader } from '@aztec/stdlib/tx';
+import { GlobalVariables, StateReference } from '@aztec/stdlib/tx';
 
 import {
   type GetContractEventsReturnType,
@@ -21,11 +28,80 @@ import {
   decodeFunctionData,
   getAbiItem,
   hexToBytes,
+  multicall3Abi,
 } from 'viem';
 
 import { NoBlobBodiesFoundError } from './errors.js';
 import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { L1Published, L1PublishedData } from './structs/published.js';
+import type { InboxMessage } from './structs/inbox_message.js';
+import type { L1PublishedData } from './structs/published.js';
+
+export type RetrievedL2Block = {
+  l2BlockNumber: number;
+  archiveRoot: Fr;
+  stateReference: StateReference;
+  header: CheckpointHeader;
+  blobFields: Fr[];
+  l1: L1PublishedData;
+  chainId: Fr;
+  version: Fr;
+  attestations: CommitteeAttestation[];
+};
+
+export async function retrievedBlockToPublishedL2Block(retrievedBlock: RetrievedL2Block): Promise<PublishedL2Block> {
+  const {
+    l2BlockNumber,
+    archiveRoot,
+    stateReference,
+    header: checkpointHeader,
+    blobFields,
+    l1,
+    chainId,
+    version,
+    attestations,
+  } = retrievedBlock;
+
+  const archive = new AppendOnlyTreeSnapshot(
+    archiveRoot,
+    l2BlockNumber + 1, // nextAvailableLeafIndex
+  );
+
+  const globalVariables = GlobalVariables.from({
+    chainId,
+    version,
+    blockNumber: l2BlockNumber,
+    slotNumber: checkpointHeader.slotNumber,
+    timestamp: checkpointHeader.timestamp,
+    coinbase: checkpointHeader.coinbase,
+    feeRecipient: checkpointHeader.feeRecipient,
+    gasFees: checkpointHeader.gasFees,
+  });
+
+  // TODO(#17027)
+  // This works when there's only one block in the checkpoint.
+  // If there's more than one block, we need to build the spongeBlob from the endSpongeBlob of the previous block.
+  const spongeBlob = await SpongeBlob.init(blobFields.length);
+  // Skip the first field which is the checkpoint prefix indicating the number of total blob fields in a checkpoint.
+  const blockBlobFields = blobFields.slice(1);
+  await spongeBlob.absorb(blockBlobFields);
+  const spongeBlobHash = await spongeBlob.squeeze();
+
+  const body = Body.fromBlobFields(blockBlobFields);
+
+  const header = L2BlockHeader.from({
+    lastArchive: new AppendOnlyTreeSnapshot(checkpointHeader.lastArchiveRoot, l2BlockNumber),
+    contentCommitment: checkpointHeader.contentCommitment,
+    state: stateReference,
+    globalVariables,
+    totalFees: body.txEffects.reduce((accum, txEffect) => accum.add(txEffect.transactionFee), Fr.ZERO),
+    totalManaUsed: checkpointHeader.totalManaUsed,
+    spongeBlobHash,
+  });
+
+  const block = new L2Block(archive, header, body);
+
+  return PublishedL2Block.fromFields({ block, l1, attestations });
+}
 
 /**
  * Fetches new L2 blocks.
@@ -43,8 +119,11 @@ export async function retrieveBlocksFromRollup(
   searchStartBlock: bigint,
   searchEndBlock: bigint,
   logger: Logger = createLogger('archiver'),
-): Promise<L1Published<L2Block>[]> {
-  const retrievedBlocks: L1Published<L2Block>[] = [];
+): Promise<RetrievedL2Block[]> {
+  const retrievedBlocks: RetrievedL2Block[] = [];
+
+  let rollupConstants: { chainId: Fr; version: Fr; targetCommitteeSize: number } | undefined;
+
   do {
     if (searchStartBlock > searchEndBlock) {
       break;
@@ -68,11 +147,25 @@ export async function retrieveBlocksFromRollup(
       `Got ${l2BlockProposedLogs.length} L2 block processed logs for L2 blocks ${l2BlockProposedLogs[0].args.blockNumber}-${lastLog.args.blockNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`,
     );
 
+    if (rollupConstants === undefined) {
+      const [chainId, version, targetCommitteeSize] = await Promise.all([
+        publicClient.getChainId(),
+        rollup.read.getVersion(),
+        rollup.read.getTargetCommitteeSize(),
+      ]);
+      rollupConstants = {
+        chainId: new Fr(chainId),
+        version: new Fr(version),
+        targetCommitteeSize: Number(targetCommitteeSize),
+      };
+    }
+
     const newBlocks = await processL2BlockProposedLogs(
       rollup,
       publicClient,
       blobSinkClient,
       l2BlockProposedLogs,
+      rollupConstants,
       logger,
     );
     retrievedBlocks.push(...newBlocks);
@@ -90,18 +183,19 @@ export async function retrieveBlocksFromRollup(
  * @param logs - L2BlockProposed logs.
  * @returns - An array blocks.
  */
-export async function processL2BlockProposedLogs(
+async function processL2BlockProposedLogs(
   rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
   publicClient: ViemPublicClient,
   blobSinkClient: BlobSinkClientInterface,
   logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>,
+  { chainId, version, targetCommitteeSize }: { chainId: Fr; version: Fr; targetCommitteeSize: number },
   logger: Logger,
-): Promise<L1Published<L2Block>[]> {
-  const retrievedBlocks: L1Published<L2Block>[] = [];
+): Promise<RetrievedL2Block[]> {
+  const retrievedBlocks: RetrievedL2Block[] = [];
   await asyncPool(10, logs, async log => {
-    const l2BlockNumber = log.args.blockNumber!;
+    const l2BlockNumber = Number(log.args.blockNumber!);
     const archive = log.args.archive!;
-    const archiveFromChain = await rollup.read.archiveAt([l2BlockNumber]);
+    const archiveFromChain = await rollup.read.archiveAt([BigInt(l2BlockNumber)]);
     const blobHashes = log.args.versionedBlobHashes!.map(blobHash => Buffer.from(blobHash.slice(2), 'hex'));
 
     // The value from the event and contract will match only if the block is in the chain.
@@ -113,6 +207,7 @@ export async function processL2BlockProposedLogs(
         blobHashes,
         l2BlockNumber,
         rollup.address,
+        targetCommitteeSize,
         logger,
       );
 
@@ -122,7 +217,13 @@ export async function processL2BlockProposedLogs(
         timestamp: await getL1BlockTime(publicClient, log.blockNumber),
       };
 
-      retrievedBlocks.push({ data: block, l1 });
+      retrievedBlocks.push({ ...block, l1, chainId, version });
+      logger.trace(`Retrieved L2 block ${l2BlockNumber} from L1 tx ${log.transactionHash}`, {
+        l1BlockNumber: log.blockNumber,
+        l2BlockNumber,
+        archive: archive.toString(),
+        attestations: block.attestations,
+      });
     } else {
       logger.warn(`Ignoring L2 block ${l2BlockNumber} due to archive root mismatch`, {
         actual: archive,
@@ -140,37 +241,36 @@ export async function getL1BlockTime(publicClient: ViemPublicClient, blockNumber
 }
 
 /**
- * Extracts the first 'propose' method calldata from a forwarder transaction's data.
- * @param forwarderData - The forwarder transaction input data
+ * Extracts the first 'propose' method calldata from a multicall3 transaction's data.
+ * @param multicall3Data - The multicall3 transaction input data
  * @param rollupAddress - The address of the rollup contract
  * @returns The calldata for the first 'propose' method call to the rollup contract
  */
-function extractRollupProposeCalldata(forwarderData: Hex, rollupAddress: Hex): Hex {
-  // TODO(#11451): custom forwarders
-  const { functionName: forwarderFunctionName, args: forwarderArgs } = decodeFunctionData({
-    abi: ForwarderAbi,
-    data: forwarderData,
+function extractRollupProposeCalldata(multicall3Data: Hex, rollupAddress: Hex): Hex {
+  const { functionName: multicall3FunctionName, args: multicall3Args } = decodeFunctionData({
+    abi: multicall3Abi,
+    data: multicall3Data,
   });
 
-  if (forwarderFunctionName !== 'forward') {
-    throw new Error(`Unexpected forwarder method called ${forwarderFunctionName}`);
+  if (multicall3FunctionName !== 'aggregate3') {
+    throw new Error(`Unexpected multicall3 method called ${multicall3FunctionName}`);
   }
 
-  if (forwarderArgs.length !== 2) {
-    throw new Error(`Unexpected number of arguments for forwarder`);
+  if (multicall3Args.length !== 1) {
+    throw new Error(`Unexpected number of arguments for multicall3`);
   }
 
-  const [to, data] = forwarderArgs;
+  const [calls] = multicall3Args;
 
   // Find all rollup calls
   const rollupAddressLower = rollupAddress.toLowerCase();
 
-  for (let i = 0; i < to.length; i++) {
-    const addr = to[i];
+  for (let i = 0; i < calls.length; i++) {
+    const addr = calls[i].target;
     if (addr.toLowerCase() !== rollupAddressLower) {
       continue;
     }
-    const callData = data[i];
+    const callData = calls[i].callData;
 
     try {
       const { functionName: rollupFunctionName } = decodeFunctionData({
@@ -181,13 +281,13 @@ function extractRollupProposeCalldata(forwarderData: Hex, rollupAddress: Hex): H
       if (rollupFunctionName === 'propose') {
         return callData;
       }
-    } catch (err) {
+    } catch {
       // Skip invalid function data
       continue;
     }
   }
 
-  throw new Error(`Rollup address not found in forwarder args`);
+  throw new Error(`Rollup address not found in multicall3 args`);
 }
 
 /**
@@ -196,18 +296,19 @@ function extractRollupProposeCalldata(forwarderData: Hex, rollupAddress: Hex): H
  * TODO: Add retries and error management.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
+ * @param l2BlockNumber - L2 block number.
  * @returns L2 block from the calldata, deserialized
  */
 async function getBlockFromRollupTx(
   publicClient: ViemPublicClient,
   blobSinkClient: BlobSinkClientInterface,
   txHash: `0x${string}`,
-  blobHashes: Buffer[], // WORKTODO(md): buffer32?
-  l2BlockNum: bigint,
+  blobHashes: Buffer[], // TODO(md): buffer32?
+  l2BlockNumber: number,
   rollupAddress: Hex,
+  targetCommitteeSize: number,
   logger: Logger,
-): Promise<L2Block> {
+): Promise<Omit<RetrievedL2Block, 'l1' | 'chainId' | 'version'>> {
   const { input: forwarderData, blockHash } = await publicClient.getTransaction({ hash: txHash });
 
   const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
@@ -220,29 +321,48 @@ async function getBlockFromRollupTx(
     throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
   }
 
-  const [decodedArgs, ,] = rollupArgs! as readonly [
+  const [decodedArgs, packedAttestations, _signers, _blobInput] = rollupArgs! as readonly [
     {
-      header: Hex;
       archive: Hex;
-      blockHash: Hex;
+      stateReference: ViemStateReference;
       oracleInput: {
         feeAssetPriceModifier: bigint;
       };
-      txHashes: Hex[];
+      header: ViemHeader;
+      txHashes: readonly Hex[];
     },
-    ViemSignature[],
+    ViemCommitteeAttestations,
+    Hex[],
+    ViemSignature,
     Hex,
   ];
 
-  const header = BlockHeader.fromBuffer(Buffer.from(hexToBytes(decodedArgs.header)));
+  const attestations = CommitteeAttestation.fromPacked(packedAttestations, targetCommitteeSize);
+
+  logger.trace(`Recovered propose calldata from tx ${txHash}`, {
+    l2BlockNumber,
+    archive: decodedArgs.archive,
+    stateReference: decodedArgs.stateReference,
+    header: decodedArgs.header,
+    blobHashes,
+    attestations,
+    packedAttestations,
+    targetCommitteeSize,
+  });
+
+  const header = CheckpointHeader.fromViem(decodedArgs.header);
   const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
   if (blobBodies.length === 0) {
-    throw new NoBlobBodiesFoundError(Number(l2BlockNum));
+    throw new NoBlobBodiesFoundError(l2BlockNumber);
   }
 
-  let blockFields: Fr[];
+  let blobFields: Fr[];
   try {
-    blockFields = Blob.toEncodedFields(blobBodies);
+    // Get the fields that were actually added in the checkpoint. And check the encoding of the fields.
+    blobFields = getBlobFieldsInCheckpoint(
+      blobBodies.map(b => b.blob),
+      true /* checkEncoding */,
+    );
   } catch (err: any) {
     if (err instanceof BlobDeserializationError) {
       logger.fatal(err.message);
@@ -252,23 +372,31 @@ async function getBlockFromRollupTx(
     throw err;
   }
 
-  // The blob source gives us blockFields, and we must construct the body from them:
-  const blockBody = Body.fromBlobFields(blockFields);
+  const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
 
-  const blockNumberFromHeader = header.globalVariables.blockNumber.toBigInt();
+  const stateReference = StateReference.fromViem(decodedArgs.stateReference);
 
-  if (blockNumberFromHeader !== l2BlockNum) {
-    throw new Error(`Block number mismatch: expected ${l2BlockNum} but got ${blockNumberFromHeader}`);
-  }
-
-  const archive = AppendOnlyTreeSnapshot.fromBuffer(
-    Buffer.concat([
-      Buffer.from(hexToBytes(decodedArgs.archive)), // L2Block.archive.root
-      numToUInt32BE(Number(l2BlockNum + 1n)), // L2Block.archive.nextAvailableLeafIndex
-    ]),
-  );
+  return {
+    l2BlockNumber,
+    archiveRoot,
+    stateReference,
+    header,
+    blobFields,
+    attestations,
+  };
+}
 
-  return new L2Block(archive, header, blockBody);
+/** Given an L1 to L2 message, retrieves its corresponding event from the Inbox within a specific block range. */
+export async function retrieveL1ToL2Message(
+  inbox: GetContractReturnType<typeof InboxAbi, ViemClient>,
+  leaf: Fr,
+  fromBlock: bigint,
+  toBlock: bigint,
+): Promise<InboxMessage | undefined> {
+  const logs = await inbox.getEvents.MessageSent({ hash: leaf.toString() }, { fromBlock, toBlock });
+
+  const messages = mapLogsInboxMessage(logs);
+  return messages.length > 0 ? messages[0] : undefined;
 }
 
 /**
@@ -281,39 +409,39 @@ async function getBlockFromRollupTx(
  * @returns An array of InboxLeaf and next eth block to search from.
  */
 export async function retrieveL1ToL2Messages(
-  inbox: GetContractReturnType<typeof InboxAbi, ViemPublicClient>,
+  inbox: GetContractReturnType<typeof InboxAbi, ViemClient>,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
-): Promise<DataRetrieval<InboxLeaf>> {
-  const retrievedL1ToL2Messages: InboxLeaf[] = [];
-  do {
-    if (searchStartBlock > searchEndBlock) {
-      break;
-    }
-
+): Promise<InboxMessage[]> {
+  const retrievedL1ToL2Messages: InboxMessage[] = [];
+  while (searchStartBlock <= searchEndBlock) {
     const messageSentLogs = (
-      await inbox.getEvents.MessageSent(
-        {},
-        {
-          fromBlock: searchStartBlock,
-          toBlock: searchEndBlock,
-        },
-      )
+      await inbox.getEvents.MessageSent({}, { fromBlock: searchStartBlock, toBlock: searchEndBlock })
     ).filter(log => log.blockNumber! >= searchStartBlock && log.blockNumber! <= searchEndBlock);
 
     if (messageSentLogs.length === 0) {
       break;
     }
 
-    for (const log of messageSentLogs) {
-      const { index, hash } = log.args;
-      retrievedL1ToL2Messages.push(new InboxLeaf(index!, Fr.fromHexString(hash!)));
-    }
+    retrievedL1ToL2Messages.push(...mapLogsInboxMessage(messageSentLogs));
+    searchStartBlock = messageSentLogs.at(-1)!.blockNumber + 1n;
+  }
 
-    // handles the case when there are no new messages:
-    searchStartBlock = (messageSentLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
-  } while (searchStartBlock <= searchEndBlock);
-  return { lastProcessedL1BlockNumber: searchStartBlock - 1n, retrievedData: retrievedL1ToL2Messages };
+  return retrievedL1ToL2Messages;
+}
+
+function mapLogsInboxMessage(logs: GetContractEventsReturnType<typeof InboxAbi, 'MessageSent'>): InboxMessage[] {
+  return logs.map(log => {
+    const { index, hash, l2BlockNumber, rollingHash } = log.args;
+    return {
+      index: index!,
+      leaf: Fr.fromHexString(hash!),
+      l1BlockNumber: log.blockNumber,
+      l1BlockHash: Buffer32.fromString(log.blockHash),
+      l2BlockNumber: Number(l2BlockNumber!),
+      rollingHash: Buffer16.fromString(rollingHash!),
+    };
+  });
 }
 
 /** Retrieves L2ProofVerified events from the rollup contract. */
@@ -322,7 +450,7 @@ export async function retrieveL2ProofVerifiedEvents(
   rollupAddress: EthAddress,
   searchStartBlock: bigint,
   searchEndBlock?: bigint,
-): Promise<{ l1BlockNumber: bigint; l2BlockNumber: bigint; proverId: Fr; txHash: Hex }[]> {
+): Promise<{ l1BlockNumber: bigint; l2BlockNumber: number; proverId: Fr; txHash: Hex }[]> {
   const logs = await publicClient.getLogs({
     address: rollupAddress.toString(),
     fromBlock: searchStartBlock,
@@ -333,7 +461,7 @@ export async function retrieveL2ProofVerifiedEvents(
 
   return logs.map(log => ({
     l1BlockNumber: log.blockNumber,
-    l2BlockNumber: log.args.blockNumber,
+    l2BlockNumber: Number(log.args.blockNumber),
     proverId: Fr.fromHexString(log.args.proverId),
     txHash: log.transactionHash,
   }));
@@ -345,9 +473,9 @@ export async function retrieveL2ProofsFromRollup(
   rollupAddress: EthAddress,
   searchStartBlock: bigint,
   searchEndBlock?: bigint,
-): Promise<DataRetrieval<{ proof: Proof; proverId: Fr; l2BlockNumber: bigint; txHash: `0x${string}` }>> {
+): Promise<DataRetrieval<{ proof: Proof; proverId: Fr; l2BlockNumber: number; txHash: `0x${string}` }>> {
   const logs = await retrieveL2ProofVerifiedEvents(publicClient, rollupAddress, searchStartBlock, searchEndBlock);
-  const retrievedData: { proof: Proof; proverId: Fr; l2BlockNumber: bigint; txHash: `0x${string}` }[] = [];
+  const retrievedData: { proof: Proof; proverId: Fr; l2BlockNumber: number; txHash: `0x${string}` }[] = [];
   const lastProcessedL1BlockNumber = logs.length > 0 ? logs.at(-1)!.l1BlockNumber : searchStartBlock - 1n;
 
   for (const { txHash, proverId, l2BlockNumber } of logs) {
@@ -363,7 +491,6 @@ export async function retrieveL2ProofsFromRollup(
 export type SubmitBlockProof = {
   archiveRoot: Fr;
   proverId: Fr;
-  aggregationObject: Buffer;
   proof: Proof;
 };
 
@@ -386,7 +513,6 @@ export async function getProofFromSubmitProofTx(
 
   let proverId: Fr;
   let archiveRoot: Fr;
-  let aggregationObject: Buffer;
   let proof: Proof;
 
   if (functionName === 'submitEpochRootProof') {
@@ -396,12 +522,10 @@ export async function getProofFromSubmitProofTx(
         end: bigint;
         args: EpochProofPublicInputArgs;
         fees: readonly Hex[];
-        aggregationObject: Hex;
         proof: Hex;
       },
     ];
 
-    aggregationObject = Buffer.from(hexToBytes(decodedArgs.aggregationObject));
     proverId = Fr.fromHexString(decodedArgs.args.proverId);
     archiveRoot = Fr.fromHexString(decodedArgs.args.endArchive);
     proof = Proof.fromBuffer(Buffer.from(hexToBytes(decodedArgs.proof)));
@@ -415,7 +539,6 @@ export async function getProofFromSubmitProofTx(
 
   return {
     proverId,
-    aggregationObject,
     archiveRoot,
     proof,
   };

package/src/archiver/errors.ts

@@ -3,3 +3,24 @@ export class NoBlobBodiesFoundError extends Error {
     super(`No blob bodies found for block ${l2BlockNum}`);
   }
 }
+
+export class InitialBlockNumberNotSequentialError extends Error {
+  constructor(
+    public readonly newBlockNumber: number,
+    public readonly previousBlockNumber: number | undefined,
+  ) {
+    super(
+      `Cannot insert new block ${newBlockNumber} given previous block number in store is ${
+        previousBlockNumber ?? 'undefined'
+      }`,
+    );
+  }
+}
+
+export class BlockNumberNotSequentialError extends Error {
+  constructor(newBlockNumber: number, previous: number | undefined) {
+    super(
+      `Cannot insert new block ${newBlockNumber} given previous block number in batch is ${previous ?? 'undefined'}`,
+    );
+  }
+}

package/src/archiver/index.ts

@@ -1,7 +1,6 @@
 export * from './archiver.js';
 export * from './config.js';
-export { type L1Published, type L1PublishedData } from './structs/published.js';
-export { MemoryArchiverStore } from './memory_archiver_store/memory_archiver_store.js';
+export { type PublishedL2Block, type L1PublishedData } from './structs/published.js';
 export type { ArchiverDataStore } from './archiver_store.js';
-export { KVArchiverDataStore } from './kv_archiver_store/kv_archiver_store.js';
+export { KVArchiverDataStore, ARCHIVER_DB_VERSION } from './kv_archiver_store/kv_archiver_store.js';
 export { ContractInstanceStore } from './kv_archiver_store/contract_instance_store.js';