@aztec/ethereum 2.1.9 → 2.1.11

package/dest/l1_tx_utils/readonly_l1_tx_utils.js

@@ -1,4 +1,4 @@
-import { getKeys, median, merge, pick, times } from '@aztec/foundation/collection';
+import { getKeys, merge, pick, times } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
@@ -6,8 +6,10 @@ 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 { P75AllTxsPriorityFeeStrategy } from './fee-strategies/index.js';
 import { getCalldataGasUsage, tryGetCustomErrorNameContractFunction } from './utils.js';
-const HISTORICAL_BLOCK_COUNT = 5;
+// Change this to the current strategy we want to use
+const CurrentStrategy = P75AllTxsPriorityFeeStrategy;
 export class ReadOnlyL1TxUtils {
     client;
     logger;
@@ -36,141 +38,37 @@ export class ReadOnlyL1TxUtils {
         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) {
+        // Execute strategy - it handles all RPC calls internally and returns everything we need
+        const strategyResult = await retry(()=>CurrentStrategy.execute(this.client, {
+                gasConfig,
+                isBlobTx,
+                logger: this.logger
+            }), 'Executing priority fee strategy', makeBackoff(times(2, ()=>0)), this.logger, true);
+        const { latestBlock, blobBaseFee, priorityFee: strategyPriorityFee } = strategyResult;
+        // Extract base fee from latest block
+        const baseFee = latestBlock.baseFeePerGas ?? 0n;
+        // Handle blob base fee
+        if (isBlobTx && blobBaseFee === undefined) {
             this.logger?.warn('Failed to get L1 blob base fee', attempt);
         }
-        let priorityFee;
-        if (gasConfig.fixedPriorityFeePerGas) {
-            this.logger?.debug('Using fixed priority fee per L1 gas', {
-                fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas
-            });
-            priorityFee = BigInt(Math.trunc(gasConfig.fixedPriorityFeePerGas * Number(WEI_CONST)));
-        } else {
-            // Get competitive priority fee (includes network estimate + analysis)
-            priorityFee = this.getCompetitivePriorityFee(networkEstimateResult, pendingBlockResult, feeHistoryResult);
+        let priorityFee = strategyPriorityFee;
+        // Apply minimum priority fee floor if configured
+        if (gasConfig.minimumPriorityFeePerGas) {
+            const minimumPriorityFee = BigInt(Math.trunc(gasConfig.minimumPriorityFeePerGas * Number(WEI_CONST)));
+            if (priorityFee < minimumPriorityFee) {
+                this.logger?.debug('Applying minimum priority fee floor', {
+                    calculatedPriorityFee: formatGwei(priorityFee),
+                    minimumPriorityFeePerGas: gasConfig.minimumPriorityFeePerGas,
+                    appliedFee: formatGwei(minimumPriorityFee)
+                });
+                priorityFee = minimumPriorityFee;
+            }
         }
         let maxFeePerGas = baseFee;
-        let maxFeePerBlobGas = blobBaseFee;
+        let maxFeePerBlobGas = blobBaseFee ?? 0n;
         // Bump base fee so it's valid for next blocks if it stalls
         const numBlocks = Math.ceil(gasConfig.stallTimeMs / BLOCK_TIME_MS);
         for(let i = 0; i < numBlocks; i++){
@@ -188,17 +86,14 @@ export class ReadOnlyL1TxUtils {
             // multiply by 100 & divide by 100 to maintain some precision
             const minPriorityFee = previousGasPrice.maxPriorityFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
             const minMaxFee = previousGasPrice.maxFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
-            let competitivePriorityFee = priorityFee;
-            if (!gasConfig.fixedPriorityFeePerGas) {
-                // Apply bump percentage to competitive fee
-                competitivePriorityFee = priorityFee * (100_00n + BigInt(configBump * 1_00)) / 100_00n;
-                this.logger?.debug(`Speed-up attempt ${attempt}: using competitive fee strategy`, {
-                    networkEstimate: formatGwei(priorityFee),
-                    competitiveFee: formatGwei(competitivePriorityFee),
-                    minRequired: formatGwei(minPriorityFee),
-                    bumpPercentage: configBump
-                });
-            }
+            // Apply bump percentage to competitive fee
+            const competitivePriorityFee = priorityFee * (100_00n + BigInt(configBump * 1_00)) / 100_00n;
+            this.logger?.debug(`Speed-up attempt ${attempt}: using competitive fee strategy`, {
+                networkEstimate: formatGwei(priorityFee),
+                competitiveFee: formatGwei(competitivePriorityFee),
+                minRequired: formatGwei(minPriorityFee),
+                bumpPercentage: configBump
+            });
             // Use maximum between competitive fee and minimum required bump
             const finalPriorityFee = competitivePriorityFee > minPriorityFee ? competitivePriorityFee : minPriorityFee;
             const feeSource = finalPriorityFee === competitivePriorityFee ? 'competitive' : 'minimum-bump';
@@ -206,20 +101,16 @@ export class ReadOnlyL1TxUtils {
             // Add the final priority fee to maxFeePerGas
             maxFeePerGas += finalPriorityFee;
             maxFeePerGas = maxFeePerGas > minMaxFee ? maxFeePerGas : minMaxFee;
-            if (!gasConfig.fixedPriorityFeePerGas) {
-                this.logger?.debug(`Speed-up fee decision: using ${feeSource} fee`, {
-                    finalPriorityFee: formatGwei(finalPriorityFee)
-                });
-            }
+            this.logger?.debug(`Speed-up fee decision: using ${feeSource} fee`, {
+                finalPriorityFee: formatGwei(finalPriorityFee)
+            });
         } else {
             // First attempt: apply configured bump percentage to competitive fee
             // multiply by 100 & divide by 100 to maintain some precision
-            if (!gasConfig.fixedPriorityFeePerGas) {
-                priorityFee = priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00)) / 100_00n;
-                this.logger?.debug('Initial transaction: using competitive fee from market analysis', {
-                    networkEstimate: formatGwei(priorityFee)
-                });
-            }
+            priorityFee = priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00)) / 100_00n;
+            this.logger?.debug('Initial transaction: using competitive fee from market analysis', {
+                networkEstimate: formatGwei(priorityFee)
+            });
             maxFeePerGas += priorityFee;
         }
         // maxGwei and maxBlobGwei are hard limits
@@ -247,7 +138,7 @@ export class ReadOnlyL1TxUtils {
             baseFee: formatGwei(baseFee),
             maxFeePerGas: formatGwei(maxFeePerGas),
             maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
-            blobBaseFee: formatGwei(blobBaseFee),
+            blobBaseFee: formatGwei(blobBaseFee ?? 0n),
             maxFeePerBlobGas: formatGwei(maxFeePerBlobGas)
         });
         return {
@@ -274,14 +165,16 @@ export class ReadOnlyL1TxUtils {
                 ...request,
                 ..._blobInputs,
                 maxFeePerBlobGas: gasPrice.maxFeePerBlobGas,
-                gas: LARGE_GAS_LIMIT
+                gas: LARGE_GAS_LIMIT,
+                blockTag: 'latest'
             });
             this.logger?.trace(`Estimated gas for blob tx: ${initialEstimate}`);
         } else {
             initialEstimate = await this.client.estimateGas({
                 account,
                 ...request,
-                gas: LARGE_GAS_LIMIT
+                gas: LARGE_GAS_LIMIT,
+                blockTag: 'latest'
             });
             this.logger?.trace(`Estimated gas for non-blob tx: ${initialEstimate}`);
         }
