@carrot-protocol/clend-rpc 0.1.6 → 0.1.7-fe-math-dev-ce2629b

package/dist/math.js

@@ -1,737 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uiToAmount = uiToAmount;
-exports.amountToUi = amountToUi;
-exports.calculateUtilizationRate = calculateUtilizationRate;
-exports.calculateAssetQuantity = calculateAssetQuantity;
-exports.calculateLiabilityQuantity = calculateLiabilityQuantity;
-exports.calculateTotalAssetQuantity = calculateTotalAssetQuantity;
-exports.calculateTotalLiabilityQuantity = calculateTotalLiabilityQuantity;
-exports.calculateBankUtilizationRate = calculateBankUtilizationRate;
-exports.calculateBaseInterestRate = calculateBaseInterestRate;
-exports.calculateSupplyApy = calculateSupplyApy;
-exports.calculateBorrowApy = calculateBorrowApy;
-exports.computeAdjustLeverageAmounts = computeAdjustLeverageAmounts;
-exports.computeMaxLeverage = computeMaxLeverage;
-exports.computeLoopingAmounts = computeLoopingAmounts;
-exports.calculateWeightedValue = calculateWeightedValue;
-exports.calculateWeightedAmount = calculateWeightedAmount;
-exports.calculateWeightedLeverage = calculateWeightedLeverage;
-exports.computeWithdrawLeverageAmounts = computeWithdrawLeverageAmounts;
-exports.calculateHealthFactorAndLeverage = calculateHealthFactorAndLeverage;
-exports.calculateAccruedInterest = calculateAccruedInterest;
-exports.adjustBorrowForOriginationFee = adjustBorrowForOriginationFee;
-exports.adjustAmountForSlippage = adjustAmountForSlippage;
-exports.calculateLiquidationPrice = calculateLiquidationPrice;
-exports.calculateLtv = calculateLtv;
-exports.calculateLiquidationPriceChangePercentage = calculateLiquidationPriceChangePercentage;
-exports.calculateLiabilityInterest = calculateLiabilityInterest;
-exports.addInterestAccrualBuffer = addInterestAccrualBuffer;
-const anchor_1 = require("@coral-xyz/anchor");
-const decimal_js_1 = require("decimal.js");
-/**
- * Convert a UI number to a token amount BN
- * @param uiAmount Amount in UI format (e.g., 1.5 USDC)
- * @param decimals Token decimals
- * @returns BN representing the token amount in smallest units (lamports)
- */
-function uiToAmount(uiAmount, decimals) {
-    return new anchor_1.BN(Math.floor(uiAmount * 10 ** decimals));
-}
-/**
- * Convert a token amount BN to a UI number
- * @param tokenAmount BN representing the token amount in smallest units (lamports)
- * @param decimals Token decimals
- * @returns Number in UI format (e.g., 1.5 USDC)
- */
-function amountToUi(amount, decimals) {
-    if (typeof amount === "number") {
-        return amount / 10 ** decimals;
-    }
-    return amount.toNumber() / 10 ** decimals;
-}
-/**
- * Calculate the utilization rate of a bank
- * @param totalSupply Total supply of tokens
- * @param totalBorrow Total borrowed tokens
- * @returns Utilization rate as a decimal (0-1)
- */
-function calculateUtilizationRate(totalSupply, totalBorrow) {
-    if (totalSupply === 0 || totalBorrow === 0)
-        return 0;
-    return Math.min(totalBorrow / totalSupply, 1);
-}
-/**
- * Calculate asset quantity from asset shares
- * @param assetShares Asset shares amount
- * @param assetShareValue Value of each asset share
- * @returns Asset quantity
- */
-function calculateAssetQuantity(assetShares, assetShareValue) {
-    const shares = typeof assetShares === "number"
-        ? assetShares
-        : Number(assetShares.toString());
-    return shares * assetShareValue;
-}
-/**
- * Calculate liability quantity from liability shares
- * @param liabilityShares Liability shares amount
- * @param liabilityShareValue Value of each liability share
- * @returns Liability quantity
- */
-function calculateLiabilityQuantity(liabilityShares, liabilityShareValue) {
-    const shares = typeof liabilityShares === "number"
-        ? liabilityShares
-        : Number(liabilityShares.toString());
-    return shares * liabilityShareValue;
-}
-/**
- * Calculate total asset quantity
- * @param totalAssetShares Total asset shares in the bank
- * @param assetShareValue Value of each asset share
- * @returns Total asset quantity
- *
- * Note: You can get these values from a Bank object:
- * - totalAssetShares = bank.totalAssetShares
- * - assetShareValue = bank.assetShareValue
- */
-function calculateTotalAssetQuantity(totalAssetShares, assetShareValue) {
-    return calculateAssetQuantity(totalAssetShares, assetShareValue);
-}
-/**
- * Calculate total liability quantity
- * @param totalLiabilityShares Total liability shares in the bank
- * @param liabilityShareValue Value of each liability share
- * @returns Total liability quantity
- *
- * Note: You can get these values from a Bank object:
- * - totalLiabilityShares = bank.totalLiabilityShares
- * - liabilityShareValue = bank.liabilityShareValue
- */
-function calculateTotalLiabilityQuantity(totalLiabilityShares, liabilityShareValue) {
-    return calculateLiabilityQuantity(totalLiabilityShares, liabilityShareValue);
-}
-/**
- * Calculate the bank's utilization rate
- * @param totalAssetShares Total asset shares in the bank
- * @param assetShareValue Value of each asset share
- * @param totalLiabilityShares Total liability shares in the bank
- * @param liabilityShareValue Value of each liability share
- * @returns Utilization rate as a decimal (0-1)
- *
- * Note: You can get these values from a Bank object:
- * - totalAssetShares = bank.totalAssetShares
- * - assetShareValue = bank.assetShareValue
- * - totalLiabilityShares = bank.totalLiabilityShares
- * - liabilityShareValue = bank.liabilityShareValue
- */
-function calculateBankUtilizationRate(totalAssetShares, assetShareValue, totalLiabilityShares, liabilityShareValue) {
-    const totalAssets = calculateTotalAssetQuantity(totalAssetShares, assetShareValue);
-    const totalLiabilities = calculateTotalLiabilityQuantity(totalLiabilityShares, liabilityShareValue);
-    return calculateUtilizationRate(totalAssets, totalLiabilities);
-}
-/**
- * Calculate the base interest rate based on utilization rate
- * @param utilizationRate Current utilization rate (0-1)
- * @param optimalUtilizationRate Optimal utilization rate target
- * @param plateauInterestRate Interest rate at optimal utilization
- * @param maxInterestRate Maximum interest rate at 100% utilization
- * @returns Base interest rate as a decimal
- *
- * Note: You can get these values from a Bank object:
- * - optimalUtilizationRate = bank.config.interestRateConfig.optimalUtilizationRate
- * - plateauInterestRate = bank.config.interestRateConfig.plateauInterestRate
- * - maxInterestRate = bank.config.interestRateConfig.maxInterestRate
- */
-function calculateBaseInterestRate(utilizationRate, optimalUtilizationRate, plateauInterestRate, maxInterestRate) {
-    if (utilizationRate <= optimalUtilizationRate) {
-        // Below optimal: linear increase from 0 to plateau rate
-        return (utilizationRate / optimalUtilizationRate) * plateauInterestRate;
-    }
-    else {
-        // Above optimal: linear increase from plateau to max rate
-        const excessUtilization = utilizationRate - optimalUtilizationRate;
-        const remainingUtilization = 1 - optimalUtilizationRate;
-        const excessRate = maxInterestRate - plateauInterestRate;
-        return (plateauInterestRate +
-            (excessUtilization / remainingUtilization) * excessRate);
-    }
-}
-/**
- * Calculate the supply APY
- * @param utilizationRate Current utilization rate (0-1)
- * @param baseInterestRate Base interest rate calculated from utilization
- * @param protocolIrFee Protocol interest rate fee
- * @param insuranceIrFee Insurance interest rate fee
- * @returns Supply APY as a decimal (e.g., 0.05 for 5%)
- *
- * Note: You can get these values from a Bank object:
- * - utilizationRate = calculateBankUtilizationRate(...)
- * - baseInterestRate = calculateBaseInterestRate(...)
- * - protocolIrFee = bank.config.interestRateConfig.protocolIrFee
- * - insuranceIrFee = bank.config.interestRateConfig.insuranceIrFee
- */
-function calculateSupplyApy(utilizationRate, baseInterestRate, protocolIrFee, insuranceIrFee) {
-    // Supply rate = base rate * utilization rate * (1 - protocol fees)
-    const totalFeeRate = protocolIrFee + insuranceIrFee;
-    return baseInterestRate * utilizationRate * (1 - totalFeeRate);
-}
-/**
- * Calculate the borrow APY
- * @param baseInterestRate Base interest rate calculated from utilization
- * @param protocolFixedFeeApr Protocol fixed fee APR
- * @param insuranceFeeFixedApr Insurance fixed fee APR
- * @returns Borrow APY as a decimal (e.g., 0.08 for 8%)
- *
- * Note: You can get these values from a Bank object:
- * - baseInterestRate = calculateBaseInterestRate(...)
- * - protocolFixedFeeApr = bank.config.interestRateConfig.protocolFixedFeeApr
- * - insuranceFeeFixedApr = bank.config.interestRateConfig.insuranceFeeFixedApr
- */
-function calculateBorrowApy(baseInterestRate, protocolFixedFeeApr, insuranceFeeFixedApr) {
-    // Borrow rate = base rate + fixed protocol fee + fixed insurance fee
-    const totalFeeRate = protocolFixedFeeApr + insuranceFeeFixedApr;
-    return baseInterestRate + totalFeeRate;
-}
-/**
- * Computes amounts needed to adjust leverage
- * @param currentCollateral - Current collateral amount (e.g., JLP)
- * @param currentDebt - Current debt amount (e.g., USDC)
- * @param collateralPrice - Current collateral price in USD
- * @param debtPrice - Current debt token price in USD
- * @param currentLeverage - Current leverage ratio
- * @param targetLeverage - Desired leverage ratio
- * @param collateralWeight - Weight of collateral for maintenance (0-1)
- * @param debtWeight - Weight of debt for maintenance (1+)
- */
-function computeAdjustLeverageAmounts(currentCollateral, currentDebt, collateralPrice, debtPrice, currentLeverage, targetLeverage, collateralWeight, debtWeight) {
-    // Convert everything to weighted USD value
-    const weightedCollateralValue = calculateWeightedValue(currentCollateral, collateralPrice, collateralWeight);
-    const weightedDebtValue = calculateWeightedValue(currentDebt, debtPrice, debtWeight);
-    const weightedEquity = weightedCollateralValue - weightedDebtValue;
-    if (weightedEquity <= 0) {
-        throw new Error("Weighted equity must be positive");
-    }
-    // Target weighted position size based on desired leverage
-    const targetWeightedPositionValue = weightedEquity * targetLeverage;
-    const targetWeightedDebtValue = targetWeightedPositionValue - weightedEquity;
-    // Convert back to raw token amounts
-    const targetCollateral = targetWeightedPositionValue / (collateralPrice * collateralWeight);
-    const targetDebt = targetWeightedDebtValue / (debtPrice * debtWeight);
-    // Calculate changes needed
-    const collateralDelta = targetCollateral - currentCollateral;
-    const debtDelta = targetDebt - currentDebt;
-    return {
-        isIncrease: targetLeverage > currentLeverage,
-        collateralDelta: Math.abs(collateralDelta),
-        debtDelta: Math.abs(debtDelta),
-    };
-}
-/**
- * Computes the maximum leverage possible given deposit and borrow asset weights
- * @param depositAssetWeight - Initial risk weight of deposit asset (0-1). Higher value = more trusted as collateral
- * @param borrowLiabilityWeight - Initial risk weight of borrow asset (0-2). Higher value = more conservative borrowing
- * @returns Object containing:
- *   - maxLeverage: Maximum leverage possible through recursive borrow-deposit
- *   - ltv: Loan-to-Value ratio, representing what portion of collateral can be borrowed
- */
-function computeMaxLeverage(depositAssetWeight, borrowLiabilityWeight) {
-    // Handle edge cases
-    if (borrowLiabilityWeight <= 0) {
-        return { maxLeverage: -1, ltv: -1 };
-    }
-    // LTV represents what portion of collateral value can be borrowed
-    const ltv = depositAssetWeight / borrowLiabilityWeight;
-    // Maximum leverage possible through recursive borrow-deposit cycles
-    // If LTV > 1, leverage is infinite
-    if (ltv > 1) {
-        return { maxLeverage: -1, ltv };
-    }
-    if (ltv === 1) {
-        return { maxLeverage: -1, ltv };
-    }
-    return {
-        maxLeverage: 1 / (1 - ltv),
-        ltv,
-    };
-}
-/**
- * Computes the borrow and deposit amounts needed to achieve target leverage, accounting for weights
- * @param principal - Initial deposit amount
- * @param targetLeverage - Desired leverage multiplier
- * @param depositPrice - Price of deposit/collateral asset
- * @param borrowPrice - Price of borrow/debt asset
- * @param collateralWeight - Weight of collateral asset (0-1)
- * @param debtWeight - Weight of debt asset (1+)
- * @returns Object containing:
- *   - borrowAmount: Amount to borrow in borrow asset units
- *   - totalDepositAmount: Total final position size in deposit asset units
- */
-function computeLoopingAmounts(principal, targetLeverage, depositPrice, borrowPrice, collateralWeight, debtWeight) {
-    // Validate inputs
-    if (principal <= 0)
-        throw new Error("Principal must be positive");
-    if (targetLeverage <= 1)
-        throw new Error("Target leverage must be greater than 1");
-    if (depositPrice <= 0 || borrowPrice <= 0)
-        throw new Error("Prices must be positive");
-    if (collateralWeight <= 0 || collateralWeight > 1)
-        throw new Error("Collateral weight must be between 0 and 1");
-    if (debtWeight < 1)
-        throw new Error("Debt weight must be greater than or equal to 1");
-    const numerator = principal * depositPrice * collateralWeight * (targetLeverage - 1);
-    const denominator = borrowPrice *
-        (collateralWeight - targetLeverage * (collateralWeight - debtWeight));
-    // If denominator is close to zero or negative, we need to cap the leverage
-    if (denominator <= 0.000001) {
-        throw new Error("Target leverage is too high for the given weights");
-    }
-    const borrowAmount = numerator / denominator;
-    // Calculate total deposit amount
-    const totalDepositAmount = principal + borrowAmount * (borrowPrice / depositPrice);
-    return {
-        borrowAmountUi: borrowAmount,
-        totalDepositAmountUi: totalDepositAmount,
-    };
-}
-/**
- * Calculates the weighted value of an amount based on its price and weight
- * @param amount - Raw amount of the token
- * @param price - Price of the token
- * @param weight - Weight to apply (0-1 for assets, 1+ for liabilities)
- * @returns Weighted value in USD terms
- */
-function calculateWeightedValue(amount, price, weight) {
-    const weightedAmount = calculateWeightedAmount(amount, weight);
-    return weightedAmount * price;
-}
-/**
- * Calculates the weighted value of an amount based on its price and weight
- * @param amount - Raw amount of the token
- * @param price - Price of the token
- * @param weight - Weight to apply (0-1 for assets, 1+ for liabilities)
- * @returns Weighted value in USD terms
- */
-function calculateWeightedAmount(amount, weight) {
-    return amount * weight;
-}
-/**
- * Calculates leverage using weighted values
- * @param collateralAmount - Amount of collateral
- * @param collateralPrice - Price of collateral
- * @param collateralWeight - Weight of collateral (0-1)
- * @param debtAmount - Amount of debt
- * @param debtPrice - Price of debt
- * @param debtWeight - Weight of debt (1+)
- * @returns Leverage ratio
- */
-function calculateWeightedLeverage(collateralAmount, collateralPrice, collateralWeight, debtAmount, debtPrice, debtWeight) {
-    const weightedCollateralValue = calculateWeightedValue(collateralAmount, collateralPrice, collateralWeight);
-    const weightedDebtValue = calculateWeightedValue(debtAmount, debtPrice, debtWeight);
-    const netValue = weightedCollateralValue - weightedDebtValue;
-    if (netValue <= 0) {
-        throw new Error("Net value must be positive");
-    }
-    return weightedCollateralValue / netValue;
-}
-/**
- * Calculates the debt to repay when withdrawing collateral to maintain the same leverage ratio
- * @param currentCollateral - Current collateral amount
- * @param currentDebt - Current debt amount
- * @param withdrawAmount - Amount of collateral to withdraw
- * @param collateralPrice - Price of collateral token
- * @param debtPrice - Price of debt token
- * @param collateralWeight - Weight of collateral (0-1)
- * @param debtWeight - Weight of debt (1+)
- * @returns Object containing the debt to repay and new leverage values
- */
-function computeWithdrawLeverageAmounts(currentCollateral, currentDebt, withdrawAmount, collateralPrice, debtPrice, collateralWeight, debtWeight) {
-    // Calculate current leverage
-    const currentLeverage = calculateWeightedLeverage(currentCollateral, collateralPrice, collateralWeight, currentDebt, debtPrice, debtWeight);
-    // Ensure we don't withdraw more than available
-    if (withdrawAmount > currentCollateral) {
-        throw new Error("Withdrawal amount exceeds available collateral");
-    }
-    // Calculate new collateral amount
-    const newCollateral = currentCollateral - withdrawAmount;
-    // Calculate weighted collateral after withdrawal
-    const newWeightedCollateral = newCollateral * collateralPrice * collateralWeight;
-    // To maintain the same leverage, we need:
-    // currentLeverage = newWeightedCollateral / (newWeightedCollateral - newWeightedDebt)
-    //
-    // Solving for newWeightedDebt:
-    // currentLeverage * (newWeightedCollateral - newWeightedDebt) = newWeightedCollateral
-    // currentLeverage * newWeightedCollateral - currentLeverage * newWeightedDebt = newWeightedCollateral
-    // -currentLeverage * newWeightedDebt = newWeightedCollateral - currentLeverage * newWeightedCollateral
-    // -currentLeverage * newWeightedDebt = newWeightedCollateral * (1 - currentLeverage)
-    const newWeightedDebt = newWeightedCollateral * (1 - 1 / currentLeverage);
-    // Convert weighted debt to actual debt amount
-    const newDebt = newWeightedDebt / (debtPrice * debtWeight);
-    // Calculate debt to repay
-    const debtToRepay = currentDebt - newDebt;
-    // Calculate what the new leverage will be (should be very close to currentLeverage)
-    const newLeverage = calculateWeightedLeverage(newCollateral, collateralPrice, collateralWeight, newDebt, debtPrice, debtWeight);
-    return {
-        debtToRepayUi: debtToRepay,
-        newCollateralUi: newCollateral,
-        newDebtUi: newDebt,
-        currentLeverage,
-        newLeverage,
-    };
-}
-/**
- * Calculates the health factor and leverage of a Clend account using weighted maintenance values.
- *
- * Standard Health Factor = Total Weighted Assets (Maintenance) / Total Weighted Liabilities (Maintenance)
- * Interpretation:
- * - HF > 1: Position is overcollateralized (safe).
- * - HF = 1: Position is at the liquidation threshold.
- * - HF < 1: Position is undercollateralized and liquidatable.
- * - HF = Infinity: Position has no debt (healthiest).
- *
- * Leverage = Total Weighted Assets (Maintenance) / (Total Weighted Assets (Maintenance) - Total Weighted Liabilities (Maintenance))
- *
- * @param weightedAssetValues - An array of the user's weighted asset values (maintenance).
- * @param weightedLiabilityValues - An array of the user's weighted liability values (maintenance).
- * @returns An object containing the healthFactor and leverage.
- */
-function calculateHealthFactorAndLeverage(weightedAssetValues, weightedLiabilityValues) {
-    let totalWeightedAssets = 0;
-    for (const weightedAssetValue of weightedAssetValues) {
-        totalWeightedAssets += weightedAssetValue;
-    }
-    let totalWeightedLiabilities = 0;
-    for (const weightedLiabilityValue of weightedLiabilityValues) {
-        totalWeightedLiabilities += weightedLiabilityValue;
-    }
-    // Calculate health factor using standard convention (Assets / Liabilities)
-    let healthFactor;
-    if (totalWeightedLiabilities === 0) {
-        // Handle division by zero: No liabilities means infinite health
-        healthFactor = Infinity;
-    }
-    else if (totalWeightedAssets === 0) {
-        // Handle edge case where assets are zero but liabilities are not (should imply HF=0)
-        healthFactor = 0;
-    }
-    else {
-        // Standard calculation
-        healthFactor = totalWeightedAssets / totalWeightedLiabilities;
-    }
-    // Calculate leverage (same formula as before, using weighted values)
-    let leverage = 0; // Default to 0 if equity is zero or negative
-    const equity = totalWeightedAssets - totalWeightedLiabilities;
-    if (equity > 0 && totalWeightedAssets > 0) {
-        // Ensure equity is positive and avoid division by zero if assets are zero
-        leverage = totalWeightedAssets / equity;
-    }
-    else if (totalWeightedAssets > 0 && totalWeightedLiabilities === 0) {
-        // If only assets exist, leverage is 1x
-        leverage = 1;
-    }
-    return { healthFactor, leverage };
-}
-/**
- * Calculates the interest that has accrued but not yet been applied to a bank
- * @param lastUpdate The timestamp of the last update
- * @param assetAmountUi The total asset amount in UI format
- * @param liabilityAmountUi The total liability amount in UI format
- * @param utilizationRate The current utilization rate
- * @param interestRateConfig The interest rate configuration
- * @param currentTimestamp Optional current timestamp (in seconds). Defaults to Math.floor(Date.now() / 1000)
- * @returns Object containing:
- *   - assetInterestAccrued: Interest accrued for lenders (in token units)
- *   - liabilityInterestAccrued: Interest accrued for borrowers (in token units)
- *   - insuranceFeesAccrued: Insurance fees accrued (in token units)
- *   - groupFeesAccrued: Group fees accrued (in token units)
- *   - protocolFeesAccrued: Protocol fees accrued (in token units)
- */
-function calculateAccruedInterest(lastUpdate, assetAmountUi, liabilityAmountUi, utilizationRate, interestRateConfig, currentTimestamp) {
-    const timeDelta = currentTimestamp - lastUpdate.toNumber();
-    // If no time has passed, return zero values
-    if (timeDelta <= 0) {
-        return {
-            assetInterestAccrued: 0,
-            liabilityInterestAccrued: 0,
-            insuranceFeesAccrued: 0,
-            groupFeesAccrued: 0,
-            protocolFeesAccrued: 0,
-        };
-    }
-    // Get total assets and liabilities
-    const totalAssets = assetAmountUi;
-    const totalLiabilities = liabilityAmountUi;
-    // If either total assets or liabilities are zero, return zero values
-    if (totalAssets === 0 || totalLiabilities === 0) {
-        return {
-            assetInterestAccrued: 0,
-            liabilityInterestAccrued: 0,
-            insuranceFeesAccrued: 0,
-            groupFeesAccrued: 0,
-            protocolFeesAccrued: 0,
-        };
-    }
-    // Get interest rate configuration
-    const { optimalUtilizationRate, plateauInterestRate, maxInterestRate, insuranceFeeFixedApr, insuranceIrFee, protocolFixedFeeApr, protocolIrFee, } = interestRateConfig;
-    // Calculate base interest rate
-    const baseInterestRate = calculateBaseInterestRate(utilizationRate, optimalUtilizationRate, plateauInterestRate, maxInterestRate);
-    // Calculate lending rate (supply rate)
-    const lendingRate = baseInterestRate * utilizationRate * (1 - (protocolIrFee + insuranceIrFee));
-    // Calculate borrowing rate
-    const borrowingRate = baseInterestRate * (1 + protocolIrFee) +
-        protocolFixedFeeApr +
-        insuranceFeeFixedApr;
-    // Calculate fee rates
-    const insuranceFeeRate = baseInterestRate * insuranceIrFee + insuranceFeeFixedApr;
-    const groupFeeRate = baseInterestRate * protocolIrFee + protocolFixedFeeApr;
-    const protocolFeeRate = baseInterestRate * protocolIrFee + protocolFixedFeeApr;
-    // Calculate interest accrued for the time period
-    const secondsPerYear = 365 * 24 * 60 * 60;
-    const timeDeltaFraction = timeDelta / secondsPerYear;
-    // Calculate asset interest accrued (for lenders)
-    const assetInterestAccrued = totalAssets * lendingRate * timeDeltaFraction;
-    // Calculate liability interest accrued (for borrowers)
-    const liabilityInterestAccrued = totalLiabilities * borrowingRate * timeDeltaFraction;
-    // Calculate fees accrued
-    const insuranceFeesAccrued = totalLiabilities * insuranceFeeRate * timeDeltaFraction;
-    const groupFeesAccrued = totalLiabilities * groupFeeRate * timeDeltaFraction;
-    const protocolFeesAccrued = totalLiabilities * protocolFeeRate * timeDeltaFraction;
-    return {
-        assetInterestAccrued,
-        liabilityInterestAccrued,
-        insuranceFeesAccrued,
-        groupFeesAccrued,
-        protocolFeesAccrued,
-    };
-}
-/**
- * Adjusts an ideal borrow amount downwards solely to compensate for the
- * protocol's origination fee. This calculates the principal amount to borrow
- * such that after the fee is added, the liability matches the ideal amount.
- *
- * @param idealBorrowAmount - The target borrow amount before considering the fee (native units, BN).
- * @param originationFeeRate - The protocol origination fee rate (e.g., 0.001 for 0.1%).
- * @returns Adjusted borrow amount (native units, BN), slightly less than or equal to ideal.
- */
-function adjustBorrowForOriginationFee(idealBorrowAmount, originationFeeRate) {
-    // Ensure the fee rate is valid
-    if (originationFeeRate < 0) {
-        return idealBorrowAmount;
-    }
-    const feeRateDecimal = new decimal_js_1.Decimal(originationFeeRate);
-    // If there's no fee, no adjustment is needed
-    if (feeRateDecimal.isZero()) {
-        return idealBorrowAmount;
-    }
-    // Formula: B_actual ≈ B_ideal / (1 + FeeRate)
-    // We borrow slightly less, anticipating the fee being added to the liability.
-    const denominator = new decimal_js_1.Decimal(1).add(feeRateDecimal);
-    // Safety check for the denominator (should not happen with non-negative fee)
-    if (denominator.isZero() ||
-        denominator.isNaN() ||
-        !denominator.isFinite() ||
-        denominator.isNegative()) {
-        return idealBorrowAmount;
-    }
-    const idealBorrowDecimal = new decimal_js_1.Decimal(idealBorrowAmount.toString());
-    const adjustedBorrowDecimal = idealBorrowDecimal.div(denominator);
-    // Round down when reducing the borrow amount due to the fee cost.
-    const adjustedBorrowAmount = new anchor_1.BN(adjustedBorrowDecimal.floor().toFixed());
-    // Ensure we don't adjust below zero
-    return anchor_1.BN.max(adjustedBorrowAmount, new anchor_1.BN(0));
-}
-/**
- * Adjusts an amount upwards to compensate for potential swap slippage,
- * assuming worst-case based on slippageBps.
- *
- * @param amountToAdjust - The amount to adjust (native units, BN), typically after cost adjustments.
- * @param slippageBps - The maximum slippage tolerance in basis points (e.g., 100 for 1%).
- * @returns Adjusted amount (native units, BN), slightly more than the input amount. Returns input amount if slippageBps is zero or invalid.
- */
-function adjustAmountForSlippage(amountToAdjust, slippageBps) {
-    if (slippageBps <= 0) {
-        return amountToAdjust; // No adjustment if no slippage tolerance
-    }
-    const S = new decimal_js_1.Decimal(slippageBps).div(10000); // Slippage factor S as decimal
-    // Ensure S is less than 1 (100% slippage)
-    if (S.gte(1)) {
-        return amountToAdjust;
-    }
-    // Formula: B_actual ≈ B_ideal / (1 - S)
-    // We borrow slightly more, anticipating the swap output will be worth less by factor S.
-    const denominator = new decimal_js_1.Decimal(1).sub(S);
-    // Should not happen with S < 1, but safety check
-    if (denominator.isZero() ||
-        denominator.isNaN() ||
-        !denominator.isFinite() ||
-        denominator.isNegative()) {
-        return amountToAdjust;
-    }
-    const amountToAdjustDecimal = new decimal_js_1.Decimal(amountToAdjust.toString());
-    const adjustedAmountDecimal = amountToAdjustDecimal.div(denominator);
-    // Round up when increasing amount due to needing more input for slippage
-    const adjustedAmount = new anchor_1.BN(adjustedAmountDecimal.ceil().toFixed());
-    return adjustedAmount;
-}
-/**
- * Calculates the estimated liquidation price for a collateral asset.
- *
- * Liquidation is possible when the risk-adjusted value of debt meets or exceeds
- * the risk-adjusted value of the collateral, based on maintenance requirements.
- *
- * Formula:
- * CollateralLiquidationPrice = (DebtAmount * DebtPrice * DebtMaintenanceLiabilityWeight) / (CollateralAmount * CollateralMaintenanceAssetWeight)
- *
- * @param collateralAmount The amount of the collateral asset deposited (e.g., number of JLP tokens).
- * @param collateralMaintenanceAssetWeight The maintenance asset weight for the collateral asset (e.g., 0.85 for 85%). Found in Marginfi protocol config/UI.
- * @param debtAmount The amount of the debt asset borrowed (e.g., number of USDC tokens).
- * @param debtMaintenanceLiabilityWeight The maintenance liability weight for the debt asset (e.g., 1.1 for 110%). Found in Marginfi protocol config/UI.
- * @param debtPrice The current price of the debt asset.
- * @returns The estimated price of the collateral asset at which liquidation may occur, or Infinity if collateral amount/weight is zero.
- */
-function calculateLiquidationPrice(collateralAmountUi, collateralMaintenanceAssetWeight, debtAmountUi, debtMaintenanceLiabilityWeight, debtPrice) {
-    // Ensure inputs are valid numbers
-    if (isNaN(collateralAmountUi) ||
-        isNaN(collateralMaintenanceAssetWeight) ||
-        isNaN(debtAmountUi) ||
-        isNaN(debtMaintenanceLiabilityWeight) ||
-        isNaN(debtPrice)) {
-        throw new Error("All input parameters must be valid numbers.");
-    }
-    // if 0 values just return 0
-    if (collateralAmountUi === 0 ||
-        debtAmountUi === 0 ||
-        debtPrice === 0 ||
-        collateralMaintenanceAssetWeight === 0 ||
-        debtMaintenanceLiabilityWeight === 0) {
-        return 0;
-    }
-    // Calculate the weighted value of the collateral side (denominator)
-    const weightedCollateralValueFactor = collateralAmountUi * collateralMaintenanceAssetWeight;
-    // Avoid division by zero if collateral amount or weight is zero
-    if (weightedCollateralValueFactor <= 0) {
-        throw new Error(`collateral amount is 0 or less`);
-    }
-    // Calculate the weighted value of the debt side (numerator)
-    const weightedDebtValue = debtAmountUi * debtPrice * debtMaintenanceLiabilityWeight;
-    // Calculate the liquidation price
-    const liquidationPrice = weightedDebtValue / weightedCollateralValueFactor;
-    return liquidationPrice;
-}
-/**
- * Calculates the Loan-to-Value (LTV) ratio.
- * LTV = Total Value of Liabilities / Total Value of Assets
- *
- * Note: The input values can be either weighted (initial or maintenance) or unweighted USD values,
- * as long as the same type of value is used consistently for both assets and liabilities.
- * The interpretation of the LTV depends on the type of values used.
- *
- * @param {number[]} assetValues - An array of the user's asset values (e.g., USD value, weighted or unweighted).
- * @param {number[]} liabilityValues - An array of the user's liability values (e.g., USD value, weighted or unweighted).
- * @returns {number} The LTV ratio. Returns 0 if there are no liabilities. Returns `NaN` if total asset value is zero or negative.
- */
-function calculateLtv(assetValues, liabilityValues) {
-    let totalAssetValue = 0;
-    for (const value of assetValues) {
-        totalAssetValue += value;
-    }
-    let totalLiabilityValue = 0;
-    for (const value of liabilityValues) {
-        totalLiabilityValue += value;
-    }
-    // If there are no assets (or negative total value), LTV is undefined.
-    if (totalAssetValue <= 0) {
-        // Return NaN if liabilities exist but assets don't, or if assets have zero/negative value.
-        // Return 0 if both are zero (as technically liabilities are 0).
-        return totalLiabilityValue === 0 ? 0 : NaN;
-    }
-    // If there are no liabilities, LTV is 0.
-    if (totalLiabilityValue === 0) {
-        return 0;
-    }
-    // Standard LTV calculation
-    const ltv = totalLiabilityValue / totalAssetValue;
-    return ltv;
-}
-/**
- * Calculates the percentage change required for the current price to reach the liquidation price.
- *
- * @param currentPrice The current price of the asset.
- * @param liquidationPrice The price at which the asset would be liquidated.
- * @returns The percentage change needed to reach the liquidation price (e.g., -10.5 for a 10.5% drop). Returns Infinity if currentPrice is 0.
- */
-function calculateLiquidationPriceChangePercentage(currentPrice, liquidationPrice) {
-    if (currentPrice <= 0) {
-        return 0;
-    }
-    const priceChange = liquidationPrice - currentPrice;
-    const percentageChange = (priceChange / currentPrice) * 100;
-    return percentageChange;
-}
-/**
- * Calculates the current liability interest for a specific liability position,
- * accounting for interest accrued since the bank's last update.
- *
- * @param userLiabilitySharesBN - The user's liability shares for the debt asset (native units, BN).
- * @param bankLiabilityShareValue - The bank's liability share value as of last update (number).
- * @param bankBorrowApy - The current estimated borrow APY of the debt asset (e.g., 0.025 for 2.5%).
- * @param bankLastUpdateSeconds - The Unix timestamp (seconds) when the bank's interest was last updated on-chain.
- * @param currentTimeSeconds - The current Unix timestamp (seconds).
- * @returns The estimated current debt amount for the user (native units, BN).
- */
-function calculateLiabilityInterest(userLiabilityShares, bankLiabilityShareValue, bankBorrowApy, bankLastUpdateSeconds, currentTimeSeconds) {
-    // If user has no liability shares for this bank, debt is zero.
-    if (userLiabilityShares <= 0) {
-        return new anchor_1.BN(0);
-    }
-    // Calculate time delta
-    const secondsSinceLastUpdate = currentTimeSeconds - bankLastUpdateSeconds;
-    let currentLiabilityShareValue;
-    // hardcode for now
-    const secondsPerYear = 31536000;
-    // Calculate the current share value if time has passed and interest rate is positive
-    if (secondsSinceLastUpdate > 0) {
-        const interestRatePerSecond = bankBorrowApy / secondsPerYear;
-        const growthFactor = interestRatePerSecond * secondsSinceLastUpdate + 1;
-        currentLiabilityShareValue = bankLiabilityShareValue * growthFactor;
-    }
-    else {
-        // Otherwise, use the share value as of the last update
-        currentLiabilityShareValue = bankLiabilityShareValue;
-    }
-    // Calculate estimated debt = user_shares * current_share_value
-    const debt = new anchor_1.BN(userLiabilityShares * currentLiabilityShareValue);
-    return debt;
-}
-/**
- * Calculates the final debt repayment target amount by adding buffers
- * for future interest accrual and minor discrepancies to an estimated current debt.
- * this is used to calculate the final debt to repay amount taking into account tx execution time from when its calculated
- *
- * @param currentDebt - The current debt amount including interest accrued up to the present moment
- * @param borrowApy - The current estimated borrow APY of the debt asset (e.g., 0.025 for 2.5%).
- * @param futureInterestBufferSec - The estimated number of seconds of future interest to buffer for transaction execution time. As in, if it takes
- * 10 seconds to execute the tx from when this is called, we will add 10 seconds of interest to the debt
- * @returns The final debt repayment target amount (native units, BN).
- */
-function addInterestAccrualBuffer(currentDebt, borrowApy, futureInterestBufferSec) {
-    // A small fixed buffer amount (in lamports/native units) to add for minor rounding or timing variations (default: 100).
-    const fixedBufferLamports = new anchor_1.BN(1000);
-    const SECONDS_PER_YEAR = 31536000;
-    let finalDebtToRepay = currentDebt;
-    // Add buffer for future interest during execution, if applicable
-    if (borrowApy > 0 && futureInterestBufferSec > 0 && !currentDebt.isZero()) {
-        const interestRatePerSecond = new decimal_js_1.Decimal(borrowApy).div(SECONDS_PER_YEAR);
-        // Calculate buffer based on the estimated current debt amount
-        const futureInterestDecimal = new decimal_js_1.Decimal(currentDebt.toString())
-            .mul(interestRatePerSecond)
-            .mul(futureInterestBufferSec);
-        // Round UP the future interest amount to be conservative
-        const futureInterestBN = new anchor_1.BN(futureInterestDecimal.ceil().toFixed());
-        finalDebtToRepay = finalDebtToRepay.add(futureInterestBN);
-    }
-    // Add the small fixed buffer
-    finalDebtToRepay = finalDebtToRepay.add(fixedBufferLamports);
-    return finalDebtToRepay;
-}
-//# sourceMappingURL=math.js.map