@aztec/ethereum 0.0.1-commit.b655e406 → 0.0.1-commit.b9865e97

package/dest/l1_tx_utils/readonly_l1_tx_utils.js

@@ -1,13 +1,16 @@
-import { getKeys, median, merge, pick, times } from '@aztec/foundation/collection';
+import { getKeys, merge, pick, times } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { getErrorCause } from '@aztec/foundation/types';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 import pickBy from 'lodash.pickby';
 import { MethodNotFoundRpcError, MethodNotSupportedRpcError, decodeErrorResult, formatGwei, getContractError, hexToBytes } from 'viem';
 import { defaultL1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
-import { BLOCK_TIME_MS, LARGE_GAS_LIMIT, MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE, MIN_REPLACEMENT_BUMP_PERCENTAGE, WEI_CONST } from './constants.js';
+import { BLOCK_TIME_MS, MAX_L1_TX_LIMIT, MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE, MIN_REPLACEMENT_BUMP_PERCENTAGE, WEI_CONST } from './constants.js';
+import { P75AllTxsPriorityFeeStrategy } from './fee-strategies/index.js';
 import { getCalldataGasUsage, tryGetCustomErrorNameContractFunction } from './utils.js';
-const HISTORICAL_BLOCK_COUNT = 5;
+// Change this to the current strategy we want to use
+const CurrentStrategy = P75AllTxsPriorityFeeStrategy;
 export class ReadOnlyL1TxUtils {
     client;
     logger;
@@ -35,150 +38,51 @@ export class ReadOnlyL1TxUtils {
     getBlockNumber() {
         return this.client.getBlockNumber();
     }
-    /**
-   * Analyzes pending transactions and recent fee history to determine a competitive priority fee.
-   * Falls back to network estimate if data is unavailable or fails.
-   * @param networkEstimateResult - Result from estimateMaxPriorityFeePerGas RPC call
-   * @param pendingBlockResult - Result from getBlock with pending tag RPC call
-   * @param feeHistoryResult - Result from getFeeHistory RPC call
-   * @returns A competitive priority fee based on pending txs and recent block history
-   */ getCompetitivePriorityFee(networkEstimateResult, pendingBlockResult, feeHistoryResult) {
-        const networkEstimate = networkEstimateResult.status === 'fulfilled' && typeof networkEstimateResult.value === 'bigint' ? networkEstimateResult.value : 0n;
-        let competitiveFee = networkEstimate;
-        if (pendingBlockResult.status === 'fulfilled' && pendingBlockResult.value !== null && pendingBlockResult.value.transactions && pendingBlockResult.value.transactions.length > 0) {
-            const pendingBlock = pendingBlockResult.value;
-            // Extract priority fees from pending transactions
-            const pendingFees = pendingBlock.transactions.map((tx)=>{
-                // Transaction can be just a hash string, so we need to check if it's an object
-                if (typeof tx === 'string') {
-                    return 0n;
-                }
-                const fee = tx.maxPriorityFeePerGas || 0n;
-                // Debug: Log suspicious fees
-                if (fee > 100n * WEI_CONST) {
-                    this.logger?.warn('Suspicious high priority fee in pending tx', {
-                        txHash: tx.hash,
-                        maxPriorityFeePerGas: formatGwei(fee),
-                        maxFeePerGas: formatGwei(tx.maxFeePerGas || 0n),
-                        maxFeePerBlobGas: tx.maxFeePerBlobGas ? formatGwei(tx.maxFeePerBlobGas) : 'N/A'
-                    });
-                }
-                return fee;
-            }).filter((fee)=>fee > 0n);
-            if (pendingFees.length > 0) {
-                // Use 75th percentile of pending fees to be competitive
-                const sortedPendingFees = [
-                    ...pendingFees
-                ].sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
-                const percentile75Index = Math.floor((sortedPendingFees.length - 1) * 0.75);
-                const pendingCompetitiveFee = sortedPendingFees[percentile75Index];
-                if (pendingCompetitiveFee > competitiveFee) {
-                    competitiveFee = pendingCompetitiveFee;
-                }
-                this.logger?.debug('Analyzed pending transactions for competitive pricing', {
-                    pendingTxCount: pendingFees.length,
-                    pendingP75: formatGwei(pendingCompetitiveFee)
-                });
-            }
-        }
-        if (feeHistoryResult.status === 'fulfilled' && feeHistoryResult.value !== null && feeHistoryResult.value.reward && feeHistoryResult.value.reward.length > 0) {
-            const feeHistory = feeHistoryResult.value;
-            // Extract 75th percentile fees from each block
-            const percentile75Fees = feeHistory.reward.map((rewards)=>rewards[0] || 0n).filter((fee)=>fee > 0n);
-            if (percentile75Fees.length > 0) {
-                // Calculate median of the 75th percentile fees across blocks
-                const medianHistoricalFee = median(percentile75Fees) ?? 0n;
-                // Debug: Log suspicious fees from history
-                if (medianHistoricalFee > 100n * WEI_CONST) {
-                    this.logger?.warn('Suspicious high fee in history', {
-                        historicalMedian: formatGwei(medianHistoricalFee),
-                        allP75Fees: percentile75Fees.map((f)=>formatGwei(f))
-                    });
-                }
-                if (medianHistoricalFee > competitiveFee) {
-                    competitiveFee = medianHistoricalFee;
-                }
-                this.logger?.debug('Analyzed fee history for competitive pricing', {
-                    historicalMedian: formatGwei(medianHistoricalFee)
-                });
-            }
-        }
-        // Sanity check: cap competitive fee at 100x network estimate to avoid using unrealistic fees
-        // (e.g., Anvil returns inflated historical fees that don't reflect actual network conditions)
-        const maxReasonableFee = networkEstimate * 100n;
-        if (competitiveFee > maxReasonableFee) {
-            this.logger?.warn('Competitive fee exceeds sanity cap, using capped value', {
-                competitiveFee: formatGwei(competitiveFee),
-                networkEstimate: formatGwei(networkEstimate),
-                cappedTo: formatGwei(maxReasonableFee)
-            });
-            competitiveFee = maxReasonableFee;
-        }
-        // Log final decision
-        if (competitiveFee > networkEstimate) {
-            this.logger?.debug('Using competitive fee from market analysis', {
-                networkEstimate: formatGwei(networkEstimate),
-                competitive: formatGwei(competitiveFee)
-            });
-        }
-        return competitiveFee;
+    getCode(address) {
+        return this.client.getCode({
+            address: address.toString()
+        });
     }
     /**
    * Gets the current gas price with bounds checking
    */ async getGasPrice(gasConfigOverrides, isBlobTx = false, attempt = 0, previousGasPrice) {
         const gasConfig = merge(this.config, gasConfigOverrides);
-        // Make all RPC calls in parallel upfront with retry logic
-        const latestBlockPromise = this.tryTwice(()=>this.client.getBlock({
-                blockTag: 'latest'
-            }), 'Getting latest block');
-        const networkEstimatePromise = gasConfig.fixedPriorityFeePerGas ? null : this.tryTwice(()=>this.client.estimateMaxPriorityFeePerGas(), 'Estimating max priority fee per gas');
-        const pendingBlockPromise = gasConfig.fixedPriorityFeePerGas ? null : this.tryTwice(()=>this.client.getBlock({
-                blockTag: 'pending',
-                includeTransactions: true
-            }), 'Getting pending block');
-        const feeHistoryPromise = gasConfig.fixedPriorityFeePerGas ? null : this.tryTwice(()=>this.client.getFeeHistory({
-                blockCount: HISTORICAL_BLOCK_COUNT,
-                rewardPercentiles: [
-                    75
-                ]
-            }), 'Getting fee history');
-        const blobBaseFeePromise = isBlobTx ? this.tryTwice(()=>this.client.getBlobBaseFee(), 'Getting blob base fee') : null;
-        const [latestBlockResult, networkEstimateResult, pendingBlockResult, feeHistoryResult, blobBaseFeeResult] = await Promise.allSettled([
-            latestBlockPromise,
-            networkEstimatePromise ?? Promise.resolve(0n),
-            pendingBlockPromise ?? Promise.resolve(null),
-            feeHistoryPromise ?? Promise.resolve(null),
-            blobBaseFeePromise ?? Promise.resolve(0n)
-        ]);
-        // Extract results
-        const baseFee = latestBlockResult.status === 'fulfilled' && typeof latestBlockResult.value === 'object' && latestBlockResult.value.baseFeePerGas ? latestBlockResult.value.baseFeePerGas : 0n;
-        // Get blob base fee if available
-        let blobBaseFee = 0n;
-        if (isBlobTx && blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
-            blobBaseFee = blobBaseFeeResult.value;
-        } else if (isBlobTx) {
+        // Execute strategy - it handles all RPC calls internally and returns everything we need
+        const strategyResult = await retry(()=>CurrentStrategy.execute(this.client, {
+                gasConfig,
+                isBlobTx,
+                logger: this.logger
+            }), 'Executing priority fee strategy', makeBackoff(times(2, ()=>0)), this.logger, true);
+        const { latestBlock, blobBaseFee, priorityFee: strategyPriorityFee } = strategyResult;
+        // Extract base fee from latest block
+        const baseFee = latestBlock.baseFeePerGas ?? 0n;
+        // Handle blob base fee
+        if (isBlobTx && blobBaseFee === undefined) {
             this.logger?.warn('Failed to get L1 blob base fee', attempt);
         }
-        let priorityFee;
-        if (gasConfig.fixedPriorityFeePerGas) {
-            this.logger?.debug('Using fixed priority fee per L1 gas', {
-                fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas
-            });
-            // try to maintain precision up to 1000000 wei
-            priorityFee = BigInt(gasConfig.fixedPriorityFeePerGas * 1_000_000) * (WEI_CONST / 1_000_000n);
-        } else {
-            // Get competitive priority fee (includes network estimate + analysis)
-            priorityFee = this.getCompetitivePriorityFee(networkEstimateResult, pendingBlockResult, feeHistoryResult);
+        let priorityFee = strategyPriorityFee;
+        // Apply minimum priority fee floor if configured
+        if (gasConfig.minimumPriorityFeePerGas) {
+            const minimumPriorityFee = BigInt(Math.trunc(gasConfig.minimumPriorityFeePerGas * Number(WEI_CONST)));
+            if (priorityFee < minimumPriorityFee) {
+                this.logger?.debug('Applying minimum priority fee floor', {
+                    calculatedPriorityFee: formatGwei(priorityFee),
+                    minimumPriorityFeePerGas: gasConfig.minimumPriorityFeePerGas,
+                    appliedFee: formatGwei(minimumPriorityFee)
+                });
+                priorityFee = minimumPriorityFee;
+            }
         }
         let maxFeePerGas = baseFee;
-        let maxFeePerBlobGas = blobBaseFee;
+        let maxFeePerBlobGas = blobBaseFee ?? 0n;
         // Bump base fee so it's valid for next blocks if it stalls
         const numBlocks = Math.ceil(gasConfig.stallTimeMs / BLOCK_TIME_MS);
         for(let i = 0; i < numBlocks; i++){
             // each block can go up 12.5% from previous baseFee
-            maxFeePerGas = maxFeePerGas * (1_000n + 125n) / 1_000n;
+            // ceil, (a+b-1)/b, to avoid truncation at small values (e.g. 1 wei blob base fee)
+            maxFeePerGas = (maxFeePerGas * (1_000n + 125n) + 999n) / 1_000n;
             // same for blob gas fee
-            maxFeePerBlobGas = maxFeePerBlobGas * (1_000n + 125n) / 1_000n;
+            maxFeePerBlobGas = (maxFeePerBlobGas * (1_000n + 125n) + 999n) / 1_000n;
         }
         if (attempt > 0) {
             const configBump = gasConfig.priorityFeeRetryBumpPercentage ?? defaultL1TxUtilsConfig.priorityFeeRetryBumpPercentage;
@@ -189,17 +93,14 @@ export class ReadOnlyL1TxUtils {
             // multiply by 100 & divide by 100 to maintain some precision
             const minPriorityFee = previousGasPrice.maxPriorityFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
             const minMaxFee = previousGasPrice.maxFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
-            let competitivePriorityFee = priorityFee;
-            if (!gasConfig.fixedPriorityFeePerGas) {
-                // Apply bump percentage to competitive fee
-                competitivePriorityFee = priorityFee * (100_00n + BigInt(configBump * 1_00)) / 100_00n;
-                this.logger?.debug(`Speed-up attempt ${attempt}: using competitive fee strategy`, {
-                    networkEstimate: formatGwei(priorityFee),
-                    competitiveFee: formatGwei(competitivePriorityFee),
-                    minRequired: formatGwei(minPriorityFee),
-                    bumpPercentage: configBump
-                });
-            }
+            // Apply bump percentage to competitive fee
+            const competitivePriorityFee = priorityFee * (100_00n + BigInt(configBump * 1_00)) / 100_00n;
+            this.logger?.debug(`Speed-up attempt ${attempt}: using competitive fee strategy`, {
+                networkEstimate: formatGwei(priorityFee),
+                competitiveFee: formatGwei(competitivePriorityFee),
+                minRequired: formatGwei(minPriorityFee),
+                bumpPercentage: configBump
+            });
             // Use maximum between competitive fee and minimum required bump
             const finalPriorityFee = competitivePriorityFee > minPriorityFee ? competitivePriorityFee : minPriorityFee;
             const feeSource = finalPriorityFee === competitivePriorityFee ? 'competitive' : 'minimum-bump';
@@ -207,25 +108,21 @@ export class ReadOnlyL1TxUtils {
             // Add the final priority fee to maxFeePerGas
             maxFeePerGas += finalPriorityFee;
             maxFeePerGas = maxFeePerGas > minMaxFee ? maxFeePerGas : minMaxFee;
-            if (!gasConfig.fixedPriorityFeePerGas) {
-                this.logger?.debug(`Speed-up fee decision: using ${feeSource} fee`, {
-                    finalPriorityFee: formatGwei(finalPriorityFee)
-                });
-            }
+            this.logger?.debug(`Speed-up fee decision: using ${feeSource} fee`, {
+                finalPriorityFee: formatGwei(finalPriorityFee)
+            });
         } else {
             // First attempt: apply configured bump percentage to competitive fee
             // multiply by 100 & divide by 100 to maintain some precision
-            if (!gasConfig.fixedPriorityFeePerGas) {
-                priorityFee = priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00)) / 100_00n;
-                this.logger?.debug('Initial transaction: using competitive fee from market analysis', {
-                    networkEstimate: formatGwei(priorityFee)
-                });
-            }
+            priorityFee = priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00)) / 100_00n;
+            this.logger?.debug('Initial transaction: using competitive fee from market analysis', {
+                networkEstimate: formatGwei(priorityFee)
+            });
             maxFeePerGas += priorityFee;
         }
         // maxGwei and maxBlobGwei are hard limits
-        const effectiveMaxGwei = gasConfig.maxGwei * WEI_CONST;
-        const effectiveMaxBlobGwei = gasConfig.maxBlobGwei * WEI_CONST;
+        const effectiveMaxGwei = BigInt(Math.trunc(gasConfig.maxGwei * Number(WEI_CONST)));
+        const effectiveMaxBlobGwei = BigInt(Math.trunc(gasConfig.maxBlobGwei * Number(WEI_CONST)));
         // Ensure we don't exceed maxGwei
         if (effectiveMaxGwei > 0n) {
             maxFeePerGas = maxFeePerGas > effectiveMaxGwei ? effectiveMaxGwei : maxFeePerGas;
@@ -248,7 +145,7 @@ export class ReadOnlyL1TxUtils {
             baseFee: formatGwei(baseFee),
             maxFeePerGas: formatGwei(maxFeePerGas),
             maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
-            blobBaseFee: formatGwei(blobBaseFee),
+            blobBaseFee: formatGwei(blobBaseFee ?? 0n),
             maxFeePerBlobGas: formatGwei(maxFeePerBlobGas)
         });
         return {
@@ -268,21 +165,26 @@ export class ReadOnlyL1TxUtils {
         };
         let initialEstimate = 0n;
         if (_blobInputs) {
-            // @note requests with blobs also require maxFeePerBlobGas to be set
+            // @note requests with blobs also require maxFeePerBlobGas to be set.
+            // Use 2x buffer for maxFeePerBlobGas to avoid stale fees and to pass EIP-4844 validation (even if it is a gas estimation call).
+            // 1. maxFeePerBlobGas >= blobBaseFee
+            // 2. account balance >= gas * maxFeePerGas + maxFeePerBlobGas * blobCount + value
             const gasPrice = await this.getGasPrice(gasConfig, true, 0);
             initialEstimate = await this.client.estimateGas({
                 account,
                 ...request,
                 ..._blobInputs,
-                maxFeePerBlobGas: gasPrice.maxFeePerBlobGas,
-                gas: LARGE_GAS_LIMIT
+                maxFeePerBlobGas: gasPrice.maxFeePerBlobGas * 2n,
+                gas: MAX_L1_TX_LIMIT,
+                blockTag: 'latest'
             });
             this.logger?.trace(`Estimated gas for blob tx: ${initialEstimate}`);
         } else {
             initialEstimate = await this.client.estimateGas({
                 account,
                 ...request,
-                gas: LARGE_GAS_LIMIT
+                gas: MAX_L1_TX_LIMIT,
+                blockTag: 'latest'
             });
             this.logger?.trace(`Estimated gas for non-blob tx: ${initialEstimate}`);
         }
@@ -396,7 +298,7 @@ export class ReadOnlyL1TxUtils {
                 result: result[0].calls[0].data
             };
         } catch (err) {
-            if (err instanceof MethodNotFoundRpcError || err instanceof MethodNotSupportedRpcError) {
+            if (getErrorCause(err, MethodNotFoundRpcError) || getErrorCause(err, MethodNotSupportedRpcError)) {
                 if (gasConfig.fallbackGasEstimate) {
                     this.logger?.warn(`Node does not support eth_simulateV1 API. Using fallback gas estimate: ${gasConfig.fallbackGasEstimate}`);
                     return {
@@ -423,9 +325,4 @@ export class ReadOnlyL1TxUtils {
         });
         return bumpedGasLimit;
     }
-    /**
-   * Helper function to retry RPC calls twice
-   */ tryTwice(fn, description) {
-        return retry(fn, description, makeBackoff(times(2, ()=>0)), this.logger, true);
-    }
 }

package/dest/l1_tx_utils/signer.d.ts

@@ -1,4 +1,4 @@
 import { type WalletClient } from 'viem';
 import type { SigningCallback } from './types.js';
 export declare function createViemSigner(client: WalletClient): SigningCallback;
-//# sourceMappingURL=signer.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbDFfdHhfdXRpbHMvc2lnbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBZ0MsS0FBSyxZQUFZLEVBQW9CLE1BQU0sTUFBTSxDQUFDO0FBRXpGLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVsRCx3QkFBZ0IsZ0JBQWdCLENBQUMsTUFBTSxFQUFFLFlBQVksbUJBb0JwRCJ9

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,8 @@ 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);
     return retryUntil(async ()=>{
@@ -12,7 +12,7 @@ export function waitUntilBlock(client, blockNumber, logger, timeout) {
         });
         logger?.debug(`Block number is ${currentBlockNumber} (waiting until ${blockNumber})`);
         return currentBlockNumber >= BigInt(blockNumber);
-    }, `Wait until L1 block ${blockNumber}`, timeout ?? 120, 0.1);
+    }, `Wait until L1 block ${blockNumber}`, timeout ?? MAX_WAIT_TIME_SECONDS, 0.1);
 }
 export function waitUntilL1Timestamp(client, timestamp, logger, timeout) {
     const publicClient = 'getBlockNumber' in client && typeof client.getBlockNumber === 'function' ? client : client.extend(publicActions);
@@ -32,61 +32,82 @@ export function waitUntilL1Timestamp(client, timestamp, logger, timeout) {
         const currentTs = currentBlock.timestamp;
         logger?.debug(`Block timstamp is ${currentTs} (waiting until ${timestamp})`);
         return currentTs >= BigInt(timestamp);
-    }, `Wait until L1 timestamp ${timestamp}`, timeout ?? 120, 0.1);
+    }, `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.
@@ -96,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;
@@ -104,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')
                     });
@@ -123,6 +148,7 @@ class DelayerImpl {
                     const now = delayer.dateProvider.now();
                     txHash = computeTxHash(serializedTransaction);
                     const logData = {
+                        sender,
                         ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
                         lastBlockTimestamp,
                         now,
@@ -149,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.verbose(`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/l1_tx_utils/types.d.ts

@@ -64,4 +64,4 @@ export declare class UnknownMinedTxError extends Error {
 export declare class DroppedTransactionError extends Error {
     constructor(nonce: number, account: string);
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,MAAM,CAAC;AAE3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IACnB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,GAAG,CAAC;CACX;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAE9F,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,GAAG,EAAE,eAAe,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,uCAAuC;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,4FAA4F;IAC5F,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,oBAAY,YAAY;IACtB,IAAI,IAAA;IACJ,IAAI,IAAA;IACJ,QAAQ,IAAA;IACR,SAAS,IAAA;IACT,SAAS,IAAA;IACT,KAAK,IAAA;CACN;AAED,eAAO,MAAM,oBAAoB,gBAAkE,CAAC;AAEpG,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,GAAG,EAAE,CAAC;IAChB,cAAc,EAAE,GAAG,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,iBAAiB,EAAE,UAAU,CAAC;IAC9B,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,IAAI,CAAC;IACjB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,UAAU,EAAE,YAAY,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAC5B,WAAW,EAAE,uBAAuB,EACpC,cAAc,EAAE,UAAU,KACvB,OAAO,CAAC,wBAAwB,CAAC,CAAC;AAEvC,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI3C;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI3C"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,MAAM,CAAC;AAE3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IACnB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,GAAG,CAAC;CACX;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAE9F,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,GAAG,EAAE,eAAe,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,uCAAuC;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,4FAA4F;IAC5F,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,oBAAY,YAAY;IACtB,IAAI,IAAA;IACJ,IAAI,IAAA;IACJ,QAAQ,IAAA;IACR,SAAS,IAAA;IACT,SAAS,IAAA;IACT,KAAK,IAAA;CACN;AAED,eAAO,MAAM,oBAAoB,gBAAkE,CAAC;AAEpG,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,GAAG,EAAE,CAAC;IAChB,cAAc,EAAE,GAAG,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,iBAAiB,EAAE,UAAU,CAAC;IAC9B,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,IAAI,CAAC;IACjB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,UAAU,EAAE,YAAY,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAC5B,WAAW,EAAE,uBAAuB,EACpC,cAAc,EAAE,UAAU,KACvB,OAAO,CAAC,wBAAwB,CAAC,CAAC;AAEvC,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,YAAY,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAGzC;CACF;AAED,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAGzC;CACF"}

package/dest/l1_tx_utils/utils.d.ts

@@ -1,4 +1,4 @@
 import type { ContractFunctionExecutionError } from 'viem';
 export declare function tryGetCustomErrorNameContractFunction(err: ContractFunctionExecutionError): string;
 export declare function getCalldataGasUsage(data: Uint8Array): number;
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sMV90eF91dGlscy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSw4QkFBOEIsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUUzRCx3QkFBZ0IscUNBQXFDLENBQUMsR0FBRyxFQUFFLDhCQUE4QixVQUV4RjtBQU9ELHdCQUFnQixtQkFBbUIsQ0FBQyxJQUFJLEVBQUUsVUFBVSxVQUVuRCJ9