@aztec/sequencer-client 0.0.0-test.0 → 0.0.1-commit.001888fc

package/src/publisher/config.ts

@@ -1,75 +1,166 @@
-import { type BlobSinkConfig, blobSinkConfigMapping } from '@aztec/blob-sink/client';
-import {
-  type L1ReaderConfig,
-  type L1TxUtilsConfig,
-  NULL_KEY,
-  l1ReaderConfigMappings,
-  l1TxUtilsConfigMappings,
-} from '@aztec/ethereum';
-import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
+import { type BlobClientConfig, blobClientConfigMapping } from '@aztec/blob-client/client/config';
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
+import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from '@aztec/ethereum/l1-tx-utils/config';
+import { type ConfigMappingsType, SecretValue, booleanConfigHelper } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
-/**
- * The configuration of the rollup transaction publisher.
- */
+/** Configuration of the transaction publisher. */
 export type TxSenderConfig = L1ReaderConfig & {
-  /**
-   * The private key to be used by the publisher.
-   */
-  publisherPrivateKey: `0x${string}`;
+  /** The private key to be used by the publisher. */
+  publisherPrivateKeys?: SecretValue<`0x${string}`>[];
 
-  /**
-   * The address of the custom forwarder contract.
-   */
-  customForwarderContractAddress: EthAddress;
+  /** Publisher addresses to be used with a remote signer */
+  publisherAddresses?: EthAddress[];
 };
 
-/**
- * Configuration of the L1Publisher.
- */
+export type ProverTxSenderConfig = L1ReaderConfig & {
+  proverPublisherPrivateKeys?: SecretValue<`0x${string}`>[];
+  proverPublisherAddresses?: EthAddress[];
+};
+
+export type SequencerTxSenderConfig = L1ReaderConfig & {
+  sequencerPublisherPrivateKeys?: SecretValue<`0x${string}`>[];
+  sequencerPublisherAddresses?: EthAddress[];
+};
+
+export function getTxSenderConfigFromProverConfig(config: ProverTxSenderConfig): TxSenderConfig {
+  return {
+    ...config,
+    publisherPrivateKeys: config.proverPublisherPrivateKeys,
+    publisherAddresses: config.proverPublisherAddresses,
+  };
+}
+
+export function getTxSenderConfigFromSequencerConfig(config: SequencerTxSenderConfig): TxSenderConfig {
+  return {
+    ...config,
+    publisherPrivateKeys: config.sequencerPublisherPrivateKeys,
+    publisherAddresses: config.sequencerPublisherAddresses,
+  };
+}
+
+/** Configuration of the L1Publisher. */
 export type PublisherConfig = L1TxUtilsConfig &
