@aztec/sequencer-client 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/global_variable_builder/global_builder.ts

@@ -1,69 +1,98 @@
-import {
-  type L1ContractsConfig,
-  type L1ReaderConfig,
-  type ViemPublicClient,
-  createEthereumChain,
-} from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import type { L1ContractsConfig } from '@aztec/ethereum/config';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ReaderConfig } from '@aztec/ethereum/l1-reader';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { RollupAbi } from '@aztec/l1-artifacts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type L1RollupConstants, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
-import type { GlobalVariableBuilder as GlobalVariableBuilderInterface } from '@aztec/stdlib/tx';
+import type {
+  CheckpointGlobalVariables,
+  GlobalVariableBuilder as GlobalVariableBuilderInterface,
+} from '@aztec/stdlib/tx';
 import { GlobalVariables } from '@aztec/stdlib/tx';
 
-import { type GetContractReturnType, createPublicClient, fallback, getAddress, getContract, http } from 'viem';
+import { createPublicClient, fallback, http } from 'viem';
 
 /**
  * Simple global variables builder.
  */
 export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
   private log = createLogger('sequencer:global_variable_builder');
-
-  private rollupContract: GetContractReturnType<typeof RollupAbi, ViemPublicClient>;
-  private publicClient: ViemPublicClient;
-  private ethereumSlotDuration: number;
-
-  constructor(config: L1ReaderConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'>) {
+  private currentMinFees: Promise<GasFees> = Promise.resolve(new GasFees(0, 0));
+  private currentL1BlockNumber: bigint | undefined = undefined;
+
+  private readonly rollupContract: RollupContract;
+  private readonly publicClient: ViemPublicClient;
+  private readonly ethereumSlotDuration: number;
+  private readonly aztecSlotDuration: number;
+  private readonly l1GenesisTime: bigint;
+
+  private chainId: Fr;
+  private version: Fr;
+
+  constructor(
+    config: L1ReaderConfig &
+      Pick<L1ContractsConfig, 'ethereumSlotDuration'> &
+      Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'> & { rollupVersion: bigint },
+  ) {
     const { l1RpcUrls, l1ChainId: chainId, l1Contracts } = config;
 
     const chain = createEthereumChain(l1RpcUrls, chainId);
 
+    this.version = new Fr(config.rollupVersion);
+    this.chainId = new Fr(chainId);
+
     this.ethereumSlotDuration = config.ethereumSlotDuration;
+    this.aztecSlotDuration = config.slotDuration;
+    this.l1GenesisTime = config.l1GenesisTime;
 
     this.publicClient = createPublicClient({
       chain: chain.chainInfo,
-      transport: fallback(chain.rpcUrls.map(url => http(url))),
+      transport: fallback(chain.rpcUrls.map(url => http(url, { batch: false }))),
       pollingInterval: config.viemPollingIntervalMS,
     });
 
-    this.rollupContract = getContract({
-      address: getAddress(l1Contracts.rollupAddress.toString()),
-      abi: RollupAbi,
-      client: this.publicClient,
-    });
+    this.rollupContract = new RollupContract(this.publicClient, l1Contracts.rollupAddress);
   }
 
   /**
-   * Computes the "current" base fees, e.g., the price that you currently should pay to get include in the next block
-   * @returns Base fees for the expected next block
+   * Computes the "current" min fees, e.g., the price that you currently should pay to get include in the next block
+   * @returns Min fees for the next block
    */
-  public async getCurrentBaseFees(): Promise<GasFees> {
+  private async computeCurrentMinFees(): Promise<GasFees> {
     // Since this might be called in the middle of a slot where a block might have been published,
     // we need to fetch the last block written, and estimate the earliest timestamp for the next block.
     // The timestamp of that last block will act as a lower bound for the next block.
 
-    const lastBlock = await this.rollupContract.read.getBlock([await this.rollupContract.read.getPendingBlockNumber()]);
-    const earliestTimestamp = await this.rollupContract.read.getTimestampForSlot([lastBlock.slotNumber + 1n]);
+    const lastCheckpoint = await this.rollupContract.getPendingCheckpoint();
+    const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
+      SlotNumber.fromBigInt(BigInt(lastCheckpoint.slotNumber) + 1n),
+    );
     const nextEthTimestamp = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
     const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
 
-    return new GasFees(Fr.ZERO, new Fr(await this.rollupContract.read.getManaBaseFeeAt([timestamp, true])));
+    return new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
+  }
+
+  public async getCurrentMinFees(): Promise<GasFees> {
+    // Get the current block number
+    const blockNumber = await this.publicClient.getBlockNumber();
+
+    // If the L1 block number has changed then chain a new promise to get the current min fees
+    if (this.currentL1BlockNumber === undefined || blockNumber > this.currentL1BlockNumber) {
+      this.currentL1BlockNumber = blockNumber;
+      this.currentMinFees = this.currentMinFees.then(() => this.computeCurrentMinFees());
+    }
+    return this.currentMinFees;
   }
 
   /**
-   * Simple builder of global variables that use the minimum time possible.
+   * Simple builder of global variables.
    * @param blockNumber - The block number to build global variables for.
    * @param coinbase - The address to receive block reward.
    * @param feeRecipient - The address to receive fees.
@@ -71,38 +100,38 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
    * @returns The global variables for the given block number.
    */
   public async buildGlobalVariables(
-    blockNumber: Fr,
+    blockNumber: BlockNumber,
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
-    slotNumber?: bigint,
+    maybeSlot?: SlotNumber,
   ): Promise<GlobalVariables> {
-    const version = new Fr(await this.rollupContract.read.getVersion());
-    const chainId = new Fr(this.publicClient.chain.id);
-
-    if (slotNumber === undefined) {
-      const ts = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
-      slotNumber = await this.rollupContract.read.getSlotAt([ts]);
-    }
-
-    const timestamp = await this.rollupContract.read.getTimestampForSlot([slotNumber]);
+    const slot: SlotNumber =
+      maybeSlot ??
+      (await this.rollupContract.getSlotAt(
+        BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration)),
+      ));
+
+    const checkpointGlobalVariables = await this.buildCheckpointGlobalVariables(coinbase, feeRecipient, slot);
+    return GlobalVariables.from({ blockNumber, ...checkpointGlobalVariables });
+  }
 
