@mento-protocol/mento-sdk 3.2.3 → 3.2.4

package/dist/services/trading/TradingLimitsService.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingLimitsService = void 0;
+const types_1 = require("../../core/types");
+const abis_1 = require("../../core/abis");
+const constants_1 = require("../../core/constants");
+const tradingLimits_1 = require("../../utils/tradingLimits");
+/**
+ * Service for querying trading limits from the Mento protocol.
+ * Supports both FPMM pools (TradingLimitsV2) and Virtual pools (TradingLimitsV1).
+ */
+class TradingLimitsService {
+    constructor(publicClient, chainId) {
+        this.publicClient = publicClient;
+        this.chainId = chainId;
+    }
+    /**
+     * Get trading limits for a pool.
+     * Returns an array of TradingLimit objects for each configured limit.
+     *
+     * @param pool - The pool to get trading limits for
+     * @returns Array of TradingLimit objects with maxIn/maxOut/until
+     */
+    async getPoolTradingLimits(pool) {
+        if (pool.poolType === types_1.PoolType.FPMM) {
+            return this.getFPMMTradingLimits(pool);
+        }
+        else {
+            return this.getVirtualPoolTradingLimits(pool);
+        }
+    }
+    /**
+     * Get trading limits for an FPMM pool.
+     * FPMM pools use TradingLimitsV2 with fixed timeframes.
+     */
+    async getFPMMTradingLimits(pool) {
+        const limits = [];
+        // Get trading limits for both tokens
+        const [token0Limits, token1Limits] = await Promise.all([
+            this.getFPMMTokenLimits(pool.poolAddr, pool.token0),
+            this.getFPMMTokenLimits(pool.poolAddr, pool.token1),
+        ]);
+        limits.push(...token0Limits);
+        limits.push(...token1Limits);
+        return limits;
+    }
+    /**
+     * Get trading limits for a specific token in an FPMM pool.
+     */
+    async getFPMMTokenLimits(poolAddr, token) {
+        try {
+            const result = await this.publicClient.readContract({
+                address: poolAddr,
+                abi: abis_1.FPMM_ABI,
+                functionName: 'getTradingLimits',
+                args: [token],
+            });
+            // Result is a tuple: [config, state]
+            const [configTuple, stateTuple] = result;
+            const config = {
+                limit0: configTuple.limit0,
+                limit1: configTuple.limit1,
+                decimals: configTuple.decimals,
+            };
+            const state = {
+                lastUpdated0: Number(stateTuple.lastUpdated0),
+                lastUpdated1: Number(stateTuple.lastUpdated1),
+                netflow0: stateTuple.netflow0,
+                netflow1: stateTuple.netflow1,
+            };
+            if (!(0, tradingLimits_1.hasConfiguredLimitsV2)(config)) {
+                return [];
+            }
+            return (0, tradingLimits_1.calculateTradingLimitsV2)(config, state, token);
+        }
+        catch {
+            // Token may not have limits configured, or invalid token
+            return [];
+        }
+    }
+    /**
+     * Get trading limits for a Virtual pool.
+     * Virtual pools use TradingLimitsV1 via the Broker contract.
+     */
+    async getVirtualPoolTradingLimits(pool) {
+        if (!pool.exchangeId) {
+            return [];
+        }
+        const limits = [];
+        // Get trading limits for both tokens
+        const [token0Limits, token1Limits] = await Promise.all([
+            this.getVirtualPoolTokenLimits(pool.exchangeId, pool.token0),
+            this.getVirtualPoolTokenLimits(pool.exchangeId, pool.token1),
+        ]);
+        limits.push(...token0Limits);
+        limits.push(...token1Limits);
+        return limits;
+    }
+    /**
+     * Get trading limits for a specific token in a Virtual pool.
+     */
+    async getVirtualPoolTokenLimits(exchangeId, token) {
+        const brokerAddr = (0, constants_1.tryGetContractAddress)(this.chainId, 'Broker');
+        if (!brokerAddr) {
+            return [];
+        }
+        const limitId = (0, tradingLimits_1.computeLimitId)(exchangeId, token);
+        try {
+            // Fetch config and state in parallel
+            const [configResult, stateResult] = await Promise.all([
+                this.publicClient.readContract({
+                    address: brokerAddr,
+                    abi: abis_1.BROKER_ABI,
+                    functionName: 'tradingLimitsConfig',
+                    args: [limitId],
+                }),
+                this.publicClient.readContract({
+                    address: brokerAddr,
+                    abi: abis_1.BROKER_ABI,
+                    functionName: 'tradingLimitsState',
+                    args: [limitId],
+                }),
+            ]);
+            // Parse config result
+            const configTuple = configResult;
+            const config = {
+                timestep0: Number(configTuple[0]),
+                timestep1: Number(configTuple[1]),
+                limit0: configTuple[2],
+                limit1: configTuple[3],
+                limitGlobal: configTuple[4],
+                flags: Number(configTuple[5]),
+            };
+            // Parse state result
+            const stateTuple = stateResult;
+            const state = {
+                lastUpdated0: Number(stateTuple[0]),
+                lastUpdated1: Number(stateTuple[1]),
+                netflow0: stateTuple[2],
+                netflow1: stateTuple[3],
+                netflowGlobal: stateTuple[4],
+            };
+            // Only return limits if configured
+            if (!(0, tradingLimits_1.hasConfiguredLimitsV1)(config)) {
+                return [];
+            }
+            // Get token decimals (V1 uses 0 decimals internally, but we track token decimals for display)
+            // For now, return 0 as the reference - consumers should query token decimals separately
+            const tokenDecimals = 0; // V1 stores values with 0 decimal precision
+            return (0, tradingLimits_1.calculateTradingLimitsV1)(config, state, token, tokenDecimals);
+        }
+        catch {
+            // Trading limits may not be configured for this token
+            return [];
+        }
+    }
+}
+exports.TradingLimitsService = TradingLimitsService;
+//# sourceMappingURL=TradingLimitsService.js.map

