@mento-protocol/mento-sdk 3.2.2-beta1 → 3.2.3

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';

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

@@ -1,127 +0,0 @@
-import { MAX_LTV_ALLOWED_RATIO, LTV_RISK_MEDIUM, LTV_RISK_HIGH, REDEMPTION_RISK_MEDIUM, REDEMPTION_RISK_LOW, } from '../../core/constants';
-const DECIMAL_PRECISION = 10n ** 18n;
-const THOUSAND = 1000n;
-const NORMALIZED_MAX_LTV = DECIMAL_PRECISION;
-const DEBT_SUGGESTION_RATIOS = [300n, 600n, 800n];
-export function getLtv(collateral, debt, collPrice) {
-    const collateralUsd = (collateral * collPrice) / DECIMAL_PRECISION;
-    if (collateralUsd === 0n)
-        return null;
-    return (debt * DECIMAL_PRECISION) / collateralUsd;
-}
-export function getLiquidationPrice(collateral, debt, mcr) {
-    if (collateral <= 0n || debt <= 0n)
-        return null;
-    if (mcr <= DECIMAL_PRECISION)
-        return null;
-    // liquidationPrice = (debt * mcr) / collateral
-    return (debt * mcr) / collateral;
-}
-export function getLiquidationRisk(ltv, maxLtv) {
-    if (maxLtv <= 0n)
-        return 'low';
-    // Compare using cross-multiplication to avoid floor-division drift.
-    if (ltv * THOUSAND > maxLtv * LTV_RISK_HIGH)
-        return 'high';
-    if (ltv * THOUSAND > maxLtv * LTV_RISK_MEDIUM)
-        return 'medium';
-    return 'low';
-}
-export function getRedemptionRisk(debtInFront, totalDebt) {
-    if (totalDebt === 0n)
-        return null;
-    // Compare using cross-multiplication to avoid floor-division drift.
-    if (debtInFront * THOUSAND > totalDebt * REDEMPTION_RISK_LOW)
-        return 'low';
-    if (debtInFront * THOUSAND > totalDebt * REDEMPTION_RISK_MEDIUM)
-        return 'medium';
-    return 'high';
-}
-export function calculateMaxDebt(collateralUsd, maxLtv) {
-    return (collateralUsd * maxLtv) / DECIMAL_PRECISION;
-}
-export function calculateDebtSuggestions(maxDebt, minDebt) {
-    if (maxDebt <= 0n)
-        return [];
-    const suggestions = [];
-    for (let i = 0; i < DEBT_SUGGESTION_RATIOS.length; i++) {
-        let amount = (maxDebt * DEBT_SUGGESTION_RATIOS[i]) / THOUSAND;
-        // Mirror frontend behavior:
-        // - First suggestion is clamped up to minDebt.
-        // - Later suggestions below minDebt are omitted.
-        if (amount < minDebt) {
-            if (i === 0) {
-                amount = minDebt;
-            }
-            else {
-                continue;
-            }
-        }
-        // ltv relative to maxLtv (normalized to 1e18 where 1e18 === maxLtv)
-        const ltv = (amount * DECIMAL_PRECISION) / maxDebt;
-        // Hide suggestions that exceed maxLtv.
-        if (ltv > NORMALIZED_MAX_LTV) {
-            continue;
-        }
-        suggestions.push({
-            amount,
-            ltv,
-            risk: getLiquidationRisk(ltv, NORMALIZED_MAX_LTV),
-        });
-    }
-    return suggestions;
-}
-/**
- * Computes collateralization metrics from the supplied collateral, debt, price, and MCR.
- *
- * This helper is lifecycle-agnostic: it does not inspect trove status. For example, a zombie
- * trove with `debt === 0` may still hold collateral on-chain, but this function only reports
- * the math implied by the inputs. Combine its output with `BorrowPosition.status` when building
- * UI for open, zombie, closed, or liquidated troves.
- */
-export function getLoanDetails(collateral, debt, interestRate, collPrice, mcr) {
-    // maxLtv = 1 / MCR (MCR is e.g. 1.1e18 meaning 110%)
-    const maxLtv = (DECIMAL_PRECISION * DECIMAL_PRECISION) / mcr;
-    // maxLtvAllowed = maxLtv * MAX_LTV_ALLOWED_RATIO / 1000
-    const maxLtvAllowed = (maxLtv * MAX_LTV_ALLOWED_RATIO) / THOUSAND;
-    const collateralUsd = collateral !== null && collPrice !== null
-        ? (collateral * collPrice) / DECIMAL_PRECISION
-        : null;
-    const ltv = debt !== null && collateralUsd !== null && collateralUsd > 0n
-        ? (debt * DECIMAL_PRECISION) / collateralUsd
-        : collateral !== null && collateral < 0n
-            ? DECIMAL_PRECISION
-            : null;
-    const status = ltv === null
-        ? null
-        : collateral !== null && (collateral < 0n || ltv > DECIMAL_PRECISION)
-            ? 'underwater'
-            : ltv > maxLtv
-                ? 'liquidatable'
-                : ltv > maxLtvAllowed
-                    ? 'at-risk'
-                    : 'healthy';
-    const maxDebt = collateralUsd !== null ? calculateMaxDebt(collateralUsd, maxLtv) : null;
-    const maxDebtAllowed = collateralUsd !== null && collateralUsd > 0n
-        ? (collateralUsd * maxLtvAllowed) / DECIMAL_PRECISION
-        : null;
-    const liquidationRisk = ltv !== null ? getLiquidationRisk(ltv, maxLtv) : null;
-    const liquidationPrice = collateral !== null && debt !== null && collateral > 0n
-        ? getLiquidationPrice(collateral, debt, mcr)
-        : null;
-    return {
-        collateral,
-        collateralUsd,
-        collPrice,
-        debt,
-        interestRate,
-        ltv,
-        maxLtv,
-        maxLtvAllowed,
-        liquidationPrice,
-        liquidationRisk,
-        maxDebt,
-        maxDebtAllowed,
-        status,
-    };
-}

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

