@aztec/sequencer-client 0.0.1-commit.358457c → 0.0.1-commit.381b1a9

package/src/client/sequencer-client.ts

@@ -1,4 +1,5 @@
 import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec/constants';
 import { EpochCache } from '@aztec/epoch-cache';
 import { isAnvilTestChain } from '@aztec/ethereum/chain';
 import { getPublicClient } from '@aztec/ethereum/client';
@@ -18,10 +19,15 @@ import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { L1Metrics, type TelemetryClient } from '@aztec/telemetry-client';
 import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
 
-import { type SequencerClientConfig, getPublisherConfigFromSequencerConfig } from '../config.js';
+import {
+  DefaultSequencerConfig,
+  type SequencerClientConfig,
+  getPublisherConfigFromSequencerConfig,
+} from '../config.js';
 import { GlobalVariableBuilder } from '../global_variable_builder/index.js';
 import { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
 import { Sequencer, type SequencerConfig } from '../sequencer/index.js';
+import { SequencerTimetable } from '../sequencer/timetable.js';
 
 /**
  * Encapsulates the full sequencer and publisher.
@@ -137,17 +143,14 @@ export class SequencerClient {
       });
 
     const ethereumSlotDuration = config.ethereumSlotDuration;
-    const l1Constants = { l1GenesisTime, slotDuration: Number(slotDuration), ethereumSlotDuration };
 
-    const globalsBuilder = new GlobalVariableBuilder({ ...config, ...l1Constants, rollupVersion });
-
-    let sequencerManaLimit = config.maxL2BlockGas ?? rollupManaLimit;
-    if (sequencerManaLimit > rollupManaLimit) {
-      log.warn(
-        `Provided maxL2BlockGas ${sequencerManaLimit} is greater than the max allowed by L1. Setting limit to ${rollupManaLimit}.`,
-      );
-      sequencerManaLimit = rollupManaLimit;
-    }
+    const globalsBuilder = new GlobalVariableBuilder({
+      ...config,
+      l1GenesisTime,
+      slotDuration: Number(slotDuration),
+      ethereumSlotDuration,
+      rollupVersion,
+    });
 
     // When running in anvil, assume we can post a tx up until one second before the end of an L1 slot.
     // Otherwise, we need the full L1 slot duration for publishing to ensure inclusion.
@@ -157,6 +160,15 @@ export class SequencerClient {
     const l1PublishingTimeBasedOnChain = isAnvilTestChain(config.l1ChainId) ? 1 : ethereumSlotDuration;
     const l1PublishingTime = config.l1PublishingTime ?? l1PublishingTimeBasedOnChain;
 
+    const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = computeBlockLimits(
+      config,
+      rollupManaLimit,
+      l1PublishingTime,
+      log,
+    );
+
+    const l1Constants = { l1GenesisTime, slotDuration: Number(slotDuration), ethereumSlotDuration, rollupManaLimit };
+
     const sequencer = new Sequencer(
       publisherFactory,
       validatorClient,
@@ -171,7 +183,7 @@ export class SequencerClient {
       deps.dateProvider,
       epochCache,
       rollupContract,
-      { ...config, l1PublishingTime, maxL2BlockGas: sequencerManaLimit },
+      { ...config, l1PublishingTime, maxL2BlockGas, maxDABlockGas, maxTxsPerBlock },
       telemetryClient,
       log,
     );
@@ -234,3 +246,90 @@ export class SequencerClient {
     return this.sequencer.maxL2BlockGas;
   }
 }
+
+/**
+ * Computes per-block L2 gas, DA gas, and TX count budgets based on the L1 rollup limits and the timetable.
+ * If the user explicitly set a limit, it is capped at the corresponding checkpoint limit.
+ * Otherwise, derives it as (checkpointLimit / maxBlocks) * multiplier, capped at the checkpoint limit.
+ */
+export function computeBlockLimits(
+  config: SequencerClientConfig,
+  rollupManaLimit: number,
+  l1PublishingTime: number,
+  log: ReturnType<typeof createLogger>,
+): { maxL2BlockGas: number; maxDABlockGas: number; maxTxsPerBlock: number } {
+  const maxNumberOfBlocks = new SequencerTimetable({
+    ethereumSlotDuration: config.ethereumSlotDuration,
+    aztecSlotDuration: config.aztecSlotDuration,
+    l1PublishingTime,
+    p2pPropagationTime: config.attestationPropagationTime,
+    blockDurationMs: config.blockDurationMs,
+    enforce: config.enforceTimeTable ?? DefaultSequencerConfig.enforceTimeTable,
+  }).maxNumberOfBlocks;
+
+  const multiplier = config.perBlockAllocationMultiplier ?? DefaultSequencerConfig.perBlockAllocationMultiplier;
+
+  // Compute maxL2BlockGas
+  let maxL2BlockGas: number;
+  if (config.maxL2BlockGas !== undefined) {
+    if (config.maxL2BlockGas > rollupManaLimit) {
+      log.warn(
+        `Provided MAX_L2_BLOCK_GAS ${config.maxL2BlockGas} exceeds L1 rollup mana limit ${rollupManaLimit} (capping)`,
+      );
+      maxL2BlockGas = rollupManaLimit;
+    } else {
+      maxL2BlockGas = config.maxL2BlockGas;
+    }
+  } else {
+    maxL2BlockGas = Math.min(rollupManaLimit, Math.ceil((rollupManaLimit / maxNumberOfBlocks) * multiplier));
+  }
+
+  // Compute maxDABlockGas
+  const daCheckpointLimit = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+  let maxDABlockGas: number;
+  if (config.maxDABlockGas !== undefined) {
+    if (config.maxDABlockGas > daCheckpointLimit) {
+      log.warn(
+        `Provided MAX_DA_BLOCK_GAS ${config.maxDABlockGas} exceeds DA checkpoint limit ${daCheckpointLimit} (capping)`,
+      );
+      maxDABlockGas = daCheckpointLimit;
+    } else {
+      maxDABlockGas = config.maxDABlockGas;
+    }
+  } else {
+    maxDABlockGas = Math.min(daCheckpointLimit, Math.ceil((daCheckpointLimit / maxNumberOfBlocks) * multiplier));
+  }
+
+  // Compute maxTxsPerBlock
+  const defaultMaxTxsPerBlock = 32;
+  let maxTxsPerBlock: number;
+  if (config.maxTxsPerBlock !== undefined) {
+    if (config.maxTxsPerCheckpoint !== undefined && config.maxTxsPerBlock > config.maxTxsPerCheckpoint) {
+      log.warn(
+        `Provided MAX_TX_PER_BLOCK ${config.maxTxsPerBlock} exceeds MAX_TX_PER_CHECKPOINT ${config.maxTxsPerCheckpoint} (capping)`,
+      );
+      maxTxsPerBlock = config.maxTxsPerCheckpoint;
+    } else {
+      maxTxsPerBlock = config.maxTxsPerBlock;
+    }
+  } else if (config.maxTxsPerCheckpoint !== undefined) {
+    maxTxsPerBlock = Math.min(
+      config.maxTxsPerCheckpoint,
+      Math.ceil((config.maxTxsPerCheckpoint / maxNumberOfBlocks) * multiplier),
+    );
+  } else {
+    maxTxsPerBlock = defaultMaxTxsPerBlock;
+  }
+
+  log.info(`Computed block limits L2=${maxL2BlockGas} DA=${maxDABlockGas} maxTxs=${maxTxsPerBlock}`, {
+    maxL2BlockGas,
+    maxDABlockGas,
+    maxTxsPerBlock,
+    rollupManaLimit,
+    daCheckpointLimit,
+    maxNumberOfBlocks,
+    multiplier,
+  });
+
+  return { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock };
+}

package/src/config.ts

@@ -35,15 +35,12 @@ export type { SequencerConfig };
  * Default values for SequencerConfig.
  * Centralized location for all sequencer configuration defaults.
  */
-export const DefaultSequencerConfig: ResolvedSequencerConfig = {
+export const DefaultSequencerConfig = {
   sequencerPollingIntervalMS: 500,
-  maxTxsPerBlock: 32,
   minTxsPerBlock: 1,
   buildCheckpointIfEmpty: false,
   publishTxsWithProposals: false,
-  maxL2BlockGas: 10e9,
-  maxDABlockGas: 10e9,
-  maxBlockSizeInBytes: 1024 * 1024,
+  perBlockAllocationMultiplier: 1.2,
   enforceTimeTable: true,
   attestationPropagationTime: DEFAULT_P2P_PROPAGATION_TIME,
   secondsBeforeInvalidatingBlockAsCommitteeMember: 144, // 12 L1 blocks
@@ -52,11 +49,13 @@ export const DefaultSequencerConfig: ResolvedSequencerConfig = {
   skipInvalidateBlockAsProposer: false,
   broadcastInvalidBlockProposal: false,
   injectFakeAttestation: false,
+  injectHighSValueAttestation: false,
+  injectUnrecoverableSignatureAttestation: false,
   fishermanMode: false,
   shuffleAttestationOrdering: false,
   skipPushProposedBlocksToArchiver: false,
   skipPublishingCheckpointsPercent: 0,
-};
+} satisfies ResolvedSequencerConfig;
 
 /**
  * Configuration settings for the SequencerClient.
@@ -68,7 +67,7 @@ export type SequencerClientConfig = SequencerPublisherConfig &
   SequencerConfig &
   L1ReaderConfig &
   ChainConfig &
-  Pick<P2PConfig, 'txPublicSetupAllowList'> &
+  Pick<P2PConfig, 'txPublicSetupAllowListExtend'> &
   Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration' | 'aztecEpochDuration'>;
 
 export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
@@ -77,10 +76,10 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
     description: 'The number of ms to wait between polling for checking to build on the next slot.',
     ...numberConfigHelper(DefaultSequencerConfig.sequencerPollingIntervalMS),
   },
-  maxTxsPerBlock: {
-    env: 'SEQ_MAX_TX_PER_BLOCK',
-    description: 'The maximum number of txs to include in a block.',
-    ...numberConfigHelper(DefaultSequencerConfig.maxTxsPerBlock),
+  maxTxsPerCheckpoint: {
+    env: 'SEQ_MAX_TX_PER_CHECKPOINT',
+    description: 'The maximum number of txs across all blocks in a checkpoint.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
   },
   minTxsPerBlock: {
     env: 'SEQ_MIN_TX_PER_BLOCK',
@@ -99,12 +98,19 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
   maxL2BlockGas: {
     env: 'SEQ_MAX_L2_BLOCK_GAS',
     description: 'The maximum L2 block gas.',
-    ...numberConfigHelper(DefaultSequencerConfig.maxL2BlockGas),
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
   },
   maxDABlockGas: {
     env: 'SEQ_MAX_DA_BLOCK_GAS',
     description: 'The maximum DA block gas.',
-    ...numberConfigHelper(DefaultSequencerConfig.maxDABlockGas),
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
+  perBlockAllocationMultiplier: {
+    env: 'SEQ_PER_BLOCK_ALLOCATION_MULTIPLIER',
+    description:
+      'Per-block gas budget multiplier for both L2 and DA gas. Budget per block is (checkpointLimit / maxBlocks) * multiplier.' +
+      ' Values greater than one allow early blocks to use more than their even share, relying on checkpoint-level capping for later blocks.',
+    ...numberConfigHelper(DefaultSequencerConfig.perBlockAllocationMultiplier),
   },
   coinbase: {
     env: 'COINBASE',
@@ -124,11 +130,6 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
     env: 'ACVM_BINARY_PATH',
     description: 'The path to the ACVM binary',
   },
-  maxBlockSizeInBytes: {
-    env: 'SEQ_MAX_BLOCK_SIZE_IN_BYTES',
-    description: 'Max block size',
-    ...numberConfigHelper(DefaultSequencerConfig.maxBlockSizeInBytes),
-  },
   enforceTimeTable: {
     env: 'SEQ_ENFORCE_TIME_TABLE',
     description: 'Whether to enforce the time table when building blocks',
@@ -186,6 +187,14 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
     description: 'Inject a fake attestation (for testing only)',
     ...booleanConfigHelper(DefaultSequencerConfig.injectFakeAttestation),
   },
+  injectHighSValueAttestation: {
+    description: 'Inject a malleable attestation with a high-s value (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.injectHighSValueAttestation),
+  },
+  injectUnrecoverableSignatureAttestation: {
+    description: 'Inject an attestation with an unrecoverable signature (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.injectUnrecoverableSignatureAttestation),
+  },
   fishermanMode: {
     env: 'FISHERMAN_MODE',
     description:
@@ -214,7 +223,7 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
     description: 'Percent probability (0 - 100) of sequencer skipping checkpoint publishing (testing only)',
     ...numberConfigHelper(DefaultSequencerConfig.skipPublishingCheckpointsPercent),
   },
-  ...pickConfigMappings(p2pConfigMappings, ['txPublicSetupAllowList']),
+  ...pickConfigMappings(p2pConfigMappings, ['txPublicSetupAllowListExtend']),
 };
 
 export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientConfig> = {

package/src/publisher/config.ts

@@ -48,8 +48,6 @@ export type PublisherConfig = L1TxUtilsConfig &
     fishermanMode?: boolean;
     /** Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only) */
     publisherForwarderAddress?: EthAddress;
-    /** Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path */
-    l1TxFailedStore?: string;
   };
 
 export type ProverPublisherConfig = L1TxUtilsConfig &
@@ -64,8 +62,6 @@ export type SequencerPublisherConfig = L1TxUtilsConfig &
     fishermanMode?: boolean;
     sequencerPublisherAllowInvalidStates?: boolean;
     sequencerPublisherForwarderAddress?: EthAddress;
-    /** Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path */
-    l1TxFailedStore?: string;
   };
 
 export function getPublisherConfigFromProverConfig(config: ProverPublisherConfig): PublisherConfig {
@@ -81,7 +77,6 @@ export function getPublisherConfigFromSequencerConfig(config: SequencerPublisher
     ...config,
     publisherAllowInvalidStates: config.sequencerPublisherAllowInvalidStates,
     publisherForwarderAddress: config.sequencerPublisherForwarderAddress,
-    l1TxFailedStore: config.l1TxFailedStore,
   };
 }
 