package/dist/services/trading/TradingService.d.ts

@@ -0,0 +1,113 @@
+import { PublicClient } from 'viem';
+import { Route, Pool, TradingLimit, PoolTradabilityStatus } from '../../core/types';
+import { RouteService } from '../routes';
+/**
+ * Service for checking trading status and circuit breaker state in the Mento protocol.
+ * Provides methods to query whether trading is enabled for specific rate feeds,
+ * token pairs, or routes. Also integrates trading limit checks.
+ */
+export declare class TradingService {
+    private publicClient;
+    private chainId;
+    private routeService;
+    private tradingLimitsService;
+    constructor(publicClient: PublicClient, chainId: number, routeService: RouteService);
+    /**
+     * Returns the current trading mode for a given rate feed.
+     *
+     * The BreakerBox uses a bitmask approach where 0 means bidirectional trading
+     * is enabled, and any non-zero value means trading is suspended.
+     *
+     * @param rateFeedId - The address of the rate feed
+     * @returns The raw trading mode value from BreakerBox (0 = enabled, non-zero = suspended)
+     *
+     * @example
+     * ```typescript
+     * const mode = await tradingService.getRateFeedTradingMode(rateFeedId)
+     * if (mode === TradingMode.BIDIRECTIONAL) {
+     *   console.log('Trading is enabled')
+     * }
+     * ```
+     */
+    getRateFeedTradingMode(rateFeedId: string): Promise<number>;
+    /**
+     * Checks if a trading pair is currently tradable.
+     * For multi-hop routes (e.g., CELO → USDm → USDT), checks that ALL
+     * intermediate rate feeds are in BIDIRECTIONAL mode.
+     *
+     * @param tokenIn - Input token address
+     * @param tokenOut - Output token address
+     * @returns true if the pair is tradable (all rate feeds BIDIRECTIONAL), false otherwise
+     * @throws {RouteNotFoundError} If no route exists between the token pair
+     *
+     * @example
+     * ```typescript
+     * const isTradable = await tradingService.isPairTradable(USDm, CELO)
+     * if (!isTradable) {
+     *   console.log('Trading is currently suspended for this pair')
+     * }
+     * ```
+     */
+    isPairTradable(tokenIn: string, tokenOut: string): Promise<boolean>;
+    /**
+     * Checks if a route is currently tradable.
+     * Verifies that all pools in the route's path have their rate feeds
+     * in BIDIRECTIONAL mode.
+     *
+     * @param route - The route to check
+     * @returns true if all pools in the route are tradable, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const route = await routeService.findRoute(tokenIn, tokenOut)
+     * const isRouteTradable = await tradingService.isRouteTradable(route)
+     * ```
+     */
+    isRouteTradable(route: Route): Promise<boolean>;
+    /**
+     * Get trading limits for a pool.
+     *
+     * @param pool - The pool to get trading limits for
+     * @returns Array of TradingLimit objects with maxIn/maxOut/until
+     *
+     * @example
+     * ```typescript
+     * const limits = await tradingService.getPoolTradingLimits(pool)
+     * limits.forEach(limit => {
+     *   console.log(`${limit.asset}: maxIn=${limit.maxIn}, maxOut=${limit.maxOut}`)
+     * })
+     * ```
+     */
+    getPoolTradingLimits(pool: Pool): Promise<TradingLimit[]>;
+    /**
+     * Get complete tradability status for a pool.
+     * Returns separate flags for circuit breaker and trading limits,
+     * allowing frontends to show different messages for each condition.
+     *
+     * @param pool - The pool to check
+     * @returns PoolTradabilityStatus with tradable, circuitBreakerOk, limitsOk, and limits
+     *
+     * @example
+     * ```typescript
+     * const status = await tradingService.getPoolTradabilityStatus(pool)
+     * if (!status.circuitBreakerOk) {
+     *   showModal("Trading temporarily suspended (circuit breaker)")
+     * } else if (!status.limitsOk) {
+     *   showModal("Trading limit reached", status.limits)
+     * }
+     * ```
+     */
+    getPoolTradabilityStatus(pool: Pool): Promise<PoolTradabilityStatus>;
+    /**
+     * Get the reference rate feed ID for a pool.
+     * Both FPMM and Virtual pools expose this via the referenceRateFeedID() view function.
+     *
+     * @param pool - The pool to get rate feed ID for
+     * @returns The rate feed ID address
+     */
+    getPoolRateFeedId(pool: Pool): Promise<string>;
+    private getTradingModesForPools;
+    private getPoolRateFeedIds;
+    private getTradingModesForRateFeeds;
+}
+//# sourceMappingURL=TradingService.d.ts.map

