@aztec/node-lib 3.0.0-nightly.20251004 → 3.0.0-nightly.20251007

package/dest/stores/l1_tx_store.js

@@ -0,0 +1,264 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+/**
+ * Store for persisting L1 transaction states across all L1TxUtils instances.
+ * Each state is stored individually with a unique ID, and blobs are stored separately.
+ * @remarks This class lives in this package instead of `ethereum` because it depends on `kv-store`.
+ */ export class L1TxStore {
+    store;
+    log;
+    static SCHEMA_VERSION = 2;
+    states;
+    blobs;
+    stateIdCounter;
+    constructor(store, log = createLogger('l1-tx-utils:store')){
+        this.store = store;
+        this.log = log;
+        this.states = store.openMap('l1_tx_states');
+        this.blobs = store.openMap('l1_tx_blobs');
+        this.stateIdCounter = store.openMap('l1_tx_state_id_counter');
+    }
+    /**
+   * Gets the next available state ID for an account.
+   */ consumeNextStateId(account) {
+        return this.store.transactionAsync(async ()=>{
+            const currentId = await this.stateIdCounter.getAsync(account) ?? 0;
+            const nextId = currentId + 1;
+            await this.stateIdCounter.set(account, nextId);
+            return nextId;
+        });
+    }
+    /**
+   * Creates a storage key for state/blob data.
+   */ makeKey(account, stateId) {
+        return `${account}-${stateId.toString().padStart(10, '0')}`;
+    }
+    /**
+   * Saves a single transaction state for a specific account.
+   * Blobs are not stored here, use saveBlobs instead.
+   * @param account - The sender account address
+   * @param state - Transaction state to save
+   */ async saveState(account, state) {
+        const key = this.makeKey(account, state.id);
+        const serializable = this.serializeState(state);
+        await this.states.set(key, jsonStringify(serializable));
+        this.log.debug(`Saved tx state ${state.id} for account ${account} with nonce ${state.nonce}`);
+        return state;
+    }
+    /**
+   * Saves blobs for a given state.
+   * @param account - The sender account address
+   * @param stateId - The state ID
+   * @param blobInputs - Blob inputs to save
+   */ async saveBlobs(account, stateId, blobInputs) {
+        if (!blobInputs) {
+            return;
+        }
+        const key = this.makeKey(account, stateId);
+        const blobData = this.serializeBlobInputs(blobInputs);
+        await this.blobs.set(key, jsonStringify(blobData));
+        this.log.debug(`Saved blobs for state ${stateId} of account ${account}`);
+    }
+    /**
+   * Loads all transaction states for a specific account.
+   * @param account - The sender account address
+   * @returns Array of transaction states with their IDs
+   */ async loadStates(account) {
+        const states = [];
+        const prefix = `${account}-`;
+        for await (const [key, stateJson] of this.states.entriesAsync({
+            start: prefix,
+            end: `${prefix}Z`
+        })){
+            const [keyAccount, stateIdStr] = key.split('-');
+            if (keyAccount !== account) {
+                throw new Error(`Mismatched account in key: expected ${account} but got ${keyAccount}`);
+            }
+            const stateId = parseInt(stateIdStr, 10);
+            try {
+                const serialized = JSON.parse(stateJson);
+                // Load blobs if they exist
+                let blobInputs;
+                if (serialized.hasBlobInputs) {
+                    const blobJson = await this.blobs.getAsync(key);
+                    if (blobJson) {
+                        blobInputs = this.deserializeBlobInputs(JSON.parse(blobJson), serialized.blobMetadata);
+                    }
+                }
+                const state = this.deserializeState(serialized, blobInputs);
+                states.push({
+                    ...state,
+                    id: stateId
+                });
+            } catch (err) {
+                this.log.error(`Failed to deserialize state ${key}`, err);
+            }
+        }
+        // Sort by ID
+        states.sort((a, b)=>a.id - b.id);
+        this.log.debug(`Loaded ${states.length} tx states for account ${account}`);
+        return states;
+    }
+    /**
+   * Loads a single state by ID.
+   * @param account - The sender account address
+   * @param stateId - The state ID
+   * @returns The transaction state or undefined if not found
+   */ async loadState(account, stateId) {
+        const key = this.makeKey(account, stateId);
+        const stateJson = await this.states.getAsync(key);
+        if (!stateJson) {
+            return undefined;
+        }
+        try {
+            const serialized = JSON.parse(stateJson);
+            // Load blobs if they exist
+            let blobInputs;
+            if (serialized.hasBlobInputs) {
+                const blobJson = await this.blobs.getAsync(key);
+                if (blobJson) {
+                    blobInputs = this.deserializeBlobInputs(JSON.parse(blobJson), serialized.blobMetadata);
+                }
+            }
+            const state = this.deserializeState(serialized, blobInputs);
+            return {
+                ...state,
+                id: stateId
+            };
+        } catch (err) {
+            this.log.error(`Failed to deserialize state ${key}`, err);
+            return undefined;
+        }
+    }
+    /**
+   * Deletes a specific state and its associated blobs.
+   * @param account - The sender account address
+   * @param stateId - The state ID to delete
+   */ async deleteState(account, stateId) {
+        const key = this.makeKey(account, stateId);
+        await this.states.delete(key);
+        await this.blobs.delete(key);
+        this.log.debug(`Deleted state ${stateId} for account ${account}`);
+    }
+    /**
+   * Clears all transaction states for a specific account.
+   * @param account - The sender account address
+   */ async clearStates(account) {
+        const states = await this.loadStates(account);
+        for (const state of states){
+            await this.deleteState(account, state.id);
+        }
+        await this.stateIdCounter.delete(account);
+        this.log.info(`Cleared all tx states for account ${account}`);
+    }
+    /**
+   * Gets all accounts that have stored states.
+   * @returns Array of account addresses
+   */ async getAllAccounts() {
+        const accounts = new Set();
+        for await (const [key] of this.states.entriesAsync()){
+            const account = key.substring(0, key.lastIndexOf('-'));
+            accounts.add(account);
+        }
+        return Array.from(accounts);
+    }
+    /**
+   * Closes the store.
+   */ async close() {
+        await this.store.close();
+        this.log.info('Closed L1 tx state store');
+    }
+    /**
+   * Serializes an L1TxState for storage.
+   */ serializeState(state) {
+        const txConfigOverrides = {
+            ...state.txConfigOverrides,
+            gasLimit: state.txConfigOverrides.gasLimit?.toString(),
+            txTimeoutAt: state.txConfigOverrides.txTimeoutAt?.getTime()
+        };
+        return {
+            id: state.id,
+            txHashes: state.txHashes,
+            cancelTxHashes: state.cancelTxHashes,
+            gasLimit: state.gasLimit.toString(),
+            gasPrice: {
+                maxFeePerGas: state.gasPrice.maxFeePerGas.toString(),
+                maxPriorityFeePerGas: state.gasPrice.maxPriorityFeePerGas.toString(),
+                maxFeePerBlobGas: state.gasPrice.maxFeePerBlobGas?.toString()
+            },
+            txConfigOverrides,
+            request: {
+                ...state.request,
+                value: state.request.value?.toString()
+            },
+            status: state.status,
+            nonce: state.nonce,
+            sentAt: state.sentAtL1Ts.getTime(),
+            lastSentAt: state.lastSentAtL1Ts.getTime(),
+            receipt: state.receipt,
+            hasBlobInputs: state.blobInputs !== undefined,
+            blobMetadata: state.blobInputs?.maxFeePerBlobGas ? {
+                maxFeePerBlobGas: state.blobInputs.maxFeePerBlobGas.toString()
+            } : undefined
+        };
+    }
+    /**
+   * Deserializes a stored state back to L1TxState.
+   */ deserializeState(stored, blobInputs) {
+        const txConfigOverrides = {
+            ...stored.txConfigOverrides,
+            gasLimit: stored.txConfigOverrides.gasLimit !== undefined ? BigInt(stored.txConfigOverrides.gasLimit) : undefined,
+            txTimeoutAt: stored.txConfigOverrides.txTimeoutAt !== undefined ? new Date(stored.txConfigOverrides.txTimeoutAt) : undefined
+        };
+        const receipt = stored.receipt ? {
+            ...stored.receipt,
+            blockNumber: BigInt(stored.receipt.blockNumber),
+            cumulativeGasUsed: BigInt(stored.receipt.cumulativeGasUsed),
+            effectiveGasPrice: BigInt(stored.receipt.effectiveGasPrice),
+            gasUsed: BigInt(stored.receipt.gasUsed)
+        } : undefined;
+        return {
+            id: stored.id,
+            txHashes: stored.txHashes,
+            cancelTxHashes: stored.cancelTxHashes,
+            gasLimit: BigInt(stored.gasLimit),
+            gasPrice: {
+                maxFeePerGas: BigInt(stored.gasPrice.maxFeePerGas),
+                maxPriorityFeePerGas: BigInt(stored.gasPrice.maxPriorityFeePerGas),
+                maxFeePerBlobGas: stored.gasPrice.maxFeePerBlobGas ? BigInt(stored.gasPrice.maxFeePerBlobGas) : undefined
+            },
+            txConfigOverrides,
+            request: {
+                to: stored.request.to,
+                data: stored.request.data,
+                value: stored.request.value ? BigInt(stored.request.value) : undefined
+            },
+            status: stored.status,
+            nonce: stored.nonce,
+            sentAtL1Ts: new Date(stored.sentAt),
+            lastSentAtL1Ts: new Date(stored.lastSentAt),
+            receipt,
+            blobInputs
+        };
+    }
+    /**
+   * Serializes blob inputs for separate storage.
+   */ serializeBlobInputs(blobInputs) {
+        return {
+            blobs: blobInputs.blobs.map((b)=>Buffer.from(b).toString('base64')),
+            kzg: jsonStringify(blobInputs.kzg)
+        };
+    }
+    /**
+   * Deserializes blob inputs from storage, combining blob data with metadata.
+   */ deserializeBlobInputs(stored, metadata) {
+        const blobInputs = {
+            blobs: stored.blobs.map((b)=>new Uint8Array(Buffer.from(b, 'base64'))),
+            kzg: JSON.parse(stored.kzg)
+        };
+        if (metadata?.maxFeePerBlobGas) {
+            blobInputs.maxFeePerBlobGas = BigInt(metadata.maxFeePerBlobGas);
+        }
+        return blobInputs;
+    }
+}

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@aztec/node-lib",
-  "version": "3.0.0-nightly.20251004",
+  "version": "3.0.0-nightly.20251007",
   "type": "module",
   "exports": {
     "./actions": "./dest/actions/index.js",
-    "./config": "./dest/config/index.js"
+    "./config": "./dest/config/index.js",
+    "./factories": "./dest/factories/index.js",
+    "./metrics": "./dest/metrics/index.js",
+    "./stores": "./dest/stores/index.js"
   },
   "inherits": [
     "../package.common.json"
@@ -54,27 +57,28 @@
     ]
   },
   "dependencies": {
-    "@aztec/archiver": "3.0.0-nightly.20251004",
-    "@aztec/bb-prover": "3.0.0-nightly.20251004",
-    "@aztec/blob-sink": "3.0.0-nightly.20251004",
-    "@aztec/constants": "3.0.0-nightly.20251004",
-    "@aztec/epoch-cache": "3.0.0-nightly.20251004",
-    "@aztec/ethereum": "3.0.0-nightly.20251004",
-    "@aztec/foundation": "3.0.0-nightly.20251004",
-    "@aztec/kv-store": "3.0.0-nightly.20251004",
-    "@aztec/merkle-tree": "3.0.0-nightly.20251004",
-    "@aztec/p2p": "3.0.0-nightly.20251004",
-    "@aztec/protocol-contracts": "3.0.0-nightly.20251004",
-    "@aztec/prover-client": "3.0.0-nightly.20251004",
-    "@aztec/sequencer-client": "3.0.0-nightly.20251004",
-    "@aztec/simulator": "3.0.0-nightly.20251004",
-    "@aztec/stdlib": "3.0.0-nightly.20251004",
-    "@aztec/telemetry-client": "3.0.0-nightly.20251004",
-    "@aztec/validator-client": "3.0.0-nightly.20251004",
-    "@aztec/world-state": "3.0.0-nightly.20251004",
+    "@aztec/archiver": "3.0.0-nightly.20251007",
+    "@aztec/bb-prover": "3.0.0-nightly.20251007",
+    "@aztec/blob-sink": "3.0.0-nightly.20251007",
+    "@aztec/constants": "3.0.0-nightly.20251007",
+    "@aztec/epoch-cache": "3.0.0-nightly.20251007",
+    "@aztec/ethereum": "3.0.0-nightly.20251007",
+    "@aztec/foundation": "3.0.0-nightly.20251007",
+    "@aztec/kv-store": "3.0.0-nightly.20251007",
+    "@aztec/merkle-tree": "3.0.0-nightly.20251007",
+    "@aztec/p2p": "3.0.0-nightly.20251007",
+    "@aztec/protocol-contracts": "3.0.0-nightly.20251007",
+    "@aztec/prover-client": "3.0.0-nightly.20251007",
+    "@aztec/sequencer-client": "3.0.0-nightly.20251007",
+    "@aztec/simulator": "3.0.0-nightly.20251007",
+    "@aztec/stdlib": "3.0.0-nightly.20251007",
+    "@aztec/telemetry-client": "3.0.0-nightly.20251007",
+    "@aztec/validator-client": "3.0.0-nightly.20251007",
+    "@aztec/world-state": "3.0.0-nightly.20251007",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
+    "@aztec/blob-lib": "3.0.0-nightly.20251007",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/factories/index.ts

@@ -0,0 +1 @@
+export * from './l1_tx_utils.js';

package/src/factories/l1_tx_utils.ts

@@ -0,0 +1,122 @@
+import {
+  createL1TxUtilsFromEthSigner as createL1TxUtilsFromEthSignerBase,
+  createL1TxUtilsFromViemWallet as createL1TxUtilsFromViemWalletBase,
+} from '@aztec/ethereum';
+import type { EthSigner, ExtendedViemWalletClient, L1TxUtilsConfig, ViemClient } from '@aztec/ethereum';
+import {
+  createL1TxUtilsWithBlobsFromEthSigner as createL1TxUtilsWithBlobsFromEthSignerBase,
+  createL1TxUtilsWithBlobsFromViemWallet as createL1TxUtilsWithBlobsFromViemWalletBase,
+} from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import { omit } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import type { TelemetryClient } from '@aztec/telemetry-client';
+
+import type { L1TxScope } from '../metrics/l1_tx_metrics.js';
+import { L1TxMetrics } from '../metrics/l1_tx_metrics.js';
+import { L1TxStore } from '../stores/l1_tx_store.js';
+
+const L1_TX_STORE_NAME = 'l1-tx-utils';
+
+/**
+ * Creates shared dependencies (logger, store, metrics) for L1TxUtils instances.
+ */
+async function createSharedDeps(
+  config: DataStoreConfig & { scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+  },
+) {
+  const logger = deps.logger ?? createLogger('l1-tx-utils');
+
+  // Note that we do NOT bind them to the rollup address, since we still need to
+  // monitor and cancel txs for previous rollups to free up our nonces.
+  const noRollupConfig = omit(config, 'l1Contracts');
+  const kvStore = await createStore(L1_TX_STORE_NAME, L1TxStore.SCHEMA_VERSION, noRollupConfig, logger);
+  const store = new L1TxStore(kvStore, logger);
+
+  const meter = deps.telemetry.getMeter('L1TxUtils');
+  const metrics = new L1TxMetrics(meter, config.scope ?? 'other', logger);
+
+  return { logger, store, metrics, dateProvider: deps.dateProvider };
+}
+
+/**
+ * Creates L1TxUtils with blobs from multiple Viem wallets, sharing store and metrics.
+ */
+export async function createL1TxUtilsWithBlobsFromViemWallet(
+  clients: ExtendedViemWalletClient[],
+  config: DataStoreConfig & Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean; scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+  },
+) {
+  const sharedDeps = await createSharedDeps(config, deps);
+
+  return clients.map(client =>
+    createL1TxUtilsWithBlobsFromViemWalletBase(client, sharedDeps, config, config.debugMaxGasLimit),
+  );
+}
+
+/**
+ * Creates L1TxUtils with blobs from multiple EthSigners, sharing store and metrics.
+ */
+export async function createL1TxUtilsWithBlobsFromEthSigner(
+  client: ViemClient,
+  signers: EthSigner[],
+  config: DataStoreConfig & Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean; scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+  },
+) {
+  const sharedDeps = await createSharedDeps(config, deps);
+
+  return signers.map(signer =>
+    createL1TxUtilsWithBlobsFromEthSignerBase(client, signer, sharedDeps, config, config.debugMaxGasLimit),
+  );
+}
+
+/**
+ * Creates L1TxUtils (without blobs) from multiple Viem wallets, sharing store and metrics.
+ */
+export async function createL1TxUtilsFromViemWalletWithStore(
+  clients: ExtendedViemWalletClient[],
+  config: DataStoreConfig & Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean; scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+    scope?: L1TxScope;
+  },
+) {
+  const sharedDeps = await createSharedDeps(config, deps);
+
+  return clients.map(client => createL1TxUtilsFromViemWalletBase(client, sharedDeps, config));
+}
+
+/**
+ * Creates L1TxUtils (without blobs) from multiple EthSigners, sharing store and metrics.
+ */
+export async function createL1TxUtilsFromEthSignerWithStore(
+  client: ViemClient,
+  signers: EthSigner[],
+  config: DataStoreConfig & Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean; scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+    scope?: L1TxScope;
+  },
+) {
+  const sharedDeps = await createSharedDeps(config, deps);
+
+  return signers.map(signer => createL1TxUtilsFromEthSignerBase(client, signer, sharedDeps, config));
+}