@@ -422,9 +315,4 @@ export class ReadOnlyL1TxUtils {
         });
         return bumpedGasLimit;
     }
-    /**
-   * Helper function to retry RPC calls twice
-   */ tryTwice(fn, description) {
-        return retry(fn, description, makeBackoff(times(2, ()=>0)), this.logger, true);
-    }
 }

package/dest/utils.d.ts

@@ -1,6 +1,6 @@
 import type { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
-import { type Abi, type ContractEventName, type DecodeEventLogReturnType, type Hex, type Log } from 'viem';
+import { type Abi, type ContractEventName, type DecodeEventLogReturnType, type FormattedTransaction, type Hex, type Log } from 'viem';
 export interface L2Claim {
     claimSecret: Fr;
     claimAmount: Fr;
@@ -22,4 +22,16 @@ export declare function prettyLogViemErrorMsg(err: any): any;
  */
 export declare function formatViemError(error: any, abi?: Abi): FormattedViemError;
 export declare function tryGetCustomErrorName(err: any): string | undefined;
+/**
+ * Type guard to check if a transaction is a blob transaction (EIP-4844).
+ * Blob transactions have maxFeePerBlobGas and blobVersionedHashes fields.
+ */
+export declare function isBlobTransaction(tx: FormattedTransaction): tx is FormattedTransaction & {
+    maxFeePerBlobGas: bigint;
+    blobVersionedHashes: readonly Hex[];
+};
+/**
+ * Calculates a percentile from an array of bigints
+ */
+export declare function calculatePercentile(values: bigint[], percentile: number): bigint;
 //# sourceMappingURL=utils.d.ts.map

package/dest/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EACL,KAAK,GAAG,EAER,KAAK,iBAAiB,EAEtB,KAAK,wBAAwB,EAC7B,KAAK,GAAG,EACR,KAAK,GAAG,EAGT,MAAM,MAAM,CAAC;AAEd,MAAM,WAAW,OAAO;IACtB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,GAAG,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC;gBAET,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,GAAG,EAAE;CAKlD;AAED,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC3C,UAAU,SAAS,iBAAiB,CAAC,IAAI,CAAC,EAC1C,UAAU,GAAG,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAE/E,IAAI,EAAE,GAAG,EAAE,EACX,OAAO,EAAE,GAAG,EACZ,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,UAAU,CAMZ;AAED,wBAAgB,eAAe,CAC7B,KAAK,CAAC,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC3C,UAAU,SAAS,iBAAiB,CAAC,IAAI,CAAC,EAC1C,UAAU,GAAG,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAE/E,IAAI,EAAE,GAAG,EAAE,EACX,OAAO,EAAE,GAAG,EACZ,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,UAAU,GAAG,SAAS,CAgBxB;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,OAW7C;AA0BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,GAAE,GAAe,GAAG,kBAAkB,CAwEpF;AAyBD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,sBAa7C"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EACL,KAAK,GAAG,EAER,KAAK,iBAAiB,EAEtB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,GAAG,EACR,KAAK,GAAG,EAGT,MAAM,MAAM,CAAC;AAEd,MAAM,WAAW,OAAO;IACtB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,GAAG,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC;gBAET,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,GAAG,EAAE;CAKlD;AAED,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC3C,UAAU,SAAS,iBAAiB,CAAC,IAAI,CAAC,EAC1C,UAAU,GAAG,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAE/E,IAAI,EAAE,GAAG,EAAE,EACX,OAAO,EAAE,GAAG,EACZ,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,UAAU,CAMZ;AAED,wBAAgB,eAAe,CAC7B,KAAK,CAAC,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC3C,UAAU,SAAS,iBAAiB,CAAC,IAAI,CAAC,EAC1C,UAAU,GAAG,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAE/E,IAAI,EAAE,GAAG,EAAE,EACX,OAAO,EAAE,GAAG,EACZ,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,UAAU,GAAG,SAAS,CAgBxB;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,OAW7C;AA0BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,GAAE,GAAe,GAAG,kBAAkB,CAwEpF;AAyBD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,sBAa7C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,oBAAoB,GAAG,EAAE,IAAI,oBAAoB,GAAG;IACxF,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,EAAE,SAAS,GAAG,EAAE,CAAC;CACrC,CAOA;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAOhF"}

package/dest/utils.js

@@ -162,3 +162,21 @@ export function tryGetCustomErrorName(err) {
         return undefined;
     }
 }
