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

package/dest/l1_tx_utils/config.d.ts

@@ -0,0 +1,59 @@
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+export interface L1TxUtilsConfig {
+    /**
+     * How much to increase calculated gas limit.
+     */
+    gasLimitBufferPercentage?: number;
+    /**
+     * Maximum gas price in gwei
+     */
+    maxGwei?: number;
+    /**
+     * Maximum blob fee per gas in gwei
+     */
+    maxBlobGwei?: number;
+    /**
+     * Priority fee bump percentage
+     */
+    priorityFeeBumpPercentage?: number;
+    /**
+     * How much to increase priority fee by each attempt (percentage)
+     */
+    priorityFeeRetryBumpPercentage?: number;
+    /**
+     * Minimum priority fee per gas in Gwei. Acts as a floor for the computed priority fee.
+     */
+    minimumPriorityFeePerGas?: number;
+    /**
+     * Maximum number of speed-up attempts
+     */
+    maxSpeedUpAttempts?: number;
+    /**
+     * How often to check tx status
+     */
+    checkIntervalMs?: number;
+    /**
+     * How long before considering tx stalled
+     */
+    stallTimeMs?: number;
+    /**
+     * How long to wait for a tx to be mined before giving up
+     */
+    txTimeoutMs?: number;
+    /**
+     * Whether to attempt to cancel a tx if it's not mined after txTimeoutMs
+     */
+    cancelTxOnTimeout?: boolean;
+    /**
+     * How long to wait for a cancellation tx to be mined after its last attempt before giving up
+     */
+    txCancellationFinalTimeoutMs?: number;
+    /**
+     * How long a tx nonce can be unseen in the mempool before considering it dropped
+     */
+    txUnseenConsideredDroppedMs?: number;
+}
+export declare const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig>;
+export declare const defaultL1TxUtilsConfig: Required<L1TxUtilsConfig>;
+export declare function getL1TxUtilsConfigEnvVars(): L1TxUtilsConfig;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbDFfdHhfdXRpbHMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLGtCQUFrQixFQU14QixNQUFNLDBCQUEwQixDQUFDO0FBRWxDLE1BQU0sV0FBVyxlQUFlO0lBQzlCOztPQUVHO0lBQ0gsd0JBQXdCLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbEM7O09BRUc7SUFDSCxPQUFPLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDakI7O09BRUc7SUFDSCxXQUFXLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDckI7O09BRUc7SUFDSCx5QkFBeUIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNuQzs7T0FFRztJQUNILDhCQUE4QixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3hDOztPQUVHO0lBQ0gsd0JBQXdCLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbEM7O09BRUc7SUFDSCxrQkFBa0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUM1Qjs7T0FFRztJQUNILGVBQWUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN6Qjs7T0FFRztJQUNILFdBQVcsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNyQjs7T0FFRztJQUNILFdBQVcsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNyQjs7T0FFRztJQUNILGlCQUFpQixDQUFDLEVBQUUsT0FBTyxDQUFDO0lBQzVCOztPQUVHO0lBQ0gsNEJBQTRCLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdEM7O09BRUc7SUFDSCwyQkFBMkIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUN0QztBQUVELGVBQU8sTUFBTSx1QkFBdUIsRUFBRSxrQkFBa0IsQ0FBQyxlQUFlLENBZ0Z2RSxDQUFDO0FBR0YsZUFBTyxNQUFNLHNCQUFzQiwyQkFFTCxDQUFDO0FBRS9CLHdCQUFnQix5QkFBeUIsSUFBSSxlQUFlLENBRTNEIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAMxB,MAAM,0BAA0B,CAAC;AAElC,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC;;OAEG;IACH,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC;;OAEG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;OAEG;IACH,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC;;OAEG;IACH,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,eAAO,MAAM,uBAAuB,EAAE,kBAAkB,CAAC,eAAe,CAgFvE,CAAC;AAGF,eAAO,MAAM,sBAAsB,2BAEL,CAAC;AAE/B,wBAAgB,yBAAyB,IAAI,eAAe,CAE3D"}

