@aztec/sequencer-client 0.47.1 → 0.49.2

package/src/config.ts

@@ -1,14 +1,24 @@
 import { type AllowedElement } from '@aztec/circuit-types';
 import { AztecAddress, Fr, FunctionSelector, getContractClassFromArtifact } from '@aztec/circuits.js';
-import { getL1ContractAddressesFromEnv } from '@aztec/ethereum';
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { FPCContract } from '@aztec/noir-contracts.js/FPC';
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { AuthRegistryAddress } from '@aztec/protocol-contracts/auth-registry';
-import { GasTokenAddress } from '@aztec/protocol-contracts/gas-token';
+import { FeeJuiceAddress } from '@aztec/protocol-contracts/fee-juice';
 
-import { type GlobalReaderConfig } from './global_variable_builder/index.js';
-import { type PublisherConfig, type TxSenderConfig, getTxSenderConfigFromEnv } from './publisher/config.js';
+import {
+  type PublisherConfig,
+  type TxSenderConfig,
+  getPublisherConfigMappings,
+  getTxSenderConfigMappings,
+} from './publisher/config.js';
 import { type SequencerConfig } from './sequencer/config.js';
 
 /** Chain configuration. */
@@ -22,60 +32,102 @@ type ChainConfig = {
 /**
  * Configuration settings for the SequencerClient.
  */
-export type SequencerClientConfig = PublisherConfig &
-  TxSenderConfig &
-  SequencerConfig &
-  GlobalReaderConfig &
-  ChainConfig;
+export type SequencerClientConfig = PublisherConfig & TxSenderConfig & SequencerConfig & L1ReaderConfig & ChainConfig;
+
+export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
+  transactionPollingIntervalMS: {
+    env: 'SEQ_TX_POLLING_INTERVAL_MS',
+    description: 'The number of ms to wait between polling for pending txs.',
+    ...numberConfigHelper(1_000),
+  },
+  maxTxsPerBlock: {
+    env: 'SEQ_MAX_TX_PER_BLOCK',
+    description: 'The maximum number of txs to include in a block.',
+    ...numberConfigHelper(32),
+  },
+  minTxsPerBlock: {
+    env: 'SEQ_MIN_TX_PER_BLOCK',
+    description: 'The minimum number of txs to include in a block.',
+    ...numberConfigHelper(1),
+  },
+  minSecondsBetweenBlocks: {
+    env: 'SEQ_MIN_SECONDS_BETWEEN_BLOCKS',
+    description: 'The minimum number of seconds in-between consecutive blocks.',
+    ...numberConfigHelper(0),
+  },
+  maxSecondsBetweenBlocks: {
+    env: 'SEQ_MAX_SECONDS_BETWEEN_BLOCKS',
+    description:
+      'The maximum number of seconds in-between consecutive blocks. Sequencer will produce a block with less than minTxsPerBlock once this threshold is reached.',
+    ...numberConfigHelper(0),
+  },
+  coinbase: {
+    env: 'COINBASE',
+    parseEnv: (val: string) => EthAddress.fromString(val),
+    description: 'Recipient of block reward.',
+  },
+  feeRecipient: {
+    env: 'FEE_RECIPIENT',
+    parseEnv: (val: string) => AztecAddress.fromString(val),
+    description: 'Address to receive fees.',
+  },
+  acvmWorkingDirectory: {
+    env: 'ACVM_WORKING_DIRECTORY',
+    description: 'The working directory to use for simulation/proving',
+  },
+  acvmBinaryPath: {
+    env: 'ACVM_BINARY_PATH',
+    description: 'The path to the ACVM binary',
+  },
+  allowedInSetup: {
+    env: 'SEQ_ALLOWED_SETUP_FN',
+    parseEnv: (val: string) => parseSequencerAllowList(val),
+    defaultValue: getDefaultAllowedSetupFunctions(),
+    description: 'The list of functions calls allowed to run in setup',
+    printDefault: () =>
+      'AuthRegistry, FeeJuice.increase_public_balance, Token.increase_public_balance, FPC.prepare_fee',
+  },
+  allowedInTeardown: {
+    env: 'SEQ_ALLOWED_TEARDOWN_FN',
+    parseEnv: (val: string) => parseSequencerAllowList(val),
+    defaultValue: getDefaultAllowedTeardownFunctions(),
+    description: 'The list of functions calls allowed to run teardown',
+    printDefault: () => 'FPC.pay_refund, FPC.pay_refund_with_shielded_rebate',
+  },
+  maxBlockSizeInBytes: {
+    env: 'SEQ_MAX_BLOCK_SIZE_IN_BYTES',
+    description: 'Max block size',
+    ...numberConfigHelper(1024 * 1024),
+  },
+  enforceFees: {
+    env: 'ENFORCE_FEES',
+    description: 'Whether to require every tx to have a fee payer',
+    ...booleanConfigHelper(),
+  },
+};
+
+export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
+  l1ChainId: l1ReaderConfigMappings.l1ChainId,
+  version: {
+    env: 'VERSION',
+    description: 'The version of the rollup.',
+    ...numberConfigHelper(1),
+  },
+};
+
+export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientConfig> = {
+  ...sequencerConfigMappings,
+  ...getTxSenderConfigMappings('SEQ'),
+  ...getPublisherConfigMappings('SEQ'),
+  ...l1ReaderConfigMappings,
+  ...chainConfigMappings,
+};
 
 /**
  * Creates an instance of SequencerClientConfig out of environment variables using sensible defaults for integration testing if not set.
  */
 export function getConfigEnvVars(): SequencerClientConfig {
-  const {
-    VERSION,
-    SEQ_PUBLISH_RETRY_INTERVAL_MS,
-    SEQ_TX_POLLING_INTERVAL_MS,
-    SEQ_MAX_TX_PER_BLOCK,
-    SEQ_MIN_TX_PER_BLOCK,
-    SEQ_MAX_SECONDS_BETWEEN_BLOCKS,
-    SEQ_MIN_SECONDS_BETWEEN_BLOCKS,
-    SEQ_ALLOWED_SETUP_FN,
-    SEQ_ALLOWED_TEARDOWN_FN,
-    SEQ_MAX_BLOCK_SIZE_IN_BYTES,
-    SEQ_SKIP_SUBMIT_PROOFS,
-    COINBASE,
-    FEE_RECIPIENT,
-    ACVM_WORKING_DIRECTORY,
-    ACVM_BINARY_PATH,
-    ENFORCE_FEES = '',
-  } = process.env;
-
-  return {
-    enforceFees: ['1', 'true'].includes(ENFORCE_FEES),
-    version: VERSION ? +VERSION : 1, // 1 is our default version
-    l1PublishRetryIntervalMS: SEQ_PUBLISH_RETRY_INTERVAL_MS ? +SEQ_PUBLISH_RETRY_INTERVAL_MS : 1_000,
-    transactionPollingIntervalMS: SEQ_TX_POLLING_INTERVAL_MS ? +SEQ_TX_POLLING_INTERVAL_MS : 1_000,
-    maxBlockSizeInBytes: SEQ_MAX_BLOCK_SIZE_IN_BYTES ? +SEQ_MAX_BLOCK_SIZE_IN_BYTES : undefined,
-    l1Contracts: getL1ContractAddressesFromEnv(),
-    maxTxsPerBlock: SEQ_MAX_TX_PER_BLOCK ? +SEQ_MAX_TX_PER_BLOCK : 32,
-    minTxsPerBlock: SEQ_MIN_TX_PER_BLOCK ? +SEQ_MIN_TX_PER_BLOCK : 1,
-    maxSecondsBetweenBlocks: SEQ_MAX_SECONDS_BETWEEN_BLOCKS ? +SEQ_MAX_SECONDS_BETWEEN_BLOCKS : 0,
-    minSecondsBetweenBlocks: SEQ_MIN_SECONDS_BETWEEN_BLOCKS ? +SEQ_MIN_SECONDS_BETWEEN_BLOCKS : 0,
-    sequencerSkipSubmitProofs: ['1', 'true'].includes(SEQ_SKIP_SUBMIT_PROOFS ?? ''),
-    // TODO: undefined should not be allowed for the following 2 values in PROD
-    coinbase: COINBASE ? EthAddress.fromString(COINBASE) : undefined,
-    feeRecipient: FEE_RECIPIENT ? AztecAddress.fromString(FEE_RECIPIENT) : undefined,
-    acvmWorkingDirectory: ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : undefined,
-    acvmBinaryPath: ACVM_BINARY_PATH ? ACVM_BINARY_PATH : undefined,
-    allowedInSetup: SEQ_ALLOWED_SETUP_FN
-      ? parseSequencerAllowList(SEQ_ALLOWED_SETUP_FN)
-      : getDefaultAllowedSetupFunctions(),
-    allowedInTeardown: SEQ_ALLOWED_TEARDOWN_FN
-      ? parseSequencerAllowList(SEQ_ALLOWED_TEARDOWN_FN)
-      : getDefaultAllowedTeardownFunctions(),
-    ...getTxSenderConfigFromEnv('SEQ'),
-  };
+  return getConfigFromMappings<SequencerClientConfig>(sequencerClientConfigMappings);
 }
 
 /**
@@ -136,7 +188,7 @@ function getDefaultAllowedSetupFunctions(): AllowedElement[] {
     },
     // needed for claiming on the same tx as a spend
     {
-      address: GasTokenAddress,
+      address: FeeJuiceAddress,
       selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
     },
     // needed for private transfers via FPC

package/src/global_variable_builder/global_builder.ts

@@ -1,4 +1,10 @@
-import { type AztecAddress, type EthAddress, GasFees, GlobalVariables } from '@aztec/circuits.js';
+import {
+  type AztecAddress,
+  ETHEREUM_SLOT_DURATION,
+  type EthAddress,
+  GasFees,
+  GlobalVariables,
+} from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
@@ -6,11 +12,6 @@ import { createDebugLogger } from '@aztec/foundation/log';
  * Reads values from L1 state that is used for the global values.
  */
 export interface L1GlobalReader {
-  /**
-   * Fetches the last timestamp that a block was processed by the contract.
-   * @returns The last timestamp that a block was processed by the contract.
-   */
-  getLastTimestamp(): Promise<bigint>;
   /**
    * Fetches the version of the rollup contract.
    * @returns The version of the rollup contract.
@@ -29,10 +30,23 @@ export interface L1GlobalReader {
   getL1CurrentTime(): Promise<bigint>;
 
   /**
-   * Gets the last time L2 was warped as tracked by the rollup contract.
-   * @returns The warped time.
+   * Gets the current slot.
+   * @returns The current slot.
    */
-  getLastWarpedBlockTs(): Promise<bigint>;
+  getCurrentSlot(): Promise<bigint>;
+
+  /**
+   * Get the slot for a specific timestamp.
+   * @param timestamp - The timestamp to get the slot for.
+   */
+  getSlotAt(timestamp: readonly [bigint]): Promise<bigint>;
+
+  /**
+   * Gets the timestamp for a slot
+   * @param slot - The slot to get the timestamp for.
+   * @returns The timestamp for the slot.
+   */
+  getTimestampForSlot(slot: readonly [bigint]): Promise<bigint>;
 }
 
 /**
@@ -69,34 +83,30 @@ export class SimpleTestGlobalVariableBuilder implements GlobalVariableBuilder {
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
   ): Promise<GlobalVariables> {
-    let lastTimestamp = new Fr(await this.reader.getLastTimestamp());
-    const version = new Fr(await this.reader.getVersion());
-    const chainId = new Fr(await this.reader.getChainId());
+    // Not just the current slot, the slot of the next block.
+    const ts = (await this.reader.getL1CurrentTime()) + BigInt(ETHEREUM_SLOT_DURATION);
 
-    // TODO(rahul) - fix #1614. By using the cheatcode warp to modify L2 time,
-    // txs in the next rollup would have same time as the txs in the current rollup (i.e. the rollup that was warped).
-    // So, for now you check if L2 time was warped and if so, serve warpedTime + 1 to txs in the new rollup.
-    // Check if L2 time was warped in the last rollup by checking if current L1 time is same as the warpedTime (stored on the rollup contract).
-    // more details at https://github.com/AztecProtocol/aztec-packages/issues/1614
+    const slot = await this.reader.getSlotAt([ts]);
+    const timestamp = await this.reader.getTimestampForSlot([slot]);
 
-    const currTimestamp = await this.reader.getL1CurrentTime();
-    const rollupWarpTime = await this.reader.getLastWarpedBlockTs();
-    const isLastBlockWarped = rollupWarpTime === currTimestamp;
-    if (isLastBlockWarped) {
-      lastTimestamp = new Fr(lastTimestamp.value + 1n);
-    }
+    const slotFr = new Fr(slot);
+    const timestampFr = new Fr(timestamp);
+
+    const version = new Fr(await this.reader.getVersion());
+    const chainId = new Fr(await this.reader.getChainId());
 
     const gasFees = GasFees.default();
     const globalVariables = new GlobalVariables(
       chainId,
       version,
       blockNumber,
-      lastTimestamp,
+      slotFr,
+      timestampFr,
       coinbase,
       feeRecipient,
       gasFees,
     );
     this.log.debug(`Built global variables for block ${blockNumber}`, globalVariables.toJSON());
-    return new GlobalVariables(chainId, version, blockNumber, lastTimestamp, coinbase, feeRecipient, gasFees);
+    return globalVariables;
   }
 }

package/src/global_variable_builder/index.ts

@@ -1,9 +1,9 @@
-import { type GlobalReaderConfig } from './config.js';
+import { type L1ReaderConfig } from '@aztec/ethereum';
+
 import { type GlobalVariableBuilder, SimpleTestGlobalVariableBuilder } from './global_builder.js';
 import { ViemReader } from './viem-reader.js';
 
 export { SimpleTestGlobalVariableBuilder as SimpleGlobalVariableBuilder } from './global_builder.js';
-export { GlobalReaderConfig } from './config.js';
 export { GlobalVariableBuilder } from './global_builder.js';
 
 /**
@@ -11,6 +11,6 @@ export { GlobalVariableBuilder } from './global_builder.js';
  * @param config - Configuration to initialize the builder.
  * @returns A new instance of the global variable builder.
  */
