@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/dest/l1_tx_utils/fee-strategies/p75_competitive_blob_txs_only.js

@@ -0,0 +1,191 @@
+import { median } from '@aztec/foundation/collection';
+import { formatGwei } from 'viem';
+import { calculatePercentile, isBlobTransaction } from '../../utils.js';
+import { WEI_CONST } from '../constants.js';
+import { HISTORICAL_BLOCK_COUNT } from './types.js';
+/**
+ * Fetches historical blocks and calculates reward percentiles for blob transactions only.
+ * Returns data in the same format as getFeeHistory for easy drop-in replacement.
+ *
+ * @param client - Viem client to use for RPC calls
+ * @param blockCount - Number of historical blocks to fetch
+ * @param rewardPercentiles - Array of percentiles to calculate (e.g., [75] for 75th percentile)
+ * @returns Object with reward field containing percentile fees for each block, similar to getFeeHistory
+ * @throws Error if fetching blocks fails
+ */ export async function getBlobPriorityFeeHistory(client, blockCount, rewardPercentiles) {
+    const latestBlockNumber = await client.getBlockNumber();
+    // Fetch multiple blocks in parallel
+    const blockPromises = Array.from({
+        length: blockCount
+    }, (_, i)=>client.getBlock({
+            blockNumber: latestBlockNumber - BigInt(i),
+            includeTransactions: true
+        }));
+    const blocks = await Promise.all(blockPromises);
+    // Process each block to extract blob transaction fees and other data
+    const baseFeePerGas = [];
+    const gasUsedRatio = [];
+    const reward = [];
+    for (const block of blocks){
+        // Collect base fee per gas
+        baseFeePerGas.push(block.baseFeePerGas || 0n);
+        // Calculate gas used ratio
+        const gasUsed = block.gasUsed || 0n;
+        const gasLimit = block.gasLimit || 1n; // Avoid division by zero
+        gasUsedRatio.push(Number(gasUsed) / Number(gasLimit));
+        if (!block.transactions || block.transactions.length === 0) {
+            // No transactions in this block - return zeros for each percentile
+            reward.push(rewardPercentiles.map(()=>0n));
+            continue;
+        }
+        // Extract priority fees from blob transactions only
+        const blobFees = block.transactions.map((tx)=>{
+            // Transaction can be just a hash string
+            if (typeof tx === 'string') {
+                return 0n;
+            }
+            if (!isBlobTransaction(tx)) {
+                return 0n;
+            }
+            return tx.maxPriorityFeePerGas || 0n;
+        }).filter((fee)=>fee > 0n);
+        if (blobFees.length === 0) {
+            // No blob transactions in this block - return zeros for each percentile
+            reward.push(rewardPercentiles.map(()=>0n));
+            continue;
+        }
+        // Calculate requested percentiles
+        const percentiles = rewardPercentiles.map((percentile)=>calculatePercentile(blobFees, percentile));
+        reward.push(percentiles);
+    }
+    // Calculate oldest block number (the last block in our array)
+    const oldestBlock = latestBlockNumber - BigInt(blockCount - 1);
+    // Reverse arrays to match getFeeHistory behavior (oldest first)
+    return {
+        baseFeePerGas: baseFeePerGas.reverse(),
+        gasUsedRatio: gasUsedRatio.reverse(),
+        oldestBlock,
+        reward: reward.reverse()
+    };
+}
+/**
+ * Similar to our current competitive priority fee strategy, but only considers blob transactions
+ * when calculating competitive priority fee for blob transactions.
+ * This strategy also has NO cap on the competitive fee if it's much higher than the network estimate.
+ * Analyzes p75 of pending transactions and 5-block fee history to determine a competitive priority fee.
+ * Falls back to network estimate if data is unavailable.
+ */ export const P75BlobTxsOnlyPriorityFeeStrategy = {
+    name: 'Competitive (P75 + History) - Blob Txs Only',
+    id: 'p75_pending_txs_and_history_blob_txs_only',
+    async execute (client, context) {
+        const { isBlobTx, logger } = context;
+        // Fire all RPC calls in parallel
+        const [latestBlockResult, blobBaseFeeResult, networkEstimateResult, pendingBlockResult, feeHistoryResult] = await Promise.allSettled([
+            client.getBlock({
+                blockTag: 'latest'
+            }),
+            isBlobTx ? client.getBlobBaseFee() : Promise.resolve(undefined),
+            client.estimateMaxPriorityFeePerGas().catch(()=>0n),
+            client.getBlock({
+                blockTag: 'pending',
+                includeTransactions: true
+            }).catch(()=>null),
+            isBlobTx ? getBlobPriorityFeeHistory(client, HISTORICAL_BLOCK_COUNT, [
+                75
+            ]) : client.getFeeHistory({
+                blockCount: HISTORICAL_BLOCK_COUNT,
+                rewardPercentiles: [
+                    75
+                ],
+                blockTag: 'latest'
+            }).catch(()=>null)
+        ]);
+        // Extract latest block (required)
+        if (latestBlockResult.status === 'rejected') {
+            throw new Error(`Failed to get latest block: ${latestBlockResult.reason}`);
+        }
+        const latestBlock = latestBlockResult.value;
+        // Extract blob base fee (only for blob txs)
+        let blobBaseFee;
+        if (isBlobTx) {
+            if (blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
+                blobBaseFee = blobBaseFeeResult.value;
+            } else {
+                logger?.warn('Failed to get L1 blob base fee');
+            }
+        }
+        // Extract network estimate
+        const networkEstimate = networkEstimateResult.status === 'fulfilled' && typeof networkEstimateResult.value === 'bigint' ? networkEstimateResult.value : 0n;
+        let competitiveFee = networkEstimate;
+        const debugInfo = {
+            networkEstimateGwei: formatGwei(networkEstimate)
+        };
+        // Extract pending block
+        const pendingBlock = pendingBlockResult.status === 'fulfilled' ? pendingBlockResult.value : null;
+        // Analyze pending block transactions
+        if (pendingBlock?.transactions && pendingBlock.transactions.length > 0) {
+            const pendingFees = pendingBlock.transactions.map((tx)=>{
+                if (typeof tx === 'string') {
+                    return 0n;
+                }
+                if (isBlobTx) {
+                    if (!isBlobTransaction(tx)) {
+                        return 0n;
+                    }
+                }
+                return tx.maxPriorityFeePerGas || 0n;
+            }).filter((fee)=>fee > 0n);
+            if (pendingFees.length > 0) {
+                const pendingCompetitiveFee = calculatePercentile(pendingFees, 75);
+                if (pendingCompetitiveFee > competitiveFee) {
+                    competitiveFee = pendingCompetitiveFee;
+                }
+                debugInfo.pendingTxCount = pendingFees.length;
+                debugInfo.pendingP75Gwei = formatGwei(pendingCompetitiveFee);
+                logger?.debug('Analyzed pending transactions for competitive pricing', {
+                    pendingTxCount: pendingFees.length,
+                    pendingP75: formatGwei(pendingCompetitiveFee)
+                });
+            }
+        }
+        // Extract fee history
+        const feeHistory = feeHistoryResult.status === 'fulfilled' ? feeHistoryResult.value : null;
+        // Analyze fee history
+        if (feeHistory?.reward && feeHistory.reward.length > 0) {
+            // 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) {
+                    logger?.warn('Suspicious high fee in history', {
+                        historicalMedian: formatGwei(medianHistoricalFee),
+                        allP75Fees: percentile75Fees.map((f)=>formatGwei(f))
+                    });
+                }
+                if (medianHistoricalFee > competitiveFee) {
+                    competitiveFee = medianHistoricalFee;
+                }
+                debugInfo.historicalMedianGwei = formatGwei(medianHistoricalFee);
+                logger?.debug('Analyzed fee history for competitive pricing', {
+                    historicalMedian: formatGwei(medianHistoricalFee)
+                });
+            }
+        }
+        // Log final decision
+        if (competitiveFee > networkEstimate) {
+            logger?.debug('Using competitive fee from market analysis', {
+                networkEstimate: formatGwei(networkEstimate),
+                competitive: formatGwei(competitiveFee)
+            });
+        }
+        debugInfo.finalFeeGwei = formatGwei(competitiveFee);
+        return {
+            priorityFee: competitiveFee,
+            latestBlock,
+            blobBaseFee,
+            debugInfo
+        };
+    }
+};

