diff --git a/frontend/app/src/screens/LoanScreen/LoanScreen.tsx b/frontend/app/src/screens/LoanScreen/LoanScreen.tsx
index d28aaf8d6..62ed6b995 100644
--- a/frontend/app/src/screens/LoanScreen/LoanScreen.tsx
+++ b/frontend/app/src/screens/LoanScreen/LoanScreen.tsx
@@ -8,6 +8,7 @@ import { Field } from "@/src/comps/Field/Field";
import { FlowButton } from "@/src/comps/FlowButton/FlowButton";
import { LinkTextButton } from "@/src/comps/LinkTextButton/LinkTextButton";
import { Screen } from "@/src/comps/Screen/Screen";
+import { WarningBox } from "@/src/comps/WarningBox/WarningBox";
import content from "@/src/content";
import { TROVE_EXPLORER_0, TROVE_EXPLORER_1 } from "@/src/env";
import { fmtnum, formatDate } from "@/src/formatting";
@@ -16,6 +17,7 @@ import {
getPrefixedTroveId,
parsePrefixedTroveId,
useCollateralSurplus,
+ useIsBranchShutdown,
useLoan,
} from "@/src/liquity-utils";
import { usePrice } from "@/src/services/Prices";
@@ -169,6 +171,7 @@ export function LoanScreen() {
const { troveId, branchId } = parsePrefixedTroveId(paramPrefixedId);
const loan = useLoan(branchId, troveId);
+ const isShutdown = useIsBranchShutdown(branchId);
const loanMode = storedState.loanModes[paramPrefixedId] ?? loan.data?.type ?? "borrow";
useEffect(() => {
@@ -177,6 +180,12 @@ export function LoanScreen() {
}
}, [loan.data?.troveId, loan.data?.branchId, paramPrefixedId]);
+ useEffect(() => {
+ if (isShutdown.data && action !== "close") {
+ router.push(`/loan/close?id=${paramPrefixedId}`, { scroll: false });
+ }
+ }, [isShutdown.data, action, paramPrefixedId, router]);
+
const collToken = getCollToken(loan.data?.branchId ?? null);
const collPriceUsd = usePrice(collToken?.symbol ?? null);
@@ -391,39 +400,68 @@ export function LoanScreen() {
)}
)}
- ({
- label: compactMode ? labelCompact : label,
- panelId: `p-${id}`,
- tabId: `t-${id}`,
- }))}
- selected={TABS.findIndex(({ id }) => id === action)}
- onSelect={(index) => {
- if (!loan.data) {
- return;
- }
- const tab = TABS[index];
- if (!tab) {
- throw new Error("Invalid tab index");
- }
- const id = getPrefixedTroveId(
- loan.data.branchId,
- loan.data.troveId,
- );
- router.push(
- `/loan/${tab.id}?id=${id}`,
- { scroll: false },
- );
- }}
- />
+ {isShutdown.data && collToken && (
+
+
+
+ {content.shutdownWarning.title}
+
+
+ {content.shutdownWarning.loanMessage(collToken.name)}
+
+
+ )}
+
+ {!isShutdown.data && (
+ ({
+ label: compactMode ? labelCompact : label,
+ panelId: `p-${id}`,
+ tabId: `t-${id}`,
+ }))}
+ selected={TABS.findIndex(({ id }) => id === action)}
+ onSelect={(index) => {
+ if (!loan.data) {
+ return;
+ }
+ const tab = TABS[index];
+ if (!tab) {
+ throw new Error("Invalid tab index");
+ }
+ const id = getPrefixedTroveId(
+ loan.data.branchId,
+ loan.data.troveId,
+ );
+ router.push(
+ `/loan/${tab.id}?id=${id}`,
+ { scroll: false },
+ );
+ }}
+ />
+ )}
- {action === "colldebt" && (
+ {!isShutdown.data && action === "colldebt" && (
loanMode === "multiply"
?
+ {hasShutdownBranches && (
+ getBranch(b.branchId).symbol)}
+ activeBranches={activeBranches.map((b) => getBranch(b.branchId).symbol)}
+ />
+ )}
- {props.title && (
-
- )}
+ const shutdownNames = props.shutdownBranches.join(", ");
+ const activeNames = props.activeBranches.length > 0
+ ? props.activeBranches.join(", ")
+ : "none";
- {props.children}
-
+ return (
+
+
+ Branch Shutdown Detected
+
+
+ The following branches are in shutdown mode: {shutdownNames}.
+ {props.activeBranches.length > 0
+ ? ` Standard redemptions will only use active branches (${activeNames}).`
+ : " No active branches available for standard redemptions."}
+
+
+ Use{" "}
+
+
);
}
diff --git a/frontend/app/src/screens/UrgentRedeemScreen/TroveSelectionTable.tsx b/frontend/app/src/screens/UrgentRedeemScreen/TroveSelectionTable.tsx
new file mode 100644
index 000000000..bc93c0983
--- /dev/null
+++ b/frontend/app/src/screens/UrgentRedeemScreen/TroveSelectionTable.tsx
@@ -0,0 +1,242 @@
+import type { Dnum, TroveId } from "@/src/types";
+import type { TroveWithICR } from "@/src/urgent-redemption-utils";
+
+import { Amount } from "@/src/comps/Amount/Amount";
+import content from "@/src/content";
+import { DNUM_0 } from "@/src/dnum-utils";
+import { shortenTroveId } from "@/src/liquity-utils";
+import { sortByRedeemableValue, TROVES_PER_PAGE } from "@/src/urgent-redemption-utils";
+import { css } from "@/styled-system/css";
+import { Button, Checkbox, HFlex, VFlex } from "@liquity2/uikit";
+import * as dn from "dnum";
+import { useMemo, useState } from "react";
+
+type TroveSelectionTableProps = {
+ troves: TroveWithICR[];
+ price: Dnum;
+ selectedTroveIds: Set;
+ onSelectionChange: (selected: Set) => void;
+};
+
+export function TroveSelectionTable({
+ troves,
+ price,
+ selectedTroveIds,
+ onSelectionChange,
+}: TroveSelectionTableProps) {
+ const [currentPage, setCurrentPage] = useState(0);
+ const sortedTroves = useMemo(
+ () => sortByRedeemableValue(troves, price),
+ [troves, price],
+ );
+ const totalPages = Math.ceil(sortedTroves.length / TROVES_PER_PAGE);
+ const paginatedTroves = useMemo(() => {
+ const start = currentPage * TROVES_PER_PAGE;
+ return sortedTroves.slice(start, start + TROVES_PER_PAGE);
+ }, [sortedTroves, currentPage]);
+
+ const selectedTotals = useMemo(() => {
+ const selected = troves.filter((t) => selectedTroveIds.has(t.troveId));
+ return {
+ count: selected.length,
+ totalDebt: selected.reduce((sum, t) => dn.add(sum, t.debt), DNUM_0),
+ totalColl: selected.reduce((sum, t) => dn.add(sum, t.coll), DNUM_0),
+ };
+ }, [troves, selectedTroveIds]);
+
+ const toggleTrove = (troveId: TroveId) => {
+ const newSelected = new Set(selectedTroveIds);
+ if (newSelected.has(troveId)) {
+ newSelected.delete(troveId);
+ } else {
+ newSelected.add(troveId);
+ }
+ onSelectionChange(newSelected);
+ };
+
+ const selectAllOnPage = () => {
+ const newSelected = new Set(selectedTroveIds);
+ for (const trove of paginatedTroves) {
+ newSelected.add(trove.troveId);
+ }
+ onSelectionChange(newSelected);
+ };
+
+ const clearSelection = () => {
+ onSelectionChange(new Set());
+ };
+
+ const allOnPageSelected = paginatedTroves.every((t) => selectedTroveIds.has(t.troveId));
+
+ return (
+
+
+
+
+ {content.urgentRedeemScreen.troveTable.trovesSelected(selectedTotals.count)}
+
+
+
+ {content.urgentRedeemScreen.troveTable.totalDebt}{" "}
+
+
+ {content.urgentRedeemScreen.troveTable.totalColl}{" "}
+
+
+
+
+
+
+
+
+
+
+ {content.urgentRedeemScreen.troveTable.columnTroveId}
+ {content.urgentRedeemScreen.troveTable.columnCollateral}
+ {content.urgentRedeemScreen.troveTable.columnDebt}
+ {content.urgentRedeemScreen.troveTable.columnIcr}
+
+
+
+ {paginatedTroves.map((trove) => {
+ const isSelected = selectedTroveIds.has(trove.troveId);
+ return (
+ toggleTrove(trove.troveId)}
+ >
+ e.stopPropagation()}>
+ toggleTrove(trove.troveId)}
+ />
+
+
+ {shortenTroveId(trove.troveId)}
+
+
+
+
+
+
+
+
+ );
+ })}
+ {paginatedTroves.length === 0 && (
+
+
+ {content.urgentRedeemScreen.troveTable.noTrovesAvailable}
+
+
+ )}
+
+
+
+ setCurrentPage((p) => Math.max(0, p - 1))}
+ />
+
+ {content.urgentRedeemScreen.troveTable.page(currentPage + 1, totalPages)}
+
+ = totalPages - 1}
+ onClick={() => setCurrentPage((p) => Math.min(totalPages - 1, p + 1))}
+ />
+
+ )}
+
+ );
+}
diff --git a/frontend/app/src/screens/UrgentRedeemScreen/UrgentRedeemScreen.tsx b/frontend/app/src/screens/UrgentRedeemScreen/UrgentRedeemScreen.tsx
new file mode 100644
index 000000000..3ff0550cc
--- /dev/null
+++ b/frontend/app/src/screens/UrgentRedeemScreen/UrgentRedeemScreen.tsx
@@ -0,0 +1,413 @@
+"use client";
+
+import type { CollateralSymbol, TroveId } from "@/src/types";
+
+import { Amount } from "@/src/comps/Amount/Amount";
+import { Field } from "@/src/comps/Field/Field";
+import { FlowButton } from "@/src/comps/FlowButton/FlowButton";
+import { InfoBox } from "@/src/comps/InfoBox/InfoBox";
+import { LinkTextButton } from "@/src/comps/LinkTextButton/LinkTextButton";
+import { Screen } from "@/src/comps/Screen/Screen";
+import content from "@/src/content";
+import { DNUM_0 } from "@/src/dnum-utils";
+import { parseInputPercentage, useInputFieldValue } from "@/src/form-utils";
+import { fmtnum } from "@/src/formatting";
+import { getBranch, getCollToken, useRedeemableTroves, useShutdownStatus } from "@/src/liquity-utils";
+import { usePrice } from "@/src/services/Prices";
+import {
+ addICRToTroves,
+ calculateMinCollateral,
+ calculateRedemptionOutput,
+ DEFAULT_SLIPPAGE,
+ effectiveRedeemable,
+ selectOptimalTroves,
+ URGENT_REDEMPTION_BONUS_PCT,
+} from "@/src/urgent-redemption-utils";
+import { useAccount, useBalance } from "@/src/wagmi-utils";
+import { css } from "@/styled-system/css";
+import { HFlex, InfoTooltip, InputField, Tabs, TextButton, TokenIcon, VFlex } from "@liquity2/uikit";
+import * as dn from "dnum";
+import { useMemo, useState } from "react";
+import { TroveSelectionTable } from "./TroveSelectionTable";
+
+export function UrgentRedeemScreen() {
+ const account = useAccount();
+ const boldBalance = useBalance(account.address, "BOLD");
+ const boldPrice = usePrice("BOLD");
+ const shutdownStatus = useShutdownStatus();
+
+ const shutdownBranches = useMemo(
+ () => shutdownStatus.data?.filter((b) => b.isShutdown) ?? [],
+ [shutdownStatus.data],
+ );
+
+ const [selectedBranchSymbol, setSelectedBranchSymbol] = useState(null);
+ const activeBranchSymbol = selectedBranchSymbol
+ ?? (shutdownBranches[0] ? getBranch(shutdownBranches[0].branchId).symbol : null);
+ const activeBranch = activeBranchSymbol ? getBranch(activeBranchSymbol) : null;
+ const collToken = activeBranch ? getCollToken(activeBranch.branchId) : null;
+
+ const price = usePrice(activeBranchSymbol);
+ const trovesQuery = useRedeemableTroves(activeBranch?.branchId ?? null, { first: 200 });
+
+ const boldAmount = useInputFieldValue(fmtnum);
+
+ const [slippage, setSlippage] = useState(DEFAULT_SLIPPAGE);
+ const slippageInput = useInputFieldValue(
+ (value) => fmtnum(dn.mul(value, 100)),
+ {
+ defaultValue: fmtnum(dn.mul(DEFAULT_SLIPPAGE, 100)),
+ parse: parseInputPercentage,
+ onChange: ({ parsed }) => {
+ if (parsed) setSlippage(parsed);
+ },
+ },
+ );
+
+ const [isManualMode, setIsManualMode] = useState(false);
+ const [selectedTroveIds, setSelectedTroveIds] = useState>(new Set());
+
+ const trovesWithICR = useMemo(() => {
+ if (!trovesQuery.data || !price.data) return [];
+ return addICRToTroves(trovesQuery.data, price.data);
+ }, [trovesQuery.data, price.data]);
+
+ const selection = useMemo(() => {
+ if (!price.data) return null;
+
+ if (isManualMode) {
+ const priceData = price.data;
+ const manuallySelected = trovesWithICR.filter((t) => selectedTroveIds.has(t.troveId));
+ const totalDebt = manuallySelected.reduce((sum, t) => dn.add(sum, t.debt), DNUM_0);
+ const totalColl = manuallySelected.reduce((sum, t) => dn.add(sum, t.coll), DNUM_0);
+ const totalRedeemable = manuallySelected.reduce(
+ (sum, t) => dn.add(sum, effectiveRedeemable(t, priceData)),
+ DNUM_0,
+ );
+ const requestedAmount = boldAmount.parsed ?? DNUM_0;
+ const actualBoldToRedeem = dn.lt(totalRedeemable, requestedAmount) ? totalRedeemable : requestedAmount;
+
+ return {
+ selectedTroves: manuallySelected,
+ totalDebt,
+ totalColl,
+ actualBoldToRedeem,
+ isAmountCapped: dn.lt(totalRedeemable, requestedAmount),
+ };
+ }
+
+ return selectOptimalTroves(
+ trovesWithICR,
+ boldAmount.parsed ?? DNUM_0,
+ price.data,
+ );
+ }, [trovesWithICR, boldAmount.parsed, price.data, isManualMode, selectedTroveIds]);
+
+ const redemptionOutput = useMemo(() => {
+ if (!selection || !price.data) return null;
+ return calculateRedemptionOutput(
+ selection.selectedTroves,
+ selection.actualBoldToRedeem,
+ price.data,
+ );
+ }, [selection, price.data]);
+
+ const minCollateral = useMemo(() => {
+ if (!redemptionOutput) return null;
+ return calculateMinCollateral(redemptionOutput.collateral, slippage);
+ }, [redemptionOutput, slippage]);
+
+ const boldRedeemedUsd = selection && boldPrice.data
+ && dn.mul(selection.actualBoldToRedeem, boldPrice.data);
+
+ const cappedAmount = selection?.isAmountCapped && dn.gt(selection.actualBoldToRedeem, DNUM_0)
+ ? selection.actualBoldToRedeem
+ : null;
+
+ const amountNonZero = boldAmount.parsed && dn.gt(boldAmount.parsed, DNUM_0);
+ const balanceSufficient = boldAmount.parsed && boldBalance.data && dn.lte(boldAmount.parsed, boldBalance.data);
+ const hasSelectedTroves = selection && selection.selectedTroves.length > 0;
+ const allowSubmit = account.isConnected
+ && amountNonZero
+ && balanceSufficient
+ && hasSelectedTroves
+ && shutdownBranches.length > 0;
+
+ if (shutdownStatus.isSuccess && shutdownBranches.length === 0) {
+ return (
+
+
+
+
+ );
+ }
+
+ const noRedeemableTroves = trovesQuery.isSuccess && trovesQuery.data.length === 0;
+
+ const tokenName = collToken?.symbol === "ETH" ? "WETH" : collToken?.name ?? "";
+
+ return (
+
+ {content.urgentRedeemScreen.headingTitleActive}
+ {collToken &&
+ {shutdownBranches.length > 1 && (
+ {
+ const symbol = getBranch(b.branchId).symbol;
+ return {
+ label: symbol,
+ panelId: `branch-${symbol}`,
+ tabId: `tab-${symbol}`,
+ };
+ })}
+ selected={shutdownBranches.findIndex((b) => getBranch(b.branchId).symbol === activeBranchSymbol)}
+ onSelect={(index) => {
+ const branch = shutdownBranches[index];
+ if (branch) {
+ setSelectedBranchSymbol(getBranch(branch.branchId).symbol);
+ setSelectedTroveIds(new Set());
+ setIsManualMode(false);
+ }
+ }}
+ />
+ }
+ />
+ )}
+
+ {noRedeemableTroves ? {
+ if (boldBalance.data) {
+ boldAmount.setValue(dn.toString(boldBalance.data));
+ }
+ }}
+ />
+ )
+ ),
+ }}
+ {...boldAmount.inputFieldProps}
+ value={!boldAmount.isFocused && cappedAmount
+ ? fmtnum(cappedAmount)
+ : boldAmount.inputFieldProps.value}
+ />
+ }
+ />
+
+
+
+ {content.urgentRedeemScreen.youReceive}
+
+
+
+
+
+ {price.data && (
+
+ {" "}@ ${fmtnum(price.data)}/{tokenName}
+
+ )}
+
+
+
+
+
+ {content.urgentRedeemScreen.bonusLabel(URGENT_REDEMPTION_BONUS_PCT)}
+
+ {content.urgentRedeemScreen.bonusTooltip(URGENT_REDEMPTION_BONUS_PCT)}
+
+
+
+
+
+
+
+
+
+
+
+ {content.urgentRedeemScreen.slippageTolerance}
+
+
+ %
+
+
+
+
+
+
+ {isManualMode
+ ? content.urgentRedeemScreen.manualTrovesLabel
+ : content.urgentRedeemScreen.autoTrovesLabel}
+
+ {
+ setIsManualMode(!isManualMode);
+ if (!isManualMode) {
+ setSelectedTroveIds(new Set(selection?.selectedTroves.map((t) => t.troveId) ?? []));
+ }
+ }}
+ />
+
+ }
+ field={isManualMode
+ ? (
+
+ {content.urgentRedeemScreen.trovesCount(selection.selectedTroves.length)}
+
+ )
+ : null}
+ />
+
+ t.troveId) ?? [],
+ minCollateral: minCollateral ?? DNUM_0,
+ expectedCollateral: redemptionOutput?.collateral ?? DNUM_0,
+ slippagePct: slippage,
+ }}
+ />
+
+ )}
+
+
+ );
+}
+
+function NoShutdownMessage() {
+ return (
+
+ {content.urgentRedeemScreen.noShutdown.body}
+
+ );
+}
+
+function NoTrovesMessage() {
+ return (
+
+ {content.urgentRedeemScreen.noTroves.body}
+
+ );
+}
diff --git a/frontend/app/src/services/TransactionFlow.tsx b/frontend/app/src/services/TransactionFlow.tsx
index 186817e05..4022b362d 100644
--- a/frontend/app/src/services/TransactionFlow.tsx
+++ b/frontend/app/src/services/TransactionFlow.tsx
@@ -45,6 +45,7 @@ import { unstakeDeposit, type UnstakeDepositRequest } from "@/src/tx-flows/unsta
import { updateBorrowPosition, type UpdateBorrowPositionRequest } from "@/src/tx-flows/updateBorrowPosition";
import { updateLeveragePosition, type UpdateLeveragePositionRequest } from "@/src/tx-flows/updateLeveragePosition";
import { updateLoanInterestRate, type UpdateLoanInterestRateRequest } from "@/src/tx-flows/updateLoanInterestRate";
+import { urgentRedemption, type UrgentRedemptionRequest } from "@/src/tx-flows/urgentRedemption";
export type FlowRequestMap = {
"allocateVotingPower": AllocateVotingPowerRequest;
@@ -68,6 +69,7 @@ export type FlowRequestMap = {
"updateBorrowPosition": UpdateBorrowPositionRequest;
"updateLeveragePosition": UpdateLeveragePositionRequest;
"updateLoanInterestRate": UpdateLoanInterestRateRequest;
+ "urgentRedemption": UrgentRedemptionRequest;
};
const FlowIdSchema = v.union([
@@ -92,6 +94,7 @@ const FlowIdSchema = v.union([
v.literal("updateBorrowPosition"),
v.literal("updateLeveragePosition"),
v.literal("updateLoanInterestRate"),
+ v.literal("urgentRedemption"),
]);
export const flows: FlowsMap = {
@@ -116,6 +119,7 @@ export const flows: FlowsMap = {
updateBorrowPosition,
updateLeveragePosition,
updateLoanInterestRate,
+ urgentRedemption,
};
/* end of flows registration */
diff --git a/frontend/app/src/tx-flows/redeemCollateral.tsx b/frontend/app/src/tx-flows/redeemCollateral.tsx
index 6858e6866..c8c1d9f8a 100644
--- a/frontend/app/src/tx-flows/redeemCollateral.tsx
+++ b/frontend/app/src/tx-flows/redeemCollateral.tsx
@@ -11,6 +11,7 @@ import { css } from "@/styled-system/css";
import { HFlex, InfoTooltip, TokenIcon, VFlex } from "@liquity2/uikit";
import * as dn from "dnum";
import * as v from "valibot";
+import { maxUint256 } from "viem";
import { REDEMPTION_SLIPPAGE_TOLERANCE } from "../constants";
import { createRequestSchema, verifyTransaction } from "./shared";
@@ -103,16 +104,21 @@ export const redeemCollateral: FlowDeclaration = {
steps: {
approve: {
name: () => "Approve BOLD",
- Status: TransactionStatus,
+ Status: (props) => >,
+ boldAmount: vDnum(),
+ troveIds: v.array(v.string()),
+ minCollateral: vDnum(),
+ expectedCollateral: vDnum(),
+ slippagePct: vDnum(),
+ },
+);
+
+export type UrgentRedemptionRequest = v.InferOutput;
+
+export const urgentRedemption: FlowDeclaration = {
+ title: content.urgentRedeemScreen.txFlow.title,
+ Summary: () => null,
+
+ Details(ctx) {
+ const { branchId, boldAmount, expectedCollateral, troveIds, slippagePct } = ctx.request;
+ const branch = getBranch(branchId);
+ const collToken = getCollToken(branchId);
+ const tokenName = collToken.symbol === "ETH" ? "WETH" : collToken.name;
+ const price = usePrice(branch.symbol);
+
+ const collWithoutBonus = price.data
+ ? dn.div(boldAmount, price.data)
+ : null;
+ const bonus = collWithoutBonus
+ ? dn.sub(expectedCollateral, collWithoutBonus)
+ : null;
+
+ return (
+
+
+
+ {content.urgentRedeemScreen.txFlow.youRedeemBold}
+
+ {content.urgentRedeemScreen.txFlow.redeemTooltip(URGENT_REDEMPTION_BONUS_PCT)}
+
+
+
+
+
+
+
+
+
+
+ {content.urgentRedeemScreen.txFlow.youReceiveToken(tokenName)}
+
+ {content.urgentRedeemScreen.txFlow.receiveTooltip(tokenName, URGENT_REDEMPTION_BONUS_PCT)}
+
+
+
+
+
+ {price.data && (
+
+ )}
+
+
+
+
+
+ {content.urgentRedeemScreen.bonusLabel(URGENT_REDEMPTION_BONUS_PCT)}
+
+
+
+
+ {price.data && bonus && (
+
+ )}
+
+
+
+
+
+ {content.urgentRedeemScreen.txFlow.trovesLabel}
+
+ {content.urgentRedeemScreen.txFlow.trovesTooltip}
+
+
+
+ {content.urgentRedeemScreen.txFlow.trovesValue(troveIds.length)}
+
+
+
+
+
+ {content.urgentRedeemScreen.slippageTolerance}
+
+ {content.urgentRedeemScreen.txFlow.slippageTooltip(
+
+
+
+
+
+ );
+ },
+
+ steps: {
+ approve: {
+ name: () => content.urgentRedeemScreen.txFlow.approveStep,
+ Status: (props) => (
+ troves: T[],
+ price: Dnum,
+): T[] {
+ return [...troves].sort((a, b) => {
+ return dn.cmp(
+ effectiveRedeemable(b, price),
+ effectiveRedeemable(a, price),
+ );
+ });
+}
+
+export function effectiveRedeemable(trove: { coll: Dnum; debt: Dnum }, price: Dnum): Dnum {
+ const collBold = dn.div(dn.mul(trove.coll, price), URGENT_REDEMPTION_BONUS_MULTIPLIER);
+ return dn.lt(trove.debt, collBold) ? trove.debt : collBold;
+}
+
+export function selectOptimalTroves(
+ troves: TroveWithICR[],
+ boldAmount: Dnum,
+ price: Dnum,
+): TroveSelectionResult {
+ const validTroves = troves.filter((trove) => dn.gt(trove.debt, DNUM_0));
+
+ const sortedTroves = sortByRedeemableValue(validTroves, price);
+
+ const selectedTroves: TroveWithICR[] = [];
+ let totalDebt = DNUM_0;
+ let totalColl = DNUM_0;
+ let totalRedeemable = DNUM_0;
+
+ for (const trove of sortedTroves) {
+ if (dn.gte(totalRedeemable, boldAmount)) {
+ break;
+ }
+ selectedTroves.push(trove);
+ totalDebt = dn.add(totalDebt, trove.debt);
+ totalColl = dn.add(totalColl, trove.coll);
+ totalRedeemable = dn.add(totalRedeemable, effectiveRedeemable(trove, price));
+ }
+
+ const actualBoldToRedeem = dn.lt(totalRedeemable, boldAmount) ? totalRedeemable : boldAmount;
+ const isAmountCapped = dn.lt(totalRedeemable, boldAmount);
+
+ return {
+ selectedTroves,
+ totalDebt,
+ totalColl,
+ actualBoldToRedeem,
+ isAmountCapped,
+ };
+}
+
+export type RedemptionOutput = {
+ collateral: Dnum;
+ collateralWithoutBonus: Dnum;
+ bonus: Dnum;
+ collateralUsd: Dnum;
+ bonusUsd: Dnum;
+};
+
+export function calculateRedemptionOutput(
+ selectedTroves: TroveWithICR[],
+ boldAmount: Dnum,
+ price: Dnum,
+): RedemptionOutput {
+ if (dn.eq(price, DNUM_0) || selectedTroves.length === 0) {
+ return {
+ collateral: DNUM_0,
+ collateralWithoutBonus: DNUM_0,
+ bonus: DNUM_0,
+ collateralUsd: DNUM_0,
+ bonusUsd: DNUM_0,
+ };
+ }
+
+ let totalCollateral = DNUM_0;
+ let remainingBold = boldAmount;
+
+ for (const trove of selectedTroves) {
+ if (dn.lte(remainingBold, DNUM_0)) break;
+
+ const boldFromTrove = dn.lt(trove.debt, remainingBold)
+ ? trove.debt
+ : remainingBold;
+
+ const collFromTrove = dn.div(dn.mul(boldFromTrove, URGENT_REDEMPTION_BONUS_MULTIPLIER), price);
+
+ if (dn.lt(collFromTrove, trove.coll)) {
+ totalCollateral = dn.add(totalCollateral, collFromTrove);
+ remainingBold = dn.sub(remainingBold, boldFromTrove);
+ } else {
+ totalCollateral = dn.add(totalCollateral, trove.coll);
+ remainingBold = dn.sub(remainingBold, dn.div(dn.mul(trove.coll, price), URGENT_REDEMPTION_BONUS_MULTIPLIER));
+ }
+ }
+
+ const collateralWithoutBonus = dn.div(dn.sub(boldAmount, remainingBold), price);
+ const bonus = dn.sub(totalCollateral, collateralWithoutBonus);
+
+ const collateralUsd = dn.mul(totalCollateral, price);
+ const bonusUsd = dn.mul(bonus, price);
+
+ return {
+ collateral: totalCollateral,
+ collateralWithoutBonus,
+ bonus,
+ collateralUsd,
+ bonusUsd,
+ };
+}
+
+export function calculateMinCollateral(
+ expectedColl: Dnum,
+ slippagePct: Dnum,
+): Dnum {
+ const slippageMultiplier = dn.sub(DNUM_1, slippagePct);
+ return dn.mul(expectedColl, slippageMultiplier);
+}