@aztec/stdlib 4.0.0-nightly.20260112 → 4.0.0-nightly.20260114

package/src/block/validate_block_result.ts

@@ -5,57 +5,62 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
-import { BlockInfoSchema, type L2BlockInfo, deserializeBlockInfo, serializeBlockInfo } from './l2_block_info.js';
+import {
+  type CheckpointInfo,
+  CheckpointInfoSchema,
+  deserializeCheckpointInfo,
+  serializeCheckpointInfo,
+} from '../checkpoint/checkpoint_info.js';
+import { MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
-/** Subtype for invalid block validation results */
-export type ValidateBlockNegativeResult =
+/** Subtype for invalid checkpoint validation results */
+export type ValidateCheckpointNegativeResult =
   | {
       valid: false;
-      /** Identifiers from the invalid block */
-      block: L2BlockInfo;
-      /** Committee members at the epoch this block was proposed */
+      /** Identifiers from the invalid checkpoint */
+      checkpoint: CheckpointInfo;
+      /** Committee members at the epoch this checkpoint was proposed */
       committee: EthAddress[];
-      /** Epoch in which this block was proposed */
+      /** Epoch in which this checkpoint was proposed */
       epoch: EpochNumber;
       /** Proposer selection seed for the epoch */
       seed: bigint;
-      /** List of committee members who signed this block proposal */
+      /** List of committee members who signed this checkpoint proposal */
       attestors: EthAddress[];
-      /** Committee attestations for this block as they were posted to L1 */
+      /** Committee attestations for this checkpoint as they were posted to L1 */
       attestations: CommitteeAttestation[];
-      /** Reason for the block being invalid: not enough attestations were posted */
+      /** Reason for the checkpoint being invalid: not enough attestations were posted */
       reason: 'insufficient-attestations';
     }
   | {
       valid: false;
-      /** Identifiers from the invalid block */
-      block: L2BlockInfo;
-      /** Committee members at the epoch this block was proposed */
+      /** Identifiers from the invalid checkpoint */
+      checkpoint: CheckpointInfo;
+      /** Committee members at the epoch this checkpoint was proposed */
       committee: EthAddress[];
-      /** Epoch in which this block was proposed */
+      /** Epoch in which this checkpoint was proposed */
       epoch: EpochNumber;
       /** Proposer selection seed for the epoch */
       seed: bigint;
-      /** List of committee members who signed this block proposal */
+      /** List of committee members who signed this checkpoint proposal */
       attestors: EthAddress[];
-      /** Committee attestations for this block as they were posted to L1 */
+      /** Committee attestations for this checkpoint as they were posted to L1 */
       attestations: CommitteeAttestation[];
-      /** Reason for the block being invalid: an invalid attestation was posted */
+      /** Reason for the checkpoint being invalid: an invalid attestation was posted */
       reason: 'invalid-attestation';
       /** Index in the attestations array of the invalid attestation posted */
       invalidIndex: number;
     };
 
-// TODO: Rename to ValidateAttestationsResult
-/** Result type for validating a block attestations */
-export type ValidateBlockResult = { valid: true } | ValidateBlockNegativeResult;
+/** Result type for validating checkpoint attestations */
+export type ValidateCheckpointResult = { valid: true } | ValidateCheckpointNegativeResult;
 
-export const ValidateBlockResultSchema: ZodFor<ValidateBlockResult> = z.union([
+export const ValidateCheckpointResultSchema: ZodFor<ValidateCheckpointResult> = z.union([
   z.object({ valid: z.literal(true) }),
   z.object({
     valid: z.literal(false),
-    block: BlockInfoSchema,
+    checkpoint: CheckpointInfoSchema,
     committee: z.array(schemas.EthAddress),
     epoch: EpochNumberSchema,
     seed: schemas.BigInt,
@@ -65,7 +70,7 @@ export const ValidateBlockResultSchema: ZodFor<ValidateBlockResult> = z.union([
   }),
   z.object({
     valid: z.literal(false),
-    block: BlockInfoSchema,
+    checkpoint: CheckpointInfoSchema,
     committee: z.array(schemas.EthAddress),
     epoch: EpochNumberSchema,
     seed: schemas.BigInt,
@@ -76,17 +81,17 @@ export const ValidateBlockResultSchema: ZodFor<ValidateBlockResult> = z.union([
   }),
 ]);
 
-export function serializeValidateBlockResult(result: ValidateBlockResult): Buffer {
+export function serializeValidateCheckpointResult(result: ValidateCheckpointResult): Buffer {
   if (result.valid) {
     return serializeToBuffer(true);
   }
 
-  const l2Block = serializeBlockInfo(result.block);
+  const checkpointBuffer = serializeCheckpointInfo(result.checkpoint);
   return serializeToBuffer(
     result.valid,
     result.reason,
-    l2Block.length,
-    l2Block,
+    checkpointBuffer.length,
+    checkpointBuffer,
     result.committee.length,
     result.committee,
     result.epoch,
@@ -99,24 +104,24 @@ export function serializeValidateBlockResult(result: ValidateBlockResult): Buffe
   );
 }
 
-export function deserializeValidateBlockResult(bufferOrReader: Buffer | BufferReader): ValidateBlockResult {
+export function deserializeValidateCheckpointResult(bufferOrReader: Buffer | BufferReader): ValidateCheckpointResult {
   const reader = BufferReader.asReader(bufferOrReader);
   const valid = reader.readBoolean();
   if (valid) {
     return { valid };
   }
-  const reason = reader.readString() as 'insufficient-attestations' | 'invalid-attestation';
-  const block = deserializeBlockInfo(reader.readBuffer());
-  const committee = reader.readVector(EthAddress);
+  const reason = reader.readString(64) as 'insufficient-attestations' | 'invalid-attestation';
+  const checkpoint = deserializeCheckpointInfo(reader.readBuffer());
+  const committee = reader.readVector(EthAddress, MAX_COMMITTEE_SIZE);
   const epoch = EpochNumber(reader.readNumber());
   const seed = reader.readBigInt();
-  const attestors = reader.readVector(EthAddress);
-  const attestations = reader.readVector(CommitteeAttestation);
+  const attestors = reader.readVector(EthAddress, MAX_COMMITTEE_SIZE);
+  const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
   const invalidIndex = reader.readNumber();
   if (reason === 'insufficient-attestations') {
-    return { valid, reason, block, committee, epoch, seed, attestors, attestations: attestations };
+    return { valid, reason, checkpoint, committee, epoch, seed, attestors, attestations };
   } else if (reason === 'invalid-attestation') {
-    return { valid, reason, block, committee, epoch, seed, attestors, invalidIndex, attestations: attestations };
+    return { valid, reason, checkpoint, committee, epoch, seed, attestors, invalidIndex, attestations };
   } else {
     const _: never = reason;
     throw new Error(`Unknown reason: ${reason}`);

package/src/checkpoint/checkpoint.ts

@@ -8,6 +8,8 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
 
 import { L2BlockNew } from '../block/l2_block_new.js';
+import { MAX_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
+import { computeCheckpointOutHash } from '../messaging/out_hash.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import type { CheckpointInfo } from './checkpoint_info.js';
@@ -48,7 +50,7 @@ export class Checkpoint {
     return new Checkpoint(
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(CheckpointHeader),
-      reader.readVector(L2BlockNew),
+      reader.readVector(L2BlockNew, MAX_BLOCKS_PER_CHECKPOINT),
       CheckpointNumber(reader.readNumber()),
     );
   }
@@ -66,6 +68,14 @@ export class Checkpoint {
     return this.header.hash();
   }
 
+  // Returns the out hash computed from all l2-to-l1 messages in this checkpoint.
+  // Note: This value is different from the out hash in the header, which is the **accumulated** out hash over all
+  // checkpoints up to and including this one in the epoch.
+  public getCheckpointOutHash(): Fr {
+    const msgs = this.blocks.map(block => block.body.txEffects.map(txEffect => txEffect.l2ToL1Msgs));
+    return computeCheckpointOutHash(msgs);
+  }
+
   public getState() {
     return this.blocks.at(-1)!.header.state;
   }
@@ -73,6 +83,7 @@ export class Checkpoint {
   public toCheckpointInfo(): CheckpointInfo {
     return {
       archive: this.archive.root,
+      lastArchive: this.header.lastArchiveRoot,
       slotNumber: this.header.slotNumber,
       checkpointNumber: this.number,
       timestamp: this.header.timestamp,

package/src/checkpoint/checkpoint_info.ts

@@ -1,9 +1,52 @@
-import type { CheckpointNumber } from '@aztec/foundation/branded-types';
-import type { Fr, SlotNumber } from '@aztec/foundation/schemas';
+import {
+  CheckpointNumber,
+  CheckpointNumberSchema,
+  SlotNumber,
+  SlotNumberSchema,
+} from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
 
 export type CheckpointInfo = {
   archive: Fr;
+  lastArchive: Fr;
   slotNumber: SlotNumber;
   checkpointNumber: CheckpointNumber;
   timestamp: bigint;
 };
+
+export function randomCheckpointInfo(checkpointNumber?: CheckpointNumber | number): CheckpointInfo {
+  return {
+    archive: Fr.random(),
+    lastArchive: Fr.random(),
+    slotNumber: SlotNumber(Math.floor(Math.random() * 100000) + 1),
+    checkpointNumber: CheckpointNumber(checkpointNumber ?? Math.floor(Math.random() * 100000) + 1),
+    timestamp: BigInt(Math.floor(Date.now() / 1000)),
+  };
+}
+
+export const CheckpointInfoSchema = z.object({
+  archive: schemas.Fr,
+  lastArchive: schemas.Fr,
+  slotNumber: SlotNumberSchema,
+  checkpointNumber: CheckpointNumberSchema,
+  timestamp: schemas.BigInt,
+});
+
+export function serializeCheckpointInfo(info: CheckpointInfo): Buffer {
+  return serializeToBuffer(info.archive, info.lastArchive, info.slotNumber, info.checkpointNumber, info.timestamp);
+}
+
+export function deserializeCheckpointInfo(buffer: Buffer | BufferReader): CheckpointInfo {
+  const reader = BufferReader.asReader(buffer);
+  return {
+    archive: reader.readObject(Fr),
+    lastArchive: reader.readObject(Fr),
+    slotNumber: SlotNumber(reader.readNumber()),
+    checkpointNumber: CheckpointNumber(reader.readNumber()),
+    timestamp: reader.readBigInt(),
+  };
+}

package/src/checkpoint/index.ts

@@ -1,2 +1,3 @@
 export * from './checkpoint.js';
+export * from './checkpoint_info.js';
 export * from './published_checkpoint.js';

package/src/checkpoint/published_checkpoint.ts

@@ -8,6 +8,7 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
 
 import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
 import { Checkpoint } from './checkpoint.js';
 
 export class L1PublishedData {
@@ -42,7 +43,7 @@ export class L1PublishedData {
   static fromBuffer(bufferOrReader: Buffer | BufferReader): L1PublishedData {
     const reader = BufferReader.asReader(bufferOrReader);
     const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
     const l1Timestamp = reader.readBigInt();
     return new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash);
   }
@@ -82,9 +83,9 @@ export class PublishedCheckpoint {
     const reader = BufferReader.asReader(bufferOrReader);
     const checkpoint = reader.readObject(Checkpoint);
     const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
     const l1Timestamp = reader.readBigInt();
-    const attestations = reader.readVector(CommitteeAttestation);
+    const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
     return new PublishedCheckpoint(
       checkpoint,
       new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),

package/src/contract/index.ts

@@ -1,11 +1,9 @@
 export * from './artifact_hash.js';
 export * from './contract_address.js';
 export * from './contract_class.js';
-export * from './contract_class_metadata.js';
 export * from './contract_class_id.js';
 export * from './contract_deployment_data.js';
 export * from './contract_instance.js';
-export * from './contract_metadata.js';
 export * from './contract_instance_update.js';
 export * from './private_function.js';
 export * from './private_function_membership_proof.js';

package/src/deserialization/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Constants for deserialization bounds checking.
+ * These constants define maximum allowed sizes during deserialization
+ * to prevent DoS attacks via maliciously crafted messages.
+ */
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
+
+/** Max transactions per block for deserialization validation */
+export const MAX_TXS_PER_BLOCK = 2 ** 16;
+
+/** Max committee size - theoretical max from bitmap design (256 bytes × 8 bits) */
+export const MAX_COMMITTEE_SIZE = 2048;
+
+/** Max blocks per checkpoint */
+export const MAX_BLOCKS_PER_CHECKPOINT = 72;
+
+/** Max tx effects per body (based on blob capacity per checkpoint) */
+export const MAX_TX_EFFECTS_PER_BODY = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+
+/** Max block hash string length (hex: 0x + 64 chars, with generous headroom) */
+export const MAX_BLOCK_HASH_STRING_LENGTH = 128;

package/src/interfaces/api_limit.ts

@@ -1,3 +1,4 @@
 export const MAX_RPC_LEN = 100;
 export const MAX_RPC_TXS_LEN = 50;
 export const MAX_RPC_BLOCKS_LEN = 50;
+export const MAX_RPC_CHECKPOINTS_LEN = 50;

package/src/interfaces/archiver.ts

@@ -8,7 +8,7 @@ import { CheckpointedL2Block, PublishedL2Block } from '../block/checkpointed_l2_
 import { L2Block } from '../block/l2_block.js';
 import { L2BlockNew } from '../block/l2_block_new.js';
 import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
-import { ValidateBlockResultSchema } from '../block/validate_block_result.js';
+import { ValidateCheckpointResultSchema } from '../block/validate_block_result.js';
 import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import {
@@ -52,14 +52,14 @@ export type ArchiverSpecificConfig = {
   /** The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb. */
   archiverStoreMapSizeKb?: number;
 
-  /** Whether to skip validating block attestations (use only for testing). */
-  skipValidateBlockAttestations?: boolean;
-
   /** Maximum allowed drift in seconds between the Ethereum client and current time. */
   maxAllowedEthClientDriftSeconds?: number;
 
   /** Whether to allow starting the archiver without debug/trace method support on Ethereum hosts */
   ethereumAllowNoDebugHosts?: boolean;
+
+  /** Skip validating checkpoint attestations (for testing purposes only) */
+  skipValidateCheckpointAttestations?: boolean;
 };
 
 export const ArchiverSpecificConfigSchema = z.object({
@@ -68,9 +68,9 @@ export const ArchiverSpecificConfigSchema = z.object({
   viemPollingIntervalMS: schemas.Integer.optional(),
   maxLogs: schemas.Integer.optional(),
   archiverStoreMapSizeKb: schemas.Integer.optional(),
-  skipValidateBlockAttestations: z.boolean().optional(),
   maxAllowedEthClientDriftSeconds: schemas.Integer.optional(),
   ethereumAllowNoDebugHosts: z.boolean().optional(),
+  skipValidateCheckpointAttestations: z.boolean().optional(),
 });
 
 export type ArchiverApi = Omit<
@@ -89,6 +89,10 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
     .args(z.union([BlockNumberSchema, z.literal('latest')]))
     .returns(BlockHeader.schema.optional()),
   getCheckpointedBlock: z.function().args(BlockNumberSchema).returns(CheckpointedL2Block.schema.optional()),
+  getCheckpointedBlocks: z
+    .function()
+    .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
+    .returns(z.array(CheckpointedL2Block.schema)),
   getBlocks: z
     .function()
     .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
@@ -101,6 +105,10 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
     .function()
     .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
     .returns(z.array(PublishedL2Block.schema)),
+  getL2BlocksNew: z
+    .function()
+    .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
+    .returns(z.array(L2BlockNew.schema)),
   getPublishedBlockByHash: z.function().args(schemas.Fr).returns(PublishedL2Block.schema.optional()),
   getPublishedBlockByArchive: z.function().args(schemas.Fr).returns(PublishedL2Block.schema.optional()),
   getBlockHeaderByHash: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
@@ -144,5 +152,5 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getL1Timestamp: z.function().args().returns(schemas.BigInt.optional()),
   syncImmediate: z.function().args().returns(z.void()),
   isPendingChainInvalid: z.function().args().returns(z.boolean()),
-  getPendingChainValidationStatus: z.function().args().returns(ValidateBlockResultSchema),
+  getPendingChainValidationStatus: z.function().args().returns(ValidateCheckpointResultSchema),
 };

package/src/interfaces/aztec-node-admin.ts

@@ -56,7 +56,10 @@ export type AztecNodeAdminConfig = ValidatorClientFullConfig &
   SequencerConfig &
   ProverConfig &
   SlasherConfig &
-  Pick<ArchiverSpecificConfig, 'archiverPollingIntervalMS' | 'skipValidateBlockAttestations' | 'archiverBatchSize'> & {
+  Pick<
+    ArchiverSpecificConfig,
+    'archiverPollingIntervalMS' | 'archiverBatchSize' | 'skipValidateCheckpointAttestations'
+  > & {
     maxPendingTxCount: number;
   };
 
@@ -66,8 +69,8 @@ export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConf
   .merge(
     ArchiverSpecificConfigSchema.pick({
       archiverPollingIntervalMS: true,
-      skipValidateBlockAttestations: true,
       archiverBatchSize: true,
+      skipValidateCheckpointAttestations: true,
     }),
   )
   .merge(z.object({ maxPendingTxCount: z.number() }));

package/src/interfaces/aztec-node.ts

@@ -10,6 +10,7 @@ import {
   BlockNumber,
   BlockNumberPositiveSchema,
   BlockNumberSchema,
+  CheckpointNumberPositiveSchema,
   EpochNumber,
   EpochNumberSchema,
   type SlotNumber,
@@ -23,10 +24,12 @@ import { z } from 'zod';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import { type BlockParameter, BlockParameterSchema } from '../block/block_parameter.js';
-import { PublishedL2Block } from '../block/checkpointed_l2_block.js';
+import { CheckpointedL2Block, PublishedL2Block } from '../block/checkpointed_l2_block.js';
 import { type DataInBlock, dataInBlockSchemaFor } from '../block/in_block.js';
 import { L2Block } from '../block/l2_block.js';
+import { L2BlockNew } from '../block/l2_block_new.js';
 import { type L2BlockSource, type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
+import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import {
   type ContractClassPublic,
   ContractClassPublicSchema,
@@ -59,7 +62,7 @@ import { SingleValidatorStatsSchema, ValidatorsStatsSchema } from '../validators
 import type { SingleValidatorStats, ValidatorsStats } from '../validators/types.js';
 import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
 import { type AllowedElement, AllowedElementSchema } from './allowed_element.js';
-import { MAX_RPC_BLOCKS_LEN, MAX_RPC_LEN, MAX_RPC_TXS_LEN } from './api_limit.js';
+import { MAX_RPC_BLOCKS_LEN, MAX_RPC_CHECKPOINTS_LEN, MAX_RPC_LEN, MAX_RPC_TXS_LEN } from './api_limit.js';
 import {
   type GetContractClassLogsResponse,
   GetContractClassLogsResponseSchema,
@@ -73,7 +76,16 @@ import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_s
  * We will probably implement the additional interfaces by means other than Aztec Node as it's currently a privacy leak
  */
 export interface AztecNode
-  extends Pick<L2BlockSource, 'getBlocks' | 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'> {
+  extends Pick<
+    L2BlockSource,
+    | 'getBlocks'
+    | 'getL2BlocksNew'
+    | 'getPublishedBlocks'
+    | 'getPublishedCheckpoints'
+    | 'getBlockHeader'
+    | 'getL2Tips'
+    | 'getCheckpointedBlocks'
+  > {
   /**
    * Returns the tips of the L2 chain.
    */
@@ -582,6 +594,21 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
     .args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN))
     .returns(z.array(PublishedL2Block.schema)),
 
+  getPublishedCheckpoints: z
+    .function()
+    .args(CheckpointNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_CHECKPOINTS_LEN))
+    .returns(z.array(PublishedCheckpoint.schema)),
+
+  getL2BlocksNew: z
+    .function()
+    .args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN))
+    .returns(z.array(L2BlockNew.schema)),
+
+  getCheckpointedBlocks: z
+    .function()
+    .args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN), optional(z.boolean()))
+    .returns(z.array(CheckpointedL2Block.schema)),
+
   getCurrentMinFees: z.function().returns(GasFees.schema),
 
   getMaxPriorityFees: z.function().returns(GasFees.schema),

package/src/interfaces/block-builder.ts

@@ -80,6 +80,7 @@ export interface IFullNodeBlockBuilder {
   buildBlock(
     txs: Iterable<Tx> | AsyncIterable<Tx>,
     l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
     globalVariables: GlobalVariables,
     options: PublicProcessorLimits,
     fork?: MerkleTreeWriteOperations,

package/src/interfaces/configs.ts

@@ -67,6 +67,10 @@ export interface SequencerConfig {
   blockDurationMs?: number;
   /** Have sequencer build and publish an empty checkpoint if there are no txs */
   buildCheckpointIfEmpty?: boolean;
+
+  // TODO(palla/mbps): Change default to false once block sync is stable
+  /** Skip pushing proposed blocks to archiver (default: true) */
+  skipPushProposedBlocksToArchiver?: boolean;
 }
 
 export const SequencerConfigSchema = zodFor<SequencerConfig>()(
@@ -100,6 +104,7 @@ export const SequencerConfigSchema = zodFor<SequencerConfig>()(
     shuffleAttestationOrdering: z.boolean().optional(),
     blockDurationMs: z.number().positive().optional(),
     buildCheckpointIfEmpty: z.boolean().optional(),
+    skipPushProposedBlocksToArchiver: z.boolean().optional(),
   }),
 );
 

package/src/interfaces/p2p.ts

@@ -2,7 +2,7 @@ import type { SlotNumber } from '@aztec/foundation/branded-types';
 
 import { z } from 'zod';
 
-import { BlockAttestation } from '../p2p/block_attestation.js';
+import { CheckpointAttestation } from '../p2p/checkpoint_attestation.js';
 import type { P2PClientType } from '../p2p/client_type.js';
 import { type ApiSchemaFor, optional, schemas } from '../schemas/index.js';
 import { Tx } from '../tx/tx.js';
@@ -52,21 +52,18 @@ export interface P2PApiWithoutAttestations {
 
 export interface P2PApiWithAttestations extends P2PApiWithoutAttestations {
   /**
-   * Queries the Attestation pool for attestations for the given slot
+   * Queries the Attestation pool for checkpoint attestations for the given slot
    *
    * @param slot - the slot to query
    * @param proposalId - the proposal id to query, or undefined to query all proposals for the slot
-   * @returns BlockAttestations
+   * @returns CheckpointAttestations
    */
-  getAttestationsForSlot(slot: SlotNumber, proposalId?: string): Promise<BlockAttestation[]>;
-
-  /** Deletes a given attestation manually from the p2p client attestation pool. */
-  deleteAttestation(attestation: BlockAttestation): Promise<void>;
+  getCheckpointAttestationsForSlot(slot: SlotNumber, proposalId?: string): Promise<CheckpointAttestation[]>;
 }
 
 export interface P2PClient extends P2PApiWithAttestations {
-  /** Manually adds an attestation to the p2p client attestation pool. */
-  addAttestations(attestations: BlockAttestation[]): Promise<void>;
+  /** Manually adds checkpoint attestations to the p2p client attestation pool. */
+  addCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void>;
 }
 
 export type P2PApi<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
@@ -78,10 +75,10 @@ export type P2PApiFull<T extends P2PClientType = P2PClientType.Full> = T extends
   : P2PApiWithoutAttestations;
 
 export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
-  getAttestationsForSlot: z
+  getCheckpointAttestationsForSlot: z
     .function()
     .args(schemas.SlotNumber, optional(z.string()))
-    .returns(z.array(BlockAttestation.schema)),
+    .returns(z.array(CheckpointAttestation.schema)),
   getPendingTxs: z
     .function()
     .args(optional(z.number().gte(1).lte(MAX_RPC_TXS_LEN).default(MAX_RPC_TXS_LEN)), optional(TxHash.schema))
@@ -90,5 +87,4 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
   getPendingTxCount: z.function().returns(schemas.Integer),
   getEncodedEnr: z.function().returns(z.string().optional()),
   getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
-  deleteAttestation: z.function().args(BlockAttestation.schema).returns(z.void()),
 };