@mento-protocol/mento-sdk 3.2.6 → 3.2.7

package/dist/esm/index.js

@@ -1,139 +0,0 @@
-import { createPublicClient, http } from 'viem';
-import { ChainId } from './core/constants/chainId';
-import { getContractAddress } from './core/constants/addresses';
-import { getDefaultRpcUrl, getChainConfig } from './utils/chainConfig';
-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';
-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) }
- *              );
- */
-export 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).filter((v) => typeof v === 'number');
-        if (!supportedChainIds.includes(chainId)) {
-            throw new Error(`ChainId ${chainId} is not supported. ` +
-                `Supported chains: ${supportedChainIds.map((id) => `${id} (${ChainId[id]})`).join(', ')}`);
-        }
-        let publicClient;
-        if (rpcUrlOrClient && typeof rpcUrlOrClient !== 'string') {
-            publicClient = rpcUrlOrClient;
-        }
-        else {
-            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,
-            });
-        }
-        const tokenService = new TokenService(publicClient, chainId);
-        const poolService = new PoolService(publicClient, chainId);
-        const routeService = new RouteService(publicClient, chainId, poolService);
-        const quoteService = new QuoteService(publicClient, chainId, routeService);
-        const swapService = new SwapService(publicClient, chainId, routeService, quoteService);
-        const tradingService = new TradingService(publicClient, chainId, routeService);
-        const liquidityService = new LiquidityService(publicClient, chainId, poolService, routeService);
-        const borrowService = new 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 getContractAddress(this.chainId, contractName);
-    }
-}
-export * from './core/constants';
-export * from './core/errors';
-export * from './core/types';
-export * from './core/abis';
-export * from './services';
-export * from './utils';

package/dist/esm/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/dist/esm/services/borrow/BorrowService.js

@@ -1,455 +0,0 @@
-import { BorrowApprovalService } from './internal/borrowApprovalService';
-import { BorrowContextStore } from './internal/borrowContextStore';
-import { BorrowReadService } from './internal/borrowReadService';
-import { BorrowTransactionService } from './internal/borrowTransactionService';
-/**
- * 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 class BorrowService {
-    constructor(publicClient, chainId) {
-        this.contextStore = new BorrowContextStore(publicClient, chainId);
-        this.txService = new BorrowTransactionService(publicClient);
-        this.approvalService = new BorrowApprovalService(publicClient);
-        this.readService = new BorrowReadService(publicClient);
-    }
-    /**
-     * 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, params) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildOpenTroveTransaction(ctx, params));
-    }
-    /**
-     * 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, params) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildAdjustTroveTransaction(ctx, params));
-    }
-    /**
-     * 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, params) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildAdjustZombieTroveTransaction(ctx, params));
-    }
-    /**
-     * 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, troveId) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildCloseTroveTransaction(ctx, troveId));
-    }
-    /**
-     * 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, troveId, amount) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildAddCollTransaction(ctx, troveId, amount));
-    }
-    /**
-     * 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, troveId, amount) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildWithdrawCollTransaction(ctx, troveId, amount));
-    }
-    /**
-     * 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, troveId, amount, maxFee) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildBorrowMoreTransaction(ctx, troveId, amount, maxFee));
-    }
-    /**
-     * 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, troveId, amount) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildRepayDebtTransaction(ctx, troveId, amount));
-    }
-    /**
-     * 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, troveId, newRate, maxFee) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildAdjustInterestRateTransaction(ctx, troveId, newRate, maxFee));
-    }
-    /**
-     * 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) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildClaimCollateralTransaction(ctx));
-    }
-    /**
-     * 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, troveId, manager, maxFee) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildSetBatchManagerTransaction(ctx, troveId, manager, maxFee));
-    }
-    /**
-     * 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, troveId, newRate, maxFee) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildRemoveFromBatchTransaction(ctx, troveId, newRate, maxFee));
-    }
-    /**
-     * 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, troveId, newManager, maxFee) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildSwitchBatchManagerTransaction(ctx, troveId, newManager, maxFee));
-    }
-    /**
-     * 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, troveId, delegate, minRate, maxRate, newRate, maxFee, minChangePeriod) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildSetInterestDelegateTransaction(ctx, troveId, delegate, minRate, maxRate, newRate, maxFee, minChangePeriod));
-    }
-    /**
-     * 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, troveId) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.txService.buildRemoveInterestDelegateTransaction(ctx, troveId));
-    }
-    /**
-     * 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, amount) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.approvalService.buildCollateralApprovalParams(ctx, amount));
-    }
-    /**
-     * 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, spender, amount) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.approvalService.buildDebtApprovalParams(ctx, spender, amount));
-    }
-    /**
-     * 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, amount) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.approvalService.buildGasCompensationApprovalParams(ctx, amount));
-    }
-    /**
-     * 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, owner) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.approvalService.getCollateralAllowance(ctx, owner));
-    }
-    /**
-     * 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, owner, spender) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.approvalService.getDebtAllowance(ctx, owner, spender));
-    }
-    /**
-     * 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, owner) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.approvalService.getGasTokenAllowance(ctx, owner));
-    }
-    /**
-     * 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, troveId) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.getTroveData(ctx, troveId));
-    }
-    /**
-     * 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, owner) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.getUserTroves(ctx, owner));
-    }
-    /**
-     * 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) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.getCollateralPrice(ctx));
-    }
-    /**
-     * 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) {
-        return this.withContext(debtTokenSymbol, (ctx) => ({ ...ctx.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) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.isSystemShutDown(ctx));
-    }
-    /**
-     * 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) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.getBranchStats(ctx));
-    }
-    /**
-     * 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) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.getInterestRateBrackets(ctx));
-    }
-    /**
-     * 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) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.getAverageInterestRate(ctx));
-    }
-    /**
-     * 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, address) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.getBatchManagerInfo(ctx, address));
-    }
-    /**
-     * 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, amount, rate) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.predictOpenTroveUpfrontFee(ctx, amount, rate));
-    }
-    /**
-     * 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, troveId, debtIncrease) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.predictAdjustUpfrontFee(ctx, troveId, debtIncrease));
-    }
-    /**
-     * 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, troveId, newRate) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.predictAdjustInterestRateUpfrontFee(ctx, troveId, newRate));
-    }
-    /**
-     * 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, troveId, batchAddress) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.predictJoinBatchUpfrontFee(ctx, troveId, batchAddress));
-    }
-    /**
-     * 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, owner) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.getOwnedTroveCount(ctx, owner));
-    }
-    /**
-     * 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, owner, opener) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.findNextAvailableOwnerIndex(ctx, owner, opener));
-    }
-    /**
-     * 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, owner) {
-        return this.withContext(debtTokenSymbol, (ctx) => this.readService.getOwnedTroveCount(ctx, owner));
-    }
-    async withContext(debtTokenSymbol, callback) {
-        const ctx = await this.ensureInitialized(debtTokenSymbol);
-        return callback(ctx);
-    }
-    ensureInitialized(debtTokenSymbol) {
-        return this.contextStore.ensureInitialized(debtTokenSymbol);
-    }
-}

package/dist/esm/services/borrow/borrowHelpers.js

@@ -1,3 +0,0 @@
-export { resolveAddressesFromRegistry, readSystemParams, } from './internal/borrowRegistryReader';
-export { buildErc20ApprovalParams as buildCollateralApprovalParams, readErc20Allowance as getCollateralAllowance, } from './internal/borrowErc20';
-export { mapTroveStatus, parseBorrowPosition } from './internal/borrowPositionParser';