@mixerx/oracles 2.0.0 → 3.0.0

package/README.md

@@ -1,8 +1,8 @@
 # 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.
+Fail-closed Sepolia pricing and gas policy for MixerX. Version 3.0.0 rejects a
+withdrawal quote when its gas or token price is missing, stale or economically
+unsafe.
 
 ## Security contract
 
@@ -13,8 +13,11 @@ price is missing, stale or economically unsafe.
   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.
+- 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.
@@ -29,10 +32,10 @@ do not accept traffic if it fails.
 ## Installation
 
 ```bash
-yarn add @mixerx/oracles@2.0.0
+yarn add @mixerx/oracles@3.0.0
 ```
 
-Node.js 22.12 or newer is required.
+Node.js 24.12.0 or newer is required.
 
 ## Usage
 
@@ -42,18 +45,24 @@ import {
   type ITokenPriceRepository,
 } from '@mixerx/oracles';
 
-const priceRepository: ITokenPriceRepository = {
-  getPrice: async (symbol) => readCachedPrice(symbol),
-  getLastUpdateTimestamp: async () => readLastPriceUpdate(),
-};
+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,
+  maxGasPriceGwei: 100,
+  maxPriceAgeMs: 120_000,
+  maxTotalFeeBps: 1_000,
+  priceBounds: {
+    fds: {
+      minimumWeiPerToken: minimumAcceptedFdsPrice,
+      maximumWeiPerToken: maximumAcceptedFdsPrice,
+    },
+  },
 });
 
 await oracles.assertReady();
@@ -72,8 +81,10 @@ console.log({
   tokenPriceInEth: fee.tokenPriceInEth,
   priceSource: fee.priceSource,
   priceObservedAtMs: fee.priceObservedAtMs,
-  baseFeePerGas: fee.baseFeePerGas,
-});
+  baseFeePerGas: fee.baseFeePerGas,
+  effectiveGasPriceWei: fee.gasPriceWei,
+  gasSource: fee.gasSource,
+});
 ```
 
 `fee_quote` and `fee_validation` remain accepted as input aliases for migration,
@@ -81,10 +92,11 @@ 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.
+`fetchPrices()` reads all configured Sepolia tokens 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

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

@@ -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);
     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.js

@@ -9,4 +9,3 @@ function assertSepoliaChainId(chainId) {
         throw new exceptions_1.OracleError('INVALID_CONFIG', `Unsupported chainId ${String(chainId)}; @mixerx/oracles is Sepolia-only`);
     }
 }
-//# 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

package/dist/infrastructure/mixerx/MixerXFeeOracle.d.ts

@@ -1,7 +1,7 @@
 import type { ILogger } from '../../application/ports/ILogger';
 import { type ITokenPriceRepository } from '../../domain/repositories';
 import { GasPriceOracle, type GasPriceParams } from '../gas/GasPriceOracle';
-import type { ChainId } from '../config/gasOracleConfigs';
+import { type ChainId } from '../config/gasOracleConfigs';
 import { TokenPriceOracle } from '../token-price/TokenPriceOracle';
 export type MixerXTxType = 'relayer_withdrawal' | 'user_withdrawal' | 'relayer_withdrawal_check_v4';
 export type MixerXGasPurpose = 'fee' | 'send' | 'replacement';
@@ -20,6 +20,12 @@ export interface MixerXFeeOracleOptions {
     maxGasPriceGwei?: number;
     maxPriceAgeMs?: number;
     maxRefundWei?: bigint;
+    maxTotalFeeBps?: number;
+    priceBounds?: Readonly<Record<string, TokenPriceBounds>>;
+}
+export interface TokenPriceBounds {
+    minimumWeiPerToken: bigint;
+    maximumWeiPerToken: bigint;
 }
 export interface MixerXWithdrawalFeeInput {
     currency: string;
@@ -28,6 +34,7 @@ export interface MixerXWithdrawalFeeInput {
     /** Gas limit obtained from a simulation or eth_estimateGas for this exact transaction. */
     gasLimit: number;
     refund?: string;
+    refundGasMultiplier?: number;
     txType?: MixerXTxType;
     purpose?: 'fee' | LegacyFeePurpose;
 }
@@ -45,10 +52,12 @@ export interface MixerXFeeCalculationResult {
     gasCost: bigint;
     relayerFee: bigint;
     refundAmount: bigint;
+    refundWei: bigint;
     totalFee: bigint;
     currency: string;
     gasLimit: number;
     gasPriceWei: bigint;
+    gasSource: 'rpc';
     baseFeePerGas?: string;
     maxFeePerGas?: string;
     maxPriorityFeePerGas?: string;
@@ -63,7 +72,6 @@ export interface MixerXFeeCalculationResult {
 export type WithdrawalFeeInput = MixerXWithdrawalFeeInput;
 export type FeeCalculationResult = MixerXFeeCalculationResult;
 export declare class MixerXFeeOracle {
-    private readonly chainId;
     private readonly relayerFeePartsPerMillion;
     private readonly gasPriceOracle;
     private readonly tokenPriceOracle;
@@ -71,18 +79,21 @@ export declare class MixerXFeeOracle {
     private readonly logger;
     private readonly maxPriceAgeMs;
     private readonly maxRefundWei;
-    private readonly supportedCurrencies;
+    private readonly maxTotalFeeBps;
+    private readonly currencyDecimals;
+    private readonly priceBounds;
     constructor(options: MixerXFeeOracleOptions);
     calculateWithdrawalFee(input: MixerXWithdrawalFeeInput): Promise<MixerXFeeCalculationResult>;
     getGasParametersForTx(input?: MixerXGasParametersForTxInput): Promise<MixerXGasParametersForTxResult>;
     assertReady(): Promise<void>;
-    getGasParameters(isLegacy?: boolean): Promise<GasPriceParams>;
-    getChainId(): ChainId;
     private validateFeeInput;
     private parseRefund;
+    private resolveRefundWei;
     private getFreshPrice;
+    private validatePriceBounds;
     private effectiveGasPrice;
     private assertTotalFee;
     private normalizePurpose;
+    private validateTxType;
     private result;
 }