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

package/dist/esm/services/routes/RouteService.js

@@ -2,6 +2,7 @@ import { ERC20_ABI } from '../../core/abis';
 import { RouteNotFoundError } from '../../core/errors';
 import { buildConnectivityStructures, generateAllRoutes, selectOptimalRoutes } from '../../utils/routeUtils';
 import { canonicalSymbolKey } from '../../utils/sortUtils';
+import { multicall } from '../../utils/multicall';
 /**
  * Service for discovering and managing trading routes in the Mento protocol.
  * Handles route discovery for both direct (single-hop) and multi-hop trading paths.
@@ -16,6 +17,9 @@ export class RouteService {
         this.chainId = chainId;
         this.poolService = poolService;
         this.symbolCache = new Map();
+        this.routeCache = new Map();
+        this.routeLookupCache = new Map();
+        this.routePromises = new Map();
     }
     /**
      * Generates all direct (single-hop) routes from available pools
@@ -43,7 +47,7 @@ export class RouteService {
         });
         // Fetch symbols for all tokens in parallel. Used for the route ids
         const tokenAddresses = Array.from(uniqueTokens);
-        await Promise.all(tokenAddresses.map((addr) => this.fetchTokenSymbol(addr)));
+        await this.hydrateTokenSymbols(tokenAddresses);
         const routes = [];
         // Loop all pools
         for (const pool of pools) {
@@ -96,20 +100,31 @@ export class RouteService {
     async getRoutes(options) {
         const cached = options?.cached ?? true;
         const returnAllRoutes = options?.returnAllRoutes ?? false;
-        if (cached) {
-            // Try to load from static cache
-            try {
-                const cachedRoutes = await this.loadCachedRoutes();
-                if (cachedRoutes.length > 0) {
-                    return cachedRoutes;
-                }
-            }
-            catch {
-                // Cache miss or corrupt - silently fall through to fresh generation
+        const cacheKey = this.getCacheKey(cached, returnAllRoutes);
+        const cachedRoutes = this.routeCache.get(cacheKey);
+        if (cachedRoutes) {
+            return cachedRoutes;
+        }
+        const inFlight = this.routePromises.get(cacheKey);
+        if (inFlight) {
+            return inFlight;
+        }
+        const promise = this.loadRoutes(cached, returnAllRoutes);
+        this.routePromises.set(cacheKey, promise);
+        try {
+            const routes = await promise;
+            this.routeCache.set(cacheKey, routes);
+            if (!returnAllRoutes) {
+                this.routeLookupCache.set(cacheKey, this.buildLookup(routes));
             }
+            return routes;
         }
-        // Generate fresh routes from blockchain
-        return this.generateFreshRoutes(returnAllRoutes);
+        finally {
+            this.routePromises.delete(cacheKey);
+        }
+    }
+    async warm(options) {
+        return this.getRoutes(options);
     }
     /**
      * Looks up the tradable route between two tokens (direct or multi-hop)
@@ -134,17 +149,12 @@ export class RouteService {
      * ```
      */
     async findRoute(tokenIn, tokenOut, options) {
-        // Get all tradable routes
-        const allRoutes = await this.getRoutes(options);
-        const t0 = tokenIn.toLowerCase();
-        const t1 = tokenOut.toLowerCase();
-        // Search for matching route (bidirectional)
-        const matchingRoute = allRoutes.find((route) => {
-            const a0 = route.tokens[0].address.toLowerCase();
-            const a1 = route.tokens[1].address.toLowerCase();
-            // Match either direction: (t0,t1) or (t1,t0)
-            return (a0 === t0 && a1 === t1) || (a0 === t1 && a1 === t0);
-        });
+        const cached = options?.cached ?? true;
+        const cacheKey = this.getCacheKey(cached, false);
+        const routes = await this.getRoutes({ cached, returnAllRoutes: false });
+        const lookup = this.routeLookupCache.get(cacheKey) ?? this.buildLookup(routes);
+        this.routeLookupCache.set(cacheKey, lookup);
+        const matchingRoute = lookup.get(makeTokenPairKey(tokenIn, tokenOut));
         if (!matchingRoute) {
             throw new RouteNotFoundError(tokenIn, tokenOut);
         }
@@ -178,6 +188,50 @@ export class RouteService {
         const cachedRoutes = await getCachedRoutes(this.chainId);
         return cachedRoutes || [];
     }
+    async loadRoutes(cached, returnAllRoutes) {
+        if (cached) {
+            try {
+                const cachedRoutes = await this.loadCachedRoutes();
+                if (cachedRoutes.length > 0) {
+                    return returnAllRoutes ? cachedRoutes : cachedRoutes;
+                }
+            }
+            catch {
+                // Cache miss or corrupt - silently fall through to fresh generation
+            }
+        }
+        return this.generateFreshRoutes(returnAllRoutes);
+    }
+    getCacheKey(cached, returnAllRoutes) {
+        return `${cached ? 'cached' : 'fresh'}:${returnAllRoutes ? 'all' : 'best'}`;
+    }
+    buildLookup(routes) {
+        const lookup = new Map();
+        for (const route of routes) {
+            lookup.set(makeTokenPairKey(route.tokens[0].address, route.tokens[1].address), route);
+        }
+        return lookup;
+    }
+    async hydrateTokenSymbols(addresses) {
+        const missingAddresses = addresses.filter((address) => !this.symbolCache.has(address));
+        if (missingAddresses.length === 0) {
+            return;
+        }
+        const results = await multicall(this.publicClient, missingAddresses.map((address) => ({
+            address: address,
+            abi: ERC20_ABI,
+            functionName: 'symbol',
+            args: [],
+        })));
+        for (const [index, address] of missingAddresses.entries()) {
+            const result = results[index];
+            if (!result || result.status === 'failure') {
+                this.symbolCache.set(address, address);
+                continue;
+            }
+            this.symbolCache.set(address, result.result);
+        }
+    }
     /**
      * Helper: Fetch token symbol from on-chain
      * Results are cached to avoid redundant RPC calls
@@ -208,3 +262,7 @@ export class RouteService {
         }
     }
 }
+function makeTokenPairKey(tokenA, tokenB) {
+    const [first, second] = [tokenA.toLowerCase(), tokenB.toLowerCase()].sort();
+    return `${first}:${second}`;
+}

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

@@ -4,6 +4,7 @@ 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.
@@ -55,18 +56,31 @@ export class SwapService {
      * ```
      */
     async buildSwapTransaction(tokenIn, tokenOut, amountIn, recipient, owner, options, route) {
-        this.validateAmountIn(amountIn);
-        // Validate all address inputs
-        validateAddress(tokenIn, 'tokenIn');
-        validateAddress(tokenOut, 'tokenOut');
-        validateAddress(recipient, 'recipient');
-        validateAddress(owner, 'owner');
-        // Build swap params first
-        const swap = await this.buildSwapParams(tokenIn, tokenOut, amountIn, recipient, options, route);
-        // Check if approval is needed
-        const currentAllowance = await this.getAllowance(tokenIn, owner);
-        const approval = currentAllowance < amountIn ? this.buildApprovalParams(tokenIn, amountIn) : null;
-        return { approval, swap };
+        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.
@@ -101,37 +115,67 @@ export class SwapService {
      * ```
      */
     async buildSwapParams(tokenIn, tokenOut, amountIn, recipient, options, route) {
-        this.validateAmountIn(amountIn);
-        const deadline = options.deadline;
-        if (deadline <= BigInt(Date.now()) / 1000n) {
-            throw new Error('Deadline must be in the future');
-        }
-        // Validate all address inputs
-        validateAddress(tokenIn, 'tokenIn');
-        validateAddress(tokenOut, 'tokenOut');
-        validateAddress(recipient, 'recipient');
-        // Find route if not provided
-        if (!route) {
-            route = await this.routeService.findRoute(tokenIn, tokenOut);
+        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');
         }
-        const expectedAmountOut = await this.quoteService.getAmountOut(tokenIn, tokenOut, amountIn, route);
-        const amountOutMin = this.calculateMinAmountOut(expectedAmountOut, options.slippageTolerance);
-        const routerRoutes = encodeRoutePath(route.path, tokenIn, tokenOut);
-        const routerAddress = getContractAddress(this.chainId, 'Router');
-        const data = this.encodeSwapCall(amountIn, amountOutMin, routerRoutes, recipient, deadline);
         return {
-            params: {
-                to: routerAddress,
-                data,
-                value: '0',
-            },
+            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,
-            amountIn,
-            amountOutMin,
             expectedAmountOut,
-            deadline,
+            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

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

@@ -1,6 +1,7 @@
 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.
  */
@@ -9,6 +10,7 @@ export class TokenService {
     constructor(publicClient, chainId) {
         this.publicClient = publicClient;
         this.chainId = chainId;
+        this.tokenMetadataCache = new Map();
     }
     isReserveV2() {
         return RESERVE_V2_CHAINS.has(this.chainId);
@@ -19,6 +21,76 @@ export 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 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,
@@ -51,6 +123,28 @@ export 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 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,
@@ -59,6 +153,32 @@ export class TokenService {
         }));
         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.
@@ -88,17 +208,14 @@ export class TokenService {
     async getStableTokens(includeSupply = true) {
         const reserveAddress = getContractAddress(this.chainId, 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;
     }
@@ -125,9 +242,10 @@ export 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;
     }
@@ -151,22 +269,17 @@ export 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([
-                retryOperation(() => this.publicClient.readContract({
-                    address: reserveAddress,
-                    abi: 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/esm/services/trading/TradingService.js

@@ -2,6 +2,7 @@ import { isTradingEnabled, } from '../../core/types';
 import { TradingLimitsService } from './TradingLimitsService';
 import { BREAKERBOX_ABI, FPMM_ABI } from '../../core/abis';
 import { getContractAddress } from '../../core/constants';
+import { multicall } from '../../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,
@@ -78,14 +79,9 @@ export 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 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) => isTradingEnabled(tradingMode));
     }
     /**
      * Get trading limits for a pool.
@@ -123,11 +119,10 @@ export 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 = 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);
@@ -147,11 +142,55 @@ export 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 multicall(this.publicClient, pools.map((pool) => ({
             address: pool.poolAddr,
             abi: 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 = getContractAddress(this.chainId, 'BreakerBox');
+        const uniqueRateFeeds = Array.from(new Map(rateFeedIds.map((rateFeedId) => [rateFeedId.toLowerCase(), rateFeedId])).values());
+        const results = await multicall(this.publicClient, uniqueRateFeeds.map((rateFeedId) => ({
+            address: breakerBoxAddr,
+            abi: 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;
     }
 }

package/dist/esm/utils/chainConfig.js

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