package/dest/l1_tx_utils/config.js

@@ -0,0 +1,96 @@
+import { booleanConfigHelper, floatConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper } from '@aztec/foundation/config';
+export const l1TxUtilsConfigMappings = {
+    gasLimitBufferPercentage: {
+        description: 'How much to increase calculated gas limit by (percentage)',
+        env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
+        ...numberConfigHelper(20)
+    },
+    maxGwei: {
+        description: 'Maximum gas price in gwei to be used for transactions.',
+        env: 'L1_GAS_PRICE_MAX',
+        fallback: [
+            'L1_FEE_PER_GAS_GWEI_MAX'
+        ],
+        ...floatConfigHelper(2000)
+    },
+    maxBlobGwei: {
+        description: 'Maximum blob fee per gas in gwei',
+        env: 'L1_BLOB_FEE_PER_GAS_MAX',
+        fallback: [
+            'L1_BLOB_FEE_PER_GAS_GWEI_MAX'
+        ],
+        ...floatConfigHelper(3000)
+    },
+    priorityFeeBumpPercentage: {
+        description: 'How much to increase priority fee by each attempt (percentage)',
+        env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
+        ...numberConfigHelper(20)
+    },
+    priorityFeeRetryBumpPercentage: {
+        description: 'How much to increase priority fee by each retry attempt (percentage)',
+        env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
+        ...numberConfigHelper(50)
+    },
+    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: {
+        description: 'Maximum number of speed-up attempts',
+        env: 'L1_TX_MONITOR_MAX_ATTEMPTS',
+        ...numberConfigHelper(3)
+    },
+    checkIntervalMs: {
+        description: 'How often to check tx status',
+        env: 'L1_TX_MONITOR_CHECK_INTERVAL_MS',
+        ...numberConfigHelper(1_000)
+    },
+    stallTimeMs: {
+        description: 'How long before considering tx stalled',
+        env: 'L1_TX_MONITOR_STALL_TIME_MS',
+        ...numberConfigHelper(12_000)
+    },
+    txTimeoutMs: {
+        description: 'How long to wait for a tx to be mined before giving up. Set to 0 to disable.',
+        env: 'L1_TX_MONITOR_TX_TIMEOUT_MS',
+        ...numberConfigHelper(120_000)
+    },
+    cancelTxOnTimeout: {
+        description: "Whether to attempt to cancel a tx if it's not mined after txTimeoutMs",
+        env: 'L1_TX_MONITOR_CANCEL_TX_ON_TIMEOUT',
+        ...booleanConfigHelper(true)
+    },
+    txCancellationFinalTimeoutMs: {
+        description: 'How long to wait for a cancellation tx after its last attempt before giving up',
+        env: 'L1_TX_MONITOR_TX_CANCELLATION_TIMEOUT_MS',
+        ...numberConfigHelper(24 * 12 * 1000)
+    },
+    txUnseenConsideredDroppedMs: {
+        description: 'How long a tx nonce can be unseen in the mempool before considering it dropped',
+        env: 'L1_TX_MONITOR_TX_UNSEEN_CONSIDERED_DROPPED_MS',
+        ...numberConfigHelper(6 * 12 * 1000)
+    }
+};
+// We abuse the fact that all mappings above have a non null default value and force-type this to Required
+export const defaultL1TxUtilsConfig = getDefaultConfig(l1TxUtilsConfigMappings);
+export function getL1TxUtilsConfigEnvVars() {
+    return getConfigFromMappings(l1TxUtilsConfigMappings);
+}
+function deprecatedFixedFeeMessage(envVar) {
+    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/dest/l1_tx_utils/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const WEI_CONST = 1000000000n;
+export declare const LARGE_GAS_LIMIT = 12000000n;
+export declare const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10;
+export declare const MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE = 100;
+export declare const BLOCK_TIME_MS = 12000;
+export declare const GAS_PER_BLOB = 131072n;
+export declare const BLOB_CAPACITY_SCHEDULE: {
+    timestamp: number;
+    target: number;
+    max: number;
+}[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbDFfdHhfdXRpbHMvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxTQUFTLGNBQWlCLENBQUM7QUFHeEMsZUFBTyxNQUFNLGVBQWUsWUFBYyxDQUFDO0FBSTNDLGVBQU8sTUFBTSwrQkFBK0IsS0FBSyxDQUFDO0FBSWxELGVBQU8sTUFBTSxvQ0FBb0MsTUFBTSxDQUFDO0FBR3hELGVBQU8sTUFBTSxhQUFhLFFBQVMsQ0FBQztBQUdwQyxlQUFPLE1BQU0sWUFBWSxVQUFVLENBQUM7QUFHcEMsZUFBTyxNQUFNLHNCQUFzQjs7OztHQUtsQyxDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS,cAAiB,CAAC;AAGxC,eAAO,MAAM,eAAe,YAAc,CAAC;AAI3C,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAIlD,eAAO,MAAM,oCAAoC,MAAM,CAAC;AAGxD,eAAO,MAAM,aAAa,QAAS,CAAC;AAGpC,eAAO,MAAM,YAAY,UAAU,CAAC;AAGpC,eAAO,MAAM,sBAAsB;;;;GAKlC,CAAC"}

package/dest/l1_tx_utils/constants.js

@@ -0,0 +1,39 @@
+// 1_000_000_000 Gwei = 1 ETH
+// 1_000_000_000 Wei = 1 Gwei
+// 1_000_000_000_000_000_000 Wei = 1 ETH
+export const WEI_CONST = 1_000_000_000n;
+// @note using this large gas limit to avoid the issue of `gas limit too low` when estimating gas in reth
+export const LARGE_GAS_LIMIT = 12_000_000n;
+// setting a minimum bump percentage to 10% due to geth's implementation
+// https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/legacypool/list.go#L298
+export const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10;
+// setting a minimum bump percentage to 100% due to geth's implementation
+// https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/blobpool/config.go#L34
+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
+    },
+    {
+        timestamp: 1733752800,
+        target: 10,
+        max: 15
+    },
+    {
+        timestamp: 1733234400,
+        target: 6,
+        max: 9
+    },
+    {
+        timestamp: 0,
+        target: 6,
+        max: 9
+    }
+];

