@aztec/sequencer-client 0.67.1 → 0.68.0

package/src/publisher/l1-publisher.ts

@@ -7,16 +7,15 @@ import {
   type TxHash,
   getHashedSignaturePayload,
 } from '@aztec/circuit-types';
-import { type L1PublishBlockStats, type L1PublishProofStats } from '@aztec/circuit-types/stats';
+import { type L1PublishBlockStats, type L1PublishProofStats, type L1PublishStats } from '@aztec/circuit-types/stats';
 import {
   AGGREGATION_OBJECT_LENGTH,
   AZTEC_MAX_EPOCH_DURATION,
   type BlockHeader,
   EthAddress,
-  type FeeRecipient,
   type Proof,
-  type RootRollupPublicInputs,
 } from '@aztec/circuits.js';
+import { type FeeRecipient, type RootRollupPublicInputs } from '@aztec/circuits.js/rollup';
 import {
   type EthereumChain,
   type L1ContractsConfig,
@@ -25,6 +24,8 @@ import {
   createEthereumChain,
 } from '@aztec/ethereum';
 import { makeTuple } from '@aztec/foundation/array';
+import { toHex } from '@aztec/foundation/bigint-buffer';
+import { Blob } from '@aztec/foundation/blob';
 import { areArraysEqual, compactArray, times } from '@aztec/foundation/collection';
 import { type Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
@@ -32,16 +33,15 @@ import { createLogger } from '@aztec/foundation/log';
 import { type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { InterruptibleSleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
-import { GovernanceProposerAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { ExtRollupLibAbi, GovernanceProposerAbi, LeonidasLibAbi, RollupAbi } from '@aztec/l1-artifacts';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import pick from 'lodash.pick';
-import { inspect } from 'util';
 import {
   type BaseError,
   type Chain,
   type Client,
-  type ContractFunctionExecutionError,
+  ContractFunctionExecutionError,
   ContractFunctionRevertedError,
   type GetContractReturnType,
   type Hex,
@@ -60,6 +60,7 @@ import {
   getAbiItem,
   getAddress,
   getContract,
+  getContractError,
   hexToBytes,
   http,
   publicActions,
@@ -68,7 +69,7 @@ import { privateKeyToAccount } from 'viem/accounts';
 
 import { type PublisherConfig, type TxSenderConfig } from './config.js';
 import { L1PublisherMetrics } from './l1-publisher-metrics.js';
-import { prettyLogViemError, prettyLogViemErrorMsg } from './utils.js';
+import { prettyLogViemErrorMsg } from './utils.js';
 
 /**
  * Stats for a sent transaction.
@@ -110,8 +111,10 @@ type L1ProcessArgs = {
   archive: Buffer;
   /** The L2 block's leaf in the archive tree. */
   blockHash: Buffer;
-  /** L2 block body. */
+  /** L2 block body. TODO(#9101): Remove block body once we can extract blobs. */
   body: Buffer;
+  /** L2 block blobs containing all tx effects. */
+  blobs: Blob[];
   /** L2 block tx hashes */
   txHashes: TxHash[];
   /** Attestations */
@@ -166,6 +169,9 @@ export class L1Publisher {
   protected account: PrivateKeyAccount;
   protected ethereumSlotDuration: bigint;
 
+  // @note - with blobs, the below estimate seems too large.
+  // Total used for full block from int_l1_pub e2e test: 1m (of which 86k is 1x blob)
+  // Total used for emptier block from above test: 429k (of which 84k is 1x blob)
   public static PROPOSE_GAS_GUESS: bigint = 12_000_000n;
   public static PROPOSE_AND_CLAIM_GAS_GUESS: bigint = this.PROPOSE_GAS_GUESS + 100_000n;
 
@@ -342,7 +348,10 @@ export class L1Publisher {
     try {
       await this.rollupContract.read.validateEpochProofRightClaimAtTime(args, { account: this.account });
     } catch (err) {
-      const errorName = tryGetCustomErrorName(err);
+      let errorName = tryGetCustomErrorName(err);
+      if (!errorName) {
+        errorName = tryGetCustomErrorNameContractFunction(err as ContractFunctionExecutionError);
+      }
       this.log.warn(`Proof quote validation failed: ${errorName}`, quote);
       return undefined;
     }
@@ -375,7 +384,7 @@ export class L1Publisher {
       formattedSignatures,
       `0x${attestationData.digest.toString('hex')}`,
       ts,
-      `0x${header.contentCommitment.txsEffectsHash.toString('hex')}`,
+      `0x${header.contentCommitment.blobsHash.toString('hex')}`,
       flags,
     ] as const;
 
@@ -386,6 +395,36 @@ export class L1Publisher {
       if (error instanceof ContractFunctionRevertedError) {
         const err = error as ContractFunctionRevertedError;
         this.log.debug(`Validation failed: ${err.message}`, err.data);
+      } else if (error instanceof ContractFunctionExecutionError) {
+        let err = error as ContractFunctionRevertedError;
+        if (!tryGetCustomErrorName(err)) {
+          // If we get here, it's because the custom error no longer exists in Rollup.sol,
+          // but in another lib. The below reconstructs the error message.
+          try {
+            await this.publicClient.estimateGas({
+              data: encodeFunctionData({
+                abi: this.rollupContract.abi,
+                functionName: 'validateHeader',
+                args,
+              }),
+              account: this.account,
+              to: this.rollupContract.address,
+            });
+          } catch (estGasErr: unknown) {
+            const possibleAbis = [ExtRollupLibAbi, LeonidasLibAbi];
+            possibleAbis.forEach(abi => {
+              const possibleErr = getContractError(estGasErr as BaseError, {
+                args: [],
+                abi: abi,
+                functionName: 'validateHeader',
+                address: this.rollupContract.address,
+                sender: this.account.address,
+              });
+              err = tryGetCustomErrorName(possibleErr) ? possibleErr : err;
+            });
+          }
+          throw err;
+        }
       } else {
         this.log.debug(`Unexpected error during validation: ${error}`);
       }
@@ -501,10 +540,10 @@ export class L1Publisher {
       archive: block.archive.root.toBuffer(),
       blockHash: block.header.hash().toBuffer(),
       body: block.body.toBuffer(),
+      blobs: Blob.getBlobs(block.body.toBlobFields()),
       attestations,
       txHashes: txHashes ?? [],
     };
-
     // Publish body and propose block (if not already published)
     if (this.interrupted) {
       this.log.verbose('L2 block data syncing interrupted while processing blocks.', ctx);
@@ -532,7 +571,7 @@ export class L1Publisher {
       return false;
     }
 
-    const { receipt, args, functionName } = result;
+    const { receipt, args, functionName, data } = result;
 
     // Tx was mined successfully
     if (receipt.status === 'success') {
@@ -540,6 +579,8 @@ export class L1Publisher {
       const stats: L1PublishBlockStats = {
         gasPrice: receipt.effectiveGasPrice,
         gasUsed: receipt.gasUsed,
+        blobGasUsed: receipt.blobGasUsed ?? 0n,
+        blobDataGas: receipt.blobGasPrice ?? 0n,
         transactionHash: receipt.transactionHash,
         ...pick(tx!, 'calldataGas', 'calldataSize', 'sender'),
         ...block.getStats(),
@@ -551,14 +592,21 @@ export class L1Publisher {
     }
 
     this.metrics.recordFailedTx('process');
-
-    const errorMsg = await this.tryGetErrorFromRevertedTx({
-      args,
-      functionName,
-      abi: RollupAbi,
-      address: this.rollupContract.address,
-      blockNumber: receipt.blockNumber,
-    });
+    const kzg = Blob.getViemKzgInstance();
+    const errorMsg = await this.tryGetErrorFromRevertedTx(
+      data,
+      {
+        args,
+        functionName,
+        abi: RollupAbi,
+        address: this.rollupContract.address,
+      },
+      {
+        blobs: proposeTxArgs.blobs.map(b => b.data),
+        kzg,
+        maxFeePerBlobGas: 10000000000n,
+      },
+    );
     this.log.error(`Rollup process tx reverted. ${errorMsg}`, undefined, {
       ...ctx,
       txHash: receipt.transactionHash,
@@ -567,25 +615,118 @@ export class L1Publisher {
     return false;
   }
 
-  private async tryGetErrorFromRevertedTx(args: {
-    args: any[];
-    functionName: string;
-    abi: any;
-    address: Hex;
-    blockNumber: bigint | undefined;
-  }) {
+  /** Calls claimEpochProofRight in the Rollup contract to submit a chosen prover quote for the previous epoch. */
+  public async claimEpochProofRight(proofQuote: EpochProofQuote) {
+    const timer = new Timer();
+
+    let receipt;
     try {
-      await this.publicClient.simulateContract({ ...args, account: this.walletClient.account });
+      this.log.debug(`Submitting claimEpochProofRight transaction`);
+      receipt = await this.l1TxUtils.sendAndMonitorTransaction({
+        to: this.rollupContract.address,
+        data: encodeFunctionData({
+          abi: RollupAbi,
+          functionName: 'claimEpochProofRight',
+          args: [proofQuote.toViemArgs()],
+        }),
+      });
+    } catch (err) {
+      this.log.error(`Failed to claim epoch proof right: ${prettyLogViemErrorMsg(err)}`, err, {
+        proofQuote: proofQuote.toInspect(),
+      });
+      return false;
+    }
+
+    if (receipt.status === 'success') {
+      const tx = await this.getTransactionStats(receipt.transactionHash);
+      const stats: L1PublishStats = {
+        gasPrice: receipt.effectiveGasPrice,
+        gasUsed: receipt.gasUsed,
+        transactionHash: receipt.transactionHash,
+        blobDataGas: 0n,
+        blobGasUsed: 0n,
+        ...pick(tx!, 'calldataGas', 'calldataSize', 'sender'),
+      };
+      this.log.verbose(`Submitted claim epoch proof right to L1 rollup contract`, {
+        ...stats,
+        ...proofQuote.toInspect(),
+      });
+      this.metrics.recordClaimEpochProofRightTx(timer.ms(), stats);
+      return true;
+    } else {
+      this.metrics.recordFailedTx('claimEpochProofRight');
+      // TODO: Get the error message from the reverted tx
+      this.log.error(`Claim epoch proof right tx reverted`, {
+        txHash: receipt.transactionHash,
+        ...proofQuote.toInspect(),
+      });
+      return false;
+    }
+  }
+
+  private async tryGetErrorFromRevertedTx(
+    data: Hex,
+    args: {
+      args: any[];
+      functionName: string;
+      abi: any;
+      address: Hex;
+    },
+    _blobInputs?: {
+      blobs: Uint8Array[];
+      kzg: any;
+      maxFeePerBlobGas: bigint;
+    },
+  ) {
+    const blobInputs = _blobInputs || {};
+    try {
+      // NB: If this fn starts unexpectedly giving incorrect blob hash errors, it may be because the checkBlob
+      // bool is no longer at the slot below. To find the slot, run: forge inspect src/core/Rollup.sol:Rollup storage
+      const checkBlobSlot = 9n;
+      await this.publicClient.simulateContract({
+        ...args,
+        account: this.walletClient.account,
+        stateOverride: [
+          {
+            address: args.address,
+            stateDiff: [
+              {
+                slot: toHex(checkBlobSlot, true),
+                value: toHex(0n, true),
+              },
+            ],
+          },
+        ],
+      });
+      // If the above passes, we have a blob error. We cannot simulate blob txs, and failed txs no longer throw errors,
+      // and viem provides no way to get the revert reason from a given tx.
+      // Strangely, the only way to throw the revert reason as an error and provide blobs is prepareTransactionRequest.
+      // See: https://github.com/wevm/viem/issues/2075
+      // This throws a EstimateGasExecutionError with the custom error information:
+      await this.walletClient.prepareTransactionRequest({
+        account: this.walletClient.account,
+        to: this.rollupContract.address,
+        data,
+        ...blobInputs,
+      });
       return undefined;
-    } catch (err: any) {
-      if (err.name === 'ContractFunctionExecutionError') {
-        const execErr = err as ContractFunctionExecutionError;
-        return compactArray([
-          execErr.shortMessage,
-          ...(execErr.metaMessages ?? []).slice(0, 2).map(s => s.trim()),
-        ]).join(' ');
+    } catch (simulationErr: any) {
+      // If we don't have a ContractFunctionExecutionError, we have a blob related error => use ExtRollupLibAbi to get the error msg.
+      const contractErr =
+        simulationErr.name === 'ContractFunctionExecutionError'
+          ? simulationErr
+          : getContractError(simulationErr as BaseError, {
+              args: [],
+              abi: ExtRollupLibAbi,
+              functionName: args.functionName,
+              address: args.address,
+              sender: this.account.address,
+            });
+      if (contractErr.name === 'ContractFunctionExecutionError') {
+        const execErr = contractErr as ContractFunctionExecutionError;
+        return tryGetCustomErrorNameContractFunction(execErr);
       }
-      this.log.error(`Error getting error from simulation`, err);
+      this.log.error(`Error getting error from simulation`, simulationErr);
     }
   }
 
@@ -620,6 +761,8 @@ export class L1Publisher {
         const stats: L1PublishProofStats = {
           ...pick(receipt, 'gasPrice', 'gasUsed', 'transactionHash'),
           ...pick(tx!, 'calldataGas', 'calldataSize', 'sender'),
+          blobDataGas: 0n,
+          blobGasUsed: 0n,
           eventName: 'proof-published-to-l1',
         };
         this.log.info(`Published epoch proof to L1 rollup contract`, { ...stats, ...ctx });
@@ -726,7 +869,8 @@ export class L1Publisher {
           epochSize: argsArray[0],
           args: argsArray[1],
           fees: argsArray[2],
-          aggregationObject: argsArray[3],
+          blobPublicInputs: argsArray[3],
+          aggregationObject: argsArray[4],
           proof: proofHex,
         },
       ] as const;
@@ -750,22 +894,31 @@ export class L1Publisher {
   }
 
   private async prepareProposeTx(encodedData: L1ProcessArgs) {
-    const computeTxsEffectsHashGas = await this.l1TxUtils.estimateGas(this.account, {
-      to: this.rollupContract.address,
-      data: encodeFunctionData({
-        abi: this.rollupContract.abi,
-        functionName: 'computeTxsEffectsHash',
-        args: [`0x${encodedData.body.toString('hex')}`],
-      }),
-    });
+    const kzg = Blob.getViemKzgInstance();
+    const blobEvaluationGas = await this.l1TxUtils.estimateGas(
+      this.account,
+      {
+        to: this.rollupContract.address,
+        data: encodeFunctionData({
+          abi: this.rollupContract.abi,
+          functionName: 'validateBlobs',
+          args: [Blob.getEthBlobEvaluationInputs(encodedData.blobs)],
+        }),
+      },
+      {},
+      {
+        blobs: encodedData.blobs.map(b => b.data),
+        kzg,
+        maxFeePerBlobGas: 10000000000n, //This is 10 gwei, taken from DEFAULT_MAX_FEE_PER_GAS
+      },
+    );
 
     // @note  We perform this guesstimate instead of the usual `gasEstimate` since
     //        viem will use the current state to simulate against, which means that
     //        we will fail estimation in the case where we are simulating for the
     //        first ethereum block within our slot (as current time is not in the
     //        slot yet).
-    const gasGuesstimate = computeTxsEffectsHashGas + L1Publisher.PROPOSE_GAS_GUESS;
-
+    const gasGuesstimate = blobEvaluationGas + L1Publisher.PROPOSE_GAS_GUESS;
     const attestations = encodedData.attestations
       ? encodedData.attestations.map(attest => attest.toViemSignature())
       : [];
@@ -783,7 +936,9 @@ export class L1Publisher {
         txHashes,
       },
       attestations,
+      // TODO(#9101): Extract blobs from beacon chain => calldata will only contain what's needed to verify blob and body input can be removed
       `0x${encodedData.body.toString('hex')}`,
+      Blob.getEthBlobEvaluationInputs(encodedData.blobs),
     ] as const;
 
     return { args, gas: gasGuesstimate };
@@ -811,39 +966,50 @@ export class L1Publisher {
           ? args.publicInputs.fees[i / 2].recipient.toField().toString()
           : args.publicInputs.fees[(i - 1) / 2].value.toString(),
       ),
+      `0x${args.publicInputs.blobPublicInputs
+        .filter((_, i) => i < args.toBlock - args.fromBlock + 1)
+        .map(b => b.toString())
+        .join(``)}`,
       `0x${serializeToBuffer(args.proof.extractAggregationObject()).toString('hex')}`,
     ] as const;
   }
 
   private async sendProposeTx(
     encodedData: L1ProcessArgs,
-  ): Promise<{ receipt: TransactionReceipt; args: any; functionName: string } | undefined> {
+  ): Promise<{ receipt: TransactionReceipt | undefined; args: any; functionName: string; data: Hex } | undefined> {
     if (this.interrupted) {
       return undefined;
     }
     try {
+      const kzg = Blob.getViemKzgInstance();
       const { args, gas } = await this.prepareProposeTx(encodedData);
+      const data = encodeFunctionData({
+        abi: this.rollupContract.abi,
+        functionName: 'propose',
+        args,
+      });
       const receipt = await this.l1TxUtils.sendAndMonitorTransaction(
         {
           to: this.rollupContract.address,
-          data: encodeFunctionData({
-            abi: this.rollupContract.abi,
-            functionName: 'propose',
-            args,
-          }),
+          data,
         },
         {
           fixedGas: gas,
         },
+        {
+          blobs: encodedData.blobs.map(b => b.data),
+          kzg,
+          maxFeePerBlobGas: 10000000000n, //This is 10 gwei, taken from DEFAULT_MAX_FEE_PER_GAS
+        },
       );
       return {
         receipt,
         args,
         functionName: 'propose',
+        data,
       };
     } catch (err) {
-      prettyLogViemError(err, this.log);
-      this.log.error(`Rollup publish failed`, err);
+      this.log.error(`Rollup publish failed: ${prettyLogViemErrorMsg(err)}`, err);
       return undefined;
     }
   }
@@ -851,36 +1017,39 @@ export class L1Publisher {
   private async sendProposeAndClaimTx(
     encodedData: L1ProcessArgs,
     quote: EpochProofQuote,
-  ): Promise<{ receipt: TransactionReceipt; args: any; functionName: string } | undefined> {
+  ): Promise<{ receipt: TransactionReceipt | undefined; args: any; functionName: string; data: Hex } | undefined> {
     if (this.interrupted) {
       return undefined;
     }
     try {
-      this.log.info(`ProposeAndClaim`);
-      this.log.info(inspect(quote.payload));
-
+      const kzg = Blob.getViemKzgInstance();
       const { args, gas } = await this.prepareProposeTx(encodedData);
+      const data = encodeFunctionData({
+        abi: this.rollupContract.abi,
+        functionName: 'proposeAndClaim',
+        args: [...args, quote.toViemArgs()],
+      });
       const receipt = await this.l1TxUtils.sendAndMonitorTransaction(
         {
           to: this.rollupContract.address,
-          data: encodeFunctionData({
-            abi: this.rollupContract.abi,
-            functionName: 'proposeAndClaim',
-            args: [...args, quote.toViemArgs()],
-          }),
+          data,
         },
         { fixedGas: gas },
+        {
+          blobs: encodedData.blobs.map(b => b.data),
+          kzg,
+          maxFeePerBlobGas: 10000000000n, //This is 10 gwei, taken from DEFAULT_MAX_FEE_PER_GAS
+        },
       );
 
       return {
         receipt,
-        args,
+        args: [...args, quote.toViemArgs()],
         functionName: 'proposeAndClaim',
+        data,
       };
     } catch (err) {
-      prettyLogViemError(err, this.log);
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      this.log.error(`Rollup publish failed`, errorMessage);
+      this.log.error(`Rollup publish failed: ${prettyLogViemErrorMsg(err)}`, err);
       return undefined;
     }
   }
@@ -935,6 +1104,10 @@ function getCalldataGasUsage(data: Uint8Array) {
   return data.filter(byte => byte === 0).length * 4 + data.filter(byte => byte !== 0).length * 16;
 }
 
+function tryGetCustomErrorNameContractFunction(err: ContractFunctionExecutionError) {
+  return compactArray([err.shortMessage, ...(err.metaMessages ?? []).slice(0, 2).map(s => s.trim())]).join(' ');
+}
+
 function tryGetCustomErrorName(err: any) {
   try {
     // See https://viem.sh/docs/contract/simulateContract#handling-custom-errors

package/src/publisher/utils.ts

@@ -1,5 +1,3 @@
-import { type Logger } from '@aztec/foundation/log';
-
 import { BaseError, ContractFunctionRevertedError } from 'viem';
 
 export function prettyLogViemErrorMsg(err: any) {
@@ -12,12 +10,5 @@ export function prettyLogViemErrorMsg(err: any) {
       return `${errorName}${args}`;
     }
   }
-}
-
-// TODO(palla/log): Review this method
-export function prettyLogViemError(err: any, logger: Logger) {
-  const msg = prettyLogViemErrorMsg(err);
-  if (msg) {
-    logger.debug(`canProposeAtTime failed with "${msg}"`);
-  }
+  return err?.message ?? err;
 }

package/src/sequencer/allowed.ts

@@ -0,0 +1,36 @@
+import { type AllowedElement } from '@aztec/circuit-types';
+import { getContractClassFromArtifact } from '@aztec/circuits.js';
+import { FPCContract } from '@aztec/noir-contracts.js/FPC';
+import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+
+let defaultAllowedSetupFunctions: AllowedElement[] | undefined = undefined;
+
+export function getDefaultAllowedSetupFunctions(): AllowedElement[] {
+  if (defaultAllowedSetupFunctions === undefined) {
+    defaultAllowedSetupFunctions = [
+      // needed for authwit support
+      {
+        address: ProtocolContractAddress.AuthRegistry,
+      },
+      // needed for claiming on the same tx as a spend
+      {
+        address: ProtocolContractAddress.FeeJuice,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
+      },
+      // needed for private transfers via FPC
+      {
+        classId: getContractClassFromArtifact(TokenContractArtifact).id,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
+      },
+      {
+        classId: getContractClassFromArtifact(FPCContract.artifact).id,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('prepare_fee((Field),Field,(Field),Field)'),
+      },
+    ];
+  }
+  return defaultAllowedSetupFunctions;
+}

package/src/sequencer/config.ts

@@ -1 +1 @@
-export { SequencerConfig } from '@aztec/circuit-types';
+export { type SequencerConfig } from '@aztec/circuit-types/config';

package/src/sequencer/metrics.ts

@@ -19,6 +19,7 @@ export class SequencerMetrics {
   private stateTransitionBufferDuration: Histogram;
   private currentBlockNumber: Gauge;
   private currentBlockSize: Gauge;
+  private blockBuilderInsertions: Histogram;
 
   private timeToCollectAttestations: Gauge;
 
@@ -49,14 +50,23 @@ export class SequencerMetrics {
 
     this.currentBlockNumber = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_NUMBER, {
       description: 'Current block number',
+      valueType: ValueType.INT,
     });
 
     this.currentBlockSize = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_SIZE, {
-      description: 'Current block number',
+      description: 'Current block size',
+      valueType: ValueType.INT,
     });
 
     this.timeToCollectAttestations = meter.createGauge(Metrics.SEQUENCER_TIME_TO_COLLECT_ATTESTATIONS, {
       description: 'The time spent collecting attestations from committee members',
+      valueType: ValueType.INT,
+    });
+
+    this.blockBuilderInsertions = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_INSERTION_TIME, {
+      description: 'Timer for tree insertions performed by the block builder',
+      unit: 'us',
+      valueType: ValueType.INT,
     });
 
     this.setCurrentBlock(0, 0);
@@ -75,6 +85,10 @@ export class SequencerMetrics {
     this.timeToCollectAttestations.record(time);
   }
 
+  recordBlockBuilderTreeInsertions(timeUs: number) {
+    this.blockBuilderInsertions.record(Math.ceil(timeUs));
+  }
+
   recordCancelledBlock() {
     this.blockCounter.add(1, {
       [Attributes.STATUS]: 'cancelled',