@aztec/sequencer-client 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/sequencer/checkpoint_voter.ts

@@ -0,0 +1,105 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import type { SlasherClientInterface } from '@aztec/slasher';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import type { ResolvedSequencerConfig } from '@aztec/stdlib/interfaces/server';
+import type { ValidatorClient } from '@aztec/validator-client';
+
+import type { TypedDataDefinition } from 'viem';
+
+import type { SequencerPublisher } from '../publisher/sequencer-publisher.js';
+import type { SequencerMetrics } from './metrics.js';
+import type { SequencerRollupConstants } from './types.js';
+
+/**
+ * Handles governance and slashing voting for a given slot.
+ */
+export class CheckpointVoter {
+  private slotTimestamp: bigint;
+  private signer: (msg: TypedDataDefinition) => Promise<`0x${string}`>;
+
+  constructor(
+    private readonly slot: SlotNumber,
+    private readonly publisher: SequencerPublisher,
+    private readonly attestorAddress: EthAddress,
+    private readonly validatorClient: ValidatorClient,
+    private readonly slasherClient: SlasherClientInterface | undefined,
+    private readonly l1Constants: SequencerRollupConstants,
+    private readonly config: ResolvedSequencerConfig,
+    private readonly metrics: SequencerMetrics,
+    private readonly log: Logger,
+  ) {
+    this.slotTimestamp = getTimestampForSlot(this.slot, this.l1Constants);
+    this.signer = (msg: TypedDataDefinition) =>
+      this.validatorClient.signWithAddress(this.attestorAddress, msg).then(s => s.toString());
+  }
+
+  /**
+   * Enqueues governance and slashing votes with the publisher.
+   * Returns a tuple of promises that resolve to whether each vote was successfully enqueued.
+   */
+  enqueueVotes(): [Promise<boolean | undefined>, Promise<boolean | undefined>] {
+    try {
+      const enqueueGovernancePromise = this.enqueueGovernanceVote();
+      const enqueueSlashingPromise = this.enqueueSlashingVote();
+
+      return [enqueueGovernancePromise, enqueueSlashingPromise];
+    } catch (err) {
+      this.log.error(`Error enqueueing governance and slashing votes`, err);
+      return [Promise.resolve(false), Promise.resolve(false)];
+    }
+  }
+
+  private async enqueueGovernanceVote(): Promise<boolean | undefined> {
+    const governanceProposerPayload = this.config.governanceProposerPayload;
+    if (!governanceProposerPayload || governanceProposerPayload.isZero()) {
+      return undefined;
+    }
+
+    this.log.info(`Enqueuing vote for ${governanceProposerPayload} governance for slot ${this.slot}`, {
+      slot: this.slot,
+      governanceProposerPayload: governanceProposerPayload.toString(),
+    });
+
+    try {
+      return await this.publisher.enqueueGovernanceCastSignal(
+        governanceProposerPayload,
+        this.slot,
+        this.slotTimestamp,
+        this.attestorAddress,
+        this.signer,
+      );
+    } catch (err) {
+      this.log.error(`Error enqueuing governance vote`, err, { slot: this.slot });
+      return false;
+    }
+  }
+
+  private async enqueueSlashingVote(): Promise<boolean | undefined> {
+    try {
+      const actions = await this.slasherClient?.getProposerActions(this.slot);
+      if (!actions || actions.length === 0) {
+        return undefined;
+      }
+
+      this.log.info(`Enqueuing vote for ${actions.length} slashing actions for slot ${this.slot}`, {
+        slot: this.slot,
+        actionCount: actions.length,
+      });
+
+      this.metrics.recordSlashingAttempt(actions.length);
+
+      return await this.publisher.enqueueSlashingActions(
+        actions,
+        this.slot,
+        this.slotTimestamp,
+        this.attestorAddress,
+        this.signer,
+      );
+    } catch (err) {
+      this.log.error(`Error enqueuing slashing vote`, err, { slot: this.slot });
+      return false;
+    }
+  }
+}

package/src/sequencer/config.ts

