@aztec/ethereum 3.0.0-canary.a9708bd → 3.0.0-devnet.20251212

package/dest/l1_tx_utils/l1_tx_utils_with_blobs.js

@@ -0,0 +1,26 @@
+import { Blob } from '@aztec/blob-lib';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { L1TxUtils } from './l1_tx_utils.js';
+import { createViemSigner } from './signer.js';
+/** Extends L1TxUtils with the capability to cancel blobs. This needs to be a separate class so we don't require a dependency on blob-lib unnecessarily. */ export class L1TxUtilsWithBlobs extends L1TxUtils {
+    /** Makes empty blob inputs for the cancellation tx. */ makeEmptyBlobInputs(maxFeePerBlobGas) {
+        const blobData = new Uint8Array(131072).fill(0);
+        const kzg = Blob.getViemKzgInstance();
+        return {
+            blobs: [
+                blobData
+            ],
+            kzg,
+            maxFeePerBlobGas
+        };
+    }
+}
+export function createL1TxUtilsWithBlobsFromViemWallet(client, deps = {}, config = {}, debugMaxGasLimit = false) {
+    return new L1TxUtilsWithBlobs(client, EthAddress.fromString(client.account.address), createViemSigner(client), deps.logger, deps.dateProvider, config, debugMaxGasLimit, deps.store, deps.metrics);
+}
+export function createL1TxUtilsWithBlobsFromEthSigner(client, signer, deps = {}, config = {}, debugMaxGasLimit = false) {
+    const callback = async (transaction, _signingAddress)=>{
+        return (await signer.signTransaction(transaction)).toViemTransactionSignature();
+    };
+    return new L1TxUtilsWithBlobs(client, signer.address, callback, deps.logger, deps.dateProvider, config, debugMaxGasLimit, deps.store, deps.metrics);
+}

package/dest/l1_tx_utils/readonly_l1_tx_utils.d.ts

@@ -0,0 +1,94 @@
+import { type Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { type Abi, type Account, type BlockOverrides, type Hex, type StateOverride } from 'viem';
+import type { ViemClient } from '../types.js';
+import { type L1TxUtilsConfig } from './config.js';
+import type { GasPrice, L1BlobInputs, L1TxRequest, TransactionStats } from './types.js';
+export declare class ReadOnlyL1TxUtils {
+    client: ViemClient;
+    protected logger: Logger;
+    readonly dateProvider: DateProvider;
+    protected debugMaxGasLimit: boolean;
+    config: Required<L1TxUtilsConfig>;
+    protected interrupted: boolean;
+    constructor(client: ViemClient, logger: Logger | undefined, dateProvider: DateProvider, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean);
+    interrupt(): void;
+    restart(): void;
+    getBlock(): Promise<{
+        baseFeePerGas: bigint | null;
+        blobGasUsed: bigint;
+        difficulty: bigint;
+        excessBlobGas: bigint;
+        extraData: `0x${string}`;
+        gasLimit: bigint;
+        gasUsed: bigint;
+        hash: `0x${string}`;
+        logsBloom: `0x${string}`;
+        miner: `0x${string}`;
+        mixHash: `0x${string}`;
+        nonce: `0x${string}`;
+        number: bigint;
+        parentBeaconBlockRoot?: `0x${string}` | undefined;
+        parentHash: `0x${string}`;
+        receiptsRoot: `0x${string}`;
+        sealFields: `0x${string}`[];
+        sha3Uncles: `0x${string}`;
+        size: bigint;
+        stateRoot: `0x${string}`;
+        timestamp: bigint;
+        totalDifficulty: bigint | null;
+        transactionsRoot: `0x${string}`;
+        uncles: `0x${string}`[];
+        withdrawals?: import("viem").Withdrawal[] | undefined;
+        withdrawalsRoot?: `0x${string}` | undefined;
+        transactions: `0x${string}`[];
+    }>;
+    getBlockNumber(): Promise<bigint>;
+    /**
+     * 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
+     */
+    protected getCompetitivePriorityFee(networkEstimateResult: PromiseSettledResult<bigint | null>, pendingBlockResult: PromiseSettledResult<Awaited<ReturnType<ViemClient['getBlock']>> | null>, feeHistoryResult: PromiseSettledResult<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>): bigint;
+    /**
+     * Gets the current gas price with bounds checking
+     */
+    getGasPrice(gasConfigOverrides?: L1TxUtilsConfig, isBlobTx?: boolean, attempt?: number, previousGasPrice?: typeof attempt extends 0 ? never : GasPrice): Promise<GasPrice>;
+    /**
+     * Estimates gas and adds buffer
+     */
+    estimateGas(account: Account | Hex, request: L1TxRequest, _gasConfig?: L1TxUtilsConfig, _blobInputs?: L1BlobInputs): Promise<bigint>;
+    getTransactionStats(txHash: string): Promise<TransactionStats | undefined>;
+    tryGetErrorFromRevertedTx(data: Hex, args: {
+        args: readonly any[];
+        functionName: string;
+        abi: Abi;
+        address: Hex;
+    }, blobInputs: (L1BlobInputs & {
+        maxFeePerBlobGas: bigint;
+    }) | undefined, stateOverride?: StateOverride): Promise<string | undefined>;
+    simulate(request: L1TxRequest & {
+        gas?: bigint;
+        from?: Hex;
+    }, blockOverrides?: BlockOverrides<bigint, number>, stateOverrides?: StateOverride, abi?: Abi, _gasConfig?: L1TxUtilsConfig & {
+        fallbackGasEstimate?: bigint;
+    }): Promise<{
+        gasUsed: bigint;
+        result: `0x${string}`;
+    }>;
+    protected _simulate(call: any, blockOverrides: BlockOverrides<bigint, number> | undefined, stateOverrides: StateOverride | undefined, gasConfig: L1TxUtilsConfig & {
+        fallbackGasEstimate?: bigint;
+    }, abi: Abi): Promise<{
+        gasUsed: bigint;
+        result: `0x${string}`;
+    }>;
+    bumpGasLimit(gasLimit: bigint, _gasConfig?: L1TxUtilsConfig): bigint;
+    /**
+     * Helper function to retry RPC calls twice
+     */
+    private tryTwice;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"readonly_l1_tx_utils.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/readonly_l1_tx_utils.ts"],"names":[],"mappings":"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"}

