@mento-protocol/mento-sdk 3.2.3 → 3.2.4

package/dist/services/swap/SwapService.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapService = void 0;
+const viem_1 = require("viem");
+const abis_1 = require("../../core/abis");
+const constants_1 = require("../../core/constants");
+const pathEncoder_1 = require("../../utils/pathEncoder");
+const validation_1 = require("../../utils/validation");
+const utils_1 = require("../../utils");
+const QuoteService_1 = require("../quotes/QuoteService");
+/**
+ * Service for building token swap transactions on the Mento protocol.
+ * Returns transaction parameters that can be executed by any wallet.
+ */
+class SwapService {
+    constructor(publicClient, chainId, routeService, quoteService) {
+        this.publicClient = publicClient;
+        this.chainId = chainId;
+        this.routeService = routeService;
+        this.quoteService = quoteService;
+    }
+    /**
+     * Builds a complete swap transaction including approval if needed.
+     * This is the recommended method for most use cases.
+     *
+     * @param tokenIn - The address of the input token (e.g., '0x765DE816845861e75A25fCA122bb6898B8B1282a')
+     * @param tokenOut - The address of the output token (e.g., '0x471EcE3750Da237f93B8E339c536989b8978a438')
+     * @param amountIn - The amount of input tokens (in wei/smallest unit)
+     * @param recipient - The address to receive the output tokens
+     * @param owner - The address that owns the input tokens (needed to check allowance)
+     * @param options - Swap configuration options (slippage, deadline)
+     * @param route - Optional pre-fetched route for better performance
+     * @returns Combined transaction with approval (if needed) and swap params
+     * @throws {Error} 'amountIn must be greater than zero' - if amountIn <= 0
+     * @throws {Error} 'Slippage tolerance cannot be negative' - if slippageTolerance < 0
+     * @throws {Error} 'Slippage tolerance exceeds maximum' - if slippageTolerance > 20%
+     * @throws {Error} 'Deadline must be in the future' - if deadline is not a future timestamp
+     * @throws {Error} Invalid address - if any address parameter is not a valid Ethereum address
+     * @throws {RouteNotFoundError} If no trading route exists between the token pair
+     *
+     * @example
+     * ```typescript
+     * const { approval, swap } = await mento.swap.buildSwapTransaction(
+     *   '0x765DE816845861e75A25fCA122bb6898B8B1282a', // USDm
+     *   '0x471EcE3750Da237f93B8E339c536989b8978a438', // CELO
+     *   parseUnits('100', 18),
+     *   '0x742d35Cc6634C0532925a3b844Bc454e4438f44e', // recipient
+     *   '0x123...', // owner
+     *   { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
+     * )
+     *
+     * // Execute approval if needed
+     * if (approval) {
+     *   await walletClient.sendTransaction(approval)
+     * }
+     *
+     * // Execute swap
+     * await walletClient.sendTransaction(swap.params)
+     * ```
+     */
+    async buildSwapTransaction(tokenIn, tokenOut, amountIn, recipient, owner, options, route) {
+        const prepared = await this.prepareSwap({
+            amountIn,
+            deadline: options.deadline,
+            owner,
+            recipient,
+            route,
+            slippageTolerance: options.slippageTolerance,
+            tokenIn,
+            tokenOut,
+        });
+        if (!prepared.params) {
+            throw new Error('Swap params were not prepared');
+        }
+        return {
+            approval: prepared.approval ?? null,
+            swap: {
+                params: prepared.params,
+                route: prepared.route,
+                routerRoutes: prepared.routerRoutes,
+                amountIn,
+                amountOutMin: prepared.amountOutMin,
+                expectedAmountOut: prepared.expectedAmountOut,
+                deadline: options.deadline,
+            },
+        };
+    }
+    /**
+     * Builds swap transaction parameters without executing the transaction.
+     * Does NOT check or handle token approval - use buildSwapTransaction for that.
+     *
+     * @param tokenIn - The address of the input token (e.g., '0x765DE816845861e75A25fCA122bb6898B8B1282a')
+     * @param tokenOut - The address of the output token (e.g., '0x471EcE3750Da237f93B8E339c536989b8978a438')
+     * @param amountIn - The amount of input tokens (in wei/smallest unit)
+     * @param recipient - The address to receive the output tokens
+     * @param options - Swap configuration options (slippage, deadline)
+     * @param route - Optional pre-fetched route for better performance
+     * @returns Detailed swap parameters including transaction data
+     * @throws {Error} 'amountIn must be greater than zero' - if amountIn <= 0
+     * @throws {Error} 'Slippage tolerance cannot be negative' - if slippageTolerance < 0
+     * @throws {Error} 'Slippage tolerance exceeds maximum' - if slippageTolerance > 20%
+     * @throws {Error} 'Deadline must be in the future' - if deadline is not a future timestamp
+     * @throws {Error} Invalid address - if any address parameter is not a valid Ethereum address
+     * @throws {RouteNotFoundError} If no trading route exists between the token pair
+     *
+     * @example
+     * ```typescript
+     * const swapDetails = await mento.swap.buildSwapParams(
+     *   '0x765DE816845861e75A25fCA122bb6898B8B1282a', // USDm
+     *   '0x471EcE3750Da237f93B8E339c536989b8978a438', // CELO
+     *   parseUnits('100', 18),
+     *   '0x742d35Cc6634C0532925a3b844Bc454e4438f44e', // recipient
+     *   { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
+     * )
+     *
+     * // Execute with any wallet (assumes approval already granted)
+     * await walletClient.sendTransaction(swapDetails.params)
+     * ```
+     */
+    async buildSwapParams(tokenIn, tokenOut, amountIn, recipient, options, route) {
+        const prepared = await this.prepareSwap({
+            amountIn,
+            deadline: options.deadline,
+            recipient,
+            route,
+            slippageTolerance: options.slippageTolerance,
+            tokenIn,
+            tokenOut,
+        });
+        if (!prepared.params) {
+            throw new Error('Swap params were not prepared');
+        }
+        return {
+            params: prepared.params,
+            route: prepared.route,
+            routerRoutes: prepared.routerRoutes,
+            amountIn,
+            amountOutMin: prepared.amountOutMin,
+            expectedAmountOut: prepared.expectedAmountOut,
+            deadline: options.deadline,
+        };
+    }
+    async prepareSwap(input) {
+        this.validateAmountIn(input.amountIn);
+        (0, validation_1.validateAddress)(input.tokenIn, 'tokenIn');
+        (0, validation_1.validateAddress)(input.tokenOut, 'tokenOut');
+        if (input.recipient) {
+            (0, validation_1.validateAddress)(input.recipient, 'recipient');
+        }
+        if (input.owner) {
+            (0, validation_1.validateAddress)(input.owner, 'owner');
+        }
+        if (input.deadline !== undefined && input.deadline <= BigInt(Date.now()) / 1000n) {
+            throw new Error('Deadline must be in the future');
+        }
+        const route = input.route ?? await this.routeService.findRoute(input.tokenIn, input.tokenOut);
+        const routerRoutes = (0, pathEncoder_1.encodeRoutePath)(route.path, input.tokenIn, input.tokenOut);
+        const expectedAmountOut = await (0, QuoteService_1.getAmountOutForRoute)(this.publicClient, this.chainId, input.tokenIn, input.tokenOut, input.amountIn, route);
+        const amountOutMin = this.calculateMinAmountOut(expectedAmountOut, input.slippageTolerance);
+        const prepared = {
+            route,
+            routerRoutes,
+            expectedAmountOut,
+            amountOutMin,
+        };
+        if (input.owner) {
+            const currentAllowance = await this.getAllowance(input.tokenIn, input.owner);
+            prepared.approval = currentAllowance < input.amountIn
+                ? this.buildApprovalParams(input.tokenIn, input.amountIn)
+                : null;
+        }
+        if (input.recipient && input.deadline !== undefined) {
+            const routerAddress = (0, constants_1.getContractAddress)(this.chainId, 'Router');
+            const data = this.encodeSwapCall(input.amountIn, amountOutMin, routerRoutes, input.recipient, input.deadline);
+            prepared.params = {
+                to: routerAddress,
+                data,
+                value: '0',
+            };
+        }
+        return prepared;
+    }
+    /**
+     * Builds approval transaction params for the Router to spend tokenIn
+     * @private
+     */
+    buildApprovalParams(tokenIn, amount) {
+        const routerAddress = (0, constants_1.getContractAddress)(this.chainId, 'Router');
+        const data = (0, viem_1.encodeFunctionData)({
+            abi: abis_1.ERC20_ABI,
+            functionName: 'approve',
+            args: [routerAddress, amount],
+        });
+        return { to: tokenIn, data, value: '0' };
+    }
+    /**
+     * Gets current allowance for the Router contract
+     * @private
+     */
+    async getAllowance(tokenIn, owner) {
+        const routerAddress = (0, constants_1.getContractAddress)(this.chainId, 'Router');
+        return (0, utils_1.retryOperation)(() => this.publicClient.readContract({
+            address: tokenIn,
+            abi: abis_1.ERC20_ABI,
+            functionName: 'allowance',
+            args: [owner, routerAddress],
+        }));
+    }
+    /**
+     * Validates that the input amount is strictly positive.
+     * @private
+     */
+    validateAmountIn(amountIn) {
+        if (amountIn <= 0n) {
+            throw new Error('amountIn must be greater than zero');
+        }
+    }
+    /**
+     * Calculates minimum output amount after applying slippage tolerance
+     * @param amountOut - Expected output amount
+     * @param slippageTolerance - Slippage tolerance as percentage (e.g., 0.5 for 0.5%)
+     * @returns Minimum acceptable output amount
+     * @throws Error if slippage tolerance is invalid
+     * @private
+     */
+    calculateMinAmountOut(amountOut, slippageTolerance) {
+        const MAX_SLIPPAGE_TOLERANCE = 20; // 20% max
+        if (slippageTolerance < 0) {
+            throw new Error('Slippage tolerance cannot be negative');
+        }
+        if (slippageTolerance > MAX_SLIPPAGE_TOLERANCE) {
+            throw new Error(`Slippage tolerance ${slippageTolerance}% exceeds maximum of ${MAX_SLIPPAGE_TOLERANCE}%. ` +
+                'High slippage makes transactions vulnerable to sandwich attacks.');
+        }
+        const basisPoints = BigInt(Math.floor(slippageTolerance * 100));
+        const slippageMultiplier = 10000n - basisPoints;
+        return (amountOut * slippageMultiplier) / 10000n;
+    }
+    /**
+     * Encodes the swapExactTokensForTokens function call
+     * @private
+     */
+    encodeSwapCall(amountIn, amountOutMin, routes, recipient, deadline) {
+        return (0, viem_1.encodeFunctionData)({
+            abi: abis_1.ROUTER_ABI,
+            functionName: 'swapExactTokensForTokens',
+            args: [amountIn, amountOutMin, routes, recipient, deadline],
+        });
+    }
+}
+exports.SwapService = SwapService;
+//# sourceMappingURL=SwapService.js.map

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

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