package/src/metrics/index.ts

@@ -0,0 +1 @@
+export * from './l1_tx_metrics.js';

package/src/metrics/l1_tx_metrics.ts

@@ -0,0 +1,169 @@
+import type { IL1TxMetrics, L1TxState } from '@aztec/ethereum';
+import { TxUtilsState } from '@aztec/ethereum';
+import { createLogger } from '@aztec/foundation/log';
+import {
+  Attributes,
+  type Histogram,
+  type Meter,
+  Metrics,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+export type L1TxScope = 'sequencer' | 'prover' | 'other';
+
+/**
+ * Metrics for L1 transaction utils tracking tx lifecycle and gas costs.
+ */
+export class L1TxMetrics implements IL1TxMetrics {
+  // Time until tx is mined
+  private txMinedDuration: Histogram;
+
+  // Number of attempts until mined
+  private txAttemptsUntilMined: Histogram;
+
+  // Counters for end states
+  private txMinedCount: UpDownCounter;
+  private txRevertedCount: UpDownCounter;
+  private txCancelledCount: UpDownCounter;
+  private txNotMinedCount: UpDownCounter;
+
+  // Gas price histograms (at end state, in wei)
+  private maxPriorityFeeHistogram: Histogram;
+  private maxFeeHistogram: Histogram;
+  private blobFeeHistogram: Histogram;
+
+  constructor(
+    private meter: Meter,
+    private scope: L1TxScope = 'other',
+    private logger = createLogger('l1-tx-utils:metrics'),
+  ) {
+    this.txMinedDuration = this.meter.createHistogram(Metrics.L1_TX_MINED_DURATION, {
+      description: 'Time from initial tx send until mined',
+      unit: 's',
+      valueType: ValueType.INT,
+    });
+
+    this.txAttemptsUntilMined = this.meter.createHistogram(Metrics.L1_TX_ATTEMPTS_UNTIL_MINED, {
+      description: 'Number of tx attempts (including speed-ups) until mined',
+      unit: 'attempts',
+      valueType: ValueType.INT,
+    });
+
+    this.txMinedCount = this.meter.createUpDownCounter(Metrics.L1_TX_MINED_COUNT, {
+      description: 'Count of transactions successfully mined',
+      valueType: ValueType.INT,
+    });
+
+    this.txRevertedCount = this.meter.createUpDownCounter(Metrics.L1_TX_REVERTED_COUNT, {
+      description: 'Count of transactions that reverted',
+      valueType: ValueType.INT,
+    });
+
+    this.txCancelledCount = this.meter.createUpDownCounter(Metrics.L1_TX_CANCELLED_COUNT, {
+      description: 'Count of transactions cancelled',
+      valueType: ValueType.INT,
+    });
+
+    this.txNotMinedCount = this.meter.createUpDownCounter(Metrics.L1_TX_NOT_MINED_COUNT, {
+      description: 'Count of transactions not mined (timed out)',
+      valueType: ValueType.INT,
+    });
+
+    this.maxPriorityFeeHistogram = this.meter.createHistogram(Metrics.L1_TX_MAX_PRIORITY_FEE, {
+      description: 'Max priority fee per gas at tx end state (in wei)',
+      unit: 'wei',
+      valueType: ValueType.INT,
+    });
+
+    this.maxFeeHistogram = this.meter.createHistogram(Metrics.L1_TX_MAX_FEE, {
+      description: 'Max fee per gas at tx end state (in wei)',
+      unit: 'wei',
+      valueType: ValueType.INT,
+    });
+
+    this.blobFeeHistogram = this.meter.createHistogram(Metrics.L1_TX_BLOB_FEE, {
+      description: 'Max fee per blob gas at tx end state (in wei)',
+      unit: 'wei',
+      valueType: ValueType.INT,
+    });
+  }
+
+  /**
+   * Records metrics when a transaction is mined.
+   * @param state - The L1 transaction state
+   * @param l1Timestamp - The current L1 timestamp
+   */
+  public recordMinedTx(state: L1TxState, l1Timestamp: Date): void {
+    if (state.status !== TxUtilsState.MINED) {
+      this.logger.warn(
+        `Attempted to record mined tx metrics for a tx not in MINED state (state: ${TxUtilsState[state.status]})`,
+        { scope: this.scope, nonce: state.nonce },
+      );
+      return;
+    }
+
+    const attributes = { [Attributes.L1_TX_SCOPE]: this.scope };
+    const isCancelTx = state.cancelTxHashes.length > 0;
+    const isReverted = state.receipt?.status === 'reverted';
+
+    if (isCancelTx) {
+      this.txCancelledCount.add(1, attributes);
+    } else if (isReverted) {
+      this.txRevertedCount.add(1, attributes);
+    } else {
+      this.txMinedCount.add(1, attributes);
+    }
+
+    // Record time to mine using provided L1 timestamp
+    const duration = Math.floor((l1Timestamp.getTime() - state.sentAtL1Ts.getTime()) / 1000);
+    this.txMinedDuration.record(duration, attributes);
+
+    // Record number of attempts until mined
+    const attempts = isCancelTx ? state.cancelTxHashes.length : state.txHashes.length;
+    this.txAttemptsUntilMined.record(attempts, attributes);
+
+    // Record gas prices at end state (in wei as integers)
+    const maxPriorityFeeWei = Number(state.gasPrice.maxPriorityFeePerGas);
+    const maxFeeWei = Number(state.gasPrice.maxFeePerGas);
+    const blobFeeWei = state.gasPrice.maxFeePerBlobGas ? Number(state.gasPrice.maxFeePerBlobGas) : undefined;
+
+    this.maxPriorityFeeHistogram.record(maxPriorityFeeWei, attributes);
+    this.maxFeeHistogram.record(maxFeeWei, attributes);
+
+    // Record blob fee if present (in wei as integer)
+    if (blobFeeWei !== undefined) {
+      this.blobFeeHistogram.record(blobFeeWei, attributes);
+    }
+
+    this.logger.debug(`Recorded tx end state metrics`, {
+      status: TxUtilsState[state.status],
+      nonce: state.nonce,
+      isCancelTx,
+      isReverted,
+      scope: this.scope,
+      maxPriorityFeeWei,
+      maxFeeWei,
+      blobFeeWei,
+    });
+  }
+
+  public recordDroppedTx(state: L1TxState): void {
+    if (state.status !== TxUtilsState.NOT_MINED) {
+      this.logger.warn(
+        `Attempted to record dropped tx metrics for a tx not in NOT_MINED state (state: ${TxUtilsState[state.status]})`,
+        { scope: this.scope, nonce: state.nonce },
+      );
+      return;
+    }
+
+    const attributes = { [Attributes.L1_TX_SCOPE]: this.scope };
+    this.txNotMinedCount.add(1, attributes);
+
+    this.logger.debug(`Recorded tx dropped metrics`, {
+      status: TxUtilsState[state.status],
+      nonce: state.nonce,
+      scope: this.scope,
+    });
+  }
+}

package/src/stores/index.ts

@@ -0,0 +1 @@
+export * from './l1_tx_store.js';