@aztec/validator-client 0.0.1-commit.b1c78909e → 0.0.1-commit.b2a5d0dd1

package/src/{block_proposal_handler.ts → proposal_handler.ts}

@@ -1,20 +1,30 @@
+import type { Archiver } from '@aztec/archiver';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { type Blob, encodeCheckpointBlobDataFromBlocks, getBlobsPerL1Block } from '@aztec/blob-lib';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import type { EpochCache } from '@aztec/epoch-cache';
+import { validateFeeAssetPriceModifier } from '@aztec/ethereum/contracts';
 import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { pick } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { TimeoutError } from '@aztec/foundation/error';
+import type { LogData } from '@aztec/foundation/log';
 import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import type { P2P, PeerId } from '@aztec/p2p';
 import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
 import type { BlockData, L2Block, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import { validateCheckpoint } from '@aztec/stdlib/checkpoint';
 import { getEpochAtSlot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import type { ITxProvider, ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
-import type { BlockProposal } from '@aztec/stdlib/p2p';
+import {
+  type L1ToL2MessageSource,
+  accumulateCheckpointOutHashes,
+  computeInHashFromL1ToL2Messages,
+} from '@aztec/stdlib/messaging';
+import type { BlockProposal, CheckpointAttestation, CheckpointProposalCore } from '@aztec/stdlib/p2p';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { CheckpointGlobalVariables, FailedTx, Tx } from '@aztec/stdlib/tx';
 import {
@@ -66,13 +76,31 @@ export type BlockProposalValidationFailureResult = {
 
 export type BlockProposalValidationResult = BlockProposalValidationSuccessResult | BlockProposalValidationFailureResult;
 
+export type CheckpointProposalValidationResult =
+  | { isValid: true; checkpointNumber: CheckpointNumber }
+  | { isValid: false; reason: string };
+
 type CheckpointComputationResult =
   | { checkpointNumber: CheckpointNumber; reason?: undefined }
   | { checkpointNumber?: undefined; reason: 'invalid_proposal' | 'global_variables_mismatch' };
 
-export class BlockProposalHandler {
+/** Handles block and checkpoint proposals for both validator and non-validator nodes. */
+export class ProposalHandler {
   public readonly tracer: Tracer;
 
+  /** Cached last checkpoint validation result to avoid double-validation on validator nodes. */
+  private lastCheckpointValidationResult?: {
+    archive: Fr;
+    slotNumber: SlotNumber;
+    result: CheckpointProposalValidationResult;
+  };
+
+  /** Archiver reference for setting proposed checkpoints (pipelining). Set via register(). */
+  private archiver?: Pick<Archiver, 'setProposedCheckpoint' | 'getL1Constants'>;
+
+  /** Returns current validator addresses for own-proposal detection. Set via register(). */
+  private getOwnValidatorAddresses?: () => string[];
+
   constructor(
     private checkpointsBuilder: FullNodeCheckpointsBuilder,
     private worldState: WorldStateSynchronizer,
@@ -82,21 +110,37 @@ export class BlockProposalHandler {
     private blockProposalValidator: BlockProposalValidator,
     private epochCache: EpochCache,
     private config: ValidatorClientFullConfig,
+    private blobClient: BlobClientInterface,
     private metrics?: ValidatorMetrics,
     private dateProvider: DateProvider = new DateProvider(),
     telemetry: TelemetryClient = getTelemetryClient(),
-    private log = createLogger('validator:block-proposal-handler'),
+    private log = createLogger('validator:proposal-handler'),
   ) {
     if (config.fishermanMode) {
       this.log = this.log.createChild('[FISHERMAN]');
     }
-    this.tracer = telemetry.getTracer('BlockProposalHandler');
+    this.tracer = telemetry.getTracer('ProposalHandler');
   }
 
-  register(p2pClient: P2P, shouldReexecute: boolean): BlockProposalHandler {
+  /**
+   * Registers handlers for block and checkpoint proposals on the p2p client.
+   * Block proposals are registered for non-validator nodes (validators register their own enhanced handler).
+   * The all-nodes checkpoint proposal handler is always registered for validation, caching, and pipelining.
+   * @param archiver - Archiver reference for setting proposed checkpoints (pipelining)
+   * @param getOwnValidatorAddresses - Returns current validator addresses for own-proposal detection
+   */
+  register(
+    p2pClient: P2P,
+    shouldReexecute: boolean,
+    archiver?: Pick<Archiver, 'setProposedCheckpoint' | 'getL1Constants'>,
+    getOwnValidatorAddresses?: () => string[],
+  ): ProposalHandler {
+    this.archiver = archiver;
+    this.getOwnValidatorAddresses = getOwnValidatorAddresses;
+
     // Non-validator handler that processes or re-executes for monitoring but does not attest.
     // Returns boolean indicating whether the proposal was valid.
-    const handler = async (proposal: BlockProposal, proposalSender: PeerId): Promise<boolean> => {
+    const blockHandler = async (proposal: BlockProposal, proposalSender: PeerId): Promise<boolean> => {
       try {
         const { slotNumber, blockNumber } = proposal;
         const result = await this.handleBlockProposal(proposal, proposalSender, shouldReexecute);
@@ -123,7 +167,51 @@ export class BlockProposalHandler {
       }
     };
 
-    p2pClient.registerBlockProposalHandler(handler);
+    p2pClient.registerBlockProposalHandler(blockHandler);
+
+    // All-nodes checkpoint proposal handler: validates, caches, and sets proposed checkpoint for pipelining.
+    // Runs for all nodes (validators and non-validators). Validators get the cached result in the
+    // validator-specific callback (attestToCheckpointProposal) which runs after this one.
+    const checkpointHandler = async (
+      proposal: CheckpointProposalCore,
+      _sender: PeerId,
+    ): Promise<CheckpointAttestation[] | undefined> => {
+      try {
+        const pipeliningTimer = new Timer();
+        const proposalInfo: LogData = {
+          slot: proposal.slotNumber,
+          archive: proposal.archive.toString(),
+          proposer: proposal.getSender()?.toString(),
+        };
+
+        // For own proposals, skip validation — the proposer already built and validated the checkpoint
+        const proposer = proposal.getSender();
+        const ownAddresses = this.getOwnValidatorAddresses?.();
+        const isOwnProposal = proposer && ownAddresses?.some(addr => addr === proposer.toString());
+
+        if (isOwnProposal) {
+          this.log.debug(`Skipping validation for own checkpoint proposal at slot ${proposal.slotNumber}`);
+          if (this.archiver && this.epochCache.isProposerPipeliningEnabled()) {
+            await this.setProposedCheckpointFromBlocks(proposal);
+          }
+          return undefined;
+        }
+
+        const result = await this.handleCheckpointProposal(proposal, proposalInfo);
+        if (result.isValid && this.archiver && this.epochCache.isProposerPipeliningEnabled()) {
+          const set = await this.setProposedCheckpointFromValidation(proposal);
+          if (set) {
+            this.metrics?.recordCheckpointProposalToPipelinedStateDuration(pipeliningTimer.ms());
+          }
+        }
+      } catch (err) {
+        this.log.warn(`Error handling checkpoint proposal for slot ${proposal.slotNumber}`, { err });
+      }
+      return undefined;
+    };
+
+    p2pClient.registerAllNodesCheckpointProposalHandler(checkpointHandler);
+
     return this;
   }
 
@@ -163,14 +251,18 @@ export class BlockProposalHandler {
     }
 
     // Ensure the block source is synced before checking for existing blocks,
-    // since a pending checkpoint prune may remove blocks we'd otherwise find.
+    // since a proposed checkpoint prune may remove blocks we'd otherwise find.
     // This affects mostly the block_number_already_exists check, since a pending
     // checkpoint prune could remove a block that would conflict with this proposal.
-    // TODO(@Maddiaa0): This may break staggered slots.
-    const blockSourceSync = await this.waitForBlockSourceSync(slotNumber);
-    if (!blockSourceSync) {
-      this.log.warn(`Block source is not synced, skipping processing`, proposalInfo);
-      return { isValid: false, reason: 'block_source_not_synced' };
+    // When pipelining is enabled, the proposer builds ahead of L1 submission, so the
+    // block source won't have synced to the proposed slot yet. Skip the sync wait to
+    // avoid eating into the attestation window.
+    if (!this.epochCache.isProposerPipeliningEnabled()) {
+      const blockSourceSync = await this.waitForBlockSourceSync(slotNumber);
+      if (!blockSourceSync) {
+        this.log.warn(`Block source is not synced, skipping processing`, proposalInfo);
+        return { isValid: false, reason: 'block_source_not_synced' };
+      }
     }
 
     // Check that the parent proposal is a block we know, otherwise reexecution would fail.
@@ -275,7 +367,7 @@ export class BlockProposalHandler {
 
     // If we succeeded, push this block into the archiver (unless disabled)
     if (reexecutionResult?.block && this.config.skipPushProposedBlocksToArchiver === false) {
-      await this.blockSource.addBlock(reexecutionResult?.block);
+      await this.blockSource.addBlock(reexecutionResult.block);
     }
 
     this.log.info(
@@ -288,7 +380,6 @@ export class BlockProposalHandler {
 
   private async getParentBlock(proposal: BlockProposal): Promise<'genesis' | BlockData | undefined> {
     const parentArchive = proposal.blockHeader.lastArchive.root;
-    const slot = proposal.slotNumber;
     const config = this.checkpointsBuilder.getConfig();
     const { genesisArchiveRoot } = await this.blockSource.getGenesisValues();
 
@@ -296,7 +387,7 @@ export class BlockProposalHandler {
       return 'genesis';
     }
 
-    const deadline = this.getReexecutionDeadline(slot, config);
+    const deadline = this.getReexecutionDeadline(proposal.slotNumber, config);
     const currentTime = this.dateProvider.now();
     const timeoutDurationMs = deadline.getTime() - currentTime;
 
@@ -445,8 +536,14 @@ export class BlockProposalHandler {
     return undefined;
   }
 
-  private getReexecutionDeadline(slot: SlotNumber, config: { l1GenesisTime: bigint; slotDuration: number }): Date {
-    const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(slot + 1), config));
+  private getReexecutionDeadline(
+    slotNumber: SlotNumber,
+    config: { l1GenesisTime: bigint; slotDuration: number },
+  ): Date {
+    // Under proposer pipelining, the proposal slot may be ahead of wall clock time.
+    // Reexecution budgets should still be bounded by the current slot we are in now.
+    const wallclockSlot = slotNumber - this.epochCache.pipeliningOffset();
+    const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(wallclockSlot + 1), config));
     return new Date(nextSlotTimestampSeconds * 1000);
   }
 
@@ -459,8 +556,9 @@ export class BlockProposalHandler {
     }
 
     // Make a quick check before triggering an archiver sync
+    // If we are pipelining and have a pending checkpoint number stored, we will allow the block proposal to be for a slot further
     const syncedSlot = await this.blockSource.getSyncedL2SlotNumber();
-    if (syncedSlot !== undefined && syncedSlot + 1 >= slot) {
+    if (syncedSlot !== undefined && syncedSlot + 1 + this.epochCache.pipeliningOffset() >= slot) {
       return true;
     }
 
@@ -469,8 +567,8 @@ export class BlockProposalHandler {
       return await retryUntil(
         async () => {
           await this.blockSource.syncImmediate();
-          const syncedSlot = await this.blockSource.getSyncedL2SlotNumber();
-          return syncedSlot !== undefined && syncedSlot + 1 >= slot;
+          const updatedSyncedSlot = await this.blockSource.getSyncedL2SlotNumber();
+          return updatedSyncedSlot !== undefined && updatedSyncedSlot + 1 >= slot;
         },
         'wait for block source sync',
         timeoutMs / 1000,
@@ -487,7 +585,9 @@ export class BlockProposalHandler {
   }
 
   private getReexecuteFailureReason(err: any): BlockProposalValidationFailureReason {
-    if (err instanceof ReExInitialStateMismatchError) {
+    if (err instanceof TransactionsNotAvailableError) {
+      return 'txs_not_available';
+    } else if (err instanceof ReExInitialStateMismatchError) {
       return 'initial_state_mismatch';
     } else if (err instanceof ReExStateMismatchError) {
       return 'state_mismatch';
@@ -567,6 +667,8 @@ export class BlockProposalHandler {
         ? new Gas(this.config.validateMaxDABlockGas ?? Infinity, this.config.validateMaxL2BlockGas ?? Infinity)
         : undefined;
     const result = await checkpointBuilder.buildBlock(txs, blockNumber, blockHeader.globalVariables.timestamp, {
+      isBuildingProposal: false,
+      minValidTxs: 0,
       deadline,
       expectedEndState: blockHeader.state,
       maxTransactions: this.config.validateMaxTxsPerBlock,
@@ -621,4 +723,320 @@ export class BlockProposalHandler {
       totalManaUsed,
     };
   }
+
+  /**
+   * Validates a checkpoint proposal, caches the result, and uploads blobs if configured.
+   * Returns a cached result if the same proposal (archive + slot) was already validated.
+   * Used by both the all-nodes callback (via register) and the validator client (via delegation).
+   */
+  async handleCheckpointProposal(
+    proposal: CheckpointProposalCore,
+    proposalInfo: LogData,
+  ): Promise<CheckpointProposalValidationResult> {
+    const slot = proposal.slotNumber;
+
+    // Check cache: same archive+slot means we already validated this proposal
+    if (
+      this.lastCheckpointValidationResult &&
+      this.lastCheckpointValidationResult.archive.equals(proposal.archive) &&
+      this.lastCheckpointValidationResult.slotNumber === slot
+    ) {
+      this.log.debug(`Returning cached validation result for checkpoint proposal at slot ${slot}`, proposalInfo);
+      return this.lastCheckpointValidationResult.result;
+    }
+
+    const proposer = proposal.getSender();
+    if (!proposer) {
+      this.log.warn(`Received checkpoint proposal with invalid signature for slot ${proposal.slotNumber}`);
+      const result: CheckpointProposalValidationResult = { isValid: false, reason: 'invalid_signature' };
+      this.lastCheckpointValidationResult = { archive: proposal.archive, slotNumber: slot, result };
+      return result;
+    }
+
+    if (!validateFeeAssetPriceModifier(proposal.feeAssetPriceModifier)) {
+      this.log.warn(
+        `Received checkpoint proposal with invalid feeAssetPriceModifier ${proposal.feeAssetPriceModifier} for slot ${proposal.slotNumber}`,
+      );
+      const result: CheckpointProposalValidationResult = { isValid: false, reason: 'invalid_fee_asset_price_modifier' };
+      this.lastCheckpointValidationResult = { archive: proposal.archive, slotNumber: slot, result };
+      return result;
+    }
+
+    const result = await this.validateCheckpointProposal(proposal, proposalInfo);
+    this.lastCheckpointValidationResult = { archive: proposal.archive, slotNumber: slot, result };
+
+    // Upload blobs to filestore if validation passed (fire and forget)
+    if (result.isValid) {
+      this.tryUploadBlobsForCheckpoint(proposal, proposalInfo);
+    }
+
+    return result;
+  }
+
+  /**
+   * Validates a checkpoint proposal by building the full checkpoint and comparing it with the proposal.
+   * @returns Validation result with isValid flag and reason if invalid.
+   */
+  async validateCheckpointProposal(
+    proposal: CheckpointProposalCore,
+    proposalInfo: LogData,
+  ): Promise<CheckpointProposalValidationResult> {
+    const slot = proposal.slotNumber;
+
+    // Timeout block syncing at the start of the next slot
+    const config = this.checkpointsBuilder.getConfig();
+    const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(slot + 1), config));
+    const timeoutSeconds = Math.max(1, nextSlotTimestampSeconds - Math.floor(this.dateProvider.now() / 1000));
+
+    // Wait for last block to sync by archive
+    let lastBlockHeader;
+    try {
+      lastBlockHeader = await retryUntil(
+        async () => {
+          await this.blockSource.syncImmediate();
+          return this.blockSource.getBlockHeaderByArchive(proposal.archive);
+        },
+        `waiting for block with archive ${proposal.archive.toString()} for slot ${slot}`,
+        timeoutSeconds,
+        0.5,
+      );
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        this.log.warn(`Timed out waiting for block with archive matching checkpoint proposal`, proposalInfo);
+        return { isValid: false, reason: 'last_block_not_found' };
+      }
+      this.log.error(`Error fetching last block for checkpoint proposal`, err, proposalInfo);
+      return { isValid: false, reason: 'block_fetch_error' };
+    }
+
+    if (!lastBlockHeader) {
+      this.log.warn(`Last block not found for checkpoint proposal`, proposalInfo);
+      return { isValid: false, reason: 'last_block_not_found' };
+    }
+
+    // Get all full blocks for the slot and checkpoint
+    const blocks = await this.blockSource.getBlocksForSlot(slot);
+    if (blocks.length === 0) {
+      this.log.warn(`No blocks found for slot ${slot}`, proposalInfo);
+      return { isValid: false, reason: 'no_blocks_for_slot' };
+    }
+
+    // Ensure the last block for this slot matches the archive in the checkpoint proposal
+    if (!blocks.at(-1)?.archive.root.equals(proposal.archive)) {
+      this.log.warn(`Last block archive mismatch for checkpoint proposal`, proposalInfo);
+      return { isValid: false, reason: 'last_block_archive_mismatch' };
+    }
+
+    this.log.debug(`Found ${blocks.length} blocks for slot ${slot}`, {
+      ...proposalInfo,
+      blockNumbers: blocks.map(b => b.number),
+    });
+
+    // Get checkpoint constants from first block
+    const firstBlock = blocks[0];
+    const constants = this.extractCheckpointConstants(firstBlock);
+    const checkpointNumber = firstBlock.checkpointNumber;
+
+    // Get L1-to-L2 messages for this checkpoint
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
+
+    // Collect the out hashes of all the checkpoints before this one in the same epoch
+    const epoch = getEpochAtSlot(slot, this.epochCache.getL1Constants());
+    const previousCheckpointOutHashes = (await this.blockSource.getCheckpointsDataForEpoch(epoch))
+      .filter(c => c.checkpointNumber < checkpointNumber)
+      .map(c => c.checkpointOutHash);
+
+    // Fork world state at the block before the first block
+    const parentBlockNumber = BlockNumber(firstBlock.number - 1);
+    await using fork = await this.checkpointsBuilder.getFork(parentBlockNumber);
+
+    // Create checkpoint builder with all existing blocks
+    const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(
+      checkpointNumber,
+      constants,
+      proposal.feeAssetPriceModifier,
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      fork,
+      blocks,
+      this.log.getBindings(),
+    );
+
+    // Complete the checkpoint to get computed values
+    const computedCheckpoint = await checkpointBuilder.completeCheckpoint();
+
+    // Compare checkpoint header with proposal
+    if (!computedCheckpoint.header.equals(proposal.checkpointHeader)) {
+      this.log.warn(`Checkpoint header mismatch`, {
+        ...proposalInfo,
+        computed: computedCheckpoint.header.toInspect(),
+        proposal: proposal.checkpointHeader.toInspect(),
+      });
+      return { isValid: false, reason: 'checkpoint_header_mismatch' };
+    }
+
+    // Compare archive root with proposal
+    if (!computedCheckpoint.archive.root.equals(proposal.archive)) {
+      this.log.warn(`Archive root mismatch`, {
+        ...proposalInfo,
+        computed: computedCheckpoint.archive.root.toString(),
+        proposal: proposal.archive.toString(),
+      });
+      return { isValid: false, reason: 'archive_mismatch' };
+    }
+
+    // Check that the accumulated epoch out hash matches the value in the proposal.
+    // The epoch out hash is the accumulated hash of all checkpoint out hashes in the epoch.
+    const checkpointOutHash = computedCheckpoint.getCheckpointOutHash();
+    const computedEpochOutHash = accumulateCheckpointOutHashes([...previousCheckpointOutHashes, checkpointOutHash]);
+    const proposalEpochOutHash = proposal.checkpointHeader.epochOutHash;
+    if (!computedEpochOutHash.equals(proposalEpochOutHash)) {
+      this.log.warn(`Epoch out hash mismatch`, {
+        proposalEpochOutHash: proposalEpochOutHash.toString(),
+        computedEpochOutHash: computedEpochOutHash.toString(),
+        checkpointOutHash: checkpointOutHash.toString(),
+        previousCheckpointOutHashes: previousCheckpointOutHashes.map(h => h.toString()),
+        ...proposalInfo,
+      });
+      return { isValid: false, reason: 'out_hash_mismatch' };
+    }
+
+    // Final round of validations on the checkpoint, just in case.
+    try {
+      validateCheckpoint(computedCheckpoint, {
+        rollupManaLimit: this.checkpointsBuilder.getConfig().rollupManaLimit,
+        maxDABlockGas: this.config.validateMaxDABlockGas,
+        maxL2BlockGas: this.config.validateMaxL2BlockGas,
+        maxTxsPerBlock: this.config.validateMaxTxsPerBlock,
+        maxTxsPerCheckpoint: this.config.validateMaxTxsPerCheckpoint,
+      });
+    } catch (err) {
+      this.log.warn(`Checkpoint validation failed: ${err}`, proposalInfo);
+      return { isValid: false, reason: 'checkpoint_validation_failed' };
+    }
+
+    this.log.verbose(`Checkpoint proposal validation successful for slot ${slot}`, proposalInfo);
+    return { isValid: true, checkpointNumber };
+  }
+
+  /** Extracts checkpoint global variables from a block. */
+  private extractCheckpointConstants(block: L2Block): CheckpointGlobalVariables {
+    const gv = block.header.globalVariables;
+    return {
+      chainId: gv.chainId,
+      version: gv.version,
+      slotNumber: gv.slotNumber,
+      timestamp: gv.timestamp,
+      coinbase: gv.coinbase,
+      feeRecipient: gv.feeRecipient,
+      gasFees: gv.gasFees,
+    };
+  }
+
+  /** Triggers blob upload for a checkpoint if the blob client can upload (fire and forget). */
+  protected tryUploadBlobsForCheckpoint(proposal: CheckpointProposalCore, proposalInfo: LogData): void {
+    if (this.blobClient.canUpload()) {
+      void this.uploadBlobsForCheckpoint(proposal, proposalInfo);
+    }
+  }
+
+  /** Uploads blobs for a checkpoint to the filestore. */
+  protected async uploadBlobsForCheckpoint(proposal: CheckpointProposalCore, proposalInfo: LogData): Promise<void> {
+    try {
+      const lastBlockHeader = await this.blockSource.getBlockHeaderByArchive(proposal.archive);
+      if (!lastBlockHeader) {
+        this.log.warn(`Failed to get last block header for blob upload`, proposalInfo);
+        return;
+      }
+
+      const blocks = await this.blockSource.getBlocksForSlot(proposal.slotNumber);
+      if (blocks.length === 0) {
+        this.log.warn(`No blocks found for blob upload`, proposalInfo);
+        return;
+      }
+
+      const blockBlobData = blocks.map(b => b.toBlockBlobData());
+      const blobFields = encodeCheckpointBlobDataFromBlocks(blockBlobData);
+      const blobs: Blob[] = await getBlobsPerL1Block(blobFields);
+      await this.blobClient.sendBlobsToFilestore(blobs);
+      this.log.debug(`Uploaded ${blobs.length} blobs to filestore for checkpoint at slot ${proposal.slotNumber}`, {
+        ...proposalInfo,
+        numBlobs: blobs.length,
+      });
+    } catch (err) {
+      this.log.warn(`Failed to upload blobs for checkpoint: ${err}`, proposalInfo);
+    }
+  }
+
+  /**
+   * Derives proposed checkpoint data from validated blocks and sets it on the archiver.
+   * Used after successful validation of a foreign proposal.
+   * Does not retry since we already waited for the block during validation.
+   */
+  private async setProposedCheckpointFromValidation(proposal: CheckpointProposalCore): Promise<boolean> {
+    if (!this.archiver) {
+      return false;
+    }
+    const blockData = await this.blockSource.getBlockDataByArchive(proposal.archive);
+    if (!blockData) {
+      this.log.debug(`Block data not found for checkpoint proposal archive, cannot set proposed checkpoint`, {
+        archive: proposal.archive.toString(),
+      });
+      return false;
+    }
+
+    await this.archiver.setProposedCheckpoint({
+      header: proposal.checkpointHeader,
+      checkpointNumber: blockData.checkpointNumber,
+      startBlock: BlockNumber(blockData.header.getBlockNumber() - blockData.indexWithinCheckpoint),
+      blockCount: blockData.indexWithinCheckpoint + 1,
+      totalManaUsed: proposal.checkpointHeader.totalManaUsed.toBigInt(),
+      feeAssetPriceModifier: proposal.feeAssetPriceModifier,
+    });
+    return true;
+  }
+
+  /**
+   * Sets proposed checkpoint from blocks for own proposals (skips full validation).
+   * Retries fetching block data since the checkpoint proposal often arrives before the last block
+   * finishes re-execution.
+   */
+  private async setProposedCheckpointFromBlocks(proposal: CheckpointProposalCore): Promise<boolean> {
+    if (!this.archiver) {
+      return false;
+    }
+    let blockData = await this.blockSource.getBlockDataByArchive(proposal.archive);
+
+    if (!blockData) {
+      // The checkpoint proposal often arrives before the last block finishes re-execution.
+      // Retry until we find the data or give up at the end of the slot.
+      const nextSlot = this.epochCache.getSlotNow() + 1;
+      const timeOfNextSlot = getTimestampForSlot(SlotNumber(nextSlot), await this.archiver.getL1Constants());
+      const timeoutSeconds = Math.max(1, Number(timeOfNextSlot) - Math.floor(this.dateProvider.now() / 1000));
+
+      blockData = await retryUntil(
+        () => this.blockSource.getBlockDataByArchive(proposal.archive),
+        'block data for own checkpoint proposal',
+        timeoutSeconds,
+        0.25,
+      ).catch(() => undefined);
+    }
+
+    if (blockData) {
+      await this.archiver.setProposedCheckpoint({
+        header: proposal.checkpointHeader,
+        checkpointNumber: blockData.checkpointNumber,
+        startBlock: BlockNumber(blockData.header.getBlockNumber() - blockData.indexWithinCheckpoint),
+        blockCount: blockData.indexWithinCheckpoint + 1,
+        totalManaUsed: proposal.checkpointHeader.totalManaUsed.toBigInt(),
+        feeAssetPriceModifier: proposal.feeAssetPriceModifier,
+      });
+      return true;
+    } else {
+      this.log.debug(`Block data not found for own checkpoint proposal archive, cannot set proposed checkpoint`, {
+        archive: proposal.archive.toString(),
+      });
+      return false;
+    }
+  }
 }