package/dest/l1_tx_utils/fee-strategies/types.d.ts

@@ -0,0 +1,51 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { Block } from 'viem';
+import type { ViemClient } from '../../types.js';
+import type { L1TxUtilsConfig } from '../config.js';
+/**
+ * Historical block count for fee history queries
+ */
+export declare const HISTORICAL_BLOCK_COUNT = 5;
+/**
+ * Result from a priority fee strategy calculation
+ */
+export interface PriorityFeeStrategyResult {
+    /** The calculated priority fee in wei */
+    priorityFee: bigint;
+    /** The latest block (fetched as part of the strategy) */
+    latestBlock: Block;
+    /** The blob base fee (only present for blob transactions) */
+    blobBaseFee?: bigint;
+    /** Optional debug info about how the fee was calculated */
+    debugInfo?: Record<string, string | number>;
+}
+/**
+ * Context passed to the strategy function
+ */
+export interface PriorityFeeStrategyContext {
+    /** Gas configuration */
+    gasConfig: L1TxUtilsConfig;
+    /** Whether this is for a blob transaction */
+    isBlobTx: boolean;
+    /** Logger for debugging */
+    logger?: Logger;
+}
+/**
+ * A strategy for calculating the priority fee for L1 transactions.
+ * The function handles all RPC calls and returns
+ * the priority fee, along with any block data needed by the caller.
+ */
+export type PriorityFeeStrategy = {
+    /** Human-readable name for logging */
+    name: string;
+    /** Unique identifier for metrics */
+    id: string;
+    /**
+     * Calculate the priority fee.
+     * @param client - The viem client to use for RPC calls
+     * @param context - Contains gas config, whether it's a blob tx, and logger
+     * @returns The calculated priority fee result including block data
+     */
+    execute: (client: ViemClient, context: PriorityFeeStrategyContext) => Promise<PriorityFeeStrategyResult>;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9sMV90eF91dGlscy9mZWUtc3RyYXRlZ2llcy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFbEMsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDakQsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRXBEOztHQUVHO0FBQ0gsZUFBTyxNQUFNLHNCQUFzQixJQUFJLENBQUM7QUFFeEM7O0dBRUc7QUFDSCxNQUFNLFdBQVcseUJBQXlCO0lBQ3hDLHlDQUF5QztJQUN6QyxXQUFXLEVBQUUsTUFBTSxDQUFDO0lBQ3BCLHlEQUF5RDtJQUN6RCxXQUFXLEVBQUUsS0FBSyxDQUFDO0lBQ25CLDZEQUE2RDtJQUM3RCxXQUFXLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDckIsMkRBQTJEO0lBQzNELFNBQVMsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0FBQyxDQUFDO0NBQzdDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsMEJBQTBCO0lBQ3pDLHdCQUF3QjtJQUN4QixTQUFTLEVBQUUsZUFBZSxDQUFDO0lBQzNCLDZDQUE2QztJQUM3QyxRQUFRLEVBQUUsT0FBTyxDQUFDO0lBQ2xCLDJCQUEyQjtJQUMzQixNQUFNLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDakI7QUFFRDs7OztHQUlHO0FBQ0gsTUFBTSxNQUFNLG1CQUFtQixHQUFHO0lBQ2hDLHNDQUFzQztJQUN0QyxJQUFJLEVBQUUsTUFBTSxDQUFDO0lBQ2Isb0NBQW9DO0lBQ3BDLEVBQUUsRUFBRSxNQUFNLENBQUM7SUFDWDs7Ozs7T0FLRztJQUNILE9BQU8sRUFBRSxDQUFDLE1BQU0sRUFBRSxVQUFVLEVBQUUsT0FBTyxFQUFFLDBCQUEwQixLQUFLLE9BQU8sQ0FBQyx5QkFBeUIsQ0FBQyxDQUFDO0NBQzFHLENBQUMifQ==

package/dest/l1_tx_utils/fee-strategies/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/l1_tx_utils/fee-strategies/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,WAAW,EAAE,KAAK,CAAC;IACnB,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,wBAAwB;IACxB,SAAS,EAAE,eAAe,CAAC;IAC3B,6CAA6C;IAC7C,QAAQ,EAAE,OAAO,CAAC;IAClB,2BAA2B;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,EAAE,EAAE,MAAM,CAAC;IACX;;;;;OAKG;IACH,OAAO,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,0BAA0B,KAAK,OAAO,CAAC,yBAAyB,CAAC,CAAC;CAC1G,CAAC"}

package/dest/l1_tx_utils/fee-strategies/types.js

@@ -0,0 +1,3 @@
+/**
+ * Historical block count for fee history queries
+ */ export const HISTORICAL_BLOCK_COUNT = 5;

package/dest/l1_tx_utils/forwarder_l1_tx_utils.d.ts

@@ -0,0 +1,41 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { EthSigner } from '../eth-signer/eth-signer.js';
+import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
+import type { L1TxUtilsConfig } from './config.js';
+import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
+import { L1TxUtilsWithBlobs } from './l1_tx_utils_with_blobs.js';
+import type { L1BlobInputs, L1TxConfig, L1TxRequest, SigningCallback } from './types.js';
+/**
+ * Extends L1TxUtilsWithBlobs to wrap all transactions through a forwarder contract.
+ * This is mainly used for testing the archiver's ability to decode transactions that go through proxies.
+ */
+export declare class ForwarderL1TxUtils extends L1TxUtilsWithBlobs {
+    private readonly forwarderAddress;
+    constructor(client: ViemClient | ExtendedViemWalletClient, senderAddress: EthAddress, signingCallback: SigningCallback, logger: Logger | undefined, dateProvider: DateProvider | undefined, config: Partial<L1TxUtilsConfig>, debugMaxGasLimit: boolean, store: IL1TxStore | undefined, metrics: IL1TxMetrics | undefined, forwarderAddress: EthAddress);
+    /**
+     * Wraps the transaction request in a call to the forwarder contract.
+     */
+    private wrapInForwarder;
+    /**
+     * Override sendAndMonitorTransaction to wrap the request in a forwarder call.
+     */
+    sendAndMonitorTransaction(request: L1TxRequest, gasConfig?: L1TxConfig, blobInputs?: L1BlobInputs): Promise<{
+        receipt: import("viem").TransactionReceipt;
+        state: import("./types.js").L1TxState;
+    }>;
+}
+export declare function createForwarderL1TxUtilsFromViemWallet(client: ExtendedViemWalletClient, forwarderAddress: EthAddress, deps?: {
+    logger?: Logger;
+    dateProvider?: DateProvider;
+    store?: IL1TxStore;
+    metrics?: IL1TxMetrics;
+}, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean): ForwarderL1TxUtils;
+export declare function createForwarderL1TxUtilsFromEthSigner(client: ViemClient, signer: EthSigner, forwarderAddress: EthAddress, deps?: {
+    logger?: Logger;
+    dateProvider?: DateProvider;
+    store?: IL1TxStore;
+    metrics?: IL1TxMetrics;
+}, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean): ForwarderL1TxUtils;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"forwarder_l1_tx_utils.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/forwarder_l1_tx_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAI5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEzF;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,kBAAkB;IAWtD,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAVnC,YACE,MAAM,EAAE,UAAU,GAAG,wBAAwB,EAC7C,aAAa,EAAE,UAAU,EACzB,eAAe,EAAE,eAAe,EAChC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,YAAY,EAAE,YAAY,GAAG,SAAS,EACtC,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,EAChC,gBAAgB,EAAE,OAAO,EACzB,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,OAAO,EAAE,YAAY,GAAG,SAAS,EAChB,gBAAgB,EAAE,UAAU,EAG9C;IAED;;OAEG;IACH,OAAO,CAAC,eAAe;IAevB;;OAEG;IACa,yBAAyB,CAAC,OAAO,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,YAAY;;;OAIhH;CACF;AAED,wBAAgB,sCAAsC,CACpD,MAAM,EAAE,wBAAwB,EAChC,gBAAgB,EAAE,UAAU,EAC5B,IAAI,GAAE;IACJ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,OAAO,CAAC,EAAE,YAAY,CAAC;CACnB,EACN,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM,EACrC,gBAAgB,GAAE,OAAe,sBAclC;AAED,wBAAgB,qCAAqC,CACnD,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,SAAS,EACjB,gBAAgB,EAAE,UAAU,EAC5B,IAAI,GAAE;IACJ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,OAAO,CAAC,EAAE,YAAY,CAAC;CACnB,EACN,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM,EACrC,gBAAgB,GAAE,OAAe,sBAkBlC"}

