@aztec/ethereum 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/dest/l1_tx_utils/tx_delayer.d.ts

@@ -0,0 +1,58 @@
+import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
+import { type Client, type Hex } from 'viem';
+import type { ViemClient } from '../types.js';
+export declare function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: Logger, timeout?: number): Promise<boolean>;
+export declare function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: number | bigint, logger?: Logger, timeout?: number): Promise<boolean>;
+/** Manages tx delaying for testing, intercepting sendRawTransaction calls to delay or cancel them. */
+export declare class Delayer {
+    dateProvider: DateProvider;
+    private logger;
+    maxInclusionTimeIntoSlot: number | undefined;
+    ethereumSlotDuration: bigint;
+    nextWait: {
+        l1Timestamp: bigint;
+        timeoutSeconds?: number;
+    } | {
+        l1BlockNumber: bigint;
+        timeoutSeconds?: number;
+    } | {
+        indefinitely: true;
+    } | undefined;
+    sentTxHashes: Hex[];
+    cancelledTxs: Hex[];
+    constructor(dateProvider: DateProvider, opts: {
+        ethereumSlotDuration: bigint | number;
+    }, bindings: LoggerBindings);
+    /** Returns the logger instance used by this delayer. */
+    getLogger(): Logger;
+    /** Returns the hashes of all effectively sent txs. */
+    getSentTxHashes(): `0x${string}`[];
+    /** Returns the raw hex for all cancelled txs. */
+    getCancelledTxs(): Hex[];
+    /** Delays the next tx to be sent so it lands on the given L1 block number. */
+    pauseNextTxUntilBlock(l1BlockNumber: number | bigint, timeoutSeconds?: number): void;
+    /** Delays the next tx to be sent so it lands on the given timestamp. */
+    pauseNextTxUntilTimestamp(l1Timestamp: number | bigint, timeoutSeconds?: number): void;
+    /** Delays the next tx to be sent indefinitely. */
+    cancelNextTx(): void;
+    /**
+     * Sets max inclusion time into slot. If more than this many seconds have passed
+     * since the last L1 block was mined, then any tx will not be mined in the current
+     * L1 slot but will be deferred for the next one.
+     */
+    setMaxInclusionTimeIntoSlot(seconds: number | undefined): void;
+}
+/**
+ * Creates a new Delayer instance. Exposed so callers can create a single shared delayer
+ * and pass it to multiple `wrapClientWithDelayer` calls.
+ */
+export declare function createDelayer(dateProvider: DateProvider, opts: {
+    ethereumSlotDuration: bigint | number;
+}, bindings: LoggerBindings): Delayer;
+/**
+ * Wraps a viem client with tx delaying logic. Returns the wrapped client.
+ * The delayer intercepts sendRawTransaction calls and delays them based on the delayer's state.
+ */
+export declare function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer: Delayer): T;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/l1_tx_utils/tx_delayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_delayer.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/tx_delayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,EACL,KAAK,MAAM,EACX,KAAK,GAAG,EAUT,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAA4B,UAAU,EAAE,MAAM,aAAa,CAAC;AAIxE,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC7C,MAAM,EAAE,CAAC,EACT,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,oBAiBjB;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EACnD,MAAM,EAAE,CAAC,EACT,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,oBAwBjB;AAED,sGAAsG;AACtG,qBAAa,OAAO;IAcT,YAAY,EAAE,YAAY;IAbnC,OAAO,CAAC,MAAM,CAAS;IAEhB,wBAAwB,EAAE,MAAM,GAAG,SAAS,CAAa;IACzD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,QAAQ,EACX;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAChD;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAClD;QAAE,YAAY,EAAE,IAAI,CAAA;KAAE,GACtB,SAAS,CAAa;IACnB,YAAY,EAAE,GAAG,EAAE,CAAM;IACzB,YAAY,EAAE,GAAG,EAAE,CAAM;IAEhC,YACS,YAAY,EAAE,YAAY,EACjC,IAAI,EAAE;QAAE,oBAAoB,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,EAC/C,QAAQ,EAAE,cAAc,EAIzB;IAED,wDAAwD;IACxD,SAAS,IAAI,MAAM,CAElB;IAED,sDAAsD;IACtD,eAAe,oBAEd;IAED,iDAAiD;IACjD,eAAe,IAAI,GAAG,EAAE,CAEvB;IAED,8EAA8E;IAC9E,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,QAE5E;IAED,wEAAwE;IACxE,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,QAE9E;IAED,kDAAkD;IAClD,YAAY,SAEX;IAED;;;;OAIG;IACH,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,QAEtD;CACF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE;IAAE,oBAAoB,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EAC/C,QAAQ,EAAE,cAAc,GACvB,OAAO,CAET;AAaD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,CAuH1F"}

package/dest/{test → l1_tx_utils}/tx_delayer.js

