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

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<{
+        number: bigint;
+        hash: `0x${string}`;
+        nonce: `0x${string}`;
+        logsBloom: `0x${string}`;
+        baseFeePerGas: bigint | null;
+        blobGasUsed: bigint;
+        difficulty: bigint;
+        excessBlobGas: bigint;
+        extraData: Hex;
+        gasLimit: bigint;
+        gasUsed: bigint;
+        miner: import("viem").Address;
+        mixHash: import("viem").Hash;
+        parentBeaconBlockRoot?: `0x${string}` | undefined;
+        parentHash: import("viem").Hash;
+        receiptsRoot: Hex;
+        sealFields: Hex[];
+        sha3Uncles: import("viem").Hash;
+        size: bigint;
+        stateRoot: import("viem").Hash;
+        timestamp: bigint;
+        totalDifficulty: bigint | null;
+        transactionsRoot: import("viem").Hash;
+        uncles: import("viem").Hash[];
+        withdrawals?: import("viem").Withdrawal[] | undefined | 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=readonly_l1_tx_utils.d.ts.map

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":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAIvD,OAAO,EACL,KAAK,GAAG,EACR,KAAK,OAAO,EAEZ,KAAK,cAAc,EAEnB,KAAK,GAAG,EAGR,KAAK,aAAa,EAKnB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,KAAK,eAAe,EAAmD,MAAM,aAAa,CAAC;AAQpG,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAKxF,qBAAa,iBAAiB;IAKnB,MAAM,EAAE,UAAU;IACzB,SAAS,CAAC,MAAM,EAAE,MAAM;aACR,YAAY,EAAE,YAAY;IAE1C,SAAS,CAAC,gBAAgB,EAAE,OAAO;IAR9B,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IACzC,SAAS,CAAC,WAAW,UAAS;gBAGrB,MAAM,EAAE,UAAU,EACf,MAAM,EAAE,MAAM,YAA6C,EACrD,YAAY,EAAE,YAAY,EAC1C,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,EACvB,gBAAgB,GAAE,OAAe;IAKtC,SAAS;IAIT,OAAO;IAIP,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIR,cAAc;IAIrB;;;;;;;OAOG;IACH,SAAS,CAAC,yBAAyB,CACjC,qBAAqB,EAAE,oBAAoB,CAAC,MAAM,GAAG,IAAI,CAAC,EAC1D,kBAAkB,EAAE,oBAAoB,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAC5F,gBAAgB,EAAE,oBAAoB,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAC9F,MAAM;IA0GT;;OAEG;IACU,WAAW,CACtB,kBAAkB,CAAC,EAAE,eAAe,EACpC,QAAQ,GAAE,OAAe,EACzB,OAAO,GAAE,MAAU,EACnB,gBAAgB,CAAC,EAAE,OAAO,OAAO,SAAS,CAAC,GAAG,KAAK,GAAG,QAAQ,GAC7D,OAAO,CAAC,QAAQ,CAAC;IAkLpB;;OAEG;IACU,WAAW,CACtB,OAAO,EAAE,OAAO,GAAG,GAAG,EACtB,OAAO,EAAE,WAAW,EACpB,UAAU,CAAC,EAAE,eAAe,EAC5B,WAAW,CAAC,EAAE,YAAY,GACzB,OAAO,CAAC,MAAM,CAAC;IA0BZ,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAcnE,yBAAyB,CACpC,IAAI,EAAE,GAAG,EACT,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,GAAG,EAAE,GAAG,CAAC;QACT,OAAO,EAAE,GAAG,CAAC;KACd,EACD,UAAU,EAAE,CAAC,YAAY,GAAG;QAAE,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,SAAS,EACrE,aAAa,GAAE,aAAkB;IAkDtB,QAAQ,CACnB,OAAO,EAAE,WAAW,GAAG;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,GAAG,CAAA;KAAE,EACnD,cAAc,GAAE,cAAc,CAAC,MAAM,EAAE,MAAM,CAAM,EACnD,cAAc,GAAE,aAAkB,EAClC,GAAG,GAAE,GAAe,EACpB,UAAU,CAAC,EAAE,eAAe,GAAG;QAAE,mBAAmB,CAAC,EAAE,MAAM,CAAA;KAAE,GAC9D,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,KAAK,MAAM,EAAE,CAAA;KAAE,CAAC;cAYtC,SAAS,CACvB,IAAI,EAAE,GAAG,EACT,cAAc,EAAE,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,YAAK,EACnD,cAAc,EAAE,aAAa,YAAK,EAClC,SAAS,EAAE,eAAe,GAAG;QAAE,mBAAmB,CAAC,EAAE,MAAM,CAAA;KAAE,EAC7D,GAAG,EAAE,GAAG;;gBAuBkE,KAAK,MAAM,EAAE;;IAelF,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,MAAM;IAa3E;;OAEG;IACH,OAAO,CAAC,QAAQ;CAGjB"}

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 = 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) {
+            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 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;
+            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
+                });
+            }
+            // 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;
+            if (!gasConfig.fixedPriorityFeePerGas) {
+                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)
+                });
+            }
+            maxFeePerGas += priorityFee;
+        }
+        // maxGwei and maxBlobGwei are hard limits
+        const effectiveMaxGwei = gasConfig.maxGwei * WEI_CONST;
+        const effectiveMaxBlobGwei = gasConfig.maxBlobGwei * 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=signer.d.ts.map

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=types.d.ts.map

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

@@ -0,0 +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"}

package/dest/l1_tx_utils/types.js

@@ -0,0 +1,26 @@
+export var TxUtilsState = /*#__PURE__*/ function(TxUtilsState) {
+    TxUtilsState[TxUtilsState["IDLE"] = 0] = "IDLE";
+    TxUtilsState[TxUtilsState["SENT"] = 1] = "SENT";
+    TxUtilsState[TxUtilsState["SPEED_UP"] = 2] = "SPEED_UP";
+    TxUtilsState[TxUtilsState["CANCELLED"] = 3] = "CANCELLED";
+    TxUtilsState[TxUtilsState["NOT_MINED"] = 4] = "NOT_MINED";
+    TxUtilsState[TxUtilsState["MINED"] = 5] = "MINED";
+    return TxUtilsState;
+}({});
+export const TerminalTxUtilsState = [
+    0,
+    5,
+    4
+];
+export class UnknownMinedTxError extends Error {
+    constructor(nonce, account){
+        super(`Nonce ${nonce} from account ${account} is MINED but not by one of our expected transactions`);
+        this.name = 'UnknownMinedTxError';
+    }
+}
+export class DroppedTransactionError extends Error {
+    constructor(nonce, account){
+        super(`Transaction with nonce ${nonce} from account ${account} was dropped from the mempool`);
+        this.name = 'DroppedTransactionError';
+    }
+}

package/dest/l1_tx_utils/utils.d.ts

@@ -0,0 +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

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,MAAM,CAAC;AAE3D,wBAAgB,qCAAqC,CAAC,GAAG,EAAE,8BAA8B,UAExF;AAOD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,UAEnD"}