@mento-protocol/mento-sdk 3.2.6 → 3.2.7

package/dist/esm/services/swap/SwapService.js

@@ -1,247 +0,0 @@
-import { encodeFunctionData } from 'viem';
-import { ROUTER_ABI, ERC20_ABI } from '../../core/abis';
-import { getContractAddress } from '../../core/constants';
-import { encodeRoutePath } from '../../utils/pathEncoder';
-import { validateAddress } from '../../utils/validation';
-import { retryOperation } from '../../utils';
-import { getAmountOutForRoute } from '../quotes/QuoteService';
-/**
- * Service for building token swap transactions on the Mento protocol.
- * Returns transaction parameters that can be executed by any wallet.
- */
-export 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);
-        validateAddress(input.tokenIn, 'tokenIn');
-        validateAddress(input.tokenOut, 'tokenOut');
-        if (input.recipient) {
-            validateAddress(input.recipient, 'recipient');
-        }
-        if (input.owner) {
-            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 = encodeRoutePath(route.path, input.tokenIn, input.tokenOut);
-        const expectedAmountOut = await 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 = 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 = getContractAddress(this.chainId, 'Router');
-        const data = encodeFunctionData({
-            abi: 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 = getContractAddress(this.chainId, 'Router');
-        return retryOperation(() => this.publicClient.readContract({
-            address: tokenIn,
-            abi: 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 encodeFunctionData({
-            abi: ROUTER_ABI,
-            functionName: 'swapExactTokensForTokens',
-            args: [amountIn, amountOutMin, routes, recipient, deadline],
-        });
-    }
-}

package/dist/esm/services/swap/index.js

@@ -1 +0,0 @@
-export * from './SwapService';

package/dist/esm/services/tokens/index.js

@@ -1 +0,0 @@
-export * from './tokenService';

package/dist/esm/services/tokens/tokenService.js

@@ -1,285 +0,0 @@
-import { RESERVE_ABI, RESERVE_V2_ABI, BIPOOL_MANAGER_ABI, ERC20_ABI } from '../../core/abis';
-import { getContractAddress, tryGetContractAddress, ChainId, RESERVE, BIPOOLMANAGER, } from '../../core/constants';
-import { retryOperation } from '../../utils';
-import { multicall } from '../../utils/multicall';
-/**
- * Chains that use ReserveV2 (v3) instead of the legacy Reserve contract.
- */
-const RESERVE_V2_CHAINS = new Set([ChainId.MONAD_TESTNET, ChainId.MONAD]);
-export 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 multicall(this.publicClient, missing.flatMap(({ address }) => ([
-            {
-                address: address,
-                abi: ERC20_ABI,
-                functionName: 'name',
-                args: [],
-            },
-            {
-                address: address,
-                abi: ERC20_ABI,
-                functionName: 'symbol',
-                args: [],
-            },
-            {
-                address: address,
-                abi: 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([
-            retryOperation(() => this.publicClient.readContract({
-                address: address,
-                abi: ERC20_ABI,
-                functionName: 'name',
-                args: [],
-            })),
-            retryOperation(() => this.publicClient.readContract({
-                address: address,
-                abi: ERC20_ABI,
-                functionName: 'symbol',
-                args: [],
-            })),
-            retryOperation(() => this.publicClient.readContract({
-                address: address,
-                abi: 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 multicall(this.publicClient, addresses.map((address) => ({
-            address: address,
-            abi: 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 retryOperation(() => this.publicClient.readContract({
-            address: address,
-            abi: ERC20_ABI,
-            functionName: 'totalSupply',
-            args: [],
-        }));
-        return totalSupply.toString();
-    }
-    async getCollateralStatusBatch(reserveAddress, addresses) {
-        if (addresses.length === 0) {
-            return [];
-        }
-        const results = await multicall(this.publicClient, addresses.map((address) => ({
-            address: reserveAddress,
-            abi: 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 retryOperation(() => this.publicClient.readContract({
-            address: reserveAddress,
-            abi: 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: RESERVE_V2_ABI,
-                functionName: 'getStableAssets',
-                args: [],
-            }));
-        }
-        return (await this.publicClient.readContract({
-            address: reserveAddress,
-            abi: 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 = getContractAddress(this.chainId, 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 = getContractAddress(this.chainId, RESERVE);
-        const collateralAddresses = (await retryOperation(() => this.publicClient.readContract({
-            address: reserveAddress,
-            abi: 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 = tryGetContractAddress(this.chainId, BIPOOLMANAGER);
-        if (!biPoolManagerAddress) {
-            return [];
-        }
-        const reserveAddress = getContractAddress(this.chainId, RESERVE);
-        // Get all exchanges to find unique token addresses
-        const exchanges = (await retryOperation(() => this.publicClient.readContract({
-            address: biPoolManagerAddress,
-            abi: 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);
-    }
-}

package/dist/esm/services/trading/TradingLimitsService.js

@@ -1,154 +0,0 @@
-import { PoolType } from '../../core/types';
-import { FPMM_ABI, BROKER_ABI } from '../../core/abis';
-import { tryGetContractAddress } from '../../core/constants';
-import { computeLimitId, calculateTradingLimitsV1, calculateTradingLimitsV2, hasConfiguredLimitsV1, hasConfiguredLimitsV2, } from '../../utils/tradingLimits';
-/**
- * Service for querying trading limits from the Mento protocol.
- * Supports both FPMM pools (TradingLimitsV2) and Virtual pools (TradingLimitsV1).
- */
-export 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 === 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: 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 (!hasConfiguredLimitsV2(config)) {
-                return [];
-            }
-            return 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 = tryGetContractAddress(this.chainId, 'Broker');
-        if (!brokerAddr) {
-            return [];
-        }
-        const limitId = computeLimitId(exchangeId, token);
-        try {
-            // Fetch config and state in parallel
-            const [configResult, stateResult] = await Promise.all([
-                this.publicClient.readContract({
-                    address: brokerAddr,
-                    abi: BROKER_ABI,
-                    functionName: 'tradingLimitsConfig',
-                    args: [limitId],
-                }),
-                this.publicClient.readContract({
-                    address: brokerAddr,
-                    abi: 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 (!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 calculateTradingLimitsV1(config, state, token, tokenDecimals);
-        }
-        catch {
-            // Trading limits may not be configured for this token
-            return [];
-        }
-    }
-}