@@ -2,8 +2,7 @@ import { omit } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { inspect } from 'util';
-import { keccak256, parseTransaction, publicActions, serializeTransaction, walletActions } from 'viem';
-import { isExtendedClient } from '../types.js';
+import { keccak256, parseTransaction, publicActions, recoverTransactionAddress, serializeTransaction, walletActions } from 'viem';
 const MAX_WAIT_TIME_SECONDS = 180;
 export function waitUntilBlock(client, blockNumber, logger, timeout) {
     const publicClient = 'getBlockNumber' in client && typeof client.getBlockNumber === 'function' ? client : client.extend(publicActions);
@@ -35,59 +34,80 @@ export function waitUntilL1Timestamp(client, timestamp, logger, timeout) {
         return currentTs >= BigInt(timestamp);
     }, `Wait until L1 timestamp ${timestamp}`, timeout ?? MAX_WAIT_TIME_SECONDS, 0.1);
 }
-class DelayerImpl {
+/** Manages tx delaying for testing, intercepting sendRawTransaction calls to delay or cancel them. */ export class Delayer {
     dateProvider;
     logger;
-    constructor(dateProvider, opts){
+    maxInclusionTimeIntoSlot;
+    ethereumSlotDuration;
+    nextWait;
+    sentTxHashes;
+    cancelledTxs;
+    constructor(dateProvider, opts, bindings){
         this.dateProvider = dateProvider;
-        this.logger = createLogger('ethereum:tx_delayer');
         this.maxInclusionTimeIntoSlot = undefined;
         this.nextWait = undefined;
         this.sentTxHashes = [];
         this.cancelledTxs = [];
         this.ethereumSlotDuration = BigInt(opts.ethereumSlotDuration);
+        this.logger = createLogger('ethereum:tx_delayer', bindings);
     }
-    maxInclusionTimeIntoSlot;
-    ethereumSlotDuration;
-    nextWait;
-    sentTxHashes;
-    cancelledTxs;
-    getSentTxHashes() {
+    /** Returns the logger instance used by this delayer. */ getLogger() {
+        return this.logger;
+    }
+    /** Returns the hashes of all effectively sent txs. */ getSentTxHashes() {
         return this.sentTxHashes;
     }
-    getCancelledTxs() {
+    /** Returns the raw hex for all cancelled txs. */ getCancelledTxs() {
         return this.cancelledTxs;
     }
-    pauseNextTxUntilBlock(l1BlockNumber) {
+    /** Delays the next tx to be sent so it lands on the given L1 block number. */ pauseNextTxUntilBlock(l1BlockNumber, timeoutSeconds) {
         this.nextWait = {
-            l1BlockNumber: BigInt(l1BlockNumber)
+            l1BlockNumber: BigInt(l1BlockNumber),
+            timeoutSeconds
         };
     }
-    pauseNextTxUntilTimestamp(l1Timestamp) {
+    /** Delays the next tx to be sent so it lands on the given timestamp. */ pauseNextTxUntilTimestamp(l1Timestamp, timeoutSeconds) {
         this.nextWait = {
-            l1Timestamp: BigInt(l1Timestamp)
+            l1Timestamp: BigInt(l1Timestamp),
+            timeoutSeconds
         };
     }
-    cancelNextTx() {
+    /** Delays the next tx to be sent indefinitely. */ cancelNextTx() {
         this.nextWait = {
             indefinitely: true
         };
     }
-    setMaxInclusionTimeIntoSlot(seconds) {
+    /**
+   * Sets max inclusion time into slot. If more than this many seconds have passed
+   * since the last L1 block was mined, then any tx will not be mined in the current
+   * L1 slot but will be deferred for the next one.
+   */ setMaxInclusionTimeIntoSlot(seconds) {
         this.maxInclusionTimeIntoSlot = seconds;
     }
 }
 /**
- * Returns a new client (without modifying the one passed in) with an injected tx delayer.
- * The delayer can be used to hold off the next tx to be sent until a given block number.
- * TODO(#10824): This doesn't play along well with blob txs for some reason.
- */ export function withDelayer(client, dateProvider, opts) {
-    if (!isExtendedClient(client)) {
-        throw new Error('withDelayer has to be instantiated with a wallet viem client.');
+ * Creates a new Delayer instance. Exposed so callers can create a single shared delayer
+ * and pass it to multiple `wrapClientWithDelayer` calls.
+ */ export function createDelayer(dateProvider, opts, bindings) {
+    return new Delayer(dateProvider, opts, bindings);
+}
+/** Tries to recover the sender address from a serialized signed transaction. */ async function tryRecoverSender(serializedTransaction) {
+    try {
+        return await recoverTransactionAddress({
+            serializedTransaction: serializedTransaction
+        });
+    } catch  {
+        return undefined;
     }
-    const logger = createLogger('ethereum:tx_delayer');
-    const delayer = new DelayerImpl(dateProvider, opts);
-    const extended = client// Tweak sendRawTransaction so it uses the delay defined in the delayer.
+}
+/**
+ * Wraps a viem client with tx delaying logic. Returns the wrapped client.
+ * The delayer intercepts sendRawTransaction calls and delays them based on the delayer's state.
+ */ export function wrapClientWithDelayer(client, delayer) {
+    const logger = delayer.getLogger();
+    // Cast to ExtendedViemWalletClient for the extend chain since it has sendRawTransaction.
+    // The sendRawTransaction override is applied to all clients regardless of type.
+    const withRawTx = client// Tweak sendRawTransaction so it uses the delay defined in the delayer.
     // Note that this will only work with local accounts (ie accounts for which we have the private key).
     // Transactions signed by the node will not be delayed since they use sendTransaction directly,
     // but we do not use them in our codebase at all.
@@ -97,6 +117,7 @@ class DelayerImpl {
                 let txHash;
                 const { serializedTransaction } = args[0];
                 const publicClient = client;
+                const sender = await tryRecoverSender(serializedTransaction);
                 if (delayer.nextWait !== undefined) {
                     // Check if we have been instructed to delay the next tx.
                     const waitUntil = delayer.nextWait;
@@ -105,13 +126,16 @@ class DelayerImpl {
                     txHash = computeTxHash(serializedTransaction);
                     // Cancel tx outright if instructed
                     if ('indefinitely' in waitUntil && waitUntil.indefinitely) {
-                        logger.info(`Cancelling tx ${txHash}`);
+                        logger.info(`Cancelling tx ${txHash}`, {
+                            sender
+                        });
                         delayer.cancelledTxs.push(serializedTransaction);
                         return Promise.resolve(txHash);
                     }
                     // Or wait until the desired block number or timestamp
-                    wait = 'l1BlockNumber' in waitUntil ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger) : 'l1Timestamp' in waitUntil ? waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger) : undefined;
+                    wait = 'l1BlockNumber' in waitUntil ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger, waitUntil.timeoutSeconds) : 'l1Timestamp' in waitUntil ? waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger, waitUntil.timeoutSeconds) : undefined;
                     logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
+                        sender,
                         argsLen: args.length,
                         ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars')
                     });
@@ -124,6 +148,7 @@ class DelayerImpl {
                     const now = delayer.dateProvider.now();
                     txHash = computeTxHash(serializedTransaction);
                     const logData = {
+                        sender,
                         ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
                         lastBlockTimestamp,
                         now,
@@ -150,29 +175,34 @@ class DelayerImpl {
                                 computedTxHash: txHash
                             });
                         }
-                        logger.info(`Sent previously delayed tx ${clientTxHash}`);
+                        logger.info(`Sent previously delayed tx ${clientTxHash}`, {
+                            sender
+                        });
                         delayer.sentTxHashes.push(clientTxHash);
                     }).catch((err)=>logger.error(`Error sending tx after delay`, err));
                     return Promise.resolve(txHash);
                 } else {
                     const txHash = await client.sendRawTransaction(...args);
-                    logger.debug(`Sent tx immediately ${txHash}`);
+                    logger.debug(`Sent tx immediately ${txHash}`, {
+                        sender
+                    });
                     delayer.sentTxHashes.push(txHash);
                     return txHash;
                 }
             }
-        }))// Re-extend with sendTransaction so it uses the modified sendRawTransaction.
+        }));
+    // Only re-bind wallet actions (sendTransaction, writeContract, deployContract) for wallet clients.
+    // This is needed for tests that use wallet actions directly rather than sendRawTransaction.
+    const isWalletClient = 'account' in client && client.account !== undefined;
+    const extended = isWalletClient ? withRawTx// Re-extend with sendTransaction so it uses the modified sendRawTransaction.
     .extend((client)=>({
             sendTransaction: walletActions(client).sendTransaction
         }))// And with the actions that depend on the modified sendTransaction
     .extend((client)=>({
             writeContract: walletActions(client).writeContract,
             deployContract: walletActions(client).deployContract
-        }));
-    return {
-        client: extended,
-        delayer
-    };
+        })) : withRawTx;
+    return extended;
 }
 /**
  * Compute the tx hash given the serialized tx. Note that if this is a blob tx, we need to

package/dest/publisher_manager.d.ts

@@ -1,16 +1,42 @@
 import { type LoggerBindings } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
 import { L1TxUtils } from './l1_tx_utils/index.js';
 export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
+/** Config accepted by PublisherManager. */
+type PublisherManagerConfig = {
+    publisherAllowInvalidStates?: boolean;
+    publisherFundingThreshold?: bigint;
+    publisherFundingAmount?: bigint;
+};
 export declare class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
