@aztec/sequencer-client 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/src/publisher/sequencer-publisher.ts

@@ -1,47 +1,46 @@
-import type { L2Block } from '@aztec/aztec.js';
-import { Blob } from '@aztec/blob-lib';
+import { L2Block } from '@aztec/aztec.js/block';
+import { Blob, getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
 import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
 import type { EpochCache } from '@aztec/epoch-cache';
+import type { L1ContractsConfig } from '@aztec/ethereum/config';
 import {
   type EmpireSlashingProposerContract,
-  FormattedViemError,
-  type GasPrice,
   type GovernanceProposerContract,
   type IEmpireBase,
-  type L1BlobInputs,
-  type L1ContractsConfig,
-  type L1GasConfig,
-  type L1TxRequest,
   MULTI_CALL_3_ADDRESS,
   Multicall3,
   RollupContract,
   type TallySlashingProposerContract,
-  type TransactionStats,
   type ViemCommitteeAttestations,
   type ViemHeader,
-  type ViemStateReference,
-  formatViemError,
-  tryExtractEvent,
-} from '@aztec/ethereum';
+} from '@aztec/ethereum/contracts';
+import {
+  type L1BlobInputs,
+  type L1TxConfig,
+  type L1TxRequest,
+  type TransactionStats,
+  WEI_CONST,
+} from '@aztec/ethereum/l1-tx-utils';
 import type { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import { FormattedViemError, formatViemError, tryExtractEvent } from '@aztec/ethereum/utils';
 import { sumBigint } from '@aztec/foundation/bigint';
 import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import { Signature, type ViemSignature } from '@aztec/foundation/eth-signature';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import { EmpireBaseAbi, ErrorsAbi, RollupAbi } from '@aztec/l1-artifacts';
 import { type ProposerSlashAction, encodeSlashConsensusVotes } from '@aztec/slasher';
-import { CommitteeAttestation, type ValidateBlockResult } from '@aztec/stdlib/block';
+import { CommitteeAttestation, CommitteeAttestationsAndSigners, type ValidateBlockResult } from '@aztec/stdlib/block';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
-import { ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayload } from '@aztec/stdlib/p2p';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { L1PublishBlockStats } from '@aztec/stdlib/stats';
-import { type ProposedBlockHeader, StateReference, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import pick from 'lodash.pick';
-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';
@@ -49,24 +48,17 @@ import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
 /** Arguments to the process method of the rollup contract */
 type L1ProcessArgs = {
   /** The L2 block header. */
-  header: ProposedBlockHeader;
+  header: CheckpointHeader;
   /** A root of the archive tree after the L2 block is applied. */
   archive: Buffer;
-  /** State reference after the L2 block is applied. */
-  stateReference: StateReference;
   /** L2 block blobs containing all tx effects. */
   blobs: Blob[];
-  /** L2 block tx hashes */
-  txHashes: TxHash[];
   /** Attestations */
-  attestations?: CommitteeAttestation[];
+  attestationsAndSigners: CommitteeAttestationsAndSigners;
+  /** Attestations and signers signature */
+  attestationsAndSignersSignature: Signature;
 };
 
-export enum SignalType {
-  GOVERNANCE,
-  SLASHING,
-}
-
 export const Actions = [
   'invalidate-by-invalid-attestation',
   'invalidate-by-insufficient-attestations',
@@ -78,8 +70,11 @@ export const Actions = [
   'vote-offenses',
   'execute-slash',
 ] as const;
+
 export type Action = (typeof Actions)[number];
 
+type GovernanceSignalAction = Extract<Action, 'governance-signal' | 'empire-slashing-signal'>;
+
 // Sorting for actions such that invalidations go before proposals, and proposals go before votes
 export const compareActions = (a: Action, b: Action) => Actions.indexOf(a) - Actions.indexOf(b);
 
@@ -87,19 +82,19 @@ export type InvalidateBlockRequest = {
   request: L1TxRequest;
   reason: 'invalid-attestation' | 'insufficient-attestations';
   gasUsed: bigint;
-  blockNumber: number;
-  forcePendingBlockNumber: number;
+  blockNumber: BlockNumber;
+  forcePendingBlockNumber: BlockNumber;
 };
 
 interface RequestWithExpiry {
   action: Action;
   request: L1TxRequest;
-  lastValidL2Slot: bigint;
-  gasConfig?: Pick<L1GasConfig, 'txTimeoutAt' | 'gasLimit'>;
+  lastValidL2Slot: SlotNumber;
+  gasConfig?: Pick<L1TxConfig, 'txTimeoutAt' | 'gasLimit'>;
   blobConfig?: L1BlobInputs;
   checkSuccess: (
     request: L1TxRequest,
-    result?: { receipt: TransactionReceipt; gasPrice: GasPrice; stats?: TransactionStats; errorMsg?: string },
+    result?: { receipt: TransactionReceipt; stats?: TransactionStats; errorMsg?: string },
   ) => boolean;
 }
 
@@ -111,15 +106,15 @@ export class SequencerPublisher {
   protected governanceLog = createLogger('sequencer:publisher:governance');
   protected slashingLog = createLogger('sequencer:publisher:slashing');
 
-  private myLastSignals: Record<SignalType, bigint> = {
-    [SignalType.GOVERNANCE]: 0n,
-    [SignalType.SLASHING]: 0n,
-  };
+  protected lastActions: Partial<Record<Action, SlotNumber>> = {};
 
-  protected log = createLogger('sequencer:publisher');
+  protected log: Logger;
   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)
@@ -152,10 +147,14 @@ export class SequencerPublisher {
       epochCache: EpochCache;
       dateProvider: DateProvider;
       metrics: SequencerPublisherMetrics;
+      lastActions: Partial<Record<Action, SlotNumber>>;
+      log?: Logger;
     },
   ) {
+    this.log = deps.log ?? createLogger('sequencer:publisher');
     this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
     this.epochCache = deps.epochCache;
+    this.lastActions = deps.lastActions;
 
     this.blobSinkClient =
       deps.blobSinkClient ?? createBlobSinkClient(config, { logger: createLogger('sequencer:blob-sink:client') });
@@ -185,14 +184,33 @@ 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);
   }
 
-  public getCurrentL2Slot(): bigint {
+  public getCurrentL2Slot(): SlotNumber {
     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:
@@ -249,18 +267,21 @@ export class SequencerPublisher {
     const gasLimit = gasLimits.length > 0 ? sumBigint(gasLimits) : undefined; // sum
     const txTimeoutAts = gasConfigs.map(g => g?.txTimeoutAt).filter((g): g is Date => g !== undefined);
     const txTimeoutAt = txTimeoutAts.length > 0 ? new Date(Math.min(...txTimeoutAts.map(g => g.getTime()))) : undefined; // earliest
-    const gasConfig: RequestWithExpiry['gasConfig'] = { gasLimit, txTimeoutAt };
+    const txConfig: RequestWithExpiry['gasConfig'] = { gasLimit, txTimeoutAt };
 
     // Sort the requests so that proposals always go first
     // This ensures the committee gets precomputed correctly
     validRequests.sort((a, b) => compareActions(a.action, b.action));
 
     try {
-      this.log.debug('Forwarding transactions', { validRequests: validRequests.map(request => request.action) });
+      this.log.debug('Forwarding transactions', {
+        validRequests: validRequests.map(request => request.action),
+        txConfig,
+      });
       const result = await Multicall3.forward(
         validRequests.map(request => request.request),
         this.l1TxUtils,
-        gasConfig,
+        txConfig,
         blobConfig,
         this.rollupContract.address,
         this.log,
@@ -285,7 +306,7 @@ export class SequencerPublisher {
 
   private callbackBundledTransactions(
     requests: RequestWithExpiry[],
-    result?: { receipt: TransactionReceipt; gasPrice: GasPrice } | FormattedViemError,
+    result?: { receipt: TransactionReceipt } | FormattedViemError,
   ) {
     const actionsListStr = requests.map(r => r.action).join(', ');
     if (result instanceof FormattedViemError) {
@@ -314,13 +335,18 @@ export class SequencerPublisher {
   public canProposeAtNextEthBlock(
     tipArchive: Fr,
     msgSender: EthAddress,
-    opts: { forcePendingBlockNumber?: number } = {},
+    opts: { forcePendingBlockNumber?: BlockNumber } = {},
   ) {
     // TODO: #14291 - should loop through multiple keys to check if any of them can propose
     const ignoredErrors = ['SlotAlreadyInChain', 'InvalidProposer', 'InvalidArchive'];
 
     return this.rollupContract
-      .canProposeAtNextEthBlock(tipArchive.toBuffer(), msgSender.toString(), this.ethereumSlotDuration, opts)
+      .canProposeAtNextEthBlock(tipArchive.toBuffer(), msgSender.toString(), Number(this.ethereumSlotDuration), {
+        forcePendingCheckpointNumber:
+          opts.forcePendingBlockNumber !== undefined
+            ? CheckpointNumber.fromBlockNumber(opts.forcePendingBlockNumber)
+            : undefined,
+      })
       .catch(err => {
         if (err instanceof FormattedViemError && ignoredErrors.find(e => err.message.includes(e))) {
           this.log.warn(`Failed canProposeAtTime check with ${ignoredErrors.find(e => err.message.includes(e))}`, {
@@ -339,25 +365,42 @@ export class SequencerPublisher {
    * @param header - The block header to validate
    */
   public async validateBlockHeader(
-    header: ProposedBlockHeader,
-    opts?: { forcePendingBlockNumber: number | undefined },
+    header: CheckpointHeader,
+    opts?: { forcePendingBlockNumber: BlockNumber | undefined },
   ) {
     const flags = { ignoreDA: true, ignoreSignatures: true };
 
     const args = [
       header.toViem(),
-      RollupContract.packAttestations([]),
+      CommitteeAttestationsAndSigners.empty().getPackedAttestations(),
       [], // no signers
+      Signature.empty().toViemSignature(),
       `0x${'0'.repeat(64)}`, // 32 empty bytes
       header.contentCommitment.blobsHash.toString(),
       flags,
     ] as const;
 
     const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
+    const optsForcePendingCheckpointNumber =
+      opts?.forcePendingBlockNumber !== undefined
+        ? CheckpointNumber.fromBlockNumber(opts.forcePendingBlockNumber)
+        : undefined;
+    const stateOverrides = await this.rollupContract.makePendingCheckpointNumberOverride(
+      optsForcePendingCheckpointNumber,
+    );
+    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,
@@ -365,10 +408,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`);
   }
@@ -385,11 +425,11 @@ export class SequencerPublisher {
     }
 
     const { reason, block } = validationResult;
-    const blockNumber = block.block.number;
-    const logData = { ...block.block.toBlockInfo(), reason };
+    const blockNumber = block.blockNumber;
+    const logData = { ...block, reason };
 
-    const currentBlockNumber = await this.rollupContract.getBlockNumber();
-    if (currentBlockNumber < validationResult.block.block.number) {
+    const currentBlockNumber = await this.rollupContract.getCheckpointNumber();
+    if (currentBlockNumber < validationResult.block.blockNumber) {
       this.log.verbose(
         `Skipping block ${blockNumber} invalidation since it has already been removed from the pending chain`,
         { currentBlockNumber, ...logData },
@@ -398,13 +438,13 @@ export class SequencerPublisher {
     }
 
     const request = this.buildInvalidateBlockRequest(validationResult);
-    this.log.debug(`Simulating invalidate block ${blockNumber}`, logData);
+    this.log.debug(`Simulating invalidate block ${blockNumber}`, { ...logData, request });
 
     try {
       const { gasUsed } = await this.l1TxUtils.simulate(request, undefined, undefined, ErrorsAbi);
       this.log.verbose(`Simulation for invalidate block ${blockNumber} succeeded`, { ...logData, request, gasUsed });
 
-      return { request, gasUsed, blockNumber, forcePendingBlockNumber: blockNumber - 1, reason };
+      return { request, gasUsed, blockNumber, forcePendingBlockNumber: BlockNumber(blockNumber - 1), reason };
     } catch (err) {
       const viemError = formatViemError(err);
 
@@ -415,7 +455,7 @@ export class SequencerPublisher {
           `Simulation for invalidate block ${blockNumber} failed due to block not being in pending chain`,
           { ...logData, request, error: viemError.message },
         );
-        const latestPendingBlockNumber = await this.rollupContract.getBlockNumber();
+        const latestPendingBlockNumber = await this.rollupContract.getCheckpointNumber();
         if (latestPendingBlockNumber < blockNumber) {
           this.log.verbose(`Block number ${blockNumber} has already been invalidated`, { ...logData });
           return undefined;
@@ -443,20 +483,24 @@ export class SequencerPublisher {
     }
 
     const { block, committee, reason } = validationResult;
-    const logData = { ...block.block.toBlockInfo(), reason };
-    this.log.debug(`Simulating invalidate block ${block.block.number}`, logData);
+    const logData = { ...block, reason };
+    this.log.debug(`Simulating invalidate block ${block.blockNumber}`, logData);
+
+    const attestationsAndSigners = new CommitteeAttestationsAndSigners(
+      validationResult.attestations,
+    ).getPackedAttestations();
 
     if (reason === 'invalid-attestation') {
       return this.rollupContract.buildInvalidateBadAttestationRequest(
-        block.block.number,
-        block.attestations.map(a => a.toViem()),
+        CheckpointNumber.fromBlockNumber(block.blockNumber),
+        attestationsAndSigners,
         committee,
         validationResult.invalidIndex,
       );
     } else if (reason === 'insufficient-attestations') {
       return this.rollupContract.buildInvalidateInsufficientAttestationsRequest(
-        block.block.number,
-        block.attestations.map(a => a.toViem()),
+        CheckpointNumber.fromBlockNumber(block.blockNumber),
+        attestationsAndSigners,
         committee,
       );
     } else {
@@ -476,48 +520,41 @@ export class SequencerPublisher {
    */
   public async validateBlockForSubmission(
     block: L2Block,
-    attestationData: { digest: Buffer; attestations: CommitteeAttestation[] } = {
-      digest: Buffer.alloc(32),
-      attestations: [],
-    },
-    options: { forcePendingBlockNumber?: number },
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    attestationsAndSignersSignature: Signature,
+    options: { forcePendingBlockNumber?: BlockNumber },
   ): Promise<bigint> {
     const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
 
     // If we have no attestations, we still need to provide the empty attestations
     // so that the committee is recalculated correctly
-    const ignoreSignatures = attestationData.attestations.length === 0;
+    const ignoreSignatures = attestationsAndSigners.attestations.length === 0;
     if (ignoreSignatures) {
-      const { committee } = await this.epochCache.getCommittee(block.header.globalVariables.slotNumber.toBigInt());
+      const { committee } = await this.epochCache.getCommittee(block.header.globalVariables.slotNumber);
       if (!committee) {
-        this.log.warn(`No committee found for slot ${block.header.globalVariables.slotNumber.toBigInt()}`);
-        throw new Error(`No committee found for slot ${block.header.globalVariables.slotNumber.toBigInt()}`);
+        this.log.warn(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
+        throw new Error(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
       }
-      attestationData.attestations = committee.map(committeeMember =>
+      attestationsAndSigners.attestations = committee.map(committeeMember =>
         CommitteeAttestation.fromAddress(committeeMember),
       );
     }
 
-    const blobs = await Blob.getBlobsPerBlock(block.body.toBlobFields());
-    const blobInput = Blob.getPrefixedEthBlobCommitments(blobs);
-
-    const formattedAttestations = attestationData.attestations.map(attest => attest.toViem());
-    const signers = attestationData.attestations
-      .filter(attest => !attest.signature.isEmpty())
-      .map(attest => attest.address.toString());
+    const blobFields = block.getCheckpointBlobFields();
+    const blobs = getBlobsPerL1Block(blobFields);
+    const blobInput = getPrefixedEthBlobCommitments(blobs);
 
     const args = [
       {
-        header: block.header.toPropose().toViem(),
+        header: block.getCheckpointHeader().toViem(),
         archive: toHex(block.archive.root.toBuffer()),
-        stateReference: block.header.state.toViem(),
-        txHashes: block.body.txEffects.map(txEffect => txEffect.txHash.toString()),
         oracleInput: {
           feeAssetPriceModifier: 0n,
         },
       },
-      RollupContract.packAttestations(formattedAttestations),
-      signers,
+      attestationsAndSigners.getPackedAttestations(),
+      attestationsAndSigners.getSigners().map(signer => signer.toString()),
+      attestationsAndSignersSignature.toViemSignature(),
       blobInput,
     ] as const;
 
@@ -526,15 +563,16 @@ export class SequencerPublisher {
   }
 
   private async enqueueCastSignalHelper(
-    slotNumber: bigint,
+    slotNumber: SlotNumber,
     timestamp: bigint,
-    signalType: SignalType,
+    signalType: GovernanceSignalAction,
     payload: EthAddress,
     base: IEmpireBase,
     signerAddress: EthAddress,
     signer: (msg: TypedDataDefinition) => Promise<`0x${string}`>,
   ): Promise<boolean> {
-    if (this.myLastSignals[signalType] >= slotNumber) {
+    if (this.lastActions[signalType] && this.lastActions[signalType] === slotNumber) {
+      this.log.debug(`Skipping duplicate vote cast signal ${signalType} for slot ${slotNumber}`);
       return false;
     }
     if (payload.equals(EthAddress.ZERO)) {
@@ -551,10 +589,9 @@ export class SequencerPublisher {
       return false;
     }
 
-    const cachedLastVote = this.myLastSignals[signalType];
-    this.myLastSignals[signalType] = slotNumber;
-
-    const action = signalType === SignalType.GOVERNANCE ? 'governance-signal' : 'empire-slashing-signal';
+    const cachedLastVote = this.lastActions[signalType];
+    this.lastActions[signalType] = slotNumber;
+    const action = signalType;
 
     const request = await base.createSignalRequestWithSignature(
       payload.toString(),
@@ -597,7 +634,7 @@ export class SequencerPublisher {
             `Signaling in [${action}] for ${payload} at slot ${slotNumber} in round ${round} failed`,
             logData,
           );
-          this.myLastSignals[signalType] = cachedLastVote;
+          this.lastActions[signalType] = cachedLastVote;
           return false;
         } else {
           this.log.info(
@@ -619,7 +656,7 @@ export class SequencerPublisher {
    */
   public enqueueGovernanceCastSignal(
     governancePayload: EthAddress,
-    slotNumber: bigint,
+    slotNumber: SlotNumber,
     timestamp: bigint,
     signerAddress: EthAddress,
     signer: (msg: TypedDataDefinition) => Promise<`0x${string}`>,
@@ -627,7 +664,7 @@ export class SequencerPublisher {
     return this.enqueueCastSignalHelper(
       slotNumber,
       timestamp,
-      SignalType.GOVERNANCE,
+      'governance-signal',
       governancePayload,
       this.govProposerContract,
       signerAddress,
@@ -638,7 +675,7 @@ export class SequencerPublisher {
   /** Enqueues all slashing actions as returned by the slasher client. */
   public async enqueueSlashingActions(
     actions: ProposerSlashAction[],
-    slotNumber: bigint,
+    slotNumber: SlotNumber,
     timestamp: bigint,
     signerAddress: EthAddress,
     signer: (msg: TypedDataDefinition) => Promise<`0x${string}`>,
@@ -661,7 +698,7 @@ export class SequencerPublisher {
           await this.enqueueCastSignalHelper(
             slotNumber,
             timestamp,
-            SignalType.SLASHING,
+            'empire-slashing-signal',
             action.payload,
             this.slashingProposerContract,
             signerAddress,
@@ -766,24 +803,22 @@ export class SequencerPublisher {
    */
   public async enqueueProposeL2Block(
     block: L2Block,
-    attestations?: CommitteeAttestation[],
-    txHashes?: TxHash[],
-    opts: { txTimeoutAt?: Date; forcePendingBlockNumber?: number } = {},
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    attestationsAndSignersSignature: Signature,
+    opts: { txTimeoutAt?: Date; forcePendingBlockNumber?: BlockNumber } = {},
   ): Promise<boolean> {
-    const proposedBlockHeader = block.header.toPropose();
+    const checkpointHeader = block.getCheckpointHeader();
 
-    const consensusPayload = ConsensusPayload.fromBlock(block);
-    const digest = getHashedSignaturePayload(consensusPayload, SignatureDomainSeparator.blockAttestation);
+    const blobFields = block.getCheckpointBlobFields();
+    const blobs = getBlobsPerL1Block(blobFields);
 
-    const blobs = await Blob.getBlobsPerBlock(block.body.toBlobFields());
     const proposeTxArgs = {
-      header: proposedBlockHeader,
+      header: checkpointHeader,
       archive: block.archive.root.toBuffer(),
-      stateReference: block.header.state,
       body: block.body.toBuffer(),
       blobs,
-      attestations,
-      txHashes: txHashes ?? [],
+      attestationsAndSigners,
+      attestationsAndSignersSignature,
     };
 
     let ts: bigint;
@@ -793,13 +828,12 @@ export class SequencerPublisher {
       //        This means that we can avoid the simulation issues in later checks.
       //        By simulation issue, I mean the fact that the block.timestamp is equal to the last block, not the next, which
       //        make time consistency checks break.
-      const attestationData = { digest: digest.toBuffer(), attestations: attestations ?? [] };
       // TODO(palla): Check whether we're validating twice, once here and once within addProposeTx, since we call simulateProposeTx in both places.
-      ts = await this.validateBlockForSubmission(block, attestationData, opts);
+      ts = await this.validateBlockForSubmission(block, attestationsAndSigners, attestationsAndSignersSignature, opts);
     } catch (err: any) {
       this.log.error(`Block validation failed. ${err instanceof Error ? err.message : 'No error message'}`, err, {
         ...block.getStats(),
-        slotNumber: block.header.globalVariables.slotNumber.toBigInt(),
+        slotNumber: block.header.globalVariables.slotNumber,
         forcePendingBlockNumber: opts.forcePendingBlockNumber,
       });
       throw err;
@@ -818,19 +852,20 @@ export class SequencerPublisher {
     // We issued the simulation against the rollup contract, so we need to account for the overhead of the multicall3
     const gasLimit = this.l1TxUtils.bumpGasLimit(BigInt(Math.ceil((Number(request.gasUsed) * 64) / 63)));
 
-    const logData = { ...pick(request, 'gasUsed', 'blockNumber'), gasLimit, opts };
+    const { gasUsed, blockNumber } = request;
+    const logData = { gasUsed, blockNumber, gasLimit, opts };
     this.log.verbose(`Enqueuing invalidate block request`, logData);
     this.addRequest({
       action: `invalidate-by-${request.reason}`,
       request: request.request,
       gasConfig: { gasLimit, txTimeoutAt: opts.txTimeoutAt },
-      lastValidL2Slot: this.getCurrentL2Slot() + 2n,
+      lastValidL2Slot: SlotNumber(this.getCurrentL2Slot() + 2),
       checkSuccess: (_req, result) => {
         const success =
           result &&
           result.receipt &&
           result.receipt.status === 'success' &&
-          tryExtractEvent(result.receipt.logs, this.rollupContract.address, RollupAbi, 'BlockInvalidated');
+          tryExtractEvent(result.receipt.logs, this.rollupContract.address, RollupAbi, 'CheckpointInvalidated');
         if (!success) {
           this.log.warn(`Invalidate block ${request.blockNumber} failed`, { ...result, ...logData });
         } else {
@@ -842,16 +877,24 @@ export class SequencerPublisher {
   }
 
   private async simulateAndEnqueueRequest(
-    action: RequestWithExpiry['action'],
+    action: Action,
     request: L1TxRequest,
     checkSuccess: (receipt: TransactionReceipt) => boolean | undefined,
-    slotNumber: bigint,
+    slotNumber: SlotNumber,
     timestamp: bigint,
   ) {
     const logData = { slotNumber, timestamp, gasLimit: undefined as bigint | undefined };
-    let gasUsed: bigint;
+    if (this.lastActions[action] && this.lastActions[action] === slotNumber) {
+      this.log.debug(`Skipping duplicate action ${action} for slot ${slotNumber}`);
+      return false;
+    }
+
+    const cachedLastActionSlot = this.lastActions[action];
+    this.lastActions[action] = slotNumber;
+
+    this.log.debug(`Simulating ${action} for slot ${slotNumber}`, logData);
 
-    this.log.debug(`Simulating ${action}`, logData);
+    let gasUsed: bigint;
     try {
       ({ gasUsed } = await this.l1TxUtils.simulate(request, { time: timestamp }, [], ErrorsAbi)); // TODO(palla/slash): Check the timestamp logic
       this.log.verbose(`Simulation for ${action} succeeded`, { ...logData, request, gasUsed });
@@ -875,6 +918,7 @@ export class SequencerPublisher {
         const success = result && result.receipt && result.receipt.status === 'success' && checkSuccess(result.receipt);
         if (!success) {
           this.log.warn(`Action ${action} at ${slotNumber} failed`, { ...result, ...logData });
+          this.lastActions[action] = cachedLastActionSlot;
         } else {
           this.log.info(`Action ${action} at ${slotNumber} succeeded`, { ...result, ...logData });
         }
@@ -904,54 +948,58 @@ export class SequencerPublisher {
   private async prepareProposeTx(
     encodedData: L1ProcessArgs,
     timestamp: bigint,
-    options: { forcePendingBlockNumber?: number },
+    options: { forcePendingBlockNumber?: BlockNumber },
   ) {
     const kzg = Blob.getViemKzgInstance();
-    const blobInput = Blob.getPrefixedEthBlobCommitments(encodedData.blobs);
+    const blobInput = 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');
-      });
-
-    const attestations = encodedData.attestations ? encodedData.attestations.map(attest => attest.toViem()) : [];
-    const txHashes = encodedData.txHashes ? encodedData.txHashes.map(txHash => txHash.toString()) : [];
 
-    const signers = encodedData.attestations
-      ?.filter(attest => !attest.signature.isEmpty())
-      .map(attest => attest.address.toString());
+    // 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 = [
       {
         header: encodedData.header.toViem(),
         archive: toHex(encodedData.archive),
-        stateReference: encodedData.stateReference.toViem(),
         oracleInput: {
           // We are currently not modifying these. See #9963
           feeAssetPriceModifier: 0n,
         },
-        txHashes,
       },
-      RollupContract.packAttestations(attestations),
-      signers ?? [],
+      encodedData.attestationsAndSigners.getPackedAttestations(),
+      signers,
+      encodedData.attestationsAndSignersSignature.toViemSignature(),
       blobInput,
     ] as const;
 
@@ -971,18 +1019,17 @@ export class SequencerPublisher {
       {
         readonly header: ViemHeader;
         readonly archive: `0x${string}`;
-        readonly stateReference: ViemStateReference;
-        readonly txHashes: `0x${string}`[];
         readonly oracleInput: {
           readonly feeAssetPriceModifier: 0n;
         };
       },
       ViemCommitteeAttestations,
-      `0x${string}`[],
+      `0x${string}`[], // Signers
+      ViemSignature,
       `0x${string}`,
     ],
     timestamp: bigint,
-    options: { forcePendingBlockNumber?: number },
+    options: { forcePendingBlockNumber?: BlockNumber },
   ) {
     const rollupData = encodeFunctionData({
       abi: RollupAbi,
@@ -990,19 +1037,42 @@ export class SequencerPublisher {
       args,
     });
 
-    // override the pending block number if requested
-    const forcePendingBlockNumberStateDiff = (
+    // override the pending checkpoint number if requested
+    const optsForcePendingCheckpointNumber =
       options.forcePendingBlockNumber !== undefined
-        ? await this.rollupContract.makePendingBlockNumberOverride(options.forcePendingBlockNumber)
+        ? CheckpointNumber.fromBlockNumber(options.forcePendingBlockNumber)
+        : undefined;
+    const forcePendingCheckpointNumberStateDiff = (
+      optsForcePendingCheckpointNumber !== undefined
+        ? await this.rollupContract.makePendingCheckpointNumberOverride(optsForcePendingCheckpointNumber)
         : []
     ).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) },
+          ...forcePendingCheckpointNumberStateDiff,
+        ],
+      },
+    ];
+    // 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
@@ -1010,16 +1080,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
@@ -1027,7 +1088,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;
       });
 
@@ -1037,7 +1108,7 @@ export class SequencerPublisher {
   private async addProposeTx(
     block: L2Block,
     encodedData: L1ProcessArgs,
-    opts: { txTimeoutAt?: Date; forcePendingBlockNumber?: number } = {},
+    opts: { txTimeoutAt?: Date; forcePendingBlockNumber?: BlockNumber } = {},
     timestamp: bigint,
   ): Promise<void> {
     const timer = new Timer();
@@ -1066,7 +1137,7 @@ export class SequencerPublisher {
         to: this.rollupContract.address,
         data: rollupData,
       },
-      lastValidL2Slot: block.header.globalVariables.slotNumber.toBigInt(),
+      lastValidL2Slot: block.header.globalVariables.slotNumber,
       gasConfig: { ...opts, gasLimit },
       blobConfig: {
         blobs: encodedData.blobs.map(b => b.data),
@@ -1080,17 +1151,20 @@ export class SequencerPublisher {
         const success =
           receipt &&
           receipt.status === 'success' &&
-          tryExtractEvent(receipt.logs, this.rollupContract.address, RollupAbi, 'L2BlockProposed');
+          tryExtractEvent(receipt.logs, this.rollupContract.address, RollupAbi, 'CheckpointProposed');
         if (success) {
           const endBlock = receipt.blockNumber;
           const inclusionBlocks = Number(endBlock - startBlock);
+          const { calldataGas, calldataSize, sender } = stats!;
           const publishStats: L1PublishBlockStats = {
             gasPrice: receipt.effectiveGasPrice,
             gasUsed: receipt.gasUsed,
             blobGasUsed: receipt.blobGasUsed ?? 0n,
             blobDataGas: receipt.blobGasPrice ?? 0n,
             transactionHash: receipt.transactionHash,
-            ...pick(stats!, 'calldataGas', 'calldataSize', 'sender'),
+            calldataGas,
+            calldataSize,
+            sender,
             ...block.getStats(),
             eventName: 'rollup-published-to-l1',
             blobCount: encodedData.blobs.length,
@@ -1106,7 +1180,7 @@ export class SequencerPublisher {
             ...block.getStats(),
             receipt,
             txHash: receipt.transactionHash,
-            slotNumber: block.header.globalVariables.slotNumber.toBigInt(),
+            slotNumber: block.header.globalVariables.slotNumber,
           });
           return false;
         }