@mixerx/oracles 2.0.0 → 3.1.0

package/README.md

@@ -1,106 +1,124 @@
-# MixerX Oracles
-
-Fail-closed Sepolia pricing and gas policy for MixerX. Version 2.0.0 removes
-historical Tornado price fallbacks and rejects a withdrawal quote when its
-price is missing, stale or economically unsafe.
-
-## Security contract
-
-- Sepolia (`11155111`) is the only accepted chain.
-- RPC endpoints must use HTTPS, are time-bounded and are checked against the
-  real `eth_chainId` response.
-- Token calls use Multicall3 atomically at one block. Any failed token rejects
-  the batch; no historical constant is substituted.
-- Non-native withdrawal fees require a repository price plus its observation
-  timestamp. The default maximum age is two minutes.
-- Gas data, service fee, refund, decimals and total fee are bounded before a
-  result is returned.
-- The exact withdrawal gas limit is mandatory input and must come from
-  simulation or `eth_estimateGas`; the package contains no token-specific
-  limits inherited from another protocol.
-- Logging is disabled by default. Inject an `ILogger` that follows the host
-  service's privacy policy if operational events are required.
-
-The Sepolia OffchainOracle deployment must contain valid rates and must be
-protected by the protocol's TWAP/deviation policy. The library cannot create or
-initialize that on-chain state. Call `assertReady()` during application startup;
-do not accept traffic if it fails.
-
-## Installation
-
-```bash
-yarn add @mixerx/oracles@2.0.0
-```
-
-Node.js 22.12 or newer is required.
-
-## Usage
-
-```ts
-import {
-  createMixerxOraclesModule,
-  type ITokenPriceRepository,
-} from '@mixerx/oracles';
-
-const priceRepository: ITokenPriceRepository = {
-  getPrice: async (symbol) => readCachedPrice(symbol),
-  getLastUpdateTimestamp: async () => readLastPriceUpdate(),
-};
-
-const oracles = createMixerxOraclesModule({
-  chainId: 11155111,
-  rpcUrl: process.env.SEPOLIA_RPC_URL!,
-  relayerFeePercent: 0.004,
-  priceRepository,
-  maxGasPriceGwei: 100,
-  maxPriceAgeMs: 120_000,
-});
-
-await oracles.assertReady();
-
-const fee = await oracles.mixerXFeeOracle.calculateWithdrawalFee({
-  currency: 'fds',
-  amount: 1_000_000_000_000_000_000n,
-  decimals: 18,
-  gasLimit: estimatedWithdrawalGas,
-  refund: '0',
-  purpose: 'fee',
-});
-
-console.log({
-  totalFee: fee.totalFee,
-  tokenPriceInEth: fee.tokenPriceInEth,
-  priceSource: fee.priceSource,
-  priceObservedAtMs: fee.priceObservedAtMs,
-  baseFeePerGas: fee.baseFeePerGas,
-});
-```
-
-`fee_quote` and `fee_validation` remain accepted as input aliases for migration,
-but both normalize to the single `fee` policy in returned data.
-
-## Price-feed operation
-
-`fetchPrices()` reads all configured Sepolia tokens through Multicall3. It
-returns `Record<string, string>` only when every token succeeds. The host price
-feed must persist both the values and one observation timestamp atomically.
-Fee calculation never falls back from that repository to a spot value.
-
-The default Multicall3 address is
-`0xcA11bde05977b3631167028862bE2a173976CA11`; an explicit verified address can
-be supplied with `multicallAddress`.
-
-## Development
-
-```bash
-yarn install --immutable
-yarn validate
-yarn npm audit --all --recursive --severity high
-```
-
-CI executes those gates for every pull request. Published packages pin the
-protocol configuration dependency exactly.
-
-## License
-
-GPL-3.0-only. See `LICENSE`.
+# MixerX Oracles
+
+Fail-closed Ethereum pricing and gas policy for MixerX. Version 3.1.0 rejects a
+withdrawal quote when its gas or token price is missing, stale or economically
+unsafe.
+
+## Security contract
+
+- Ethereum mainnet (`1`) and Sepolia (`11155111`) are accepted, as defined by
+  `@mixerx/config`. A fork must report a supported chain ID.
+- RPC endpoints must use HTTPS, are time-bounded and are checked against the
+  real `eth_chainId` response.
+- Token calls use Multicall3 atomically at one block. Any failed token rejects
+  the batch; no historical constant is substituted.
+- Non-native withdrawal fees require a repository price plus its observation
+  timestamp. The default maximum age is two minutes.
+- Gas data, service fee, refund, token decimals and total fee are bounded before
+  a result is returned. The default total-fee ceiling matches the contracts at
+  10% of the withdrawal amount.
+- Configurable token-price sanity bands can reject corrupted but fresh cache
+  values.
+- The exact withdrawal gas limit is mandatory input and must come from
+  simulation or `eth_estimateGas`; the package contains no token-specific
+  limits inherited from another protocol.
+- Logging is disabled by default. Inject an `ILogger` that follows the host
+  service's privacy policy if operational events are required.
+
+The selected network's OffchainOracle deployment must contain valid rates and must be
+protected by the protocol's TWAP/deviation policy. The library cannot create or
+initialize that on-chain state. Call `assertReady()` during application startup;
+do not accept traffic if it fails.
+
+Mainnet addresses in Config 1.1.0 are provisional copies of Sepolia. Accepting
+chain ID `1` only enables backend configuration; it does not establish that
+contracts or oracle rates exist. Readiness and pricing still fail when required
+on-chain data is absent or the RPC reports another chain.
+
+## Installation
+
+```bash
+yarn add @mixerx/oracles@3.1.0
+```
+
+Node.js 24.12.0 or newer is required.
+
+## Usage
+
+```ts
+import {
+  createMixerxOraclesModule,
+  type ITokenPriceRepository,
+} from '@mixerx/oracles';
+
+const priceRepository: ITokenPriceRepository = {
+  getQuote: async (symbol) => readCachedQuote(symbol),
+};
+
+const oracles = createMixerxOraclesModule({
+  chainId: 11155111,
+  rpcUrl: process.env.SEPOLIA_RPC_URL!,
+  relayerFeePercent: 0.004,
+  priceRepository,
+  maxGasPriceGwei: 100,
+  maxPriceAgeMs: 120_000,
+  maxTotalFeeBps: 1_000,
+  priceBounds: {
+    fds: {
+      minimumWeiPerToken: minimumAcceptedFdsPrice,
+      maximumWeiPerToken: maximumAcceptedFdsPrice,
+    },
+  },
+});
+
+await oracles.assertReady();
+
+const fee = await oracles.mixerXFeeOracle.calculateWithdrawalFee({
+  currency: 'fds',
+  amount: 1_000_000_000_000_000_000n,
+  decimals: 18,
+  gasLimit: estimatedWithdrawalGas,
+  refund: '0',
+  purpose: 'fee',
+});
+
+console.log({
+  totalFee: fee.totalFee,
+  tokenPriceInEth: fee.tokenPriceInEth,
+  priceSource: fee.priceSource,
+  priceObservedAtMs: fee.priceObservedAtMs,
+  baseFeePerGas: fee.baseFeePerGas,
+  effectiveGasPriceWei: fee.gasPriceWei,
+  gasSource: fee.gasSource,
+});
+```
+
+`fee_quote` and `fee_validation` remain accepted as input aliases for migration,
+but both normalize to the single `fee` policy in returned data.
+
+## Price-feed operation
+
+`fetchPrices()` reads all tokens configured for the selected network through Multicall3 at one
+explicit block. It returns the complete price map together with `blockNumber`
+and `observedAtMs`, and only succeeds when every token succeeds. The host price
+feed must persist each price and its observation metadata atomically. Fee
+calculation never falls back from that repository to a spot value.
+
+The default Multicall3 address is
+`0xcA11bde05977b3631167028862bE2a173976CA11`; an explicit verified address can
+be supplied with `multicallAddress`.
+
+## Development
+
+```bash
+yarn install --immutable
+yarn validate
+yarn npm audit --all --recursive --severity high
+```
+
+CI executes those gates for every pull request. Published packages pin the
+protocol configuration dependency exactly.
+
+## License
+
+GPL-3.0-only. See `LICENSE`.

