@gearbox-protocol/sdk 14.12.0-next.33 → 14.12.0-next.35

package/dist/cjs/sdk/accounts/liquidations/LiquidationsService.js

@@ -0,0 +1,207 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LiquidationsService_exports = {};
+__export(LiquidationsService_exports, {
+  LiquidationsService: () => LiquidationsService
+});
+module.exports = __toCommonJS(LiquidationsService_exports);
+var import_base = require("../../base/index.js");
+var import_constants = require("../../constants/index.js");
+var import_utils = require("../../utils/index.js");
+var import_helpers = require("./helpers.js");
+class LiquidationsService extends import_base.SDKConstruct {
+  /**
+   * {@inheritDoc ILiquidationsService.getLiquidatableAccounts}
+   **/
+  async getLiquidatableAccounts(props) {
+    if (props?.networks && !props.networks.includes(this.sdk.networkType)) {
+      return [];
+    }
+    await this.sdk.withdrawalCompressor?.loadWithdrawableAssets();
+    const accounts = await this.sdk.accounts.getCreditAccounts({
+      maxHealthFactor: import_constants.WAD - 1n,
+      includeZeroDebt: false
+    });
+    const seen = new import_utils.AddressSet(accounts.map((ca) => ca.creditAccount));
+    for (const ca of await this.#getExpiredCreditAccounts()) {
+      if (!seen.has(ca.creditAccount)) {
+        seen.add(ca.creditAccount);
+        accounts.push(ca);
+      }
+    }
+    const rows = [];
+    for (const ca of accounts) {
+      if (!ca.success) {
+        continue;
+      }
+      rows.push(this.#buildAccount(ca));
+    }
+    const allowedAssets = props?.assets?.length ? new import_utils.AddressSet(props.assets) : void 0;
+    return rows.filter((row) => {
+      if (props?.delayed !== void 0 && row.isDelayed !== props.delayed) {
+        return false;
+      }
+      if (allowedAssets && !allowedAssets.has(row.asset)) {
+        return false;
+      }
+      return true;
+    });
+  }
+  /**
+   * {@inheritDoc ILiquidationsService.getLiquidationDetails}
+   **/
+  async getLiquidationDetails(props) {
+    const { network, creditAccount } = props;
+    if (network !== this.sdk.networkType) {
+      throw new Error(
+        `network mismatch: this SDK is attached to ${this.sdk.networkType}, requested ${network}`
+      );
+    }
+    const ca = await this.sdk.accounts.getCreditAccountData(creditAccount);
+    if (!ca) {
+      throw new Error(`credit account ${creditAccount} not found`);
+    }
+    if (!ca.success) {
+      throw new Error(
+        `cannot compute liquidation details for ${creditAccount}: collateral computation failed`
+      );
+    }
+    const compressor = this.sdk.withdrawalCompressor;
+    await compressor?.loadWithdrawableAssets();
+    const account = this.#buildAccount(ca);
+    const receivedAssets = [];
+    for (const t of ca.tokens) {
+      if (t.balance > import_helpers.DUST_THRESHOLD && !compressor?.getWithdrawalSourceToken(t.token)) {
+        receivedAssets.push({
+          isDelayed: false,
+          token: t.token,
+          amount: t.balance
+        });
+      }
+    }
+    if (account.isDelayed && compressor) {
+      const { claimable, pending } = await compressor.getCurrentWithdrawals(creditAccount);
+      for (const w of claimable) {
+        for (const o of w.outputs) {
+          receivedAssets.push({
+            isDelayed: true,
+            token: o.token,
+            amount: o.amount,
+            sourceToken: w.token
+          });
+        }
+      }
+      for (const w of pending) {
+        for (const o of w.expectedOutputs) {
+          receivedAssets.push({
+            isDelayed: true,
+            token: o.token,
+            amount: o.amount,
+            sourceToken: w.token,
+            claimableAt: w.claimableAt
+          });
+        }
+      }
+    }
+    return { ...account, receivedAssets };
+  }
+  /**
+   * Accounts of expired credit managers with outstanding debt are liquidatable
+   * regardless of their health factor.
+   **/
+  async #getExpiredCreditAccounts() {
+    const expiredCMs = [];
+    for (const market of this.sdk.marketRegister.markets) {
+      if (market.pool.pool.totalBorrowed === 0n) {
+        continue;
+      }
+      for (const cm of market.creditManagers) {
+        const borrowed = market.pool.pool.creditManagerDebtParams.get(cm.creditManager.address)?.borrowed ?? 0n;
+        if (cm.isExpired && borrowed > 0n) {
+          expiredCMs.push(cm.creditManager.address);
+        }
+      }
+    }
+    if (expiredCMs.length === 0) {
+      return [];
+    }
+    this.logger?.debug(
+      `getting credit accounts of ${expiredCMs.length} expired credit managers`
+    );
+    const result = [];
+    for (const creditManager of expiredCMs) {
+      const accounts = await this.sdk.accounts.getCreditAccounts({
+        creditManager,
+        includeZeroDebt: false
+      });
+      result.push(...accounts);
+    }
+    return result;
+  }
+  /**
+   * Requires the compressor's withdrawable assets cache to be loaded
+   * (see `loadWithdrawableAssets`) so that phantom token lookups are sync.
+   **/
+  #buildAccount(ca) {
+    const compressor = this.sdk.withdrawalCompressor;
+    const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const market = suite.market;
+    const meta = this.sdk.tokensMeta.get(suite.underlying);
+    const unwrappedUnderlying = meta && this.sdk.tokensMeta.isRWAUnderlying(meta) ? meta.asset : suite.underlying;
+    const liquidationDiscount = suite.isExpired ? suite.creditManager.liquidationDiscountExpired : suite.creditManager.liquidationDiscount;
+    let asset = (0, import_helpers.pickMainAsset)(ca, (token, balance) => {
+      try {
+        return market.priceOracle.convert(token, market.underlying, balance);
+      } catch {
+        return 0n;
+      }
+    });
+    if (asset) {
+      asset = compressor?.getWithdrawalSourceToken(asset) ?? asset;
+    } else {
+      asset = unwrappedUnderlying;
+    }
+    return {
+      creditAccount: ca.creditAccount,
+      creditManager: ca.creditManager,
+      network: this.sdk.networkType,
+      asset,
+      totalValue: {
+        token: unwrappedUnderlying,
+        balance: ca.totalValue
+      },
+      totalValueUSD: ca.totalValueUSD,
+      repaymentAmount: {
+        token: unwrappedUnderlying,
+        balance: (0, import_helpers.calcRepaymentAmount)(ca.totalValue, liquidationDiscount)
+      },
+      estimatedProfit: {
+        token: unwrappedUnderlying,
+        balance: (0, import_helpers.calcEstimatedProfit)(ca.totalValue, liquidationDiscount)
+      },
+      isDelayed: ca.tokens.some(
+        (t) => t.balance > import_helpers.DUST_THRESHOLD && !!compressor?.getWithdrawalSourceToken(t.token)
+      )
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LiquidationsService
+});