+/**
+ * Type guard to check if a transaction is a blob transaction (EIP-4844).
+ * Blob transactions have maxFeePerBlobGas and blobVersionedHashes fields.
+ */ export function isBlobTransaction(tx) {
+    return 'maxFeePerBlobGas' in tx && tx.maxFeePerBlobGas !== undefined && 'blobVersionedHashes' in tx && tx.blobVersionedHashes !== undefined;
+}
+/**
+ * Calculates a percentile from an array of bigints
+ */ export function calculatePercentile(values, percentile) {
+    if (values.length === 0) {
+        return 0n;
+    }
+    const sorted = [
+        ...values
+    ].sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
+    const index = Math.ceil((sorted.length - 1) * (percentile / 100));
+    return sorted[index];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "2.1.9",
+  "version": "2.1.11",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -8,6 +8,7 @@
     "./contracts": "./dest/contracts/index.js",
     "./deploy-l1-contracts": "./dest/deploy_l1_contracts.js",
     "./l1-contract-addresses": "./dest/l1_contract_addresses.js",
+    "./l1-fee-analysis": "./dest/l1_tx_utils/l1_fee_analyzer.js",
     "./l1-tx-utils-with-blobs": "./dest/l1_tx_utils/index-blobs.js",
     "./utils": "./dest/utils.js"
   },