-    const slotFr = new Fr(slotNumber);
-    const timestampFr = new Fr(timestamp);
+  /** Builds global variables that are constant throughout a checkpoint. */
+  public async buildCheckpointGlobalVariables(
+    coinbase: EthAddress,
+    feeRecipient: AztecAddress,
+    slotNumber: SlotNumber,
+  ): Promise<CheckpointGlobalVariables & { timestamp: bigint }> {
+    const { chainId, version } = this;
 
-    // We can skip much of the logic in getCurrentBaseFees since it we already check that we are not within a slot elsewhere.
-    const gasFees = new GasFees(Fr.ZERO, new Fr(await this.rollupContract.read.getManaBaseFeeAt([timestamp, true])));
+    const timestamp = getTimestampForSlot(slotNumber, {
+      slotDuration: this.aztecSlotDuration,
+      l1GenesisTime: this.l1GenesisTime,
+    });
 
-    const globalVariables = new GlobalVariables(
-      chainId,
-      version,
-      blockNumber,
-      slotFr,
-      timestampFr,
-      coinbase,
-      feeRecipient,
-      gasFees,
-    );
+    // We can skip much of the logic in getCurrentMinFees since it we already check that we are not within a slot elsewhere.
+    // TODO(palla/mbps): Can we use a cached value here?
+    const gasFees = new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
 
-    return globalVariables;
+    return { chainId, version, slotNumber, timestamp, coinbase, feeRecipient, gasFees };
   }
 }

package/src/index.ts

@@ -1,9 +1,7 @@
 export * from './client/index.js';
 export * from './config.js';
 export * from './publisher/index.js';
-export * from './tx_validator/tx_validator_factory.js';
-export * from './slasher/index.js';
-export { Sequencer, SequencerState, getDefaultAllowedSetupFunctions } from './sequencer/index.js';
+export { Sequencer, SequencerState, type SequencerEvents } from './sequencer/index.js';
 
 // Used by the node to simulate public parts of transactions. Should these be moved to a shared library?
 // ISSUE(#9832)

package/src/publisher/config.ts

@@ -1,12 +1,12 @@
-import { type BlobSinkConfig, blobSinkConfigMapping } from '@aztec/blob-sink/client';
+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 L1ReaderConfig,
-  type L1TxUtilsConfig,
-  NULL_KEY,
-  l1ReaderConfigMappings,
-  l1TxUtilsConfigMappings,
-} from '@aztec/ethereum';
-import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
+  type ConfigMappingsType,
+  SecretValue,
+  booleanConfigHelper,
+  getConfigFromMappings,
+} from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 /**
@@ -16,40 +16,43 @@ export type TxSenderConfig = L1ReaderConfig & {
   /**
    * The private key to be used by the publisher.
    */
