@aztec/archiver 0.0.1-commit.b655e406 → 0.0.1-commit.fce3e4f

package/src/archiver/validation.ts

@@ -1,60 +1,77 @@
 import type { EpochCache } from '@aztec/epoch-cache';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import type { Logger } from '@aztec/foundation/log';
 import {
-  type PublishedL2Block,
+  type AttestationInfo,
   type ValidateBlockNegativeResult,
   type ValidateBlockResult,
-  getAttestationInfoFromPublishedL2Block,
+  getAttestationInfoFromPayload,
 } from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { ConsensusPayload } from '@aztec/stdlib/p2p';
 
 export type { ValidateBlockResult };
 
 /**
- * Validates the attestations submitted for the given block.
+ * Extracts attestation information from a published checkpoint.
+ * Returns info for each attestation, preserving array indices.
+ */
+export function getAttestationInfoFromPublishedCheckpoint({
+  checkpoint,
+  attestations,
+}: PublishedCheckpoint): AttestationInfo[] {
+  const payload = ConsensusPayload.fromCheckpoint(checkpoint);
+  return getAttestationInfoFromPayload(payload, attestations);
+}
+
+/**
+ * Validates the attestations submitted for the given checkpoint.
  * Returns true if the attestations are valid and sufficient, false otherwise.
  */
-export async function validateBlockAttestations(
-  publishedBlock: PublishedL2Block,
+export async function validateCheckpointAttestations(
+  publishedCheckpoint: PublishedCheckpoint,
   epochCache: EpochCache,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
   logger?: Logger,
 ): Promise<ValidateBlockResult> {
-  const attestorInfos = getAttestationInfoFromPublishedL2Block(publishedBlock);
+  const attestorInfos = getAttestationInfoFromPublishedCheckpoint(publishedCheckpoint);
   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();
-  const slot = block.header.getSlot();
-  const epoch = getEpochAtSlot(slot, constants);
+  const { checkpoint, attestations } = publishedCheckpoint;
+  const headerHash = checkpoint.header.hash();
+  const archiveRoot = checkpoint.archive.root.toString();
+  const slot = checkpoint.header.slotNumber;
+  const epoch: EpochNumber = getEpochAtSlot(slot, constants);
   const { committee, seed } = await epochCache.getCommitteeForEpoch(epoch);
-  const logData = { blockNumber: block.number, slot, epoch, blockHash, archiveRoot };
+  const logData = { checkpointNumber: checkpoint.number, slot, epoch, headerHash, archiveRoot };
 
-  logger?.debug(`Validating attestations for block ${block.number} at slot ${slot} in epoch ${epoch}`, {
+  logger?.debug(`Validating attestations for checkpoint ${checkpoint.number} at slot ${slot} in epoch ${epoch}`, {
     committee: (committee ?? []).map(member => member.toString()),
     recoveredAttestors: attestorInfos,
-    postedAttestations: publishedBlock.attestations.map(a => (a.address.isZero() ? a.signature : a.address).toString()),
+    postedAttestations: attestations.map(a => (a.address.isZero() ? a.signature : a.address).toString()),
     ...logData,
   });
 
   if (!committee || committee.length === 0) {
-    logger?.warn(`No committee found for epoch ${epoch} at slot ${slot}. Accepting block without validation.`, logData);
+    logger?.warn(
+      `No committee found for epoch ${epoch} at slot ${slot}. Accepting checkpoint without validation.`,
+      logData,
+    );
     return { valid: true };
   }
 
-  const committeeSet = new Set(committee.map(member => member.toString()));
   const requiredAttestationCount = Math.floor((committee.length * 2) / 3) + 1;
 
   const failedValidationResult = <TReason extends ValidateBlockNegativeResult['reason']>(reason: TReason) => ({
     valid: false as const,
     reason,
-    block: publishedBlock.block.toBlockInfo(),
+    block: checkpoint.blocks[0].toBlockInfo(),
     committee,
     seed,
     epoch,
     attestors,
-    attestations: publishedBlock.attestations,
+    attestations,
   });
 
   for (let i = 0; i < attestorInfos.length; i++) {
@@ -70,15 +87,20 @@ export async function validateBlockAttestations(
       return { ...failedValidationResult('invalid-attestation'), invalidIndex: i };
     }
 
-    // Check if the attestor is in the committee
+    // Check if the attestor at this index matches the committee member at the same index
     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,
-        });
+      const expectedCommitteeMember = committee[i]?.toString();
+
+      if (!expectedCommitteeMember || signer !== expectedCommitteeMember) {
+        logger?.warn(
+          `Attestation at index ${i} from ${signer} does not match expected committee member ${expectedCommitteeMember} at slot ${slot}`,
+          {
+            committee,
+            invalidIndex: i,
+            ...logData,
+          },
+        );
         return { ...failedValidationResult('invalid-attestation'), invalidIndex: i };
       }
     }
@@ -86,7 +108,7 @@ export async function validateBlockAttestations(
 
   const validAttestationCount = attestorInfos.filter(info => info.status === 'recovered-from-signature').length;
   if (validAttestationCount < requiredAttestationCount) {
-    logger?.warn(`Insufficient attestations for block at slot ${slot}`, {
+    logger?.warn(`Insufficient attestations for checkpoint at slot ${slot}`, {
       requiredAttestations: requiredAttestationCount,
       actualAttestations: validAttestationCount,
       ...logData,
@@ -94,6 +116,9 @@ export async function validateBlockAttestations(
     return failedValidationResult('insufficient-attestations');
   }
 
-  logger?.debug(`Block attestations validated successfully for block ${block.number} at slot ${slot}`, logData);
+  logger?.debug(
+    `Checkpoint attestations validated successfully for checkpoint ${checkpoint.number} at slot ${slot}`,
+    logData,
+  );
   return { valid: true };
 }

package/src/index.ts

@@ -2,4 +2,4 @@ export * from './archiver/index.js';
 export * from './factory.js';
 export * from './rpc/index.js';
 
-export { retrieveBlocksFromRollup, retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';
+export { retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';

package/src/test/mock_l2_block_source.ts

@@ -1,5 +1,6 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -182,17 +183,17 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
   }
 
-  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]> {
     const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
     const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
     const blocks = this.l2Blocks.filter(b => {
-      const slot = b.header.globalVariables.slotNumber.toBigInt();
+      const slot = b.header.globalVariables.slotNumber;
       return slot >= start && slot <= end;
     });
     return Promise.resolve(blocks);
   }
 
-  async getBlockHeadersForEpoch(epochNumber: bigint): Promise<BlockHeader[]> {
+  async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
     const blocks = await this.getBlocksForEpoch(epochNumber);
     return blocks.map(b => b.getBlockHeader());
   }
@@ -268,15 +269,15 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     };
   }
 
-  getL2EpochNumber(): Promise<bigint> {
+  getL2EpochNumber(): Promise<EpochNumber> {
     throw new Error('Method not implemented.');
   }
 
-  getL2SlotNumber(): Promise<bigint> {
+  getL2SlotNumber(): Promise<SlotNumber> {
     throw new Error('Method not implemented.');
   }
 
-  isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+  isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
     throw new Error('Method not implemented.');
   }