-  BlobSinkConfig & {
-    /**
-     * The interval to wait between publish retries.
-     */
-    l1PublishRetryIntervalMS: number;
+  BlobClientConfig & {
+    /** 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;
+    /** 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 &
+  BlobClientConfig & {
+    fishermanMode?: boolean;
+    proverPublisherAllowInvalidStates?: boolean;
+    proverPublisherForwarderAddress?: EthAddress;
+  };
+
+export type SequencerPublisherConfig = L1TxUtilsConfig &
+  BlobClientConfig & {
+    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 {
+  return {
+    ...config,
+    publisherAllowInvalidStates: config.proverPublisherAllowInvalidStates,
+    publisherForwarderAddress: config.proverPublisherForwarderAddress,
+  };
+}
+
+export function getPublisherConfigFromSequencerConfig(config: SequencerPublisherConfig): PublisherConfig {
+  return {
+    ...config,
+    publisherAllowInvalidStates: config.sequencerPublisherAllowInvalidStates,
+    publisherForwarderAddress: config.sequencerPublisherForwarderAddress,
+    l1TxFailedStore: config.l1TxFailedStore,
   };
+}
 
-export const getTxSenderConfigMappings: (
-  scope: 'PROVER' | 'SEQ',
-) => ConfigMappingsType<Omit<TxSenderConfig, 'l1Contracts'>> = (scope: 'PROVER' | 'SEQ') => ({
+export const proverTxSenderConfigMappings: ConfigMappingsType<Omit<ProverTxSenderConfig, 'l1Contracts'>> = {
   ...l1ReaderConfigMappings,
-  customForwarderContractAddress: {
-    env: `CUSTOM_FORWARDER_CONTRACT_ADDRESS`,
-    parseEnv: (val: string) => EthAddress.fromString(val),
-    description: 'The address of the custom forwarder contract.',
-    defaultValue: EthAddress.ZERO,
+  proverPublisherPrivateKeys: {
+    env: `PROVER_PUBLISHER_PRIVATE_KEYS`,
+    description: 'The private keys to be used by the prover publisher.',
+    parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
+    defaultValue: [],
+    fallback: [`PROVER_PUBLISHER_PRIVATE_KEY`],
   },
-  publisherPrivateKey: {
-    env: scope === 'PROVER' ? `PROVER_PUBLISHER_PRIVATE_KEY` : `SEQ_PUBLISHER_PRIVATE_KEY`,
-    description: 'The private key to be used by the publisher.',
-    parseEnv: (val: string) => (val ? `0x${val.replace('0x', '')}` : NULL_KEY),
-    defaultValue: NULL_KEY,
+  proverPublisherAddresses: {
+    env: `PROVER_PUBLISHER_ADDRESSES`,
+    description: 'The addresses of the publishers to use with remote signers',
+    parseEnv: (val: string) => val.split(',').map(address => EthAddress.fromString(address)),
+    defaultValue: [],
   },
-});
-
-export function getTxSenderConfigFromEnv(scope: 'PROVER' | 'SEQ'): Omit<TxSenderConfig, 'l1Contracts'> {
-  return getConfigFromMappings(getTxSenderConfigMappings(scope));
-}
+};
 
-export const getPublisherConfigMappings: (
-  scope: 'PROVER' | 'SEQ',
-) => ConfigMappingsType<PublisherConfig & L1TxUtilsConfig> = scope => ({
-  l1PublishRetryIntervalMS: {
-    env: scope === `PROVER` ? `PROVER_PUBLISH_RETRY_INTERVAL_MS` : `SEQ_PUBLISH_RETRY_INTERVAL_MS`,
-    parseEnv: (val: string) => +val,
-    defaultValue: 1000,
-    description: 'The interval to wait between publish retries.',
+export const sequencerTxSenderConfigMappings: ConfigMappingsType<Omit<SequencerTxSenderConfig, 'l1Contracts'>> = {
+  ...l1ReaderConfigMappings,
+  sequencerPublisherPrivateKeys: {
+    env: `SEQ_PUBLISHER_PRIVATE_KEYS`,
+    description: 'The private keys to be used by the sequencer publisher.',
+    parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
+    defaultValue: [],
+    fallback: [`SEQ_PUBLISHER_PRIVATE_KEY`],
   },
+  sequencerPublisherAddresses: {
+    env: `SEQ_PUBLISHER_ADDRESSES`,
+    description: 'The addresses of the publishers to use with remote signers',
+    parseEnv: (val: string) => val.split(',').map(address => EthAddress.fromString(address)),
+    defaultValue: [],
+  },
+};
+
+export const sequencerPublisherConfigMappings: ConfigMappingsType<SequencerPublisherConfig & L1TxUtilsConfig> = {
   ...l1TxUtilsConfigMappings,
-  ...blobSinkConfigMapping,
-});
+  ...blobClientConfigMapping,
+  sequencerPublisherAllowInvalidStates: {
+    env: `SEQ_PUBLISHER_ALLOW_INVALID_STATES`,
+    description: 'True to use publishers in invalid states (timed out, cancelled, etc) if no other is available',
+    ...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),
+  },
+  sequencerPublisherForwarderAddress: {
+    env: `SEQ_PUBLISHER_FORWARDER_ADDRESS`,
+    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 function getPublisherConfigFromEnv(scope: 'PROVER' | 'SEQ'): PublisherConfig {
-  return getConfigFromMappings(getPublisherConfigMappings(scope));
-}
+export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherConfig & L1TxUtilsConfig> = {
+  ...l1TxUtilsConfigMappings,
+  ...blobClientConfigMapping,
+  proverPublisherAllowInvalidStates: {
+    env: `PROVER_PUBLISHER_ALLOW_INVALID_STATES`,
+    description: 'True to use publishers in invalid states (timed out, cancelled, etc) if no other is available',
+    ...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),
+  },
+  proverPublisherForwarderAddress: {
+    env: `PROVER_PUBLISHER_FORWARDER_ADDRESS`,
+    description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
+    parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
+  },
+};

package/src/publisher/index.ts

@@ -1 +1,8 @@
 export { SequencerPublisher } from './sequencer-publisher.js';
+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/l1_tx_failed_store/factory.ts

@@ -0,0 +1,32 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { createFileStore } from '@aztec/stdlib/file-store';
+
+import type { L1TxFailedStore } from './failed_tx_store.js';
+import { FileStoreL1TxFailedStore } from './file_store_failed_tx_store.js';
+
+/**
+ * Creates an L1TxFailedStore from a config string.
+ * Supports any backend that FileStore supports (GCS, S3, R2, local filesystem).
+ * @param config - Config string (e.g., 'gs://bucket/path', 's3://bucket/path', 'file:///path'). If undefined, returns undefined.
+ * @param logger - Optional logger.
+ * @returns The store instance, or undefined if config is not provided.
+ */
+export async function createL1TxFailedStore(
+  config: string | undefined,
+  logger: Logger = createLogger('sequencer:l1-tx-failed-store'),
+): Promise<L1TxFailedStore | undefined> {
+  if (!config) {
+    return undefined;
+  }
+
+  const fileStore = await createFileStore(config, logger);
+  if (!fileStore) {
+    throw new Error(
+      `Failed to create file store from config: '${config}'. ` +
+        `Supported formats: 'gs://bucket/path', 's3://bucket/path', 'file:///path'.`,
+    );
+  }
+
+  logger.info(`Created L1 tx failed store`, { config });
+  return new FileStoreL1TxFailedStore(fileStore, logger);
+}

package/src/publisher/l1_tx_failed_store/failed_tx_store.ts

@@ -0,0 +1,55 @@
+import type { Hex } from 'viem';
+
+/** URI pointing to a stored failed L1 transaction. */
+export type FailedL1TxUri = string & { __brand: 'FailedL1TxUri' };
+
+/** A failed L1 transaction captured for debugging and replay. */
+export type FailedL1Tx = {
+  /** Tx hash (for reverts) or keccak256(request.data) (for simulation/send failures). */
+  id: Hex;
+  /** Unix timestamp (ms) when failure occurred. */
+  timestamp: number;
+  /** Whether the failure was during simulation or after sending. */
+  failureType: 'simulation' | 'revert' | 'send-error';
+  /** The actual L1 transaction for replay (multicall-encoded for bundled txs). */
+  request: {
+    to: Hex;
+    data: Hex;
+    value?: string; // bigint as string
+  };
+  /** Raw blob data as hex for replay. */
+  blobData?: Hex[];
+  /** L1 block number at time of failure (simulation target or receipt block). */
+  l1BlockNumber: string; // bigint as string
+  /** Receipt info (present only for on-chain reverts). */
+  receipt?: {
+    transactionHash: Hex;
+    blockNumber: string; // bigint as string
+    gasUsed: string; // bigint as string
+    status: 'reverted';
+  };
+  /** Error information. */
+  error: {
+    message: string;
+    /** Decoded error name (e.g., 'Rollup__InvalidProposer'). */
+    name?: string;
+  };
+  /** Context metadata. */
+  context: {
+    /** Actions involved (e.g., ['propose', 'governance-signal']). */
+    actions: string[];
+    /** Individual request data for each action (metadata, not used for replay). */
+    requests?: Array<{ action: string; to: Hex; data: Hex }>;
+    checkpointNumber?: number;
+    slot?: number;
+    sender: Hex;
+  };
+};
+
+/** Store for failed L1 transactions for debugging purposes. */
+export interface L1TxFailedStore {
+  /** Saves a failed transaction and returns its URI. */
+  saveFailedTx(tx: FailedL1Tx): Promise<FailedL1TxUri>;
+  /** Retrieves a failed transaction by its URI. */
+  getFailedTx(uri: FailedL1TxUri): Promise<FailedL1Tx>;
+}

package/src/publisher/l1_tx_failed_store/file_store_failed_tx_store.ts

@@ -0,0 +1,46 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { FileStore } from '@aztec/stdlib/file-store';
+
+import type { FailedL1Tx, FailedL1TxUri, L1TxFailedStore } from './failed_tx_store.js';
+
+/**
+ * L1TxFailedStore implementation using the FileStore abstraction.
+ * Supports any backend that FileStore supports (GCS, S3, R2, local filesystem).
+ */
+export class FileStoreL1TxFailedStore implements L1TxFailedStore {
+  private readonly log: Logger;
+
+  constructor(
+    private readonly fileStore: FileStore,
+    logger?: Logger,
+  ) {
+    this.log = logger ?? createLogger('sequencer:l1-tx-failed-store');
+  }
+
+  public async saveFailedTx(tx: FailedL1Tx): Promise<FailedL1TxUri> {
+    const prefix = tx.receipt ? 'tx' : 'data';
+    const path = `${tx.failureType}/${prefix}-${tx.id}.json`;
+    const json = JSON.stringify(tx, null, 2);
+
+    const uri = await this.fileStore.save(path, Buffer.from(json), {
+      metadata: {
+        'content-type': 'application/json',
+        actions: tx.context.actions.join(','),
+        'failure-type': tx.failureType,
+      },
+    });
+
+    this.log.info(`Saved failed L1 tx to ${uri}`, {
+      id: tx.id,
+      failureType: tx.failureType,
+      actions: tx.context.actions.join(','),
+    });
+
+    return uri as FailedL1TxUri;
+  }
+
+  public async getFailedTx(uri: FailedL1TxUri): Promise<FailedL1Tx> {
+    const data = await this.fileStore.read(uri);
+    return JSON.parse(data.toString()) as FailedL1Tx;
+  }
+}

package/src/publisher/l1_tx_failed_store/index.ts

@@ -0,0 +1,3 @@
+export { type FailedL1Tx, type FailedL1TxUri, type L1TxFailedStore } from './failed_tx_store.js';
+export { createL1TxFailedStore } from './factory.js';
+export { FileStoreL1TxFailedStore } from './file_store_failed_tx_store.js';

package/src/publisher/sequencer-publisher-factory.ts

@@ -0,0 +1,124 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import type { EpochCache } from '@aztec/epoch-cache';
+import type { GovernanceProposerContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
+import type { PublisherFilter, PublisherManager } from '@aztec/ethereum/publisher-manager';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
+import type { TelemetryClient } from '@aztec/telemetry-client';
+import { NodeKeystoreAdapter } from '@aztec/validator-client';
+
+import type { SequencerClientConfig } from '../config.js';
+import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
+import { type Action, SequencerPublisher } from './sequencer-publisher.js';
+
+export type AttestorPublisherPair = {
+  attestorAddress: EthAddress;
+  publisher: SequencerPublisher;
+};
+
+export class SequencerPublisherFactory {
+  private publisherMetrics: SequencerPublisherMetrics;
+
+  /** Stores the last slot in which every action was carried out by a publisher */
+  private lastActions: Partial<Record<Action, SlotNumber>> = {};
+
+  private nodeKeyStore: NodeKeystoreAdapter;
+
+  private logger: Logger;
+
+  constructor(
+    private sequencerConfig: SequencerClientConfig,
+    private deps: {
+      telemetry: TelemetryClient;
+      publisherManager: PublisherManager<L1TxUtils>;
+      blobClient: BlobClientInterface;
+      dateProvider: DateProvider;
+      epochCache: EpochCache;
+      rollupContract: RollupContract;
+      governanceProposerContract: GovernanceProposerContract;
+      slashFactoryContract: SlashFactoryContract;
+      nodeKeyStore: NodeKeystoreAdapter;
+      logger?: Logger;
+    },
+  ) {
+    this.publisherMetrics = new SequencerPublisherMetrics(deps.telemetry, 'SequencerPublisher');
+    this.logger = deps.logger ?? createLogger('sequencer');
+    this.nodeKeyStore = this.deps.nodeKeyStore;
+  }
+
+  /**
+   * Updates the node keystore adapter used for publisher lookups.
+   * Called when the keystore is reloaded at runtime to reflect new validator-publisher mappings.
+   */
+  public updateNodeKeyStore(adapter: NodeKeystoreAdapter): void {
+    this.nodeKeyStore = adapter;
+  }
+
+  /**
+   * Creates a new SequencerPublisher instance.
+   * @param _validatorAddress - The address of the validator that will be using the publisher.
+   * @returns A new SequencerPublisher instance.
+   */
+  public async create(validatorAddress?: EthAddress): Promise<AttestorPublisherPair> {
+    // If we have been given an attestor address we must only allow publishers permitted for that attestor
+
+    const allowedPublishers = !validatorAddress ? [] : this.nodeKeyStore.getPublisherAddresses(validatorAddress);
+    const filter: PublisherFilter<L1TxUtils> = !validatorAddress
+      ? () => true
+      : (utils: L1TxUtils) => {
+          const publisherAddress = utils.getSenderAddress();
+          return allowedPublishers.some(allowedPublisher => allowedPublisher.equals(publisherAddress));
+        };
+
+    const l1Publisher = await this.deps.publisherManager.getAvailablePublisher(filter);
+    const attestorAddress =
+      validatorAddress ?? this.nodeKeyStore.getAttestorForPublisher(l1Publisher.getSenderAddress());
+
+    const rollup = this.deps.rollupContract;
+    const slashingProposerContract = await rollup.getSlashingProposer();
+
+    const getNextPublisher = async (excludeAddresses: EthAddress[]): Promise<L1TxUtils | undefined> => {
+      const exclusionFilter: PublisherFilter<L1TxUtils> = (utils: L1TxUtils) => {
+        if (excludeAddresses.some(addr => addr.equals(utils.getSenderAddress()))) {
+          return false;
+        }
+        return filter(utils);
+      };
+      try {
+        return await this.deps.publisherManager.getAvailablePublisher(exclusionFilter);
+      } catch {
+        return undefined;
+      }
+    };
+
+    const publisher = new SequencerPublisher(this.sequencerConfig, {
+      l1TxUtils: l1Publisher,
+      getNextPublisher,
+      telemetry: this.deps.telemetry,
+      blobClient: this.deps.blobClient,
+      rollupContract: this.deps.rollupContract,
+      epochCache: this.deps.epochCache,
+      governanceProposerContract: this.deps.governanceProposerContract,
+      slashingProposerContract,
+      slashFactoryContract: this.deps.slashFactoryContract,
+      dateProvider: this.deps.dateProvider,
+      metrics: this.publisherMetrics,
+      lastActions: this.lastActions,
+      log: this.logger.createChild('publisher'),
+    });
+
+    return {
+      attestorAddress,
+      publisher,
+    };
+  }
+
+  /** Interrupts all publishers managed by this factory. Used during sequencer shutdown. */
+  public interruptAll(): void {
+    this.deps.publisherManager.interrupt();
+  }
+}

package/src/publisher/sequencer-publisher-metrics.ts

@@ -1,5 +1,5 @@
-import { createLogger } from '@aztec/aztec.js';
-import type { L1PublishBlockStats, L1PublishStats } from '@aztec/stdlib/stats';
+import { createLogger } from '@aztec/aztec.js/log';
+import type { L1PublishCheckpointStats, L1PublishStats } from '@aztec/stdlib/stats';
 import {
   Attributes,
   type Gauge,
@@ -7,7 +7,7 @@ import {
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import { formatEther } from 'viem/utils';
@@ -24,6 +24,7 @@ export class SequencerPublisherMetrics {
   private txCalldataGas: Histogram;
   private txBlobDataGasUsed: Histogram;
   private txBlobDataGasCost: Histogram;
+  private txTotalFee: Histogram;
 
   private readonly blobCountHistogram: Histogram;
   private readonly blobInclusionBlocksHistogram: Histogram;
@@ -39,77 +40,36 @@ export class SequencerPublisherMetrics {
   ) {
     const meter = client.getMeter(name);
 
-    this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE, {
-      description: 'The gas price used for transactions',
-      unit: 'gwei',
-      valueType: ValueType.DOUBLE,
-    });
+    this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE);
 
-    this.txCount = meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT, {
-      description: 'The number of transactions processed',
+    this.txCount = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_TX_COUNT, {
+      [Attributes.L1_TX_TYPE]: ['process'],
+      [Attributes.OK]: [true, false],
     });
 
-    this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION, {
-      description: 'The duration of transaction processing',
-      unit: 'ms',
-      valueType: ValueType.INT,
-    });
+    this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION);
 
-    this.txGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_GAS, {
-      description: 'The gas consumed by transactions',
-      unit: 'gas',
-      valueType: ValueType.INT,
-    });
+    this.txGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_GAS);
 
-    this.txCalldataSize = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_SIZE, {
-      description: 'The size of the calldata in transactions',
-      unit: 'By',
-      valueType: ValueType.INT,
-    });
+    this.txCalldataSize = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_SIZE);
 
