@aztec/sequencer-client 0.0.1-commit.fce3e4f → 0.0.1-commit.ff7989d6c

package/src/sequencer/checkpoint_voter.ts

@@ -0,0 +1,130 @@
+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 { DutyAlreadySignedError } from '@aztec/validator-ha-signer/errors';
+import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
+
+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 governanceSigner: (msg: TypedDataDefinition) => Promise<`0x${string}`>;
+  private slashingSigner: (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);
+
+    // Create separate signers with appropriate duty contexts for governance and slashing votes
+    // These use HA protection to ensure only one node signs per slot/duty
+    const governanceContext: SigningContext = { slot: this.slot, dutyType: DutyType.GOVERNANCE_VOTE };
+    this.governanceSigner = (msg: TypedDataDefinition) =>
+      this.validatorClient.signWithAddress(this.attestorAddress, msg, governanceContext).then(s => s.toString());
+
+    const slashingContext: SigningContext = { slot: this.slot, dutyType: DutyType.SLASHING_VOTE };
+    this.slashingSigner = (msg: TypedDataDefinition) =>
+      this.validatorClient.signWithAddress(this.attestorAddress, msg, slashingContext).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.governanceSigner,
+      );
+    } catch (err) {
+      if (err instanceof DutyAlreadySignedError) {
+        this.log.info(`Governance vote already signed by another node`, {
+          slot: this.slot,
+          signedByNode: err.signedByNode,
+        });
+      } else {
+        this.log.error(`Error enqueueing governance vote`, err);
+      }
+      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.slashingSigner,
+      );
+    } catch (err) {
+      if (err instanceof DutyAlreadySignedError) {
+        this.log.info(`Slashing vote already signed by another node`, {
+          slot: this.slot,
+          signedByNode: err.signedByNode,
+        });
+      } else {
+        this.log.error(`Error enqueueing slashing vote`, err);
+      }
+      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/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,5 @@
-export * from './block_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,5 +1,6 @@
 import { EthAddress } from '@aztec/aztec.js/addresses';
-import type { RollupContract } from '@aztec/ethereum';
+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,
@@ -10,7 +11,7 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import { type Hex, formatUnits } from 'viem';
@@ -38,9 +39,32 @@ export class SequencerMetrics {
   private filledSlots: UpDownCounter;
 
   private blockProposalFailed: UpDownCounter;
-  private blockProposalSuccess: UpDownCounter;
-  private blockProposalPrecheckFailed: UpDownCounter;
+  private checkpointProposalSuccess: UpDownCounter;
+  private checkpointPrecheckFailed: UpDownCounter;
+  private checkpointProposalFailed: UpDownCounter;
+  private checkpointSuccess: UpDownCounter;
   private slashingAttempts: UpDownCounter;
+  private checkpointAttestationDelay: Histogram;
+  private checkpointBuildDuration: Histogram;
+  private checkpointBlockCount: Gauge;
+  private checkpointTxCount: Gauge;
+  private checkpointTotalMana: Gauge;
+
+  // Fisherman fee analysis metrics
+  private fishermanWouldBeIncluded: UpDownCounter;
+  private fishermanTimeBeforeBlock: Histogram;
+  private fishermanPendingBlobTxCount: Histogram;
+  private fishermanIncludedBlobTxCount: Histogram;
+  private fishermanPendingBlobCount: Histogram;
+  private fishermanIncludedBlobCount: Histogram;
+  private fishermanBlockBlobsFull: UpDownCounter;
+  private fishermanMaxBlobCapacity: Histogram;
+  private fishermanCalculatedPriorityFee: Histogram;
+  private fishermanPriorityFeeDelta: Histogram;
+  private fishermanEstimatedCost: Histogram;
+  private fishermanEstimatedOverpayment: Histogram;
+  private fishermanMinedBlobTxPriorityFee: Histogram;
+  private fishermanMinedBlobTxTotalCost: Histogram;
 
   private lastSeenSlot?: SlotNumber;
 
@@ -52,104 +76,124 @@ export class SequencerMetrics {
     this.meter = client.getMeter(name);
     this.tracer = client.getTracer(name);
 
-    this.blockCounter = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
-
-    this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
-      unit: 'ms',
-      description: 'Duration to build a block',
-      valueType: ValueType.INT,
+    this.blockCounter = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_COUNT, {
+      [Attributes.STATUS]: ['failed', 'built'],
     });
 
-    this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND, {
-      unit: 'mana/s',
-      description: 'Mana per second when building a block',
-      valueType: ValueType.INT,
-    });
+    this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION);
 