package/dest/l1_tx_utils/forwarder_l1_tx_utils.js

@@ -0,0 +1,48 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { encodeFunctionData } from 'viem';
+import { FORWARDER_ABI } from '../forwarder_proxy.js';
+import { L1TxUtilsWithBlobs } from './l1_tx_utils_with_blobs.js';
+import { createViemSigner } from './signer.js';
+/**
+ * Extends L1TxUtilsWithBlobs to wrap all transactions through a forwarder contract.
+ * This is mainly used for testing the archiver's ability to decode transactions that go through proxies.
+ */ export class ForwarderL1TxUtils extends L1TxUtilsWithBlobs {
+    forwarderAddress;
+    constructor(client, senderAddress, signingCallback, logger, dateProvider, config, debugMaxGasLimit, store, metrics, forwarderAddress){
+        super(client, senderAddress, signingCallback, logger, dateProvider, config, debugMaxGasLimit, store, metrics), this.forwarderAddress = forwarderAddress;
+    }
+    /**
+   * Wraps the transaction request in a call to the forwarder contract.
+   */ wrapInForwarder(request) {
+        const forwarderCalldata = encodeFunctionData({
+            abi: FORWARDER_ABI,
+            functionName: 'forward',
+            args: [
+                request.to,
+                request.data
+            ]
+        });
+        return {
+            to: this.forwarderAddress.toString(),
+            data: forwarderCalldata,
+            value: request.value,
+            abi: request.abi
+        };
+    }
+    /**
+   * Override sendAndMonitorTransaction to wrap the request in a forwarder call.
+   */ sendAndMonitorTransaction(request, gasConfig, blobInputs) {
+        this.logger.debug(`Wrapping transaction to ${request.to} in forwarder at ${this.forwarderAddress.toString()}`);
+        const wrappedRequest = this.wrapInForwarder(request);
+        return super.sendAndMonitorTransaction(wrappedRequest, gasConfig, blobInputs);
+    }
+}
+export function createForwarderL1TxUtilsFromViemWallet(client, forwarderAddress, deps = {}, config = {}, debugMaxGasLimit = false) {
+    return new ForwarderL1TxUtils(client, EthAddress.fromString(client.account.address), createViemSigner(client), deps.logger, deps.dateProvider, config, debugMaxGasLimit, deps.store, deps.metrics, forwarderAddress);
+}
+export function createForwarderL1TxUtilsFromEthSigner(client, signer, forwarderAddress, deps = {}, config = {}, debugMaxGasLimit = false) {
+    const callback = async (transaction, _signingAddress)=>{
+        return (await signer.signTransaction(transaction)).toViemTransactionSignature();
+    };
+    return new ForwarderL1TxUtils(client, signer.address, callback, deps.logger, deps.dateProvider, config, debugMaxGasLimit, deps.store, deps.metrics, forwarderAddress);
+}

