@aztec/sequencer-client 2.1.7 → 2.1.8

package/dest/sequencer/sequencer.js

@@ -68,6 +68,7 @@ export { SequencerState };
     lastBlockPublished;
     governanceProposerPayload;
     /** The last slot for which we attempted to vote when sync failed, to prevent duplicate attempts. */ lastSlotForVoteWhenSyncFailed;
+    /** The last slot for which we built a validation block in fisherman mode, to prevent duplicate attempts. */ lastSlotForValidationBlock;
     /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */ timetable;
     enforceTimeTable;
     // This shouldn't be here as this gets re-created each time we build/propose a block.
@@ -78,6 +79,10 @@ export { SequencerState };
     publisher;
     constructor(publisherFactory, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, l2BlockSource, l1ToL2MessageSource, blockBuilder, l1Constants, dateProvider, epochCache, rollupContract, config, telemetry = getTelemetryClient(), log = createLogger('sequencer')){
         super(), this.publisherFactory = publisherFactory, this.validatorClient = validatorClient, this.globalsBuilder = globalsBuilder, this.p2pClient = p2pClient, this.worldState = worldState, this.slasherClient = slasherClient, this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.blockBuilder = blockBuilder, this.l1Constants = l1Constants, this.dateProvider = dateProvider, this.epochCache = epochCache, this.rollupContract = rollupContract, this.config = config, this.telemetry = telemetry, this.log = log, this.pollingIntervalMs = 1000, this.maxTxsPerBlock = 32, this.minTxsPerBlock = 1, this.maxL1TxInclusionTimeIntoSlot = 0, this.state = SequencerState.STOPPED, this.maxBlockSizeInBytes = 1024 * 1024, this.maxBlockGas = new Gas(100e9, 100e9), this.enforceTimeTable = false;
+        // Add [FISHERMAN] prefix to logger if in fisherman mode
+        if (this.config.fishermanMode) {
+            this.log = log.createChild('[FISHERMAN]');
+        }
         this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
         // Initialize config
         this.updateConfig(this.config);
@@ -214,25 +219,50 @@ export { SequencerState };
         // Check that we are a proposer for the next slot
         this.setState(SequencerState.PROPOSER_CHECK, slot);
         const [canPropose, proposer] = await this.checkCanPropose(slot);
-        // If we are not a proposer, check if we should invalidate a invalid block, and bail
+        // If we are not a proposer check if we should invalidate a invalid block, and bail
         if (!canPropose) {
             await this.considerInvalidatingBlock(syncedTo, slot);
             return;
         }
+        // In fisherman mode, check if we've already validated this slot to prevent duplicate attempts
+        if (this.config.fishermanMode) {
+            if (this.lastSlotForValidationBlock === slot) {
+                this.log.trace(`Already validated block building for slot ${slot} (skipping)`, {
+                    slot
+                });
+                return;
+            }
+            this.log.debug(`Building validation block for slot ${slot} (actual proposer: ${proposer?.toString() ?? 'none'})`, {
+                slot,
+                proposer: proposer?.toString()
+            });
+            // Mark this slot as being validated
+            this.lastSlotForValidationBlock = slot;
+        }
         // Check that the slot is not taken by a block already (should never happen, since only us can propose for this slot)
         if (syncedTo.block && syncedTo.block.header.getSlot() >= slot) {
             this.log.warn(`Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`, {
                 ...syncLogData,
                 block: syncedTo.block.header.toInspect()
             });
+            this.metrics.recordBlockProposalPrecheckFailed('slot_already_taken');
             return;
         }
         // We now need to get ourselves a publisher.
         // The returned attestor will be the one we provided if we provided one.
         // Otherwise it will be a valid attestor for the returned publisher.
-        const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
+        // In fisherman mode, pass undefined to use the fisherman's own keystore instead of the actual proposer's
+        const { attestorAddress, publisher } = await this.publisherFactory.create(this.config.fishermanMode ? undefined : proposer);
         this.log.verbose(`Created publisher at address ${publisher.getSenderAddress()} for attestor ${attestorAddress}`);
         this.publisher = publisher;
+        // In fisherman mode, set the actual proposer's address for simulations
+        if (this.config.fishermanMode) {
+            if (proposer) {
+                publisher.setProposerAddressForSimulation(proposer);
+                this.log.debug(`Set proposer address ${proposer} for simulation in fisherman mode`);
+            }
+        }
+        // Get proposer credentials
         const coinbase = this.validatorClient.getCoinbaseForAttestor(attestorAddress);
         const feeRecipient = this.validatorClient.getFeeRecipientForAttestor(attestorAddress);
         // Prepare invalidation request if the pending chain is invalid (returns undefined if no need)
@@ -245,6 +275,7 @@ export { SequencerState };
             this.emit('proposer-rollup-check-failed', {
                 reason: 'Rollup contract check failed'
             });
+            this.metrics.recordBlockProposalPrecheckFailed('rollup_contract_check_failed');
             return;
         } else if (canProposeCheck.slot !== slot) {
             this.log.warn(`Cannot propose block due to slot mismatch with rollup contract (this can be caused by a clock out of sync). Expected slot ${slot} but got ${canProposeCheck.slot}.`, {
@@ -256,6 +287,7 @@ export { SequencerState };
             this.emit('proposer-rollup-check-failed', {
                 reason: 'Slot mismatch'
             });
+            this.metrics.recordBlockProposalPrecheckFailed('slot_mismatch');
             return;
         } else if (canProposeCheck.blockNumber !== BigInt(newBlockNumber)) {
             this.log.warn(`Cannot propose block due to block mismatch with rollup contract (this can be caused by a pending archiver sync). Expected block ${newBlockNumber} but got ${canProposeCheck.blockNumber}.`, {
@@ -267,6 +299,7 @@ export { SequencerState };
             this.emit('proposer-rollup-check-failed', {
                 reason: 'Block mismatch'
             });
+            this.metrics.recordBlockProposalPrecheckFailed('block_number_mismatch');
             return;
         }
         this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot} as ${proposer}`, {
@@ -274,6 +307,7 @@ export { SequencerState };
         });
         const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(newBlockNumber, coinbase, feeRecipient, slot);
         // Enqueue governance and slashing votes (returns promises that will be awaited later)
+        // In fisherman mode, we simulate slashing but don't actually publish to L1
         const votesPromises = this.enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, newGlobalVariables.timestamp);
         // Enqueues block invalidation
         if (invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
@@ -284,18 +318,41 @@ export { SequencerState };
         const block = await this.tryBuildBlockAndEnqueuePublish(slot, proposer, newBlockNumber, publisher, newGlobalVariables, chainTipArchive, invalidateBlock);
         // Wait until the voting promises have resolved, so all requests are enqueued
         await Promise.all(votesPromises);
-        // And send the tx to L1
-        const l1Response = await publisher.sendRequests();
-        const proposedBlock = l1Response?.successfulActions.find((a)=>a === 'propose');
-        if (proposedBlock) {
-            this.lastBlockPublished = block;
-            this.emit('block-published', {
-                blockNumber: newBlockNumber,
-                slot: Number(slot)
-            });
-            await this.metrics.incFilledSlot(publisher.getSenderAddress().toString(), coinbase);
-        } else if (block) {
-            this.emit('block-publish-failed', l1Response ?? {});
+        // In fisherman mode, we don't publish to L1
+        if (this.config.fishermanMode) {
+            // Clear pending requests
+            publisher.clearPendingRequests();
+            if (block) {
+                this.log.info(`Validation block building SUCCEEDED for slot ${slot}`, {
+                    blockNumber: newBlockNumber,
+                    slot: Number(slot),
+                    archive: block.archive.toString(),
+                    txCount: block.body.txEffects.length
+                });
+                this.lastBlockPublished = block;
+                this.metrics.recordBlockProposalSuccess();
+            } else {
+                // Block building failed in fisherman mode
+                this.log.warn(`Validation block building FAILED for slot ${slot}`, {
+                    blockNumber: newBlockNumber,
+                    slot: Number(slot)
+                });
+                this.metrics.recordBlockProposalFailed('block_build_failed');
+            }
+        } else {
+            // Normal mode: send the tx to L1
+            const l1Response = await publisher.sendRequests();
+            const proposedBlock = l1Response?.successfulActions.find((a)=>a === 'propose');
+            if (proposedBlock) {
+                this.lastBlockPublished = block;
+                this.emit('block-published', {
+                    blockNumber: newBlockNumber,
+                    slot: Number(slot)
+                });
+                await this.metrics.incFilledSlot(publisher.getSenderAddress().toString(), coinbase);
+            } else if (block) {
+                this.emit('block-publish-failed', l1Response ?? {});
+            }
         }
         this.setState(SequencerState.IDLE, undefined);
     }
@@ -336,6 +393,7 @@ export { SequencerState };
                         slot
                     });
                 }
+                this.metrics.recordBlockProposalFailed(err.name || 'unknown_error');
             }
         } else {
             this.log.verbose(`Not enough txs to build block ${newBlockNumber} at slot ${slot} (got ${pendingTxCount} txs, need ${this.minTxsPerBlock})`, {
@@ -347,6 +405,7 @@ export { SequencerState };
                 minTxs: this.minTxsPerBlock,
                 availableTxs: pendingTxCount
             });
+            this.metrics.recordBlockProposalFailed('insufficient_txs');
         }
         return block;
     }
@@ -476,14 +535,22 @@ export { SequencerState };
                 txHashes,
                 ...blockStats
             });
-            this.log.debug('Collecting attestations');
-            const attestationsAndSigners = await this.collectAttestations(block, usedTxs, proposerAddress);
-            this.log.verbose(`Collected ${attestationsAndSigners.attestations.length} attestations for block ${blockNumber} at slot ${slot}`, {
-                blockHash,
-                blockNumber,
-                slot
-            });
-            const attestationsAndSignersSignature = await this.validatorClient?.signAttestationsAndSigners(attestationsAndSigners, proposerAddress ?? publisher.getSenderAddress()) ?? Signature.empty();
+            // In fisherman mode, skip attestation collection
+            let attestationsAndSigners;
+            if (this.config.fishermanMode) {
+                this.log.debug('Skipping attestation collection');
+                attestationsAndSigners = CommitteeAttestationsAndSigners.empty();
+            } else {
+                this.log.debug('Collecting attestations');
+                attestationsAndSigners = await this.collectAttestations(block, usedTxs, proposerAddress);
+                this.log.verbose(`Collected ${attestationsAndSigners.attestations.length} attestations for block ${blockNumber} at slot ${slot}`, {
+                    blockHash,
+                    blockNumber,
+                    slot
+                });
+            }
+            // In fisherman mode, skip attestation signing
+            const attestationsAndSignersSignature = this.config.fishermanMode || !this.validatorClient ? Signature.empty() : await this.validatorClient.signAttestationsAndSigners(attestationsAndSigners, proposerAddress ?? publisher.getSenderAddress());
             await this.enqueuePublishL2Block(block, attestationsAndSigners, attestationsAndSignersSignature, invalidateBlock, publisher);
             this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
             return block;
@@ -685,7 +752,18 @@ export { SequencerState };
                 });
                 return false;
             }) : undefined;
-            const enqueueSlashingPromise = this.slasherClient ? this.slasherClient.getProposerActions(slot).then((actions)=>publisher.enqueueSlashingActions(actions, slot, timestamp, attestorAddress, signerFn)).catch((err)=>{
+            const enqueueSlashingPromise = this.slasherClient ? this.slasherClient.getProposerActions(slot).then((actions)=>{
+                // Record metrics for fisherman mode
+                if (this.config.fishermanMode && actions.length > 0) {
+                    this.log.debug(`Fisherman mode: simulating ${actions.length} slashing action(s) for slot ${slot}`, {
+                        slot,
+                        actionCount: actions.length
+                    });
+                    this.metrics.recordSlashingAttempt(actions.length);
+                }
+                // Enqueue the actions to fully simulate L1 tx building (they won't be sent in fisherman mode)
+                return publisher.enqueueSlashingActions(actions, slot, timestamp, attestorAddress, signerFn);
+            }).catch((err)=>{
                 this.log.error(`Error enqueuing slashing actions`, err, {
                     slot
                 });
@@ -731,6 +809,13 @@ export { SequencerState };
                 undefined
             ];
         }
+        // In fisherman mode, just return the current proposer
+        if (this.config.fishermanMode) {
+            return [
+                true,
+                proposer
+            ];
+        }
         const validatorAddresses = this.validatorClient.getValidatorAddresses();
         const weAreProposer = validatorAddresses.some((addr)=>addr.equals(proposer));
         if (!weAreProposer) {
@@ -842,7 +927,12 @@ export { SequencerState };
         }
         this.log.info(invalidateAsCommitteeMember ? `Invalidating block ${invalidBlockNumber} as committee member` : `Invalidating block ${invalidBlockNumber} as non-committee member`, logData);
         publisher.enqueueInvalidateBlock(invalidateBlock);
-        await publisher.sendRequests();
+        if (!this.config.fishermanMode) {
+            await publisher.sendRequests();
+        } else {
+            this.log.info('Invalidating block in fisherman mode, clearing pending requests');
+            publisher.clearPendingRequests();
+        }
     }
     getSlotStartBuildTimestamp(slotNumber) {
         return getSlotStartBuildTimestamp(slotNumber, this.l1Constants);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/sequencer-client",
-  "version": "2.1.7",
+  "version": "2.1.8",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -26,37 +26,37 @@
     "test:integration:run": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --no-cache --config jest.integration.config.json"
   },
   "dependencies": {
-    "@aztec/aztec.js": "2.1.7",
-    "@aztec/bb-prover": "2.1.7",
-    "@aztec/blob-lib": "2.1.7",
-    "@aztec/blob-sink": "2.1.7",
-    "@aztec/constants": "2.1.7",
-    "@aztec/epoch-cache": "2.1.7",
-    "@aztec/ethereum": "2.1.7",
-    "@aztec/foundation": "2.1.7",
-    "@aztec/l1-artifacts": "2.1.7",
-    "@aztec/merkle-tree": "2.1.7",
-    "@aztec/node-keystore": "2.1.7",
-    "@aztec/noir-acvm_js": "2.1.7",
-    "@aztec/noir-contracts.js": "2.1.7",
-    "@aztec/noir-protocol-circuits-types": "2.1.7",
-    "@aztec/noir-types": "2.1.7",
-    "@aztec/p2p": "2.1.7",
-    "@aztec/protocol-contracts": "2.1.7",
-    "@aztec/prover-client": "2.1.7",
-    "@aztec/simulator": "2.1.7",
-    "@aztec/slasher": "2.1.7",
-    "@aztec/stdlib": "2.1.7",
-    "@aztec/telemetry-client": "2.1.7",
-    "@aztec/validator-client": "2.1.7",
-    "@aztec/world-state": "2.1.7",
+    "@aztec/aztec.js": "2.1.8",
+    "@aztec/bb-prover": "2.1.8",
+    "@aztec/blob-lib": "2.1.8",
+    "@aztec/blob-sink": "2.1.8",
+    "@aztec/constants": "2.1.8",
+    "@aztec/epoch-cache": "2.1.8",
+    "@aztec/ethereum": "2.1.8",
+    "@aztec/foundation": "2.1.8",
+    "@aztec/l1-artifacts": "2.1.8",
+    "@aztec/merkle-tree": "2.1.8",
+    "@aztec/node-keystore": "2.1.8",
+    "@aztec/noir-acvm_js": "2.1.8",
+    "@aztec/noir-contracts.js": "2.1.8",
+    "@aztec/noir-protocol-circuits-types": "2.1.8",
+    "@aztec/noir-types": "2.1.8",
+    "@aztec/p2p": "2.1.8",
+    "@aztec/protocol-contracts": "2.1.8",
+    "@aztec/prover-client": "2.1.8",
+    "@aztec/simulator": "2.1.8",
+    "@aztec/slasher": "2.1.8",
+    "@aztec/stdlib": "2.1.8",
+    "@aztec/telemetry-client": "2.1.8",
+    "@aztec/validator-client": "2.1.8",
+    "@aztec/world-state": "2.1.8",
     "lodash.chunk": "^4.2.0",
     "tslib": "^2.4.0",
-    "viem": "npm:@spalladino/viem@2.38.2-eip7594.2"
+    "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/archiver": "2.1.7",
-    "@aztec/kv-store": "2.1.7",
+    "@aztec/archiver": "2.1.8",
+    "@aztec/kv-store": "2.1.8",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.chunk": "^4.2.7",

package/src/config.ts

@@ -149,6 +149,12 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
     description: 'Inject a fake attestation (for testing only)',
     ...booleanConfigHelper(false),
   },
+  fishermanMode: {
+    env: 'FISHERMAN_MODE',
+    description:
+      'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
+    ...booleanConfigHelper(false),
+  },
   shuffleAttestationOrdering: {
     description: 'Shuffle attestation ordering to create invalid ordering (for testing only)',
     ...booleanConfigHelper(false),

package/src/publisher/config.ts

@@ -35,6 +35,8 @@ export type PublisherConfig = L1TxUtilsConfig &
   BlobSinkConfig & {
     /** True to use publishers in invalid states (timed out, cancelled, etc) if no other is available */
     publisherAllowInvalidStates?: boolean;
+    /** Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1 */
+    fishermanMode?: boolean;
   };
 
 export const getTxSenderConfigMappings: (
@@ -68,6 +70,12 @@ export const getPublisherConfigMappings: (
     env: scope === `PROVER` ? `PROVER_PUBLISHER_ALLOW_INVALID_STATES` : `SEQ_PUBLISHER_ALLOW_INVALID_STATES`,
     ...booleanConfigHelper(true),
   },
+  fishermanMode: {
+    env: 'FISHERMAN_MODE',
+    description:
+      'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
+    ...booleanConfigHelper(false),
+  },
   ...l1TxUtilsConfigMappings,
   ...blobSinkConfigMapping,
 });

package/src/publisher/sequencer-publisher.ts

@@ -19,6 +19,7 @@ import {
   type ViemCommitteeAttestations,
   type ViemHeader,
   type ViemStateReference,
+  WEI_CONST,
   formatViemError,
   tryExtractEvent,
 } from '@aztec/ethereum';
@@ -39,7 +40,7 @@ import type { L1PublishBlockStats } from '@aztec/stdlib/stats';
 import { type ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { type TransactionReceipt, type TypedDataDefinition, encodeFunctionData, toHex } from 'viem';
+import { type StateOverride, type TransactionReceipt, type TypedDataDefinition, encodeFunctionData, toHex } from 'viem';
 
 import type { PublisherConfig, TxSenderConfig } from './config.js';
 import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
@@ -113,6 +114,9 @@ export class SequencerPublisher {
   protected ethereumSlotDuration: bigint;
 
   private blobSinkClient: BlobSinkClientInterface;
+
+  /** Address to use for simulations in fisherman mode (actual proposer's address) */
+  private proposerAddressForSimulation?: EthAddress;
   // @note - with blobs, the below estimate seems too large.
   // Total used for full block from int_l1_pub e2e test: 1m (of which 86k is 1x blob)
   // Total used for emptier block from above test: 429k (of which 84k is 1x blob)
@@ -182,6 +186,14 @@ export class SequencerPublisher {
     return this.l1TxUtils.getSenderAddress();
   }
 
+  /**
+   * Sets the proposer address to use for simulations in fisherman mode.
+   * @param proposerAddress - The actual proposer's address to use for balance lookups in simulations
+   */
+  public setProposerAddressForSimulation(proposerAddress: EthAddress | undefined) {
+    this.proposerAddressForSimulation = proposerAddress;
+  }
+
   public addRequest(request: RequestWithExpiry) {
     this.requests.push(request);
   }
@@ -190,6 +202,17 @@ export class SequencerPublisher {
     return this.epochCache.getEpochAndSlotNow().slot;
   }
 
+  /**
+   * Clears all pending requests without sending them.
+   */
+  public clearPendingRequests(): void {
+    const count = this.requests.length;
+    this.requests = [];
+    if (count > 0) {
+      this.log.debug(`Cleared ${count} pending request(s)`);
+    }
+  }
+
   /**
    * Sends all requests that are still valid.
    * @returns one of:
@@ -355,10 +378,20 @@ export class SequencerPublisher {
     ] as const;
 
     const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
+    const stateOverrides = await this.rollupContract.makePendingBlockNumberOverride(opts?.forcePendingBlockNumber);
+    let balance = 0n;
+    if (this.config.fishermanMode) {
+      // In fisherman mode, we can't know where the proposer is publishing from
+      // so we just add sufficient balance to the multicall3 address
+      balance = 10n * WEI_CONST * WEI_CONST; // 10 ETH
+    } else {
+      balance = await this.l1TxUtils.getSenderBalance();
+    }
+    stateOverrides.push({
+      address: MULTI_CALL_3_ADDRESS,
+      balance,
+    });
 
-    // use sender balance to simulate
-    const balance = await this.l1TxUtils.getSenderBalance();
-    this.log.debug(`Simulating validateHeader with balance: ${balance}`);
     await this.l1TxUtils.simulate(
       {
         to: this.rollupContract.address,
@@ -366,10 +399,7 @@ export class SequencerPublisher {
         from: MULTI_CALL_3_ADDRESS,
       },
       { time: ts + 1n },
-      [
-        { address: MULTI_CALL_3_ADDRESS, balance },
-        ...(await this.rollupContract.makePendingBlockNumberOverride(opts?.forcePendingBlockNumber)),
-      ],
+      stateOverrides,
     );
     this.log.debug(`Simulated validateHeader`);
   }
@@ -911,29 +941,39 @@ export class SequencerPublisher {
     const kzg = Blob.getViemKzgInstance();
     const blobInput = Blob.getPrefixedEthBlobCommitments(encodedData.blobs);
     this.log.debug('Validating blob input', { blobInput });
-    const blobEvaluationGas = await this.l1TxUtils
-      .estimateGas(
-        this.getSenderAddress().toString(),
-        {
-          to: this.rollupContract.address,
-          data: encodeFunctionData({
-            abi: RollupAbi,
-            functionName: 'validateBlobs',
-            args: [blobInput],
-          }),
-        },
-        {},
-        {
-          blobs: encodedData.blobs.map(b => b.data),
-          kzg,
-        },
-      )
-      .catch(err => {
-        const { message, metaMessages } = formatViemError(err);
-        this.log.error(`Failed to validate blobs`, message, { metaMessages });
-        throw new Error('Failed to validate blobs');
-      });
 
+    // Get blob evaluation gas
+    let blobEvaluationGas: bigint;
+    if (this.config.fishermanMode) {
+      // In fisherman mode, we can't estimate blob gas because estimateGas doesn't support state overrides
+      // Use a fixed estimate.
+      blobEvaluationGas = BigInt(encodedData.blobs.length) * 21_000n;
+      this.log.debug(`Using fixed blob evaluation gas estimate in fisherman mode: ${blobEvaluationGas}`);
+    } else {
+      // Normal mode - use estimateGas with blob inputs
+      blobEvaluationGas = await this.l1TxUtils
+        .estimateGas(
+          this.getSenderAddress().toString(),
+          {
+            to: this.rollupContract.address,
+            data: encodeFunctionData({
+              abi: RollupAbi,
+              functionName: 'validateBlobs',
+              args: [blobInput],
+            }),
+          },
+          {},
+          {
+            blobs: encodedData.blobs.map(b => b.data),
+            kzg,
+          },
+        )
+        .catch(err => {
+          const { message, metaMessages } = formatViemError(err);
+          this.log.error(`Failed to validate blobs`, message, { metaMessages });
+          throw new Error('Failed to validate blobs');
+        });
+    }
     const signers = encodedData.attestationsAndSigners.getSigners().map(signer => signer.toString());
 
     const args = [
@@ -994,12 +1034,31 @@ export class SequencerPublisher {
         : []
     ).flatMap(override => override.stateDiff ?? []);
 
+    const stateOverrides: StateOverride = [
+      {
+        address: this.rollupContract.address,
+        // @note we override checkBlob to false since blobs are not part simulate()
+        stateDiff: [
+          { slot: toPaddedHex(RollupContract.checkBlobStorageSlot, true), value: toPaddedHex(0n, true) },
+          ...forcePendingBlockNumberStateDiff,
+        ],
+      },
+    ];
+    // In fisherman mode, simulate as the proposer but with sufficient balance
+    if (this.proposerAddressForSimulation) {
+      stateOverrides.push({
+        address: this.proposerAddressForSimulation.toString(),
+        balance: 10n * WEI_CONST * WEI_CONST, // 10 ETH
+      });
+    }
+
     const simulationResult = await this.l1TxUtils
       .simulate(
         {
           to: this.rollupContract.address,
           data: rollupData,
           gas: SequencerPublisher.PROPOSE_GAS_GUESS,
+          ...(this.proposerAddressForSimulation && { from: this.proposerAddressForSimulation.toString() }),
         },
         {
           // @note we add 1n to the timestamp because geth implementation doesn't like simulation timestamp to be equal to the current block timestamp
@@ -1007,16 +1066,7 @@ export class SequencerPublisher {
           // @note reth should have a 30m gas limit per block but throws errors that this tx is beyond limit so we increase here
           gasLimit: SequencerPublisher.PROPOSE_GAS_GUESS * 2n,
         },
-        [
-          {
-            address: this.rollupContract.address,
-            // @note we override checkBlob to false since blobs are not part simulate()
-            stateDiff: [
-              { slot: toPaddedHex(RollupContract.checkBlobStorageSlot, true), value: toPaddedHex(0n, true) },
-              ...forcePendingBlockNumberStateDiff,
-            ],
-          },
-        ],
+        stateOverrides,
         RollupAbi,
         {
           // @note fallback gas estimate to use if the node doesn't support simulation API
@@ -1024,7 +1074,17 @@ export class SequencerPublisher {
         },
       )
       .catch(err => {
-        this.log.error(`Failed to simulate propose tx`, err);
+        // In fisherman mode, we expect ValidatorSelection__MissingProposerSignature since fisherman doesn't have proposer signature
+        const viemError = formatViemError(err);
+        if (this.config.fishermanMode && viemError.message?.includes('ValidatorSelection__MissingProposerSignature')) {
+          this.log.debug(`Ignoring expected ValidatorSelection__MissingProposerSignature error in fisherman mode`);
+          // Return a minimal simulation result with the fallback gas estimate
+          return {
+            gasUsed: SequencerPublisher.PROPOSE_GAS_GUESS,
+            logs: [],
+          };
+        }
+        this.log.error(`Failed to simulate propose tx`, viemError);
         throw err;
       });
 

package/src/sequencer/metrics.ts

@@ -36,6 +36,11 @@ export class SequencerMetrics {
   private slots: UpDownCounter;
   private filledSlots: UpDownCounter;
 
+  private blockProposalFailed: UpDownCounter;
+  private blockProposalSuccess: UpDownCounter;
+  private blockProposalPrecheckFailed: UpDownCounter;
+  private slashingAttempts: UpDownCounter;
+
   private lastSeenSlot?: bigint;
 
   constructor(
@@ -121,6 +126,29 @@ export class SequencerMetrics {
       valueType: ValueType.INT,
       description: 'The minimum number of attestations required to publish a block',
     });
+
+    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.blockProposalSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The number of times block proposal succeeded (including validation builds)',
+    });
+
+    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',
+      },
+    );
+
+    this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The number of slashing action attempts',
+    });
   }
 
   public recordRequiredAttestations(requiredAttestationsCount: number, allowanceMs: number) {
@@ -188,4 +216,24 @@ export class SequencerMetrics {
       }
     }
   }
+
+  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);
+  }
 }