feat: debt-only full liquidation

doomsower · doomsower · commit 36062723417d · 2025-12-05T14:17:33.000-03:00
diff --git a/src/sdk/accounts/AbstractCreditAccountsService.ts b/src/sdk/accounts/AbstractCreditAccountsService.ts
@@ -362,6 +362,7 @@ export abstract class AbstractCreditAccountService extends SDKConstruct {
       keepAssets,
       ignoreReservePrices,
       applyLossPolicy,
+      debtOnly,
     } = props;
     const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
     const routerCloseResult = await this.sdk
@@ -372,6 +373,7 @@ export abstract class AbstractCreditAccountService extends SDKConstruct {
         slippage,
         force,
         keepAssets,
+        debtOnly,
       });
     const priceUpdates = await this.getPriceUpdatesForFacade({
       creditManager: account.creditManager,
diff --git a/src/sdk/accounts/types.ts b/src/sdk/accounts/types.ts
@@ -407,6 +407,10 @@ export interface FullyLiquidateProps {
    * If true, will try to apply loss policy
    */
   applyLossPolicy?: boolean;
+  /**
+   * Debt only mode - will try to sell just enought of most valuable token to cover debt
+   */
+  debtOnly?: boolean;
 }
 
 export interface PermitResult {
diff --git a/src/sdk/router/AbstractRouterContract.ts b/src/sdk/router/AbstractRouterContract.ts
@@ -1,12 +1,15 @@
 import type { Abi, Address } from "viem";
 
 import { BaseContract } from "../base/index.js";
-import { AddressMap, isDust } from "../utils/index.js";
+import { PERCENTAGE_FACTOR } from "../constants/math.js";
+import type { IPriceOracleContract } from "../market/index.js";
+import { AddressMap, AddressSet, formatBN, isDust } from "../utils/index.js";
 import type { IHooks } from "../utils/internal/index.js";
 import { Hooks } from "../utils/internal/index.js";
 import { limitLeftover } from "./helpers.js";
 import type {
   Asset,
+  ExpectedAndLeftoverOptions,
   RouterCASlice,
   RouterCMSlice,
   RouterHooks,
@@ -32,10 +35,15 @@ export abstract class AbstractRouterContract<
   protected getExpectedAndLeftover(
     ca: RouterCASlice,
     cm: RouterCMSlice,
-    balances?: Leftovers,
-    keepAssets?: Address[],
+    options: ExpectedAndLeftoverOptions = {},
   ): Leftovers {
-    const b = balances || this.getDefaultExpectedAndLeftover(ca, keepAssets);
+    const b = options.balances
+      ? options.balances
+      : this.getDefaultExpectedAndLeftover(
+          ca,
+          options.keepAssets,
+          options.debtOnly,
+        );
     const { leftoverBalances, expectedBalances, tokensToClaim } = b;
 
     const expected: AddressMap<Asset> = new AddressMap<Asset>();
@@ -65,18 +73,28 @@ export abstract class AbstractRouterContract<
   protected getDefaultExpectedAndLeftover(
     ca: RouterCASlice,
     keepAssets?: Address[],
+    debtOnly?: boolean,
   ): Leftovers {
     const expectedBalances = new AddressMap<Asset>();
     const leftoverBalances = new AddressMap<Asset>();
-    const keepAssetsSet = new Set(keepAssets?.map(a => a.toLowerCase()));
-    for (const { token: t, balance, mask } of ca.tokens) {
-      const token = t as Address;
+    const keepAssetsSet = new AddressSet(keepAssets);
+
+    if (debtOnly) {
+      const result = this.getLeftoversAfterBuyingDebt(ca, keepAssetsSet);
+      if (result) {
+        return result;
+      } else {
+        this.logger?.warn("no token found to cover debt");
+      }
+    }
+
+    for (const { token, balance, mask } of ca.tokens) {
       const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
       expectedBalances.upsert(token, { token, balance });
       // filter out dust, we don't want to swap it
       // also: gearbox liquidator does not need to swap disabled tokens. third-party liquidators might want to do it
       if (
-        keepAssetsSet.has(token.toLowerCase()) ||
+        keepAssetsSet.has(token) ||
         !isEnabled ||
         isDust({
           sdk: this.sdk,
@@ -98,4 +116,124 @@ export abstract class AbstractRouterContract<
       tokensToClaim: new AddressMap<Asset>(),
     };
   }
+
+  /**
+   * Tries to sell just enought of most valuable token to cover debt
+   * @param ca
+   * @param keepAssets
+   * @returns
+   */
+  protected getLeftoversAfterBuyingDebt(
+    ca: RouterCASlice,
+    keepAssets: AddressSet,
+  ): Leftovers | undefined {
+    const { priceOracle } = this.sdk.marketRegister.findByCreditManager(
+      ca.creditManager,
+    );
+
+    const expectedBalances = new AddressMap<Asset>();
+    const leftoverBalances = new AddressMap<Asset>();
+    const usdBalances: Asset[] = [];
+
+    for (const { token, balance, mask } of ca.tokens) {
+      const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
+      expectedBalances.upsert(token, { token, balance });
+      leftoverBalances.upsert(token, {
+        token,
+        balance: limitLeftover(balance, token) ?? balance,
+      });
+      if (isEnabled && !keepAssets.has(token)) {
+        usdBalances.push({
+          token,
+          balance: this.safeConvertToUSD(priceOracle, token, balance),
+        });
+      }
+    }
+
+    usdBalances.sort((a, b) => {
+      if (a.balance > b.balance) return -1;
+      if (a.balance < b.balance) return 1;
+      return 0;
+    });
+
+    if (usdBalances.length === 0) {
+      return undefined;
+    }
+
+    // found token with highest balance in USD which is not in keepAssets and is enabled
+    const highestToken = usdBalances[0];
+    const lt = this.sdk.marketRegister
+      .findCreditManager(ca.creditManager)
+      .creditManager.liquidationThresholds.mustGet(highestToken.token);
+    const requiredDebtUSD = (ca.totalDebtUSD * PERCENTAGE_FACTOR) / BigInt(lt);
+
+    if (highestToken.balance < requiredDebtUSD) {
+      return undefined;
+    }
+    const tokenAmount = this.safeConvertFromUSD(
+      priceOracle,
+      highestToken.token,
+      requiredDebtUSD,
+    );
+    if (tokenAmount === 0n) {
+      return undefined;
+    }
+    let leftoverBalance =
+      leftoverBalances.get(highestToken.token)?.balance ?? 0n;
+    leftoverBalance -= tokenAmount;
+    if (leftoverBalance < 0n) {
+      return undefined;
+    }
+    leftoverBalances.upsert(highestToken.token, {
+      token: highestToken.token,
+      balance: leftoverBalance,
+    });
+    const tokenAmountStr = this.sdk.tokensMeta.formatBN(
+      highestToken.token,
+      tokenAmount,
+      { symbol: true },
+    );
+    const totalDebtUSDStr = formatBN(ca.totalDebtUSD, 8);
+    this.logger?.debug(
+      `will sell ${tokenAmountStr} (LT=${lt}) to cover debt of ${totalDebtUSDStr} USD`,
+    );
+
+    return {
+      expectedBalances,
+      leftoverBalances,
+      tokensToClaim: new AddressMap<Asset>(),
+    };
+  }
+
+  protected safeConvertToUSD(
+    priceOracle: IPriceOracleContract,
+    token: Address,
+    balance: bigint,
+  ): bigint {
+    try {
+      return priceOracle.convertToUSD(token, balance);
+    } catch {
+      try {
+        return priceOracle.convertToUSD(token, balance, true);
+      } catch {
+        return 0n;
+      }
+    }
+  }
+
+  protected safeConvertFromUSD(
+    priceOracle: IPriceOracleContract,
+    token: Address,
+    balance: bigint,
+  ): bigint {
+    try {
+      return priceOracle.convertFromUSD(token, balance);
+    } catch {
+      try {
+        return priceOracle.convertFromUSD(token, balance, true);
+      } catch {
+        return 0n;
+      }
+    }
+  }
 }
diff --git a/src/sdk/router/RouterV300Contract.ts b/src/sdk/router/RouterV300Contract.ts
@@ -20,6 +20,7 @@ import {
 import { PathOptionFactory } from "./PathOptionFactory.js";
 import type {
   Asset,
+  ExpectedAndLeftoverOptions,
   FindAllSwapsProps,
   FindBestClosePathProps,
   FindClaimAllRewardsProps,
@@ -256,23 +257,23 @@ export class RouterV300Contract
     creditManager: cm,
     slippage,
     balances,
+    debtOnly,
   }: FindBestClosePathProps): Promise<RouterCloseResult> {
     const {
       pathOptions,
       expected,
       leftover: leftoverUnsafe,
       connectors,
-    } = this.getFindClosePathInput(
-      ca,
-      cm,
-      balances
+    } = this.getFindClosePathInput(ca, cm, {
+      balances: balances
         ? {
             expectedBalances: assetsMap(balances.expectedBalances),
             leftoverBalances: assetsMap(balances.leftoverBalances),
             tokensToClaim: assetsMap(balances.tokensToClaim || []),
           }
         : undefined,
-    );
+      debtOnly,
+    });
 
     const leftover: Array<Asset> = leftoverUnsafe.map(a => ({
       ...a,
@@ -351,14 +352,12 @@ export class RouterV300Contract
   public getFindClosePathInput(
     ca: RouterCASlice,
     cm: RouterCMSlice,
-    balances?: Leftovers,
-    keepAssets?: Address[],
+    options?: ExpectedAndLeftoverOptions,
   ): FindClosePathInput {
     const { expectedBalances, leftoverBalances } = this.getExpectedAndLeftover(
       ca,
       cm,
-      balances,
-      keepAssets,
+      options,
     );
 
     const leftover: Array<Asset> = leftoverBalances.values().map(a => ({
diff --git a/src/sdk/router/RouterV310Contract.ts b/src/sdk/router/RouterV310Contract.ts
@@ -11,6 +11,7 @@ import { AbstractRouterContract } from "./AbstractRouterContract.js";
 import { assetsMap, balancesMap, limitLeftover } from "./helpers.js";
 import type {
   Asset,
+  ExpectedAndLeftoverOptions,
   FindAllSwapsProps,
   FindBestClosePathProps,
   FindClaimAllRewardsProps,
@@ -213,20 +214,20 @@ export class RouterV310Contract
       slippage,
       balances,
       keepAssets,
+      debtOnly,
     } = props;
     const { expectedBalances, leftoverBalances, tokensToClaim } =
-      this.getExpectedAndLeftover(
-        ca,
-        cm,
-        balances
+      this.getExpectedAndLeftover(ca, cm, {
+        balances: balances
           ? {
               expectedBalances: assetsMap(balances.expectedBalances),
               leftoverBalances: assetsMap(balances.leftoverBalances),
               tokensToClaim: assetsMap(balances.tokensToClaim || []),
             }
           : undefined,
-        keepAssets,
-      );
+        keepAssets: balances ? undefined : keepAssets,
+        debtOnly,
+      });
 
     const getNumSplits = this.#numSplitsGetter(cm, expectedBalances.values());
     const tData: TokenData[] = [];
@@ -421,7 +422,7 @@ export class RouterV310Contract
   public getFindClosePathInput(
     _: RouterCASlice,
     __: RouterCMSlice,
-    ___?: Leftovers,
+    ___?: ExpectedAndLeftoverOptions,
   ): FindClosePathInput {
     throw ERR_NOT_IMPLEMENTED;
   }
diff --git a/src/sdk/router/types.ts b/src/sdk/router/types.ts
@@ -101,6 +101,7 @@ export type RouterCASlice = Pick<
   | "creditAccount"
   | "creditFacade"
   | "debt"
+  | "totalDebtUSD"
   | "creditManager"
 >;
 
@@ -246,6 +247,10 @@ export interface FindBestClosePathProps {
    * TODO: legacy v3 option to pass to contract
    */
   force?: boolean;
+  /**
+   * Debt only mode - will try to sell just enought of most valuable token to cover debt
+   */
+  debtOnly?: boolean;
 }
 
 export interface ClosePathBalances {
@@ -267,6 +272,12 @@ export interface ClosePathBalances {
   tokensToClaim?: Array<Asset>;
 }
 
+export interface ExpectedAndLeftoverOptions {
+  balances?: Leftovers;
+  keepAssets?: Address[];
+  debtOnly?: boolean;
+}
+
 export interface IRouterContract extends IBaseContract {
   /**
    * Find the best path to swap token A to token B (target token).
@@ -331,15 +342,13 @@ export interface IRouterContract extends IBaseContract {
    *
    * @param ca
    * @param cm
-   * @param balances
-   * @param keepAssets
+   * @param options
    * @returns
    */
   getFindClosePathInput: (
     ca: RouterCASlice,
     cm: RouterCMSlice,
-    balances?: Leftovers,
-    keepAssets?: Address[],
+    options?: ExpectedAndLeftoverOptions,
   ) => FindClosePathInput;
 }
 