@@ -1,3 +0,0 @@
-export * from './BorrowService';
-export * from './borrowHelpers';
-export * from './borrowMath';

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

@@ -1,48 +0,0 @@
-import { encodeFunctionData } from 'viem';
-import { ERC20_ABI } from '../../../core/abis';
-import { buildErc20ApprovalParams, readErc20Allowance } from './borrowErc20';
-import { requireAddress, requireNonNegativeBigInt } from './borrowValidation';
-const ZERO_VALUE = '0';
-export class BorrowApprovalService {
-    constructor(publicClient) {
-        this.publicClient = publicClient;
-    }
-    buildCollateralApprovalParams(ctx, amount) {
-        const approvalAmount = requireNonNegativeBigInt(amount, 'amount');
-        return buildErc20ApprovalParams(ctx.addresses.collToken, ctx.addresses.borrowerOperations, approvalAmount);
-    }
-    buildDebtApprovalParams(ctx, spender, amount) {
-        const spenderAddress = requireAddress(spender, 'spender');
-        const approvalAmount = requireNonNegativeBigInt(amount, 'amount');
-        const data = encodeFunctionData({
-            abi: ERC20_ABI,
-            functionName: 'approve',
-            args: [spenderAddress, approvalAmount],
-        });
-        return { to: ctx.addresses.debtToken, data, value: ZERO_VALUE };
-    }
-    buildGasCompensationApprovalParams(ctx, amount) {
-        const approvalAmount = amount === undefined
-            ? ctx.systemParams.ethGasCompensation
-            : requireNonNegativeBigInt(amount, 'amount');
-        return buildErc20ApprovalParams(ctx.addresses.gasToken, ctx.addresses.borrowerOperations, approvalAmount);
-    }
-    async getCollateralAllowance(ctx, owner) {
-        const ownerAddress = requireAddress(owner, 'owner');
-        return readErc20Allowance(this.publicClient, ctx.addresses.collToken, ownerAddress, ctx.addresses.borrowerOperations);
-    }
-    async getDebtAllowance(ctx, owner, spender) {
-        const ownerAddress = requireAddress(owner, 'owner');
-        const spenderAddress = requireAddress(spender, 'spender');
-        return (await this.publicClient.readContract({
-            address: ctx.addresses.debtToken,
-            abi: ERC20_ABI,
-            functionName: 'allowance',
-            args: [ownerAddress, spenderAddress],
-        }));
-    }
-    async getGasTokenAllowance(ctx, owner) {
-        const ownerAddress = requireAddress(owner, 'owner');
-        return readErc20Allowance(this.publicClient, ctx.addresses.gasToken, ownerAddress, ctx.addresses.borrowerOperations);
-    }
-}

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

@@ -1,35 +0,0 @@
-import { getBorrowRegistry } from '../../../core/constants';
-import { readSystemParams, resolveAddressesFromRegistry } from './borrowRegistryReader';
-import { requireDebtTokenSymbol } from './borrowValidation';
-export class BorrowContextStore {
-    constructor(publicClient, chainId) {
-        this.publicClient = publicClient;
-        this.chainId = chainId;
-        this.deployments = new Map();
-        this.initializing = new Map();
-    }
-    async ensureInitialized(debtTokenSymbol) {
-        const symbol = requireDebtTokenSymbol(debtTokenSymbol);
-        const cached = this.deployments.get(symbol);
-        if (cached)
-            return cached;
-        const inFlight = this.initializing.get(symbol);
-        if (inFlight)
-            return inFlight;
-        const initPromise = (async () => {
-            const registryAddress = getBorrowRegistry(this.chainId, symbol);
-            const addresses = await resolveAddressesFromRegistry(this.publicClient, registryAddress);
-            const systemParams = await readSystemParams(this.publicClient, addresses.borrowerOperations);
-            const ctx = { addresses, systemParams };
-            this.deployments.set(symbol, ctx);
-            return ctx;
-        })();
-        this.initializing.set(symbol, initPromise);
-        try {
-            return await initPromise;
-        }
-        finally {
-            this.initializing.delete(symbol);
-        }
-    }
-}