@@ -1,4 +1,5 @@
-import type { GovernanceProposerContract, RollupContract } from '@aztec/ethereum';
+import type { GovernanceProposerContract } from '@aztec/ethereum/contracts';
+import type { RollupContract } from '@aztec/ethereum/contracts/rollup';
 
 export { type SequencerConfig } from '@aztec/stdlib/config';
 

package/src/sequencer/errors.ts

@@ -0,0 +1,21 @@
+import type { SequencerState } from './utils.js';
+
+export class SequencerTooSlowError extends Error {
+  constructor(
+    public readonly proposedState: SequencerState,
+    public readonly maxAllowedTime: number,
+    public readonly currentTime: number,
+  ) {
+    super(
+      `Too far into slot for ${proposedState} (time into slot ${currentTime}s greater than ${maxAllowedTime}s allowance)`,
+    );
+    this.name = 'SequencerTooSlowError';
+  }
+}
+
+export class SequencerInterruptedError extends Error {
+  constructor() {
+    super(`Sequencer was interrupted`);
+    this.name = 'SequencerInterruptedError';
+  }
+}

package/src/sequencer/events.ts

@@ -0,0 +1,27 @@
+import type { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+
+import type { Action } from '../publisher/sequencer-publisher.js';
+import type { SequencerState } from './utils.js';
+
+export type SequencerEvents = {
+  ['state-changed']: (args: {
+    oldState: SequencerState;
+    newState: SequencerState;
+    secondsIntoSlot?: number;
+    slot?: SlotNumber;
+  }) => void;
+  ['proposer-rollup-check-failed']: (args: { reason: string; slot: SlotNumber }) => void;
+  ['block-tx-count-check-failed']: (args: { minTxs: number; availableTxs: number; slot: SlotNumber }) => void;
+  ['block-build-failed']: (args: { reason: string; slot: SlotNumber }) => void;
+  ['block-proposed']: (args: { blockNumber: BlockNumber; slot: SlotNumber }) => void;
+  ['checkpoint-empty']: (args: { slot: SlotNumber }) => void;
+  ['checkpoint-publish-failed']: (args: {
+    slot: SlotNumber;
+    successfulActions?: Action[];
+    failedActions?: Action[];
+    sentActions?: Action[];
+    expiredActions?: Action[];
+  }) => void;
+  ['checkpoint-published']: (args: { checkpoint: CheckpointNumber; slot: SlotNumber }) => void;
+  ['checkpoint-error']: (args: { error: Error }) => void;
+};

package/src/sequencer/index.ts

@@ -1,3 +1,7 @@
 export * from './block_builder.js';
+export * from './checkpoint_builder.js';
+export * from './checkpoint_proposal_job.js';
+export * from './checkpoint_voter.js';
 export * from './config.js';
+export * from './events.js';
 export * from './sequencer.js';

package/src/sequencer/metrics.ts

@@ -1,23 +1,24 @@
-import type { EthAddress } from '@aztec/aztec.js';
-import type { RollupContract } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1FeeAnalysisResult } from '@aztec/ethereum/l1-fee-analysis';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import {
   Attributes,
-  type BatchObservableResult,
   type Gauge,
   type Histogram,
   type Meter,
   Metrics,
-  type ObservableGauge,
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
   ValueType,
 } from '@aztec/telemetry-client';
 
-import { formatUnits } from 'viem';
+import { type Hex, formatUnits } from 'viem';
 
-import { type SequencerState, type SequencerStateCallback, sequencerStateToNumber } from './utils.js';
+import type { SequencerState } from './utils.js';
 