-  publisherPrivateKey: `0x${string}`;
+  publisherPrivateKeys?: SecretValue<`0x${string}`>[];
 
   /**
-   * The address of the custom forwarder contract.
+   * Publisher addresses to be used with a remote signer
    */
-  customForwarderContractAddress: EthAddress;
+  publisherAddresses?: EthAddress[];
 };
 
 /**
  * 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;
   };
 
 export const getTxSenderConfigMappings: (
   scope: 'PROVER' | 'SEQ',
 ) => ConfigMappingsType<Omit<TxSenderConfig, 'l1Contracts'>> = (scope: 'PROVER' | 'SEQ') => ({
   ...l1ReaderConfigMappings,
-  customForwarderContractAddress: {
-    env: `CUSTOM_FORWARDER_CONTRACT_ADDRESS`,
-    parseEnv: (val: string) => EthAddress.fromString(val),
-    description: 'The address of the custom forwarder contract.',
-    defaultValue: EthAddress.ZERO,
+  publisherPrivateKeys: {
+    env: scope === 'PROVER' ? `PROVER_PUBLISHER_PRIVATE_KEYS` : `SEQ_PUBLISHER_PRIVATE_KEYS`,
+    description: 'The private keys to be used by the publisher.',
+    parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
+    defaultValue: [],
+    fallback: [scope === 'PROVER' ? `PROVER_PUBLISHER_PRIVATE_KEY` : `SEQ_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,
+  publisherAddresses: {
+    env: scope === 'PROVER' ? `PROVER_PUBLISHER_ADDRESSES` : `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: [],
   },
 });
 
@@ -60,14 +63,24 @@ export function getTxSenderConfigFromEnv(scope: 'PROVER' | 'SEQ'): Omit<TxSender
 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.',
+  publisherAllowInvalidStates: {
+    description: 'True to use publishers in invalid states (timed out, cancelled, etc) if no other is available',
+    env: scope === `PROVER` ? `PROVER_PUBLISHER_ALLOW_INVALID_STATES` : `SEQ_PUBLISHER_ALLOW_INVALID_STATES`,
+    ...booleanConfigHelper(true),
+  },
+  fishermanMode: {
+    env: 'FISHERMAN_MODE',
+    description:
+      'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
+    ...booleanConfigHelper(false),
+  },
+  publisherForwarderAddress: {
+    env: scope === `PROVER` ? `PROVER_PUBLISHER_FORWARDER_ADDRESS` : `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),
   },
   ...l1TxUtilsConfigMappings,
-  ...blobSinkConfigMapping,
+  ...blobClientConfigMapping,
 });
 
 export function getPublisherConfigFromEnv(scope: 'PROVER' | 'SEQ'): PublisherConfig {

package/src/publisher/index.ts

@@ -1 +1,5 @@
 export { SequencerPublisher } from './sequencer-publisher.js';
+export { SequencerPublisherFactory } from './sequencer-publisher-factory.js';
+
+// Used for tests
+export { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';

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

@@ -0,0 +1,92 @@
+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 { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+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 logger: Logger;
+
+  constructor(
+    private sequencerConfig: SequencerClientConfig,
+    private deps: {
+      telemetry: TelemetryClient;
+      publisherManager: PublisherManager<L1TxUtilsWithBlobs>;
+      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');
+  }
+  /**
+   * 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.deps.nodeKeyStore.getPublisherAddresses(validatorAddress);
+    const filter: PublisherFilter<L1TxUtilsWithBlobs> = !validatorAddress
+      ? () => true
+      : (utils: L1TxUtilsWithBlobs) => {
+          const publisherAddress = utils.getSenderAddress();
+          return allowedPublishers.some(allowedPublisher => allowedPublisher.equals(publisherAddress));
+        };
+
+    const l1Publisher = await this.deps.publisherManager.getAvailablePublisher(filter);
+    const attestorAddress =
+      validatorAddress ?? this.deps.nodeKeyStore.getAttestorForPublisher(l1Publisher.getSenderAddress());
+
+    const rollup = this.deps.rollupContract;
+    const slashingProposerContract = await rollup.getSlashingProposer();
+
+    const publisher = new SequencerPublisher(this.sequencerConfig, {
+      l1TxUtils: l1Publisher,
+      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,
+    };
+  }
+}

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,6 @@ import {
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
-  ValueType,
 } from '@aztec/telemetry-client';
 
 import { formatEther } from 'viem/utils';
@@ -24,6 +23,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 +39,33 @@ 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 = meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT);
 
-    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 = meter.createUpDownCounter(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 = meter.createUpDownCounter(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 +79,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 +125,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
     }
   }