-    this.txCalldataGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_GAS, {
-      description: 'The gas consumed by the calldata in transactions',
-      unit: 'gas',
-      valueType: ValueType.INT,
-    });
+    this.txCalldataGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_GAS);
 
-    this.txBlobDataGasUsed = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_USED, {
-      description: 'The amount of blob gas used in transactions',
-      unit: 'gas',
-      valueType: ValueType.INT,
-    });
+    this.txBlobDataGasUsed = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_USED);
 
-    this.txBlobDataGasCost = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_COST, {
-      description: 'The gas cost of blobs in transactions',
-      unit: 'gwei',
-      valueType: ValueType.INT,
-    });
+    this.txBlobDataGasCost = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_COST);
 
-    this.blobCountHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_COUNT, {
-      description: 'Number of blobs in L1 transactions',
-      unit: 'blobs',
-      valueType: ValueType.INT,
-    });
+    this.blobCountHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_COUNT);
 
-    this.blobInclusionBlocksHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_INCLUSION_BLOCKS, {
-      description: 'Number of L1 blocks between blob tx submission and inclusion',
-      unit: 'blocks',
-      valueType: ValueType.INT,
-    });
+    this.blobInclusionBlocksHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_INCLUSION_BLOCKS);
 
-    this.blobTxSuccessCounter = meter.createUpDownCounter(Metrics.L1_PUBLISHER_BLOB_TX_SUCCESS, {
-      description: 'Number of successful L1 transactions with blobs',
-    });
+    this.blobTxSuccessCounter = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_BLOB_TX_SUCCESS);
 
