@mento-protocol/mento-sdk 3.2.3 → 3.2.5

package/dist/services/borrow/BorrowService.js

@@ -0,0 +1,460 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BorrowService = void 0;
+const borrowApprovalService_1 = require("./internal/borrowApprovalService");
+const borrowContextStore_1 = require("./internal/borrowContextStore");
+const borrowReadService_1 = require("./internal/borrowReadService");
+const borrowTransactionService_1 = require("./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)
+ * ```
+ */
+class BorrowService {
+    constructor(publicClient, chainId) {
+        this.contextStore = new borrowContextStore_1.BorrowContextStore(publicClient, chainId);
+        this.txService = new borrowTransactionService_1.BorrowTransactionService(publicClient);
+        this.approvalService = new borrowApprovalService_1.BorrowApprovalService(publicClient);
+        this.readService = new borrowReadService_1.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);
+    }
+}
+exports.BorrowService = BorrowService;
+//# sourceMappingURL=BorrowService.js.map

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

@@ -0,0 +1,4 @@
+export { resolveAddressesFromRegistry, readSystemParams, } from './internal/borrowRegistryReader';
+export { buildErc20ApprovalParams as buildCollateralApprovalParams, readErc20Allowance as getCollateralAllowance, } from './internal/borrowErc20';
+export { mapTroveStatus, parseBorrowPosition } from './internal/borrowPositionParser';
+//# sourceMappingURL=borrowHelpers.d.ts.map

package/dist/services/borrow/borrowHelpers.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBorrowPosition = exports.mapTroveStatus = exports.getCollateralAllowance = exports.buildCollateralApprovalParams = exports.readSystemParams = exports.resolveAddressesFromRegistry = void 0;
+var borrowRegistryReader_1 = require("./internal/borrowRegistryReader");
+Object.defineProperty(exports, "resolveAddressesFromRegistry", { enumerable: true, get: function () { return borrowRegistryReader_1.resolveAddressesFromRegistry; } });
+Object.defineProperty(exports, "readSystemParams", { enumerable: true, get: function () { return borrowRegistryReader_1.readSystemParams; } });
+var borrowErc20_1 = require("./internal/borrowErc20");
+Object.defineProperty(exports, "buildCollateralApprovalParams", { enumerable: true, get: function () { return borrowErc20_1.buildErc20ApprovalParams; } });
+Object.defineProperty(exports, "getCollateralAllowance", { enumerable: true, get: function () { return borrowErc20_1.readErc20Allowance; } });
+var borrowPositionParser_1 = require("./internal/borrowPositionParser");
+Object.defineProperty(exports, "mapTroveStatus", { enumerable: true, get: function () { return borrowPositionParser_1.mapTroveStatus; } });
+Object.defineProperty(exports, "parseBorrowPosition", { enumerable: true, get: function () { return borrowPositionParser_1.parseBorrowPosition; } });
+//# sourceMappingURL=borrowHelpers.js.map

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

@@ -0,0 +1,21 @@
+import type { LoanDetails, RiskLevel } from '../../core/types';
+export declare function getLtv(collateral: bigint, debt: bigint, collPrice: bigint): bigint | null;
+export declare function getLiquidationPrice(collateral: bigint, debt: bigint, mcr: bigint): bigint | null;
+export declare function getLiquidationRisk(ltv: bigint, maxLtv: bigint): RiskLevel;
+export declare function getRedemptionRisk(debtInFront: bigint, totalDebt: bigint): RiskLevel | null;
+export declare function calculateMaxDebt(collateralUsd: bigint, maxLtv: bigint): bigint;
+export declare function calculateDebtSuggestions(maxDebt: bigint, minDebt: bigint): {
+    amount: bigint;
+    ltv: bigint;
+    risk: RiskLevel;
+}[];
+/**
+ * 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 declare function getLoanDetails(collateral: bigint | null, debt: bigint | null, interestRate: bigint | null, collPrice: bigint | null, mcr: bigint): LoanDetails;
+//# sourceMappingURL=borrowMath.d.ts.map

package/dist/services/borrow/borrowMath.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLtv = getLtv;
+exports.getLiquidationPrice = getLiquidationPrice;
+exports.getLiquidationRisk = getLiquidationRisk;
+exports.getRedemptionRisk = getRedemptionRisk;
+exports.calculateMaxDebt = calculateMaxDebt;
+exports.calculateDebtSuggestions = calculateDebtSuggestions;
+exports.getLoanDetails = getLoanDetails;
+const constants_1 = require("../../core/constants");
+const DECIMAL_PRECISION = 10n ** 18n;
+const THOUSAND = 1000n;
+const NORMALIZED_MAX_LTV = DECIMAL_PRECISION;
+const DEBT_SUGGESTION_RATIOS = [300n, 600n, 800n];
+function getLtv(collateral, debt, collPrice) {
+    const collateralUsd = (collateral * collPrice) / DECIMAL_PRECISION;
+    if (collateralUsd === 0n)
+        return null;
+    return (debt * DECIMAL_PRECISION) / collateralUsd;
+}
+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;
+}
+function getLiquidationRisk(ltv, maxLtv) {
+    if (maxLtv <= 0n)
+        return 'low';
+    // Compare using cross-multiplication to avoid floor-division drift.
+    if (ltv * THOUSAND > maxLtv * constants_1.LTV_RISK_HIGH)
+        return 'high';
+    if (ltv * THOUSAND > maxLtv * constants_1.LTV_RISK_MEDIUM)
+        return 'medium';
+    return 'low';
+}
+function getRedemptionRisk(debtInFront, totalDebt) {
+    if (totalDebt === 0n)
+        return null;
+    // Compare using cross-multiplication to avoid floor-division drift.
+    if (debtInFront * THOUSAND > totalDebt * constants_1.REDEMPTION_RISK_LOW)
+        return 'low';
+    if (debtInFront * THOUSAND > totalDebt * constants_1.REDEMPTION_RISK_MEDIUM)
+        return 'medium';
+    return 'high';
+}
+function calculateMaxDebt(collateralUsd, maxLtv) {
+    return (collateralUsd * maxLtv) / DECIMAL_PRECISION;
+}
+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.
+ */
+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 * constants_1.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,
+    };
+}
+//# sourceMappingURL=borrowMath.js.map

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

@@ -0,0 +1,4 @@
+export * from './BorrowService';
+export * from './borrowHelpers';
+export * from './borrowMath';
+//# sourceMappingURL=index.d.ts.map

package/dist/{cjs/interfaces → services/borrow}/index.js

@@ -14,7 +14,7 @@ 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 });
-__exportStar(require("./tradingLimit"), exports);
-__exportStar(require("./tradingLimitsConfig"), exports);
-__exportStar(require("./tradingLimitsState"), exports);
-__exportStar(require("./IChainClient"), exports);
+__exportStar(require("./BorrowService"), exports);
+__exportStar(require("./borrowHelpers"), exports);
+__exportStar(require("./borrowMath"), exports);
+//# sourceMappingURL=index.js.map

package/dist/services/borrow/internal/borrowApprovalService.d.ts

@@ -0,0 +1,14 @@
+import { PublicClient } from 'viem';
+import { CallParams } from '../../../core/types';
+import { DeploymentContext } from './borrowTypes';
+export declare class BorrowApprovalService {
+    private publicClient;
+    constructor(publicClient: PublicClient);
+    buildCollateralApprovalParams(ctx: DeploymentContext, amount: bigint): CallParams;
+    buildDebtApprovalParams(ctx: DeploymentContext, spender: string, amount: bigint): CallParams;
+    buildGasCompensationApprovalParams(ctx: DeploymentContext, amount?: bigint): CallParams;
+    getCollateralAllowance(ctx: DeploymentContext, owner: string): Promise<bigint>;
+    getDebtAllowance(ctx: DeploymentContext, owner: string, spender: string): Promise<bigint>;
+    getGasTokenAllowance(ctx: DeploymentContext, owner: string): Promise<bigint>;
+}
+//# sourceMappingURL=borrowApprovalService.d.ts.map