@indigo-labs/indigo-sdk 0.3.9 → 0.3.10

package/src/contracts/rob-leverage/helpers.ts

@@ -51,374 +51,382 @@
  *      `b’’ = d(L - 1)`
  */
 
-// import { UTxO } from '@lucid-evolution/lucid';
-// import {
-//   OCD_DECIMAL_UNIT,
-//   ocdMul,
-//   OnChainDecimal,
-// } from '../../types/on-chain-decimal';
-// import { calculateFeeFromPercentage } from '../../utils/indigo-helpers';
-// import { bigintMax, bigintMin, fromDecimal } from '../../utils/bigint-utils';
-// import { array as A, function as F } from 'fp-ts';
-// import { Decimal } from 'decimal.js';
-// import { RobParamsSP } from '../../types/system-params';
-// import {
-//   calculateTotalAdaForRedemption,
-//   lrpRedeemableLovelacesInclReimb,
-// } from '../lrp/helpers';
-// import { RobDatum } from '../lrp/types-new';
-
-// /**
-//  * How many LRP redemptions can we fit into a TX with CDP open.
-//  */
-// export const MAX_REDEMPTIONS_WITH_CDP_OPEN = 4;
-
-// type LRPRedemptionDetails = {
-//   utxo: UTxO;
-//   /**
-//    * This is including the reimbursement fee.
-//    **/
-//   redemptionLovelacesAmtInclReimbursement: bigint;
-//   iassetsForRedemptionAmt: bigint;
-//   reimbursementLovelacesAmt: bigint;
-// };
-
-// type ApproximateLeverageRedemptionsResult = {
-//   leverage: number;
-//   collateralRatio: OnChainDecimal;
-//   lovelacesForRedemptionWithReimbursement: bigint;
-// };
-// /**
-//  * We assume exact precision. However, actual redemptions include rounding and
-//  * the rounding behaviour changes based on the number of redemptions.
-//  * This may slightly tweak the numbers and the result can be different.
-//  *
-//  * The math is described at the top of this code file.
-//  */
-// export function approximateLeverageRedemptions(
-//   baseCollateral: bigint,
-//   targetLeverage: number,
-//   redemptionReimbursementPercentage: OnChainDecimal,
-//   debtMintingFeePercentage: OnChainDecimal,
-// ): ApproximateLeverageRedemptionsResult {
-//   const debtMintingFeeRatioDecimal = Decimal(
-//     debtMintingFeePercentage.getOnChainInt,
-//   )
-//     .div(OCD_DECIMAL_UNIT)
-//     .div(100);
-//   const redemptionReimbursementRatioDecimal = Decimal(
-//     redemptionReimbursementPercentage.getOnChainInt,
-//   )
-//     .div(OCD_DECIMAL_UNIT)
-//     .div(100);
-
-//   const totalFeeRatio = debtMintingFeeRatioDecimal.add(
-//     redemptionReimbursementRatioDecimal,
-//   );
-
-//   // b''
-//   const bExFees = Decimal(baseCollateral)
-//     .mul(targetLeverage)
-//     .minus(baseCollateral)
-//     .floor();
-
-//   // b = b’’ / (1-f_r - f_m)
-//   const b = bExFees.div(Decimal(1).minus(totalFeeRatio)).floor();
-
-//   // c = (d + b * (1 - f_r - f_m)) / b
-//   const collateralRatio = {
-//     getOnChainInt: fromDecimal(
-//       Decimal(Decimal(baseCollateral).add(bExFees))
-//         .div(b)
-//         .mul(100n * OCD_DECIMAL_UNIT)
-//         .floor(),
-//     ),
-//   };
-
-//   return {
-//     leverage: targetLeverage,
-//     collateralRatio: collateralRatio,
-//     lovelacesForRedemptionWithReimbursement: fromDecimal(b),
-//   };
-// }
-
-// export function summarizeActualLeverageRedemptions(
-//   lovelacesForRedemptionWithReimbursement: bigint,
-//   redemptionReimbursementPercentage: OnChainDecimal,
-//   iassetPrice: OnChainDecimal,
-//   lrpParams: RobParamsSP,
-//   // Picking from the beginning until the iasset redemption amount is satisfied.
-//   redemptionLrps: [UTxO, RobDatum][],
-// ): {
-//   redemptions: LRPRedemptionDetails[];
-//   /**
-//    * The actual amount received from redemptions (i.e. without the reimbursement fee).
-//    */
-//   totalRedeemedLovelaces: bigint;
-//   /**
-//    * Total lovelaces amt that has been reimbursted
-//    */
-//   totalReimbursementLovelaces: bigint;
-//   totalRedemptionIAssets: bigint;
-// } {
-//   const priceDecimal = Decimal(iassetPrice.getOnChainInt).div(OCD_DECIMAL_UNIT);
-
-//   type Accumulator = {
-//     /// This is including the redemption reimbursement
-//     remainingRedemptionLovelacesInclReim: bigint;
-//     redemptions: LRPRedemptionDetails[];
-//   };
-
-//   const redemptionDetails = F.pipe(
-//     redemptionLrps,
-//     A.reduce<[UTxO, RobDatum], Accumulator>(
-//       {
-//         remainingRedemptionLovelacesInclReim:
-//           lovelacesForRedemptionWithReimbursement,
-//         redemptions: [],
-//       },
-//       (acc, lrp) => {
-//         if (
-//           acc.remainingRedemptionLovelacesInclReim <
-//           lrpParams.minRedemptionLovelacesAmt
-//         ) {
-//           return acc;
-//         }
-
-//         const lovelacesToSpend = lrpRedeemableLovelacesInclReimb(
-//           lrp,
-//           lrpParams,
-//         );
-
-//         if (lovelacesToSpend === 0n) {
-//           return acc;
-//         }
-
-//         const newRemainingLovelaces = bigintMax(
-//           acc.remainingRedemptionLovelacesInclReim - lovelacesToSpend,
-//           0n,
-//         );
-//         const redemptionLovelacesInitial =
-//           acc.remainingRedemptionLovelacesInclReim - newRemainingLovelaces;
-
-//         const finalRedemptionIAssets = fromDecimal(
-//           Decimal(redemptionLovelacesInitial).div(priceDecimal).floor(),
-//         );
-//         // We need to calculate the new number since redemptionIAssets got corrected by rounding.
-//         const finalRedemptionLovelaces = ocdMul(
-//           {
-//             getOnChainInt: finalRedemptionIAssets,
-//           },
-//           iassetPrice,
-//         ).getOnChainInt;
-
-//         const reimbursementLovelaces = calculateFeeFromPercentage(
-//           redemptionReimbursementPercentage,
-//           finalRedemptionLovelaces,
-//         );
-
-//         return {
-//           remainingRedemptionLovelacesInclReim:
-//             acc.remainingRedemptionLovelacesInclReim - finalRedemptionLovelaces,
-//           redemptions: [
-//             ...acc.redemptions,
-//             {
-//               utxo: lrp[0],
-//               iassetsForRedemptionAmt: finalRedemptionIAssets,
-//               redemptionLovelacesAmtInclReimbursement: finalRedemptionLovelaces,
-//               reimbursementLovelacesAmt: reimbursementLovelaces,
-//             },
-//           ],
-//         };
-//       },
-//     ),
-//   );
-
-//   const res = F.pipe(
-//     redemptionDetails.redemptions,
-//     A.reduce<
-//       LRPRedemptionDetails,
-//       {
-//         redeemedLovelaces: bigint;
-//         redemptionIAssets: bigint;
-//         reimbursementLovelaces: bigint;
-//       }
-//     >(
-//       {
-//         redeemedLovelaces: 0n,
-//         redemptionIAssets: 0n,
-//         reimbursementLovelaces: 0n,
-//       },
-//       (acc, details) => {
-//         return {
-//           redeemedLovelaces:
-//             acc.redeemedLovelaces +
-//             details.redemptionLovelacesAmtInclReimbursement -
-//             details.reimbursementLovelacesAmt,
-//           reimbursementLovelaces:
-//             acc.reimbursementLovelaces + details.reimbursementLovelacesAmt,
-//           redemptionIAssets:
-//             acc.redemptionIAssets + details.iassetsForRedemptionAmt,
-//         };
-//       },
-//     ),
-//   );
-
-//   return {
-//     redemptions: redemptionDetails.redemptions,
-//     totalRedeemedLovelaces: res.redeemedLovelaces,
-//     totalReimbursementLovelaces: res.reimbursementLovelaces,
-//     totalRedemptionIAssets: res.redemptionIAssets,
-//   };
-// }
-
-// /**
-//  * The math is described at the top of this code file.
-//  */
-// export function calculateCollateralRatioFromLeverage(
-//   iasset: Uint8Array<ArrayBufferLike>,
-//   leverage: number,
-//   baseCollateral: bigint,
-//   iassetPrice: OnChainDecimal,
-//   debtMintingFeePercentage: OnChainDecimal,
-//   redemptionReimbursementPercentage: OnChainDecimal,
-//   lrpParams: RobParamsSP,
-//   allLrps: [UTxO, RobDatum][],
-// ): OnChainDecimal | undefined {
-//   const debtMintingFeeRatioDecimal = Decimal(
-//     debtMintingFeePercentage.getOnChainInt,
-//   )
-//     .div(OCD_DECIMAL_UNIT)
-//     .div(100);
-//   const redemptionReimbursementRatioDecimal = Decimal(
-//     redemptionReimbursementPercentage.getOnChainInt,
-//   )
-//     .div(OCD_DECIMAL_UNIT)
-//     .div(100);
-
-//   const totalFeeRatio = debtMintingFeeRatioDecimal.add(
-//     redemptionReimbursementRatioDecimal,
-//   );
-
-//   const maxAvailableAdaForRedemptionInclReimb = calculateTotalAdaForRedemption(
-//     iasset,
-//     iassetPrice,
-//     lrpParams,
-//     allLrps,
-//     MAX_REDEMPTIONS_WITH_CDP_OPEN,
-//   );
-
-//   if (
-//     leverage <= 1 ||
-//     baseCollateral <= 0n ||
-//     maxAvailableAdaForRedemptionInclReimb <= 0n
-//   ) {
-//     return undefined;
-//   }
-
-//   // b''
-//   const bExFees = Decimal(baseCollateral)
-//     .mul(leverage)
-//     .minus(baseCollateral)
-//     .floor();
-
-//   // b = b’’ / (1-f_r - f_m)
-//   const b = bExFees.div(Decimal(1).minus(totalFeeRatio)).floor();
-
-//   const cappedB = bigintMin(
-//     maxAvailableAdaForRedemptionInclReimb,
-//     fromDecimal(b),
-//   );
-
-//   const cappedBExFees = Decimal(cappedB)
-//     .mul(Decimal(1).minus(totalFeeRatio))
-//     .floor();
-
-//   // c = (d + b * (1 - f_r - f_m)) / b
-//   const collateralRatio = Decimal(
-//     Decimal(baseCollateral).add(cappedBExFees),
-//   ).div(cappedB);
-
-//   return {
-//     getOnChainInt: fromDecimal(
-//       collateralRatio.mul(100n * OCD_DECIMAL_UNIT).floor(),
-//     ),
-//   };
-// }
-
-// /**
-//  * The math is described at the top of this code file.
-//  */
-// export function calculateLeverageFromCollateralRatio(
-//   iasset: Uint8Array<ArrayBufferLike>,
-//   collateralRatioPercentage: OnChainDecimal,
-//   baseCollateral: bigint,
-//   iassetPrice: OnChainDecimal,
-//   debtMintingFeePercentage: OnChainDecimal,
-//   redemptionReimbursementPercentage: OnChainDecimal,
-//   lrpParams: RobParamsSP,
-//   allLrps: [UTxO, RobDatum][],
-// ): number | undefined {
-//   const debtMintingFeeRatioDecimal = Decimal(
-//     debtMintingFeePercentage.getOnChainInt,
-//   )
-//     .div(OCD_DECIMAL_UNIT)
-//     .div(100);
-//   const redemptionReimbursementRatioDecimal = Decimal(
-//     redemptionReimbursementPercentage.getOnChainInt,
-//   )
-//     .div(OCD_DECIMAL_UNIT)
-//     .div(100);
-
-//   const totalFeeRatio = debtMintingFeeRatioDecimal.add(
-//     redemptionReimbursementRatioDecimal,
-//   );
-
-//   const collateralRatio = Decimal(collateralRatioPercentage.getOnChainInt)
-//     .div(OCD_DECIMAL_UNIT)
-//     .div(100);
-
-//   const maxAvailableAdaForRedemptionInclReimb = calculateTotalAdaForRedemption(
-//     iasset,
-//     iassetPrice,
-//     lrpParams,
-//     allLrps,
-//     MAX_REDEMPTIONS_WITH_CDP_OPEN,
-//   );
-
-//   if (
-//     collateralRatio.toNumber() <= 1 ||
-//     baseCollateral <= 0n ||
-//     maxAvailableAdaForRedemptionInclReimb <= 0n
-//   ) {
-//     return undefined;
-//   }
-
-//   // The leverage unconstrained by the liquidity in LRP
-//   const theoreticalMaxLeverage = Decimal(Decimal(1).minus(totalFeeRatio))
-//     .div(collateralRatio.minus(1).add(totalFeeRatio))
-//     .add(1);
-
-//   // b''
-//   const bExFees = theoreticalMaxLeverage
-//     .mul(baseCollateral)
-//     .minus(baseCollateral)
-//     .floor();
-
-//   // b = b’’ / (1-f_r - f_m)
-//   const b = bExFees.div(Decimal(1).minus(totalFeeRatio)).floor();
-
-//   const cappedB = bigintMin(
-//     maxAvailableAdaForRedemptionInclReimb,
-//     fromDecimal(b),
-//   );
-
-//   const cappedBExFees = Decimal(cappedB)
-//     .mul(Decimal(1).minus(totalFeeRatio))
-//     .floor();
-
-//   return Decimal(baseCollateral)
-//     .add(cappedBExFees)
-//     .div(baseCollateral)
-//     .toNumber();
-// }
+import { UTxO } from '@lucid-evolution/lucid';
+import { OCD_DECIMAL_UNIT, OnChainDecimal } from '../../types/on-chain-decimal';
+import { bigintMax, bigintMin, fromDecimal } from '../../utils/bigint-utils';
+import { array as A, function as F } from 'fp-ts';
+import { Decimal } from 'decimal.js';
+import {
+  calculateTotalCollateralForRedemption,
+  robCollateralAmtToSpend,
+} from '../rob/helpers';
+import {
+  Rational,
+  rationalFloor,
+  rationalFromInt,
+  rationalMul,
+} from '../../types/rational';
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
+import { RobDatum } from '../rob/types-new';
+import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
+import { iassetValueOfCollateral } from '../cdp/helpers';
+
+/**
+ * How many LRP redemptions can we fit into a TX with CDP open.
+ */
+export const MAX_REDEMPTIONS_WITH_CDP_OPEN = 4;
+
+type ROBRedemptionDetails = {
+  utxo: UTxO;
+  redeemedCollateral: bigint;
+  /**
+   * The amount of iAssets paid to ROB.
+   */
+  iassetsPayoutAmt: bigint;
+  reimbursementIAssetAmt: bigint;
+};
+
+type ApproximateLeverageRedemptionsResult = {
+  leverage: number;
+  collateralRatio: Rational;
+  redeemedCollateral: bigint;
+};
+
+/**
+ * We assume exact precision. However, actual redemptions include rounding and
+ * the rounding behaviour changes based on the number of redemptions.
+ * This may slightly tweak the numbers and the result can be different.
+ *
+ * The math is described at the top of this code file.
+ */
+export function approximateLeverageRedemptions(
+  baseCollateral: bigint,
+  targetLeverage: number,
+  redemptionReimbursementRatio: Rational,
+  debtMintingFeeRatio: Rational,
+): ApproximateLeverageRedemptionsResult {
+  const debtMintingFeeRatioDecimal = Decimal(debtMintingFeeRatio.numerator).div(
+    debtMintingFeeRatio.denominator,
+  );
+
+  const redemptionReimbursementRatioDecimal = Decimal(
+    redemptionReimbursementRatio.numerator,
+  ).div(redemptionReimbursementRatio.denominator);
+
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal,
+  );
+
+  // b''
+  const bExFees = Decimal(baseCollateral)
+    .mul(targetLeverage)
+    .minus(baseCollateral)
+    .floor();
+
+  // b = b’’ / (1-f_r - f_m)
+  const b = bExFees.div(Decimal(1).minus(totalFeeRatio)).floor();
+
+  // c = (d + b * (1 - f_r - f_m)) / b
+  const collateralRatio: Rational = {
+    numerator: fromDecimal(Decimal(baseCollateral).add(bExFees)),
+    denominator: fromDecimal(b),
+  };
+
+  return {
+    leverage: targetLeverage,
+    collateralRatio: collateralRatio,
+    redeemedCollateral: fromDecimal(bExFees),
+  };
+}
+
+export function summarizeActualLeverageRedemptions(
+  lovelacesForRedemptionWithReimbursement: bigint,
+  redemptionReimbursementRatio: Rational,
+  iassetPrice: Rational,
+  // Picking from the beginning until the iasset redemption amount is satisfied.
+  redemptionLrps: [UTxO, RobDatum][],
+): {
+  redemptions: ROBRedemptionDetails[];
+  /**
+   * The actual amount received from redemptions (i.e. without the reimbursement fee).
+   */
+  totalRedeemedCollateral: bigint;
+  /**
+   * Total amount of IAssets to cover the reimbursement fee.
+   */
+  totalReimbursedIAsset: bigint;
+  /**
+   * Total amount of IAssets paid to ROBs, including the reimbursement.
+   */
+  totalIAssetPayout: bigint;
+} {
+  const priceDecimal = Decimal(iassetPrice.numerator).div(
+    iassetPrice.denominator,
+  );
+
+  type Accumulator = {
+    /// The remaining collateral to spend from ROBs
+    remainingCollateralToSpend: bigint;
+    redemptions: ROBRedemptionDetails[];
+  };
+
+  const reimbRatio = Decimal(redemptionReimbursementRatio.numerator).div(
+    redemptionReimbursementRatio.denominator,
+  );
+
+  const redemptionDetails = F.pipe(
+    redemptionLrps,
+    A.reduce<[UTxO, RobDatum], Accumulator>(
+      {
+        remainingCollateralToSpend: lovelacesForRedemptionWithReimbursement,
+        redemptions: [],
+      },
+      (acc, lrp) => {
+        if (
+          acc.remainingCollateralToSpend <= 0n ||
+          iassetValueOfCollateral(
+            acc.remainingCollateralToSpend,
+            iassetPrice,
+          ) <= 0n
+        ) {
+          return acc;
+        }
+
+        const collateralToSpend = robCollateralAmtToSpend(lrp[0], lrp[1]);
+
+        if (collateralToSpend === 0n) {
+          return acc;
+        }
+
+        const newRemainingCollateral = bigintMax(
+          acc.remainingCollateralToSpend - collateralToSpend,
+          0n,
+        );
+        const collateralToSpendInitial =
+          acc.remainingCollateralToSpend - newRemainingCollateral;
+
+        // TODO: make corrections here in case we can be ceiling this number instead.
+        // We want to be flooring here so that we don't go over the collateral to spend.
+        // Flooring multiple times is necessary here otherwise we could go over the collateral available.
+        // iassets = floor(collateral / price) / floor(1 - reimbursement fee)
+        const finalPayoutIAssets = fromDecimal(
+          Decimal(collateralToSpendInitial)
+            .div(priceDecimal)
+            .floor()
+            .div(Decimal(1).minus(reimbRatio))
+            .floor(),
+        );
+
+        const feeIAssetAmt = calculateFeeFromRatio(
+          redemptionReimbursementRatio,
+          finalPayoutIAssets,
+        );
+
+        // We need to calculate the new number since redemptionIAssets got corrected by rounding.
+        const finalCollateralToSpend = rationalFloor(
+          rationalMul(
+            rationalFromInt(finalPayoutIAssets - feeIAssetAmt),
+            iassetPrice,
+          ),
+        );
+
+        return {
+          remainingCollateralToSpend:
+            acc.remainingCollateralToSpend - finalCollateralToSpend,
+          redemptions: [
+            ...acc.redemptions,
+            {
+              utxo: lrp[0],
+              iassetsPayoutAmt: finalPayoutIAssets,
+              redeemedCollateral: finalCollateralToSpend,
+              reimbursementIAssetAmt: feeIAssetAmt,
+            },
+          ],
+        };
+      },
+    ),
+  );
+
+  const res = F.pipe(
+    redemptionDetails.redemptions,
+    A.reduce<
+      ROBRedemptionDetails,
+      {
+        redeemedCollateral: bigint;
+        payoutIAssets: bigint;
+        reimbursementIAssets: bigint;
+      }
+    >(
+      {
+        redeemedCollateral: 0n,
+        payoutIAssets: 0n,
+        reimbursementIAssets: 0n,
+      },
+      (acc, details) => {
+        return {
+          redeemedCollateral:
+            acc.redeemedCollateral + details.redeemedCollateral,
+          reimbursementIAssets:
+            acc.reimbursementIAssets + details.reimbursementIAssetAmt,
+          payoutIAssets: acc.payoutIAssets + details.iassetsPayoutAmt,
+        };
+      },
+    ),
+  );
+
+  return {
+    redemptions: redemptionDetails.redemptions,
+    totalRedeemedCollateral: res.redeemedCollateral,
+    totalReimbursedIAsset: res.reimbursementIAssets,
+    totalIAssetPayout: res.payoutIAssets,
+  };
+}
+
+/**
+ * The math is described at the top of this code file.
+ */
+export function calculateCollateralRatioFromLeverage(
+  iasset: Uint8Array<ArrayBufferLike>,
+  collateralAsset: AssetClass,
+  leverage: number,
+  baseCollateral: bigint,
+  iassetPrice: Rational,
+  debtMintingFeePercentage: OnChainDecimal,
+  redemptionReimbursementPercentage: OnChainDecimal,
+  allLrps: [UTxO, RobDatum][],
+): OnChainDecimal | undefined {
+  const debtMintingFeeRatioDecimal = Decimal(
+    debtMintingFeePercentage.getOnChainInt,
+  )
+    .div(OCD_DECIMAL_UNIT)
+    .div(100);
+  const redemptionReimbursementRatioDecimal = Decimal(
+    redemptionReimbursementPercentage.getOnChainInt,
+  )
+    .div(OCD_DECIMAL_UNIT)
+    .div(100);
+
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal,
+  );
+
+  const maxAvailableCollateralForRedemption =
+    calculateTotalCollateralForRedemption(
+      iasset,
+      collateralAsset,
+      iassetPrice,
+      allLrps,
+      MAX_REDEMPTIONS_WITH_CDP_OPEN,
+    );
+
+  if (
+    leverage <= 1 ||
+    baseCollateral <= 0n ||
+    maxAvailableCollateralForRedemption <= 0n
+  ) {
+    return undefined;
+  }
+
+  // b''
+  const bExFees = Decimal(baseCollateral)
+    .mul(leverage)
+    .minus(baseCollateral)
+    .floor();
+
+  // b = b’’ / (1-f_r - f_m)
+  const b = bExFees.div(Decimal(1).minus(totalFeeRatio)).floor();
+
+  const cappedB = bigintMin(
+    maxAvailableCollateralForRedemption,
+    fromDecimal(b),
+  );
+
+  const cappedBExFees = Decimal(cappedB)
+    .mul(Decimal(1).minus(totalFeeRatio))
+    .floor();
+
+  // c = (d + b * (1 - f_r - f_m)) / b
+  const collateralRatio = Decimal(
+    Decimal(baseCollateral).add(cappedBExFees),
+  ).div(cappedB);
+
+  return {
+    getOnChainInt: fromDecimal(
+      collateralRatio.mul(100n * OCD_DECIMAL_UNIT).floor(),
+    ),
+  };
+}
+
+/**
+ * The math is described at the top of this code file.
+ */
+export function calculateLeverageFromCollateralRatio(
+  iasset: Uint8Array<ArrayBufferLike>,
+  collateralAsset: AssetClass,
+  collateralRatio: Rational,
+  baseCollateral: bigint,
+  iassetPrice: Rational,
+  debtMintingFeeRatio: Rational,
+  redemptionReimbursementRatio: Rational,
+  allLrps: [UTxO, RobDatum][],
+): number | undefined {
+  const debtMintingFeeRatioDecimal = Decimal(debtMintingFeeRatio.numerator).div(
+    debtMintingFeeRatio.denominator,
+  );
+  const redemptionReimbursementRatioDecimal = Decimal(
+    redemptionReimbursementRatio.numerator,
+  ).div(redemptionReimbursementRatio.denominator);
+
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal,
+  );
+
+  const collateralRatioDecimal = Decimal(collateralRatio.numerator).div(
+    collateralRatio.denominator,
+  );
+
+  const maxAvailableCollateralForRedemption =
+    calculateTotalCollateralForRedemption(
+      iasset,
+      collateralAsset,
+      iassetPrice,
+      allLrps,
+      MAX_REDEMPTIONS_WITH_CDP_OPEN,
+    );
+
+  if (
+    collateralRatioDecimal.toNumber() <= 1 ||
+    baseCollateral <= 0n ||
+    maxAvailableCollateralForRedemption <= 0n
+  ) {
+    return undefined;
+  }
+
+  // The leverage unconstrained by the liquidity in LRP
+  const theoreticalMaxLeverage = Decimal(Decimal(1).minus(totalFeeRatio))
+    .div(collateralRatioDecimal.minus(1).add(totalFeeRatio))
+    .add(1);
+
+  // b''
+  const bExFees = theoreticalMaxLeverage
+    .mul(baseCollateral)
+    .minus(baseCollateral)
+    .floor();
+
+  // b = b’’ / (1-f_r - f_m)
+  const b = bExFees.div(Decimal(1).minus(totalFeeRatio)).floor();
+
+  const cappedB = bigintMin(
+    maxAvailableCollateralForRedemption,
+    fromDecimal(b),
+  );
+
+  const cappedBExFees = Decimal(cappedB)
+    .mul(Decimal(1).minus(totalFeeRatio))
+    .floor();
+
+  return Decimal(baseCollateral)
+    .add(cappedBExFees)
+    .div(baseCollateral)
+    .toNumber();
+}