package/dist/services/swap/index.js

@@ -0,0 +1,18 @@
+"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("./SwapService"), exports);
+//# sourceMappingURL=index.js.map

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

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

package/dist/services/tokens/index.js

@@ -0,0 +1,18 @@
+"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("./tokenService"), exports);
+//# sourceMappingURL=index.js.map

package/dist/services/tokens/tokenService.d.ts

@@ -0,0 +1,55 @@
+import { StableToken, CollateralAsset } from '../../core/types';
+import type { PublicClient } from 'viem';
+export declare class TokenService {
+    private publicClient;
+    private chainId;
+    private tokenMetadataCache;
+    constructor(publicClient: PublicClient, chainId: number);
+    private isReserveV2;
+    /**
+     * Get token metadata (name, symbol, decimals)
+     * @param address - Token contract address
+     * @returns Token metadata
+     */
+    private getTokenMetadata;
+    private getTokenMetadataBatch;
+    private readTokenMetadataWithRetry;
+    /**
+     * Get total supply of a token
+     * @param address - Token contract address
+     * @returns Total supply as string
+     */
+    private getTotalSupply;
+    private getTotalSupplyBatch;
+    private readTotalSupplyWithRetry;
+    private getCollateralStatusBatch;
+    private readCollateralStatusWithRetry;
+    /**
+     * Get stable token addresses from the Reserve contract.
+     * Uses getStableAssets() on ReserveV2, getTokens() on legacy Reserve.
+     */
+    private getStableTokenAddresses;
+    /**
+     * Get all stable tokens from the Reserve contract.
+     * Returns the actual on-chain ERC20 totalSupply values without adjustments.
+     * @param includeSupply - Whether to fetch total supply
+     * @returns Array of stable tokens
+     */
+    getStableTokens(includeSupply?: boolean): Promise<StableToken[]>;
+    /**
+     * Get all collateral assets.
+     * On ReserveV2 chains, queries the reserve directly.
+     * On legacy chains, discovers collateral via BiPoolManager exchanges.
+     * @returns Array of collateral assets
+     */
+    getCollateralAssets(): Promise<CollateralAsset[]>;
+    /**
+     * Get collateral assets directly from ReserveV2.
+     */
+    private getCollateralAssetsV2;
+    /**
+     * Get collateral assets from legacy Reserve via BiPoolManager exchanges.
+     */
+    private getCollateralAssetsLegacy;
+}
+//# sourceMappingURL=tokenService.d.ts.map

