@aztec/archiver 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/archiver/archiver_store.ts

@@ -61,6 +61,18 @@ export interface ArchiverDataStore {
    */
   getPublishedBlock(number: number): Promise<PublishedL2Block | undefined>;
 
+  /**
+   * Returns the block for the given hash, or undefined if not exists.
+   * @param blockHash - The block hash to return.
+   */
+  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Returns the block for the given archive root, or undefined if not exists.
+   * @param archive - The archive root to return.
+   */
+  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+
   /**
    * Gets up to `limit` amount of published L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
@@ -77,6 +89,18 @@ export interface ArchiverDataStore {
    */
   getBlockHeaders(from: number, limit: number): Promise<BlockHeader[]>;
 
+  /**
+   * Returns the block header for the given hash, or undefined if not exists.
+   * @param blockHash - The block hash to return.
+   */
+  getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined>;
+
+  /**
+   * Returns the block header for the given archive root, or undefined if not exists.
+   * @param archive - The archive root to return.
+   */
+  getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined>;
+
   /**
    * Gets a tx effect.
    * @param txHash - The hash of the tx corresponding to the tx effect.

package/src/archiver/archiver_store_test_suite.ts

@@ -2,7 +2,6 @@ import {
   INITIAL_L2_BLOCK_NUM,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   PRIVATE_LOG_SIZE_IN_FIELDS,
-  PUBLIC_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
@@ -143,6 +142,28 @@ export function describeArchiverDataStore(
         await store.addBlocks(blocks);
         await expect(store.unwindBlocks(5, 1)).rejects.toThrow(/can only unwind blocks from the tip/i);
       });
+
+      it('unwound blocks and headers cannot be retrieved by hash or archive', async () => {
+        await store.addBlocks(blocks);
+        const lastBlock = blocks[blocks.length - 1];
+        const blockHash = await lastBlock.block.hash();
+        const archive = lastBlock.block.archive.root;
+
+        // Verify block and header exist before unwinding
+        expect(await store.getPublishedBlockByHash(blockHash)).toBeDefined();
+        expect(await store.getPublishedBlockByArchive(archive)).toBeDefined();
+        expect(await store.getBlockHeaderByHash(blockHash)).toBeDefined();
+        expect(await store.getBlockHeaderByArchive(archive)).toBeDefined();
+
+        // Unwind the block
+        await store.unwindBlocks(lastBlock.block.number, 1);
+
+        // Verify neither block nor header can be retrieved after unwinding
+        expect(await store.getPublishedBlockByHash(blockHash)).toBeUndefined();
+        expect(await store.getPublishedBlockByArchive(archive)).toBeUndefined();
+        expect(await store.getBlockHeaderByHash(blockHash)).toBeUndefined();
+        expect(await store.getBlockHeaderByArchive(archive)).toBeUndefined();
+      });
     });
 
     describe('getBlocks', () => {
@@ -180,6 +201,86 @@ export function describeArchiverDataStore(
       });
     });
 
+    describe('getPublishedBlockByHash', () => {
+      beforeEach(async () => {
+        await store.addBlocks(blocks);
+      });
+
+      it('retrieves a block by its hash', async () => {
+        const expectedBlock = blocks[5];
+        const blockHash = await expectedBlock.block.hash();
+        const retrievedBlock = await store.getPublishedBlockByHash(blockHash);
+
+        expect(retrievedBlock).toBeDefined();
+        expectBlocksEqual([retrievedBlock!], [expectedBlock]);
+      });
+
+      it('returns undefined for non-existent block hash', async () => {
+        const nonExistentHash = Fr.random();
+        await expect(store.getPublishedBlockByHash(nonExistentHash)).resolves.toBeUndefined();
+      });
+    });
+
+    describe('getPublishedBlockByArchive', () => {
+      beforeEach(async () => {
+        await store.addBlocks(blocks);
+      });
+
+      it('retrieves a block by its archive root', async () => {
+        const expectedBlock = blocks[3];
+        const archive = expectedBlock.block.archive.root;
+        const retrievedBlock = await store.getPublishedBlockByArchive(archive);
+
+        expect(retrievedBlock).toBeDefined();
+        expectBlocksEqual([retrievedBlock!], [expectedBlock]);
+      });
+
+      it('returns undefined for non-existent archive root', async () => {
+        const nonExistentArchive = Fr.random();
+        await expect(store.getPublishedBlockByArchive(nonExistentArchive)).resolves.toBeUndefined();
+      });
+    });
+
+    describe('getBlockHeaderByHash', () => {
+      beforeEach(async () => {
+        await store.addBlocks(blocks);
+      });
+
+      it('retrieves a block header by its hash', async () => {
+        const expectedBlock = blocks[7];
+        const blockHash = await expectedBlock.block.hash();
+        const retrievedHeader = await store.getBlockHeaderByHash(blockHash);
+
+        expect(retrievedHeader).toBeDefined();
+        expect(retrievedHeader!.equals(expectedBlock.block.getBlockHeader())).toBe(true);
+      });
+
+      it('returns undefined for non-existent block hash', async () => {
+        const nonExistentHash = Fr.random();
+        await expect(store.getBlockHeaderByHash(nonExistentHash)).resolves.toBeUndefined();
+      });
+    });
+
+    describe('getBlockHeaderByArchive', () => {
+      beforeEach(async () => {
+        await store.addBlocks(blocks);
+      });
+
+      it('retrieves a block header by its archive root', async () => {
+        const expectedBlock = blocks[2];
+        const archive = expectedBlock.block.archive.root;
+        const retrievedHeader = await store.getBlockHeaderByArchive(archive);
+
+        expect(retrievedHeader).toBeDefined();
+        expect(retrievedHeader!.equals(expectedBlock.block.getBlockHeader())).toBe(true);
+      });
+
+      it('returns undefined for non-existent archive root', async () => {
+        const nonExistentArchive = Fr.random();
+        await expect(store.getBlockHeaderByArchive(nonExistentArchive)).resolves.toBeUndefined();
+      });
+    });
+
     describe('getSyncedL2BlockNumber', () => {
       it('returns the block number before INITIAL_L2_BLOCK_NUM if no blocks have been added', async () => {
         await expect(store.getSynchedL2BlockNumber()).resolves.toEqual(INITIAL_L2_BLOCK_NUM - 1);
@@ -737,8 +838,8 @@ export function describeArchiverDataStore(
       const makePublicLog = (tag: Fr) =>
         PublicLog.from({
           contractAddress: AztecAddress.fromNumber(1),
-          fields: makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, i => (!i ? tag : new Fr(tag.toNumber() + i))),
-          emittedLength: PUBLIC_LOG_SIZE_IN_FIELDS,
+          // Arbitrary length
+          fields: new Array(10).fill(null).map((_, i) => (!i ? tag : new Fr(tag.toNumber() + i))),
         });
 
       const mockPrivateLogs = (blockNumber: number, txIndex: number) => {

package/src/archiver/config.ts

@@ -44,7 +44,7 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
   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.',
+    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).',

package/src/archiver/data_retrieval.ts

@@ -1,4 +1,4 @@
-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,
@@ -15,10 +15,11 @@ import type { ViemSignature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, L2Block, PublishedL2Block } from '@aztec/stdlib/block';
+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, GlobalVariables, ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
+import { GlobalVariables, StateReference } from '@aztec/stdlib/tx';
 
 import {
   type GetContractEventsReturnType,
@@ -39,21 +40,21 @@ export type RetrievedL2Block = {
   l2BlockNumber: number;
   archiveRoot: Fr;
   stateReference: StateReference;
-  header: ProposedBlockHeader;
-  body: Body;
+  header: CheckpointHeader;
+  blobFields: Fr[];
   l1: L1PublishedData;
   chainId: Fr;
   version: Fr;
   attestations: CommitteeAttestation[];
 };
 
-export function retrievedBlockToPublishedL2Block(retrievedBlock: RetrievedL2Block): PublishedL2Block {
+export async function retrievedBlockToPublishedL2Block(retrievedBlock: RetrievedL2Block): Promise<PublishedL2Block> {
   const {
     l2BlockNumber,
     archiveRoot,
     stateReference,
-    header: proposedHeader,
-    body,
+    header: checkpointHeader,
+    blobFields,
     l1,
     chainId,
     version,
@@ -69,20 +70,32 @@ export function retrievedBlockToPublishedL2Block(retrievedBlock: RetrievedL2Bloc
     chainId,
     version,
     blockNumber: l2BlockNumber,
-    slotNumber: proposedHeader.slotNumber,
-    timestamp: proposedHeader.timestamp,
-    coinbase: proposedHeader.coinbase,
-    feeRecipient: proposedHeader.feeRecipient,
-    gasFees: proposedHeader.gasFees,
+    slotNumber: checkpointHeader.slotNumber,
+    timestamp: checkpointHeader.timestamp,
+    coinbase: checkpointHeader.coinbase,
+    feeRecipient: checkpointHeader.feeRecipient,
+    gasFees: checkpointHeader.gasFees,
   });
 
-  const header = BlockHeader.from({
-    lastArchive: new AppendOnlyTreeSnapshot(proposedHeader.lastArchiveRoot, l2BlockNumber),
-    contentCommitment: proposedHeader.contentCommitment,
+  // 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: proposedHeader.totalManaUsed,
+    totalManaUsed: checkpointHeader.totalManaUsed,
+    spongeBlobHash,
   });
 
   const block = new L2Block(archive, header, body);
@@ -337,17 +350,19 @@ async function getBlockFromRollupTx(
     targetCommitteeSize,
   });
 
-  // TODO(md): why is the proposed block header different to the actual block header?
-  // This is likely going to be a footgun
-  const header = ProposedBlockHeader.fromViem(decodedArgs.header);
+  const header = CheckpointHeader.fromViem(decodedArgs.header);
   const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
   if (blobBodies.length === 0) {
     throw new NoBlobBodiesFoundError(l2BlockNumber);
   }
 
-  let blockFields: Fr[];
+  let blobFields: Fr[];
   try {
-    blockFields = Blob.toEncodedFields(blobBodies.map(b => b.blob));
+    // 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);
@@ -357,9 +372,6 @@ async function getBlockFromRollupTx(
     throw err;
   }
 
-  // The blob source gives us blockFields, and we must construct the body from them:
-  const body = Body.fromBlobFields(blockFields);
-
   const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
 
   const stateReference = StateReference.fromViem(decodedArgs.stateReference);
@@ -369,7 +381,7 @@ async function getBlockFromRollupTx(
     archiveRoot,
     stateReference,
     header,
-    body,
+    blobFields,
     attestations,
   };
 }

package/src/archiver/instrumentation.ts

@@ -152,6 +152,9 @@ export class ArchiverInstrumentation {
   }
 
   public processNewMessages(count: number, syncPerMessageMs: number) {
+    if (count === 0) {
+      return;
+    }
     this.syncMessageCount.add(count);
     this.syncDurationPerMessage.record(Math.ceil(syncPerMessageMs));
   }

package/src/archiver/kv_archiver_store/block_store.ts

@@ -14,7 +14,7 @@ import {
   PublishedL2Block,
   type ValidateBlockResult,
 } from '@aztec/stdlib/block';
-import { deserializeValidateBlockResult, serializeValidateBlockResult } from '@aztec/stdlib/block';
+import { L2BlockHeader, deserializeValidateBlockResult, serializeValidateBlockResult } from '@aztec/stdlib/block';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import {
   BlockHeader,
@@ -66,6 +66,12 @@ export class BlockStore {
   /** Index mapping a contract's address (as a string) to its location in a block */
   #contractIndex: AztecAsyncMap<string, BlockIndexValue>;
 
+  /** Index mapping block hash to block number */
+  #blockHashIndex: AztecAsyncMap<string, number>;
+
+  /** Index mapping block archive to block number */
+  #blockArchiveIndex: AztecAsyncMap<string, number>;
+
   #log = createLogger('archiver:block_store');
 
   constructor(private db: AztecAsyncKVStore) {
@@ -73,6 +79,8 @@ export class BlockStore {
     this.#blockTxs = db.openMap('archiver_block_txs');
     this.#txEffects = db.openMap('archiver_tx_effects');
     this.#contractIndex = db.openMap('archiver_contract_index');
+    this.#blockHashIndex = db.openMap('archiver_block_hash_index');
+    this.#blockArchiveIndex = db.openMap('archiver_block_archive_index');
     this.#lastSynchedL1Block = db.openSingleton('archiver_last_synched_l1_block');
     this.#lastProvenL2Block = db.openSingleton('archiver_last_proven_l2_block');
     this.#pendingChainValidationStatus = db.openSingleton('archiver_pending_chain_validation_status');
@@ -132,6 +140,10 @@ export class BlockStore {
           blockHash.toString(),
           Buffer.concat(block.block.body.txEffects.map(tx => tx.txHash.toBuffer())),
         );
+
+        // Update indices for block hash and archive
+        await this.#blockHashIndex.set(blockHash.toString(), block.block.number);
+        await this.#blockArchiveIndex.set(block.block.archive.root.toString(), block.block.number);
       }
 
       await this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
@@ -170,6 +182,11 @@ export class BlockStore {
         await Promise.all(block.block.body.txEffects.map(tx => this.#txEffects.delete(tx.txHash.toString())));
         const blockHash = (await block.block.hash()).toString();
         await this.#blockTxs.delete(blockHash);
+
+        // Clean up indices
+        await this.#blockHashIndex.delete(blockHash);
+        await this.#blockArchiveIndex.delete(block.block.archive.root.toString());
+
         this.#log.debug(`Unwound block ${blockNumber} ${blockHash}`);
       }
 
@@ -205,6 +222,66 @@ export class BlockStore {
     return this.getBlockFromBlockStorage(blockNumber, blockStorage);
   }
 
+  /**
+   * Gets an L2 block by its hash.
+   * @param blockHash - The hash of the block to return.
+   * @returns The requested L2 block.
+   */
+  async getBlockByHash(blockHash: L2BlockHash): Promise<PublishedL2Block | undefined> {
+    const blockNumber = await this.#blockHashIndex.getAsync(blockHash.toString());
+    if (blockNumber === undefined) {
+      return undefined;
+    }
+    return this.getBlock(blockNumber);
+  }
+
+  /**
+   * Gets an L2 block by its archive root.
+   * @param archive - The archive root of the block to return.
+   * @returns The requested L2 block.
+   */
+  async getBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+    const blockNumber = await this.#blockArchiveIndex.getAsync(archive.toString());
+    if (blockNumber === undefined) {
+      return undefined;
+    }
+    return this.getBlock(blockNumber);
+  }
+
+  /**
+   * Gets a block header by its hash.
+   * @param blockHash - The hash of the block to return.
+   * @returns The requested block header.
+   */
+  async getBlockHeaderByHash(blockHash: L2BlockHash): Promise<BlockHeader | undefined> {
+    const blockNumber = await this.#blockHashIndex.getAsync(blockHash.toString());
+    if (blockNumber === undefined) {
+      return undefined;
+    }
+    const blockStorage = await this.#blocks.getAsync(blockNumber);
+    if (!blockStorage || !blockStorage.header) {
+      return undefined;
+    }
+    return L2BlockHeader.fromBuffer(blockStorage.header).toBlockHeader();
+  }
+
+  /**
+   * Gets a block header by its archive root.
+   * @param archive - The archive root of the block to return.
+   * @returns The requested block header.
+   */
+  async getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
+    const blockNumber = await this.#blockArchiveIndex.getAsync(archive.toString());
+    if (blockNumber === undefined) {
+      return undefined;
+    }
+    const blockStorage = await this.#blocks.getAsync(blockNumber);
+    if (!blockStorage || !blockStorage.header) {
+      return undefined;
+    }
+    return L2BlockHeader.fromBuffer(blockStorage.header).toBlockHeader();
+  }
+
   /**
    * Gets the headers for a sequence of L2 blocks.
    * @param start - Number of the first block to return (inclusive).
@@ -213,7 +290,7 @@ export class BlockStore {
    */
   async *getBlockHeaders(start: number, limit: number): AsyncIterableIterator<BlockHeader> {
     for await (const [blockNumber, blockStorage] of this.getBlockStorages(start, limit)) {
-      const header = BlockHeader.fromBuffer(blockStorage.header);
+      const header = L2BlockHeader.fromBuffer(blockStorage.header).toBlockHeader();
       if (header.getBlockNumber() !== blockNumber) {
         throw new Error(
           `Block number mismatch when retrieving block header from archive (expected ${blockNumber} but got ${header.getBlockNumber()})`,
@@ -240,7 +317,7 @@ export class BlockStore {
     blockNumber: number,
     blockStorage: BlockStorage,
   ): Promise<PublishedL2Block | undefined> {
-    const header = BlockHeader.fromBuffer(blockStorage.header);
+    const header = L2BlockHeader.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
     const blockHash = blockStorage.blockHash;
     const blockHashString = bufferToHex(blockHash);

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -5,7 +5,7 @@ import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, CustomRange, StoreSize } from '@aztec/kv-store';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2Block, ValidateBlockResult } from '@aztec/stdlib/block';
+import { type L2Block, L2BlockHash, type ValidateBlockResult } from '@aztec/stdlib/block';
 import type {
   ContractClassPublic,
   ContractDataSource,
@@ -204,6 +204,14 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#blockStore.getBlock(number);
   }
 
+  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+    return this.#blockStore.getBlockByHash(L2BlockHash.fromField(blockHash));
+  }
+
+  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+    return this.#blockStore.getBlockByArchive(archive);
+  }
+
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    *
@@ -226,6 +234,14 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return toArray(this.#blockStore.getBlockHeaders(start, limit));
   }
 
+  getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
+    return this.#blockStore.getBlockHeaderByHash(L2BlockHash.fromField(blockHash));
+  }
+
+  getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
+    return this.#blockStore.getBlockHeaderByArchive(archive);
+  }
+
   /**
    * Gets a tx effect.
    * @param txHash - The hash of the tx corresponding to the tx effect.

package/src/archiver/validation.ts

@@ -3,8 +3,9 @@ import { compactArray } from '@aztec/foundation/collection';
 import type { Logger } from '@aztec/foundation/log';
 import {
   type PublishedL2Block,
+  type ValidateBlockNegativeResult,
   type ValidateBlockResult,
-  getAttestationsFromPublishedL2Block,
+  getAttestationInfoFromPublishedL2Block,
 } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 
@@ -20,8 +21,8 @@ export async function validateBlockAttestations(
   constants: Pick<L1RollupConstants, 'epochDuration'>,
   logger?: Logger,
 ): Promise<ValidateBlockResult> {
-  const attestations = getAttestationsFromPublishedL2Block(publishedBlock);
-  const attestors = compactArray(attestations.map(a => a?.tryGetSender()));
+  const attestorInfos = getAttestationInfoFromPublishedL2Block(publishedBlock);
+  const attestors = compactArray(attestorInfos.map(info => ('address' in info ? info.address : undefined)));
   const { block } = publishedBlock;
   const blockHash = await block.hash().then(hash => hash.toString());
   const archiveRoot = block.archive.root.toString();
@@ -32,10 +33,7 @@ export async function validateBlockAttestations(
 
   logger?.debug(`Validating attestations for block ${block.number} at slot ${slot} in epoch ${epoch}`, {
     committee: (committee ?? []).map(member => member.toString()),
-    recoveredAttestors: attestors.map(member => member.toString()),
-    invalidAttestations: attestations
-      .filter(a => a !== undefined && a.tryGetSender() === undefined)
-      .map(a => a?.toInspect()),
+    recoveredAttestors: attestorInfos,
     postedAttestations: publishedBlock.attestations.map(a => (a.address.isZero() ? a.signature : a.address).toString()),
     ...logData,
   });
@@ -48,57 +46,52 @@ export async function validateBlockAttestations(
   const committeeSet = new Set(committee.map(member => member.toString()));
   const requiredAttestationCount = Math.floor((committee.length * 2) / 3) + 1;
 
-  for (let i = 0; i < attestations.length; i++) {
-    const attestation = attestations[i];
+  const failedValidationResult = <TReason extends ValidateBlockNegativeResult['reason']>(reason: TReason) => ({
+    valid: false as const,
+    reason,
+    block: publishedBlock.block.toBlockInfo(),
+    committee,
+    seed,
+    epoch,
+    attestors,
+    attestations: publishedBlock.attestations,
+  });
 
-    // Skip empty signatures (undefined entries)
-    if (attestation === undefined) {
-      continue;
-    }
+  for (let i = 0; i < attestorInfos.length; i++) {
+    const info = attestorInfos[i];
 
-    const signer = attestation.tryGetSender()?.toString();
-    if (signer !== undefined && committeeSet.has(signer)) {
-      continue;
+    // Fail on invalid signatures (no address recovered)
+    if (info.status === 'invalid-signature' || info.status === 'empty') {
+      logger?.warn(`Attestation with empty or invalid signature at slot ${slot}`, {
+        committee,
+        invalidIndex: i,
+        ...logData,
+      });
+      return { ...failedValidationResult('invalid-attestation'), invalidIndex: i };
     }
 
-    if (signer === undefined) {
-      logger?.warn(`Attestation with invalid signature at slot ${slot}`, { committee, ...logData });
-    } else {
-      logger?.warn(`Attestation from non-committee member ${signer} at slot ${slot}`, { committee, ...logData });
+    // Check if the attestor is in the committee
+    if (info.status === 'recovered-from-signature' || info.status === 'provided-as-address') {
+      const signer = info.address.toString();
+      if (!committeeSet.has(signer)) {
+        logger?.warn(`Attestation from non-committee member ${signer} at slot ${slot}`, {
+          committee,
+          invalidIndex: i,
+          ...logData,
+        });
+        return { ...failedValidationResult('invalid-attestation'), invalidIndex: i };
+      }
     }
-
-    const reason = 'invalid-attestation';
-    return {
-      valid: false,
-      reason,
-      invalidIndex: i,
-      block: publishedBlock.block.toBlockInfo(),
-      committee,
-      seed,
-      epoch,
-      attestors,
-      attestations: publishedBlock.attestations,
-    };
   }
 
-  const validAttestationCount = compactArray(attestations).length;
+  const validAttestationCount = attestorInfos.filter(info => info.status === 'recovered-from-signature').length;
   if (validAttestationCount < requiredAttestationCount) {
     logger?.warn(`Insufficient attestations for block at slot ${slot}`, {
       requiredAttestations: requiredAttestationCount,
       actualAttestations: validAttestationCount,
       ...logData,
     });
-    const reason = 'insufficient-attestations';
-    return {
-      valid: false,
-      reason,
-      block: publishedBlock.block.toBlockInfo(),
-      committee,
-      seed,
-      epoch,
-      attestors,
-      attestations: publishedBlock.attestations,
-    };
+    return failedValidationResult('insufficient-attestations');
   }
 
   logger?.debug(`Block attestations validated successfully for block ${block.number} at slot ${slot}`, logData);

package/src/factory.ts

@@ -20,7 +20,7 @@ export async function createArchiverStore(
 ) {
   const config = {
     ...userConfig,
-    dataStoreMapSizeKB: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKB,
+    dataStoreMapSizeKb: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKb,
   };
   const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config, createLogger('archiver:lmdb'));
   return new KVArchiverDataStore(store, config.maxLogs);