@mento-protocol/mento-sdk 3.1.0-beta.4 → 3.1.0-beta.6

package/dist/core/abis/index.d.ts

@@ -18,4 +18,5 @@ export * from './troveNFT';
 export * from './priceFeed';
 export * from './addressesRegistry';
 export * from './systemParams';
+export * from './liquidityStrategy';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/abis/index.js

@@ -34,4 +34,5 @@ __exportStar(require("./troveNFT"), exports);
 __exportStar(require("./priceFeed"), exports);
 __exportStar(require("./addressesRegistry"), exports);
 __exportStar(require("./systemParams"), exports);
+__exportStar(require("./liquidityStrategy"), exports);
 //# sourceMappingURL=index.js.map

package/dist/core/abis/liquidityStrategy.d.ts

@@ -0,0 +1,132 @@
+export declare const LIQUIDITY_STRATEGY_ABI: readonly [{
+    readonly name: "poolConfigs";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+        readonly name: "isToken0Debt";
+    }, {
+        readonly type: "uint32";
+        readonly name: "lastRebalance";
+    }, {
+        readonly type: "uint32";
+        readonly name: "rebalanceCooldown";
+    }, {
+        readonly type: "address";
+        readonly name: "protocolFeeRecipient";
+    }, {
+        readonly type: "uint64";
+        readonly name: "liquiditySourceIncentiveExpansion";
+    }, {
+        readonly type: "uint64";
+        readonly name: "protocolIncentiveExpansion";
+    }, {
+        readonly type: "uint64";
+        readonly name: "liquiditySourceIncentiveContraction";
+    }, {
+        readonly type: "uint64";
+        readonly name: "protocolIncentiveContraction";
+    }];
+}, {
+    readonly name: "determineAction";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "pool";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "pool";
+        }, {
+            readonly type: "tuple";
+            readonly components: readonly [{
+                readonly type: "uint256";
+                readonly name: "reserveNum";
+            }, {
+                readonly type: "uint256";
+                readonly name: "reserveDen";
+            }];
+            readonly name: "reserves";
+        }, {
+            readonly type: "tuple";
+            readonly components: readonly [{
+                readonly type: "uint256";
+                readonly name: "oracleNum";
+            }, {
+                readonly type: "uint256";
+                readonly name: "oracleDen";
+            }, {
+                readonly type: "bool";
+                readonly name: "poolPriceAbove";
+            }, {
+                readonly type: "uint16";
+                readonly name: "rebalanceThreshold";
+            }];
+            readonly name: "prices";
+        }, {
+            readonly type: "address";
+            readonly name: "token0";
+        }, {
+            readonly type: "address";
+            readonly name: "token1";
+        }, {
+            readonly type: "uint64";
+            readonly name: "token0Dec";
+        }, {
+            readonly type: "uint64";
+            readonly name: "token1Dec";
+        }, {
+            readonly type: "bool";
+            readonly name: "isToken0Debt";
+        }, {
+            readonly type: "tuple";
+            readonly components: readonly [{
+                readonly type: "uint64";
+                readonly name: "liquiditySourceIncentiveExpansion";
+            }, {
+                readonly type: "uint64";
+                readonly name: "protocolIncentiveExpansion";
+            }, {
+                readonly type: "uint64";
+                readonly name: "liquiditySourceIncentiveContraction";
+            }, {
+                readonly type: "uint64";
+                readonly name: "protocolIncentiveContraction";
+            }];
+            readonly name: "incentives";
+        }];
+        readonly name: "ctx";
+    }, {
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint8";
+            readonly name: "dir";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount0Out";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount1Out";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amountOwedToPool";
+        }];
+        readonly name: "action";
+    }];
+}, {
+    readonly name: "rebalance";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "pool";
+    }];
+    readonly outputs: readonly [];
+}];
+//# sourceMappingURL=liquidityStrategy.d.ts.map