package/dist/services/tokens/tokenService.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenService = void 0;
+const abis_1 = require("../../core/abis");
+const constants_1 = require("../../core/constants");
+const utils_1 = require("../../utils");
+const multicall_1 = require("../../utils/multicall");
+/**
+ * Chains that use ReserveV2 (v3) instead of the legacy Reserve contract.
+ */
+const RESERVE_V2_CHAINS = new Set([constants_1.ChainId.MONAD_TESTNET, constants_1.ChainId.MONAD]);
+class TokenService {
+    constructor(publicClient, chainId) {
+        this.publicClient = publicClient;
+        this.chainId = chainId;
+        this.tokenMetadataCache = new Map();
+    }
+    isReserveV2() {
+        return RESERVE_V2_CHAINS.has(this.chainId);
+    }
+    /**
+     * Get token metadata (name, symbol, decimals)
+     * @param address - Token contract address
+     * @returns Token metadata
+     */
+    async getTokenMetadata(address) {
+        const cacheKey = address.toLowerCase();
+        const cached = this.tokenMetadataCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const [metadata] = await this.getTokenMetadataBatch([address]);
+        this.tokenMetadataCache.set(cacheKey, metadata);
+        return metadata;
+    }
+    async getTokenMetadataBatch(addresses) {
+        if (addresses.length === 0) {
+            return [];
+        }
+        const results = new Array(addresses.length);
+        const missing = [];
+        for (const [index, address] of addresses.entries()) {
+            const cached = this.tokenMetadataCache.get(address.toLowerCase());
+            if (cached) {
+                results[index] = cached;
+                continue;
+            }
+            missing.push({ address, index });
+        }
+        if (missing.length === 0) {
+            return results;
+        }
+        const multicallResults = await (0, multicall_1.multicall)(this.publicClient, missing.flatMap(({ address }) => ([
+            {
+                address: address,
+                abi: abis_1.ERC20_ABI,
+                functionName: 'name',
+                args: [],
+            },
+            {
+                address: address,
+                abi: abis_1.ERC20_ABI,
+                functionName: 'symbol',
+                args: [],
+            },
+            {
+                address: address,
+                abi: abis_1.ERC20_ABI,
+                functionName: 'decimals',
+                args: [],
+            },
+        ])), { allowFailure: true });
+        const hydrated = await Promise.all(missing.map(async ({ address }, index) => {
+            const resultOffset = index * 3;
+            const name = multicallResults[resultOffset];
+            const symbol = multicallResults[resultOffset + 1];
+            const decimals = multicallResults[resultOffset + 2];
+            if (name?.status === 'success' &&
+                symbol?.status === 'success' &&
+                decimals?.status === 'success') {
+                return {
+                    name: name.result,
+                    symbol: symbol.result,
+                    decimals: Number(decimals.result),
+                };
+            }
+            return this.readTokenMetadataWithRetry(address);
+        }));
+        for (const [index, metadata] of hydrated.entries()) {
+            const address = missing[index].address;
+            this.tokenMetadataCache.set(address.toLowerCase(), metadata);
+            results[missing[index].index] = metadata;
+        }
+        return results;
+    }
+    async readTokenMetadataWithRetry(address) {
+        const [name, symbol, decimals] = await Promise.all([
+            (0, utils_1.retryOperation)(() => this.publicClient.readContract({
+                address: address,
+                abi: abis_1.ERC20_ABI,
+                functionName: 'name',
+                args: [],
+            })),
+            (0, utils_1.retryOperation)(() => this.publicClient.readContract({
+                address: address,
+                abi: abis_1.ERC20_ABI,
+                functionName: 'symbol',
+                args: [],
+            })),
+            (0, utils_1.retryOperation)(() => this.publicClient.readContract({
+                address: address,
+                abi: abis_1.ERC20_ABI,
+                functionName: 'decimals',
+                args: [],
+            })),
+        ]);
+        return {
+            name: name,
+            symbol: symbol,
+            decimals: Number(decimals),
+        };
+    }
+    /**
+     * Get total supply of a token
+     * @param address - Token contract address
+     * @returns Total supply as string
+     */
+    async getTotalSupply(address) {
+        const [totalSupply] = await this.getTotalSupplyBatch([address]);
+        return totalSupply;
+    }
+    async getTotalSupplyBatch(addresses) {
+        if (addresses.length === 0) {
+            return [];
+        }
+        const results = await (0, multicall_1.multicall)(this.publicClient, addresses.map((address) => ({
+            address: address,
+            abi: abis_1.ERC20_ABI,
+            functionName: 'totalSupply',
+            args: [],
+        })), { allowFailure: true });
+        return Promise.all(addresses.map(async (address, index) => {
+            const result = results[index];
+            if (result?.status === 'success') {
+                return result.result.toString();
+            }
+            return this.readTotalSupplyWithRetry(address);
+        }));
+    }
+    async readTotalSupplyWithRetry(address) {
+        const totalSupply = await (0, utils_1.retryOperation)(() => this.publicClient.readContract({
+            address: address,
+            abi: abis_1.ERC20_ABI,
+            functionName: 'totalSupply',
+            args: [],
+        }));
+        return totalSupply.toString();
+    }
+    async getCollateralStatusBatch(reserveAddress, addresses) {
+        if (addresses.length === 0) {
+            return [];
+        }
+        const results = await (0, multicall_1.multicall)(this.publicClient, addresses.map((address) => ({
+            address: reserveAddress,
+            abi: abis_1.RESERVE_ABI,
+            functionName: 'isCollateralAsset',
+            args: [address],
+        })), { allowFailure: true });
+        return Promise.all(addresses.map(async (address, index) => {
+            const result = results[index];
+            if (result?.status === 'success') {
+                return result.result;
+            }
+            return this.readCollateralStatusWithRetry(reserveAddress, address);
+        }));
+    }
+    async readCollateralStatusWithRetry(reserveAddress, address) {
+        return (0, utils_1.retryOperation)(() => this.publicClient.readContract({
+            address: reserveAddress,
+            abi: abis_1.RESERVE_ABI,
+            functionName: 'isCollateralAsset',
+            args: [address],
+        }));
+    }
+    /**
+     * Get stable token addresses from the Reserve contract.
+     * Uses getStableAssets() on ReserveV2, getTokens() on legacy Reserve.
+     */
+    async getStableTokenAddresses(reserveAddress) {
+        if (this.isReserveV2()) {
+            return (await this.publicClient.readContract({
+                address: reserveAddress,
+                abi: abis_1.RESERVE_V2_ABI,
+                functionName: 'getStableAssets',
+                args: [],
+            }));
+        }
+        return (await this.publicClient.readContract({
+            address: reserveAddress,
+            abi: abis_1.RESERVE_ABI,
+            functionName: 'getTokens',
+            args: [],
+        }));
+    }
+    /**
+     * Get all stable tokens from the Reserve contract.
+     * Returns the actual on-chain ERC20 totalSupply values without adjustments.
+     * @param includeSupply - Whether to fetch total supply
+     * @returns Array of stable tokens
+     */
+    async getStableTokens(includeSupply = true) {
+        const reserveAddress = (0, constants_1.getContractAddress)(this.chainId, constants_1.RESERVE);
+        const tokenAddresses = await this.getStableTokenAddresses(reserveAddress);
+        const [metadataList, totalSupplies] = await Promise.all([
+            this.getTokenMetadataBatch(tokenAddresses),
+            includeSupply ? this.getTotalSupplyBatch(tokenAddresses) : Promise.resolve(tokenAddresses.map(() => '0')),
+        ]);
+        const tokens = tokenAddresses.map((address, index) => ({
+            address,
+            ...metadataList[index],
+            totalSupply: totalSupplies[index],
+        }));
+        return tokens;
+    }
+    /**
+     * Get all collateral assets.
+     * On ReserveV2 chains, queries the reserve directly.
+     * On legacy chains, discovers collateral via BiPoolManager exchanges.
+     * @returns Array of collateral assets
+     */
+    async getCollateralAssets() {
+        if (this.isReserveV2()) {
+            return this.getCollateralAssetsV2();
+        }
+        return this.getCollateralAssetsLegacy();
+    }
+    /**
+     * Get collateral assets directly from ReserveV2.
+     */
+    async getCollateralAssetsV2() {
+        const reserveAddress = (0, constants_1.getContractAddress)(this.chainId, constants_1.RESERVE);
+        const collateralAddresses = (await (0, utils_1.retryOperation)(() => this.publicClient.readContract({
+            address: reserveAddress,
+            abi: abis_1.RESERVE_V2_ABI,
+            functionName: 'getCollateralAssets',
+            args: [],
+        })));
+        const metadataList = await this.getTokenMetadataBatch(collateralAddresses);
+        const assets = collateralAddresses.map((address, index) => ({
+            address,
+            ...metadataList[index],
+        }));
+        return assets;
+    }
+    /**
+     * Get collateral assets from legacy Reserve via BiPoolManager exchanges.
+     */
+    async getCollateralAssetsLegacy() {
+        const biPoolManagerAddress = (0, constants_1.tryGetContractAddress)(this.chainId, constants_1.BIPOOLMANAGER);
+        if (!biPoolManagerAddress) {
+            return [];
+        }
+        const reserveAddress = (0, constants_1.getContractAddress)(this.chainId, constants_1.RESERVE);
+        // Get all exchanges to find unique token addresses
+        const exchanges = (await (0, utils_1.retryOperation)(() => this.publicClient.readContract({
+            address: biPoolManagerAddress,
+            abi: abis_1.BIPOOL_MANAGER_ABI,
+            functionName: 'getExchanges',
+        })));
+        // Extract unique token addresses from exchanges
+        const uniqueAddresses = new Set();
+        for (const exchange of exchanges) {
+            exchange.assets.forEach((address) => uniqueAddresses.add(address));
+        }
+        const addresses = Array.from(uniqueAddresses);
+        const [collateralStatuses, metadataList] = await Promise.all([
+            this.getCollateralStatusBatch(reserveAddress, addresses),
+            this.getTokenMetadataBatch(addresses),
+        ]);
+        const results = addresses.map((address, index) => {
+            if (!collateralStatuses[index]) {
+                return null;
+            }
+            return { address, ...metadataList[index] };
+        });
+        return results.filter((asset) => asset !== null);
+    }
+}
+exports.TokenService = TokenService;
+//# sourceMappingURL=tokenService.js.map

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