+// TODO(palla/mbps): Review all metrics and add any missing ones per checkpoint
 export class SequencerMetrics {
   public readonly tracer: Tracer;
   private meter: Meter;
@@ -26,9 +27,6 @@ export class SequencerMetrics {
   private blockBuildDuration: Histogram;
   private blockBuildManaPerSecond: Gauge;
   private stateTransitionBufferDuration: Histogram;
-  private currentBlockNumber: Gauge;
-  private currentBlockSize: Gauge;
-  private blockBuilderInsertions: Histogram;
 
   // these are gauges because for individual sequencers building a block is not something that happens often enough to warrant a histogram
   private timeToCollectAttestations: Gauge;
@@ -36,18 +34,34 @@ export class SequencerMetrics {
   private requiredAttestions: Gauge;
   private collectedAttestions: Gauge;
 
-  private rewards: ObservableGauge;
+  private rewards: Gauge;
 
   private slots: UpDownCounter;
   private filledSlots: UpDownCounter;
-  private missedSlots: UpDownCounter;
 
-  private lastSeenSlot?: bigint;
+  private blockProposalFailed: UpDownCounter;
+  private blockProposalSuccess: UpDownCounter;
+  private blockProposalPrecheckFailed: UpDownCounter;
+  private checkpointSuccess: UpDownCounter;
+  private slashingAttempts: UpDownCounter;
+  private blockAttestationDelay: Histogram;
+
+  // Fisherman fee analysis metrics
+  private fishermanWouldBeIncluded: UpDownCounter;
+  private fishermanTimeBeforeBlock: Histogram;
+  private fishermanPendingBlobTxCount: Histogram;
+  private fishermanIncludedBlobTxCount: Histogram;
+  private fishermanCalculatedPriorityFee: Histogram;
+  private fishermanPriorityFeeDelta: Histogram;
+  private fishermanEstimatedCost: Histogram;
+  private fishermanEstimatedOverpayment: Histogram;
+  private fishermanMinedBlobTxPriorityFee: Histogram;
+  private fishermanMinedBlobTxTotalCost: Histogram;
+
+  private lastSeenSlot?: SlotNumber;
 
   constructor(
     client: TelemetryClient,
-    getState: SequencerStateCallback,
-    private coinbase: EthAddress,
     private rollup: RollupContract,
     name = 'Sequencer',
   ) {
@@ -78,35 +92,13 @@ export class SequencerMetrics {
       },
     );
 
-    const currentState = this.meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_STATE, {
-      description: 'Current state of the sequencer',
-    });
-
-    currentState.addCallback(observer => {
-      observer.observe(sequencerStateToNumber(getState()));
-    });
-
-    this.currentBlockNumber = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_NUMBER, {
-      description: 'Current block number',
-      valueType: ValueType.INT,
-    });
-
-    this.currentBlockSize = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_SIZE, {
-      description: 'Current block size',
-      valueType: ValueType.INT,
-    });
-
-    this.blockBuilderInsertions = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_INSERTION_TIME, {
-      description: 'Timer for tree insertions performed by the block builder',
-      unit: 'us',
+    this.blockAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_ATTESTATION_DELAY, {
+      unit: 'ms',
+      description: 'The time difference between block proposal and minimal attestation count reached,',
       valueType: ValueType.INT,
     });
 
     // Init gauges and counters
-    this.setCurrentBlock(0, 0);
-    this.blockCounter.add(0, {
-      [Attributes.STATUS]: 'cancelled',
-    });
     this.blockCounter.add(0, {
       [Attributes.STATUS]: 'failed',
     });
@@ -114,7 +106,7 @@ export class SequencerMetrics {
       [Attributes.STATUS]: 'built',
     });
 
-    this.rewards = this.meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS, {
+    this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS, {
       valueType: ValueType.DOUBLE,
       description: 'The rewards earned',
     });
@@ -124,16 +116,15 @@ export class SequencerMetrics {
       description: 'The number of slots this sequencer was selected for',
     });
 
+    /**
+     * NOTE: we do not track missed slots as a separate metric. That would be difficult to determine
+     * Instead, use a computed metric, `slots - filledSlots` to get the number of slots a sequencer has missed.
+     */
     this.filledSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_FILLED_SLOT_COUNT, {
       valueType: ValueType.INT,
       description: 'The number of slots this sequencer has filled',
     });
 
-    this.missedSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_MISSED_SLOT_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of slots this sequencer has missed to fill',
-    });
-
     this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION, {
       description: 'The time spent collecting attestations from committee members',
       unit: 'ms',
@@ -158,29 +149,111 @@ export class SequencerMetrics {
       valueType: ValueType.INT,
       description: 'The minimum number of attestations required to publish a block',
     });
-  }
 
