@mento-protocol/mento-sdk 3.2.7 → 3.3.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+import { type PublicClient } from 'viem';
+import { ContractAddresses } from './core/types';
+import { TokenService } from './services/tokens';
+import { PoolService } from './services/pools';
+import { RouteService } from './services/routes';
+import { QuoteService } from './services/quotes';
+import { SwapService } from './services/swap';
+import { TradingService } from './services/trading';
+import { LiquidityService } from './services/liquidity';
+import { BorrowService } from './services/borrow';
+export interface MentoBatchOptions {
+    batchSize?: number;
+    wait?: number;
+}
+export interface MentoClientOptions {
+    httpBatch?: MentoBatchOptions | false;
+    multicallBatch?: MentoBatchOptions | false;
+}
+/**
+ * @class Mento
+ * @description The main class for the Mento SDK. Initializes a viem PublicClient internally
+ *              and provides a public API for interacting with the Mento Protocol.
+ * @dev         example usage:
+ *              const mento = await Mento.create(ChainId.CELO);
+ *              // or with custom RPC URL
+ *              const mento = await Mento.create(ChainId.CELO, 'https://custom-rpc-url.com');
+ *              // or with an existing viem PublicClient
+ *              const mento = await Mento.create(ChainId.CELO, myPublicClient);
+ *
+ *              // Get all stable tokens
+ *              const stableTokens = await mento.tokens.getStableTokens();
+ *
+ *              // Get all collateral assets
+ *              const collateralAssets = await mento.tokens.getCollateralAssets();
+ *
+ *              // Get all pools
+ *              const pools = await mento.pools.getPools();
+ *
+ *              // Find a route between tokens
+ *              const route = await mento.routes.findRoute(USDm, CELO);
+ *
+ *              // Get a quote for a swap
+ *              const amountOut = await mento.quotes.getAmountOut(USDm, CELO, amountIn);
+ *
+ *              // Build swap parameters
+ *              const swapDetails = await mento.swap.buildSwapParams(USDm, CELO, amountIn, recipient, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) });
+ *
+ *              // Check if a pair is tradable (circuit breaker check)
+ *              const isTradable = await mento.trading.isPairTradable(USDm, CELO);
+ *
+ *              // Get trading limits for a pool
+ *              const limits = await mento.trading.getPoolTradingLimits(pool);
+ *
+ *              // Get full tradability status (circuit breaker + limits)
+ *              const status = await mento.trading.getPoolTradabilityStatus(pool);
+ *
+ *              // Add liquidity to a pool
+ *              const { approval0, approval1, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction(
+ *                poolAddress, amount0, amount1, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
+ *              );
+ *
+ *              // Add liquidity using a single token (zap in)
+ *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction(
+ *                poolAddress, tokenIn, amountIn, 0.5, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
+ *              );
+ */
+export declare class Mento {
+    private chainId;
+    tokens: TokenService;
+    pools: PoolService;
+    routes: RouteService;
+    quotes: QuoteService;
+    swap: SwapService;
+    trading: TradingService;
+    liquidity: LiquidityService;
+    borrow: BorrowService;
+    private constructor();
+    /**
+     * 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.
+     * @param options - Optional batching configuration used only when the SDK creates the PublicClient internally.
+     * @returns A new Mento instance
+     */
+    static create(chainId: number): Promise<Mento>;
+    static create(chainId: number, rpcUrlOrClient: string | PublicClient, options?: MentoClientOptions): Promise<Mento>;
+    /**
+     * Get the address of a contract for the current chain
+     * @param contractName - The contract name
+     * @returns The contract address
+     */
+    getContractAddress(contractName: keyof ContractAddresses): string;
+}
+export * from './core/constants';
+export * from './core/errors';
+export * from './core/types';
+export * from './core/abis';
+export * from './services';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mento = void 0;
+const viem_1 = require("viem");
+const chainId_1 = require("./core/constants/chainId");
+const addresses_1 = require("./core/constants/addresses");
+const chainConfig_1 = require("./utils/chainConfig");
+const tokens_1 = require("./services/tokens");
+const pools_1 = require("./services/pools");
+const routes_1 = require("./services/routes");
+const quotes_1 = require("./services/quotes");
+const swap_1 = require("./services/swap");
+const trading_1 = require("./services/trading");
+const liquidity_1 = require("./services/liquidity");
+const borrow_1 = require("./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
+ *              and provides a public API for interacting with the Mento Protocol.
+ * @dev         example usage:
+ *              const mento = await Mento.create(ChainId.CELO);
+ *              // or with custom RPC URL
+ *              const mento = await Mento.create(ChainId.CELO, 'https://custom-rpc-url.com');
+ *              // or with an existing viem PublicClient
+ *              const mento = await Mento.create(ChainId.CELO, myPublicClient);
+ *
+ *              // Get all stable tokens
+ *              const stableTokens = await mento.tokens.getStableTokens();
+ *
+ *              // Get all collateral assets
+ *              const collateralAssets = await mento.tokens.getCollateralAssets();
+ *
+ *              // Get all pools
+ *              const pools = await mento.pools.getPools();
+ *
+ *              // Find a route between tokens
+ *              const route = await mento.routes.findRoute(USDm, CELO);
+ *
+ *              // Get a quote for a swap
+ *              const amountOut = await mento.quotes.getAmountOut(USDm, CELO, amountIn);
+ *
+ *              // Build swap parameters
+ *              const swapDetails = await mento.swap.buildSwapParams(USDm, CELO, amountIn, recipient, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) });
+ *
+ *              // Check if a pair is tradable (circuit breaker check)
+ *              const isTradable = await mento.trading.isPairTradable(USDm, CELO);
+ *
+ *              // Get trading limits for a pool
+ *              const limits = await mento.trading.getPoolTradingLimits(pool);
+ *
+ *              // Get full tradability status (circuit breaker + limits)
+ *              const status = await mento.trading.getPoolTradabilityStatus(pool);
+ *
+ *              // Add liquidity to a pool
+ *              const { approval0, approval1, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction(
+ *                poolAddress, amount0, amount1, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
+ *              );
+ *
+ *              // Add liquidity using a single token (zap in)
+ *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction(
+ *                poolAddress, tokenIn, amountIn, 0.5, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
+ *              );
+ */
+class Mento {
+    constructor(chainId, tokens, pools, routes, quotes, swap, trading, liquidity, borrow) {
+        this.chainId = chainId;
+        this.tokens = tokens;
+        this.pools = pools;
+        this.routes = routes;
+        this.quotes = quotes;
+        this.swap = swap;
+        this.trading = trading;
+        this.liquidity = liquidity;
+        this.borrow = borrow;
+    }
+    static async create(chainId, rpcUrlOrClient, options) {
+        // Validate chainId is supported
+        const supportedChainIds = Object.values(chainId_1.ChainId).filter((v) => typeof v === 'number');
+        if (!supportedChainIds.includes(chainId)) {
+            throw new Error(`ChainId ${chainId} is not supported. ` +
+                `Supported chains: ${supportedChainIds.map((id) => `${id} (${chainId_1.ChainId[id]})`).join(', ')}`);
+        }
+        let publicClient;
+        if (rpcUrlOrClient && typeof rpcUrlOrClient !== 'string') {
+            publicClient = rpcUrlOrClient;
+        }
+        else {
+            const transport = (0, viem_1.http)(rpcUrlOrClient || (0, chainConfig_1.getDefaultRpcUrl)(chainId), {
+                batch: options?.httpBatch === false
+                    ? false
+                    : {
+                        ...DEFAULT_HTTP_BATCH_OPTIONS,
+                        ...(options?.httpBatch ?? {}),
+                    },
+            });
+            publicClient = (0, viem_1.createPublicClient)({
+                batch: {
+                    multicall: options?.multicallBatch === false
+                        ? false
+                        : {
+                            ...DEFAULT_MULTICALL_BATCH_OPTIONS,
+                            ...(options?.multicallBatch ?? {}),
+                        },
+                },
+                chain: (0, chainConfig_1.getChainConfig)(chainId),
+                transport,
+            });
+        }
+        const tokenService = new tokens_1.TokenService(publicClient, chainId);
+        const poolService = new pools_1.PoolService(publicClient, chainId);
+        const routeService = new routes_1.RouteService(publicClient, chainId, poolService);
+        const quoteService = new quotes_1.QuoteService(publicClient, chainId, routeService);
+        const swapService = new swap_1.SwapService(publicClient, chainId, routeService, quoteService);
+        const tradingService = new trading_1.TradingService(publicClient, chainId, routeService);
+        const liquidityService = new liquidity_1.LiquidityService(publicClient, chainId, poolService, routeService);
+        const borrowService = new borrow_1.BorrowService(publicClient, chainId);
+        // Return new mento
+        return new Mento(chainId, tokenService, poolService, routeService, quoteService, swapService, tradingService, liquidityService, borrowService);
+    }
+    /**
+     * Get the address of a contract for the current chain
+     * @param contractName - The contract name
+     * @returns The contract address
+     */
+    getContractAddress(contractName) {
+        return (0, addresses_1.getContractAddress)(this.chainId, contractName);
+    }
+}
+exports.Mento = Mento;
+__exportStar(require("./core/constants"), exports);
+__exportStar(require("./core/errors"), exports);
+__exportStar(require("./core/types"), exports);
+__exportStar(require("./core/abis"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=index.js.map

package/dist/services/borrow/BorrowService.d.ts

@@ -0,0 +1,381 @@
+import { PublicClient } from 'viem';
+import { AdjustTroveParams, BorrowPosition, CallParams, InterestRateBracket, OpenTroveParams, SystemParams } from '../../core/types';
+/**
+ * Service for managing borrowing positions (troves) in the Mento protocol.
+ * Provides methods to open, adjust, and close troves, manage collateral and debt,
+ * handle interest rates and batch managers, and query position data.
+ *
+ * All `build*` methods return `CallParams` ({ to, data, value }) that can be
+ * executed with any wallet client. The `debtTokenSymbol` parameter (e.g., 'GBPm')
+ * identifies which borrowing deployment to interact with.
+ *
+ * @example
+ * ```typescript
+ * const mento = await Mento.create(ChainId.CELO)
+ *
+ * const ownerIndex = await mento.borrow.findNextAvailableOwnerIndex('GBPm', '0x...', '0x...')
+ *
+ * // Open a trove
+ * const tx = await mento.borrow.buildOpenTroveTransaction('GBPm', {
+ *   owner: '0x...', ownerIndex,
+ *   collAmount: parseUnits('10', 18),
+ *   boldAmount: parseUnits('1000', 18),
+ *   annualInterestRate: parseUnits('0.05', 18),
+ *   maxUpfrontFee: parseUnits('100', 18),
+ * })
+ * await walletClient.sendTransaction(tx)
+ * ```
+ */
+export declare class BorrowService {
+    private contextStore;
+    private txService;
+    private approvalService;
+    private readService;
+    constructor(publicClient: PublicClient, chainId: number);
+    /**
+     * Builds a transaction to open a new trove (borrowing position).
+     * Requires prior collateral approval via `buildCollateralApprovalParams`.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param params - Trove opening parameters including collateral, debt amount, and interest rate
+     * @returns Transaction parameters ready to send
+     */
+    buildOpenTroveTransaction(debtTokenSymbol: string, params: OpenTroveParams): Promise<CallParams>;
+    /**
+     * Builds a transaction to adjust an existing trove's collateral and/or debt.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param params - Adjustment parameters specifying collateral/debt changes
+     * @returns Transaction parameters ready to send
+     */
+    buildAdjustTroveTransaction(debtTokenSymbol: string, params: AdjustTroveParams): Promise<CallParams>;
+    /**
+     * Builds a transaction to adjust a zombie trove. Zombie troves are still-open troves whose
+     * debt fell below the branch minimum debt, typically after a redemption.
+     *
+     * Use this when `getTroveData()` or `getUserTroves()` returns `status === 'zombie'`.
+     * Same parameters as `buildAdjustTroveTransaction`.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param params - Adjustment parameters specifying collateral/debt changes
+     * @returns Transaction parameters ready to send
+     */
+    buildAdjustZombieTroveTransaction(debtTokenSymbol: string, params: AdjustTroveParams): Promise<CallParams>;
+    /**
+     * Builds a transaction to close a trove, repaying all debt and reclaiming collateral.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @returns Transaction parameters ready to send
+     */
+    buildCloseTroveTransaction(debtTokenSymbol: string, troveId: string): Promise<CallParams>;
+    /**
+     * Builds a transaction to add collateral to an existing trove.
+     * Requires prior collateral approval via `buildCollateralApprovalParams`.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param amount - Amount of collateral to add (in wei)
+     * @returns Transaction parameters ready to send
+     */
+    buildAddCollTransaction(debtTokenSymbol: string, troveId: string, amount: bigint): Promise<CallParams>;
+    /**
+     * Builds a transaction to withdraw collateral from an existing trove.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param amount - Amount of collateral to withdraw (in wei)
+     * @returns Transaction parameters ready to send
+     */
+    buildWithdrawCollTransaction(debtTokenSymbol: string, troveId: string, amount: bigint): Promise<CallParams>;
+    /**
+     * Builds a transaction to borrow additional debt against an existing trove.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param amount - Additional debt amount to borrow (in wei)
+     * @param maxFee - Maximum upfront fee the borrower is willing to pay (in wei)
+     * @returns Transaction parameters ready to send
+     */
+    buildBorrowMoreTransaction(debtTokenSymbol: string, troveId: string, amount: bigint, maxFee: bigint): Promise<CallParams>;
+    /**
+     * Builds a transaction to repay debt on an existing trove.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param amount - Amount of debt to repay (in wei)
+     * @returns Transaction parameters ready to send
+     */
+    buildRepayDebtTransaction(debtTokenSymbol: string, troveId: string, amount: bigint): Promise<CallParams>;
+    /**
+     * Builds a transaction to change the annual interest rate on a trove.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param newRate - New annual interest rate (18-decimal fixed-point, e.g., parseUnits('0.05', 18) for 5%)
+     * @param maxFee - Maximum upfront fee the borrower is willing to pay (in wei)
+     * @returns Transaction parameters ready to send
+     */
+    buildAdjustInterestRateTransaction(debtTokenSymbol: string, troveId: string, newRate: bigint, maxFee: bigint): Promise<CallParams>;
+    /**
+     * Builds a transaction to claim collateral surplus after a liquidation.
+     * This is for collateral held in the surplus pool after `closedByLiquidation`.
+     * Zombie troves with remaining collateral should usually be closed or adjusted instead.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @returns Transaction parameters ready to send
+     */
+    buildClaimCollateralTransaction(debtTokenSymbol: string): Promise<CallParams>;
+    /**
+     * Builds a transaction to delegate interest rate management to a batch manager.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param manager - Address of the batch manager contract
+     * @param maxFee - Maximum upfront fee the borrower is willing to pay (in wei)
+     * @returns Transaction parameters ready to send
+     */
+    buildSetBatchManagerTransaction(debtTokenSymbol: string, troveId: string, manager: string, maxFee: bigint): Promise<CallParams>;
+    /**
+     * Builds a transaction to remove a trove from a batch manager, setting a new individual rate.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param newRate - New individual annual interest rate (18-decimal fixed-point)
+     * @param maxFee - Maximum upfront fee the borrower is willing to pay (in wei)
+     * @returns Transaction parameters ready to send
+     */
+    buildRemoveFromBatchTransaction(debtTokenSymbol: string, troveId: string, newRate: bigint, maxFee: bigint): Promise<CallParams>;
+    /**
+     * Builds a transaction to switch a trove to a different batch manager.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param newManager - Address of the new batch manager contract
+     * @param maxFee - Maximum upfront fee the borrower is willing to pay (in wei)
+     * @returns Transaction parameters ready to send
+     */
+    buildSwitchBatchManagerTransaction(debtTokenSymbol: string, troveId: string, newManager: string, maxFee: bigint): Promise<CallParams>;
+    /**
+     * Builds a transaction to delegate interest rate management to another address
+     * with bounded rate constraints.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param delegate - Address to delegate interest rate management to
+     * @param minRate - Minimum allowed annual interest rate (18-decimal fixed-point)
+     * @param maxRate - Maximum allowed annual interest rate (18-decimal fixed-point)
+     * @param newRate - Initial annual interest rate to set (18-decimal fixed-point)
+     * @param maxFee - Maximum upfront fee the borrower is willing to pay (in wei)
+     * @param minChangePeriod - Minimum time between rate changes (in seconds)
+     * @returns Transaction parameters ready to send
+     */
+    buildSetInterestDelegateTransaction(debtTokenSymbol: string, troveId: string, delegate: string, minRate: bigint, maxRate: bigint, newRate: bigint, maxFee: bigint, minChangePeriod: bigint): Promise<CallParams>;
+    /**
+     * Builds a transaction to remove the interest rate delegate from a trove.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @returns Transaction parameters ready to send
+     */
+    buildRemoveInterestDelegateTransaction(debtTokenSymbol: string, troveId: string): Promise<CallParams>;
+    /**
+     * Builds approval params to allow BorrowerOperations to spend collateral tokens.
+     * Must be executed before `buildOpenTroveTransaction` or `buildAddCollTransaction`.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param amount - Amount of collateral to approve (in wei)
+     * @returns Transaction parameters for the ERC-20 approve call
+     */
+    buildCollateralApprovalParams(debtTokenSymbol: string, amount: bigint): Promise<CallParams>;
+    /**
+     * Builds approval params for the debt token (e.g., for repayment or closing).
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param spender - Address to approve as spender
+     * @param amount - Amount of debt tokens to approve (in wei)
+     * @returns Transaction parameters for the ERC-20 approve call
+     */
+    buildDebtApprovalParams(debtTokenSymbol: string, spender: string, amount: bigint): Promise<CallParams>;
+    /**
+     * Builds approval params for the gas compensation token (required when opening a trove).
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param amount - Amount to approve (in wei). If omitted, approves the gas compensation amount.
+     * @returns Transaction parameters for the ERC-20 approve call
+     */
+    buildGasCompensationApprovalParams(debtTokenSymbol: string, amount?: bigint): Promise<CallParams>;
+    /**
+     * Gets the current collateral token allowance for BorrowerOperations.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param owner - Address to check allowance for
+     * @returns Current allowance in wei
+     */
+    getCollateralAllowance(debtTokenSymbol: string, owner: string): Promise<bigint>;
+    /**
+     * Gets the current debt token allowance for a specific spender.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param owner - Address to check allowance for
+     * @param spender - Address of the approved spender
+     * @returns Current allowance in wei
+     */
+    getDebtAllowance(debtTokenSymbol: string, owner: string, spender: string): Promise<bigint>;
+    /**
+     * Gets the current gas compensation token allowance.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param owner - Address to check allowance for
+     * @returns Current allowance in wei
+     */
+    getGasTokenAllowance(debtTokenSymbol: string, owner: string): Promise<bigint>;
+    /**
+     * Fetches on-chain data for a specific trove.
+     * The returned position reflects the trove's current lifecycle status, including
+     * zombie troves that may still hold collateral even when their debt is zero.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @returns Trove position data including collateral, debt, interest rate, and status
+     */
+    getTroveData(debtTokenSymbol: string, troveId: string): Promise<BorrowPosition>;
+    /**
+     * Fetches troves currently owned by an address via the Trove NFT.
+     * This includes zombie troves that have been removed from `SortedTroves` but are still owned
+     * by the address. Closed or liquidated troves are not returned once their Trove NFT is burned
+     * or transferred away.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param owner - Address to query troves for
+     * @returns Array of trove positions currently owned by the address
+     */
+    getUserTroves(debtTokenSymbol: string, owner: string): Promise<BorrowPosition[]>;
+    /**
+     * Gets the current collateral token price from the price feed.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @returns Collateral price in 18-decimal fixed-point format
+     */
+    getCollateralPrice(debtTokenSymbol: string): Promise<bigint>;
+    /**
+     * Gets the system parameters for a borrowing deployment.
+     * Returns MCR, CCR, SCR, BCR, minimum debt, gas compensation, and minimum interest rate.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @returns System parameters (all values in 18-decimal fixed-point)
+     */
+    getSystemParams(debtTokenSymbol: string): Promise<SystemParams>;
+    /**
+     * Checks whether the borrowing system has been shut down (e.g., during a crisis).
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @returns true if the system is shut down, false otherwise
+     */
+    isSystemShutDown(debtTokenSymbol: string): Promise<boolean>;
+    /**
+     * Gets aggregate collateral and debt statistics for the borrowing branch.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @returns Total collateral and total debt across all troves (in wei)
+     */
+    getBranchStats(debtTokenSymbol: string): Promise<{
+        totalColl: bigint;
+        totalDebt: bigint;
+    }>;
+    /**
+     * Gets the distribution of debt across interest rate brackets.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @returns Array of brackets, each with a rate and total debt at that rate
+     */
+    getInterestRateBrackets(debtTokenSymbol: string): Promise<InterestRateBracket[]>;
+    /**
+     * Gets the weighted average interest rate across all active troves.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @returns Average annual interest rate in 18-decimal fixed-point
+     */
+    getAverageInterestRate(debtTokenSymbol: string): Promise<bigint>;
+    /**
+     * Gets information about a batch manager's configuration.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param address - Address of the batch manager
+     * @returns Batch manager config (min/max rate, min change period), or null if not a valid manager
+     */
+    getBatchManagerInfo(debtTokenSymbol: string, address: string): Promise<{
+        minRate: bigint;
+        maxRate: bigint;
+        minChangePeriod: bigint;
+    } | null>;
+    /**
+     * Estimates the upfront fee for opening a new trove.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param amount - Debt amount to borrow (in wei)
+     * @param rate - Annual interest rate (18-decimal fixed-point)
+     * @returns Estimated upfront fee in wei
+     */
+    predictOpenTroveUpfrontFee(debtTokenSymbol: string, amount: bigint, rate: bigint): Promise<bigint>;
+    /**
+     * Estimates the upfront fee for increasing debt on an existing trove.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param debtIncrease - Amount of additional debt (in wei)
+     * @returns Estimated upfront fee in wei
+     */
+    predictAdjustUpfrontFee(debtTokenSymbol: string, troveId: string, debtIncrease: bigint): Promise<bigint>;
+    /**
+     * Estimates the upfront fee for changing a trove's interest rate.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param newRate - New annual interest rate (18-decimal fixed-point)
+     * @returns Estimated upfront fee in wei
+     */
+    predictAdjustInterestRateUpfrontFee(debtTokenSymbol: string, troveId: string, newRate: bigint): Promise<bigint>;
+    /**
+     * Estimates the upfront fee for joining a batch manager.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param troveId - The NFT token ID identifying the trove
+     * @param batchAddress - Address of the batch manager to join
+     * @returns Estimated upfront fee in wei
+     */
+    predictJoinBatchUpfrontFee(debtTokenSymbol: string, troveId: string, batchAddress: string): Promise<bigint>;
+    /**
+     * Gets the current number of troves owned by an address via the Trove NFT.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param owner - Address of the trove owner
+     * @returns The number of troves currently owned by the address
+     */
+    getOwnedTroveCount(debtTokenSymbol: string, owner: string): Promise<number>;
+    /**
+     * Finds the first safe owner index for opening a trove with the given transaction sender.
+     *
+     * The `opener` must be the address that will call BorrowerOperations on-chain.
+     * For smart accounts, pass the smart account address rather than the controlling EOA.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param owner - Address that will own the trove NFT
+     * @param opener - Address that will submit the open-trove transaction on-chain
+     * @returns The first owner index that does not already map to an existing trove
+     */
+    findNextAvailableOwnerIndex(debtTokenSymbol: string, owner: string, opener: string): Promise<number>;
+    /**
+     * Gets the current number of troves owned by an address via the Trove NFT.
+     *
+     * @deprecated Use `findNextAvailableOwnerIndex` when preparing an open-trove transaction.
+     *
+     * @param debtTokenSymbol - The debt token symbol (e.g., 'GBPm')
+     * @param owner - Address of the trove owner
+     * @returns The number of troves currently owned by the address
+     */
+    getNextOwnerIndex(debtTokenSymbol: string, owner: string): Promise<number>;
+    private withContext;
+    private ensureInitialized;
+}
+//# sourceMappingURL=BorrowService.d.ts.map