-    this.stateTransitionBufferDuration = this.meter.createHistogram(
-      Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION,
-      {
-        unit: 'ms',
-        description:
-          'The time difference between when the sequencer needed to transition to a new state and when it actually did.',
-        valueType: ValueType.INT,
-      },
-    );
+    this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND);
 
-    // Init gauges and counters
-    this.blockCounter.add(0, {
-      [Attributes.STATUS]: 'failed',
-    });
-    this.blockCounter.add(0, {
-      [Attributes.STATUS]: 'built',
-    });
+    this.stateTransitionBufferDuration = this.meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION);
 
-    this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS, {
-      valueType: ValueType.DOUBLE,
-      description: 'The rewards earned',
-    });
+    this.checkpointAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY);
 
-    this.slots = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLOT_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of slots this sequencer was selected for',
-    });
+    this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_SLOT_REWARDS);
+
+    this.slots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLOT_COUNT);
 
     /**
      * 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.filledSlots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_FILLED_SLOT_COUNT);
 
-    this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION, {
-      description: 'The time spent collecting attestations from committee members',
-      unit: 'ms',
-      valueType: ValueType.INT,
-    });
+    this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION);
+
+    this.allowanceToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_TIME_ALLOWANCE);
+
+    this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT);
+
+    this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT);
+
+    this.blockProposalFailed = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT,
+    );
 
-    this.allowanceToCollectAttestations = this.meter.createGauge(
-      Metrics.SEQUENCER_COLLECT_ATTESTATIONS_TIME_ALLOWANCE,
+    this.checkpointProposalSuccess = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_CHECKPOINT_PROPOSAL_SUCCESS_COUNT,
+    );
+
+    this.checkpointSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
+
+    this.checkpointPrecheckFailed = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_CHECKPOINT_PRECHECK_FAILED_COUNT,
       {
-        description: 'Maximum amount of time to collect attestations',
-        unit: 'ms',
-        valueType: ValueType.INT,
+        [Attributes.ERROR_TYPE]: [
+          'slot_already_taken',
+          'rollup_contract_check_failed',
+          'slot_mismatch',
+          'block_number_mismatch',
+        ],
       },
     );
 
-    this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The minimum number of attestations required to publish a block',
-    });
+    this.checkpointProposalFailed = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_CHECKPOINT_PROPOSAL_FAILED_COUNT,
+    );
 
-    this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The minimum number of attestations required to publish a block',
-    });
+    this.checkpointBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_BUILD_DURATION);
+    this.checkpointBlockCount = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_BLOCK_COUNT);
+    this.checkpointTxCount = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TX_COUNT);
+    this.checkpointTotalMana = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TOTAL_MANA);
 
-    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)',
-    });
+    this.slashingAttempts = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
 
-    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)',
-    });
+    // Fisherman fee analysis metrics
+    this.fishermanWouldBeIncluded = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED,
+      {
+        [Attributes.OK]: [true, false],
+        [Attributes.BLOCK_FULL]: ['true', 'false'],
+      },
+    );
+
+    this.fishermanTimeBeforeBlock = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_TIME_BEFORE_BLOCK);
+
+    this.fishermanPendingBlobTxCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_TX_COUNT);
+
+    this.fishermanIncludedBlobTxCount = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_INCLUDED_BLOB_TX_COUNT,
+    );
+
+    this.fishermanCalculatedPriorityFee = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_CALCULATED_PRIORITY_FEE,
+    );
+
+    this.fishermanPriorityFeeDelta = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PRIORITY_FEE_DELTA);
 
-    this.blockProposalPrecheckFailed = this.meter.createUpDownCounter(
-      Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT,
+    this.fishermanEstimatedCost = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_COST);
+
+    this.fishermanEstimatedOverpayment = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_OVERPAYMENT,
+    );
+
+    this.fishermanMinedBlobTxPriorityFee = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_PRIORITY_FEE,
+    );
+
+    this.fishermanMinedBlobTxTotalCost = this.meter.createHistogram(
+      Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_TOTAL_COST,
+    );
+
+    this.fishermanPendingBlobCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_COUNT);
+
+    this.fishermanIncludedBlobCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_INCLUDED_BLOB_COUNT);
+
+    this.fishermanBlockBlobsFull = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.FISHERMAN_FEE_ANALYSIS_BLOCK_BLOBS_FULL,
       {
-        valueType: ValueType.INT,
-        description: 'The number of times block proposal pre-build checks failed',
+        [Attributes.OK]: [true, false],
       },
     );
 
-    this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of slashing action attempts',
-    });
+    this.fishermanMaxBlobCapacity = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_MAX_BLOB_CAPACITY);
   }
 
   public recordRequiredAttestations(requiredAttestationsCount: number, allowanceMs: number) {
@@ -161,6 +205,10 @@ export class SequencerMetrics {
     this.timeToCollectAttestations.record(0);
   }
 
+  public recordCheckpointAttestationDelay(duration: number) {
+    this.checkpointAttestationDelay.record(duration);
+  }
+
   public recordCollectedAttestations(count: number, durationMs: number) {
     this.collectedAttestions.record(count);
     this.timeToCollectAttestations.record(Math.ceil(durationMs));
@@ -218,23 +266,161 @@ export class SequencerMetrics {
     }
   }
 
+  recordCheckpointSuccess() {
+    this.checkpointSuccess.add(1);
+  }
+
   recordBlockProposalFailed(reason?: string) {
     this.blockProposalFailed.add(1, {
       ...(reason && { [Attributes.ERROR_TYPE]: reason }),
     });
   }
 
-  recordBlockProposalSuccess() {
-    this.blockProposalSuccess.add(1);
+  recordCheckpointProposalSuccess() {
+    this.checkpointProposalSuccess.add(1);
   }
 
-  recordBlockProposalPrecheckFailed(checkType: string) {
-    this.blockProposalPrecheckFailed.add(1, {
-      [Attributes.ERROR_TYPE]: checkType,
+  recordCheckpointPrecheckFailed(
+    checkType: 'slot_already_taken' | 'rollup_contract_check_failed' | 'slot_mismatch' | 'block_number_mismatch',
+  ) {
+    this.checkpointPrecheckFailed.add(1, { [Attributes.ERROR_TYPE]: checkType });
+  }
+
+  recordCheckpointProposalFailed(reason?: string) {
+    this.checkpointProposalFailed.add(1, {
+      ...(reason && { [Attributes.ERROR_TYPE]: reason }),
     });
   }
 
+  /** Records aggregate metrics for a completed checkpoint build. */
+  recordCheckpointBuild(durationMs: number, blockCount: number, txCount: number, totalMana: number) {
+    this.checkpointBuildDuration.record(Math.ceil(durationMs));
+    this.checkpointBlockCount.record(blockCount);
+    this.checkpointTxCount.record(txCount);
+    this.checkpointTotalMana.record(totalMana);
+  }
+
   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);