-    private publishers;
+    protected publishers: UtilsType[];
     private log;
     private config;
-    constructor(publishers: UtilsType[], config: {
-        publisherAllowInvalidStates?: boolean;
-    }, bindings?: LoggerBindings);
-    /** Loads the state of all publishers and resumes monitoring any pending txs */
-    loadState(): Promise<void>;
+    private static readonly FUNDING_CHECK_INTERVAL_MS;
+    protected funder?: UtilsType;
+    protected readonly fundingPromise?: RunningPromise;
+    private started;
+    constructor(publishers: UtilsType[], config: PublisherManagerConfig, opts?: {
+        bindings?: LoggerBindings;
+        funder?: UtilsType;
+    });
+    /**
+     * Clears any interrupted flag left by a previous {@link stop} so publishing works again after a restart,
+     * loads the state of all publishers and the funder, and starts periodic funding checks. Idempotent: a
+     * start while already started is a no-op, so it never re-runs `loadStateAndResumeMonitoring` (which
+     * would spawn a duplicate background monitor per pending nonce). Lifecycle calls are expected to be
+     * serialized by the caller.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the funding loop, interrupts all publishers so no further L1 txs are sent, and waits (bounded)
+     * for their in-flight tx monitor loops to wind down. Idempotent, and the manager may be restarted
+     * afterwards via {@link start}, which clears the interrupted flag.
+     */
+    stop(): Promise<void>;
     getAvailablePublisher(filter?: PublisherFilter<UtilsType>): Promise<UtilsType>;