-export function getGlobalVariableBuilder(config: GlobalReaderConfig): GlobalVariableBuilder {
+export function getGlobalVariableBuilder(config: L1ReaderConfig): GlobalVariableBuilder {
   return new SimpleTestGlobalVariableBuilder(new ViemReader(config));
 }

package/src/global_variable_builder/viem-reader.ts

@@ -1,4 +1,4 @@
-import { createEthereumChain } from '@aztec/ethereum';
+import { type L1ReaderConfig, createEthereumChain } from '@aztec/ethereum';
 import { RollupAbi } from '@aztec/l1-artifacts';
 
 import {
@@ -12,7 +12,6 @@ import {
 } from 'viem';
 import type * as chains from 'viem/chains';
 
-import { type GlobalReaderConfig } from './config.js';
 import { type L1GlobalReader } from './global_builder.js';
 
 /**
@@ -22,10 +21,10 @@ export class ViemReader implements L1GlobalReader {
   private rollupContract: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, chains.Chain>>;
   private publicClient: PublicClient<HttpTransport, chains.Chain>;
 
-  constructor(config: GlobalReaderConfig) {
-    const { rpcUrl, l1ChainId: chainId, l1Contracts } = config;
+  constructor(config: L1ReaderConfig) {
+    const { l1RpcUrl, l1ChainId: chainId, l1Contracts } = config;
 
-    const chain = createEthereumChain(rpcUrl, chainId);
+    const chain = createEthereumChain(l1RpcUrl, chainId);
 
     this.publicClient = createPublicClient({
       chain: chain.chainInfo,
@@ -39,10 +38,6 @@ export class ViemReader implements L1GlobalReader {
     });
   }
 
-  public async getLastTimestamp(): Promise<bigint> {
-    return BigInt(await this.rollupContract.read.lastBlockTs());
-  }
-
   public async getVersion(): Promise<bigint> {
     return BigInt(await this.rollupContract.read.VERSION());
   }
@@ -55,7 +50,15 @@ export class ViemReader implements L1GlobalReader {
     return await Promise.resolve((await this.publicClient.getBlock()).timestamp);
   }
 
-  public async getLastWarpedBlockTs(): Promise<bigint> {
-    return BigInt(await this.rollupContract.read.lastWarpedBlockTs());
+  public async getCurrentSlot(): Promise<bigint> {
+    return BigInt(await this.rollupContract.read.getCurrentSlot());
+  }
+
+  public async getSlotAt(timestamp: readonly [bigint]): Promise<bigint> {
+    return BigInt(await this.rollupContract.read.getSlotAt(timestamp));
+  }
+
+  public async getTimestampForSlot(slot: readonly [bigint]): Promise<bigint> {
+    return BigInt(await this.rollupContract.read.getTimestampForSlot(slot));
   }
 }

package/src/publisher/config.ts

@@ -1,36 +1,20 @@
-import { type L1ContractAddresses, NULL_KEY } from '@aztec/ethereum';
-
-import { type Hex } from 'viem';
+import { type L1ReaderConfig, NULL_KEY } from '@aztec/ethereum';
+import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
 
 /**
  * The configuration of the rollup transaction publisher.
  */
-export interface TxSenderConfig {
+export type TxSenderConfig = L1ReaderConfig & {
   /**
    * The private key to be used by the publisher.
    */
   publisherPrivateKey: `0x${string}`;
 
-  /**
-   * The RPC Url of the ethereum host.
-   */
-  rpcUrl: string;
-
-  /**
-   * The chain ID of the ethereum host.
-   */
-  l1ChainId: number;
-
   /**
    * The number of confirmations required.
    */
   requiredConfirmations: number;
-
-  /**
-   * The deployed l1 contract addresses
-   */
-  l1Contracts: L1ContractAddresses;
-}
+};
 
 /**
  * Configuration of the L1Publisher.
@@ -42,18 +26,46 @@ export interface PublisherConfig {
   l1PublishRetryIntervalMS: number;
 }
 
-export function getTxSenderConfigFromEnv(scope: 'PROVER' | 'SEQ'): Omit<TxSenderConfig, 'l1Contracts'> {
-  const { ETHEREUM_HOST, L1_CHAIN_ID } = process.env;
+export const getTxSenderConfigMappings: (
+  scope: 'PROVER' | 'SEQ',
+) => ConfigMappingsType<Omit<TxSenderConfig, 'l1Contracts'>> = (scope: 'PROVER' | 'SEQ') => ({
+  l1RpcUrl: {
+    env: 'ETHEREUM_HOST',
+    description: 'The RPC Url of the ethereum host.',
+  },
+  l1ChainId: {
+    env: 'L1_CHAIN_ID',
+    parseEnv: (val: string) => +val,
+    defaultValue: 31337,
+    description: 'The chain ID of the ethereum host.',
+  },
+  publisherPrivateKey: {
+    env: `${scope}_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,
+  },
+  requiredConfirmations: {
+    env: `${scope}_REQUIRED_CONFIRMATIONS`,
+    parseEnv: (val: string) => +val,
+    defaultValue: 1,
+    description: 'The number of confirmations required.',
+  },
+});
 
-  const PUBLISHER_PRIVATE_KEY = process.env[`${scope}_PUBLISHER_PRIVATE_KEY`];
-  const REQUIRED_CONFIRMATIONS = process.env[`${scope}_REQUIRED_CONFIRMATIONS`];
+export function getTxSenderConfigFromEnv(scope: 'PROVER' | 'SEQ'): Omit<TxSenderConfig, 'l1Contracts'> {
+  return getConfigFromMappings(getTxSenderConfigMappings(scope));
+}
 
-  const publisherPrivateKey: Hex = PUBLISHER_PRIVATE_KEY ? `0x${PUBLISHER_PRIVATE_KEY.replace('0x', '')}` : NULL_KEY;
+export const getPublisherConfigMappings: (scope: 'PROVER' | 'SEQ') => ConfigMappingsType<PublisherConfig> = scope => ({
+  l1PublishRetryIntervalMS: {
+    env: `${scope}_PUBLISH_RETRY_INTERVAL_MS`,
+    parseEnv: (val: string) => +val,
+    defaultValue: 1000,
+    description: 'The interval to wait between publish retries.',
+  },
+});
 
-  return {
-    rpcUrl: ETHEREUM_HOST ? ETHEREUM_HOST : '',
-    requiredConfirmations: REQUIRED_CONFIRMATIONS ? +REQUIRED_CONFIRMATIONS : 1,
-    publisherPrivateKey,
-    l1ChainId: L1_CHAIN_ID ? +L1_CHAIN_ID : 31337,
-  };
+export function getPublisherConfigFromEnv(scope: 'PROVER' | 'SEQ'): PublisherConfig {
+  return getConfigFromMappings(getPublisherConfigMappings(scope));
 }

package/src/publisher/index.ts

@@ -1,14 +1,16 @@
+import { type TelemetryClient } from '@aztec/telemetry-client';
+
 import { type PublisherConfig, type TxSenderConfig } from './config.js';
 import { L1Publisher } from './l1-publisher.js';
 import { ViemTxSender } from './viem-tx-sender.js';
 
 export { L1Publisher } from './l1-publisher.js';
-export { PublisherConfig, TxSenderConfig, getTxSenderConfigFromEnv } from './config.js';
+export * from './config.js';
 
 /**
  * Returns a new instance of the L1Publisher.
  * @param config - Configuration to initialize the new instance.
  */
-export function getL1Publisher(config: PublisherConfig & TxSenderConfig): L1Publisher {
-  return new L1Publisher(new ViemTxSender(config), config);
+export function getL1Publisher(config: PublisherConfig & TxSenderConfig, client: TelemetryClient): L1Publisher {
+  return new L1Publisher(new ViemTxSender(config), client, config);
 }

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

@@ -0,0 +1,108 @@
+import type { L1PublishBlockStats, L1PublishProofStats } from '@aztec/circuit-types/stats';
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+import { formatEther } from 'viem/utils';
+
+export type L1TxType = 'submitProof' | 'process';
+
+export class L1PublisherMetrics {
+  private gasPrice: Histogram;
+
+  private txCount: UpDownCounter;
+  private txDuration: Histogram;
+  private txGas: Histogram;
+  private txCalldataSize: Histogram;
+  private txCalldataGas: Histogram;
+
+  constructor(client: TelemetryClient, name = 'L1Publisher') {
+    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.txCount = meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT, {
+      description: 'The number of transactions processed',
+    });
+
+    this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION, {
+      description: 'The duration of transaction processing',
+      unit: 'ms',
+      valueType: ValueType.INT,
+      advice: {
+        explicitBucketBoundaries: [10, 50, 100, 200, 500, 1000, 2000, 5000, 10000],
+      },
+    });
+
+    this.txGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_GAS, {
+      description: 'The gas consumed by transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+
+    this.txCalldataSize = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_SIZE, {
+      description: 'The size of the calldata in transactions',
+      unit: 'bytes',
+      valueType: ValueType.INT,
+      advice: {
+        explicitBucketBoundaries: [0, 100, 200, 500, 1000, 2000, 5000, 10000],
+      },
+    });
+
+    this.txCalldataGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_GAS, {
+      description: 'The gas consumed by the calldata in transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+  }
+
+  recordFailedTx(txType: L1TxType) {
+    this.txCount.add(1, {
+      [Attributes.L1_TX_TYPE]: txType,
+      [Attributes.OK]: false,
+    });
+  }
+
+  recordSubmitProof(durationMs: number, stats: L1PublishProofStats) {
+    this.recordTx('submitProof', durationMs, stats);
+  }
+
+  recordProcessBlockTx(durationMs: number, stats: L1PublishBlockStats) {
+    this.recordTx('process', durationMs, stats);
+  }
+
+  private recordTx(txType: L1TxType, durationMs: number, stats: Omit<L1PublishProofStats, 'eventName'>) {
+    const attributes = {
+      [Attributes.L1_TX_TYPE]: txType,
+    } as const;
+
+    this.txCount.add(1, {
+      ...attributes,
+      [Attributes.OK]: true,
+    });
+
+    this.txDuration.record(Math.ceil(durationMs), attributes);
+    this.txGas.record(
+      // safe to downcast - total block limit is 30M gas which fits in a JS number
+      Number(stats.gasUsed),
+      attributes,
+    );
+    this.txCalldataGas.record(stats.calldataGas, attributes);
+    this.txCalldataSize.record(stats.calldataSize, attributes);
+
+    try {
+      this.gasPrice.record(parseInt(formatEther(stats.gasPrice, 'gwei'), 10));
+    } catch (e) {
+      // ignore
+    }
+  }
+}