@carrot-protocol/clend-rpc 0.0.1-mrgn-fork1-dev-7be6ef2

package/src/math.ts

@@ -0,0 +1,684 @@
+import { BN } from "@coral-xyz/anchor";
+import { ClendAccount, WrappedI80F48 } from "./state";
+import { wrappedI80F48toBigNumber } from "./utils";
+import { Decimal } from "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)
+ */
+export function uiToAmount(uiAmount: number, decimals: number): BN {
+  return new 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)
+ */
+export function amountToUi(amount: BN | number, decimals: number): number {
+  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)
+ */
+export function calculateUtilizationRate(
+  totalSupply: number,
+  totalBorrow: number,
+): number {
+  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
+ */
+export function calculateAssetQuantity(
+  assetShares: number | BN,
+  assetShareValue: WrappedI80F48,
+): number {
+  const shares =
+    typeof assetShares === "number"
+      ? assetShares
+      : Number(assetShares.toString());
+  const shareValue = Number(
+    wrappedI80F48toBigNumber(assetShareValue).toString(),
+  );
+  return shares * shareValue;
+}
+
+/**
+ * Calculate liability quantity from liability shares
+ * @param liabilityShares Liability shares amount
+ * @param liabilityShareValue Value of each liability share
+ * @returns Liability quantity
+ */
+export function calculateLiabilityQuantity(
+  liabilityShares: number | BN,
+  liabilityShareValue: WrappedI80F48,
+): number {
+  const shares =
+    typeof liabilityShares === "number"
+      ? liabilityShares
+      : Number(liabilityShares.toString());
+  const shareValue = Number(
+    wrappedI80F48toBigNumber(liabilityShareValue).toString(),
+  );
+  return shares * shareValue;
+}
+
+/**
+ * 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
+ */
+export function calculateTotalAssetQuantity(
+  totalAssetShares: WrappedI80F48,
+  assetShareValue: WrappedI80F48,
+): number {
+  return calculateAssetQuantity(
+    wrappedI80F48toBigNumber(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
+ */
+export function calculateTotalLiabilityQuantity(
+  totalLiabilityShares: WrappedI80F48,
+  liabilityShareValue: WrappedI80F48,
+): number {
+  return calculateLiabilityQuantity(
+    wrappedI80F48toBigNumber(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
+ */
+export function calculateBankUtilizationRate(
+  totalAssetShares: WrappedI80F48,
+  assetShareValue: WrappedI80F48,
+  totalLiabilityShares: WrappedI80F48,
+  liabilityShareValue: WrappedI80F48,
+): number {
+  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
+ */
+export function calculateBaseInterestRate(
+  utilizationRate: number,
+  optimalUtilizationRate: WrappedI80F48,
+  plateauInterestRate: WrappedI80F48,
+  maxInterestRate: WrappedI80F48,
+): number {
+  const optimalRate = Number(
+    wrappedI80F48toBigNumber(optimalUtilizationRate).toString(),
+  );
+  const plateauRate = Number(
+    wrappedI80F48toBigNumber(plateauInterestRate).toString(),
+  );
+  const maxRate = Number(wrappedI80F48toBigNumber(maxInterestRate).toString());
+
+  if (utilizationRate <= optimalRate) {
+    // Below optimal: linear increase from 0 to plateau rate
+    return (utilizationRate / optimalRate) * plateauRate;
+  } else {
+    // Above optimal: linear increase from plateau to max rate
+    const excessUtilization = utilizationRate - optimalRate;
+    const remainingUtilization = 1 - optimalRate;
+    const excessRate = maxRate - plateauRate;
+
+    return (
+      plateauRate + (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
+ */
+export function calculateSupplyApy(
+  utilizationRate: number,
+  baseInterestRate: number,
+  protocolIrFee: WrappedI80F48,
+  insuranceIrFee: WrappedI80F48,
+): number {
+  // Supply rate = base rate * utilization rate * (1 - protocol fees)
+  const protocolFee = Number(
+    wrappedI80F48toBigNumber(protocolIrFee).toString(),
+  );
+  const insuranceFee = Number(
+    wrappedI80F48toBigNumber(insuranceIrFee).toString(),
+  );
+  const totalFeeRate = protocolFee + insuranceFee;
+
+  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
+ */
+export function calculateBorrowApy(
+  baseInterestRate: number,
+  protocolFixedFeeApr: WrappedI80F48,
+  insuranceFeeFixedApr: WrappedI80F48,
+): number {
+  // Borrow rate = base rate + fixed protocol fee + fixed insurance fee
+  const protocolFee = Number(
+    wrappedI80F48toBigNumber(protocolFixedFeeApr).toString(),
+  );
+  const insuranceFee = Number(
+    wrappedI80F48toBigNumber(insuranceFeeFixedApr).toString(),
+  );
+
+  return baseInterestRate + protocolFee + insuranceFee;
+}
+
+/**
+ * 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
+ */
+export function computeAdjustLeverageAmounts(
+  currentCollateral: number,
+  currentDebt: number,
+  collateralPrice: number,
+  debtPrice: number,
+  currentLeverage: number,
+  targetLeverage: number,
+): {
+  isIncrease: boolean;
+  collateralDelta: number;
+  debtDelta: number;
+} {
+  // Convert everything to USD value
+  const currentPositionValue = currentCollateral * collateralPrice;
+  const currentDebtValue = currentDebt * debtPrice;
+  const currentEquity = currentPositionValue - currentDebtValue;
+
+  // Target position size based on desired leverage
+  const targetPositionValue = currentEquity * targetLeverage;
+  const targetCollateral = targetPositionValue / collateralPrice;
+  const targetDebtValue = targetPositionValue - currentEquity;
+  const targetDebt = targetDebtValue / debtPrice;
+
+  // Calculate changes needed
+  const collateralDelta = targetCollateral - currentCollateral;
+  const debtDelta = targetDebt - currentDebt;
+  const isIncrease = targetLeverage > currentLeverage;
+
+  return {
+    isIncrease,
+    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
+ */
+export function computeMaxLeverage(
+  depositAssetWeight: number,
+  borrowLiabilityWeight: number,
+): { maxLeverage: number; ltv: number } {
+  // 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 liquidation threshold (LT) given deposit and borrow asset maintenance weights.
+ * The LT represents the Loan-to-Value ratio at which liquidation can occur.
+ * @param depositAssetWeightMaint - Maintenance risk weight of deposit asset (0-1).
+ * @param borrowLiabilityWeightMaint - Maintenance risk weight of borrow asset (0-2).
+ * @returns Object containing:
+ * - liquidationThreshold: The LTV ratio at which liquidation occurs. Returns -1 if parameters are invalid.
+ */
+export function computeLiquidationThreshold(
+  depositAssetWeightMaint: number,
+  borrowLiabilityWeightMaint: number,
+): { liquidationThreshold: number } {
+  // Handle edge cases/invalid inputs
+  if (borrowLiabilityWeightMaint <= 0 || depositAssetWeightMaint < 0) {
+    // LT cannot be calculated if liability weight is non-positive
+    // or asset weight is negative.
+    return { liquidationThreshold: -1 };
+  }
+
+  // Liquidation Threshold (LT) is the LTV calculated using maintenance weights.
+  // It represents the point where weighted assets no longer cover weighted liabilities.
+  const liquidationThreshold =
+    depositAssetWeightMaint / borrowLiabilityWeightMaint;
+
+  // LT can theoretically be >= 1 if weights are set permissively,
+  // although this implies liquidation is impossible or happens immediately
+  // depending on initial LTV. We return the calculated value.
+  return {
+    liquidationThreshold,
+  };
+}
+
+/**
+ * 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
+ */
+export function computeLoopingAmounts(
+  principal: number,
+  targetLeverage: number,
+  depositPrice: number,
+  borrowPrice: number,
+  collateralWeight: number,
+  debtWeight: number,
+): {
+  borrowAmountUi: number;
+  totalDepositAmountUi: number;
+} {
+  // 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");
+
+  // With weights, we need to solve for the borrow amount that achieves the target weighted leverage
+  // Given:
+  //   - P = principal (initial deposit)
+  //   - B = borrow amount
+  //   - Tp = total position (P + additional from swap)
+  //   - Dp = deposit price
+  //   - Bp = borrow price
+  //   - Cw = collateral weight
+  //   - Dw = debt weight
+  //   - L = target leverage
+  //
+  // We have:
+  // L = (Tp * Dp * Cw) / ((Tp * Dp * Cw) - (B * Bp * Dw))
+  //
+  // We know that Tp = P + B*(Bp/Dp) (the additional amount from swapping the borrowed amount)
+  //
+  // Substituting:
+  // L = ((P + B*(Bp/Dp)) * Dp * Cw) / (((P + B*(Bp/Dp)) * Dp * Cw) - (B * Bp * Dw))
+  // L = (P*Dp*Cw + B*Bp*Cw) / (P*Dp*Cw + B*Bp*Cw - B*Bp*Dw)
+  // L = (P*Dp*Cw + B*Bp*Cw) / (P*Dp*Cw + B*Bp*(Cw - Dw))
+  //
+  // Solving for B:
+  // L * (P*Dp*Cw + B*Bp*(Cw - Dw)) = P*Dp*Cw + B*Bp*Cw
+  // L*P*Dp*Cw + L*B*Bp*(Cw - Dw) = P*Dp*Cw + B*Bp*Cw
+  // L*B*Bp*(Cw - Dw) = P*Dp*Cw + B*Bp*Cw - L*P*Dp*Cw
+  // L*B*Bp*(Cw - Dw) = P*Dp*Cw*(1 - L) + B*Bp*Cw
+  // L*B*Bp*(Cw - Dw) - B*Bp*Cw = P*Dp*Cw*(1 - L)
+  // B*Bp*(L*(Cw - Dw) - Cw) = P*Dp*Cw*(1 - L)
+  // B = (P*Dp*Cw*(1 - L)) / (Bp*(L*(Cw - Dw) - Cw))
+  // B = (P*Dp*Cw*(L - 1)) / (Bp*(Cw - L*(Cw - Dw)))
+
+  // This is a more general solution that handles weights
+  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
+ */
+export function calculateWeightedValue(
+  amount: number,
+  price: number,
+  weight: number,
+): number {
+  return amount * price * 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
+ */
+export function calculateWeightedLeverage(
+  collateralAmount: number,
+  collateralPrice: number,
+  collateralWeight: number,
+  debtAmount: number,
+  debtPrice: number,
+  debtWeight: number,
+): number {
+  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 required borrow amount to achieve target leverage
+ * @param collateralAmount - Initial collateral amount
+ * @param collateralPrice - Price of collateral
+ * @param collateralWeight - Weight of collateral (0-1)
+ * @param debtPrice - Price of debt
+ * @param debtWeight - Weight of debt (1+)
+ * @param targetLeverage - Desired leverage ratio
+ * @returns Required borrow amount in debt token units
+ */
+export function calculateRequiredBorrowAmount(
+  collateralAmount: number,
+  collateralPrice: number,
+  collateralWeight: number,
+  debtPrice: number,
+  debtWeight: number,
+  targetLeverage: number,
+): number {
+  const weightedCollateralValue = calculateWeightedValue(
+    collateralAmount,
+    collateralPrice,
+    collateralWeight,
+  );
+
+  // Solve for debt value in the leverage equation:
+  // leverage = weightedCollateralValue / (weightedCollateralValue - weightedDebtValue)
+  // => weightedDebtValue = weightedCollateralValue * (1 - 1/leverage)
+  const weightedDebtValue = weightedCollateralValue * (1 - 1 / targetLeverage);
+
+  // Convert weighted debt value to actual debt amount
+  return weightedDebtValue / (debtPrice * debtWeight);
+}
+
+/**
+ * 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
+ */
+export function computeWithdrawLeverageAmounts(
+  currentCollateral: number,
+  currentDebt: number,
+  withdrawAmount: number,
+  collateralPrice: number,
+  debtPrice: number,
+  collateralWeight: number,
+  debtWeight: number,
+): {
+  debtToRepay: number;
+  newCollateral: number;
+  newDebt: number;
+  currentLeverage: number;
+  newLeverage: number;
+} {
+  // 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 values for current position
+  const currentWeightedCollateral =
+    currentCollateral * collateralPrice * collateralWeight;
+  const currentWeightedDebt = currentDebt * debtPrice * debtWeight;
+
+  // 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 {
+    debtToRepay,
+    newCollateral,
+    newDebt,
+    currentLeverage,
+    newLeverage,
+  };
+}
+
+/**
+ * Calculates the health factor of a Marginfi account.
+ * Health Factor = Total Weighted Assets (Maintenance) / Total Weighted Liabilities (Maintenance)
+ * A health factor > 1 indicates solvency. Liquidation occurs when it approaches 1.
+ *
+ * @param assets - An array of the user's deposited assets with their values and maintenance weights.
+ * @param liabilities - An array of the user's borrowed liabilities with their values and maintenance weights.
+ * @returns The health factor. Returns Infinity if there are no liabilities.
+ */
+export function calculateHealthFactor(
+  assets: {
+    assetAmountUi: number;
+    assetPrice: number;
+    maintAssetWeight: number;
+  }[],
+  liabilities: {
+    liabilityAmountUi: number;
+    liabilityPrice: number;
+    maintLiabilityWeight: number;
+  }[],
+): number {
+  let totalWeightedAssets = 0;
+  for (const asset of assets) {
+    totalWeightedAssets +=
+      asset.assetAmountUi * asset.assetPrice * asset.maintAssetWeight;
+  }
+
+  let totalWeightedLiabilities = 0;
+  for (const liability of liabilities) {
+    totalWeightedLiabilities +=
+      liability.liabilityAmountUi *
+      liability.liabilityPrice *
+      liability.maintLiabilityWeight;
+  }
+
+  // if no borrows, 100% health
+  if (totalWeightedLiabilities === 0) {
+    return 1;
+  }
+
+  return totalWeightedAssets / totalWeightedLiabilities;
+}
+
+/**
+ * Calculate USD value from UI amount and price
+ * @param uiAmount Amount in UI format (e.g., 1.5 USDC)
+ * @param price Price of the token in USD
+ * @returns USD value
+ */
+export function calculateUsdValue(uiAmount: number, price: number): number {
+  return uiAmount * price;
+}