-    interrupt(): void;
+    private triggerFundingIfNeeded;
+    private fundPublishers;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGlzaGVyX21hbmFnZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9wdWJsaXNoZXJfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQWUsS0FBSyxjQUFjLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFFdkYsT0FBTyxFQUFFLFNBQVMsRUFBZ0IsTUFBTSx3QkFBd0IsQ0FBQztBQXdCakUsTUFBTSxNQUFNLGVBQWUsQ0FBQyxTQUFTLFNBQVMsU0FBUyxJQUFJLENBQUMsS0FBSyxFQUFFLFNBQVMsS0FBSyxPQUFPLENBQUM7QUFFekYscUJBQWEsZ0JBQWdCLENBQUMsU0FBUyxTQUFTLFNBQVMsR0FBRyxTQUFTO0lBS2pFLE9BQU8sQ0FBQyxVQUFVO0lBSnBCLE9BQU8sQ0FBQyxHQUFHLENBQVM7SUFDcEIsT0FBTyxDQUFDLE1BQU0sQ0FBNEM7SUFFMUQsWUFDVSxVQUFVLEVBQUUsU0FBUyxFQUFFLEVBQy9CLE1BQU0sRUFBRTtRQUFFLDJCQUEyQixDQUFDLEVBQUUsT0FBTyxDQUFBO0tBQUUsRUFDakQsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQU0xQjtJQUVELCtFQUErRTtJQUNsRSxTQUFTLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUV0QztJQVFZLHFCQUFxQixDQUFDLE1BQU0sR0FBRSxlQUFlLENBQUMsU0FBUyxDQUFjLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQStDdEc7SUFFTSxTQUFTLFNBRWY7Q0FDRiJ9
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGlzaGVyX21hbmFnZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9wdWJsaXNoZXJfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQWUsS0FBSyxjQUFjLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDdkYsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBR25FLE9BQU8sRUFBRSxTQUFTLEVBQWdCLE1BQU0sd0JBQXdCLENBQUM7QUF3QmpFLE1BQU0sTUFBTSxlQUFlLENBQUMsU0FBUyxTQUFTLFNBQVMsSUFBSSxDQUFDLEtBQUssRUFBRSxTQUFTLEtBQUssT0FBTyxDQUFDO0FBRXpGLDJDQUEyQztBQUMzQyxLQUFLLHNCQUFzQixHQUFHO0lBQzVCLDJCQUEyQixDQUFDLEVBQUUsT0FBTyxDQUFDO0lBQ3RDLHlCQUF5QixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ25DLHNCQUFzQixDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2pDLENBQUM7QUFFRixxQkFBYSxnQkFBZ0IsQ0FBQyxTQUFTLFNBQVMsU0FBUyxHQUFHLFNBQVM7SUFTakUsU0FBUyxDQUFDLFVBQVUsRUFBRSxTQUFTLEVBQUU7SUFSbkMsT0FBTyxDQUFDLEdBQUcsQ0FBUztJQUNwQixPQUFPLENBQUMsTUFBTSxDQUF5QjtJQUN2QyxPQUFPLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyx5QkFBeUIsQ0FBaUI7SUFDbEUsU0FBUyxDQUFDLE1BQU0sQ0FBQyxFQUFFLFNBQVMsQ0FBQztJQUM3QixTQUFTLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBQyxFQUFFLGNBQWMsQ0FBQztJQUNuRCxPQUFPLENBQUMsT0FBTyxDQUFTO0lBRXhCLFlBQ1ksVUFBVSxFQUFFLFNBQVMsRUFBRSxFQUNqQyxNQUFNLEVBQUUsc0JBQXNCLEVBQzlCLElBQUksQ0FBQyxFQUFFO1FBQUUsUUFBUSxDQUFDLEVBQUUsY0FBYyxDQUFDO1FBQUMsTUFBTSxDQUFDLEVBQUUsU0FBUyxDQUFBO0tBQUUsRUE2QnpEO0lBRUQ7Ozs7OztPQU1HO0lBQ1UsS0FBSyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FtQmxDO0lBRUQ7Ozs7T0FJRztJQUNVLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBV2pDO0lBUVkscUJBQXFCLENBQUMsTUFBTSxHQUFFLGVBQWUsQ0FBQyxTQUFTLENBQWMsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBd0R0RztZQUdhLHNCQUFzQjtZQXFDdEIsY0FBYztDQVU3QiJ9

