@mixerx/oracles 1.0.0 → 3.0.0

package/dist/infrastructure/mixerx/MixerXFeeOracle.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MixerXFeeOracle = void 0;
+const ILogger_1 = require("../../application/ports/ILogger");
+const TokenDefaults_1 = require("../../domain/config/TokenDefaults");
+const exceptions_1 = require("../../domain/exceptions");
+const repositories_1 = require("../../domain/repositories");
+const GasPriceOracle_1 = require("../gas/GasPriceOracle");
+const gasOracleConfigs_1 = require("../config/gasOracleConfigs");
+const TokenPriceOracle_1 = require("../token-price/TokenPriceOracle");
+const DEFAULT_MAX_PRICE_AGE_MS = 120_000;
+const DEFAULT_MAX_REFUND_WEI = 1000000000000000000n;
+const DEFAULT_MAX_TOTAL_FEE_BPS = 1_000;
+const BASIS_POINTS_SCALE = 10000n;
+const FEE_SCALE = 1000000n;
+const MAX_REFUND_DIGITS = 256;
+const TX_TYPES = new Set([
+    'relayer_withdrawal',
+    'user_withdrawal',
+    'relayer_withdrawal_check_v4',
+]);
+const GAS_PURPOSES = new Set([
+    'fee',
+    'send',
+    'replacement',
+    'fee_quote',
+    'fee_validation',
+]);
+class MixerXFeeOracle {
+    relayerFeePartsPerMillion;
+    gasPriceOracle;
+    tokenPriceOracle;
+    priceRepository;
+    logger;
+    maxPriceAgeMs;
+    maxRefundWei;
+    maxTotalFeeBps;
+    currencyDecimals;
+    priceBounds;
+    constructor(options) {
+        (0, gasOracleConfigs_1.assertSepoliaChainId)(options.chainId);
+        if (!Number.isFinite(options.relayerFeePercent) || options.relayerFeePercent < 0 || options.relayerFeePercent > 0.1) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', 'relayerFeePercent must be between 0 and 0.1');
+        }
+        const relayerFeePartsPerMillion = options.relayerFeePercent * Number(FEE_SCALE);
+        if (!Number.isInteger(relayerFeePartsPerMillion)) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', 'relayerFeePercent exceeds supported precision');
+        }
+        this.maxPriceAgeMs = options.maxPriceAgeMs ?? DEFAULT_MAX_PRICE_AGE_MS;
+        if (!Number.isInteger(this.maxPriceAgeMs) || this.maxPriceAgeMs < 1_000 || this.maxPriceAgeMs > 3_600_000) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', 'maxPriceAgeMs must be between 1000 and 3600000');
+        }
+        this.maxRefundWei = options.maxRefundWei ?? DEFAULT_MAX_REFUND_WEI;
+        if (this.maxRefundWei < 0n) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', 'maxRefundWei cannot be negative');
+        }
+        this.maxTotalFeeBps = options.maxTotalFeeBps ?? DEFAULT_MAX_TOTAL_FEE_BPS;
+        if (!Number.isInteger(this.maxTotalFeeBps) ||
+            this.maxTotalFeeBps < 1 ||
+            this.maxTotalFeeBps > DEFAULT_MAX_TOTAL_FEE_BPS) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', 'maxTotalFeeBps must be an integer between 1 and 1000');
+        }
+        this.relayerFeePartsPerMillion = BigInt(relayerFeePartsPerMillion);
+        this.logger = options.logger ?? new ILogger_1.NullLogger();
+        this.gasPriceOracle = options.gasPriceOracle ?? new GasPriceOracle_1.GasPriceOracle({
+            chainId: options.chainId,
+            rpcUrl: options.rpcUrl,
+            logger: this.logger,
+            rpcTimeoutMs: options.rpcTimeoutMs,
+            maxGasPriceGwei: options.maxGasPriceGwei,
+        });
+        this.tokenPriceOracle = options.tokenPriceOracle ?? new TokenPriceOracle_1.TokenPriceOracle(options.rpcUrl, options.chainId, options.offchainOracleAddress, options.multicallAddress, undefined, this.logger, options.rpcTimeoutMs);
+        const supportedTokens = this.tokenPriceOracle.getSupportedTokens();
+        if (supportedTokens.some((token) => token.symbol.trim().toLowerCase() === 'eth')) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', 'Token symbol eth is reserved for native ETH');
+        }
+        this.currencyDecimals = new Map([
+            ['eth', 18],
+            ...supportedTokens.map((token) => [token.symbol, token.decimals]),
+        ]);
+        this.priceBounds = this.validatePriceBounds(options.priceBounds ?? {});
+        this.priceRepository = options.priceRepository;
+    }
+    async calculateWithdrawalFee(input) {
+        const currency = this.validateFeeInput(input);
+        const txType = this.validateTxType(input.txType ?? 'relayer_withdrawal');
+        const gasParams = await this.getGasParametersForTx({
+            txType,
+            purpose: this.normalizePurpose(input.purpose ?? 'fee'),
+            isLegacy: false,
+        });
+        const gasLimit = input.gasLimit;
+        const gasPriceWei = this.effectiveGasPrice(gasParams);
+        const gasCostWei = gasPriceWei * BigInt(gasLimit);
+        const relayerFee = (input.amount * this.relayerFeePartsPerMillion) / FEE_SCALE;
+        if (currency === 'eth') {
+            if ((input.refund !== undefined && this.parseRefund(input.refund) !== 0n) ||
+                (input.refundGasMultiplier !== undefined && input.refundGasMultiplier !== 0)) {
+                throw new exceptions_1.OracleError('INVALID_INPUT', 'refund must be zero for native ETH withdrawals');
+            }
+            const totalFee = gasCostWei + relayerFee;
+            this.assertTotalFee(totalFee, input.amount);
+            return this.result({
+                gasCost: gasCostWei,
+                relayerFee,
+                refundAmount: 0n,
+                refundWei: 0n,
+                totalFee,
+                currency,
+                gasLimit,
+                gasPriceWei,
+                gasParams,
+                txType,
+                priceSource: 'native',
+            });
+        }
+        const quote = await this.getFreshPrice(currency);
+        const decimalsFactor = 10n ** BigInt(input.decimals);
+        const gasCost = (gasCostWei * decimalsFactor) / quote.priceInEthWei;
+        const refundWei = this.resolveRefundWei(input, gasCostWei);
+        const refundAmount = (refundWei * decimalsFactor) / quote.priceInEthWei;
+        const totalFee = gasCost + relayerFee + refundAmount;
+        this.assertTotalFee(totalFee, input.amount);
+        return this.result({
+            gasCost,
+            relayerFee,
+            refundAmount,
+            refundWei,
+            totalFee,
+            currency,
+            gasLimit,
+            gasPriceWei,
+            gasParams,
+            txType,
+            tokenPriceInEth: quote.priceInEthWei,
+            priceSource: quote.source,
+            priceObservedAtMs: quote.observedAtMs,
+        });
+    }
+    async getGasParametersForTx(input = {}) {
+        const txType = this.validateTxType(input.txType ?? 'relayer_withdrawal');
+        const purpose = this.normalizePurpose(input.purpose ?? 'send');
+        const bumpPercent = purpose === 'send' ? 0 : (0, TokenDefaults_1.getBumpPercent)(txType);
+        const gasParams = await this.gasPriceOracle.getTxGasParams({
+            isLegacy: input.isLegacy ?? false,
+            bumpPercent,
+        });
+        return { ...gasParams, txType, purpose, bumpPercent };
+    }
+    async assertReady() {
+        await Promise.all([
+            this.gasPriceOracle.getTxGasParams(),
+            this.tokenPriceOracle.fetchPrices(),
+        ]);
+        await Promise.all(this.tokenPriceOracle
+            .getSupportedTokens()
+            .map((token) => this.getFreshPrice(token.symbol)));
+    }
+    validateFeeInput(input) {
+        const currency = input.currency.trim().toLowerCase();
+        if (!/^[a-z0-9]{2,16}$/.test(currency)) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'currency must be a valid protocol token symbol');
+        }
+        const configuredDecimals = this.currencyDecimals.get(currency);
+        if (configuredDecimals === undefined) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', `Unsupported MixerX currency: ${currency}`);
+        }
+        if (input.amount <= 0n) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'amount must be greater than zero');
+        }
+        if (!Number.isInteger(input.decimals) || input.decimals < 0 || input.decimals > 255) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'decimals must be an integer between 0 and 255');
+        }
+        if (input.decimals !== configuredDecimals) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', `${currency} must use configured decimals ${String(configuredDecimals)}`);
+        }
+        if (!Number.isInteger(input.gasLimit) || input.gasLimit < 21_000 || input.gasLimit > 5_000_000) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'gasLimit must be an integer between 21000 and 5000000');
+        }
+        return currency;
+    }
+    parseRefund(raw) {
+        if (typeof raw !== 'string' || raw.length > MAX_REFUND_DIGITS || !/^\d+$/.test(raw)) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'refund must be an unsigned base-10 integer string');
+        }
+        const refund = BigInt(raw);
+        if (refund > this.maxRefundWei) {
+            throw new exceptions_1.OracleError('ECONOMIC_LIMIT_EXCEEDED', 'refund exceeds maxRefundWei');
+        }
+        return refund;
+    }
+    resolveRefundWei(input, gasCostWei) {
+        if (input.refund !== undefined && input.refundGasMultiplier !== undefined) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'Specify either refund or refundGasMultiplier, not both');
+        }
+        if (input.refundGasMultiplier === undefined) {
+            return this.parseRefund(input.refund ?? '0');
+        }
+        if (!Number.isSafeInteger(input.refundGasMultiplier) ||
+            input.refundGasMultiplier < 0 ||
+            input.refundGasMultiplier > 10) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'refundGasMultiplier must be an integer between 0 and 10');
+        }
+        return this.parseRefund((gasCostWei * BigInt(input.refundGasMultiplier)).toString());
+    }
+    async getFreshPrice(symbol) {
+        if (!this.priceRepository) {
+            throw new exceptions_1.OracleError('TOKEN_PRICE_UNAVAILABLE', `No fresh price repository configured for ${symbol}`);
+        }
+        const storedQuote = await this.priceRepository.getQuote(symbol);
+        const quote = (0, repositories_1.toPriceQuote)(storedQuote?.priceInEthWei, storedQuote?.observedAtMs);
+        if (!quote) {
+            throw new exceptions_1.OracleError('TOKEN_PRICE_UNAVAILABLE', `Price unavailable for ${symbol}`);
+        }
+        if (Date.now() - quote.observedAtMs > this.maxPriceAgeMs || quote.observedAtMs > Date.now() + 5_000) {
+            throw new exceptions_1.OracleError('TOKEN_PRICE_STALE', `Price is stale for ${symbol}`);
+        }
+        const bounds = this.priceBounds.get(symbol);
+        if (bounds &&
+            (quote.priceInEthWei < bounds.minimumWeiPerToken ||
+                quote.priceInEthWei > bounds.maximumWeiPerToken)) {
+            throw new exceptions_1.OracleError('TOKEN_PRICE_OUT_OF_RANGE', `Price is outside configured bounds for ${symbol}`);
+        }
+        return quote;
+    }
+    validatePriceBounds(configuredBounds) {
+        const validated = new Map();
+        for (const [rawSymbol, bounds] of Object.entries(configuredBounds)) {
+            const symbol = rawSymbol.trim().toLowerCase();
+            if (!this.currencyDecimals.has(symbol) ||
+                bounds.minimumWeiPerToken <= 0n ||
+                bounds.maximumWeiPerToken <= bounds.minimumWeiPerToken) {
+                throw new exceptions_1.OracleError('INVALID_CONFIG', `Invalid token price bounds for ${symbol}`);
+            }
+            validated.set(symbol, Object.freeze({ ...bounds }));
+        }
+        return validated;
+    }
+    effectiveGasPrice(params) {
+        return BigInt(params.effectiveGasPriceWei);
+    }
+    assertTotalFee(totalFee, amount) {
+        const maximumFee = (amount * BigInt(this.maxTotalFeeBps)) / BASIS_POINTS_SCALE;
+        if (totalFee <= 0n || totalFee > maximumFee) {
+            const maximumPercent = (this.maxTotalFeeBps / 100).toFixed(2);
+            throw new exceptions_1.OracleError('ECONOMIC_LIMIT_EXCEEDED', `Total fee must be greater than zero and no more than ${maximumPercent}% of the withdrawal amount`);
+        }
+    }
+    normalizePurpose(purpose) {
+        if (typeof purpose !== 'string' || !GAS_PURPOSES.has(purpose)) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'purpose is not supported');
+        }
+        if (purpose === 'fee_quote' || purpose === 'fee_validation') {
+            return 'fee';
+        }
+        return purpose;
+    }
+    validateTxType(txType) {
+        if (typeof txType !== 'string' || !TX_TYPES.has(txType)) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', 'txType is not supported');
+        }
+        return txType;
+    }
+    result(input) {
+        this.logger.debug('Withdrawal fee calculated', {
+            priceSource: input.priceSource,
+            gasPurpose: 'fee',
+        });
+        return {
+            gasCost: input.gasCost,
+            relayerFee: input.relayerFee,
+            refundAmount: input.refundAmount,
+            refundWei: input.refundWei,
+            totalFee: input.totalFee,
+            currency: input.currency,
+            gasLimit: input.gasLimit,
+            gasPriceWei: input.gasPriceWei,
+            gasSource: input.gasParams.gasSource,
+            baseFeePerGas: input.gasParams.baseFeePerGas,
+            maxFeePerGas: input.gasParams.maxFeePerGas,
+            maxPriorityFeePerGas: input.gasParams.maxPriorityFeePerGas,
+            gasPrice: input.gasParams.gasPrice,
+            tokenPriceInEth: input.tokenPriceInEth,
+            priceSource: input.priceSource,
+            priceObservedAtMs: input.priceObservedAtMs,
+            bumpPercent: input.gasParams.bumpPercent,
+            txType: input.txType,
+            gasPurpose: 'fee',
+        };
+    }
+}
+exports.MixerXFeeOracle = MixerXFeeOracle;

