@mento-protocol/mento-sdk 3.1.0-beta.3 → 3.1.0-beta.5

package/dist/services/tokens/tokenService.js

@@ -4,6 +4,7 @@ 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.
  */
@@ -12,6 +13,7 @@ class TokenService {
     constructor(publicClient, chainId) {
         this.publicClient = publicClient;
         this.chainId = chainId;
+        this.tokenMetadataCache = new Map();
     }
     isReserveV2() {
         return RESERVE_V2_CHAINS.has(this.chainId);
@@ -22,6 +24,76 @@ class TokenService {
      * @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,
@@ -54,6 +126,28 @@ class TokenService {
      * @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,
@@ -62,6 +156,32 @@ class TokenService {
         }));
         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.
@@ -91,17 +211,14 @@ class TokenService {
     async getStableTokens(includeSupply = true) {
         const reserveAddress = (0, constants_1.getContractAddress)(this.chainId, constants_1.RESERVE);
         const tokenAddresses = await this.getStableTokenAddresses(reserveAddress);
-        // Fetch metadata and totalSupply for all tokens concurrently
-        const tokens = await Promise.all(tokenAddresses.map(async (address) => {
-            const [metadata, totalSupply] = await Promise.all([
-                this.getTokenMetadata(address),
-                includeSupply ? this.getTotalSupply(address) : Promise.resolve('0'),
-            ]);
-            return {
-                address,
-                ...metadata,
-                totalSupply,
-            };
+        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;
     }
@@ -128,9 +245,10 @@ class TokenService {
             functionName: 'getCollateralAssets',
             args: [],
         })));
-        const assets = await Promise.all(collateralAddresses.map(async (address) => {
-            const metadata = await this.getTokenMetadata(address);
-            return { address, ...metadata };
+        const metadataList = await this.getTokenMetadataBatch(collateralAddresses);
+        const assets = collateralAddresses.map((address, index) => ({
+            address,
+            ...metadataList[index],
         }));
         return assets;
     }
@@ -154,22 +272,17 @@ class TokenService {
         for (const exchange of exchanges) {
             exchange.assets.forEach((address) => uniqueAddresses.add(address));
         }
-        // Check which tokens are collateral assets and get their info in parallel
-        const results = await Promise.all(Array.from(uniqueAddresses).map(async (address) => {
-            const [isCollateral, metadata] = await Promise.all([
-                (0, utils_1.retryOperation)(() => this.publicClient.readContract({
-                    address: reserveAddress,
-                    abi: abis_1.RESERVE_ABI,
-                    functionName: 'isCollateralAsset',
-                    args: [address],
-                })),
-                this.getTokenMetadata(address),
-            ]);
-            if (isCollateral) {
-                return { address, ...metadata };
+        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 null;
-        }));
+            return { address, ...metadataList[index] };
+        });
         return results.filter((asset) => asset !== null);
     }
 }

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

@@ -106,5 +106,8 @@ export declare class TradingService {
      * @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

@@ -5,6 +5,7 @@ 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,
@@ -81,14 +82,9 @@ class TradingService {
      * ```
      */
     async isRouteTradable(route) {
-        // Get rate feed IDs for each pool in the path and check trading modes
-        const rateFeedChecks = await Promise.all(route.path.map(async (pool) => {
-            const rateFeedId = await this.getPoolRateFeedId(pool);
-            const tradingMode = await this.getRateFeedTradingMode(rateFeedId);
-            return (0, types_1.isTradingEnabled)(tradingMode);
-        }));
+        const tradingModes = await this.getTradingModesForPools(route.path);
         // All rate feeds must have trading enabled for the route to be tradable
-        return rateFeedChecks.every((isEnabled) => isEnabled);
+        return tradingModes.every((tradingMode) => (0, types_1.isTradingEnabled)(tradingMode));
     }
     /**
      * Get trading limits for a pool.
@@ -126,11 +122,10 @@ class TradingService {
      * ```
      */
     async getPoolTradabilityStatus(pool) {
-        const [rateFeedId, limits] = await Promise.all([
-            this.getPoolRateFeedId(pool),
+        const [[tradingMode], limits] = await Promise.all([
+            this.getTradingModesForPools([pool]),
             this.tradingLimitsService.getPoolTradingLimits(pool),
         ]);
-        const tradingMode = await this.getRateFeedTradingMode(rateFeedId);
         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);
@@ -150,12 +145,56 @@ class TradingService {
      * @returns The rate feed ID address
      */
     async getPoolRateFeedId(pool) {
-        const rateFeedId = await this.publicClient.readContract({
+        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;
         });
-        return rateFeedId;
     }
 }
 exports.TradingService = TradingService;

package/dist/utils/chainConfig.js

@@ -46,6 +46,12 @@ const monadTestnet = (0, viem_1.defineChain)({
             url: 'https://testnet.monadexplorer.com',
         },
     },
+    contracts: {
+        multicall3: {
+            address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+            blockCreated: 251449,
+        },
+    },
     testnet: true,
 });
 const monad = (0, viem_1.defineChain)({
@@ -67,6 +73,12 @@ const monad = (0, viem_1.defineChain)({
             url: 'https://monadvision.com',
         },
     },
+    contracts: {
+        multicall3: {
+            address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+            blockCreated: 9248132,
+        },
+    },
 });
 /**
  * Get the default RPC URL for a given chain ID

package/dist/utils/costUtils.js

@@ -4,6 +4,7 @@ exports.getPoolCostPercent = getPoolCostPercent;
 const types_1 = require("../core/types");
 const abis_1 = require("../core/abis");
 const virtualPool_1 = require("../core/abis/virtualPool");
+const multicall_1 = require("./multicall");
 /**
  * Calculate cost percentage for a pool based on its type
  * Returns cost as a percentage (e.g., 0.5 = 0.5%)
@@ -28,12 +29,10 @@ async function getPoolCostPercent(pool, publicClient) {
  * FPMM pools use lpFee + protocolFee in basis points (10000 = 100%)
  */
 async function getFPMMCostPercent(poolAddress, publicClient) {
-    const results = await publicClient.multicall({
-        contracts: [
-            { address: poolAddress, abi: abis_1.FPMM_ABI, functionName: 'lpFee' },
-            { address: poolAddress, abi: abis_1.FPMM_ABI, functionName: 'protocolFee' },
-        ],
-    });
+    const results = await (0, multicall_1.multicall)(publicClient, [
+        { address: poolAddress, abi: abis_1.FPMM_ABI, functionName: 'lpFee' },
+        { address: poolAddress, abi: abis_1.FPMM_ABI, functionName: 'protocolFee' },
+    ]);
     if (results[0].status === 'failure' || results[1].status === 'failure') {
         throw new Error(`Failed to read fees for pool ${poolAddress}`);
     }
@@ -48,9 +47,9 @@ async function getFPMMCostPercent(poolAddress, publicClient) {
  * Calculate cost for Virtual pools
  */
 async function getVirtualPoolCostPercent(poolAddress, publicClient) {
-    const results = await publicClient.multicall({
-        contracts: [{ address: poolAddress, abi: virtualPool_1.VIRTUAL_POOL_ABI, functionName: 'protocolFee' }],
-    });
+    const results = await (0, multicall_1.multicall)(publicClient, [
+        { address: poolAddress, abi: virtualPool_1.VIRTUAL_POOL_ABI, functionName: 'protocolFee' },
+    ]);
     if (results[0].status === 'failure') {
         throw new Error(`Failed to read protocolFee for pool ${poolAddress}`);
     }

package/dist/utils/multicall.d.ts

@@ -0,0 +1,30 @@
+import type { Abi, PublicClient } from 'viem';
+/**
+ * Standard Multicall3 contract address, deployed at the same address on all EVM chains.
+ * https://www.multicall3.com/
+ */
+export declare const MULTICALL3_ADDRESS: "0xcA11bde05977b3631167028862bE2a173976CA11";
+type MulticallResult = {
+    status: 'success';
+    result: unknown;
+} | {
+    status: 'failure';
+    error: Error;
+};
+interface ContractCall {
+    address: `0x${string}`;
+    abi: Abi | readonly unknown[];
+    functionName: string;
+    args?: readonly unknown[];
+}
+interface MulticallOptions {
+    allowFailure?: boolean;
+    batchSize?: number;
+}
+/**
+ * Wrapper around viem's multicall that explicitly provides the Multicall3 address.
+ * This ensures multicall works even when the PublicClient was created without a `chain` config.
+ */
+export declare function multicall(publicClient: PublicClient, contracts: ContractCall[], options?: MulticallOptions): Promise<MulticallResult[]>;
+export {};
+//# sourceMappingURL=multicall.d.ts.map

package/dist/utils/multicall.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MULTICALL3_ADDRESS = void 0;
+exports.multicall = multicall;
+/**
+ * Standard Multicall3 contract address, deployed at the same address on all EVM chains.
+ * https://www.multicall3.com/
+ */
+exports.MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+/**
+ * Wrapper around viem's multicall that explicitly provides the Multicall3 address.
+ * This ensures multicall works even when the PublicClient was created without a `chain` config.
+ */
+async function multicall(publicClient, contracts, options = {}) {
+    const { allowFailure = true, batchSize } = options;
+    const client = publicClient;
+    if (typeof client.multicall !== 'function') {
+        if (typeof client.readContract !== 'function') {
+            throw new Error('Public client does not support multicall or readContract');
+        }
+        return Promise.all(contracts.map(async (contract) => {
+            try {
+                const result = await client.readContract({
+                    ...contract,
+                    args: contract.args ?? [],
+                });
+                return { status: 'success', result };
+            }
+            catch (error) {
+                if (!allowFailure) {
+                    throw error;
+                }
+                return {
+                    status: 'failure',
+                    error: error instanceof Error ? error : new Error(String(error)),
+                };
+            }
+        }));
+    }
+    return client.multicall({
+        allowFailure,
+        batchSize,
+        contracts: contracts,
+        multicallAddress: exports.MULTICALL3_ADDRESS,
+    });
+}
+//# sourceMappingURL=multicall.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mento-protocol/mento-sdk",
   "description": "Official SDK for interacting with the Mento Protocol",
-  "version": "3.1.0-beta.3",
+  "version": "3.1.0-beta.5",
   "license": "MIT",
   "author": "Mento Labs",
   "keywords": [