@@ -138,10 +133,6 @@ export const sequencerPublisherConfigMappings: ConfigMappingsType<SequencerPubli
     description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
     parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
   },
-  l1TxFailedStore: {
-    env: 'L1_TX_FAILED_STORE',
-    description: 'Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path',
-  },
 };
 
 export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherConfig & L1TxUtilsConfig> = {

package/src/publisher/index.ts

@@ -3,6 +3,3 @@ export { SequencerPublisherFactory } from './sequencer-publisher-factory.js';
 
 // Used for tests
 export { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
-
-// Failed L1 tx store (optional, for test networks)
-export { type FailedL1Tx, type FailedL1TxUri, type L1TxFailedStore } from './l1_tx_failed_store/index.js';

package/src/publisher/sequencer-publisher.ts

@@ -45,19 +45,9 @@ import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { L1PublishCheckpointStats } from '@aztec/stdlib/stats';
 import { type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import {
-  type Hex,
-  type StateOverride,
-  type TransactionReceipt,
-  type TypedDataDefinition,
-  encodeFunctionData,
-  keccak256,
-  multicall3Abi,
-  toHex,
-} from 'viem';
+import { type StateOverride, type TransactionReceipt, type TypedDataDefinition, encodeFunctionData, toHex } from 'viem';
 
 import type { SequencerPublisherConfig } from './config.js';
-import { type FailedL1Tx, type L1TxFailedStore, createL1TxFailedStore } from './l1_tx_failed_store/index.js';
 import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
 
 /** Arguments to the process method of the rollup contract */
@@ -119,7 +109,6 @@ export class SequencerPublisher {
   private interrupted = false;
   private metrics: SequencerPublisherMetrics;
   public epochCache: EpochCache;
-  private failedTxStore?: Promise<L1TxFailedStore | undefined>;
 
   protected governanceLog = createLogger('sequencer:publisher:governance');
   protected slashingLog = createLogger('sequencer:publisher:slashing');
@@ -160,7 +149,7 @@ export class SequencerPublisher {
   protected requests: RequestWithExpiry[] = [];
 
   constructor(
-    private config: Pick<SequencerPublisherConfig, 'fishermanMode' | 'l1TxFailedStore'> &
+    private config: Pick<SequencerPublisherConfig, 'fishermanMode'> &
       Pick<L1ContractsConfig, 'ethereumSlotDuration'> & { l1ChainId: number },
     deps: {
       telemetry?: TelemetryClient;
@@ -216,31 +205,6 @@ export class SequencerPublisher {
       this.rollupContract,
       createLogger('sequencer:publisher:price-oracle'),
     );
-
-    // Initialize failed L1 tx store (optional, for test networks)
-    this.failedTxStore = createL1TxFailedStore(config.l1TxFailedStore, this.log);
-  }
-
-  /**
-   * Backs up a failed L1 transaction to the configured store for debugging.
-   * Does nothing if no store is configured.
-   */
-  private backupFailedTx(failedTx: Omit<FailedL1Tx, 'timestamp'>): void {
-    if (!this.failedTxStore) {
-      return;
-    }
-
-    const tx: FailedL1Tx = {
-      ...failedTx,
-      timestamp: Date.now(),
-    };
-
-    // Fire and forget - don't block on backup
-    void this.failedTxStore
-      .then(store => store?.saveFailedTx(tx))
-      .catch(err => {
-        this.log.warn(`Failed to backup failed L1 tx to store`, err);
-      });
   }
 
   public getRollupContract(): RollupContract {
@@ -422,21 +386,6 @@ export class SequencerPublisher {
     validRequests.sort((a, b) => compareActions(a.action, b.action));
 
     try {
-      // Capture context for failed tx backup before sending
-      const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-      const multicallData = encodeFunctionData({
-        abi: multicall3Abi,
-        functionName: 'aggregate3',
-        args: [
-          validRequests.map(r => ({
-            target: r.request.to!,
-            callData: r.request.data!,
-            allowFailure: true,
-          })),
-        ],
-      });
-      const blobDataHex = blobConfig?.blobs?.map(b => toHex(b)) as Hex[] | undefined;
-
       this.log.debug('Forwarding transactions', {
         validRequests: validRequests.map(request => request.action),
         txConfig,
@@ -449,12 +398,7 @@ export class SequencerPublisher {
         this.rollupContract.address,
         this.log,
       );
-      const txContext = { multicallData, blobData: blobDataHex, l1BlockNumber };
-      const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(
-        validRequests,
-        result,
-        txContext,
-      );
+      const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(validRequests, result);
       return { result, expiredActions, sentActions: validActions, successfulActions, failedActions };
     } catch (err) {
       const viemError = formatViemError(err);
@@ -474,25 +418,11 @@ export class SequencerPublisher {
 
   private callbackBundledTransactions(
     requests: RequestWithExpiry[],
-    result: { receipt: TransactionReceipt; errorMsg?: string } | FormattedViemError | undefined,
-    txContext: { multicallData: Hex; blobData?: Hex[]; l1BlockNumber: bigint },
+    result?: { receipt: TransactionReceipt } | FormattedViemError,
   ) {
     const actionsListStr = requests.map(r => r.action).join(', ');
     if (result instanceof FormattedViemError) {
       this.log.error(`Failed to publish bundled transactions (${actionsListStr})`, result);
-      this.backupFailedTx({
-        id: keccak256(txContext.multicallData),
-        failureType: 'send-error',
-        request: { to: MULTI_CALL_3_ADDRESS, data: txContext.multicallData },
-        blobData: txContext.blobData,
-        l1BlockNumber: txContext.l1BlockNumber.toString(),
-        error: { message: result.message, name: result.name },
-        context: {
-          actions: requests.map(r => r.action),
-          requests: requests.map(r => ({ action: r.action, to: r.request.to! as Hex, data: r.request.data! })),
-          sender: this.getSenderAddress().toString(),
-        },
-      });
       return { failedActions: requests.map(r => r.action) };
     } else {
       this.log.verbose(`Published bundled transactions (${actionsListStr})`, { result, requests });
@@ -505,30 +435,6 @@ export class SequencerPublisher {
           failedActions.push(request.action);
         }
       }
-      // Single backup for the whole reverted tx
-      if (failedActions.length > 0 && result?.receipt?.status === 'reverted') {
-        this.backupFailedTx({
-          id: result.receipt.transactionHash,
-          failureType: 'revert',
-          request: { to: MULTI_CALL_3_ADDRESS, data: txContext.multicallData },
-          blobData: txContext.blobData,
-          l1BlockNumber: result.receipt.blockNumber.toString(),
-          receipt: {
-            transactionHash: result.receipt.transactionHash,
-            blockNumber: result.receipt.blockNumber.toString(),
-            gasUsed: (result.receipt.gasUsed ?? 0n).toString(),
-            status: 'reverted',
-          },
-          error: { message: result.errorMsg ?? 'Transaction reverted' },
-          context: {
-            actions: failedActions,
-            requests: requests
-              .filter(r => failedActions.includes(r.action))
-              .map(r => ({ action: r.action, to: r.request.to! as Hex, data: r.request.data! })),
-            sender: this.getSenderAddress().toString(),
-          },
-        });
-      }
       return { successfulActions, failedActions };
     }
   }
@@ -640,8 +546,6 @@ export class SequencerPublisher {
     const request = this.buildInvalidateCheckpointRequest(validationResult);
     this.log.debug(`Simulating invalidate checkpoint ${checkpointNumber}`, { ...logData, request });
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     try {
       const { gasUsed } = await this.l1TxUtils.simulate(
         request,
@@ -693,18 +597,6 @@ export class SequencerPublisher {
 
       // Otherwise, throw. We cannot build the next checkpoint if we cannot invalidate the previous one.
       this.log.error(`Simulation for invalidate checkpoint ${checkpointNumber} failed`, viemError, logData);
-      this.backupFailedTx({
-        id: keccak256(request.data!),
-        failureType: 'simulation',
-        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
-        l1BlockNumber: l1BlockNumber.toString(),
-        error: { message: viemError.message, name: viemError.name },
-        context: {
-          actions: [`invalidate-${reason}`],
-          checkpointNumber,
-          sender: this.getSenderAddress().toString(),
-        },
-      });
       throw new Error(`Failed to simulate invalidate checkpoint ${checkpointNumber}`, { cause: viemError });
     }
   }
@@ -852,26 +744,11 @@ export class SequencerPublisher {
       lastValidL2Slot: slotNumber,
     });
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     try {
       await this.l1TxUtils.simulate(request, { time: timestamp }, [], mergeAbis([request.abi ?? [], ErrorsAbi]));
       this.log.debug(`Simulation for ${action} at slot ${slotNumber} succeeded`, { request });
     } catch (err) {
-      const viemError = formatViemError(err);
-      this.log.error(`Failed simulation for ${action} at slot ${slotNumber} (enqueuing the action anyway)`, viemError);
-      this.backupFailedTx({
-        id: keccak256(request.data!),
-        failureType: 'simulation',
-        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
-        l1BlockNumber: l1BlockNumber.toString(),
-        error: { message: viemError.message, name: viemError.name },
-        context: {
-          actions: [action],
-          slot: slotNumber,
-          sender: this.getSenderAddress().toString(),
-        },
-      });
+      this.log.error(`Failed simulation for ${action} at slot ${slotNumber} (enqueuing the action anyway)`, err);
       // Yes, we enqueue the request anyway, in case there was a bug with the simulation itself
     }
 
@@ -1167,8 +1044,6 @@ export class SequencerPublisher {
 
     this.log.debug(`Simulating ${action} for slot ${slotNumber}`, logData);
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     let gasUsed: bigint;
     const simulateAbi = mergeAbis([request.abi ?? [], ErrorsAbi]);
     try {
@@ -1178,19 +1053,6 @@ export class SequencerPublisher {
       const viemError = formatViemError(err, simulateAbi);
       this.log.error(`Simulation for ${action} at ${slotNumber} failed`, viemError, logData);
 
-      this.backupFailedTx({
-        id: keccak256(request.data!),
-        failureType: 'simulation',
-        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
-        l1BlockNumber: l1BlockNumber.toString(),
-        error: { message: viemError.message, name: viemError.name },
-        context: {
-          actions: [action],
-          slot: slotNumber,
-          sender: this.getSenderAddress().toString(),
-        },
-      });
-
       return false;
     }
 
@@ -1274,27 +1136,9 @@ export class SequencerPublisher {
             kzg,
           },
         )
-        .catch(async err => {
-          const viemError = formatViemError(err);
-          this.log.error(`Failed to validate blobs`, viemError.message, { metaMessages: viemError.metaMessages });
-          const validateBlobsData = encodeFunctionData({
-            abi: RollupAbi,
-            functionName: 'validateBlobs',
-            args: [blobInput],
-          });
-          const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-          this.backupFailedTx({
-            id: keccak256(validateBlobsData),
-            failureType: 'simulation',
-            request: { to: this.rollupContract.address as Hex, data: validateBlobsData },
-            blobData: encodedData.blobs.map(b => toHex(b.data)) as Hex[],
-            l1BlockNumber: l1BlockNumber.toString(),
-            error: { message: viemError.message, name: viemError.name },
-            context: {
-              actions: ['validate-blobs'],
-              sender: this.getSenderAddress().toString(),
-            },
-          });
+        .catch(err => {
+          const { message, metaMessages } = formatViemError(err);
+          this.log.error(`Failed to validate blobs`, message, { metaMessages });
           throw new Error('Failed to validate blobs');
         });
     }
@@ -1373,8 +1217,6 @@ export class SequencerPublisher {
       });
     }
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     const simulationResult = await this.l1TxUtils
       .simulate(
         {
@@ -1408,18 +1250,6 @@ export class SequencerPublisher {
           };
         }
         this.log.error(`Failed to simulate propose tx`, viemError);
-        this.backupFailedTx({
-          id: keccak256(rollupData),
-          failureType: 'simulation',
-          request: { to: this.rollupContract.address, data: rollupData },
-          l1BlockNumber: l1BlockNumber.toString(),
-          error: { message: viemError.message, name: viemError.name },
-          context: {
-            actions: ['propose'],
-            slot: Number(args[0].header.slotNumber),
-            sender: this.getSenderAddress().toString(),
-          },
-        });
         throw err;
       });