package/dist/cjs/sdk/accounts/liquidations/MultichainLiquidationsService.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MultichainLiquidationsService_exports = {};
+__export(MultichainLiquidationsService_exports, {
+  MultichainLiquidationsService: () => MultichainLiquidationsService
+});
+module.exports = __toCommonJS(MultichainLiquidationsService_exports);
+class MultichainLiquidationsService {
+  #sdk;
+  constructor(sdk) {
+    this.#sdk = sdk;
+  }
+  /**
+   * {@inheritDoc ILiquidationsService.getLiquidatableAccounts}
+   **/
+  async getLiquidatableAccounts(props) {
+    const chains = [...this.#sdk.chains.entries()].filter(
+      ([network]) => !props?.networks || props.networks.includes(network)
+    );
+    const results = await Promise.allSettled(
+      chains.map(
+        ([, chainSdk]) => chainSdk.liquidations.getLiquidatableAccounts(props)
+      )
+    );
+    const accounts = [];
+    results.forEach((result, i) => {
+      const [network, chainSdk] = chains[i];
+      if (result.status === "fulfilled") {
+        accounts.push(...result.value);
+      } else {
+        chainSdk.logger?.warn(
+          result.reason,
+          `failed to get liquidatable accounts on ${network}`
+        );
+      }
+    });
+    return accounts;
+  }
+  /**
+   * {@inheritDoc ILiquidationsService.getLiquidationDetails}
+   **/
+  async getLiquidationDetails(props) {
+    return this.#sdk.chain(props.network).liquidations.getLiquidationDetails(props);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultichainLiquidationsService
+});

package/dist/cjs/sdk/accounts/liquidations/helpers.js

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var helpers_exports = {};
+__export(helpers_exports, {
+  DUST_THRESHOLD: () => DUST_THRESHOLD,
+  calcEstimatedProfit: () => calcEstimatedProfit,
+  calcRepaymentAmount: () => calcRepaymentAmount,
+  pickMainAsset: () => pickMainAsset
+});
+module.exports = __toCommonJS(helpers_exports);
+var import_constants = require("../../constants/index.js");
+var import_utils = require("../../utils/index.js");
+const DUST_THRESHOLD = 10n;
+function calcRepaymentAmount(totalValue, liquidationDiscount) {
+  return totalValue * BigInt(liquidationDiscount) / import_constants.PERCENTAGE_FACTOR;
+}
+function calcEstimatedProfit(totalValue, liquidationDiscount) {
+  return totalValue * (import_constants.PERCENTAGE_FACTOR - BigInt(liquidationDiscount)) / import_constants.PERCENTAGE_FACTOR;
+}
+function pickMainAsset(ca, convert) {
+  let bestValue = 0n;
+  let bestToken;
+  for (const t of ca.tokens) {
+    if ((0, import_utils.hexEq)(t.token, ca.underlying)) {
+      continue;
+    }
+    if ((t.mask & ca.enabledTokensMask) === 0n) {
+      continue;
+    }
+    if (t.balance <= DUST_THRESHOLD) {
+      continue;
+    }
+    const value = convert(t.token, t.balance);
+    if (value > bestValue) {
+      bestValue = value;
+      bestToken = t.token;
+    }
+  }
+  return bestToken;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DUST_THRESHOLD,
+  calcEstimatedProfit,
+  calcRepaymentAmount,
+  pickMainAsset
+});

package/dist/cjs/sdk/accounts/liquidations/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var liquidations_exports = {};
+module.exports = __toCommonJS(liquidations_exports);
+__reExport(liquidations_exports, require("./helpers.js"), module.exports);
+__reExport(liquidations_exports, require("./LiquidationsService.js"), module.exports);
+__reExport(liquidations_exports, require("./MultichainLiquidationsService.js"), module.exports);
+__reExport(liquidations_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./helpers.js"),
+  ...require("./LiquidationsService.js"),
+  ...require("./MultichainLiquidationsService.js"),
+  ...require("./types.js")
+});

package/dist/cjs/sdk/accounts/liquidations/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);