@mento-protocol/mento-sdk 3.2.3 → 3.2.5

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

@@ -0,0 +1,247 @@
+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

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

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

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

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

@@ -0,0 +1,285 @@
+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

@@ -0,0 +1,154 @@
+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 [];
+        }
+    }
+}