package/dest/l1_tx_utils/factory.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { EthSigner } from '../eth-signer/eth-signer.js';
+import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
+import type { L1TxUtilsConfig } from './config.js';
+import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
+import { L1TxUtils } from './l1_tx_utils.js';
+export declare function createL1TxUtilsFromViemWallet(client: ExtendedViemWalletClient, deps?: {
+    logger?: Logger;
+    dateProvider?: DateProvider;
+    store?: IL1TxStore;
+    metrics?: IL1TxMetrics;
+}, config?: Partial<L1TxUtilsConfig> & {
+    debugMaxGasLimit?: boolean;
+}): L1TxUtils;
+export declare function createL1TxUtilsFromEthSigner(client: ViemClient, signer: EthSigner, deps?: {
+    logger?: Logger;
+    dateProvider?: DateProvider;
+    store?: IL1TxStore;
+    metrics?: IL1TxMetrics;
+}, config?: Partial<L1TxUtilsConfig> & {
+    debugMaxGasLimit?: boolean;
+}): L1TxUtils;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2wxX3R4X3V0aWxzL2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBSXZELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQzdELE9BQU8sS0FBSyxFQUFFLHdCQUF3QixFQUFFLFVBQVUsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUk3Qyx3QkFBZ0IsNkJBQTZCLENBQzNDLE1BQU0sRUFBRSx3QkFBd0IsRUFDaEMsSUFBSSxDQUFDLEVBQUU7SUFDTCxNQUFNLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDaEIsWUFBWSxDQUFDLEVBQUUsWUFBWSxDQUFDO0lBQzVCLEtBQUssQ0FBQyxFQUFFLFVBQVUsQ0FBQztJQUNuQixPQUFPLENBQUMsRUFBRSxZQUFZLENBQUM7Q0FDeEIsRUFDRCxNQUFNLENBQUMsRUFBRSxPQUFPLENBQUMsZUFBZSxDQUFDLEdBQUc7SUFBRSxnQkFBZ0IsQ0FBQyxFQUFFLE9BQU8sQ0FBQTtDQUFFLEdBQ2pFLFNBQVMsQ0FZWDtBQUVELHdCQUFnQiw0QkFBNEIsQ0FDMUMsTUFBTSxFQUFFLFVBQVUsRUFDbEIsTUFBTSxFQUFFLFNBQVMsRUFDakIsSUFBSSxDQUFDLEVBQUU7SUFDTCxNQUFNLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDaEIsWUFBWSxDQUFDLEVBQUUsWUFBWSxDQUFDO0lBQzVCLEtBQUssQ0FBQyxFQUFFLFVBQVUsQ0FBQztJQUNuQixPQUFPLENBQUMsRUFBRSxZQUFZLENBQUM7Q0FDeEIsRUFDRCxNQUFNLENBQUMsRUFBRSxPQUFPLENBQUMsZUFBZSxDQUFDLEdBQUc7SUFBRSxnQkFBZ0IsQ0FBQyxFQUFFLE9BQU8sQ0FBQTtDQUFFLEdBQ2pFLFNBQVMsQ0FnQlgifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAIvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI7C,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,wBAAwB,EAChC,IAAI,CAAC,EAAE;IACL,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB,EACD,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,GACjE,SAAS,CAYX;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,SAAS,EACjB,IAAI,CAAC,EAAE;IACL,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB,EACD,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,GACjE,SAAS,CAgBX"}

