@aztec/sequencer-client 0.0.1-commit.f504929 → 0.0.1-commit.f81dbcf

package/src/publisher/sequencer-publisher.ts

@@ -30,7 +30,6 @@ import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
 import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { pick } from '@aztec/foundation/collection';
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import { TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature, type ViemSignature } from '@aztec/foundation/eth-signature';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -46,19 +45,9 @@ import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { L1PublishCheckpointStats } from '@aztec/stdlib/stats';
 import { type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import {
-  type Hex,
-  type StateOverride,
-  type TransactionReceipt,
-  type TypedDataDefinition,
-  encodeFunctionData,
-  keccak256,
-  multicall3Abi,
-  toHex,
-} from 'viem';
+import { type StateOverride, type TransactionReceipt, type TypedDataDefinition, encodeFunctionData, toHex } from 'viem';
 
 import type { SequencerPublisherConfig } from './config.js';
-import { type FailedL1Tx, type L1TxFailedStore, createL1TxFailedStore } from './l1_tx_failed_store/index.js';
 import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
 
 /** Arguments to the process method of the rollup contract */
@@ -120,7 +109,6 @@ export class SequencerPublisher {
   private interrupted = false;
   private metrics: SequencerPublisherMetrics;
   public epochCache: EpochCache;
-  private failedTxStore?: Promise<L1TxFailedStore | undefined>;
 
   protected governanceLog = createLogger('sequencer:publisher:governance');
   protected slashingLog = createLogger('sequencer:publisher:slashing');
@@ -138,9 +126,6 @@ export class SequencerPublisher {
   /** Address to use for simulations in fisherman mode (actual proposer's address) */
   private proposerAddressForSimulation?: EthAddress;
 
-  /** Optional callback to obtain a replacement publisher when the current one fails to send. */
-  private getNextPublisher?: (excludeAddresses: EthAddress[]) => Promise<L1TxUtils | undefined>;
-
   /** L1 fee analyzer for fisherman mode */
   private l1FeeAnalyzer?: L1FeeAnalyzer;
 
@@ -164,7 +149,7 @@ export class SequencerPublisher {
   protected requests: RequestWithExpiry[] = [];
 
   constructor(
-    private config: Pick<SequencerPublisherConfig, 'fishermanMode' | 'l1TxFailedStore'> &
+    private config: Pick<SequencerPublisherConfig, 'fishermanMode'> &
       Pick<L1ContractsConfig, 'ethereumSlotDuration'> & { l1ChainId: number },
     deps: {
       telemetry?: TelemetryClient;
@@ -179,7 +164,6 @@ export class SequencerPublisher {
       metrics: SequencerPublisherMetrics;
       lastActions: Partial<Record<Action, SlotNumber>>;
       log?: Logger;
-      getNextPublisher?: (excludeAddresses: EthAddress[]) => Promise<L1TxUtils | undefined>;
     },
   ) {
     this.log = deps.log ?? createLogger('sequencer:publisher');
@@ -193,7 +177,6 @@ export class SequencerPublisher {
     this.metrics = deps.metrics ?? new SequencerPublisherMetrics(telemetry, 'SequencerPublisher');
     this.tracer = telemetry.getTracer('SequencerPublisher');
     this.l1TxUtils = deps.l1TxUtils;
-    this.getNextPublisher = deps.getNextPublisher;
 
     this.rollupContract = deps.rollupContract;
 
@@ -222,31 +205,6 @@ export class SequencerPublisher {
       this.rollupContract,
       createLogger('sequencer:publisher:price-oracle'),
     );
-
-    // Initialize failed L1 tx store (optional, for test networks)
-    this.failedTxStore = createL1TxFailedStore(config.l1TxFailedStore, this.log);
-  }
-
-  /**
-   * Backs up a failed L1 transaction to the configured store for debugging.
-   * Does nothing if no store is configured.
-   */
-  private backupFailedTx(failedTx: Omit<FailedL1Tx, 'timestamp'>): void {
-    if (!this.failedTxStore) {
-      return;
-    }
-
-    const tx: FailedL1Tx = {
-      ...failedTx,
-      timestamp: Date.now(),
-    };
-
-    // Fire and forget - don't block on backup
-    void this.failedTxStore
-      .then(store => store?.saveFailedTx(tx))
-      .catch(err => {
-        this.log.warn(`Failed to backup failed L1 tx to store`, err);
-      });
   }
 
   public getRollupContract(): RollupContract {
@@ -428,36 +386,19 @@ export class SequencerPublisher {
     validRequests.sort((a, b) => compareActions(a.action, b.action));
 
     try {
-      // Capture context for failed tx backup before sending
-      const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-      const multicallData = encodeFunctionData({
-        abi: multicall3Abi,
-        functionName: 'aggregate3',
-        args: [
-          validRequests.map(r => ({
-            target: r.request.to!,
-            callData: r.request.data!,
-            allowFailure: true,
-          })),
-        ],
-      });
-      const blobDataHex = blobConfig?.blobs?.map(b => toHex(b)) as Hex[] | undefined;
-
-      const txContext = { multicallData, blobData: blobDataHex, l1BlockNumber };
-
       this.log.debug('Forwarding transactions', {
         validRequests: validRequests.map(request => request.action),
         txConfig,
       });
-      const result = await this.forwardWithPublisherRotation(validRequests, txConfig, blobConfig);
-      if (result === undefined) {
-        return undefined;
-      }
-      const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(
-        validRequests,
-        result,
-        txContext,
+      const result = await Multicall3.forward(
+        validRequests.map(request => request.request),
+        this.l1TxUtils,
+        txConfig,
+        blobConfig,
+        this.rollupContract.address,
+        this.log,
       );
+      const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(validRequests, result);
       return { result, expiredActions, sentActions: validActions, successfulActions, failedActions };
     } catch (err) {
       const viemError = formatViemError(err);
@@ -475,76 +416,13 @@ export class SequencerPublisher {
     }
   }
 
-  /**
-   * Forwards transactions via Multicall3, rotating to the next available publisher if a send
-   * failure occurs (i.e. the tx never reached the chain).
-   * On-chain reverts and simulation errors are returned as-is without rotation.
-   */
-  private async forwardWithPublisherRotation(
-    validRequests: RequestWithExpiry[],
-    txConfig: RequestWithExpiry['gasConfig'],
-    blobConfig: L1BlobInputs | undefined,
-  ) {
-    const triedAddresses: EthAddress[] = [];
-    let currentPublisher = this.l1TxUtils;
-
-    while (true) {
-      triedAddresses.push(currentPublisher.getSenderAddress());
-      try {
-        const result = await Multicall3.forward(
-          validRequests.map(r => r.request),
-          currentPublisher,
-          txConfig,
-          blobConfig,
-          this.rollupContract.address,
-          this.log,
-        );
-        this.l1TxUtils = currentPublisher;
-        return result;
-      } catch (err) {
-        if (err instanceof TimeoutError) {
-          throw err;
-        }
-        const viemError = formatViemError(err);
-        if (!this.getNextPublisher) {
-          this.log.error('Failed to publish bundled transactions', viemError);
-          return undefined;
-        }
-        this.log.warn(
-          `Publisher ${currentPublisher.getSenderAddress()} failed to send, rotating to next publisher`,
-          viemError,
-        );
-        const nextPublisher = await this.getNextPublisher([...triedAddresses]);
-        if (!nextPublisher) {
-          this.log.error('All available publishers exhausted, failed to publish bundled transactions');
-          return undefined;
-        }
-        currentPublisher = nextPublisher;
-      }
-    }
-  }
-
   private callbackBundledTransactions(
     requests: RequestWithExpiry[],
-    result: { receipt: TransactionReceipt; errorMsg?: string } | FormattedViemError | undefined,
-    txContext: { multicallData: Hex; blobData?: Hex[]; l1BlockNumber: bigint },
+    result?: { receipt: TransactionReceipt } | FormattedViemError,
   ) {
     const actionsListStr = requests.map(r => r.action).join(', ');
     if (result instanceof FormattedViemError) {
       this.log.error(`Failed to publish bundled transactions (${actionsListStr})`, result);
-      this.backupFailedTx({
-        id: keccak256(txContext.multicallData),
-        failureType: 'send-error',
-        request: { to: MULTI_CALL_3_ADDRESS, data: txContext.multicallData },
-        blobData: txContext.blobData,
-        l1BlockNumber: txContext.l1BlockNumber.toString(),
-        error: { message: result.message, name: result.name },
-        context: {
-          actions: requests.map(r => r.action),
-          requests: requests.map(r => ({ action: r.action, to: r.request.to! as Hex, data: r.request.data! })),
-          sender: this.getSenderAddress().toString(),
-        },
-      });
       return { failedActions: requests.map(r => r.action) };
     } else {
       this.log.verbose(`Published bundled transactions (${actionsListStr})`, { result, requests });
@@ -557,30 +435,6 @@ export class SequencerPublisher {
           failedActions.push(request.action);
         }
       }
-      // Single backup for the whole reverted tx
-      if (failedActions.length > 0 && result?.receipt?.status === 'reverted') {
-        this.backupFailedTx({
-          id: result.receipt.transactionHash,
-          failureType: 'revert',
-          request: { to: MULTI_CALL_3_ADDRESS, data: txContext.multicallData },
-          blobData: txContext.blobData,
-          l1BlockNumber: result.receipt.blockNumber.toString(),
-          receipt: {
-            transactionHash: result.receipt.transactionHash,
-            blockNumber: result.receipt.blockNumber.toString(),
-            gasUsed: (result.receipt.gasUsed ?? 0n).toString(),
-            status: 'reverted',
-          },
-          error: { message: result.errorMsg ?? 'Transaction reverted' },
-          context: {
-            actions: failedActions,
-            requests: requests
-              .filter(r => failedActions.includes(r.action))
-              .map(r => ({ action: r.action, to: r.request.to! as Hex, data: r.request.data! })),
-            sender: this.getSenderAddress().toString(),
-          },
-        });
-      }
       return { successfulActions, failedActions };
     }
   }
@@ -692,8 +546,6 @@ export class SequencerPublisher {
     const request = this.buildInvalidateCheckpointRequest(validationResult);
     this.log.debug(`Simulating invalidate checkpoint ${checkpointNumber}`, { ...logData, request });
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     try {
       const { gasUsed } = await this.l1TxUtils.simulate(
         request,
@@ -745,18 +597,6 @@ export class SequencerPublisher {
 
       // Otherwise, throw. We cannot build the next checkpoint if we cannot invalidate the previous one.
       this.log.error(`Simulation for invalidate checkpoint ${checkpointNumber} failed`, viemError, logData);
-      this.backupFailedTx({
-        id: keccak256(request.data!),
-        failureType: 'simulation',
-        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
-        l1BlockNumber: l1BlockNumber.toString(),
-        error: { message: viemError.message, name: viemError.name },
-        context: {
-          actions: [`invalidate-${reason}`],
-          checkpointNumber,
-          sender: this.getSenderAddress().toString(),
-        },
-      });
       throw new Error(`Failed to simulate invalidate checkpoint ${checkpointNumber}`, { cause: viemError });
     }
   }
@@ -904,26 +744,11 @@ export class SequencerPublisher {
       lastValidL2Slot: slotNumber,
     });
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     try {
       await this.l1TxUtils.simulate(request, { time: timestamp }, [], mergeAbis([request.abi ?? [], ErrorsAbi]));
       this.log.debug(`Simulation for ${action} at slot ${slotNumber} succeeded`, { request });
     } catch (err) {
-      const viemError = formatViemError(err);
-      this.log.error(`Failed simulation for ${action} at slot ${slotNumber} (enqueuing the action anyway)`, viemError);
-      this.backupFailedTx({
-        id: keccak256(request.data!),
-        failureType: 'simulation',
-        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
-        l1BlockNumber: l1BlockNumber.toString(),
-        error: { message: viemError.message, name: viemError.name },
-        context: {
-          actions: [action],
-          slot: slotNumber,
-          sender: this.getSenderAddress().toString(),
-        },
-      });
+      this.log.error(`Failed simulation for ${action} at slot ${slotNumber} (enqueuing the action anyway)`, err);
       // Yes, we enqueue the request anyway, in case there was a bug with the simulation itself
     }
 
@@ -1219,8 +1044,6 @@ export class SequencerPublisher {
 
     this.log.debug(`Simulating ${action} for slot ${slotNumber}`, logData);
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     let gasUsed: bigint;
     const simulateAbi = mergeAbis([request.abi ?? [], ErrorsAbi]);
     try {
@@ -1230,19 +1053,6 @@ export class SequencerPublisher {
       const viemError = formatViemError(err, simulateAbi);
       this.log.error(`Simulation for ${action} at ${slotNumber} failed`, viemError, logData);
 
-      this.backupFailedTx({
-        id: keccak256(request.data!),
-        failureType: 'simulation',
-        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
-        l1BlockNumber: l1BlockNumber.toString(),
-        error: { message: viemError.message, name: viemError.name },
-        context: {
-          actions: [action],
-          slot: slotNumber,
-          sender: this.getSenderAddress().toString(),
-        },
-      });
-
       return false;
     }
 
@@ -1326,27 +1136,9 @@ export class SequencerPublisher {
             kzg,
           },
         )
-        .catch(async err => {
-          const viemError = formatViemError(err);
-          this.log.error(`Failed to validate blobs`, viemError.message, { metaMessages: viemError.metaMessages });
-          const validateBlobsData = encodeFunctionData({
-            abi: RollupAbi,
-            functionName: 'validateBlobs',
-            args: [blobInput],
-          });
-          const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-          this.backupFailedTx({
-            id: keccak256(validateBlobsData),
-            failureType: 'simulation',
-            request: { to: this.rollupContract.address as Hex, data: validateBlobsData },
-            blobData: encodedData.blobs.map(b => toHex(b.data)) as Hex[],
-            l1BlockNumber: l1BlockNumber.toString(),
-            error: { message: viemError.message, name: viemError.name },
-            context: {
-              actions: ['validate-blobs'],
-              sender: this.getSenderAddress().toString(),
-            },
-          });
+        .catch(err => {
+          const { message, metaMessages } = formatViemError(err);
+          this.log.error(`Failed to validate blobs`, message, { metaMessages });
           throw new Error('Failed to validate blobs');
         });
     }
@@ -1425,8 +1217,6 @@ export class SequencerPublisher {
       });
     }
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     const simulationResult = await this.l1TxUtils
       .simulate(
         {
@@ -1460,18 +1250,6 @@ export class SequencerPublisher {
           };
         }
         this.log.error(`Failed to simulate propose tx`, viemError);
-        this.backupFailedTx({
-          id: keccak256(rollupData),
-          failureType: 'simulation',
-          request: { to: this.rollupContract.address, data: rollupData },
-          l1BlockNumber: l1BlockNumber.toString(),
-          error: { message: viemError.message, name: viemError.name },
-          context: {
-            actions: ['propose'],
-            slot: Number(args[0].header.slotNumber),
-            sender: this.getSenderAddress().toString(),
-          },
-        });
         throw err;
       });
 

package/src/sequencer/checkpoint_proposal_job.ts

@@ -1,5 +1,3 @@
-import { NUM_CHECKPOINT_END_MARKER_FIELDS, getNumBlockEndBlobFields } from '@aztec/blob-lib/encoding';
-import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
 import type { EpochCache } from '@aztec/epoch-cache';
 import {
   BlockNumber,
@@ -32,11 +30,11 @@ import {
   type L2BlockSource,
   MaliciousCommitteeAttestationsAndSigners,
 } from '@aztec/stdlib/block';
-import type { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { type Checkpoint, validateCheckpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import {
-  NoValidTxsError,
+  InsufficientValidTxsError,
   type PublicProcessorLimits,
   type ResolvedSequencerConfig,
   type WorldStateSynchronizer,
@@ -267,6 +265,22 @@ export class CheckpointProposalJob implements Traceable {
       this.setStateFn(SequencerState.ASSEMBLING_CHECKPOINT, this.slot);
       const checkpoint = await checkpointBuilder.completeCheckpoint();
 
+      // Final validation round for the checkpoint before we propose it, just for safety
+      try {
+        validateCheckpoint(checkpoint, {
+          rollupManaLimit: this.l1Constants.rollupManaLimit,
+          maxL2BlockGas: this.config.maxL2BlockGas,
+          maxDABlockGas: this.config.maxDABlockGas,
+          maxTxsPerBlock: this.config.maxTxsPerBlock,
+          maxTxsPerCheckpoint: this.config.maxTxsPerCheckpoint,
+        });
+      } catch (err) {
+        this.log.error(`Built an invalid checkpoint at slot ${this.slot} (skipping proposal)`, err, {
+          checkpoint: checkpoint.header.toInspect(),
+        });
+        return undefined;
+      }
+
       // Record checkpoint-level build metrics
       this.metrics.recordCheckpointBuild(
         checkpointBuildTimer.ms(),
@@ -389,9 +403,6 @@ export class CheckpointProposalJob implements Traceable {
     const txHashesAlreadyIncluded = new Set<string>();
     const initialBlockNumber = BlockNumber(this.syncedToBlockNumber + 1);
 
-    // Remaining blob fields available for blocks (checkpoint end marker already subtracted)
-    let remainingBlobFields = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS;
-
     // Last block in the checkpoint will usually be flagged as pending broadcast, so we send it along with the checkpoint proposal
     let blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined = undefined;
 
@@ -424,7 +435,6 @@ export class CheckpointProposalJob implements Traceable {
         blockNumber,
         indexWithinCheckpoint,
         txHashesAlreadyIncluded,
-        remainingBlobFields,
       });
 
       // TODO(palla/mbps): Review these conditions. We may want to keep trying in some scenarios.
@@ -450,12 +460,9 @@ export class CheckpointProposalJob implements Traceable {
         break;
       }
 
-      const { block, usedTxs, remainingBlobFields: newRemainingBlobFields } = buildResult;
+      const { block, usedTxs } = buildResult;
       blocksInCheckpoint.push(block);
 
-      // Update remaining blob fields for the next block
-      remainingBlobFields = newRemainingBlobFields;
-
       // Sync the proposed block to the archiver to make it available
       // Note that the checkpoint builder uses its own fork so it should not need to wait for this syncing
       // Eventually we should refactor the checkpoint builder to not need a separate long-lived fork
@@ -523,18 +530,10 @@ export class CheckpointProposalJob implements Traceable {
       indexWithinCheckpoint: IndexWithinCheckpoint;
       buildDeadline: Date | undefined;
       txHashesAlreadyIncluded: Set<string>;
-      remainingBlobFields: number;
     },
-  ): Promise<{ block: L2Block; usedTxs: Tx[]; remainingBlobFields: number } | { error: Error } | undefined> {
-    const {
-      blockTimestamp,
-      forceCreate,
-      blockNumber,
-      indexWithinCheckpoint,
-      buildDeadline,
-      txHashesAlreadyIncluded,
-      remainingBlobFields,
-    } = opts;
+  ): Promise<{ block: L2Block; usedTxs: Tx[] } | { error: Error } | undefined> {
+    const { blockTimestamp, forceCreate, blockNumber, indexWithinCheckpoint, buildDeadline, txHashesAlreadyIncluded } =
+      opts;
 
     this.log.verbose(
       `Preparing block ${blockNumber} index ${indexWithinCheckpoint} at checkpoint ${this.checkpointNumber} for slot ${this.slot}`,
@@ -543,8 +542,7 @@ export class CheckpointProposalJob implements Traceable {
 
     try {
       // Wait until we have enough txs to build the block
-      const minTxs = this.config.minTxsPerBlock;
-      const { availableTxs, canStartBuilding } = await this.waitForMinTxs(opts);
+      const { availableTxs, canStartBuilding, minTxs } = await this.waitForMinTxs(opts);
       if (!canStartBuilding) {
         this.log.warn(
           `Not enough txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.slot} (got ${availableTxs} txs but needs ${minTxs})`,
@@ -568,19 +566,24 @@ export class CheckpointProposalJob implements Traceable {
       );
       this.setStateFn(SequencerState.CREATING_BLOCK, this.slot);
 
-      // Calculate blob fields limit for txs (remaining capacity - this block's end overhead)
-      const blockEndOverhead = getNumBlockEndBlobFields(indexWithinCheckpoint === 0);
-      const maxBlobFieldsForTxs = remainingBlobFields - blockEndOverhead;
-
-      const blockBuilderOptions: PublicProcessorLimits = {
+      // Per-block limits derived at startup by computeBlockLimits(), further capped
+      // by remaining checkpoint-level budgets inside CheckpointBuilder before each block is built.
+      // minValidTxs is passed into the builder so it can reject the block *before* updating state.
+      const minValidTxs = forceCreate ? 0 : (this.config.minValidTxsPerBlock ?? minTxs);
+      const blockBuilderOptions: PublicProcessorLimits & { minValidTxs?: number } = {
         maxTransactions: this.config.maxTxsPerBlock,
-        maxBlockSize: this.config.maxBlockSizeInBytes,
-        maxBlockGas: new Gas(this.config.maxDABlockGas, this.config.maxL2BlockGas),
-        maxBlobFields: maxBlobFieldsForTxs,
+        maxBlockGas:
+          this.config.maxL2BlockGas !== undefined || this.config.maxDABlockGas !== undefined
+            ? new Gas(this.config.maxDABlockGas ?? Infinity, this.config.maxL2BlockGas ?? Infinity)
+            : undefined,
         deadline: buildDeadline,
+        isBuildingProposal: true,
+        minValidTxs,
       };
 
-      // Actually build the block by executing txs
+      // Actually build the block by executing txs. The builder throws InsufficientValidTxsError
+      // if the number of successfully processed txs is below minValidTxs, ensuring state is not
+      // updated for blocks that will be discarded.
       const buildResult = await this.buildSingleBlockWithCheckpointBuilder(
         checkpointBuilder,
         pendingTxs,
@@ -592,14 +595,16 @@ export class CheckpointProposalJob implements Traceable {
       // If any txs failed during execution, drop them from the mempool so we don't pick them up again
       await this.dropFailedTxsFromP2P(buildResult.failedTxs);
 
-      // Check if we have created a block with enough txs. If there were invalid txs in the pool, or if execution took
-      // too long, then we may not get to minTxsPerBlock after executing public functions.
-      const minValidTxs = this.config.minValidTxsPerBlock ?? minTxs;
-      const numTxs = buildResult.status === 'no-valid-txs' ? 0 : buildResult.numTxs;
-      if (buildResult.status === 'no-valid-txs' || (!forceCreate && numTxs < minValidTxs)) {
+      if (buildResult.status === 'insufficient-valid-txs') {
         this.log.warn(
           `Block ${blockNumber} at index ${indexWithinCheckpoint} on slot ${this.slot} has too few valid txs to be proposed`,
-          { slot: this.slot, blockNumber, numTxs, indexWithinCheckpoint, minValidTxs, buildResult: buildResult.status },
+          {
+            slot: this.slot,
+            blockNumber,
+            numTxs: buildResult.processedCount,
+            indexWithinCheckpoint,
+            minValidTxs,
+          },
         );
         this.eventEmitter.emit('block-build-failed', { reason: `Insufficient valid txs`, slot: this.slot });
         this.metrics.recordBlockProposalFailed('insufficient_valid_txs');
@@ -607,7 +612,7 @@ export class CheckpointProposalJob implements Traceable {
       }
 
       // Block creation succeeded, emit stats and metrics
-      const { publicGas, block, publicProcessorDuration, usedTxs, usedTxBlobFields, blockBuildDuration } = buildResult;
+      const { block, publicProcessorDuration, usedTxs, blockBuildDuration, numTxs } = buildResult;
 
       const blockStats = {
         eventName: 'l2-block-built',
@@ -618,7 +623,7 @@ export class CheckpointProposalJob implements Traceable {
 
       const blockHash = await block.hash();
       const txHashes = block.body.txEffects.map(tx => tx.txHash);
-      const manaPerSec = publicGas.l2Gas / (blockBuildDuration / 1000);
+      const manaPerSec = block.header.totalManaUsed.toNumberUnsafe() / (blockBuildDuration / 1000);
 
       this.log.info(
         `Built block ${block.number} at checkpoint ${this.checkpointNumber} for slot ${this.slot} with ${numTxs} txs`,
@@ -626,9 +631,9 @@ export class CheckpointProposalJob implements Traceable {
       );
 
       this.eventEmitter.emit('block-proposed', { blockNumber: block.number, slot: this.slot });
-      this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
+      this.metrics.recordBuiltBlock(blockBuildDuration, block.header.totalManaUsed.toNumberUnsafe());
 
-      return { block, usedTxs, remainingBlobFields: maxBlobFieldsForTxs - usedTxBlobFields };
+      return { block, usedTxs };
     } catch (err: any) {
       this.eventEmitter.emit('block-build-failed', { reason: err.message, slot: this.slot });
       this.log.error(`Error building block`, err, { blockNumber, slot: this.slot });
@@ -638,13 +643,13 @@ export class CheckpointProposalJob implements Traceable {
     }
   }
 
-  /** Uses the checkpoint builder to build a block, catching specific txs */
+  /** Uses the checkpoint builder to build a block, catching InsufficientValidTxsError. */
   private async buildSingleBlockWithCheckpointBuilder(
     checkpointBuilder: CheckpointBuilder,
     pendingTxs: AsyncIterable<Tx>,
     blockNumber: BlockNumber,
     blockTimestamp: bigint,
-    blockBuilderOptions: PublicProcessorLimits,
+    blockBuilderOptions: PublicProcessorLimits & { minValidTxs?: number },
   ) {
     try {
       const workTimer = new Timer();
@@ -652,8 +657,12 @@ export class CheckpointProposalJob implements Traceable {
       const blockBuildDuration = workTimer.ms();
       return { ...result, blockBuildDuration, status: 'success' as const };
     } catch (err: unknown) {
-      if (isErrorClass(err, NoValidTxsError)) {
-        return { failedTxs: err.failedTxs, status: 'no-valid-txs' as const };
+      if (isErrorClass(err, InsufficientValidTxsError)) {
+        return {
+          failedTxs: err.failedTxs,
+          processedCount: err.processedCount,
+          status: 'insufficient-valid-txs' as const,
+        };
       }
       throw err;
     }
@@ -666,7 +675,7 @@ export class CheckpointProposalJob implements Traceable {
     blockNumber: BlockNumber;
     indexWithinCheckpoint: IndexWithinCheckpoint;
     buildDeadline: Date | undefined;
-  }): Promise<{ canStartBuilding: boolean; availableTxs: number }> {
+  }): Promise<{ canStartBuilding: boolean; availableTxs: number; minTxs: number }> {
     const { indexWithinCheckpoint, blockNumber, buildDeadline, forceCreate } = opts;
 
     // We only allow a block with 0 txs in the first block of the checkpoint
@@ -683,7 +692,7 @@ export class CheckpointProposalJob implements Traceable {
       // If we're past deadline, or we have no deadline, give up
       const now = this.dateProvider.nowAsDate();
       if (startBuildingDeadline === undefined || now >= startBuildingDeadline) {
-        return { canStartBuilding: false, availableTxs: availableTxs };
+        return { canStartBuilding: false, availableTxs, minTxs };
       }
 
       // Wait a bit before checking again
@@ -696,7 +705,7 @@ export class CheckpointProposalJob implements Traceable {
       availableTxs = await this.p2pClient.getPendingTxCount();
     }
 
-    return { canStartBuilding: true, availableTxs };
+    return { canStartBuilding: true, availableTxs, minTxs };
   }
 
   /**
@@ -834,20 +843,11 @@ export class CheckpointProposalJob implements Traceable {
       this.log.warn(`Shuffling attestation ordering in checkpoint for slot ${slotNumber} (proposer #${proposerIndex})`);
 
       const shuffled = [...attestations];
-
-      // Find two non-proposer positions that both have non-empty signatures to swap.
-      // This ensures the bitmap doesn't change, so the MaliciousCommitteeAttestationsAndSigners
-      // signers array stays correctly aligned with L1's committee reconstruction.
-      const swappable: number[] = [];
-      for (let k = 0; k < shuffled.length; k++) {
-        if (!shuffled[k].signature.isEmpty() && k !== proposerIndex) {
-          swappable.push(k);
-        }
-      }
-      if (swappable.length >= 2) {
-        const [i, j] = [swappable[0], swappable[1]];
-        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
-      }
+      const [i, j] = [(proposerIndex + 1) % shuffled.length, (proposerIndex + 2) % shuffled.length];
+      const valueI = shuffled[i];
+      const valueJ = shuffled[j];
+      shuffled[i] = valueJ;
+      shuffled[j] = valueI;
 
       const signers = new CommitteeAttestationsAndSigners(attestations).getSigners();
       return new MaliciousCommitteeAttestationsAndSigners(shuffled, signers);