package/dist/services/trading/TradingService.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingService = void 0;
+const types_1 = require("../../core/types");
+const TradingLimitsService_1 = require("./TradingLimitsService");
+const abis_1 = require("../../core/abis");
+const constants_1 = require("../../core/constants");
+const multicall_1 = require("../../utils/multicall");
+/**
+ * Service for checking trading status and circuit breaker state in the Mento protocol.
+ * Provides methods to query whether trading is enabled for specific rate feeds,
+ * token pairs, or routes. Also integrates trading limit checks.
+ */
+class TradingService {
+    constructor(publicClient, chainId, routeService) {
+        this.publicClient = publicClient;
+        this.chainId = chainId;
+        this.routeService = routeService;
+        this.tradingLimitsService = new TradingLimitsService_1.TradingLimitsService(publicClient, chainId);
+    }
+    /**
+     * Returns the current trading mode for a given rate feed.
+     *
+     * The BreakerBox uses a bitmask approach where 0 means bidirectional trading
+     * is enabled, and any non-zero value means trading is suspended.
+     *
+     * @param rateFeedId - The address of the rate feed
+     * @returns The raw trading mode value from BreakerBox (0 = enabled, non-zero = suspended)
+     *
+     * @example
+     * ```typescript
+     * const mode = await tradingService.getRateFeedTradingMode(rateFeedId)
+     * if (mode === TradingMode.BIDIRECTIONAL) {
+     *   console.log('Trading is enabled')
+     * }
+     * ```
+     */
+    async getRateFeedTradingMode(rateFeedId) {
+        const breakerBoxAddr = (0, constants_1.getContractAddress)(this.chainId, 'BreakerBox');
+        const mode = await this.publicClient.readContract({
+            address: breakerBoxAddr,
+            abi: abis_1.BREAKERBOX_ABI,
+            functionName: 'getRateFeedTradingMode',
+            args: [rateFeedId],
+        });
+        return Number(mode);
+    }
+    /**
+     * Checks if a trading pair is currently tradable.
+     * For multi-hop routes (e.g., CELO → USDm → USDT), checks that ALL
+     * intermediate rate feeds are in BIDIRECTIONAL mode.
+     *
+     * @param tokenIn - Input token address
+     * @param tokenOut - Output token address
+     * @returns true if the pair is tradable (all rate feeds BIDIRECTIONAL), false otherwise
+     * @throws {RouteNotFoundError} If no route exists between the token pair
+     *
+     * @example
+     * ```typescript
+     * const isTradable = await tradingService.isPairTradable(USDm, CELO)
+     * if (!isTradable) {
+     *   console.log('Trading is currently suspended for this pair')
+     * }
+     * ```
+     */
+    async isPairTradable(tokenIn, tokenOut) {
+        const route = await this.routeService.findRoute(tokenIn, tokenOut);
+        return this.isRouteTradable(route);
+    }
+    /**
+     * Checks if a route is currently tradable.
+     * Verifies that all pools in the route's path have their rate feeds
+     * in BIDIRECTIONAL mode.
+     *
+     * @param route - The route to check
+     * @returns true if all pools in the route are tradable, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const route = await routeService.findRoute(tokenIn, tokenOut)
+     * const isRouteTradable = await tradingService.isRouteTradable(route)
+     * ```
+     */
+    async isRouteTradable(route) {
+        const tradingModes = await this.getTradingModesForPools(route.path);
+        // All rate feeds must have trading enabled for the route to be tradable
+        return tradingModes.every((tradingMode) => (0, types_1.isTradingEnabled)(tradingMode));
+    }
+    /**
+     * Get trading limits for a pool.
+     *
+     * @param pool - The pool to get trading limits for
+     * @returns Array of TradingLimit objects with maxIn/maxOut/until
+     *
+     * @example
+     * ```typescript
+     * const limits = await tradingService.getPoolTradingLimits(pool)
+     * limits.forEach(limit => {
+     *   console.log(`${limit.asset}: maxIn=${limit.maxIn}, maxOut=${limit.maxOut}`)
+     * })
+     * ```
+     */
+    async getPoolTradingLimits(pool) {
+        return this.tradingLimitsService.getPoolTradingLimits(pool);
+    }
+    /**
+     * Get complete tradability status for a pool.
+     * Returns separate flags for circuit breaker and trading limits,
+     * allowing frontends to show different messages for each condition.
+     *
+     * @param pool - The pool to check
+     * @returns PoolTradabilityStatus with tradable, circuitBreakerOk, limitsOk, and limits
+     *
+     * @example
+     * ```typescript
+     * const status = await tradingService.getPoolTradabilityStatus(pool)
+     * if (!status.circuitBreakerOk) {
+     *   showModal("Trading temporarily suspended (circuit breaker)")
+     * } else if (!status.limitsOk) {
+     *   showModal("Trading limit reached", status.limits)
+     * }
+     * ```
+     */
+    async getPoolTradabilityStatus(pool) {
+        const [[tradingMode], limits] = await Promise.all([
+            this.getTradingModesForPools([pool]),
+            this.tradingLimitsService.getPoolTradingLimits(pool),
+        ]);
+        const circuitBreakerOk = (0, types_1.isTradingEnabled)(tradingMode);
+        // Limits are OK if no limits configured OR all limits have capacity
+        const limitsOk = limits.length === 0 || limits.every((l) => l.maxIn > 0n && l.maxOut > 0n);
+        return {
+            tradable: circuitBreakerOk && limitsOk,
+            circuitBreakerOk,
+            tradingMode,
+            limitsOk,
+            limits,
+        };
+    }
+    /**
+     * Get the reference rate feed ID for a pool.
+     * Both FPMM and Virtual pools expose this via the referenceRateFeedID() view function.
+     *
+     * @param pool - The pool to get rate feed ID for
+     * @returns The rate feed ID address
+     */
+    async getPoolRateFeedId(pool) {
+        const [rateFeedId] = await this.getPoolRateFeedIds([pool]);
+        return rateFeedId;
+    }
+    async getTradingModesForPools(pools) {
+        const rateFeedIds = await this.getPoolRateFeedIds(pools);
+        return this.getTradingModesForRateFeeds(rateFeedIds);
+    }
+    async getPoolRateFeedIds(pools) {
+        if (pools.length === 0) {
+            return [];
+        }
+        const results = await (0, multicall_1.multicall)(this.publicClient, pools.map((pool) => ({
+            address: pool.poolAddr,
+            abi: abis_1.FPMM_ABI,
+            functionName: 'referenceRateFeedID',
+            args: [],
+        })), { allowFailure: false });
+        return results.map((result) => {
+            if (result.status === 'failure') {
+                throw result.error;
+            }
+            return result.result;
+        });
+    }
+    async getTradingModesForRateFeeds(rateFeedIds) {
+        if (rateFeedIds.length === 0) {
+            return [];
+        }
+        const breakerBoxAddr = (0, constants_1.getContractAddress)(this.chainId, 'BreakerBox');
+        const uniqueRateFeeds = Array.from(new Map(rateFeedIds.map((rateFeedId) => [rateFeedId.toLowerCase(), rateFeedId])).values());
+        const results = await (0, multicall_1.multicall)(this.publicClient, uniqueRateFeeds.map((rateFeedId) => ({
+            address: breakerBoxAddr,
+            abi: abis_1.BREAKERBOX_ABI,
+            functionName: 'getRateFeedTradingMode',
+            args: [rateFeedId],
+        })), { allowFailure: false });
+        const tradingModes = new Map();
+        for (const [index, result] of results.entries()) {
+            if (result.status === 'failure') {
+                throw result.error;
+            }
+            tradingModes.set(uniqueRateFeeds[index].toLowerCase(), Number(result.result));
+        }
+        return rateFeedIds.map((rateFeedId) => {
+            const tradingMode = tradingModes.get(rateFeedId.toLowerCase());
+            if (tradingMode === undefined) {
+                throw new Error(`Trading mode not found for rate feed ${rateFeedId}`);
+            }
+            return tradingMode;
+        });
+    }
+}
+exports.TradingService = TradingService;
+//# sourceMappingURL=TradingService.js.map