@@ -0,0 +1,38 @@
+import { PublicClient } from 'viem';
+import type { Pool, TradingLimit } from '../../core/types';
+/**
+ * Service for querying trading limits from the Mento protocol.
+ * Supports both FPMM pools (TradingLimitsV2) and Virtual pools (TradingLimitsV1).
+ */
+export declare class TradingLimitsService {
+    private publicClient;
+    private chainId;
+    constructor(publicClient: PublicClient, chainId: number);
+    /**
+     * 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
+     */
+    getPoolTradingLimits(pool: Pool): Promise<TradingLimit[]>;
+    /**
+     * Get trading limits for an FPMM pool.
+     * FPMM pools use TradingLimitsV2 with fixed timeframes.
+     */
+    private getFPMMTradingLimits;
+    /**
+     * Get trading limits for a specific token in an FPMM pool.
+     */
+    private getFPMMTokenLimits;
+    /**
+     * Get trading limits for a Virtual pool.
+     * Virtual pools use TradingLimitsV1 via the Broker contract.
+     */
+    private getVirtualPoolTradingLimits;
+    /**
+     * Get trading limits for a specific token in a Virtual pool.
+     */
+    private getVirtualPoolTokenLimits;
+}
+//# sourceMappingURL=TradingLimitsService.d.ts.map