package/dist/infrastructure/multicall/MulticallProvider.d.ts

@@ -1,3 +1,4 @@
+import type { ChainId } from '../../types';
 export interface Call {
     target: string;
     callData: string;
@@ -6,9 +7,14 @@ export interface CallResult {
     success: boolean;
     returnData: string;
 }
+export interface MulticallResult {
+    blockNumber: number;
+    results: CallResult[];
+}
 export declare class MulticallProvider {
     private readonly provider;
-    constructor(rpcUrl: string, _multicallAddress?: string);
-    aggregate(calls: Call[]): Promise<CallResult[]>;
+    private readonly multicall;
+    private readonly chainId;
+    constructor(rpcUrl: string, multicallAddress: string | undefined, chainId: ChainId | number, rpcTimeoutMs?: number);
+    aggregate(calls: readonly Call[]): Promise<MulticallResult>;
 }
-//# sourceMappingURL=MulticallProvider.d.ts.map

package/dist/infrastructure/multicall/MulticallProvider.js

@@ -2,22 +2,60 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MulticallProvider = void 0;
 const ethers_1 = require("ethers");
+const exceptions_1 = require("../../domain/exceptions");
+const staticProvider_1 = require("../blockchain/staticProvider");
+const gasOracleConfigs_1 = require("../config/gasOracleConfigs");
+const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+const MAX_CALLS = 64;
+const MULTICALL3_ABI = [
+    'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+];
 class MulticallProvider {
     provider;
-    constructor(rpcUrl, _multicallAddress) {
-        this.provider = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+    multicall;
+    chainId;
+    constructor(rpcUrl, multicallAddress = MULTICALL3_ADDRESS, chainId, rpcTimeoutMs) {
+        (0, gasOracleConfigs_1.assertSepoliaChainId)(chainId);
+        if (!ethers_1.ethers.isAddress(multicallAddress)) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', 'multicallAddress must be a valid EVM address');
+        }
+        this.chainId = chainId;
+        this.provider = (0, staticProvider_1.createVerifiedJsonRpcProvider)(rpcUrl, chainId, { batchMaxCount: 1 }, rpcTimeoutMs);
+        this.multicall = new ethers_1.ethers.Contract(multicallAddress, MULTICALL3_ABI, this.provider);
     }
     async aggregate(calls) {
-        return Promise.all(calls.map(async ({ target, callData }) => {
-            try {
-                const returnData = await this.provider.call({ to: target, data: callData });
-                return { success: true, returnData };
+        if (calls.length > MAX_CALLS) {
+            throw new exceptions_1.OracleError('INVALID_INPUT', `Multicall supports at most ${String(MAX_CALLS)} calls`);
+        }
+        if (calls.length === 0) {
+            return { blockNumber: await this.provider.getBlockNumber(), results: [] };
+        }
+        for (const call of calls) {
+            if (!ethers_1.ethers.isAddress(call.target) || !ethers_1.ethers.isHexString(call.callData)) {
+                throw new exceptions_1.OracleError('INVALID_INPUT', 'Every multicall target and calldata value must be valid');
             }
-            catch {
-                return { success: false, returnData: '0x' };
+        }
+        try {
+            await (0, staticProvider_1.assertProviderNetwork)(this.provider, this.chainId);
+            const blockNumber = await this.provider.getBlockNumber();
+            const rawResults = (await this.multicall.aggregate3.staticCall(calls.map((call) => ({ ...call, allowFailure: true })), { blockTag: blockNumber }));
+            if (rawResults.length !== calls.length) {
+                throw new exceptions_1.OracleError('RPC_REQUEST_FAILED', 'Multicall returned an unexpected number of results');
             }
-        }));
+            return {
+                blockNumber,
+                results: rawResults.map((result) => ({
+                    success: result.success,
+                    returnData: result.returnData,
+                })),
+            };
+        }
+        catch (error) {
+            if (error instanceof exceptions_1.OracleError) {
+                throw error;
+            }
+            throw new exceptions_1.OracleError('RPC_REQUEST_FAILED', 'Multicall RPC request failed');
+        }
     }
 }
 exports.MulticallProvider = MulticallProvider;
-//# sourceMappingURL=MulticallProvider.js.map

package/dist/infrastructure/token-price/TokenPriceOracle.d.ts

@@ -1,50 +1,13 @@
-import { ILogger } from '../../application/ports/ILogger';
-import { ChainId, Token } from '../../types';
-export interface TokenPrices {
-    [symbol: string]: string;
-}
-/**
- * TokenPriceOracle
- * Fetches token prices from OffchainOracle using Multicall
- * Based on @tornado/tornado-oracles TokenPriceOracle
- *
- * Uses protocol-configured OffchainOracle from @mixerx/config
- * Returns price rate to ETH in wei (how much ETH 1 token = X wei)
- *
- * NOTE: Uses centralized TokenDefaults to avoid duplication
- */
+import type { ILogger } from '../../application/ports/ILogger';
+import type { ChainId, Token, TokenPriceSnapshot } from '../../types';
 export declare class TokenPriceOracle {
-    private multicall;
-    private offchainOracleAddress;
-    private offchainOracleAbi;
-    private defaultTokens;
-    private defaultPrices;
-    private logger;
-    constructor(rpcUrl: string, chainId: ChainId | number, offchainOracleAddress?: string, multicallAddress?: string, tokens?: Token[], logger?: ILogger);
-    /**
-     * Fetch prices for tokens
-     * Uses multicall to batch requests
-     */
-    fetchPrices(tokens?: Token[]): Promise<TokenPrices>;
-    /**
-     * Fetch price for single token
-     */
-    fetchPrice(token: Token): Promise<string | null>;
-    /**
-     * Get default prices
-     */
-    getDefaultPrices(): TokenPrices;
-    /**
-     * Get supported tokens
-     */
+    private readonly multicall;
+    private readonly offchainOracleAddress;
+    private readonly interface;
+    private readonly logger;
+    private readonly defaultTokens;
+    constructor(rpcUrl: string, chainId: ChainId | number, offchainOracleAddress?: string, multicallAddress?: string, tokens?: Token[], logger?: ILogger, rpcTimeoutMs?: number);
+    fetchPrices(tokens?: readonly Token[]): Promise<TokenPriceSnapshot>;
     getSupportedTokens(): Token[];
-    /**
-     * Add custom tokens
-     */
-    addTokens(tokens: Token[]): void;
-    /**
-     * Encode getRateToEth call
-     */
-    private encodeGetRateToEth;
+    private normalizeTokens;
 }
-//# sourceMappingURL=TokenPriceOracle.d.ts.map

package/dist/infrastructure/token-price/TokenPriceOracle.js

@@ -2,132 +2,100 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenPriceOracle = void 0;
 const ethers_1 = require("ethers");
-const MulticallProvider_1 = require("../multicall/MulticallProvider");
-const TokenDefaults_1 = require("../../domain/config/TokenDefaults");
 const ILogger_1 = require("../../application/ports/ILogger");
+const exceptions_1 = require("../../domain/exceptions");
 const ProtocolTokenConfig_1 = require("../config/ProtocolTokenConfig");
-/**
- * TokenPriceOracle
- * Fetches token prices from OffchainOracle using Multicall
- * Based on @tornado/tornado-oracles TokenPriceOracle
- *
- * Uses protocol-configured OffchainOracle from @mixerx/config
- * Returns price rate to ETH in wei (how much ETH 1 token = X wei)
- *
- * NOTE: Uses centralized TokenDefaults to avoid duplication
- */
+const MulticallProvider_1 = require("../multicall/MulticallProvider");
+const MAX_TOKENS = 32;
+const OFFCHAIN_ORACLE_ABI = [
+    'function getRateToEth(address srcToken, bool useSrcWrappers) external view returns (uint256 weightedRate)',
+];
 class TokenPriceOracle {
     multicall;
     offchainOracleAddress;
-    offchainOracleAbi = [
-        'function getRateToEth(address srcToken, bool useSrcWrappers) external view returns (uint256 weightedRate)',
-    ];
-    // Default tokens from @mixerx/config by chain
-    defaultTokens;
-    // Default prices as fallback (in wei) - from TokenDefaults
-    defaultPrices = TokenDefaults_1.DEFAULT_TOKEN_PRICES;
+    interface = new ethers_1.ethers.Interface(OFFCHAIN_ORACLE_ABI);
     logger;
-    constructor(rpcUrl, chainId, offchainOracleAddress, multicallAddress, tokens, logger) {
-        this.multicall = new MulticallProvider_1.MulticallProvider(rpcUrl, multicallAddress);
+    defaultTokens;
+    constructor(rpcUrl, chainId, offchainOracleAddress, multicallAddress, tokens, logger, rpcTimeoutMs) {
         this.offchainOracleAddress = offchainOracleAddress ?? (0, ProtocolTokenConfig_1.resolveOffchainOracleAddress)(chainId);
-        this.defaultTokens = tokens ?? (0, ProtocolTokenConfig_1.resolveDefaultTokens)(chainId);
+        if (!ethers_1.ethers.isAddress(this.offchainOracleAddress)) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', 'offchainOracleAddress must be a valid EVM address');
+        }
+        this.defaultTokens = this.normalizeTokens(tokens ?? (0, ProtocolTokenConfig_1.resolveDefaultTokens)(chainId));
+        this.multicall = new MulticallProvider_1.MulticallProvider(rpcUrl, multicallAddress, chainId, rpcTimeoutMs);
         this.logger = logger ?? new ILogger_1.NullLogger();
     }
-    /**
-     * Fetch prices for tokens
-     * Uses multicall to batch requests
-     */
     async fetchPrices(tokens = this.defaultTokens) {
-        try {
-            if (tokens.length === 0) {
-                return {};
+        const normalizedTokens = this.normalizeTokens(tokens);
+        const calls = normalizedTokens.map((token) => ({
+            target: this.offchainOracleAddress,
+            callData: this.interface.encodeFunctionData('getRateToEth', [token.address, true]),
+        }));
+        const { blockNumber, results } = await this.multicall.aggregate(calls);
+        const prices = Object.create(null);
+        const failedSymbols = [];
+        for (const [index, result] of results.entries()) {
+            const token = normalizedTokens[index];
+            if (!result.success) {
+                failedSymbols.push(token.symbol);
+                continue;
             }
-            // Prepare multicall data
-            const calls = tokens.map(token => ({
-                target: this.offchainOracleAddress,
-                callData: this.encodeGetRateToEth(token.address),
-            }));
-            // Execute multicall
-            const results = await this.multicall.aggregate(calls);
-            const prices = {};
-            for (let i = 0; i < results.length; i++) {
-                const token = tokens[i];
-                const result = results[i];
-                if (!result.success) {
-                    // Use default price if available
-                    const defaultPrice = this.defaultPrices[token.symbol.toLowerCase()];
-                    if (defaultPrice) {
-                        prices[token.symbol.toLowerCase()] = defaultPrice;
-                        this.logger.warn('TokenPriceOracle default price used (call failed)', {
-                            symbol: token.symbol,
-                            address: token.address,
-                        });
-                    }
+            try {
+                const rateWei = this.interface.decodeFunctionResult('getRateToEth', result.returnData)[0];
+                const price = (rateWei * 10n ** BigInt(token.decimals)) / 10n ** 18n;
+                if (price <= 0n) {
+                    failedSymbols.push(token.symbol);
                     continue;
                 }
-                try {
-                    // Decode result
-                    const rateWei = ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(['uint256'], result.returnData)[0];
-                    // Convert rate to proper decimals
-                    // Formula: (rate * 10^tokenDecimals) / 10^18
-                    const tokenDecimals = 10n ** BigInt(token.decimals);
-                    const ethDecimals = 10n ** 18n;
-                    const price = (rateWei * tokenDecimals) / ethDecimals;
-                    prices[token.symbol.toLowerCase()] = price.toString();
-                }
-                catch (decodeError) {
-                    // Use default if decoding fails
-                    const defaultPrice = this.defaultPrices[token.symbol.toLowerCase()];
-                    if (defaultPrice) {
-                        prices[token.symbol.toLowerCase()] = defaultPrice;
-                        this.logger.warn('TokenPriceOracle default price used (decode failed)', {
-                            symbol: token.symbol,
-                            address: token.address,
-                        });
-                    }
-                }
+                prices[token.symbol] = price.toString();
+            }
+            catch {
+                failedSymbols.push(token.symbol);
             }
-            return prices;
         }
-        catch (error) {
-            this.logger.error('Failed to fetch token prices:', error);
-            // Return defaults on complete failure
-            this.logger.warn('TokenPriceOracle using default prices (fetch failed)');
-            return this.defaultPrices;
+        if (failedSymbols.length > 0) {
+            this.logger.warn('Token price batch rejected', { failedSymbols: [...failedSymbols] });
+            throw new exceptions_1.TokenPriceError('One or more on-chain token prices are unavailable', failedSymbols);
         }
+        return Object.freeze({
+            prices: Object.freeze({ ...prices }),
+            observedAtMs: Date.now(),
+            blockNumber,
+        });
     }
-    /**
-     * Fetch price for single token
-     */
-    async fetchPrice(token) {
-        const prices = await this.fetchPrices([token]);
-        return prices[token.symbol.toLowerCase()] || null;
-    }
-    /**
-     * Get default prices
-     */
-    getDefaultPrices() {
-        return { ...this.defaultPrices };
-    }
-    /**
-     * Get supported tokens
-     */
     getSupportedTokens() {
-        return [...this.defaultTokens];
-    }
-    /**
-     * Add custom tokens
-     */
-    addTokens(tokens) {
-        this.defaultTokens = [...this.defaultTokens, ...tokens];
+        return this.defaultTokens.map((token) => ({ ...token }));
     }
-    /**
-     * Encode getRateToEth call
-     */
-    encodeGetRateToEth(tokenAddress) {
-        const iface = new ethers_1.ethers.Interface(this.offchainOracleAbi);
-        return iface.encodeFunctionData('getRateToEth', [tokenAddress, true]);
+    normalizeTokens(tokens) {
+        if (tokens.length === 0) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', `Token list must contain between 1 and ${String(MAX_TOKENS)} items`);
+        }
+        const byAddress = new Map();
+        const symbols = new Set();
+        for (const token of tokens) {
+            const address = token.address.trim().toLowerCase();
+            const symbol = token.symbol.trim().toLowerCase();
+            if (!ethers_1.ethers.isAddress(address) || !/^[a-z0-9]{2,16}$/.test(symbol)) {
+                throw new exceptions_1.OracleError('INVALID_CONFIG', 'Token address or symbol is invalid');
+            }
+            if (!Number.isInteger(token.decimals) || token.decimals < 0 || token.decimals > 255) {
+                throw new exceptions_1.OracleError('INVALID_CONFIG', `Invalid decimals for token ${symbol}`);
+            }
+            if (symbols.has(symbol) && byAddress.get(address)?.symbol !== symbol) {
+                throw new exceptions_1.OracleError('INVALID_CONFIG', `Duplicate token symbol: ${symbol}`);
+            }
+            const existingToken = byAddress.get(address);
+            if (existingToken &&
+                (existingToken.symbol !== symbol || existingToken.decimals !== token.decimals)) {
+                throw new exceptions_1.OracleError('INVALID_CONFIG', `Conflicting metadata for token address: ${address}`);
+            }
+            symbols.add(symbol);
+            byAddress.set(address, { address, symbol, decimals: token.decimals });
+        }
+        if (byAddress.size > MAX_TOKENS) {
+            throw new exceptions_1.OracleError('INVALID_CONFIG', `Token list exceeds ${String(MAX_TOKENS)} unique addresses`);
+        }
+        return [...byAddress.values()];
     }
 }
 exports.TokenPriceOracle = TokenPriceOracle;
-//# sourceMappingURL=TokenPriceOracle.js.map