package/dest/l1_tx_utils/readonly_l1_tx_utils.js

@@ -0,0 +1,431 @@
+import { getKeys, median, merge, pick, times } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+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 { getCalldataGasUsage, tryGetCustomErrorNameContractFunction } from './utils.js';
+const HISTORICAL_BLOCK_COUNT = 5;
+export class ReadOnlyL1TxUtils {
+    client;
+    logger;
+    dateProvider;
+    debugMaxGasLimit;
+    config;
+    interrupted;
+    constructor(client, logger = createLogger('ethereum:readonly-l1-utils'), dateProvider, config, debugMaxGasLimit = false){
+        this.client = client;
+        this.logger = logger;
+        this.dateProvider = dateProvider;
+        this.debugMaxGasLimit = debugMaxGasLimit;
+        this.interrupted = false;
+        this.config = merge(defaultL1TxUtilsConfig, pick(config || {}, ...getKeys(l1TxUtilsConfigMappings)));
+    }
+    interrupt() {
+        this.interrupted = true;
+    }
+    restart() {
+        this.interrupted = false;
+    }
+    getBlock() {
+        return this.client.getBlock();
+    }
+    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;
+    }
+    /**
+   * 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 = this.tryTwice(()=>this.client.estimateMaxPriorityFeePerGas(), 'Estimating max priority fee per gas');
+        const pendingBlockPromise = this.tryTwice(()=>this.client.getBlock({
+                blockTag: 'pending',
+                includeTransactions: true
+            }), 'Getting pending block');
+        const feeHistoryPromise = 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,
+            pendingBlockPromise,
+            feeHistoryPromise,
+            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) {
+            this.logger?.warn('Failed to get L1 blob base fee', attempt);
+        }
+        // Get competitive priority fee
+        let priorityFee = this.getCompetitivePriorityFee(networkEstimateResult, pendingBlockResult, feeHistoryResult);
+        // Apply minimum priority fee as a floor if configured
+        if (gasConfig.minimumPriorityFeePerGas) {
+            const minimumFee = BigInt(Math.trunc(gasConfig.minimumPriorityFeePerGas * Number(WEI_CONST)));
+            if (minimumFee > priorityFee) {
+                this.logger?.debug('Using minimum priority fee as floor', {
+                    minimumPriorityFeePerGas: formatGwei(minimumFee),
+                    competitiveFee: formatGwei(priorityFee)
+                });
+                priorityFee = minimumFee;
+            } else {
+                this.logger?.debug('Competitive fee exceeds minimum, using competitive fee', {
+                    minimumPriorityFeePerGas: formatGwei(minimumFee),
+                    competitiveFee: formatGwei(priorityFee)
+                });
+            }
+        }
+        let maxFeePerGas = baseFee;
+        let maxFeePerBlobGas = blobBaseFee;
+        // 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;
+            // same for blob gas fee
+            maxFeePerBlobGas = maxFeePerBlobGas * (1_000n + 125n) / 1_000n;
+        }
+        if (attempt > 0) {
+            const configBump = gasConfig.priorityFeeRetryBumpPercentage ?? defaultL1TxUtilsConfig.priorityFeeRetryBumpPercentage;
+            // if this is a blob tx, we have to use the blob bump percentage
+            const minBumpPercentage = isBlobTx ? MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE : MIN_REPLACEMENT_BUMP_PERCENTAGE;
+            const bumpPercentage = configBump > minBumpPercentage ? configBump : minBumpPercentage;
+            // Calculate minimum required fees based on previous attempt
+            // 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;
+            // 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';
+            priorityFee = finalPriorityFee;
+            // Add the final priority fee to maxFeePerGas
+            maxFeePerGas += finalPriorityFee;
+            maxFeePerGas = maxFeePerGas > minMaxFee ? maxFeePerGas : minMaxFee;
+            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
+            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 = 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;
+        }
+        // Ensure we don't exceed maxBlobGwei
+        if (maxFeePerBlobGas && effectiveMaxBlobGwei > 0n) {
+            maxFeePerBlobGas = maxFeePerBlobGas > effectiveMaxBlobGwei ? effectiveMaxBlobGwei : maxFeePerBlobGas;
+        }
+        // Ensure priority fee doesn't exceed max fee
+        const maxPriorityFeePerGas = priorityFee > maxFeePerGas ? maxFeePerGas : priorityFee;
+        if (attempt > 0 && previousGasPrice?.maxFeePerBlobGas) {
+            const bumpPercentage = gasConfig.priorityFeeRetryBumpPercentage > MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE ? gasConfig.priorityFeeRetryBumpPercentage : MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE;
+            // calculate min blob fee based on previous attempt
+            const minBlobFee = previousGasPrice.maxFeePerBlobGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
+            // use max between current network values and min required values
+            maxFeePerBlobGas = maxFeePerBlobGas > minBlobFee ? maxFeePerBlobGas : minBlobFee;
+        }
+        this.logger?.trace(`Computed L1 gas price max fee ${formatGwei(maxFeePerGas)} and max priority fee ${formatGwei(maxPriorityFeePerGas)}`, {
+            attempt,
+            baseFee: formatGwei(baseFee),
+            maxFeePerGas: formatGwei(maxFeePerGas),
+            maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
+            blobBaseFee: formatGwei(blobBaseFee),
+            maxFeePerBlobGas: formatGwei(maxFeePerBlobGas)
+        });
+        return {
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            ...maxFeePerBlobGas && {
+                maxFeePerBlobGas: maxFeePerBlobGas
+            }
+        };
+    }
+    /**
+   * Estimates gas and adds buffer
+   */ async estimateGas(account, request, _gasConfig, _blobInputs) {
+        const gasConfig = {
+            ...this.config,
+            ..._gasConfig
+        };
+        let initialEstimate = 0n;
+        if (_blobInputs) {
+            // @note requests with blobs also require maxFeePerBlobGas to be set
+            const gasPrice = await this.getGasPrice(gasConfig, true, 0);
+            initialEstimate = await this.client.estimateGas({
+                account,
+                ...request,
+                ..._blobInputs,
+                maxFeePerBlobGas: gasPrice.maxFeePerBlobGas,
+                gas: LARGE_GAS_LIMIT
+            });
+            this.logger?.trace(`Estimated gas for blob tx: ${initialEstimate}`);
+        } else {
+            initialEstimate = await this.client.estimateGas({
+                account,
+                ...request,
+                gas: LARGE_GAS_LIMIT
+            });
+            this.logger?.trace(`Estimated gas for non-blob tx: ${initialEstimate}`);
+        }
+        // Add buffer based on either fixed amount or percentage
+        const withBuffer = this.bumpGasLimit(initialEstimate, gasConfig);
+        return withBuffer;
+    }
+    async getTransactionStats(txHash) {
+        const tx = await this.client.getTransaction({
+            hash: txHash
+        });
+        if (!tx) {
+            return undefined;
+        }
+        const calldata = hexToBytes(tx.input);
+        return {
+            sender: tx.from.toString(),
+            transactionHash: tx.hash,
+            calldataSize: calldata.length,
+            calldataGas: getCalldataGasUsage(calldata)
+        };
+    }
+    async tryGetErrorFromRevertedTx(data, args, blobInputs, stateOverride = []) {
+        try {
+            await this.client.simulateContract({
+                ...args,
+                account: this.client.account,
+                stateOverride
+            });
+            this.logger?.trace('Simulated blob tx', {
+                blobInputs
+            });
+            // If the above passes, we have a blob error. We cannot simulate blob txs, and failed txs no longer throw errors.
+            // Strangely, the only way to throw the revert reason as an error and provide blobs is prepareTransactionRequest.
+            // See: https://github.com/wevm/viem/issues/2075
+            // This throws a EstimateGasExecutionError with the custom error information:
+            const request = blobInputs ? {
+                account: this.client.account,
+                to: args.address,
+                data,
+                blobs: blobInputs.blobs,
+                kzg: blobInputs.kzg,
+                maxFeePerBlobGas: blobInputs.maxFeePerBlobGas
+            } : {
+                account: this.client.account,
+                to: args.address,
+                data
+            };
+            this.logger?.trace('Preparing tx', {
+                request
+            });
+            await this.client.prepareTransactionRequest(request);
+            this.logger?.trace('Prepared tx');
+            return undefined;
+        } catch (simulationErr) {
+            // If we don't have a ContractFunctionExecutionError, we have a blob related error => use getContractError to get the error msg.
+            const contractErr = simulationErr.name === 'ContractFunctionExecutionError' ? simulationErr : getContractError(simulationErr, {
+                args: [],
+                abi: args.abi,
+                functionName: args.functionName,
+                address: args.address
+            });
+            if (contractErr.name === 'ContractFunctionExecutionError') {
+                const execErr = contractErr;
+                return tryGetCustomErrorNameContractFunction(execErr);
+            }
+            this.logger?.error(`Error getting error from simulation`, simulationErr);
+        }
+    }
+    async simulate(request, blockOverrides = {}, stateOverrides = [], abi = RollupAbi, _gasConfig) {
+        const gasConfig = {
+            ...this.config,
+            ..._gasConfig
+        };
+        const call = {
+            to: request.to,
+            data: request.data,
+            ...request.from && {
+                from: request.from
+            }
+        };
+        return await this._simulate(call, blockOverrides, stateOverrides, gasConfig, abi);
+    }
+    async _simulate(call, blockOverrides = {}, stateOverrides = [], gasConfig, abi) {
+        try {
+            const result = await this.client.simulateBlocks({
+                validation: false,
+                blocks: [
+                    {
+                        blockOverrides,
+                        stateOverrides,
+                        calls: [
+                            call
+                        ]
+                    }
+                ]
+            });
+            if (result[0].calls[0].status === 'failure') {
+                this.logger?.error('L1 transaction simulation failed', result[0].calls[0].error);
+                const decodedError = decodeErrorResult({
+                    abi,
+                    data: result[0].calls[0].data
+                });
+                throw new Error(`L1 transaction simulation failed with error ${decodedError.errorName}(${decodedError.args?.join(',')})`);
+            }
+            this.logger?.debug(`L1 transaction simulation succeeded`, {
+                ...result[0].calls[0]
+            });
+            return {
+                gasUsed: result[0].gasUsed,
+                result: result[0].calls[0].data
+            };
+        } catch (err) {
+            if (err instanceof MethodNotFoundRpcError || err instanceof MethodNotSupportedRpcError) {
+                if (gasConfig.fallbackGasEstimate) {
+                    this.logger?.warn(`Node does not support eth_simulateV1 API. Using fallback gas estimate: ${gasConfig.fallbackGasEstimate}`);
+                    return {
+                        gasUsed: gasConfig.fallbackGasEstimate,
+                        result: '0x'
+                    };
+                }
+                this.logger?.error('Node does not support eth_simulateV1 API');
+            }
+            throw err;
+        }
+    }
+    bumpGasLimit(gasLimit, _gasConfig) {
+        const gasConfig = {
+            ...this.config,
+            ..._gasConfig
+        };
+        const bumpedGasLimit = gasLimit + gasLimit * BigInt((gasConfig?.gasLimitBufferPercentage || 0) * 1_00) / 100_00n;
+        const cleanGasConfig = pickBy(gasConfig, (_, key)=>key in l1TxUtilsConfigMappings);
+        this.logger?.trace(`Bumping gas limit from ${gasLimit} to ${bumpedGasLimit}`, {
+            gasLimit,
+            gasConfig: cleanGasConfig,
+            bumpedGasLimit
+        });
+        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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/signer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgC,KAAK,YAAY,EAAoB,MAAM,MAAM,CAAC;AAEzF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,mBAoBpD"}

package/dest/l1_tx_utils/signer.js

@@ -0,0 +1,16 @@
+import { parseTransaction } from 'viem';
+export function createViemSigner(client) {
+    const signer = async (tx, _address)=>{
+        const signedTx = await client.signTransaction(tx);
+        const parsed = parseTransaction(signedTx);
+        if (!parsed.r || !parsed.s || parsed.yParity !== 0 && parsed.yParity !== 1) {
+            throw new Error('Failed to extract signature from viem signed transaction');
+        }
+        return {
+            r: parsed.r,
+            s: parsed.s,
+            yParity: parsed.yParity
+        };
+    };
+    return signer;
+}

package/dest/l1_tx_utils/types.d.ts

@@ -0,0 +1,67 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ViemTransactionSignature } from '@aztec/foundation/eth-signature';
+import type { Abi, Address, Hex, TransactionReceipt, TransactionSerializable } from 'viem';
+import type { L1TxUtilsConfig } from './config.js';
+export interface L1TxRequest {
+    to: Address | null;
+    data?: Hex;
+    value?: bigint;
+    abi?: Abi;
+}
+export type L1TxConfig = Partial<L1TxUtilsConfig> & {
+    gasLimit?: bigint;
+    txTimeoutAt?: Date;
+};
+export interface L1BlobInputs {
+    blobs: Uint8Array[];
+    kzg: BlobKzgInstance;
+    maxFeePerBlobGas?: bigint;
+}
+export interface GasPrice {
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    maxFeePerBlobGas?: bigint;
+}
+export type TransactionStats = {
+    /** Address of the sender. */
+    sender: string;
+    /** Hash of the transaction. */
+    transactionHash: string;
+    /** Size in bytes of the tx calldata */
+    calldataSize: number;
+    /** Gas required to pay for the calldata inclusion (depends on size and number of zeros)  */
+    calldataGas: number;
+};
+export declare enum TxUtilsState {
+    IDLE = 0,
+    SENT = 1,
+    SPEED_UP = 2,
+    CANCELLED = 3,
+    NOT_MINED = 4,
+    MINED = 5
+}
+export declare const TerminalTxUtilsState: TxUtilsState[];
+export type L1TxState = {
+    id: number;
+    txHashes: Hex[];
+    cancelTxHashes: Hex[];
+    gasLimit: bigint;
+    gasPrice: GasPrice;
+    txConfigOverrides: L1TxConfig;
+    request: L1TxRequest;
+    status: TxUtilsState;
+    nonce: number;
+    sentAtL1Ts: Date;
+    lastSentAtL1Ts: Date;
+    receipt?: TransactionReceipt;
+    blobInputs: L1BlobInputs | undefined;
+};
+export type SigningCallback = (transaction: TransactionSerializable, signingAddress: EthAddress) => Promise<ViemTransactionSignature>;
+export declare class UnknownMinedTxError extends Error {
+    constructor(nonce: number, account: string);
+}
+export declare class DroppedTransactionError extends Error {
+    constructor(nonce: number, account: string);
+}
+//# sourceMappingURL=data:application/json;base64,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