@aztec/sequencer-client 0.0.1-commit.d3ec352c → 0.0.1-commit.e61ad554

package/src/config.ts

@@ -1,9 +1,5 @@
-import {
-  type L1ContractsConfig,
-  type L1ReaderConfig,
-  l1ContractsConfigMappings,
-  l1ReaderConfigMappings,
-} from '@aztec/ethereum';
+import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec/ethereum/config';
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
@@ -12,11 +8,12 @@ import {
   pickConfigMappings,
 } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { type KeyStoreConfig, keyStoreConfigMappings } from '@aztec/node-keystore';
-import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p';
+import { type KeyStoreConfig, keyStoreConfigMappings } from '@aztec/node-keystore/config';
+import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p/config';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type ChainConfig, type SequencerConfig, chainConfigMappings } from '@aztec/stdlib/config';
-import { type ValidatorClientConfig, validatorClientConfigMappings } from '@aztec/validator-client';
+import type { ResolvedSequencerConfig } from '@aztec/stdlib/interfaces/server';
+import { type ValidatorClientConfig, validatorClientConfigMappings } from '@aztec/validator-client/config';
 
 import {
   type PublisherConfig,
@@ -30,6 +27,32 @@ export type { SequencerConfig };
 
 export const DEFAULT_ATTESTATION_PROPAGATION_TIME = 2;
 
+/**
+ * Default values for SequencerConfig.
+ * Centralized location for all sequencer configuration defaults.
+ */
+export const DefaultSequencerConfig: ResolvedSequencerConfig = {
+  sequencerPollingIntervalMS: 500,
+  maxTxsPerBlock: 32,
+  minTxsPerBlock: 1,
+  buildCheckpointIfEmpty: false,
+  publishTxsWithProposals: false,
+  maxL2BlockGas: 10e9,
+  maxDABlockGas: 10e9,
+  maxBlockSizeInBytes: 1024 * 1024,
+  enforceTimeTable: true,
+  attestationPropagationTime: DEFAULT_ATTESTATION_PROPAGATION_TIME,
+  secondsBeforeInvalidatingBlockAsCommitteeMember: 144, // 12 L1 blocks
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember: 432, // 36 L1 blocks
+  skipCollectingAttestations: false,
+  skipInvalidateBlockAsProposer: false,
+  broadcastInvalidBlockProposal: false,
+  injectFakeAttestation: false,
+  fishermanMode: false,
+  shuffleAttestationOrdering: false,
+  skipPushProposedBlocksToArchiver: false,
+};
+
 /**
  * Configuration settings for the SequencerClient.
  */
@@ -44,35 +67,39 @@ export type SequencerClientConfig = PublisherConfig &
   Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration' | 'aztecEpochDuration'>;
 
 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(500),
+  sequencerPollingIntervalMS: {
+    env: 'SEQ_POLLING_INTERVAL_MS',
+    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(32),
+    ...numberConfigHelper(DefaultSequencerConfig.maxTxsPerBlock),
   },
   minTxsPerBlock: {
     env: 'SEQ_MIN_TX_PER_BLOCK',
     description: 'The minimum number of txs to include in a block.',
-    ...numberConfigHelper(1),
+    ...numberConfigHelper(DefaultSequencerConfig.minTxsPerBlock),
+  },
+  minValidTxsPerBlock: {
+    description:
+      'The minimum number of valid txs (after execution) to include in a block. If not set, falls back to minTxsPerBlock.',
   },
   publishTxsWithProposals: {
     env: 'SEQ_PUBLISH_TXS_WITH_PROPOSALS',
     description: 'Whether to publish txs with proposals.',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.publishTxsWithProposals),
   },
   maxL2BlockGas: {
     env: 'SEQ_MAX_L2_BLOCK_GAS',
     description: 'The maximum L2 block gas.',
-    ...numberConfigHelper(10e9),
+    ...numberConfigHelper(DefaultSequencerConfig.maxL2BlockGas),
   },
   maxDABlockGas: {
     env: 'SEQ_MAX_DA_BLOCK_GAS',
     description: 'The maximum DA block gas.',
-    ...numberConfigHelper(10e9),
+    ...numberConfigHelper(DefaultSequencerConfig.maxDABlockGas),
   },
   coinbase: {
     env: 'COINBASE',
@@ -95,73 +122,90 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
   maxBlockSizeInBytes: {
     env: 'SEQ_MAX_BLOCK_SIZE_IN_BYTES',
     description: 'Max block size',
-    ...numberConfigHelper(1024 * 1024),
+    ...numberConfigHelper(DefaultSequencerConfig.maxBlockSizeInBytes),
   },
   enforceTimeTable: {
     env: 'SEQ_ENFORCE_TIME_TABLE',
     description: 'Whether to enforce the time table when building blocks',
-    ...booleanConfigHelper(),
-    defaultValue: true,
+    ...booleanConfigHelper(DefaultSequencerConfig.enforceTimeTable),
   },
   governanceProposerPayload: {
     env: 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS',
     description: 'The address of the payload for the governanceProposer',
     parseEnv: (val: string) => EthAddress.fromString(val),
-    defaultValue: EthAddress.ZERO,
   },
-  maxL1TxInclusionTimeIntoSlot: {
-    env: 'SEQ_MAX_L1_TX_INCLUSION_TIME_INTO_SLOT',
-    description: 'How many seconds into an L1 slot we can still send a tx and get it mined.',
+  l1PublishingTime: {
+    env: 'SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT',
+    description: 'How much time (in seconds) we allow in the slot for publishing the L1 tx (defaults to 1 L1 slot).',
     parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
   },
   attestationPropagationTime: {
     env: 'SEQ_ATTESTATION_PROPAGATION_TIME',
     description: 'How many seconds it takes for proposals and attestations to travel across the p2p layer (one-way)',
-    ...numberConfigHelper(DEFAULT_ATTESTATION_PROPAGATION_TIME),
+    ...numberConfigHelper(DefaultSequencerConfig.attestationPropagationTime),
   },
   fakeProcessingDelayPerTxMs: {
     description: 'Used for testing to introduce a fake delay after processing each tx',
   },
+  fakeThrowAfterProcessingTxCount: {
+    description: 'Used for testing to throw an error after processing N txs',
+  },
   secondsBeforeInvalidatingBlockAsCommitteeMember: {
     env: 'SEQ_SECONDS_BEFORE_INVALIDATING_BLOCK_AS_COMMITTEE_MEMBER',
     description:
       'How many seconds to wait before trying to invalidate a block from the pending chain as a committee member (zero to never invalidate).' +
       ' The next proposer is expected to invalidate, so the committee acts as a fallback.',
-    ...numberConfigHelper(144), // 12 L1 blocks
+    ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsCommitteeMember),
   },
   secondsBeforeInvalidatingBlockAsNonCommitteeMember: {
     env: 'SEQ_SECONDS_BEFORE_INVALIDATING_BLOCK_AS_NON_COMMITTEE_MEMBER',
     description:
       'How many seconds to wait before trying to invalidate a block from the pending chain as a non-committee member (zero to never invalidate).' +
       ' The next proposer is expected to invalidate, then the committee, so other sequencers act as a fallback.',
-    ...numberConfigHelper(432), // 36 L1 blocks
+    ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsNonCommitteeMember),
   },
   skipCollectingAttestations: {
     description:
       'Whether to skip collecting attestations from validators and only use self-attestations (for testing only)',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.skipCollectingAttestations),
   },
   skipInvalidateBlockAsProposer: {
     description: 'Do not invalidate the previous block if invalid when we are the proposer (for testing only)',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.skipInvalidateBlockAsProposer),
   },
   broadcastInvalidBlockProposal: {
     description: 'Broadcast invalid block proposals with corrupted state (for testing only)',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.broadcastInvalidBlockProposal),
   },
   injectFakeAttestation: {
     description: 'Inject a fake attestation (for testing only)',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.injectFakeAttestation),
   },
   fishermanMode: {
     env: 'FISHERMAN_MODE',
     description:
       'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.fishermanMode),
   },
   shuffleAttestationOrdering: {
     description: 'Shuffle attestation ordering to create invalid ordering (for testing only)',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.shuffleAttestationOrdering),