package/dest/l1_tx_utils/factory.js

@@ -0,0 +1,12 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { L1TxUtils } from './l1_tx_utils.js';
+import { createViemSigner } from './signer.js';
+export function createL1TxUtilsFromViemWallet(client, deps, config) {
+    return new L1TxUtils(client, EthAddress.fromString(client.account.address), createViemSigner(client), deps?.logger, deps?.dateProvider, config, config?.debugMaxGasLimit ?? false, deps?.store, deps?.metrics);
+}
+export function createL1TxUtilsFromEthSigner(client, signer, deps, config) {
+    const callback = async (transaction, _signingAddress)=>{
+        return (await signer.signTransaction(transaction)).toViemTransactionSignature();
+    };
+    return new L1TxUtils(client, signer.address, callback, deps?.logger, deps?.dateProvider, config, config?.debugMaxGasLimit ?? false, deps?.store, deps?.metrics);
+}

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

@@ -0,0 +1,9 @@
+import type { PriorityFeeStrategy } from './types.js';
+export { HISTORICAL_BLOCK_COUNT, executeStrategy, type PriorityFeeStrategy, type PriorityFeeStrategyContext, type PriorityFeeStrategyResult, } from './types.js';
+export { P75AllTxsPriorityFeeStrategy } from './p75_competitive.js';
+/**
+ * Default list of priority fee strategies to analyze.
+ * Add more strategies here for comparison.
+ */
+export declare const DEFAULT_PRIORITY_FEE_STRATEGIES: PriorityFeeStrategy[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9sMV90eF91dGlscy9mZWUtc3RyYXRlZ2llcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUV0RCxPQUFPLEVBQ0wsc0JBQXNCLEVBQ3RCLGVBQWUsRUFDZixLQUFLLG1CQUFtQixFQUN4QixLQUFLLDBCQUEwQixFQUMvQixLQUFLLHlCQUF5QixHQUMvQixNQUFNLFlBQVksQ0FBQztBQUVwQixPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVwRTs7O0dBR0c7QUFDSCxlQUFPLE1BQU0sK0JBQStCLEVBQUUsbUJBQW1CLEVBR2hFLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/l1_tx_utils/fee-strategies/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,GAC/B,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,+BAA+B,EAAE,mBAAmB,EAGhE,CAAC"}

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

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

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

@@ -0,0 +1,18 @@
+import type { ViemClient } from '../../types.js';
+import { type PriorityFeeStrategy } from './types.js';
+/**
+ * Type for the promises required by the competitive strategy
+ */
+type P75AllTxsStrategyPromises = {
+    networkEstimate: Promise<bigint>;
+    pendingBlock: Promise<Awaited<ReturnType<ViemClient['getBlock']>> | null>;
+    feeHistory: Promise<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>;
+};
+/**
+ * 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 declare const P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStrategyPromises>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDc1X2NvbXBldGl0aXZlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbDFfdHhfdXRpbHMvZmVlLXN0cmF0ZWdpZXMvcDc1X2NvbXBldGl0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBR2pELE9BQU8sRUFFTCxLQUFLLG1CQUFtQixFQUd6QixNQUFNLFlBQVksQ0FBQztBQUVwQjs7R0FFRztBQUNILEtBQUsseUJBQXlCLEdBQUc7SUFDL0IsZUFBZSxFQUFFLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNqQyxZQUFZLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQztJQUMxRSxVQUFVLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLGVBQWUsQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQztDQUM5RSxDQUFDO0FBRUY7Ozs7R0FJRztBQUNILGVBQU8sTUFBTSw0QkFBNEIsRUFBRSxtQkFBbUIsQ0FBQyx5QkFBeUIsQ0FrSXZGLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"p75_competitive.d.ts","sourceRoot":"","sources":["../../../src/l1_tx_utils/fee-strategies/p75_competitive.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,EAEL,KAAK,mBAAmB,EAGzB,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,KAAK,yBAAyB,GAAG;IAC/B,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC1E,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;CAC9E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,mBAAmB,CAAC,yBAAyB,CAkIvF,CAAC"}

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

@@ -0,0 +1,111 @@
+import { median } from '@aztec/foundation/collection';
+import { formatGwei } from 'viem';
+import { calculatePercentile } from '../../utils.js';
+import { WEI_CONST } from '../constants.js';
+import { HISTORICAL_BLOCK_COUNT } 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 = {
+    name: 'Competitive (P75 + History) - CURRENT',
+    id: 'p75_pending_txs_and_history_all_txs',
+    getRequiredPromises (client) {
+        return {
+            networkEstimate: client.estimateMaxPriorityFeePerGas().catch(()=>0n),
+            pendingBlock: client.getBlock({
+                blockTag: 'pending',
+                includeTransactions: true
+            }).catch(()=>null),
+            feeHistory: client.getFeeHistory({
+                blockCount: HISTORICAL_BLOCK_COUNT,
+                rewardPercentiles: [
+                    75
+                ],
+                blockTag: 'latest'
+            }).catch(()=>null)
+        };
+    },
+    calculate (results, context) {
+        const { logger } = context;
+        // Extract network estimate from settled result
+        const networkEstimate = results.networkEstimate.status === 'fulfilled' && typeof results.networkEstimate.value === 'bigint' ? results.networkEstimate.value : 0n;
+        let competitiveFee = networkEstimate;
+        const debugInfo = {
+            networkEstimateGwei: formatGwei(networkEstimate)
+        };
+        // Extract pending block from settled result
+        const pendingBlock = results.pendingBlock.status === 'fulfilled' ? results.pendingBlock.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;
+                }
+                const fee = tx.maxPriorityFeePerGas || 0n;
+                return fee;
+            }).filter((fee)=>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 from settled result
+        const feeHistory = results.feeHistory.status === 'fulfilled' ? results.feeHistory.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,
+            debugInfo
+        };
+    }
+};

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

@@ -0,0 +1,32 @@
+import { type GetFeeHistoryReturnType } from 'viem';
+import type { ViemClient } from '../../types.js';
+import { type PriorityFeeStrategy } from './types.js';
+/**
+ * Type for the promises required by the competitive strategy
+ */
+type P75AllTxsStrategyPromises = {
+    networkEstimate: Promise<bigint>;
+    pendingBlock: Promise<Awaited<ReturnType<ViemClient['getBlock']>> | null>;
+    feeHistory: Promise<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>;
+};
+/**
+ * Fetches historical blocks and calculates reward percentiles for blob transactions only.
+ * Returns data in the same format as getFeeHistory for easy drop-in replacement.
+ *
+ * @param client - Viem client to use for RPC calls
+ * @param blockCount - Number of historical blocks to fetch
+ * @param rewardPercentiles - Array of percentiles to calculate (e.g., [75] for 75th percentile)
+ * @returns Object with reward field containing percentile fees for each block, similar to getFeeHistory
+ * @throws Error if fetching blocks fails
+ */
+export declare function getBlobPriorityFeeHistory(client: ViemClient, blockCount: number, rewardPercentiles: number[]): Promise<GetFeeHistoryReturnType>;
+/**
+ * Similar to our current competitive priority fee strategy, but only considers blob transactions
+ * when calculating competitive priority fee for blob transactions.
+ * This strategy also has NO cap on the competitive fee if it's much higher than the network estimate.
+ * Analyzes p75 of pending transactions and 5-block fee history to determine a competitive priority fee.
+ * Falls back to network estimate if data is unavailable.
+ */
+export declare const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStrategyPromises>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDc1X2NvbXBldGl0aXZlX2Jsb2JfdHhzX29ubHkuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9sMV90eF91dGlscy9mZWUtc3RyYXRlZ2llcy9wNzVfY29tcGV0aXRpdmVfYmxvYl90eHNfb25seS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsS0FBSyx1QkFBdUIsRUFBYyxNQUFNLE1BQU0sQ0FBQztBQUVoRSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUdqRCxPQUFPLEVBRUwsS0FBSyxtQkFBbUIsRUFHekIsTUFBTSxZQUFZLENBQUM7QUFFcEI7O0dBRUc7QUFDSCxLQUFLLHlCQUF5QixHQUFHO0lBQy9CLGVBQWUsRUFBRSxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDakMsWUFBWSxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDLENBQUM7SUFDMUUsVUFBVSxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxlQUFlLENBQUMsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDLENBQUM7Q0FDOUUsQ0FBQztBQUVGOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFzQix5QkFBeUIsQ0FDN0MsTUFBTSxFQUFFLFVBQVUsRUFDbEIsVUFBVSxFQUFFLE1BQU0sRUFDbEIsaUJBQWlCLEVBQUUsTUFBTSxFQUFFLEdBQzFCLE9BQU8sQ0FBQyx1QkFBdUIsQ0FBQyxDQXNFbEM7QUFFRDs7Ozs7O0dBTUc7QUFDSCxlQUFPLE1BQU0saUNBQWlDLEVBQUUsbUJBQW1CLENBQUMseUJBQXlCLENBNEg1RixDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"p75_competitive_blob_txs_only.d.ts","sourceRoot":"","sources":["../../../src/l1_tx_utils/fee-strategies/p75_competitive_blob_txs_only.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,uBAAuB,EAAc,MAAM,MAAM,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,EAEL,KAAK,mBAAmB,EAGzB,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,KAAK,yBAAyB,GAAG;IAC/B,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC1E,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;CAC9E,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EAAE,GAC1B,OAAO,CAAC,uBAAuB,CAAC,CAsElC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iCAAiC,EAAE,mBAAmB,CAAC,yBAAyB,CA4H5F,CAAC"}

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

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