package/dest/publisher_manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publisher_manager.d.ts","sourceRoot":"","sources":["../src/publisher_manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,EAAE,SAAS,EAAgB,MAAM,wBAAwB,CAAC;AAwBjE,MAAM,MAAM,eAAe,CAAC,SAAS,SAAS,SAAS,IAAI,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC;AAEzF,qBAAa,gBAAgB,CAAC,SAAS,SAAS,SAAS,GAAG,SAAS;IAKjE,OAAO,CAAC,UAAU;IAJpB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,MAAM,CAA4C;IAE1D,YACU,UAAU,EAAE,SAAS,EAAE,EAC/B,MAAM,EAAE;QAAE,2BAA2B,CAAC,EAAE,OAAO,CAAA;KAAE,EACjD,QAAQ,CAAC,EAAE,cAAc,EAM1B;IAED,+EAA+E;IAClE,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAEtC;IAQY,qBAAqB,CAAC,MAAM,GAAE,eAAe,CAAC,SAAS,CAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CA+CtG;IAEM,SAAS,SAEf;CACF"}
+{"version":3,"file":"publisher_manager.d.ts","sourceRoot":"","sources":["../src/publisher_manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAGnE,OAAO,EAAE,SAAS,EAAgB,MAAM,wBAAwB,CAAC;AAwBjE,MAAM,MAAM,eAAe,CAAC,SAAS,SAAS,SAAS,IAAI,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC;AAEzF,2CAA2C;AAC3C,KAAK,sBAAsB,GAAG;IAC5B,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,qBAAa,gBAAgB,CAAC,SAAS,SAAS,SAAS,GAAG,SAAS;IASjE,SAAS,CAAC,UAAU,EAAE,SAAS,EAAE;IARnC,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAiB;IAClE,SAAS,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;IAC7B,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACnD,OAAO,CAAC,OAAO,CAAS;IAExB,YACY,UAAU,EAAE,SAAS,EAAE,EACjC,MAAM,EAAE,sBAAsB,EAC9B,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,cAAc,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAA;KAAE,EA6BzD;IAED;;;;;;OAMG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAmBlC;IAED;;;;OAIG;IACU,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAWjC;IAQY,qBAAqB,CAAC,MAAM,GAAE,eAAe,CAAC,SAAS,CAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CAwDtG;YAGa,sBAAsB;YAqCtB,cAAc;CAU7B"}

package/dest/publisher_manager.js

@@ -1,5 +1,7 @@
 import { pick } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { Multicall3 } from './contracts/multicall.js';
 import { TxUtilsState } from './l1_tx_utils/index.js';
 // Defines the order in which we prioritise publishers based on their state (first is better)
 const sortOrder = [
@@ -25,15 +27,72 @@ export class PublisherManager {
     publishers;
     log;
     config;
-    constructor(publishers, config, bindings){
+    static FUNDING_CHECK_INTERVAL_MS = 2 * 60 * 1000;
+    funder;
+    fundingPromise;
+    started;
+    constructor(publishers, config, opts){
         this.publishers = publishers;
-        this.log = createLogger('publisher:manager', bindings);
+        this.started = false;
+        this.funder = opts?.funder;
+        this.log = createLogger('publisher:manager', opts?.bindings);
         this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
         this.publishers = publishers;
-        this.config = pick(config, 'publisherAllowInvalidStates');
+        this.config = pick(config, 'publisherAllowInvalidStates', 'publisherFundingThreshold', 'publisherFundingAmount');
+        const hasThreshold = this.config.publisherFundingThreshold !== undefined;
+        const hasAmount = this.config.publisherFundingAmount !== undefined;
+        if (hasThreshold !== hasAmount) {
+            this.log.warn(`Incomplete funding config: both publisherFundingThreshold and publisherFundingAmount must be set`);
+        }
+        if (this.funder) {
+            const funderAddress = this.funder.getSenderAddress();
+            if (publishers.some((p)=>p.getSenderAddress().equals(funderAddress))) {
+                this.log.error(`Funding account ${funderAddress} is also a publisher, disabling funding to avoid self-funding`);
+                this.funder = undefined;
+            }
+        }
+        if (this.funder && hasThreshold && hasAmount) {
+            this.fundingPromise = new RunningPromise(()=>this.triggerFundingIfNeeded(), this.log, PublisherManager.FUNDING_CHECK_INTERVAL_MS);
+        }
     }
-    /** Loads the state of all publishers and resumes monitoring any pending txs */ async loadState() {
-        await Promise.all(this.publishers.map((pub)=>pub.loadStateAndResumeMonitoring()));
+    /**
+   * Clears any interrupted flag left by a previous {@link stop} so publishing works again after a restart,
+   * loads the state of all publishers and the funder, and starts periodic funding checks. Idempotent: a
+   * start while already started is a no-op, so it never re-runs `loadStateAndResumeMonitoring` (which
+   * would spawn a duplicate background monitor per pending nonce). Lifecycle calls are expected to be
+   * serialized by the caller.
+   */ async start() {
+        if (this.started) {
+            this.log.debug('PublisherManager already started, ignoring start');
+            return;
+        }
+        // Clear the interrupted flag set by a previous stop() so a restarted manager can publish again.
+        // On a first start this is a no-op (the flag is already clear).
+        this.publishers.forEach((pub)=>pub.restart());
+        this.funder?.restart();
+        await Promise.all([
+            ...this.publishers.map((pub)=>pub.loadStateAndResumeMonitoring()),
+            this.funder?.loadStateAndResumeMonitoring()
+        ]);
+        this.fundingPromise?.start();
+        // Marked started only once fully up, so a start that failed to load state can be retried.
+        this.started = true;
+    }
+    /**
+   * Stops the funding loop, interrupts all publishers so no further L1 txs are sent, and waits (bounded)
+   * for their in-flight tx monitor loops to wind down. Idempotent, and the manager may be restarted
+   * afterwards via {@link start}, which clears the interrupted flag.
+   */ async stop() {
+        this.started = false;
+        await this.fundingPromise?.stop();
+        this.publishers.forEach((pub)=>pub.interrupt());
+        this.funder?.interrupt();
+        // Wait for in-flight tx monitor loops to observe the interrupt, so no L1 requests are still
+        // being issued after shutdown (e.g. against an anvil instance a test is about to tear down).
+        await Promise.all([
+            ...this.publishers.map((pub)=>pub.waitMonitoringStopped()),
+            this.funder?.waitMonitoringStopped()
+        ]);
     }
     // Finds and prioritises available publishers based on
     // 1. Validity as per the provided filter function
@@ -67,8 +126,16 @@ export class PublisherManager {
                 publisher: pub
             };
         }));
+        // Discount unfunded publishers: a publisher with no ETH cannot send a tx, so it must never win
+        // selection regardless of how favourable its state or last-used time is. Fall back to the full
+        // set only if every candidate is unfunded, so behaviour is no worse than before.
+        let fundedPublishers = publishersWithBalance.filter((p)=>p.balance > 0n);
+        if (fundedPublishers.length === 0) {
+            this.log.warn(`All candidate publishers have zero balance; selecting from unfunded publishers.`);
+            fundedPublishers = publishersWithBalance;
+        }
         // Sort based on state, then balance, then time since last use
-        const sortedPublishers = publishersWithBalance.sort((a, b)=>{
+        const sortedPublishers = fundedPublishers.sort((a, b)=>{
             const stateComparison = sortOrder.indexOf(a.publisher.state) - sortOrder.indexOf(b.publisher.state);
             if (stateComparison !== 0) {
                 return stateComparison;
@@ -82,7 +149,51 @@ export class PublisherManager {
         });
         return sortedPublishers[0].publisher;
     }
-    interrupt() {
-        this.publishers.forEach((pub)=>pub.interrupt());
+    /** Check all publisher balances and fund those below threshold. */ async triggerFundingIfNeeded() {
+        const { funder, config } = this;
+        if (!funder || config.publisherFundingThreshold === undefined || config.publisherFundingAmount === undefined) {
+            return;
+        }
+        const allBalances = await Promise.all(this.publishers.map(async (pub)=>({
+                balance: await pub.getSenderBalance(),
+                publisher: pub
+            })));
+        const lowBalance = allBalances.filter((p)=>p.balance < config.publisherFundingThreshold);
+        if (lowBalance.length === 0) {
+            return;
+        }
+        const fundingAmount = config.publisherFundingAmount;
+        const funderBalance = await funder.getSenderBalance();
+        if (funderBalance < 10n * fundingAmount) {
+            this.log.warn(`Funding account balance is low`, {
+                funderBalance,
+                threshold: 10n * fundingAmount
+            });
+        }
+        const affordableCount = Number(funderBalance / fundingAmount);
+        if (affordableCount === 0) {
+            this.log.error(`Funding account balance too low to fund any publisher`, {
+                funderBalance,
+                fundingAmount
+            });
+            return;
+        }
+        if (affordableCount < lowBalance.length) {
+            this.log.warn(`Funder can only afford ${affordableCount}/${lowBalance.length} publishers`, {
+                funderBalance,
+                fundingAmount
+            });
+        }
+        const toFund = lowBalance.slice(0, affordableCount).map((p)=>p.publisher);
+        await this.fundPublishers(toFund);
+    }
+    /** Fund publishers via a single Multicall3 aggregate3Value transaction. */ async fundPublishers(publishers) {
+        const fundingAmount = this.config.publisherFundingAmount;
+        const calls = publishers.map((pub)=>({
+                to: pub.getSenderAddress().toString(),
+                value: fundingAmount
+            }));
+        await Multicall3.forwardValue(calls, this.funder, this.log);
+        this.log.info(`Funded ${publishers.length} publishers`);
     }
 }

package/dest/queries.d.ts

@@ -1,6 +1,17 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Block } from 'viem';
 import { type L1ContractsConfig } from './config.js';
-import type { ViemPublicClient } from './types.js';
+import type { ViemClient, ViemPublicClient } from './types.js';
+/**
+ * Returns the L1 finalized block, or `undefined` if the chain does not yet have one
+ * (common on freshly started devnets). Rethrows any other RPC error.
+ */
+export declare function getFinalizedL1Block(client: ViemClient): Promise<Block<bigint, false, 'finalized'> | undefined>;
+/**
+ * Returns true if the error originates from an RPC call that failed because
+ * the "finalized" (or "safe") block tag is not yet available on the chain.
+ */
+export declare function isFinalizedBlockTagNotFoundError(err: unknown): boolean;
 /** Reads the L1ContractsConfig from L1 contracts. */
 export declare function getL1ContractsConfig(publicClient: ViemPublicClient, addresses: {
     governanceAddress: EthAddress;
@@ -11,4 +22,4 @@ export declare function getL1ContractsConfig(publicClient: ViemPublicClient, add
     rollupVersion: number;
     genesisArchiveTreeRoot: `0x${string}`;
 }>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcmllcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3F1ZXJpZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRTNELE9BQU8sRUFBNEIsS0FBSyxpQkFBaUIsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUsvRSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVuRCxxREFBcUQ7QUFDckQsd0JBQXNCLG9CQUFvQixDQUN4QyxZQUFZLEVBQUUsZ0JBQWdCLEVBQzlCLFNBQVMsRUFBRTtJQUFFLGlCQUFpQixFQUFFLFVBQVUsQ0FBQztJQUFDLGFBQWEsQ0FBQyxFQUFFLFVBQVUsQ0FBQTtDQUFFLEdBQ3ZFLE9BQU8sQ0FDUixJQUFJLENBQUMsaUJBQWlCLEVBQUUsc0JBQXNCLENBQUMsR0FBRztJQUNoRCxZQUFZLEVBQUUsTUFBTSxDQUFDO0lBQ3JCLGFBQWEsRUFBRSxNQUFNLENBQUM7SUFDdEIsYUFBYSxFQUFFLE1BQU0sQ0FBQztJQUN0QixzQkFBc0IsRUFBRSxLQUFLLE1BQU0sRUFBRSxDQUFDO0NBQ3ZDLENBQ0YsQ0F1R0EifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcmllcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3F1ZXJpZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRTNELE9BQU8sRUFBYSxLQUFLLEtBQUssRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUU3QyxPQUFPLEVBQTRCLEtBQUssaUJBQWlCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFLL0UsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRS9EOzs7R0FHRztBQUNILHdCQUFzQixtQkFBbUIsQ0FBQyxNQUFNLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLEtBQUssRUFBRSxXQUFXLENBQUMsR0FBRyxTQUFTLENBQUMsQ0FTcEg7QUFtQkQ7OztHQUdHO0FBQ0gsd0JBQWdCLGdDQUFnQyxDQUFDLEdBQUcsRUFBRSxPQUFPLEdBQUcsT0FBTyxDQWtCdEU7QUFVRCxxREFBcUQ7QUFDckQsd0JBQXNCLG9CQUFvQixDQUN4QyxZQUFZLEVBQUUsZ0JBQWdCLEVBQzlCLFNBQVMsRUFBRTtJQUFFLGlCQUFpQixFQUFFLFVBQVUsQ0FBQztJQUFDLGFBQWEsQ0FBQyxFQUFFLFVBQVUsQ0FBQTtDQUFFLEdBQ3ZFLE9BQU8sQ0FDUixJQUFJLENBQUMsaUJBQWlCLEVBQUUsc0JBQXNCLENBQUMsR0FBRztJQUNoRCxZQUFZLEVBQUUsTUFBTSxDQUFDO0lBQ3JCLGFBQWEsRUFBRSxNQUFNLENBQUM7SUFDdEIsYUFBYSxFQUFFLE1BQU0sQ0FBQztJQUN0QixzQkFBc0IsRUFBRSxLQUFLLE1BQU0sRUFBRSxDQUFDO0NBQ3ZDLENBQ0YsQ0F1R0EifQ==

package/dest/queries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../src/queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAA4B,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAK/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,qDAAqD;AACrD,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE;IAAE,iBAAiB,EAAE,UAAU,CAAC;IAAC,aAAa,CAAC,EAAE,UAAU,CAAA;CAAE,GACvE,OAAO,CACR,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,GAAG;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,sBAAsB,EAAE,KAAK,MAAM,EAAE,CAAC;CACvC,CACF,CAuGA"}
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../src/queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAa,KAAK,KAAK,EAAE,MAAM,MAAM,CAAC;AAE7C,OAAO,EAA4B,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAK/E,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE/D;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,GAAG,SAAS,CAAC,CASpH;AAmBD;;;GAGG;AACH,wBAAgB,gCAAgC,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAkBtE;AAUD,qDAAqD;AACrD,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE;IAAE,iBAAiB,EAAE,UAAU,CAAC;IAAC,aAAa,CAAC,EAAE,UAAU,CAAA;CAAE,GACvE,OAAO,CACR,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,GAAG;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,sBAAsB,EAAE,KAAK,MAAM,EAAE,CAAC;CACvC,CACF,CAuGA"}

package/dest/queries.js

@@ -1,9 +1,68 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { BaseError } from 'viem';
 import { DefaultL1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
 import { GovernanceProposerContract } from './contracts/governance_proposer.js';
 import { InboxContract } from './contracts/inbox.js';
 import { RollupContract } from './contracts/rollup.js';
+/**
+ * Returns the L1 finalized block, or `undefined` if the chain does not yet have one
+ * (common on freshly started devnets). Rethrows any other RPC error.
+ */ export async function getFinalizedL1Block(client) {
+    try {
+        return await client.getBlock({
+            blockTag: 'finalized',
+            includeTransactions: false
+        });
+    } catch (err) {
+        if (isFinalizedBlockTagNotFoundError(err)) {
+            return undefined;
+        }
+        throw err;
+    }
+}
+// Error messages returned by popular Ethereum execution clients when
+// eth_getBlockByNumber / eth_call is called with blockTag "finalized" or
+// "safe" and no such block has been produced yet:
+//
+//   geth       "finalized block not found"
+//              "safe block not found"
+//   reth       "block not found: finalized"
+//              "block not found: safe"
+//   nethermind "Unknown block error"           (same for both tags)
+//   besu       "Unknown block"
+//   erigon     'block "finalized" not available (head block: N)'
+//              'block "safe" not available (head block: N)'
+//
+// A combined regex covers all five:
+const FINALIZED_BLOCK_TAG_NOT_FOUND_MESSAGE_RE = /(finalized|safe) block not found|block not found: (finalized|safe)|unknown block|block "(finalized|safe)" not available/i;
+/**
+ * Returns true if the error originates from an RPC call that failed because
+ * the "finalized" (or "safe") block tag is not yet available on the chain.
+ */ export function isFinalizedBlockTagNotFoundError(err) {
+    if (!err) {
+        return false;
+    }
+    if (err instanceof BaseError) {
+        const hit = err.walk((e)=>matchesFinalizedBlockTagNotFound(e));
+        if (hit) {
+            return true;
+        }
+    }
+    for(let cur = err, i = 0; cur && i < 10; cur = cur.cause, i++){
+        if (matchesFinalizedBlockTagNotFound(cur)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchesFinalizedBlockTagNotFound(e) {
+    if (!e) {
+        return false;
+    }
+    const text = `${e.details ?? ''} ${e.message ?? ''} ${e.shortMessage ?? ''}`;
+    return FINALIZED_BLOCK_TAG_NOT_FOUND_MESSAGE_RE.test(text);
+}
 /** Reads the L1ContractsConfig from L1 contracts. */ export async function getL1ContractsConfig(publicClient, addresses) {
     const governance = new ReadOnlyGovernanceContract(addresses.governanceAddress.toString(), publicClient);
     const governanceProposerAddress = await governance.getGovernanceProposerAddress();
@@ -33,8 +92,8 @@ import { RollupContract } from './contracts/rollup.js';
         slasherProposer?.getRoundSize() ?? 0n,
         slasherProposer?.getLifetimeInRounds() ?? 0n,
         slasherProposer?.getExecutionDelayInRounds() ?? 0n,
-        slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
-        slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [
+        slasherProposer?.getSlashOffsetInRounds() ?? 0n,
+        slasherProposer?.getSlashingAmounts() ?? [
             0n,
             0n,
             0n
@@ -74,7 +133,7 @@ import { RollupContract } from './contracts/rollup.js';
         rollupVersion: Number(rollupVersion),
         genesisArchiveTreeRoot: genesisArchiveTreeRoot.toString(),
         exitDelaySeconds: Number(exitDelay),
-        slasherFlavor: slasherProposer?.type ?? 'tally',
+        slasherEnabled: !!slasherProposer,
         slashingOffsetInRounds: Number(slashingOffsetInRounds),
         slashAmountSmall: slashingAmounts[0],
         slashAmountMedium: slashingAmounts[1],

package/dest/test/blob_kzg_warmup.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { ExtendedViemWalletClient } from '../types.js';
+/**
+ * Warms both KZG trusted setups in parallel for tests against a local anvil:
+ *   - anvil's own setup, loaded lazily when it first validates a blob sidecar in `eth_sendRawTransaction`
+ *   - our `@crate-crypto/node-eth-kzg` singleton (`getKzg()`, a ~2.2s synchronous precomp build)
+ *
+ * Without this, the first checkpoint publish pays both serially (~4.4s). The recipe does all RPC round
+ * trips up front, fires a single bare raw send carrying a fake (garbage) blob sidecar that anvil rejects
+ * after loading its trusted setup, yields once to flush the socket write, then synchronously builds our
+ * own precomp tables while anvil warms in parallel. The fake tx is rejected at admission, so it never
+ * enters the pool, mines no block, and burns no nonce — sending it from the passed client is harmless.
+ *
+ * Best-effort: any failure is debug-logged and swallowed, leaving lazy init as the fallback. Never throws.
+ *
+ * @param l1Client - The L1 client whose account sends the (rejected) warm-up blob tx.
+ */
+export declare function warmBlobKzg(l1Client: ExtendedViemWalletClient, logger?: Logger): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvYl9remdfd2FybXVwLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC9ibG9iX2t6Z193YXJtdXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFNUQ7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFDSCx3QkFBc0IsV0FBVyxDQUFDLFFBQVEsRUFBRSx3QkFBd0IsRUFBRSxNQUFNLENBQUMsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQTRDcEcifQ==

package/dest/test/blob_kzg_warmup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob_kzg_warmup.d.ts","sourceRoot":"","sources":["../../src/test/blob_kzg_warmup.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,wBAAwB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CpG"}