+  },
+  blockDurationMs: {
+    env: 'SEQ_BLOCK_DURATION_MS',
+    description:
+      'Duration per block in milliseconds when building multiple blocks per slot. ' +
+      'If undefined (default), builds a single block per slot using the full slot duration.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
+  buildCheckpointIfEmpty: {
+    env: 'SEQ_BUILD_CHECKPOINT_IF_EMPTY',
+    description: 'Have sequencer build and publish an empty checkpoint if there are no txs',
+    ...booleanConfigHelper(DefaultSequencerConfig.buildCheckpointIfEmpty),
+  },
+  skipPushProposedBlocksToArchiver: {
+    description: 'Skip pushing proposed blocks to archiver (default: true)',
+    ...booleanConfigHelper(DefaultSequencerConfig.skipPushProposedBlocksToArchiver),
   },
   ...pickConfigMappings(p2pConfigMappings, ['txPublicSetupAllowList']),
 };

package/src/global_variable_builder/global_builder.ts

@@ -1,17 +1,19 @@
-import {
-  type L1ContractsConfig,
-  type L1ReaderConfig,
-  RollupContract,
-  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 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 { createPublicClient, fallback, http } from 'viem';
@@ -21,26 +23,37 @@ import { createPublicClient, fallback, http } from 'viem';
  */
 export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
   private log = createLogger('sequencer:global_variable_builder');
-  private currentBaseFees: Promise<GasFees> = Promise.resolve(new GasFees(0, 0));
+  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;
+  private chainId: Fr;
+  private version: Fr;
 
-  constructor(config: L1ReaderConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'>) {
+  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,
     });
 