@@ -31,10 +32,10 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/blob-lib": "2.1.9",
-    "@aztec/constants": "2.1.9",
-    "@aztec/foundation": "2.1.9",
-    "@aztec/l1-artifacts": "2.1.9",
+    "@aztec/blob-lib": "2.1.11",
+    "@aztec/constants": "2.1.11",
+    "@aztec/foundation": "2.1.11",
+    "@aztec/l1-artifacts": "2.1.11",
     "@viem/anvil": "^0.0.10",
     "dotenv": "^16.0.3",
     "lodash.chunk": "^4.2.0",

package/src/deploy_l1_contracts.ts

@@ -276,7 +276,14 @@ export const deploySharedContracts = async (
     feeAssetAddress = deployedFee.address;
     logger.verbose(`Deployed Fee Asset at ${feeAssetAddress}`);
 
+    const deployedStaking = await deployer.deploy(StakingAssetArtifact, ['Staking', 'STK', l1Client.account.address]);
+    stakingAssetAddress = deployedStaking.address;
+    logger.verbose(`Deployed Staking Asset at ${stakingAssetAddress}`);
+
+    await deployer.waitForDeployments();
+
     // Mint a tiny bit of tokens to satisfy coin-issuer constraints
+    // This must happen AFTER the FeeAsset deployment is mined
     const { txHash } = await deployer.sendTransaction({
       to: feeAssetAddress.toString(),
       data: encodeFunctionData({
@@ -287,12 +294,6 @@ export const deploySharedContracts = async (
     });
     await l1Client.waitForTransactionReceipt({ hash: txHash });
     logger.verbose(`Minted tiny bit of tokens to satisfy coin-issuer constraints in ${txHash}`);
-
-    const deployedStaking = await deployer.deploy(StakingAssetArtifact, ['Staking', 'STK', l1Client.account.address]);
-    stakingAssetAddress = deployedStaking.address;
-    logger.verbose(`Deployed Staking Asset at ${stakingAssetAddress}`);
-
-    await deployer.waitForDeployments();
   }
 
   const gseAddress = (

package/src/l1_tx_utils/config.ts

@@ -29,9 +29,9 @@ export interface L1TxUtilsConfig {
    */
   priorityFeeRetryBumpPercentage?: number;
   /**
-   * Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage config
+   * Minimum priority fee per gas in Gwei. Acts as a floor for the computed priority fee.
    */
-  fixedPriorityFeePerGas?: number;
+  minimumPriorityFeePerGas?: number;
   /**
    * Maximum number of speed-up attempts
    */
@@ -90,10 +90,21 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
     env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
     ...numberConfigHelper(50),
   },
-  fixedPriorityFeePerGas: {
-    description: 'Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage',
-    env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
-    fallback: ['L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI'],
+  minimumPriorityFeePerGas: {
+    description:
+      'Minimum priority fee per gas in Gwei. Acts as a floor for the computed priority fee. If network conditions require a higher fee, the higher fee will be used.',
+    env: 'L1_MINIMUM_PRIORITY_FEE_PER_GAS_GWEI',
+    fallback: ['L1_FIXED_PRIORITY_FEE_PER_GAS', 'L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI'],
+    deprecatedFallback: [
+      {
+        env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
+        message: deprecatedFixedFeeMessage('L1_FIXED_PRIORITY_FEE_PER_GAS'),
+      },
+      {
+        env: 'L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI',
+        message: deprecatedFixedFeeMessage('L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI'),
+      },
+    ],
     ...floatConfigHelper(0),
   },
   maxSpeedUpAttempts: {
@@ -141,3 +152,10 @@ export const defaultL1TxUtilsConfig = getDefaultConfig<L1TxUtilsConfig>(
 export function getL1TxUtilsConfigEnvVars(): L1TxUtilsConfig {
   return getConfigFromMappings(l1TxUtilsConfigMappings);
 }
+
+function deprecatedFixedFeeMessage(envVar: string): string {
+  return (
+    `Environment variable ${envVar} is deprecated. It is now used as a MINIMUM priority fee rather than a fixed value. ` +
+    'Please use L1_MINIMUM_PRIORITY_FEE_PER_GAS_GWEI instead. If network conditions require a higher fee, the higher fee will be used.'
+  );
+}

package/src/l1_tx_utils/constants.ts

@@ -16,3 +16,14 @@ export const MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE = 100;
 
 // Avg ethereum block time is ~12s
 export const BLOCK_TIME_MS = 12_000;
+
+// Gas per blob (EIP-4844)
+export const GAS_PER_BLOB = 131072n;
+
+// Blob capacity schedule based on Ethereum upgrades
+export const BLOB_CAPACITY_SCHEDULE = [
+  { timestamp: 1734357600, target: 14, max: 21 }, // BPO2: Dec 17, 2025
+  { timestamp: 1733752800, target: 10, max: 15 }, // BPO1: Dec 9, 2025
+  { timestamp: 1733234400, target: 6, max: 9 }, // Fusaka: Dec 3, 2025
+  { timestamp: 0, target: 6, max: 9 }, // Pectra/earlier
+];

package/src/l1_tx_utils/fee-strategies/index.ts

@@ -0,0 +1,22 @@
+import { P75AllTxsPriorityFeeStrategy } from './p75_competitive.js';
+import { P75BlobTxsOnlyPriorityFeeStrategy } from './p75_competitive_blob_txs_only.js';
+import type { PriorityFeeStrategy } from './types.js';
+
+export {
+  HISTORICAL_BLOCK_COUNT,
+  type PriorityFeeStrategy,
+  type PriorityFeeStrategyContext,
+  type PriorityFeeStrategyResult,
+} from './types.js';
+
+export { P75AllTxsPriorityFeeStrategy } from './p75_competitive.js';
+export { P75BlobTxsOnlyPriorityFeeStrategy } from './p75_competitive_blob_txs_only.js';
+
+/**
+ * Default list of priority fee strategies to analyze.
+ * Add more strategies here for comparison.
+ */
+export const DEFAULT_PRIORITY_FEE_STRATEGIES: PriorityFeeStrategy[] = [
+  P75AllTxsPriorityFeeStrategy,
+  P75BlobTxsOnlyPriorityFeeStrategy,
+];

package/src/l1_tx_utils/fee-strategies/p75_competitive.ts

@@ -0,0 +1,163 @@
+import { median } from '@aztec/foundation/collection';
+
+import { formatGwei } from 'viem';
+
+import type { ViemClient } from '../../types.js';
+import { calculatePercentile } from '../../utils.js';
+import { WEI_CONST } from '../constants.js';
+import {
+  HISTORICAL_BLOCK_COUNT,
+  type PriorityFeeStrategy,
+  type PriorityFeeStrategyContext,
+  type PriorityFeeStrategyResult,
+} from './types.js';
+
+/**
+ * Our current competitive priority fee strategy.
+ * 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 P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy = {
+  name: 'Competitive (P75 + History) - CURRENT',
+  id: 'p75_pending_txs_and_history_all_txs',
+
+  async execute(client: ViemClient, context: PriorityFeeStrategyContext): Promise<PriorityFeeStrategyResult> {
+    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),
+        client
+          .getFeeHistory({
+            blockCount: HISTORICAL_BLOCK_COUNT,
+            rewardPercentiles: [75],
+            blockTag: 'latest',
+          })
+          .catch(() => null),
+      ]);
+
+    // Extract latest block
+    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: bigint | undefined;
+    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: Record<string, string | number> = {
+      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;
+          }
+          return tx.maxPriorityFeePerGas || 0n;
+        })
+        .filter((fee: bigint) => fee > 0n);
+
+      if (pendingFees.length > 0) {
+        // Use 75th percentile of pending fees to be competitive
+        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),
+        });
+      }
+    }
+
+    // Sanity check: cap competitive fee at 100x network estimate to avoid using unrealistic fees
+    const maxReasonableFee = networkEstimate * 100n;
+    if (competitiveFee > maxReasonableFee && networkEstimate > 0n) {
+      logger?.warn('Competitive fee exceeds sanity cap, using capped value', {
+        competitiveFee: formatGwei(competitiveFee),
+        networkEstimate: formatGwei(networkEstimate),
+        cappedTo: formatGwei(maxReasonableFee),
+      });
+      competitiveFee = maxReasonableFee;
+      debugInfo.cappedToGwei = formatGwei(maxReasonableFee);
+    }
+
+    // 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,
+    };
+  },
+};