@mixerx/oracles 1.0.0 → 3.0.0

package/dist/infrastructure/config/ProtocolTokenConfig.js

@@ -3,10 +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;
 }
@@ -15,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;
 }
@@ -34,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();
@@ -47,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,14 +1,3 @@
-import { getNetworkConfig as getProtocolNetworkConfig } from '@mixerx/config';
 export type ChainId = number;
-export interface NetworkConfig {
-    chainId: number;
-    rpcUrl?: string;
-}
-export declare const NETWORKS: Record<number, NetworkConfig>;
-export declare function getNetworkConfig(chainId: ChainId): ReturnType<typeof getProtocolNetworkConfig>;
-export declare function isSupportedChain(chainId: number): boolean;
-export declare function getSupportedChainIds(): number[];
-export declare function getDefaultGasPrice(): number;
-export declare function getMaxGasPrice(): number;
-export declare function getRpcUrl(chainId: number): string | undefined;
-//# sourceMappingURL=gasOracleConfigs.d.ts.map
+export declare const SEPOLIA_CHAIN_ID = 11155111;
+export declare function assertSepoliaChainId(chainId: number): void;

package/dist/infrastructure/config/gasOracleConfigs.js

@@ -1,38 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NETWORKS = void 0;
-exports.getNetworkConfig = getNetworkConfig;
-exports.isSupportedChain = isSupportedChain;
-exports.getSupportedChainIds = getSupportedChainIds;
-exports.getDefaultGasPrice = getDefaultGasPrice;
-exports.getMaxGasPrice = getMaxGasPrice;
-exports.getRpcUrl = getRpcUrl;
-const config_1 = require("@mixerx/config");
-const SUPPORTED_CHAIN_IDS = [...config_1.SUPPORTED_NET_IDS];
-exports.NETWORKS = Object.fromEntries(SUPPORTED_CHAIN_IDS.map((chainId) => [chainId, { chainId }]));
-function getNetworkConfig(chainId) {
-    if (!(0, config_1.isSupportedNetId)(chainId)) {
-        return undefined;
+exports.SEPOLIA_CHAIN_ID = void 0;
+exports.assertSepoliaChainId = assertSepoliaChainId;
+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`);
     }
-    return (0, config_1.getNetworkConfig)(chainId);
 }
-function isSupportedChain(chainId) {
-    return (0, config_1.isSupportedNetId)(chainId);
-}
-function getSupportedChainIds() {
-    return [...SUPPORTED_CHAIN_IDS];
-}
-function getDefaultGasPrice() {
-    return 20;
-}
-function getMaxGasPrice() {
-    return 500;
-}
-function getRpcUrl(chainId) {
-    const network = getNetworkConfig(chainId);
-    if (!network || !('rpcUrl' in network) || typeof network.rpcUrl !== 'string') {
-        return undefined;
-    }
-    return network.rpcUrl;
-}
-//# sourceMappingURL=gasOracleConfigs.js.map

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

@@ -1,41 +1,38 @@
 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;
     maxPriorityFeePerGas?: string;
 }
 export interface GetTxGasParamsInput {
     isLegacy?: boolean;
     bumpPercent?: number;
-    legacySpeed?: 'instant' | 'fast' | 'standard' | 'low';
 }
 export interface GasPriceOracleOptions {
     chainId: ChainId;
     rpcUrl: string;
     logger?: ILogger;
-    fallbackGasPrices?: {
-        legacy?: {
-            instant: number;
-            fast: number;
-            standard: number;
-            low: number;
-        };
-        eip1559?: {
-            baseFee: number;
-            maxFeePerGas: number;
-            maxPriorityFeePerGas: number;
-        };
-    };
+    rpcTimeoutMs?: number;
+    maxGasPriceGwei?: number;
 }
 export declare class GasPriceOracle {
     private readonly provider;
     private readonly logger;
-    private readonly fallback;
+    private readonly chainId;
+    private readonly maxGasPriceWei;
     constructor(options: GasPriceOracleOptions);
     getTxGasParams(input?: GetTxGasParamsInput): Promise<GasPriceParams>;
+    private validateGwei;
+    private validateBump;
     private bump;
     private toWeiGwei;
-    private bumpGwei;
+    private cap;
+    private assertWithinMaximum;
+    private assertPositiveGasPrice;
+    private assertValidEip1559FeeData;
+    private min;
 }
-//# sourceMappingURL=GasPriceOracle.d.ts.map

package/dist/infrastructure/gas/GasPriceOracle.js

@@ -1,77 +1,122 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GasPriceOracle = void 0;
-const ethers_1 = require("ethers");
 const ILogger_1 = require("../../application/ports/ILogger");
+const exceptions_1 = require("../../domain/exceptions");
+const staticProvider_1 = require("../blockchain/staticProvider");
+const DEFAULT_MAX_GAS_PRICE_GWEI = 500;
 class GasPriceOracle {
     provider;
     logger;
-    fallback;
+    chainId;
+    maxGasPriceWei;
     constructor(options) {
-        this.provider = new ethers_1.ethers.JsonRpcProvider(options.rpcUrl);
+        this.chainId = options.chainId;
+        this.provider = (0, staticProvider_1.createVerifiedJsonRpcProvider)(options.rpcUrl, options.chainId, { batchMaxCount: 1 }, options.rpcTimeoutMs);
         this.logger = options.logger ?? new ILogger_1.NullLogger();
-        this.fallback = {
-            legacy: options.fallbackGasPrices?.legacy ?? { instant: 35, fast: 25, standard: 20, low: 15 },
-            eip1559: options.fallbackGasPrices?.eip1559 ?? { baseFee: 15, maxFeePerGas: 30, maxPriorityFeePerGas: 2 },
-        };
+        const maxGasPriceGwei = options.maxGasPriceGwei ?? DEFAULT_MAX_GAS_PRICE_GWEI;
+        const validatedMaxGasPriceGwei = this.validateGwei(maxGasPriceGwei, 'maxGasPriceGwei');
+        if (validatedMaxGasPriceGwei === 0) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', 'maxGasPriceGwei must be greater than 0');
+        }
+        this.maxGasPriceWei = this.toWeiGwei(validatedMaxGasPriceGwei);
     }
     async getTxGasParams(input = {}) {
-        const rawBumpPercent = Number(input.bumpPercent);
-        const bumpPercent = Number.isFinite(rawBumpPercent)
-            ? Math.max(0, Math.floor(rawBumpPercent))
-            : 0;
+        const bumpPercent = this.validateBump(input.bumpPercent ?? 0);
         try {
-            const feeData = await this.provider.getFeeData();
-            if (!input.isLegacy && feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
-                const maxFeePerGas = this.bump(feeData.maxFeePerGas, bumpPercent);
-                const maxPriorityFeePerGas = this.bump(feeData.maxPriorityFeePerGas, bumpPercent);
+            await (0, staticProvider_1.assertProviderNetwork)(this.provider, this.chainId);
+            const [feeData, block] = await Promise.all([
+                this.provider.getFeeData(),
+                this.provider.getBlock('latest'),
+            ]);
+            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: maxPriorityFeePerGas.toString(),
+                    maxPriorityFeePerGas: cappedPriorityFeePerGas.toString(),
                 };
             }
-            if (feeData.gasPrice) {
+            if (feeData.gasPrice !== null) {
+                this.assertWithinMaximum(feeData.gasPrice, 'legacy gas price');
+                const gasPrice = this.cap(this.bump(feeData.gasPrice, bumpPercent));
+                this.assertPositiveGasPrice(gasPrice);
                 return {
-                    gasPrice: this.bump(feeData.gasPrice, bumpPercent).toString(),
+                    effectiveGasPriceWei: gasPrice.toString(),
+                    gasPrice: gasPrice.toString(),
+                    gasSource: 'rpc',
                 };
             }
+            throw new exceptions_1.OracleError('RPC_REQUEST_FAILED', 'Gas RPC response is incomplete');
         }
         catch (error) {
-            this.logger.warn('GasPriceOracle failed to fetch gas price; using fallback', error);
+            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', { code: 'RPC_REQUEST_FAILED' });
+            throw new exceptions_1.OracleError('RPC_REQUEST_FAILED', 'Gas RPC request failed');
         }
-        if (input.isLegacy) {
-            const requestedSpeed = input.legacySpeed;
-            const speed = requestedSpeed && Object.prototype.hasOwnProperty.call(this.fallback.legacy, requestedSpeed)
-                ? requestedSpeed
-                : 'fast';
-            const bumpedLegacyGwei = this.bumpGwei(this.fallback.legacy[speed], bumpPercent);
-            return { gasPrice: this.toWeiGwei(bumpedLegacyGwei).toString() };
+    }
+    validateGwei(value, name) {
+        if (!Number.isFinite(value) || value < 0 || value > DEFAULT_MAX_GAS_PRICE_GWEI) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', `${name} must be a finite number between 0 and ${String(DEFAULT_MAX_GAS_PRICE_GWEI)} gwei`);
         }
-        const bumpedMaxFeePerGasGwei = this.bumpGwei(this.fallback.eip1559.maxFeePerGas, bumpPercent);
-        const bumpedMaxPriorityFeePerGasGwei = this.bumpGwei(this.fallback.eip1559.maxPriorityFeePerGas, bumpPercent);
-        return {
-            maxFeePerGas: this.toWeiGwei(bumpedMaxFeePerGasGwei).toString(),
-            maxPriorityFeePerGas: this.toWeiGwei(bumpedMaxPriorityFeePerGasGwei).toString(),
-        };
+        return value;
     }
-    bump(value, percent) {
-        if (!percent) {
-            return value;
+    validateBump(value) {
+        if (!Number.isFinite(value) || value < 0 || value > 100) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'bumpPercent must be a finite number between 0 and 100');
         }
-        return (value * BigInt(100 + percent)) / 100n;
+        return Math.floor(value);
+    }
+    bump(value, percent) {
+        return percent === 0 ? value : (value * BigInt(100 + percent)) / 100n;
     }
     toWeiGwei(gwei) {
-        if (!Number.isFinite(gwei) || gwei < 0) {
-            throw new Error(`Invalid fallbackGasPrices gwei value: ${String(gwei)}. Expected a finite non-negative number.`);
-        }
         return BigInt(Math.round(gwei * 1e9));
     }
-    bumpGwei(gwei, percent) {
-        if (!percent) {
-            return gwei;
+    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');
         }
-        return (gwei * (100 + percent)) / 100;
+    }
+    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

@@ -0,0 +1,99 @@
+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 { TokenPriceOracle } from '../token-price/TokenPriceOracle';
+export type MixerXTxType = 'relayer_withdrawal' | 'user_withdrawal' | 'relayer_withdrawal_check_v4';
+export type MixerXGasPurpose = 'fee' | 'send' | 'replacement';
+export type LegacyFeePurpose = 'fee_quote' | 'fee_validation';
+export interface MixerXFeeOracleOptions {
+    chainId: ChainId;
+    rpcUrl: string;
+    relayerFeePercent: number;
+    gasPriceOracle?: GasPriceOracle;
+    tokenPriceOracle?: TokenPriceOracle;
+    priceRepository?: ITokenPriceRepository;
+    logger?: ILogger;
+    multicallAddress?: string;
+    offchainOracleAddress?: string;
+    rpcTimeoutMs?: number;
+    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;
+    amount: bigint;
+    decimals: number;
+    /** Gas limit obtained from a simulation or eth_estimateGas for this exact transaction. */
+    gasLimit: number;
+    refund?: string;
+    refundGasMultiplier?: number;
+    txType?: MixerXTxType;
+    purpose?: 'fee' | LegacyFeePurpose;
+}
+export interface MixerXGasParametersForTxInput {
+    txType?: MixerXTxType;
+    purpose?: MixerXGasPurpose | LegacyFeePurpose;
+    isLegacy?: boolean;
+}
+export interface MixerXGasParametersForTxResult extends GasPriceParams {
+    txType: MixerXTxType;
+    purpose: MixerXGasPurpose;
+    bumpPercent: number;
+}
+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;
+    gasPrice?: string;
+    tokenPriceInEth?: bigint;
+    priceSource: 'native' | 'repository';
+    priceObservedAtMs?: number;
+    bumpPercent: number;
+    txType: MixerXTxType;
+    gasPurpose: 'fee';
+}
+export type WithdrawalFeeInput = MixerXWithdrawalFeeInput;
+export type FeeCalculationResult = MixerXFeeCalculationResult;
+export declare class MixerXFeeOracle {
+    private readonly relayerFeePartsPerMillion;
+    private readonly gasPriceOracle;
+    private readonly tokenPriceOracle;
+    private readonly priceRepository?;
+    private readonly logger;
+    private readonly maxPriceAgeMs;
+    private readonly maxRefundWei;
+    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>;
+    private validateFeeInput;
+    private parseRefund;
+    private resolveRefundWei;
+    private getFreshPrice;
+    private validatePriceBounds;
+    private effectiveGasPrice;
+    private assertTotalFee;
+    private normalizePurpose;
+    private validateTxType;
+    private result;
+}