package/dist/application/ports/ILogger.js

@@ -23,4 +23,3 @@ class ConsoleLogger {
     }
 }
 exports.ConsoleLogger = ConsoleLogger;
-//# sourceMappingURL=ILogger.js.map

package/dist/domain/config/TokenDefaults.js

@@ -10,4 +10,3 @@ function getBumpPercent(txType) {
     const key = txType.trim().toLowerCase();
     return BUMP_PERCENTAGES.get(key) ?? 10;
 }
-//# sourceMappingURL=TokenDefaults.js.map

package/dist/domain/exceptions.d.ts

@@ -1,4 +1,4 @@
-export type OracleErrorCode = 'INVALID_CONFIG' | 'INVALID_INPUT' | 'NETWORK_MISMATCH' | 'RPC_REQUEST_FAILED' | 'TOKEN_PRICE_UNAVAILABLE' | 'TOKEN_PRICE_STALE' | 'ECONOMIC_LIMIT_EXCEEDED';
+export type OracleErrorCode = 'INVALID_CONFIG' | 'INVALID_INPUT' | 'NETWORK_MISMATCH' | 'RPC_REQUEST_FAILED' | 'TOKEN_PRICE_UNAVAILABLE' | 'TOKEN_PRICE_STALE' | 'TOKEN_PRICE_OUT_OF_RANGE' | 'ECONOMIC_LIMIT_EXCEEDED';
 export declare class OracleError extends Error {
     readonly code: OracleErrorCode;
     constructor(code: OracleErrorCode, message: string);

package/dist/domain/exceptions.js

@@ -19,4 +19,3 @@ class TokenPriceError extends OracleError {
     }
 }
 exports.TokenPriceError = TokenPriceError;