package/dist/core/abis/liquidityStrategy.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIQUIDITY_STRATEGY_ABI = void 0;
+const viem_1 = require("viem");
+exports.LIQUIDITY_STRATEGY_ABI = (0, viem_1.parseAbi)([
+    'function poolConfigs(address) view returns (bool isToken0Debt, uint32 lastRebalance, uint32 rebalanceCooldown, address protocolFeeRecipient, uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction)',
+    'function determineAction(address pool) view returns ((address pool, (uint256 reserveNum, uint256 reserveDen) reserves, (uint256 oracleNum, uint256 oracleDen, bool poolPriceAbove, uint16 rebalanceThreshold) prices, address token0, address token1, uint64 token0Dec, uint64 token1Dec, bool isToken0Debt, (uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction) incentives) ctx, (uint8 dir, uint256 amount0Out, uint256 amount1Out, uint256 amountOwedToPool) action)',
+    'function rebalance(address pool)',
+]);
+//# sourceMappingURL=liquidityStrategy.js.map

package/dist/core/constants/addresses.js

@@ -44,6 +44,7 @@ exports.addresses = {
         FPMMFactory: '0x353ED52bF8482027C0e0b9e3c0e5d96A9F680980',
         Router: '0xcf6cD45210b3ffE3cA28379C4683F1e60D0C2CCd',
         ReserveLiquidityStrategy: '0x734bb3251Ec3f1A83f8f2A8609bcEF649D54EbF8',
+        OpenLiquidityStrategy: '0xCCd2aD0603a08EBc14D223a983171ef18192e8c9',
     },
     [chainId_1.ChainId.MONAD]: {},
     [chainId_1.ChainId.CELO_SEPOLIA]: {

package/dist/core/types/contractAddresses.d.ts

@@ -30,6 +30,7 @@ export type ContractAddresses = {
     Router?: string;
     ReserveLiquidityStrategy?: string;
     CDPLiquidityStrategy?: string;
+    OpenLiquidityStrategy?: string;
 };
 /**
  * Map of chain IDs to their contract addresses.

package/dist/core/types/liquidity.d.ts

@@ -1,4 +1,5 @@
 import { CallParams } from './transaction';
+import { LiquidityStrategyDirection } from './pool';
 import { RouterRoute } from '../../utils/pathEncoder';
 export interface LiquidityOptions {
     slippageTolerance: number;
@@ -114,6 +115,39 @@ export interface ZapOutTransaction {
     approval: TokenApproval | null;
     zapOut: ZapOutDetails;
 }
+export interface RebalanceDetails {
+    params: CallParams;
+    poolAddress: string;
+    strategyAddress: string;
+    inputToken: string;
+    outputToken: string;
+    amountRequired: bigint;
+    expectedAmountTransferred: bigint;
+    expectedProtocolIncentive: bigint;
+    expectedLiquiditySourceIncentive: bigint;
+    approvalToken: string;
+    approvalSpender: string;
+    approvalAmount: bigint;
+    direction: LiquidityStrategyDirection;
+}
+export interface RebalanceTransaction {
+    approval: TokenApproval | null;
+    rebalance: RebalanceDetails;
+}
+export interface PreparedZapIn {
+    routesA: RouterRoute[];
+    routesB: RouterRoute[];
+    quote: ZapInQuote;
+    approval?: TokenApproval | null;
+    details: ZapInDetails;
+}
+export interface PreparedZapOut {
+    routesA: RouterRoute[];
+    routesB: RouterRoute[];
+    quote: ZapOutQuote;
+    approval?: TokenApproval | null;
+    details: ZapOutDetails;
+}
 /** Input for adding liquidity (without approval handling) */
 export interface AddLiquidityInput {
     poolAddress: string;
@@ -140,6 +174,9 @@ export interface ZapInInput {
     recipient: string;
     options: LiquidityOptions;
 }
+export interface PrepareZapInInput extends ZapInInput {
+    owner?: string;
+}
 /** Input for zap out (without approval handling) */
 export interface ZapOutInput {
     poolAddress: string;
@@ -148,4 +185,10 @@ export interface ZapOutInput {
     recipient: string;
     options: LiquidityOptions;
 }
+export interface PrepareZapOutInput extends ZapOutInput {
+    owner?: string;
+}
+export interface RebalanceInput {
+    poolAddress: string;
+}
 //# sourceMappingURL=liquidity.d.ts.map

package/dist/core/types/pool.d.ts

@@ -92,9 +92,72 @@ export interface FPMMRebalancing {
     rebalanceThresholdBelowPercent: number;
     /** Whether the current price is within rebalancing thresholds (null when pricing unavailable) */
     inBand: boolean | null;
-    /** The active liquidity strategy address for this pool, or null if none */
+    /** The registered Open Liquidity Strategy address for this pool, or null if none */
     liquidityStrategy: string | null;
 }
+export type LiquidityStrategyDirection = 'Expand' | 'Contract';
+export interface LiquidityStrategyRebalanceIncentives {
+    liquiditySourceIncentiveExpansion: bigint;
+    protocolIncentiveExpansion: bigint;
+    liquiditySourceIncentiveContraction: bigint;
+    protocolIncentiveContraction: bigint;
+}
+export interface LiquidityStrategyPoolConfig {
+    isToken0Debt: boolean;
+    lastRebalance: number;
+    rebalanceCooldown: number;
+    protocolFeeRecipient: string;
+    liquiditySourceIncentiveExpansion: bigint;
+    protocolIncentiveExpansion: bigint;
+    liquiditySourceIncentiveContraction: bigint;
+    protocolIncentiveContraction: bigint;
+}
+export interface LiquidityStrategyContext {
+    pool: string;
+    reserves: {
+        reserveNum: bigint;
+        reserveDen: bigint;
+    };
+    prices: {
+        oracleNum: bigint;
+        oracleDen: bigint;
+        poolPriceAbove: boolean;
+        rebalanceThreshold: number;
+    };
+    token0: string;
+    token1: string;
+    token0Dec: bigint;
+    token1Dec: bigint;
+    isToken0Debt: boolean;
+    incentives: LiquidityStrategyRebalanceIncentives;
+}
+export interface LiquidityStrategyAction {
+    dir: LiquidityStrategyDirection;
+    amount0Out: bigint;
+    amount1Out: bigint;
+    amountOwedToPool: bigint;
+}
+export interface PoolRebalanceTokenAmount {
+    token: string;
+    amount: bigint;
+}
+export interface PoolRebalancePreview {
+    poolAddress: string;
+    strategyAddress: string;
+    direction: LiquidityStrategyDirection;
+    config: LiquidityStrategyPoolConfig;
+    context: LiquidityStrategyContext;
+    action: LiquidityStrategyAction;
+    inputToken: string;
+    outputToken: string;
+    amountRequired: PoolRebalanceTokenAmount;
+    amountTransferred: PoolRebalanceTokenAmount;
+    protocolIncentive: PoolRebalanceTokenAmount;
+    liquiditySourceIncentive: PoolRebalanceTokenAmount;
+    approvalToken: string;
+    approvalSpender: string;
+    approvalAmount: bigint;
+}
 /**
  * Enriched details for an FPMM pool including pricing, fees, and rebalancing state
  */

package/dist/esm/core/abis/index.js

@@ -18,3 +18,4 @@ export * from './troveNFT';
 export * from './priceFeed';
 export * from './addressesRegistry';
 export * from './systemParams';
+export * from './liquidityStrategy';

package/dist/esm/core/abis/liquidityStrategy.js

@@ -0,0 +1,6 @@
+import { parseAbi } from 'viem';
+export const LIQUIDITY_STRATEGY_ABI = parseAbi([
+    'function poolConfigs(address) view returns (bool isToken0Debt, uint32 lastRebalance, uint32 rebalanceCooldown, address protocolFeeRecipient, uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction)',
+    'function determineAction(address pool) view returns ((address pool, (uint256 reserveNum, uint256 reserveDen) reserves, (uint256 oracleNum, uint256 oracleDen, bool poolPriceAbove, uint16 rebalanceThreshold) prices, address token0, address token1, uint64 token0Dec, uint64 token1Dec, bool isToken0Debt, (uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction) incentives) ctx, (uint8 dir, uint256 amount0Out, uint256 amount1Out, uint256 amountOwedToPool) action)',
+    'function rebalance(address pool)',
+]);

package/dist/esm/core/constants/addresses.js

@@ -39,6 +39,7 @@ export const addresses = {
         FPMMFactory: '0x353ED52bF8482027C0e0b9e3c0e5d96A9F680980',
         Router: '0xcf6cD45210b3ffE3cA28379C4683F1e60D0C2CCd',
         ReserveLiquidityStrategy: '0x734bb3251Ec3f1A83f8f2A8609bcEF649D54EbF8',
+        OpenLiquidityStrategy: '0xCCd2aD0603a08EBc14D223a983171ef18192e8c9',
     },
     [ChainId.MONAD]: {},
     [ChainId.CELO_SEPOLIA]: {

package/dist/esm/index.js

@@ -10,6 +10,14 @@ import { SwapService } from './services/swap';
 import { TradingService } from './services/trading';
 import { LiquidityService } from './services/liquidity';
 import { BorrowService } from './services/borrow';
+const DEFAULT_HTTP_BATCH_OPTIONS = {
+    batchSize: 1000,
+    wait: 8,
+};
+const DEFAULT_MULTICALL_BATCH_OPTIONS = {
+    batchSize: 1024,
+    wait: 8,
+};
 /**
  * @class Mento
  * @description The main class for the Mento SDK. Initializes a viem PublicClient internally
@@ -70,14 +78,7 @@ export class Mento {
         this.liquidity = liquidity;
         this.borrow = borrow;
     }
-    /**
-     * Create a new Mento SDK instance
-     * @param chainId - The chain ID (e.g., ChainId.CELO, ChainId.CELO_SEPOLIA)
-     * @param rpcUrlOrClient - Optional RPC URL string or an existing viem PublicClient.
-     *                         If not provided, uses the default RPC URL for the chain.
-     * @returns A new Mento instance
-     */
-    static async create(chainId, rpcUrlOrClient) {
+    static async create(chainId, rpcUrlOrClient, options) {
         // Validate chainId is supported
         const supportedChainIds = Object.values(ChainId).filter((v) => typeof v === 'number');
         if (!supportedChainIds.includes(chainId)) {
@@ -89,8 +90,23 @@ export class Mento {
             publicClient = rpcUrlOrClient;
         }
         else {
-            const transport = http(rpcUrlOrClient || getDefaultRpcUrl(chainId));
+            const transport = http(rpcUrlOrClient || getDefaultRpcUrl(chainId), {
+                batch: options?.httpBatch === false
+                    ? false
+                    : {
+                        ...DEFAULT_HTTP_BATCH_OPTIONS,
+                        ...(options?.httpBatch ?? {}),
+                    },
+            });
             publicClient = createPublicClient({
+                batch: {
+                    multicall: options?.multicallBatch === false
+                        ? false
+                        : {
+                            ...DEFAULT_MULTICALL_BATCH_OPTIONS,
+                            ...(options?.multicallBatch ?? {}),
+                        },
+                },
                 chain: getChainConfig(chainId),
                 transport,
             });

package/dist/esm/services/borrow/internal/borrowReadService.js

@@ -1,27 +1,31 @@
 import { BORROWER_OPERATIONS_ABI, HINT_HELPERS_ABI, MULTI_TROVE_GETTER_ABI, PRICE_FEED_ABI, TROVE_MANAGER_ABI, TROVE_NFT_ABI, } from '../../../core/abis';
 import { COLL_INDEX } from '../../../core/constants';
+import { multicall } from '../../../utils/multicall';
 import { parseBorrowPosition } from './borrowPositionParser';
 import { formatTroveId, MAX_SAFE_INTEGER_BIGINT, parseTroveId, requireAddress, requireNonNegativeBigInt, } from './borrowValidation';
+const TROVE_ID_BATCH_SIZE = 64;
+const TROVE_OWNER_BATCH_SIZE = 64;
+const TROVE_DETAIL_BATCH_SIZE = 64;
 export class BorrowReadService {
     constructor(publicClient) {
         this.publicClient = publicClient;
     }
     async getTroveData(ctx, troveId) {
         const parsedTroveId = parseTroveId(troveId);
-        const [latestData, trovesData] = await Promise.all([
-            this.publicClient.readContract({
+        const [latestData, trovesData] = await this.readContractsInChunks([
+            {
                 address: ctx.addresses.troveManager,
                 abi: TROVE_MANAGER_ABI,
                 functionName: 'getLatestTroveData',
                 args: [parsedTroveId],
-            }),
-            this.publicClient.readContract({
+            },
+            {
                 address: ctx.addresses.troveManager,
                 abi: TROVE_MANAGER_ABI,
                 functionName: 'Troves',
                 args: [parsedTroveId],
-            }),
-        ]);
+            },
+        ], 2);
         return parseBorrowPosition(formatTroveId(parsedTroveId), latestData, trovesData);
     }
     async getUserTroves(ctx, owner) {
@@ -32,41 +36,49 @@ export class BorrowReadService {
             functionName: 'getTroveIdsCount',
             args: [],
         }));
-        const matchedTroveIds = [];
+        if (troveCount === 0n) {
+            return [];
+        }
+        const troveIdContracts = [];
         for (let i = 0n; i < troveCount; i++) {
-            const troveId = (await this.publicClient.readContract({
+            troveIdContracts.push({
                 address: ctx.addresses.troveManager,
                 abi: TROVE_MANAGER_ABI,
                 functionName: 'getTroveFromTroveIdsArray',
                 args: [i],
-            }));
-            const troveOwner = (await this.publicClient.readContract({
-                address: ctx.addresses.troveNFT,
-                abi: TROVE_NFT_ABI,
-                functionName: 'ownerOf',
-                args: [troveId],
-            }));
-            if (troveOwner.toLowerCase() === ownerAddress.toLowerCase()) {
-                matchedTroveIds.push(troveId);
-            }
+            });
         }
-        return Promise.all(matchedTroveIds.map(async (troveId) => {
-            const [latestData, trovesData] = await Promise.all([
-                this.publicClient.readContract({
-                    address: ctx.addresses.troveManager,
-                    abi: TROVE_MANAGER_ABI,
-                    functionName: 'getLatestTroveData',
-                    args: [troveId],
-                }),
-                this.publicClient.readContract({
-                    address: ctx.addresses.troveManager,
-                    abi: TROVE_MANAGER_ABI,
-                    functionName: 'Troves',
-                    args: [troveId],
-                }),
-            ]);
-            return parseBorrowPosition(formatTroveId(troveId), latestData, trovesData);
+        const troveIds = (await this.readContractsInChunks(troveIdContracts, TROVE_ID_BATCH_SIZE)).map((troveId) => troveId);
+        const ownerContracts = troveIds.map((troveId) => ({
+            address: ctx.addresses.troveNFT,
+            abi: TROVE_NFT_ABI,
+            functionName: 'ownerOf',
+            args: [troveId],
         }));
+        const troveOwners = await this.readContractsInChunks(ownerContracts, TROVE_OWNER_BATCH_SIZE);
+        const matchedTroveIds = troveIds.filter((troveId, index) => troveOwners[index].toLowerCase() === ownerAddress.toLowerCase());
+        if (matchedTroveIds.length === 0) {
+            return [];
+        }
+        const troveDetailContracts = matchedTroveIds.flatMap((troveId) => ([
+            {
+                address: ctx.addresses.troveManager,
+                abi: TROVE_MANAGER_ABI,
+                functionName: 'getLatestTroveData',
+                args: [troveId],
+            },
+            {
+                address: ctx.addresses.troveManager,
+                abi: TROVE_MANAGER_ABI,
+                functionName: 'Troves',
+                args: [troveId],
+            },
+        ]));
+        const detailResults = await this.readContractsInChunks(troveDetailContracts, TROVE_DETAIL_BATCH_SIZE * 2);
+        return matchedTroveIds.map((troveId, index) => {
+            const offset = index * 2;
+            return parseBorrowPosition(formatTroveId(troveId), detailResults[offset], detailResults[offset + 1]);
+        });
     }
     async getCollateralPrice(ctx) {
         return (await this.publicClient.readContract({
@@ -210,4 +222,21 @@ export class BorrowReadService {
         }
         return Number(ownerTroveCount);
     }
+    async readContractsInChunks(contracts, chunkSize) {
+        if (contracts.length === 0) {
+            return [];
+        }
+        const results = [];
+        for (let index = 0; index < contracts.length; index += chunkSize) {
+            const chunk = contracts.slice(index, index + chunkSize);
+            const chunkResults = await multicall(this.publicClient, chunk, { allowFailure: false });
+            for (const result of chunkResults) {
+                if (result.status === 'failure') {
+                    throw result.error;
+                }
+                results.push(result.result);
+            }
+        }
+        return results;
+    }
 }

package/dist/esm/services/borrow/internal/borrowRegistryReader.js

@@ -1,9 +1,26 @@
 import { ADDRESSES_REGISTRY_ABI, BORROWER_OPERATIONS_ABI, SYSTEM_PARAMS_ABI, } from '../../../core/abis';
+import { multicall } from '../../../utils/multicall';
 import { validateAddress } from '../../../utils/validation';
 function readNoArgsContract(publicClient, address, abi, functionName) {
     const readContract = publicClient.readContract;
     return readContract({ address, abi, functionName, args: [] });
 }
+async function readNoArgsContracts(publicClient, contracts) {
+    if (contracts.length === 0) {
+        return [];
+    }
+    const results = await multicall(publicClient, contracts.map((contract) => ({
+        ...contract,
+        abi: contract.abi,
+        args: [],
+    })), { allowFailure: false });
+    return results.map((result) => {
+        if (result.status === 'failure') {
+            throw result.error;
+        }
+        return result.result;
+    });
+}
 function requireAddress(value, fieldName) {
     if (typeof value !== 'string') {
         throw new Error(`${fieldName} must be a string address`);
@@ -23,26 +40,26 @@ function requireBigInt(value, fieldName) {
 export async function resolveAddressesFromRegistry(publicClient, registryAddress) {
     validateAddress(registryAddress, 'registryAddress');
     const registry = registryAddress;
-    const [borrowerOperationsRaw, troveManagerRaw, sortedTrovesRaw, activePoolRaw, defaultPoolRaw, hintHelpersRaw, multiTroveGetterRaw, collTokenRaw, debtTokenRaw, troveNFTRaw, metadataNFTRaw, stabilityPoolRaw, priceFeedRaw, collSurplusPoolRaw, interestRouterRaw, collateralRegistryRaw, gasTokenRaw, gasPoolAddressRaw, liquidityStrategyRaw,] = await Promise.all([
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'borrowerOperations'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'troveManager'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'sortedTroves'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'activePool'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'defaultPool'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'hintHelpers'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'multiTroveGetter'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'collToken'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'boldToken'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'troveNFT'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'metadataNFT'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'stabilityPool'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'priceFeed'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'collSurplusPool'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'interestRouter'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'collateralRegistry'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'gasToken'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'gasPoolAddress'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'liquidityStrategy'),
+    const [borrowerOperationsRaw, troveManagerRaw, sortedTrovesRaw, activePoolRaw, defaultPoolRaw, hintHelpersRaw, multiTroveGetterRaw, collTokenRaw, debtTokenRaw, troveNFTRaw, metadataNFTRaw, stabilityPoolRaw, priceFeedRaw, collSurplusPoolRaw, interestRouterRaw, collateralRegistryRaw, gasTokenRaw, gasPoolAddressRaw, liquidityStrategyRaw,] = await readNoArgsContracts(publicClient, [
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'borrowerOperations' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'troveManager' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'sortedTroves' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'activePool' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'defaultPool' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'hintHelpers' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'multiTroveGetter' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'collToken' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'boldToken' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'troveNFT' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'metadataNFT' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'stabilityPool' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'priceFeed' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'collSurplusPool' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'interestRouter' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'collateralRegistry' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'gasToken' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'gasPoolAddress' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'liquidityStrategy' },
     ]);
     return {
         borrowerOperations: requireAddress(borrowerOperationsRaw, 'borrowerOperations'),
@@ -70,14 +87,14 @@ export async function readSystemParams(publicClient, borrowerOperations) {
     validateAddress(borrowerOperations, 'borrowerOperations');
     const systemParamsAddressRaw = await readNoArgsContract(publicClient, borrowerOperations, BORROWER_OPERATIONS_ABI, 'systemParams');
     const systemParamsAddress = requireAddress(systemParamsAddressRaw, 'systemParamsAddress');
-    const [ccrRaw, mcrRaw, scrRaw, bcrRaw, minDebtRaw, ethGasCompensationRaw, minAnnualInterestRateRaw,] = await Promise.all([
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'CCR'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'MCR'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'SCR'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'BCR'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'MIN_DEBT'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'ETH_GAS_COMPENSATION'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'MIN_ANNUAL_INTEREST_RATE'),
+    const [ccrRaw, mcrRaw, scrRaw, bcrRaw, minDebtRaw, ethGasCompensationRaw, minAnnualInterestRateRaw,] = await readNoArgsContracts(publicClient, [
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'CCR' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'MCR' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'SCR' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'BCR' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'MIN_DEBT' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'ETH_GAS_COMPENSATION' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'MIN_ANNUAL_INTEREST_RATE' },
     ]);
     return {
         mcr: requireBigInt(mcrRaw, 'MCR'),

package/dist/esm/services/index.js

@@ -5,3 +5,4 @@ export * from './swap';
 export * from './trading';
 export * from './borrow';
 export * from './tokens';
+export * from './liquidity';