@aztec/sequencer-client 0.0.1-commit.6230efd → 0.0.1-commit.6b90f3f5

package/src/global_variable_builder/global_builder.ts

@@ -23,7 +23,7 @@ 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;
@@ -61,34 +61,34 @@ 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.getPendingCheckpoint();
+    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());
+      this.currentMinFees = this.currentMinFees.then(() => this.computeCurrentMinFees());
     }
-    return this.currentBaseFees;
+    return this.currentMinFees;
   }
 
   /**
@@ -128,9 +128,9 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
       l1GenesisTime: this.l1GenesisTime,
     });
 
-    // We can skip much of the logic in getCurrentBaseFees since it we already check that we are not within a slot elsewhere.
+    // 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.getManaBaseFeeAt(timestamp, true));
+    const gasFees = new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
 
     return { chainId, version, slotNumber, timestamp, coinbase, feeRecipient, gasFees };
   }

package/src/index.ts

@@ -1,15 +1,7 @@
 export * from './client/index.js';
 export * from './config.js';
 export * from './publisher/index.js';
-export {
-  FullNodeBlockBuilder as BlockBuilder,
-  FullNodeCheckpointsBuilder as CheckpointsBuilder,
-  CheckpointBuilder,
-  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/sequencer-publisher-metrics.ts

@@ -7,7 +7,7 @@ import {
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import { formatEther } from 'viem/utils';
@@ -40,88 +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.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) {