-//# sourceMappingURL=exceptions.js.map

package/dist/domain/repositories.d.ts

@@ -1,6 +1,5 @@
 import type { TokenPriceQuote } from '../types';
 export interface ITokenPriceRepository {
-    getPrice(symbol: string): Promise<bigint | null | undefined>;
-    getLastUpdateTimestamp(symbol: string): Promise<number | null | undefined>;
+    getQuote(symbol: string): Promise<TokenPriceQuote | null | undefined>;
 }
 export declare function toPriceQuote(price: bigint | null | undefined, observedAtMs: number | null | undefined): TokenPriceQuote | null;

package/dist/domain/repositories.js

@@ -10,4 +10,3 @@ function toPriceQuote(price, observedAtMs) {
     }
     return { priceInEthWei: price, observedAtMs: observedAtMs, source: 'repository' };
 }
-//# sourceMappingURL=repositories.js.map

package/dist/factory.d.ts

@@ -2,8 +2,9 @@ import type { ILogger } from './application/ports/ILogger';
 import type { ITokenPriceRepository } from './domain/repositories';
 import { GasPriceOracle } from './infrastructure/gas/GasPriceOracle';
 import { MixerXFeeOracle } from './infrastructure/mixerx/MixerXFeeOracle';
+import type { TokenPriceBounds } from './infrastructure/mixerx/MixerXFeeOracle';
 import { TokenPriceOracle } from './infrastructure/token-price/TokenPriceOracle';
-import type { ChainId, TokenPrices } from './types';
+import type { ChainId, TokenPriceSnapshot } from './types';
 export interface MixerxOraclesConfig {
     chainId: ChainId;
     rpcUrl: string;
@@ -16,25 +17,14 @@ export interface MixerxOraclesConfig {
     maxGasPriceGwei?: number;
     maxPriceAgeMs?: number;
     maxRefundWei?: bigint;
-    fallbackGasPrices?: {
-        legacy?: {
-            instant: number;
-            fast: number;
-            standard: number;
-            low: number;
-        };
-        eip1559?: {
-            baseFee: number;
-            maxFeePerGas: number;
-            maxPriorityFeePerGas: number;
-        };
-    };
+    maxTotalFeeBps?: number;
+    priceBounds?: Readonly<Record<string, TokenPriceBounds>>;
 }
 export interface IMixerxOraclesModule {
     gasPriceOracle: GasPriceOracle;
     tokenPriceOracle: TokenPriceOracle;
     mixerXFeeOracle: MixerXFeeOracle;
-    fetchPrices(): Promise<TokenPrices>;
+    fetchPrices(): Promise<TokenPriceSnapshot>;
     assertReady(): Promise<void>;
     chainId: ChainId;
 }

package/dist/factory.js

@@ -11,7 +11,6 @@ function createMixerxOraclesModule(config) {
         chainId: config.chainId,
         rpcUrl: config.rpcUrl,
         logger,
-        fallbackGasPrices: config.fallbackGasPrices,
         rpcTimeoutMs: config.rpcTimeoutMs,
         maxGasPriceGwei: config.maxGasPriceGwei,
     });