package/dist/services/trading/index.d.ts

@@ -0,0 +1,3 @@
+export * from './TradingService';
+export * from './TradingLimitsService';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/trading/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TradingService"), exports);
+__exportStar(require("./TradingLimitsService"), exports);
+//# sourceMappingURL=index.js.map

package/dist/utils/chainConfig.d.ts

@@ -0,0 +1,16 @@
+import { type Chain } from 'viem/chains';
+/**
+ * Get the default RPC URL for a given chain ID
+ * @param chainId - The chain ID
+ * @returns The default RPC URL for the chain
+ * @throws Error if chain ID is not supported
+ */
+export declare function getDefaultRpcUrl(chainId: number): string;
+/**
+ * Get the viem chain configuration for a given chain ID
+ * @param chainId - The chain ID
+ * @returns The viem chain configuration
+ * @throws Error if chain ID is not supported
+ */
+export declare function getChainConfig(chainId: number): Chain;
+//# sourceMappingURL=chainConfig.d.ts.map

package/dist/utils/chainConfig.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultRpcUrl = getDefaultRpcUrl;
+exports.getChainConfig = getChainConfig;
+const chains_1 = require("viem/chains");
+const viem_1 = require("viem");
+const chainId_1 = require("../core/constants/chainId");
+// Celo Sepolia chain definition (not available in viem/chains yet)
+const celoSepolia = (0, viem_1.defineChain)({
+    id: 11142220,
+    name: 'Celo Sepolia',
+    nativeCurrency: {
+        decimals: 18,
+        name: 'CELO',
+        symbol: 'CELO',
+    },
+    rpcUrls: {
+        default: {
+            http: ['https://forno.celo-sepolia.celo-testnet.org'],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: 'Celo Explorer',
+            url: 'https://sepolia.celoscan.io',
+        },
+    },
+    testnet: true,
+});
+const monadTestnet = (0, viem_1.defineChain)({
+    id: 10143,
+    name: 'Monad Testnet',
+    nativeCurrency: {
+        decimals: 18,
+        name: 'MON',
+        symbol: 'MON',
+    },
+    rpcUrls: {
+        default: {
+            http: ['https://testnet-rpc.monad.xyz'],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: 'Monad Testnet Explorer',
+            url: 'https://testnet.monadexplorer.com',
+        },
+    },
+    contracts: {
+        multicall3: {
+            address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+            blockCreated: 251449,
+        },
+    },
+    testnet: true,
+});
+const monad = (0, viem_1.defineChain)({
+    id: 143,
+    name: 'Monad',
+    nativeCurrency: {
+        decimals: 18,
+        name: 'MON',
+        symbol: 'MON',
+    },
+    rpcUrls: {
+        default: {
+            http: ['https://rpc.monad.xyz'],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: 'Monad Explorer',
+            url: 'https://monadvision.com',
+        },
+    },
+    contracts: {
+        multicall3: {
+            address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+            blockCreated: 9248132,
+        },
+    },
+});
+/**
+ * Get the default RPC URL for a given chain ID
+ * @param chainId - The chain ID
+ * @returns The default RPC URL for the chain
+ * @throws Error if chain ID is not supported
+ */
+function getDefaultRpcUrl(chainId) {
+    switch (chainId) {
+        case chainId_1.ChainId.CELO:
+            return 'https://forno.celo.org';
+        case chainId_1.ChainId.CELO_SEPOLIA:
+            return 'https://forno.celo-sepolia.celo-testnet.org';
+        case chainId_1.ChainId.MONAD_TESTNET:
+            return 'https://testnet-rpc.monad.xyz';
+        case chainId_1.ChainId.MONAD:
+            return 'https://rpc.monad.xyz';
+        default:
+            throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+}
+/**
+ * Get the viem chain configuration for a given chain ID
+ * @param chainId - The chain ID
+ * @returns The viem chain configuration
+ * @throws Error if chain ID is not supported
+ */
+function getChainConfig(chainId) {
+    switch (chainId) {
+        case chainId_1.ChainId.CELO:
+            return chains_1.celo;
+        case chainId_1.ChainId.CELO_SEPOLIA:
+            return celoSepolia;
+        case chainId_1.ChainId.MONAD_TESTNET:
+            return monadTestnet;
+        case chainId_1.ChainId.MONAD:
+            return monad;
+        default:
+            throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+}
+//# sourceMappingURL=chainConfig.js.map

package/dist/utils/costUtils.d.ts

@@ -0,0 +1,12 @@
+import { Pool } from '../core/types';
+import type { PublicClient } from 'viem';
+/**
+ * Calculate cost percentage for a pool based on its type
+ * Returns cost as a percentage (e.g., 0.5 = 0.5%)
+ *
+ * @param pool - The pool to calculate cost for
+ * @param publicClient - Viem public client for RPC calls
+ * @returns Cost percentage for the pool
+ */
+export declare function getPoolCostPercent(pool: Pool, publicClient: PublicClient): Promise<number>;
+//# sourceMappingURL=costUtils.d.ts.map