@@ -48,48 +61,38 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
   }
 
   /**
-   * 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 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
    */
-  private async computeCurrentBaseFees(): 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.getCheckpoint(await this.rollupContract.getCheckpointNumber());
+    const lastCheckpoint = await this.rollupContract.getPendingCheckpoint();
     const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
-      SlotNumber.fromBigInt(lastBlock.slotNumber + 1n),
+      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(0, await this.rollupContract.getManaBaseFeeAt(timestamp, true));
+    return new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
   }
 
-  public async getCurrentBaseFees(): Promise<GasFees> {
+  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 base fees
+    // 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.currentBaseFees = this.currentBaseFees.then(() => this.computeCurrentBaseFees());
-    }
-    return this.currentBaseFees;
-  }
-
-  public async getGlobalConstantVariables(): Promise<Pick<GlobalVariables, 'chainId' | 'version'>> {
-    if (!this.chainId) {
-      this.chainId = new Fr(this.publicClient.chain.id);
-    }
-    if (!this.version) {
-      this.version = new Fr(await this.rollupContract.getVersion());
+      this.currentMinFees = this.currentMinFees.then(() => this.computeCurrentMinFees());
     }
-    return { chainId: this.chainId, version: this.version };
+    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.
@@ -100,34 +103,35 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     blockNumber: BlockNumber,
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
-    slotNumber?: SlotNumber,
+    maybeSlot?: SlotNumber,
   ): Promise<GlobalVariables> {
-    const { chainId, version } = await this.getGlobalConstantVariables();
-
-    let slot: SlotNumber;
-    if (slotNumber === undefined) {
-      const ts = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
-      slot = await this.rollupContract.getSlotAt(ts);
-    } else {
-      slot = 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 timestamp = await this.rollupContract.getTimestampForSlot(slot);
+  /** 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(0, await this.rollupContract.getManaBaseFeeAt(timestamp, true));
+    const timestamp = getTimestampForSlot(slotNumber, {
+      slotDuration: this.aztecSlotDuration,
+      l1GenesisTime: this.l1GenesisTime,
+    });
 
-    const globalVariables = new GlobalVariables(
-      chainId,
-      version,
-      blockNumber,
-      slot,
-      timestamp,
-      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,13 +1,7 @@
 export * from './client/index.js';
 export * from './config.js';
 export * from './publisher/index.js';
-export {
-  FullNodeBlockBuilder as BlockBuilder,
-  Sequencer,
-  SequencerState,
-  type SequencerEvents,
-} from './sequencer/index.js';
-export * from './tx_validator/tx_validator_factory.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,10 +1,6 @@
-import { type BlobSinkConfig, blobSinkConfigMapping } from '@aztec/blob-sink/client';
-import {
-  type L1ReaderConfig,
-  type L1TxUtilsConfig,
-  l1ReaderConfigMappings,
-  l1TxUtilsConfigMappings,
-} from '@aztec/ethereum';
+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,
@@ -32,11 +28,13 @@ export type TxSenderConfig = L1ReaderConfig & {
  * Configuration of the L1Publisher.
  */
 export type PublisherConfig = L1TxUtilsConfig &
-  BlobSinkConfig & {
+  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: (
@@ -76,8 +74,13 @@ export const getPublisherConfigMappings: (
       '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/sequencer-publisher-factory.ts

@@ -1,9 +1,10 @@
 import { EthAddress } from '@aztec/aztec.js/addresses';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
 import type { EpochCache } from '@aztec/epoch-cache';
-import type { GovernanceProposerContract, PublisherFilter, PublisherManager, RollupContract } from '@aztec/ethereum';
+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';
@@ -32,7 +33,7 @@ export class SequencerPublisherFactory {
     private deps: {
       telemetry: TelemetryClient;
       publisherManager: PublisherManager<L1TxUtilsWithBlobs>;
-      blobSinkClient?: BlobSinkClientInterface;
+      blobClient: BlobClientInterface;
       dateProvider: DateProvider;
       epochCache: EpochCache;
       rollupContract: RollupContract;
@@ -71,7 +72,7 @@ export class SequencerPublisherFactory {
     const publisher = new SequencerPublisher(this.sequencerConfig, {
       l1TxUtils: l1Publisher,
       telemetry: this.deps.telemetry,
-      blobSinkClient: this.deps.blobSinkClient,
+      blobClient: this.deps.blobClient,
       rollupContract: this.deps.rollupContract,
       epochCache: this.deps.epochCache,
       governanceProposerContract: this.deps.governanceProposerContract,

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

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/aztec.js/log';
-import type { L1PublishBlockStats, L1PublishStats } from '@aztec/stdlib/stats';
+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';
@@ -40,88 +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.txTotalFee = meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE, {
-      description: 'How much L1 tx costs',
-      unit: 'eth',
-      valueType: ValueType.DOUBLE,
-      advice: {
-        explicitBucketBoundaries: [
-          0.001, 0.002, 0.004, 0.008, 0.01, 0.02, 0.04, 0.08, 0.1, 0.2, 0.4, 0.8, 1, 1.2, 1.4, 1.8, 2,
-        ],
-      },
-    });
+    this.txTotalFee = meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE);
 
-    this.senderBalance = meter.createGauge(Metrics.L1_PUBLISHER_BALANCE, {
-      unit: 'eth',
-      description: 'The balance of the sender address',
-      valueType: ValueType.DOUBLE,
-    });
+    this.senderBalance = meter.createGauge(Metrics.L1_PUBLISHER_BALANCE);
   }
 
   recordFailedTx(txType: L1TxType) {
@@ -135,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) {