@@ -28,6 +27,8 @@ function createMixerxOraclesModule(config) {
         maxGasPriceGwei: config.maxGasPriceGwei,
         maxPriceAgeMs: config.maxPriceAgeMs,
         maxRefundWei: config.maxRefundWei,
+        maxTotalFeeBps: config.maxTotalFeeBps,
+        priceBounds: config.priceBounds,
     });
     return {
         gasPriceOracle,
@@ -38,4 +39,3 @@ function createMixerxOraclesModule(config) {
         assertReady: () => mixerXFeeOracle.assertReady(),
     };
 }
-//# sourceMappingURL=factory.js.map

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export { OracleError, TokenPriceError } from './domain/exceptions';
 export type { OracleErrorCode } from './domain/exceptions';
 export type { ILogger } from './application/ports/ILogger';
 export type { ITokenPriceRepository } from './domain/repositories';
+export type { TokenPriceQuote, TokenPriceSnapshot } from './types';
 export type { FeeCalculationResult, MixerXGasPurpose, MixerXFeeCalculationResult, MixerXGasParametersForTxResult, MixerXTxType, WithdrawalFeeInput, } from './infrastructure/mixerx/MixerXFeeOracle';

package/dist/index.js

@@ -19,4 +19,3 @@ __exportStar(require("./factory"), exports);
 var exceptions_1 = require("./domain/exceptions");
 Object.defineProperty(exports, "OracleError", { enumerable: true, get: function () { return exceptions_1.OracleError; } });
 Object.defineProperty(exports, "TokenPriceError", { enumerable: true, get: function () { return exceptions_1.TokenPriceError; } });
-//# sourceMappingURL=index.js.map

package/dist/infrastructure/blockchain/staticProvider.js

