@aztec-labs/sequencer-client 6.0.0-nightly.20260829

package/dest/publisher/l1_tx_failed_store/file_store_failed_tx_store.d.ts

@@ -0,0 +1,15 @@
+import { type Logger } from '@aztec-labs/foundation/log';
+import type { FileStore } from '@aztec-labs/stdlib/file-store';
+import { type FailedL1Tx, type FailedL1TxUri, type L1TxFailedStore } from './failed_tx_store.js';
+/**
+ * L1TxFailedStore implementation using the FileStore abstraction.
+ * Supports any backend that FileStore supports (GCS, S3, R2, local filesystem).
+ */
+export declare class FileStoreL1TxFailedStore implements L1TxFailedStore {
+    private readonly fileStore;
+    private readonly log;
+    constructor(fileStore: FileStore, logger?: Logger);
+    saveFailedTx(tx: FailedL1Tx): Promise<FailedL1TxUri>;
+    getFailedTx(uri: FailedL1TxUri): Promise<FailedL1Tx>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZV9zdG9yZV9mYWlsZWRfdHhfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaXNoZXIvbDFfdHhfZmFpbGVkX3N0b3JlL2ZpbGVfc3RvcmVfZmFpbGVkX3R4X3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSw0QkFBNEIsQ0FBQztBQUN2RSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUUvRCxPQUFPLEVBQUUsS0FBSyxVQUFVLEVBQW9CLEtBQUssYUFBYSxFQUFFLEtBQUssZUFBZSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFbkg7OztHQUdHO0FBQ0gscUJBQWEsd0JBQXlCLFlBQVcsZUFBZTtJQUk1RCxPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFINUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQVM7SUFFN0IsWUFDbUIsU0FBUyxFQUFFLFNBQVMsRUFDckMsTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUdoQjtJQUVZLFlBQVksQ0FBQyxFQUFFLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxhQUFhLENBQUMsQ0FvQmhFO0lBRVksV0FBVyxDQUFDLEdBQUcsRUFBRSxhQUFhLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUdoRTtDQUNGIn0=

package/dest/publisher/l1_tx_failed_store/file_store_failed_tx_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file_store_failed_tx_store.d.ts","sourceRoot":"","sources":["../../../src/publisher/l1_tx_failed_store/file_store_failed_tx_store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,KAAK,UAAU,EAAoB,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEnH;;;GAGG;AACH,qBAAa,wBAAyB,YAAW,eAAe;IAI5D,OAAO,CAAC,QAAQ,CAAC,SAAS;IAH5B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YACmB,SAAS,EAAE,SAAS,EACrC,MAAM,CAAC,EAAE,MAAM,EAGhB;IAEY,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAoBhE;IAEY,WAAW,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,CAGhE;CACF"}

package/dest/publisher/l1_tx_failed_store/file_store_failed_tx_store.js

@@ -0,0 +1,36 @@
+import { jsonParseWithSchema, jsonStringify } from '@aztec-labs/foundation/json-rpc';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { FailedL1TxSchema } from './failed_tx_store.js';
+/**
+ * L1TxFailedStore implementation using the FileStore abstraction.
+ * Supports any backend that FileStore supports (GCS, S3, R2, local filesystem).
+ */ export class FileStoreL1TxFailedStore {
+    fileStore;
+    log;
+    constructor(fileStore, logger){
+        this.fileStore = fileStore;
+        this.log = logger ?? createLogger('sequencer:l1-tx-failed-store');
+    }
+    async saveFailedTx(tx) {
+        const prefix = tx.receipt ? 'tx' : 'data';
+        const path = `${tx.failureType}/${prefix}-${tx.id}.json`;
+        const json = jsonStringify(tx, true);
+        const uri = await this.fileStore.save(path, Buffer.from(json), {
+            metadata: {
+                'content-type': 'application/json',
+                actions: tx.context.actions.join(','),
+                'failure-type': tx.failureType
+            }
+        });
+        this.log.info(`Saved failed L1 tx to ${uri}`, {
+            id: tx.id,
+            failureType: tx.failureType,
+            actions: tx.context.actions.join(',')
+        });
+        return uri;
+    }
+    async getFailedTx(uri) {
+        const data = await this.fileStore.read(uri);
+        return jsonParseWithSchema(data.toString(), FailedL1TxSchema);
+    }
+}

package/dest/publisher/l1_tx_failed_store/index.d.ts

@@ -0,0 +1,4 @@
+export { type FailedL1Tx, FailedL1TxSchema, type FailedL1TxUri, type L1TxFailedStore } from './failed_tx_store.js';
+export { createL1TxFailedStore } from './factory.js';
+export { FileStoreL1TxFailedStore } from './file_store_failed_tx_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaXNoZXIvbDFfdHhfZmFpbGVkX3N0b3JlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLFVBQVUsRUFBRSxnQkFBZ0IsRUFBRSxLQUFLLGFBQWEsRUFBRSxLQUFLLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ25ILE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUNyRCxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQyJ9

package/dest/publisher/l1_tx_failed_store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/publisher/l1_tx_failed_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,gBAAgB,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACnH,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC"}

package/dest/publisher/l1_tx_failed_store/index.js

@@ -0,0 +1,3 @@
+export { FailedL1TxSchema } from './failed_tx_store.js';
+export { createL1TxFailedStore } from './factory.js';
+export { FileStoreL1TxFailedStore } from './file_store_failed_tx_store.js';

package/dest/publisher/sequencer-bundle-simulator.d.ts

@@ -0,0 +1,96 @@
+import type { EpochCache } from '@aztec-labs/epoch-cache';
+import { type RollupContract } from '@aztec-labs/ethereum/contracts';
+import { type L1TxUtils } from '@aztec-labs/ethereum/l1-tx-utils';
+import type { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { type Logger } from '@aztec-labs/foundation/log';
+import type { Hex } from 'viem';
+import type { RequestWithExpiry } from './sequencer-publisher.js';
+/** A request that was dropped by bundle simulation, with the decoded revert reason. */
+export type DroppedRequest = {
+    request: RequestWithExpiry;
+    revertReason: string | undefined;
+    returnData: Hex | undefined;
+};
+/**
+ * Result of {@link SequencerBundleSimulator.simulate}.
+ *
+ * - `success`: simulation succeeded. `requests` is the filtered survivor list, `gasLimit` is
+ *   the bumped gas limit derived from `gasUsed` (plus blob evaluation gas). `droppedRequests`
+ *   lists the entries that were observed to revert in simulation.
+ * - `fallback`: the node does not support eth_simulateV1 (or the simulate call threw). The
+ *   caller should send `requests` as-is with a safe gas limit (e.g. {@link MAX_L1_TX_LIMIT}).
+ *   `droppedRequests` carries any entries that the first pass already proved reverted, so the
+ *   caller does not re-include them when the second pass falls back.
+ * - `aborted`: the bundle cannot be sent. `droppedRequests` contains only entries that were
+ *   actually observed to revert (so they can be reported as simulation failures); it is empty
+ *   when the abort was caused by an empty input bundle.
+ */
+export type BundleSimulateResult = {
+    kind: 'success';
+    requests: RequestWithExpiry[];
+    gasLimit: bigint;
+    droppedRequests: DroppedRequest[];
+} | {
+    kind: 'fallback';
+    requests: RequestWithExpiry[];
+    droppedRequests: DroppedRequest[];
+} | {
+    kind: 'aborted';
+    reason: AbortReason;
+    droppedRequests: DroppedRequest[];
+};
+export type AbortReason = 'empty-bundle' | 'all-reverted' | 'second-pass-reverts';
+/**
+ * Bundle-level simulator for the aggregate3 payload that `SequencerPublisher` is about to send.
+ *
+ * Runs `eth_simulateV1` against `Multicall3.aggregate3`, drops entries that revert, and returns
+ * a gasLimit for the survivors. When `eth_simulateV1` is unavailable, signals fallback to the
+ * caller so it can send the bundle as-is with a conservative gas limit.
+ */
+export declare class SequencerBundleSimulator {
+    private readonly deps;
+    private readonly log;
+    constructor(deps: {
+        getL1TxUtils: () => L1TxUtils;
+        rollupContract: RollupContract;
+        epochCache: EpochCache;
+        log?: Logger;
+    });
+    /**
+     * Simulates the given bundle near the end of the target slot and filters out entries
+     * that revert.
+     *
+     * - If all entries pass on the first pass, returns `success` with the gasLimit.
+     * - If some entries revert, re-simulates the survivors. If the second pass is clean, returns
+     *   `success` with the survivors and dropped entries. If the second pass surfaces any revert,
+     *   returns `aborted` — we refuse to send a bundle whose composition still has internal
+     *   reverts after one round of filtering.
+     * - If eth_simulateV1 is unavailable, returns `fallback`. The caller is expected to send the
+     *   bundle as-is with a safe gas limit.
+     *
+     * The simulation `block.timestamp` is the last L1 slot timestamp inside the target L2 slot.
+     * This still maps to the target L2 slot for propose's `validateHeader` and EIP-712 signature
+     * checks, while avoiding eth_simulateV1 rejecting a child block whose timestamp is not strictly
+     * greater than the current L1 head.
+     *
+     * Known limitation: on networks where L1 is mining behind cadence (missed L1 slots, anvil with
+     * overridden timestamps), the actual `block.timestamp` at send time can land in the prior L2
+     * slot. In that case `propose` would revert silently inside the multicall. The simulator does
+     * not detect this case because it simulates inside the target slot — the prior implementation
+     * used `min(predictedNextL1Ts, targetTimestamp)` to surface this failure mode at simulate time.
+     */
+    simulate(validRequests: RequestWithExpiry[], targetSlot: SlotNumber): Promise<BundleSimulateResult>;
+    private buildSuccessResult;
+    /**
+     * `gasLimit = bumpGasLimit(ceil(gasUsed * 64 / 63))`, plus blob evaluation gas if a propose
+     * survived, capped at the L1 block gas limit.
+     */
+    private computeGasLimit;
+    /**
+     * eth_simulateV1 cannot carry blob sidecar data, so disable the rollup's on-chain blob check
+     * when a propose is in the bundle.
+     */
+    private buildStateOverrides;
+    private simulateAndDecode;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/publisher/sequencer-bundle-simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencer-bundle-simulator.d.ts","sourceRoot":"","sources":["../../src/publisher/sequencer-bundle-simulator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAc,KAAK,cAAc,EAAyC,MAAM,gCAAgC,CAAC;AACxH,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,kCAAkC,CAAC;AAEnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,4BAA4B,CAAC;AAEvE,OAAO,KAAK,EAAE,GAAG,EAAiB,MAAM,MAAM,CAAC;AAE/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,uFAAuF;AACvF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,UAAU,EAAE,GAAG,GAAG,SAAS,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,cAAc,EAAE,CAAA;CAAE,GACvG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAAC,eAAe,EAAE,cAAc,EAAE,CAAA;CAAE,GACtF;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,eAAe,EAAE,cAAc,EAAE,CAAA;CAAE,CAAC;AAEhF,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,cAAc,GAAG,qBAAqB,CAAC;AAMlF;;;;;;GAMG;AACH,qBAAa,wBAAwB;IAIjC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHvB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YACmB,IAAI,EAAE;QACrB,YAAY,EAAE,MAAM,SAAS,CAAC;QAC9B,cAAc,EAAE,cAAc,CAAC;QAC/B,UAAU,EAAE,UAAU,CAAC;QACvB,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,EAGF;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACU,QAAQ,CAAC,aAAa,EAAE,iBAAiB,EAAE,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA6E/G;IAED,OAAO,CAAC,kBAAkB;IAmB1B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAMvB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;YAOb,iBAAiB;CA8ChC"}

package/dest/publisher/sequencer-bundle-simulator.js

@@ -0,0 +1,198 @@
+import { Multicall3, buildSimulationOverridesStateOverride } from '@aztec-labs/ethereum/contracts';
+import { MAX_L1_TX_LIMIT } from '@aztec-labs/ethereum/l1-tx-utils';
+import { formatViemError } from '@aztec-labs/ethereum/utils';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { getLastL1SlotTimestampForL2Slot } from '@aztec-labs/stdlib/epoch-helpers';
+/**
+ * Bundle-level simulator for the aggregate3 payload that `SequencerPublisher` is about to send.
+ *
+ * Runs `eth_simulateV1` against `Multicall3.aggregate3`, drops entries that revert, and returns
+ * a gasLimit for the survivors. When `eth_simulateV1` is unavailable, signals fallback to the
+ * caller so it can send the bundle as-is with a conservative gas limit.
+ */ export class SequencerBundleSimulator {
+    deps;
+    log;
+    constructor(deps){
+        this.deps = deps;
+        this.log = deps.log ?? createLogger('sequencer:publisher:bundle-simulator');
+    }
+    /**
+   * Simulates the given bundle near the end of the target slot and filters out entries
+   * that revert.
+   *
+   * - If all entries pass on the first pass, returns `success` with the gasLimit.
+   * - If some entries revert, re-simulates the survivors. If the second pass is clean, returns
+   *   `success` with the survivors and dropped entries. If the second pass surfaces any revert,
+   *   returns `aborted` — we refuse to send a bundle whose composition still has internal
+   *   reverts after one round of filtering.
+   * - If eth_simulateV1 is unavailable, returns `fallback`. The caller is expected to send the
+   *   bundle as-is with a safe gas limit.
+   *
+   * The simulation `block.timestamp` is the last L1 slot timestamp inside the target L2 slot.
+   * This still maps to the target L2 slot for propose's `validateHeader` and EIP-712 signature
+   * checks, while avoiding eth_simulateV1 rejecting a child block whose timestamp is not strictly
+   * greater than the current L1 head.
+   *
+   * Known limitation: on networks where L1 is mining behind cadence (missed L1 slots, anvil with
+   * overridden timestamps), the actual `block.timestamp` at send time can land in the prior L2
+   * slot. In that case `propose` would revert silently inside the multicall. The simulator does
+   * not detect this case because it simulates inside the target slot — the prior implementation
+   * used `min(predictedNextL1Ts, targetTimestamp)` to surface this failure mode at simulate time.
+   */ async simulate(validRequests, targetSlot) {
+        if (validRequests.length === 0) {
+            return {
+                kind: 'aborted',
+                reason: 'empty-bundle',
+                droppedRequests: []
+            };
+        }
+        // Pin the publisher we'll use across the whole simulate call so that the publisher's rotation
+        // can't change l1TxUtils mid-flight.
+        const l1TxUtils = this.deps.getL1TxUtils();
+        const proposeRequest = validRequests.find((r)=>r.action === 'propose');
+        const simulateTimestamp = getLastL1SlotTimestampForL2Slot(targetSlot, this.deps.epochCache.getL1Constants());
+        const firstPassOverrides = await this.buildStateOverrides(!!proposeRequest);
+        const firstPass = await this.simulateAndDecode(l1TxUtils, validRequests, simulateTimestamp, firstPassOverrides);
+        if (firstPass.kind === 'fallback') {
+            this.log.warn('Bundle simulate fallback (eth_simulateV1 unavailable); caller will send bundle as-is', {
+                actions: validRequests.map((r)=>r.action)
+            });
+            return {
+                kind: 'fallback',
+                requests: validRequests,
+                droppedRequests: []
+            };
+        }
+        if (firstPass.survivors.length === 0) {
+            this.log.warn('All bundle entries dropped in simulation; aborting send', {
+                actions: validRequests.map((r)=>r.action)
+            });
+            return {
+                kind: 'aborted',
+                reason: 'all-reverted',
+                droppedRequests: firstPass.droppedRequests
+            };
+        }
+        if (firstPass.droppedRequests.length === 0) {
+            return this.buildSuccessResult(l1TxUtils, firstPass.survivors, [], firstPass.gasUsed, proposeRequest);
+        }
+        this.log.warn('Some bundle entries reverted; re-simulating reduced bundle', {
+            droppedActions: firstPass.droppedRequests.map((d)=>d.request.action),
+            remainingActions: firstPass.survivors.map((r)=>r.action)
+        });
+        // Rebuild overrides for the reduced bundle: if propose was dropped, we no longer need the blob-check override
+        const proposeSurvived = proposeRequest !== undefined && firstPass.survivors.includes(proposeRequest);
+        const secondPassOverrides = proposeSurvived ? firstPassOverrides : await this.buildStateOverrides(false);
+        const secondPass = await this.simulateAndDecode(l1TxUtils, firstPass.survivors, simulateTimestamp, secondPassOverrides);
+        if (secondPass.kind === 'fallback') {
+            this.log.warn('Bundle simulate errored on second pass (eth_simulateV1 unavailable); sending first-pass survivors as-is', {
+                actions: firstPass.survivors.map((r)=>r.action),
+                droppedActions: firstPass.droppedRequests.map((d)=>d.request.action)
+            });
+            return {
+                kind: 'fallback',
+                requests: firstPass.survivors,
+                droppedRequests: firstPass.droppedRequests
+            };
+        }
+        // We refuse to chase reverts through repeated trimming: anything other than a clean second pass aborts the whole send
+        if (secondPass.droppedRequests.length > 0) {
+            this.log.error('Re-simulate surfaced reverts; aborting send', {
+                secondPassDroppedActions: secondPass.droppedRequests.map((d)=>d.request.action)
+            });
+            return {
+                kind: 'aborted',
+                reason: 'second-pass-reverts',
+                droppedRequests: [
+                    ...firstPass.droppedRequests,
+                    ...secondPass.droppedRequests
+                ]
+            };
+        }
+        return this.buildSuccessResult(l1TxUtils, secondPass.survivors, firstPass.droppedRequests, secondPass.gasUsed, proposeRequest);
+    }
+    buildSuccessResult(l1TxUtils, survivors, droppedRequests, bundleGasUsed, proposeRequest) {
+        const proposeSurvived = proposeRequest !== undefined && survivors.includes(proposeRequest);
+        const blobEvaluationGas = proposeSurvived ? proposeRequest?.blobEvaluationGas ?? 0n : 0n;
+        const gasLimit = this.computeGasLimit(l1TxUtils, bundleGasUsed, blobEvaluationGas);
+        this.log.debug('Bundle simulate complete', {
+            survivingRequests: survivors.length,
+            bundleGasUsed,
+            gasLimit,
+            actions: survivors.map((r)=>r.action)
+        });
+        return {
+            kind: 'success',
+            requests: survivors,
+            gasLimit,
+            droppedRequests
+        };
+    }
+    /**
+   * `gasLimit = bumpGasLimit(ceil(gasUsed * 64 / 63))`, plus blob evaluation gas if a propose
+   * survived, capped at the L1 block gas limit.
+   */ computeGasLimit(l1TxUtils, bundleGasUsed, blobEvaluationGas) {
+        const gasUsedWithEip150 = (bundleGasUsed * 64n + 62n) / 63n;
+        const gasLimit = l1TxUtils.bumpGasLimit(gasUsedWithEip150) + blobEvaluationGas;
+        return gasLimit > MAX_L1_TX_LIMIT ? MAX_L1_TX_LIMIT : gasLimit;
+    }
+    /**
+   * eth_simulateV1 cannot carry blob sidecar data, so disable the rollup's on-chain blob check
+   * when a propose is in the bundle.
+   */ buildStateOverrides(hasProposeAction) {
+        return buildSimulationOverridesStateOverride(this.deps.rollupContract, hasProposeAction ? {
+            disableBlobCheck: true
+        } : undefined);
+    }
+    async simulateAndDecode(l1TxUtils, requests, simulateTimestamp, stateOverrides) {
+        let simResult;
+        try {
+            simResult = await Multicall3.simulateAggregate3(requests.map((r)=>({
+                    to: r.request.to,
+                    data: r.request.data,
+                    abi: r.request.abi
+                })), l1TxUtils, {
+                blockOverrides: {
+                    time: simulateTimestamp,
+                    gasLimit: MAX_L1_TX_LIMIT * 2n
+                },
+                stateOverrides,
+                gas: MAX_L1_TX_LIMIT,
+                fallbackGasEstimate: MAX_L1_TX_LIMIT
+            });
+        } catch (err) {
+            this.log.warn('Bundle simulate threw; treating as fallback', {
+                err: formatViemError(err),
+                actions: requests.map((r)=>r.action)
+            });
+            return {
+                kind: 'fallback'
+            };
+        }
+        if (simResult.kind === 'fallback') {
+            return {
+                kind: 'fallback'
+            };
+        }
+        const survivors = [];
+        const droppedRequests = [];
+        for(let i = 0; i < requests.length; i++){
+            const entry = simResult.entries[i];
+            if (entry.success) {
+                survivors.push(requests[i]);
+                continue;
+            }
+            droppedRequests.push({
+                request: requests[i],
+                revertReason: entry.revertReason,
+                returnData: entry.returnData
+            });
+        }
+        return {
+            kind: 'decoded',
+            survivors,
+            droppedRequests,
+            gasUsed: simResult.gasUsed
+        };
+    }
+}

package/dest/publisher/sequencer-publisher-factory.d.ts

@@ -0,0 +1,50 @@
+import type { BlobClientInterface } from '@aztec-labs/blob-client/client';
+import type { EpochCache } from '@aztec-labs/epoch-cache';
+import type { GovernanceProposerContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import type { L1TxUtils } from '@aztec-labs/ethereum/l1-tx-utils';
+import type { PublisherManager } from '@aztec-labs/ethereum/publisher-manager';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type Logger } from '@aztec-labs/foundation/log';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import type { TelemetryClient } from '@aztec-labs/telemetry-client';
+import { NodeKeystoreAdapter } from '@aztec-labs/validator-client';
+import type { SequencerClientConfig } from '../config.js';
+import { SequencerPublisher } from './sequencer-publisher.js';
+export type AttestorPublisherPair = {
+    attestorAddress: EthAddress;
+    publisher: SequencerPublisher;
+};
+export declare class SequencerPublisherFactory {
+    private sequencerConfig;
+    private deps;
+    private publisherMetrics;
+    /** Stores the last slot in which every action was carried out by a publisher */
+    private lastActions;
+    private nodeKeyStore;
+    private logger;
+    constructor(sequencerConfig: SequencerClientConfig, deps: {
+        telemetry: TelemetryClient;
+        publisherManager: PublisherManager<L1TxUtils>;
+        blobClient: BlobClientInterface;
+        dateProvider: DateProvider;
+        epochCache: EpochCache;
+        rollupContract: RollupContract;
+        governanceProposerContract: GovernanceProposerContract;
+        nodeKeyStore: NodeKeystoreAdapter;
+        logger?: Logger;
+    });
+    /**
+     * Updates the node keystore adapter used for publisher lookups.
+     * Called when the keystore is reloaded at runtime to reflect new validator-publisher mappings.
+     */
+    updateNodeKeyStore(adapter: NodeKeystoreAdapter): void;
+    /**
+     * Creates a new SequencerPublisher instance.
+     * @param _validatorAddress - The address of the validator that will be using the publisher.
+     * @returns A new SequencerPublisher instance.
+     */
+    create(validatorAddress?: EthAddress): Promise<AttestorPublisherPair>;
+    /** Stops all publishers managed by this factory. Used during sequencer shutdown. */
+    stopAll(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VxdWVuY2VyLXB1Ymxpc2hlci1mYWN0b3J5LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHVibGlzaGVyL3NlcXVlbmNlci1wdWJsaXNoZXItZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzFFLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzFELE9BQU8sS0FBSyxFQUFFLDBCQUEwQixFQUFFLGNBQWMsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ2pHLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ2xFLE9BQU8sS0FBSyxFQUFtQixnQkFBZ0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBRWhHLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNoRSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sNEJBQTRCLENBQUM7QUFDdkUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDcEUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFbkUsT0FBTyxLQUFLLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFMUQsT0FBTyxFQUFlLGtCQUFrQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFM0UsTUFBTSxNQUFNLHFCQUFxQixHQUFHO0lBQ2xDLGVBQWUsRUFBRSxVQUFVLENBQUM7SUFDNUIsU0FBUyxFQUFFLGtCQUFrQixDQUFDO0NBQy9CLENBQUM7QUFFRixxQkFBYSx5QkFBeUI7SUFXbEMsT0FBTyxDQUFDLGVBQWU7SUFDdkIsT0FBTyxDQUFDLElBQUk7SUFYZCxPQUFPLENBQUMsZ0JBQWdCLENBQTRCO0lBRXBELGdGQUFnRjtJQUNoRixPQUFPLENBQUMsV0FBVyxDQUEyQztJQUU5RCxPQUFPLENBQUMsWUFBWSxDQUFzQjtJQUUxQyxPQUFPLENBQUMsTUFBTSxDQUFTO0lBRXZCLFlBQ1UsZUFBZSxFQUFFLHFCQUFxQixFQUN0QyxJQUFJLEVBQUU7UUFDWixTQUFTLEVBQUUsZUFBZSxDQUFDO1FBQzNCLGdCQUFnQixFQUFFLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQzlDLFVBQVUsRUFBRSxtQkFBbUIsQ0FBQztRQUNoQyxZQUFZLEVBQUUsWUFBWSxDQUFDO1FBQzNCLFVBQVUsRUFBRSxVQUFVLENBQUM7UUFDdkIsY0FBYyxFQUFFLGNBQWMsQ0FBQztRQUMvQiwwQkFBMEIsRUFBRSwwQkFBMEIsQ0FBQztRQUN2RCxZQUFZLEVBQUUsbUJBQW1CLENBQUM7UUFDbEMsTUFBTSxDQUFDLEVBQUUsTUFBTSxDQUFDO0tBQ2pCLEVBS0Y7SUFFRDs7O09BR0c7SUFDSSxrQkFBa0IsQ0FBQyxPQUFPLEVBQUUsbUJBQW1CLEdBQUcsSUFBSSxDQUU1RDtJQUVEOzs7O09BSUc7SUFDVSxNQUFNLENBQUMsZ0JBQWdCLENBQUMsRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUFDLHFCQUFxQixDQUFDLENBbURqRjtJQUVELG9GQUFvRjtJQUN2RSxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUVwQztDQUNGIn0=

package/dest/publisher/sequencer-publisher-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencer-publisher-factory.d.ts","sourceRoot":"","sources":["../../src/publisher/sequencer-publisher-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,0BAA0B,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACjG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAEhG,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAEnE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,EAAe,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE3E,MAAM,MAAM,qBAAqB,GAAG;IAClC,eAAe,EAAE,UAAU,CAAC;IAC5B,SAAS,EAAE,kBAAkB,CAAC;CAC/B,CAAC;AAEF,qBAAa,yBAAyB;IAWlC,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,IAAI;IAXd,OAAO,CAAC,gBAAgB,CAA4B;IAEpD,gFAAgF;IAChF,OAAO,CAAC,WAAW,CAA2C;IAE9D,OAAO,CAAC,YAAY,CAAsB;IAE1C,OAAO,CAAC,MAAM,CAAS;IAEvB,YACU,eAAe,EAAE,qBAAqB,EACtC,IAAI,EAAE;QACZ,SAAS,EAAE,eAAe,CAAC;QAC3B,gBAAgB,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;QAC9C,UAAU,EAAE,mBAAmB,CAAC;QAChC,YAAY,EAAE,YAAY,CAAC;QAC3B,UAAU,EAAE,UAAU,CAAC;QACvB,cAAc,EAAE,cAAc,CAAC;QAC/B,0BAA0B,EAAE,0BAA0B,CAAC;QACvD,YAAY,EAAE,mBAAmB,CAAC;QAClC,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,EAKF;IAED;;;OAGG;IACI,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAE5D;IAED;;;;OAIG;IACU,MAAM,CAAC,gBAAgB,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAmDjF;IAED,oFAAoF;IACvE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpC;CACF"}

package/dest/publisher/sequencer-publisher-factory.js

@@ -0,0 +1,75 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
+import { SequencerPublisher } from './sequencer-publisher.js';
+export class SequencerPublisherFactory {
+    sequencerConfig;
+    deps;
+    publisherMetrics;
+    /** Stores the last slot in which every action was carried out by a publisher */ lastActions;
+    nodeKeyStore;
+    logger;
+    constructor(sequencerConfig, deps){
+        this.sequencerConfig = sequencerConfig;
+        this.deps = deps;
+        this.lastActions = {};
+        this.publisherMetrics = new SequencerPublisherMetrics(deps.telemetry, 'SequencerPublisher');
+        this.logger = deps.logger ?? createLogger('sequencer');
+        this.nodeKeyStore = this.deps.nodeKeyStore;
+    }
+    /**
+   * Updates the node keystore adapter used for publisher lookups.
+   * Called when the keystore is reloaded at runtime to reflect new validator-publisher mappings.
+   */ updateNodeKeyStore(adapter) {
+        this.nodeKeyStore = adapter;
+    }
+    /**
+   * Creates a new SequencerPublisher instance.
+   * @param _validatorAddress - The address of the validator that will be using the publisher.
+   * @returns A new SequencerPublisher instance.
+   */ async create(validatorAddress) {
+        // If we have been given an attestor address we must only allow publishers permitted for that attestor
+        const allowedPublishers = !validatorAddress ? [] : this.nodeKeyStore.getPublisherAddresses(validatorAddress);
+        const filter = !validatorAddress ? ()=>true : (utils)=>{
+            const publisherAddress = utils.getSenderAddress();
+            return allowedPublishers.some((allowedPublisher)=>allowedPublisher.equals(publisherAddress));
+        };
+        const l1Publisher = await this.deps.publisherManager.getAvailablePublisher(filter);
+        const attestorAddress = validatorAddress ?? this.nodeKeyStore.getAttestorForPublisher(l1Publisher.getSenderAddress());
+        const rollup = this.deps.rollupContract;
+        const slashingProposerContract = await rollup.getSlashingProposer();
+        const getNextPublisher = async (excludeAddresses)=>{
+            const exclusionFilter = (utils)=>{
+                if (excludeAddresses.some((addr)=>addr.equals(utils.getSenderAddress()))) {
+                    return false;
+                }
+                return filter(utils);
+            };
+            try {
+                return await this.deps.publisherManager.getAvailablePublisher(exclusionFilter);
+            } catch  {
+                return undefined;
+            }
+        };
+        const publisher = new SequencerPublisher(this.sequencerConfig, {
+            l1TxUtils: l1Publisher,
+            getNextPublisher,
+            telemetry: this.deps.telemetry,
+            blobClient: this.deps.blobClient,
+            rollupContract: this.deps.rollupContract,
+            epochCache: this.deps.epochCache,
+            governanceProposerContract: this.deps.governanceProposerContract,
+            slashingProposerContract,
+            dateProvider: this.deps.dateProvider,
+            metrics: this.publisherMetrics,
+            lastActions: this.lastActions,
+            log: this.logger.createChild('publisher')
+        });
+        return {
+            attestorAddress,
+            publisher
+        };
+    }
+    /** Stops all publishers managed by this factory. Used during sequencer shutdown. */ async stopAll() {
+        await this.deps.publisherManager.stop();
+    }
+}

package/dest/publisher/sequencer-publisher-metrics.d.ts

@@ -0,0 +1,26 @@
+import type { L1PublishCheckpointStats } from '@aztec-labs/stdlib/stats';
+import { type TelemetryClient } from '@aztec-labs/telemetry-client';
+export type L1TxType = 'process';
+export declare class SequencerPublisherMetrics {
+    private logger;
+    private gasPrice;
+    private txCount;
+    private txDuration;
+    private txGas;
+    private txCalldataSize;
+    private txCalldataGas;
+    private txBlobDataGasUsed;
+    private txBlobDataGasCost;
+    private txTotalFee;
+    private readonly blobCountHistogram;
+    private readonly blobInclusionBlocksHistogram;
+    private readonly blobTxSuccessCounter;
+    private readonly blobTxFailureCounter;
+    private senderBalance;
+    constructor(client: TelemetryClient, name?: string, logger?: import("@aztec-labs/foundation/log").Logger);
+    recordFailedTx(txType: L1TxType): void;
+    recordProcessBlockTx(durationMs: number, stats: L1PublishCheckpointStats): void;
+    recordSenderBalance(wei: bigint, senderAddress: string): void;
+    private recordTx;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VxdWVuY2VyLXB1Ymxpc2hlci1tZXRyaWNzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHVibGlzaGVyL3NlcXVlbmNlci1wdWJsaXNoZXItbWV0cmljcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSx3QkFBd0IsRUFBa0IsTUFBTSwwQkFBMEIsQ0FBQztBQUN6RixPQUFPLEVBS0wsS0FBSyxlQUFlLEVBR3JCLE1BQU0sOEJBQThCLENBQUM7QUFHdEMsTUFBTSxNQUFNLFFBQVEsR0FBRyxTQUFTLENBQUM7QUFFakMscUJBQWEseUJBQXlCO0lBc0JsQyxPQUFPLENBQUMsTUFBTTtJQXJCaEIsT0FBTyxDQUFDLFFBQVEsQ0FBWTtJQUU1QixPQUFPLENBQUMsT0FBTyxDQUFnQjtJQUMvQixPQUFPLENBQUMsVUFBVSxDQUFZO0lBQzlCLE9BQU8sQ0FBQyxLQUFLLENBQVk7SUFDekIsT0FBTyxDQUFDLGNBQWMsQ0FBWTtJQUNsQyxPQUFPLENBQUMsYUFBYSxDQUFZO0lBQ2pDLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBWTtJQUNyQyxPQUFPLENBQUMsaUJBQWlCLENBQVk7SUFDckMsT0FBTyxDQUFDLFVBQVUsQ0FBWTtJQUU5QixPQUFPLENBQUMsUUFBUSxDQUFDLGtCQUFrQixDQUFZO0lBQy9DLE9BQU8sQ0FBQyxRQUFRLENBQUMsNEJBQTRCLENBQVk7SUFDekQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxvQkFBb0IsQ0FBZ0I7SUFDckQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxvQkFBb0IsQ0FBZ0I7SUFFckQsT0FBTyxDQUFDLGFBQWEsQ0FBUTtJQUU3QixZQUNFLE1BQU0sRUFBRSxlQUFlLEVBQ3ZCLElBQUksU0FBdUIsRUFDbkIsTUFBTSw4Q0FBOEMsRUFrQzdEO0lBRUQsY0FBYyxDQUFDLE1BQU0sRUFBRSxRQUFRLFFBUzlCO0lBRUQsb0JBQW9CLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsd0JBQXdCLFFBWXZFO0lBRUQsbUJBQW1CLENBQUMsR0FBRyxFQUFFLE1BQU0sRUFBRSxhQUFhLEVBQUUsTUFBTSxRQUtyRDtJQUVELE9BQU8sQ0FBQyxRQUFRO0NBdUNqQiJ9

package/dest/publisher/sequencer-publisher-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencer-publisher-metrics.d.ts","sourceRoot":"","sources":["../../src/publisher/sequencer-publisher-metrics.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAkB,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAKL,KAAK,eAAe,EAGrB,MAAM,8BAA8B,CAAC;AAGtC,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC;AAEjC,qBAAa,yBAAyB;IAsBlC,OAAO,CAAC,MAAM;IArBhB,OAAO,CAAC,QAAQ,CAAY;IAE5B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,KAAK,CAAY;IACzB,OAAO,CAAC,cAAc,CAAY;IAClC,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,UAAU,CAAY;IAE9B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAY;IAC/C,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAAY;IACzD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAgB;IACrD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAgB;IAErD,OAAO,CAAC,aAAa,CAAQ;IAE7B,YACE,MAAM,EAAE,eAAe,EACvB,IAAI,SAAuB,EACnB,MAAM,8CAA8C,EAkC7D;IAED,cAAc,CAAC,MAAM,EAAE,QAAQ,QAS9B;IAED,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,wBAAwB,QAYvE;IAED,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,QAKrD;IAED,OAAO,CAAC,QAAQ;CAuCjB"}

package/dest/publisher/sequencer-publisher-metrics.js

@@ -0,0 +1,101 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec-labs/telemetry-client';
+import { formatEther } from 'viem/utils';
+export class SequencerPublisherMetrics {
+    logger;
+    gasPrice;
+    txCount;
+    txDuration;
+    txGas;
+    txCalldataSize;
+    txCalldataGas;
+    txBlobDataGasUsed;
+    txBlobDataGasCost;
+    txTotalFee;
+    blobCountHistogram;
+    blobInclusionBlocksHistogram;
+    blobTxSuccessCounter;
+    blobTxFailureCounter;
+    senderBalance;
+    constructor(client, name = 'SequencerPublisher', logger = createLogger('sequencer:publisher:metrics')){
+        this.logger = logger;
+        const meter = client.getMeter(name);
+        this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE);
+        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);
+        this.txGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_GAS);
+        this.txCalldataSize = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_SIZE);
+        this.txCalldataGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_GAS);
+        this.txBlobDataGasUsed = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_USED);
+        this.txBlobDataGasCost = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_COST);
+        this.blobCountHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_COUNT);
+        this.blobInclusionBlocksHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_INCLUSION_BLOCKS);
+        this.blobTxSuccessCounter = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_BLOB_TX_SUCCESS);
+        this.blobTxFailureCounter = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_BLOB_TX_FAILURE);
+        this.txTotalFee = meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE);
+        this.senderBalance = meter.createGauge(Metrics.L1_PUBLISHER_BALANCE);
+    }
+    recordFailedTx(txType) {
+        this.txCount.add(1, {
+            [Attributes.L1_TX_TYPE]: txType,
+            [Attributes.OK]: false
+        });
+        if (txType === 'process') {
+            this.blobTxFailureCounter.add(1);
+        }
+    }
+    recordProcessBlockTx(durationMs, stats) {
+        this.recordTx('process', durationMs, stats);
+        if (stats.blobCount && stats.blobCount > 0) {
+            this.blobCountHistogram.record(stats.blobCount);
+            if (stats.inclusionBlocks !== undefined) {
+                this.blobInclusionBlocksHistogram.record(stats.inclusionBlocks);
+            }
+            this.blobTxSuccessCounter.add(1);
+        }
+    }
+    recordSenderBalance(wei, senderAddress) {
+        const eth = parseFloat(formatEther(wei, 'wei'));
+        this.senderBalance.record(eth, {
+            [Attributes.SENDER_ADDRESS]: senderAddress
+        });
+    }
+    recordTx(txType, durationMs, stats) {
+        const attributes = {
+            [Attributes.L1_TX_TYPE]: txType,
+            [Attributes.L1_SENDER]: stats.sender
+        };
+        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);
+        this.txBlobDataGasCost.record(Number(stats.blobDataGas), attributes);
+        this.txBlobDataGasUsed.record(Number(stats.blobGasUsed), attributes);
+        try {
+            this.gasPrice.record(parseInt(formatEther(stats.gasPrice, 'gwei'), 10));
+        } catch  {
+        // ignore
+        }
+        const executionFee = stats.gasUsed * stats.gasPrice;
+        const blobFee = stats.blobGasUsed * stats.blobDataGas;
+        const totalFee = executionFee + blobFee;
+        try {
+            this.txTotalFee.record(parseFloat(formatEther(totalFee)));
+        } catch  {
+        // ignore
+        }
+    }
+}