-  public setCoinbase(coinbase: EthAddress) {
-    this.coinbase = coinbase;
-  }
+    this.blockProposalFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The number of times block proposal failed (including validation builds)',
+    });
 
-  public start() {
-    this.meter.addBatchObservableCallback(this.observe, [this.rewards]);
-  }
+    this.blockProposalSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The number of times block proposal succeeded (including validation builds)',
+    });
 
-  public stop() {
-    this.meter.removeBatchObservableCallback(this.observe, [this.rewards]);
-  }
+    this.checkpointSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The number of times checkpoint publishing succeeded',
+    });
 
-  private observe = async (observer: BatchObservableResult): Promise<void> => {
-    let rewards = 0n;
-    rewards = await this.rollup.getSequencerRewards(this.coinbase);
+    this.blockProposalPrecheckFailed = this.meter.createUpDownCounter(
+      Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT,
+      {
+        valueType: ValueType.INT,
+        description: 'The number of times block proposal pre-build checks failed',
+      },
+    );
 
-    const fmt = parseFloat(formatUnits(rewards, 18));
-    observer.observe(this.rewards, fmt, {
-      [Attributes.COINBASE]: this.coinbase.toString(),
+    this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The number of slashing action attempts',
     });
-  };
+
+    // Fisherman fee analysis metrics
+    this.fishermanWouldBeIncluded = this.meter.createUpDownCounter(Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED, {
+      valueType: ValueType.INT,
+      description: 'Whether the transaction would have been included in the block',
+    });
+
+    this.fishermanTimeBeforeBlock = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_TIME_BEFORE_BLOCK, {
+      unit: 'ms',
+      description: 'Time in ms between fee analysis and block being mined',
+      valueType: ValueType.INT,
+    });
+
+    this.fishermanPendingBlobTxCount = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_TX_COUNT,
+      {
+        description: 'Number of blob transactions seen in the pending block',
+        valueType: ValueType.INT,
+      },
+    );
+
+    this.fishermanIncludedBlobTxCount = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_INCLUDED_BLOB_TX_COUNT,
+      {
+        description: 'Number of blob transactions that got included in the mined block',
+        valueType: ValueType.INT,
+      },
+    );
+
+    this.fishermanCalculatedPriorityFee = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_CALCULATED_PRIORITY_FEE,
+      {
+        unit: 'gwei',
+        description: 'Priority fee calculated by each strategy',
+        valueType: ValueType.DOUBLE,
+      },
+    );
+
+    this.fishermanPriorityFeeDelta = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PRIORITY_FEE_DELTA, {
+      unit: 'gwei',
+      description: 'Difference between our priority fee and minimum included priority fee',
+      valueType: ValueType.DOUBLE,
+    });
+
+    this.fishermanEstimatedCost = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_COST, {
+      unit: 'eth',
+      description: 'Estimated total cost in ETH for the transaction with this strategy',
+      valueType: ValueType.DOUBLE,
+    });
+
+    this.fishermanEstimatedOverpayment = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_OVERPAYMENT,
+      {
+        unit: 'eth',
+        description: 'Estimated overpayment in ETH vs minimum required for inclusion',
+        valueType: ValueType.DOUBLE,
+      },
+    );
+
+    this.fishermanMinedBlobTxPriorityFee = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_PRIORITY_FEE,
+      {
+        unit: 'gwei',
+        description: 'Priority fee per gas for blob transactions in mined blocks',
+        valueType: ValueType.DOUBLE,
+      },
+    );
+
+    this.fishermanMinedBlobTxTotalCost = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_TOTAL_COST,
+      {
+        unit: 'eth',
+        description: 'Total cost in ETH for blob transactions in mined blocks',
+        valueType: ValueType.DOUBLE,
+      },
+    );
+  }
 
   public recordRequiredAttestations(requiredAttestationsCount: number, allowanceMs: number) {
     this.requiredAttestions.record(requiredAttestationsCount);
@@ -191,22 +264,15 @@ export class SequencerMetrics {
     this.timeToCollectAttestations.record(0);
   }
 
+  public recordBlockAttestationDelay(duration: number) {
+    this.blockAttestationDelay.record(duration);
+  }
+
   public recordCollectedAttestations(count: number, durationMs: number) {
     this.collectedAttestions.record(count);
     this.timeToCollectAttestations.record(Math.ceil(durationMs));
   }
 
-  recordBlockBuilderTreeInsertions(timeUs: number) {
-    this.blockBuilderInsertions.record(Math.ceil(timeUs));
-  }
-
-  recordCancelledBlock() {
-    this.blockCounter.add(1, {
-      [Attributes.STATUS]: 'cancelled',
-    });
-    this.setCurrentBlock(0, 0);
-  }
-
   recordBuiltBlock(buildDurationMs: number, totalMana: number) {
     this.blockCounter.add(1, {
       [Attributes.STATUS]: 'built',
@@ -219,11 +285,6 @@ export class SequencerMetrics {
     this.blockCounter.add(1, {
       [Attributes.STATUS]: 'failed',
     });
-    this.setCurrentBlock(0, 0);
-  }
-
-  recordNewBlock(blockNumber: number, txCount: number) {
-    this.setCurrentBlock(blockNumber, txCount);
   }
 
   recordStateTransitionBufferMs(durationMs: number, state: SequencerState) {
@@ -232,36 +293,150 @@ export class SequencerMetrics {
     });
   }
 
-  observeSlotChange(slot: bigint | undefined, proposer: string) {
+  incOpenSlot(slot: SlotNumber, proposer: string) {
     // sequencer went through the loop a second time. Noop
     if (slot === this.lastSeenSlot) {
       return;
     }
 
-    if (typeof this.lastSeenSlot === 'bigint') {
-      this.missedSlots.add(1, {
-        [Attributes.BLOCK_PROPOSER]: proposer,
-      });
-    }
-
-    if (typeof slot === 'bigint') {
-      this.slots.add(1, {
-        [Attributes.BLOCK_PROPOSER]: proposer,
-      });
-    }
+    this.slots.add(1, {
+      [Attributes.BLOCK_PROPOSER]: proposer,
+    });
 
     this.lastSeenSlot = slot;
   }
 
-  incFilledSlot(proposer: string) {
+  async incFilledSlot(proposer: string, coinbase: Hex | EthAddress | undefined): Promise<void> {
     this.filledSlots.add(1, {
       [Attributes.BLOCK_PROPOSER]: proposer,
     });
     this.lastSeenSlot = undefined;
+
+    if (coinbase) {
+      try {
+        const rewards = await this.rollup.getSequencerRewards(coinbase);
+        const fmt = parseFloat(formatUnits(rewards, 18));
+        this.rewards.record(fmt, {
+          [Attributes.COINBASE]: coinbase.toString(),
+        });
+      } catch {
+        // no-op
+      }
+    }
   }
 
-  private setCurrentBlock(blockNumber: number, txCount: number) {
-    this.currentBlockNumber.record(blockNumber);
-    this.currentBlockSize.record(txCount);
+  recordCheckpointSuccess() {
+    this.checkpointSuccess.add(1);
+  }
+
+  recordBlockProposalFailed(reason?: string) {
+    this.blockProposalFailed.add(1, {
+      ...(reason && { [Attributes.ERROR_TYPE]: reason }),
+    });
+  }
+
+  recordBlockProposalSuccess() {
+    this.blockProposalSuccess.add(1);
+  }
+
+  recordBlockProposalPrecheckFailed(checkType: string) {
+    this.blockProposalPrecheckFailed.add(1, {
+      [Attributes.ERROR_TYPE]: checkType,
+    });
+  }
+
+  recordSlashingAttempt(actionCount: number) {
+    this.slashingAttempts.add(actionCount);
+  }
+
+  /**
+   * Records metrics for a completed fisherman fee analysis
+   * @param analysis - The completed fee analysis result
+   */
+  recordFishermanFeeAnalysis(analysis: L1FeeAnalysisResult) {
+    // In fisherman mode, we should always have strategy results
+    if (!analysis.computedPrices.strategyResults || analysis.computedPrices.strategyResults.length === 0) {
+      // This should never happen in fisherman mode - log an error
+      // We don't record metrics without strategy IDs as that defeats the purpose
+      throw new Error(
+        `No strategy results found in fisherman fee analysis ${analysis.id}. This indicates a bug in the fee analysis.`,
+      );
+    }
+
+    // Record metrics for each strategy separately
+    for (const strategyResult of analysis.computedPrices.strategyResults) {
+      const strategyAttributes = {
+        [Attributes.FISHERMAN_FEE_STRATEGY_ID]: strategyResult.strategyId,
+      };
+
+      // Record pending block snapshot data (once per strategy for comparison)
+      this.fishermanPendingBlobTxCount.record(analysis.pendingSnapshot.pendingBlobTxCount, strategyAttributes);
+
+      // Record mined block data if available
+      if (analysis.minedBlock) {
+        this.fishermanIncludedBlobTxCount.record(analysis.minedBlock.includedBlobTxCount, strategyAttributes);
+
+        // Record actual fees from blob transactions in the mined block
+        for (const blobTx of analysis.minedBlock.includedBlobTxs) {
+          // Record priority fee per gas in Gwei
+          const priorityFeeGwei = Number(blobTx.maxPriorityFeePerGas) / 1e9;
+          this.fishermanMinedBlobTxPriorityFee.record(priorityFeeGwei, strategyAttributes);
+
+          // Calculate total cost in ETH
+          // Cost = (gas * (baseFee + priorityFee)) + (blobCount * blobGasPerBlob * blobBaseFee)
+          const baseFee = analysis.minedBlock.baseFeePerGas;
+          const effectiveGasPrice = baseFee + blobTx.maxPriorityFeePerGas;
+
+          // Calculate execution cost using actual gas limit from the transaction
+          const executionCost = blobTx.gas * effectiveGasPrice;
+
+          // Calculate blob cost using maxFeePerBlobGas * blobCount * GAS_PER_BLOB
+          const blobCost = blobTx.maxFeePerBlobGas * BigInt(blobTx.blobCount) * 131072n; // 128KB per blob
+
+          const totalCostWei = executionCost + blobCost;
+          const totalCostEth = Number(totalCostWei) / 1e18;
+
+          this.fishermanMinedBlobTxTotalCost.record(totalCostEth, strategyAttributes);
+        }
+      }
+
+      // Record the calculated priority fee for this strategy
+      const calculatedPriorityFeeGwei = Number(strategyResult.calculatedPriorityFee) / 1e9;
+      this.fishermanCalculatedPriorityFee.record(calculatedPriorityFeeGwei, strategyAttributes);
+
+      // Record analysis results if available
+      if (analysis.analysis) {
+        this.fishermanTimeBeforeBlock.record(Math.ceil(analysis.analysis.timeBeforeBlockMs), strategyAttributes);
+
+        // Record strategy-specific inclusion result
+        if (strategyResult.wouldBeIncluded !== undefined) {
+          if (strategyResult.wouldBeIncluded) {
+            this.fishermanWouldBeIncluded.add(1, { ...strategyAttributes, [Attributes.OK]: true });
+          } else {
+            this.fishermanWouldBeIncluded.add(1, {
+              ...strategyAttributes,
+              [Attributes.OK]: false,
+              ...(strategyResult.exclusionReason && { [Attributes.ERROR_TYPE]: strategyResult.exclusionReason }),
+            });
+          }
+        }
+
+        // Record strategy-specific priority fee delta
+        if (strategyResult.priorityFeeDelta !== undefined) {
+          const priorityFeeDeltaGwei = Number(strategyResult.priorityFeeDelta) / 1e9;
+          this.fishermanPriorityFeeDelta.record(priorityFeeDeltaGwei, strategyAttributes);
+        }
+
+        // Record estimated cost if available
+        if (strategyResult.estimatedCostEth !== undefined) {
+          this.fishermanEstimatedCost.record(strategyResult.estimatedCostEth, strategyAttributes);
+        }
+
+        // Record estimated overpayment if available
+        if (strategyResult.estimatedOverpaymentEth !== undefined) {
+          this.fishermanEstimatedOverpayment.record(strategyResult.estimatedOverpaymentEth, strategyAttributes);
+        }
+      }
+    }
   }
 }