@@ -7,7 +7,7 @@ const exceptions_1 = require("../../domain/exceptions");
 const gasOracleConfigs_1 = require("../config/gasOracleConfigs");
 const DEFAULT_RPC_TIMEOUT_MS = 10_000;
 function createVerifiedJsonRpcProvider(rpcUrl, chainId, options, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
-    (0, gasOracleConfigs_1.assertSepoliaChainId)(chainId);
+    (0, gasOracleConfigs_1.assertSupportedChainId)(chainId);
     validateRpcUrl(rpcUrl);
     if (!Number.isInteger(timeoutMs) || timeoutMs < 1_000 || timeoutMs > 60_000) {
         throw new exceptions_1.OracleError('INVALID_CONFIG', 'rpcTimeoutMs must be an integer between 1000 and 60000');
@@ -34,4 +34,3 @@ function validateRpcUrl(rawUrl) {
         throw new exceptions_1.OracleError('INVALID_CONFIG', 'rpcUrl must use HTTPS and must not contain user-info credentials');
     }
 }
-//# sourceMappingURL=staticProvider.js.map

package/dist/infrastructure/config/ProtocolTokenConfig.js

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveOffchainOracleAddress = resolveOffchainOracleAddress;
 exports.resolveDefaultTokens = resolveDefaultTokens;
 const config_1 = require("@mixerx/config");
+const exceptions_1 = require("../../domain/exceptions");
 const gasOracleConfigs_1 = require("./gasOracleConfigs");
 function toSupportedChainId(chainId) {
     const numericChainId = Number(chainId);
-    (0, gasOracleConfigs_1.assertSepoliaChainId)(numericChainId);
+    (0, gasOracleConfigs_1.assertSupportedChainId)(numericChainId);
     if (!(0, config_1.isSupportedNetId)(numericChainId)) {
-        throw new Error(`Unsupported chainId ${chainId} for @mixerx/config`);
+        throw new exceptions_1.OracleError('INVALID_CONFIG', `Unsupported chainId ${chainId} for @mixerx/config`);
     }
     return numericChainId;
 }
@@ -17,7 +18,7 @@ function resolveOffchainOracleAddress(chainId) {
     const network = (0, config_1.getNetworkConfig)(validatedChainId);
     const address = network?.contracts.offchainOracleAddress;
     if (!address) {
-        throw new Error(`Missing offchainOracleAddress in @mixerx/config for chainId ${chainId}`);
+        throw new exceptions_1.OracleError('INVALID_CONFIG', `Missing offchainOracleAddress in @mixerx/config for chainId ${chainId}`);
     }
     return address;
 }
@@ -36,7 +37,7 @@ function resolveDefaultTokens(chainId) {
     }
     if (networkInstances) {
         for (const currencyData of Object.values(networkInstances)) {
-            if (!currencyData.tokenAddress) {
+            if (currencyData.assetType !== 'erc20') {
                 continue;
             }
             const tokenAddress = currencyData.tokenAddress.toLowerCase();
@@ -49,8 +50,7 @@ function resolveDefaultTokens(chainId) {
     }
     const tokens = Array.from(tokenMap.values());
     if (tokens.length === 0) {
-        throw new Error(`No default tokens resolved from @mixerx/config for chainId ${chainId}`);
+        throw new exceptions_1.OracleError('INVALID_CONFIG', `No default tokens resolved from @mixerx/config for chainId ${chainId}`);
     }
     return tokens;
 }
-//# sourceMappingURL=ProtocolTokenConfig.js.map

package/dist/infrastructure/config/gasOracleConfigs.d.ts

@@ -1,3 +1,2 @@
 export type ChainId = number;
-export declare const SEPOLIA_CHAIN_ID = 11155111;
-export declare function assertSepoliaChainId(chainId: number): void;
+export declare function assertSupportedChainId(chainId: number): void;

package/dist/infrastructure/config/gasOracleConfigs.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEPOLIA_CHAIN_ID = void 0;
-exports.assertSepoliaChainId = assertSepoliaChainId;
+exports.assertSupportedChainId = assertSupportedChainId;
+const config_1 = require("@mixerx/config");
 const exceptions_1 = require("../../domain/exceptions");
-exports.SEPOLIA_CHAIN_ID = 11_155_111;
-function assertSepoliaChainId(chainId) {
-    if (chainId !== exports.SEPOLIA_CHAIN_ID) {
-        throw new exceptions_1.OracleError('INVALID_CONFIG', `Unsupported chainId ${String(chainId)}; @mixerx/oracles is Sepolia-only`);
+function assertSupportedChainId(chainId) {
+    if (!(0, config_1.isSupportedNetId)(chainId)) {
+        throw new exceptions_1.OracleError('INVALID_CONFIG', `Unsupported chainId ${String(chainId)}; supported networks: ${config_1.SUPPORTED_NET_IDS.join(', ')}`);
     }
 }
-//# sourceMappingURL=gasOracleConfigs.js.map

package/dist/infrastructure/gas/GasPriceOracle.d.ts

@@ -1,6 +1,8 @@
 import type { ILogger } from '../../application/ports/ILogger';
 import type { ChainId } from '../config/gasOracleConfigs';
 export interface GasPriceParams {
+    effectiveGasPriceWei: string;
+    gasSource: 'rpc';
     gasPrice?: string;
     baseFeePerGas?: string;
     maxFeePerGas?: string;
@@ -9,7 +11,6 @@ export interface GasPriceParams {
 export interface GetTxGasParamsInput {
     isLegacy?: boolean;
     bumpPercent?: number;
-    legacySpeed?: 'instant' | 'fast' | 'standard' | 'low';
 }
 export interface GasPriceOracleOptions {
     chainId: ChainId;
@@ -17,35 +18,21 @@ export interface GasPriceOracleOptions {
     logger?: ILogger;
     rpcTimeoutMs?: number;
     maxGasPriceGwei?: number;
-    fallbackGasPrices?: {
-        legacy?: {
-            instant: number;
-            fast: number;
-            standard: number;
-            low: number;
-        };
-        eip1559?: {
-            baseFee: number;
-            maxFeePerGas: number;
-            maxPriorityFeePerGas: number;
-        };
-    };
 }
 export declare class GasPriceOracle {
     private readonly provider;
     private readonly logger;
     private readonly chainId;
     private readonly maxGasPriceWei;
-    private readonly fallback;
     constructor(options: GasPriceOracleOptions);
     getTxGasParams(input?: GetTxGasParamsInput): Promise<GasPriceParams>;
-    private fallbackParams;
-    private validateFallback;
     private validateGwei;
     private validateBump;
     private bump;
-    private bumpGwei;
     private toWeiGwei;
     private cap;
+    private assertWithinMaximum;
+    private assertPositiveGasPrice;
+    private assertValidEip1559FeeData;
     private min;
 }

package/dist/infrastructure/gas/GasPriceOracle.js

@@ -10,7 +10,6 @@ class GasPriceOracle {
     logger;
     chainId;
     maxGasPriceWei;
-    fallback;
     constructor(options) {
         this.chainId = options.chainId;
         this.provider = (0, staticProvider_1.createVerifiedJsonRpcProvider)(options.rpcUrl, options.chainId, { batchMaxCount: 1 }, options.rpcTimeoutMs);
@@ -21,15 +20,6 @@ class GasPriceOracle {
             throw new exceptions_1.OracleError('INVALID_CONFIG', 'maxGasPriceGwei must be greater than 0');
         }
         this.maxGasPriceWei = this.toWeiGwei(validatedMaxGasPriceGwei);
-        this.fallback = {
-            legacy: options.fallbackGasPrices?.legacy ?? { instant: 35, fast: 25, standard: 20, low: 15 },
-            eip1559: options.fallbackGasPrices?.eip1559 ?? {
-                baseFee: 15,
-                maxFeePerGas: 30,
-                maxPriorityFeePerGas: 2,
-            },
-        };
-        this.validateFallback();
     }
     async getTxGasParams(input = {}) {
         const bumpPercent = this.validateBump(input.bumpPercent ?? 0);
@@ -39,49 +29,51 @@ class GasPriceOracle {
                 this.provider.getFeeData(),
                 this.provider.getBlock('latest'),
             ]);
-            if (!input.isLegacy && feeData.maxFeePerGas && feeData.maxPriorityFeePerGas && block?.baseFeePerGas) {
-                const baseFeePerGas = this.cap(block.baseFeePerGas);
+            if (!input.isLegacy &&
+                feeData.maxFeePerGas !== null &&
+                feeData.maxPriorityFeePerGas !== null &&
+                block?.baseFeePerGas !== null &&
+                block?.baseFeePerGas !== undefined) {
+                this.assertValidEip1559FeeData(block.baseFeePerGas, feeData.maxFeePerGas, feeData.maxPriorityFeePerGas);
+                this.assertWithinMaximum(block.baseFeePerGas, 'base fee');
+                const baseFeePerGas = block.baseFeePerGas;
                 const maxPriorityFeePerGas = this.cap(this.bump(feeData.maxPriorityFeePerGas, bumpPercent));
                 const maxFeePerGas = this.cap(this.bump(feeData.maxFeePerGas, bumpPercent));
+                if (maxFeePerGas < baseFeePerGas) {
+                    throw new exceptions_1.OracleError('RPC_REQUEST_FAILED', 'EIP-1559 fee cap is below the current base fee');
+                }
+                const cappedPriorityFeePerGas = this.min(maxPriorityFeePerGas, maxFeePerGas);
+                const effectiveGasPriceWei = this.min(baseFeePerGas + cappedPriorityFeePerGas, maxFeePerGas);
+                this.assertPositiveGasPrice(effectiveGasPriceWei);
                 return {
                     baseFeePerGas: baseFeePerGas.toString(),
+                    effectiveGasPriceWei: effectiveGasPriceWei.toString(),
+                    gasSource: 'rpc',
                     maxFeePerGas: maxFeePerGas.toString(),
-                    maxPriorityFeePerGas: this.min(maxPriorityFeePerGas, maxFeePerGas).toString(),
+                    maxPriorityFeePerGas: cappedPriorityFeePerGas.toString(),
                 };
             }
-            if (feeData.gasPrice) {
-                return { gasPrice: this.cap(this.bump(feeData.gasPrice, bumpPercent)).toString() };
+            if (feeData.gasPrice !== null) {
+                this.assertWithinMaximum(feeData.gasPrice, 'legacy gas price');
+                const gasPrice = this.cap(this.bump(feeData.gasPrice, bumpPercent));
+                this.assertPositiveGasPrice(gasPrice);
+                return {
+                    effectiveGasPriceWei: gasPrice.toString(),
+                    gasPrice: gasPrice.toString(),
+                    gasSource: 'rpc',
+                };
             }
+            throw new exceptions_1.OracleError('RPC_REQUEST_FAILED', 'Gas RPC response is incomplete');
         }
         catch (error) {
-            if (error instanceof exceptions_1.OracleError && error.code === 'NETWORK_MISMATCH') {
+            if (error instanceof exceptions_1.OracleError &&
+                (error.code === 'NETWORK_MISMATCH' ||
+                    error.code === 'RPC_REQUEST_FAILED' ||
+                    error.code === 'ECONOMIC_LIMIT_EXCEEDED')) {
                 throw error;
             }
-            this.logger.warn('Gas RPC request failed; bounded fallback selected', { code: 'RPC_REQUEST_FAILED' });
-        }
-        return this.fallbackParams(input, bumpPercent);
-    }
-    fallbackParams(input, bumpPercent) {
-        if (input.isLegacy) {
-            const speed = input.legacySpeed ?? 'fast';
-            const gasPrice = this.cap(this.toWeiGwei(this.bumpGwei(this.fallback.legacy[speed], bumpPercent)));
-            return { gasPrice: gasPrice.toString() };
-        }
-        const baseFeePerGas = this.cap(this.toWeiGwei(this.fallback.eip1559.baseFee));
-        const maxFeePerGas = this.cap(this.toWeiGwei(this.bumpGwei(this.fallback.eip1559.maxFeePerGas, bumpPercent)));
-        const priority = this.cap(this.toWeiGwei(this.bumpGwei(this.fallback.eip1559.maxPriorityFeePerGas, bumpPercent)));
-        return {
-            baseFeePerGas: baseFeePerGas.toString(),
-            maxFeePerGas: maxFeePerGas.toString(),
-            maxPriorityFeePerGas: this.min(priority, maxFeePerGas).toString(),
-        };
-    }
-    validateFallback() {
-        for (const [name, value] of Object.entries(this.fallback.legacy)) {
-            this.validateGwei(value, `fallbackGasPrices.legacy.${name}`);
-        }
-        for (const [name, value] of Object.entries(this.fallback.eip1559)) {
-            this.validateGwei(value, `fallbackGasPrices.eip1559.${name}`);
+            this.logger.warn('Gas RPC request failed', { code: 'RPC_REQUEST_FAILED' });
+            throw new exceptions_1.OracleError('RPC_REQUEST_FAILED', 'Gas RPC request failed');
         }
     }
     validateGwei(value, name) {
@@ -99,18 +91,32 @@ class GasPriceOracle {
     bump(value, percent) {
         return percent === 0 ? value : (value * BigInt(100 + percent)) / 100n;
     }
-    bumpGwei(gwei, percent) {
-        return percent === 0 ? gwei : (gwei * (100 + percent)) / 100;
-    }
     toWeiGwei(gwei) {
         return BigInt(Math.round(gwei * 1e9));
     }
     cap(value) {
         return this.min(value, this.maxGasPriceWei);
     }
+    assertWithinMaximum(value, label) {
+        if (value > this.maxGasPriceWei) {
+            throw new exceptions_1.OracleError('ECONOMIC_LIMIT_EXCEEDED', `${label} exceeds maxGasPriceGwei`);
+        }
+    }
+    assertPositiveGasPrice(value) {
+        if (value <= 0n) {
+            throw new exceptions_1.OracleError('RPC_REQUEST_FAILED', 'Gas RPC response has no positive economic value');
+        }
+    }
+    assertValidEip1559FeeData(baseFeePerGas, maxFeePerGas, maxPriorityFeePerGas) {
+        if (baseFeePerGas < 0n ||
+            maxFeePerGas <= 0n ||
+            maxPriorityFeePerGas < 0n ||
+            maxFeePerGas < maxPriorityFeePerGas) {
+            throw new exceptions_1.OracleError('RPC_REQUEST_FAILED', 'EIP-1559 RPC fee data is internally inconsistent');
+        }
+    }
     min(left, right) {
         return left < right ? left : right;
     }
 }
 exports.GasPriceOracle = GasPriceOracle;
-//# sourceMappingURL=GasPriceOracle.js.map