package/dest/l1_tx_utils/index-blobs.d.ts

@@ -0,0 +1,3 @@
+export * from './forwarder_l1_tx_utils.js';
+export * from './l1_tx_utils_with_blobs.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXgtYmxvYnMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sMV90eF91dGlscy9pbmRleC1ibG9icy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsNkJBQTZCLENBQUMifQ==

package/dest/l1_tx_utils/index-blobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-blobs.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/index-blobs.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC"}

package/dest/l1_tx_utils/index-blobs.js

@@ -0,0 +1,2 @@
+export * from './forwarder_l1_tx_utils.js';
+export * from './l1_tx_utils_with_blobs.js';

package/dest/l1_tx_utils/index.d.ts

@@ -0,0 +1,12 @@
+export * from './config.js';
+export * from './constants.js';
+export * from './factory.js';
+export * from './fee-strategies/index.js';
+export * from './interfaces.js';
+export * from './l1_fee_analyzer.js';
+export * from './l1_tx_utils.js';
+export * from './readonly_l1_tx_utils.js';
+export * from './signer.js';
+export * from './types.js';
+export * from './utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sMV90eF91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFlBQVksQ0FBQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/dest/l1_tx_utils/index.js

@@ -0,0 +1,12 @@
+export * from './config.js';
+export * from './constants.js';
+export * from './factory.js';
+export * from './fee-strategies/index.js';
+export * from './interfaces.js';
+export * from './l1_fee_analyzer.js';
+export * from './l1_tx_utils.js';
+export * from './readonly_l1_tx_utils.js';
+export * from './signer.js';
+export * from './types.js';
+export * from './utils.js'; // Note: We intentionally do not export l1_tx_utils_with_blobs.js
+ // to avoid accidentally importing blob-lib dependency.