+      this.fishermanPendingBlobCount.record(analysis.pendingSnapshot.pendingBlobCount, strategyAttributes);
+
+      // Record mined block data if available
+      if (analysis.minedBlock) {
+        this.fishermanIncludedBlobTxCount.record(analysis.minedBlock.includedBlobTxCount, strategyAttributes);
+        this.fishermanIncludedBlobCount.record(analysis.minedBlock.includedBlobCount, 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 whether the block reached 100% blob capacity
+        if (analysis.analysis.blockBlobsFull) {
+          this.fishermanBlockBlobsFull.add(1, { ...strategyAttributes, [Attributes.OK]: true });
+        } else {
+          this.fishermanBlockBlobsFull.add(1, { ...strategyAttributes, [Attributes.OK]: false });
+        }
+
+        // Record the max blob capacity for this block
+        this.fishermanMaxBlobCapacity.record(analysis.analysis.maxBlobCapacity, strategyAttributes);
+
+        // Record strategy-specific inclusion result
+        if (strategyResult.wouldBeIncluded !== undefined) {
+          const inclusionAttributes = {
+            ...strategyAttributes,
+            [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false',
+          };
+
+          if (strategyResult.wouldBeIncluded) {
+            this.fishermanWouldBeIncluded.add(1, { ...inclusionAttributes, [Attributes.OK]: true });
+          } else {
+            this.fishermanWouldBeIncluded.add(1, {
+              ...inclusionAttributes,
+              [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;
+          const deltaAttributes = {
+            ...strategyAttributes,
+            [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false',
+          };
+          this.fishermanPriorityFeeDelta.record(priorityFeeDeltaGwei, deltaAttributes);
+        }
+
+        // Record estimated cost if available
+        if (strategyResult.estimatedCostEth !== undefined) {
+          const costAttributes = {
+            ...strategyAttributes,
+            [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false',
+          };
+          this.fishermanEstimatedCost.record(strategyResult.estimatedCostEth, costAttributes);
+        }
+
+        // Record estimated overpayment if available
+        if (strategyResult.estimatedOverpaymentEth !== undefined) {
+          const overpaymentAttributes = {
+            ...strategyAttributes,
+            [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false',
+          };
+          this.fishermanEstimatedOverpayment.record(strategyResult.estimatedOverpaymentEth, overpaymentAttributes);
+        }
+      }
+    }
+  }
 }