-    this.blobTxFailureCounter = meter.createUpDownCounter(Metrics.L1_PUBLISHER_BLOB_TX_FAILURE, {
-      description: 'Number of failed L1 transactions with blobs',
-    });
+    this.blobTxFailureCounter = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_BLOB_TX_FAILURE);
 
-    this.senderBalance = meter.createGauge(Metrics.L1_PUBLISHER_BALANCE, {
-      unit: 'eth',
-      description: 'The balance of the sender address',
-      valueType: ValueType.DOUBLE,
-    });
+    this.txTotalFee = meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE);
+
+    this.senderBalance = meter.createGauge(Metrics.L1_PUBLISHER_BALANCE);
   }
 
   recordFailedTx(txType: L1TxType) {
@@ -123,7 +83,7 @@ export class SequencerPublisherMetrics {
     }
   }
 
-  recordProcessBlockTx(durationMs: number, stats: L1PublishBlockStats) {
+  recordProcessBlockTx(durationMs: number, stats: L1PublishCheckpointStats) {
     this.recordTx('process', durationMs, stats);
 
     if (stats.blobCount && stats.blobCount > 0) {
@@ -169,7 +129,17 @@ export class SequencerPublisherMetrics {
 
     try {
       this.gasPrice.record(parseInt(formatEther(stats.gasPrice, 'gwei'), 10));
-    } catch (e) {
+    } catch {
+      // ignore
+    }
+
+    const executionFee = stats.gasUsed * stats.gasPrice;
+    const blobFee = stats.blobGasUsed * stats.blobDataGas;
+    const totalFee = executionFee + blobFee;
+
+    try {
+      this.txTotalFee.record(parseFloat(formatEther(totalFee)));
+    } catch {
       // ignore
     }
   }