package/dest/l1_tx_utils/interfaces.d.ts

@@ -0,0 +1,76 @@
+import type { L1BlobInputs, L1TxState } from './types.js';
+/**
+ * Interface for L1 transaction state storage.
+ * Implementations handle persistence of transaction states across restarts.
+ */
+export interface IL1TxStore {
+    /**
+     * Gets the next available state ID for an account.
+     */
+    consumeNextStateId(account: string): Promise<number>;
+    /**
+     * Saves a single transaction state for a specific account.
+     * Does not save blob data (see saveBlobs).
+     * @param account - The sender account address
+     * @param state - Transaction state to save
+     */
+    saveState(account: string, state: L1TxState): Promise<L1TxState>;
+    /**
+     * Saves blobs for a given state.
+     * @param account - The sender account address
+     * @param stateId - The state ID
+     * @param blobInputs - Blob inputs to save
+     */
+    saveBlobs(account: string, stateId: number, blobInputs: L1BlobInputs | undefined): Promise<void>;
+    /**
+     * Loads all transaction states for a specific account.
+     * @param account - The sender account address
+     * @returns Array of transaction states with their IDs
+     */
+    loadStates(account: string): Promise<L1TxState[]>;
+    /**
+     * Loads a single state by ID.
+     * @param account - The sender account address
+     * @param stateId - The state ID
+     * @returns The transaction state or undefined if not found
+     */
+    loadState(account: string, stateId: number): Promise<L1TxState | undefined>;
+    /**
+     * Deletes a specific state and its associated blobs.
+     * @param account - The sender account address
+     * @param stateId - The state ID to delete
+     */
+    deleteState(account: string, ...stateId: number[]): Promise<void>;
+    /**
+     * Clears all transaction states for a specific account.
+     * @param account - The sender account address
+     */
+    clearStates(account: string): Promise<void>;
+    /**
+     * Gets all accounts that have stored states.
+     * @returns Array of account addresses
+     */
+    getAllAccounts(): Promise<string[]>;
+    /**
+     * Closes the store.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Interface for L1 transaction metrics recording.
+ * Implementations handle tracking of transaction lifecycle and gas costs.
+ */
+export interface IL1TxMetrics {
+    /**
+     * Records metrics when a transaction is mined
+     * @param state - The L1 transaction state
+     * @param l1Timestamp - The current L1 timestamp
+     */
+    recordMinedTx(state: L1TxState, l1Timestamp: Date): void;
+    /**
+     * Records metrics when a transaction is dropped
+     * @param state - The L1 transaction state
+     */
+    recordDroppedTx(state: L1TxState): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2wxX3R4X3V0aWxzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUUxRDs7O0dBR0c7QUFDSCxNQUFNLFdBQVcsVUFBVTtJQUN6Qjs7T0FFRztJQUNILGtCQUFrQixDQUFDLE9BQU8sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRXJEOzs7OztPQUtHO0lBQ0gsU0FBUyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLFNBQVMsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUM7SUFFakU7Ozs7O09BS0c7SUFDSCxTQUFTLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxZQUFZLEdBQUcsU0FBUyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUVqRzs7OztPQUlHO0lBQ0gsVUFBVSxDQUFDLE9BQU8sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFFbEQ7Ozs7O09BS0c7SUFDSCxTQUFTLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDLENBQUM7SUFFNUU7Ozs7T0FJRztJQUNILFdBQVcsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEdBQUcsT0FBTyxFQUFFLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUVsRTs7O09BR0c7SUFDSCxXQUFXLENBQUMsT0FBTyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7SUFFNUM7OztPQUdHO0lBQ0gsY0FBYyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBRXBDOztPQUVHO0lBQ0gsS0FBSyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztDQUN4QjtBQUVEOzs7R0FHRztBQUNILE1BQU0sV0FBVyxZQUFZO0lBQzNCOzs7O09BSUc7SUFDSCxhQUFhLENBQUMsS0FBSyxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsSUFBSSxHQUFHLElBQUksQ0FBQztJQUV6RDs7O09BR0c7SUFDSCxlQUFlLENBQUMsS0FBSyxFQUFFLFNBQVMsR0FBRyxJQUFJLENBQUM7Q0FDekMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAErD;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAEjE;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjG;;;;OAIG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAElD;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IAE5E;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElE;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5C;;;OAGG;IACH,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEpC;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IAEzD;;;OAGG;IACH,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CACzC"}

package/dest/l1_tx_utils/interfaces.js

@@ -0,0 +1,4 @@
+/**
+ * Interface for L1 transaction metrics recording.
+ * Implementations handle tracking of transaction lifecycle and gas costs.
+ */ export { };