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

package/dist/esm/abi/IWithdrawalCompressorV313.js

@@ -79,6 +79,100 @@ const iWithdrawalCompressorV313Abi = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "getExternalAccountCurrentWithdrawals",
+    inputs: [
+      { name: "withdrawalToken", type: "address", internalType: "address" },
+      { name: "account", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct ClaimableWithdrawal[]",
+        components: [
+          { name: "token", type: "address", internalType: "address" },
+          {
+            name: "withdrawalPhantomToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "withdrawalTokenSpent",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "outputs",
+            type: "tuple[]",
+            internalType: "struct WithdrawalOutput[]",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "isDelayed", type: "bool", internalType: "bool" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          {
+            name: "claimCalls",
+            type: "tuple[]",
+            internalType: "struct MultiCall[]",
+            components: [
+              { name: "target", type: "address", internalType: "address" },
+              { name: "callData", type: "bytes", internalType: "bytes" }
+            ]
+          },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
+        ]
+      },
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct PendingWithdrawal[]",
+        components: [
+          { name: "token", type: "address", internalType: "address" },
+          {
+            name: "withdrawalPhantomToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "expectedOutputs",
+            type: "tuple[]",
+            internalType: "struct WithdrawalOutput[]",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "isDelayed", type: "bool", internalType: "bool" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          { name: "claimableAt", type: "uint256", internalType: "uint256" },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getWithdrawalStatus",
+    inputs: [{ name: "redeemer", type: "address", internalType: "address" }],
+    outputs: [
+      { name: "", type: "uint8", internalType: "enum WithdrawalStatus" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getWithdrawalStatus",
+    inputs: [
+      { name: "redeemers", type: "address[]", internalType: "address[]" }
+    ],
+    outputs: [
+      { name: "", type: "uint8[]", internalType: "enum WithdrawalStatus[]" }
+    ],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "getWithdrawableAssets",
@@ -152,6 +246,48 @@ const iWithdrawalCompressorV313Abi = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "getWithdrawalRequestResult",
+    inputs: [
+      { name: "creditAccount", type: "address", internalType: "address" },
+      { name: "token", type: "address", internalType: "address" },
+      { name: "withdrawalToken", type: "address", internalType: "address" },
+      { name: "amount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct RequestableWithdrawal",
+        components: [
+          { name: "token", type: "address", internalType: "address" },
+          { name: "amountIn", type: "uint256", internalType: "uint256" },
+          {
+            name: "outputs",
+            type: "tuple[]",
+            internalType: "struct WithdrawalOutput[]",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "isDelayed", type: "bool", internalType: "bool" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          {
+            name: "requestCalls",
+            type: "tuple[]",
+            internalType: "struct MultiCall[]",
+            components: [
+              { name: "target", type: "address", internalType: "address" },
+              { name: "callData", type: "bytes", internalType: "bytes" }
+            ]
+          },
+          { name: "claimableAt", type: "uint256", internalType: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "getWithdrawalRequestResult",

package/dist/esm/plugins/delayed-withdrawal/DelayedWithdrawalPlugin.js

@@ -1,16 +1,31 @@
 import { AddressMap, BasePlugin } from "../../sdk/index.js";
 const MAP_LABEL = "delayedWithdrawal";
 class DelayedWithdrawalPlugin extends BasePlugin {
-  #withdrawableAssets;
   async load(force) {
     if (!force && this.loaded) {
       return this.state;
     }
-    this.#withdrawableAssets = new AddressMap(void 0, MAP_LABEL);
-    const resp = await this.sdk.withdrawalCompressor.getWithdrawableAssetsBatch();
-    const byCreditManager = /* @__PURE__ */ new Map();
-    for (const cfg of resp) {
-      const assets = byCreditManager.get(cfg.creditManager) ?? [];
+    await this.sdk.withdrawalCompressor?.loadWithdrawableAssets(force);
+    return this.state;
+  }
+  get loaded() {
+    return !!this.sdk.withdrawalCompressor?.state;
+  }
+  /**
+   * Returns a map of cmAddress -> array of delayed assets
+   * @throws if withdrawable assets have not been loaded
+   */
+  get withdrawableAssets() {
+    const compressor = this.sdk.withdrawalCompressor;
+    if (!compressor?.state) {
+      throw new Error("withdrawable assets are not loaded");
+    }
+    const result = new AddressMap(
+      void 0,
+      MAP_LABEL
+    );
+    for (const cfg of compressor.getWithdrawableAssets()) {
+      const assets = result.get(cfg.creditManager) ?? [];
       assets.push({
         ...cfg,
         disabled: isConfigToOmit({
@@ -20,25 +35,9 @@ class DelayedWithdrawalPlugin extends BasePlugin {
           underlying: cfg.underlying
         })
       });
-      byCreditManager.set(cfg.creditManager, assets);
-    }
-    for (const [creditManager, assets] of byCreditManager) {
-      this.#withdrawableAssets.upsert(creditManager, assets);
+      result.upsert(cfg.creditManager, assets);
     }
-    return this.state;
-  }
-  get loaded() {
-    return !!this.#withdrawableAssets;
-  }
-  /**
-   * Returns a map of cmAddress -> array of delayed assets
-   * @throws if plugin is not attached
-   */
-  get withdrawableAssets() {
-    if (!this.#withdrawableAssets) {
-      throw new Error("withdrawable assets plugin not attached");
-    }
-    return this.#withdrawableAssets;
+    return result;
   }
   stateHuman(_) {
     return this.withdrawableAssets.values().flatMap((cm) => {
@@ -53,15 +52,7 @@ class DelayedWithdrawalPlugin extends BasePlugin {
     });
   }
   get state() {
-    return {
-      withdrawableAssets: this.withdrawableAssets.asRecord()
-    };
-  }
-  hydrate(state) {
-    this.#withdrawableAssets = new AddressMap(
-      Object.entries(state.withdrawableAssets),
-      MAP_LABEL
-    );
+    return {};
   }
 }
 function getConfigKey(config) {

package/dist/esm/sdk/MultichainSDK.js

@@ -1,3 +1,4 @@
+import { MultichainLiquidationsService } from "./accounts/index.js";
 import { getNetworkType } from "./chain/chains.js";
 import {
   SdkMissingChainStateError,
@@ -16,6 +17,11 @@ class MultichainSDK {
   #redstoneCache;
   #pythCache;
   #logger;
+  /**
+   * Namespace for liquidatable credit accounts discovery across all
+   * configured chains.
+   */
+  liquidations;
   constructor(options) {
     this.#chains = /* @__PURE__ */ new Map();
     this.#logger = options.logger;
@@ -43,6 +49,7 @@ class MultichainSDK {
       );
       this.#chains.set(network, sdk);
     }
+    this.liquidations = new MultichainLiquidationsService(this);
   }
   /**
    * Attach all configured chains in parallel.

package/dist/esm/sdk/OnchainSDK.js

@@ -6,7 +6,8 @@ import {
 } from "viem";
 import {
   CreditAccountsServiceV310,
-  createWithdrawalCompressor
+  createWithdrawalCompressor,
+  LiquidationsService
 } from "./accounts/index.js";
 import { ChainContractsRegister } from "./base/index.js";
 import { getChain } from "./chain/index.js";
@@ -67,6 +68,7 @@ class OnchainSDK extends ChainContractsRegister {
   #rwa;
   #marketRegister;
   #priceFeeds;
+  #withdrawalCompressor;
   /**
    * Gas limit applied to read-only `eth_call` requests.
    **/
@@ -83,6 +85,10 @@ class OnchainSDK extends ChainContractsRegister {
    * Namespace for pool operations.
    */
   pools;
+  /**
+   * Namespace for liquidatable credit accounts discovery.
+   */
+  liquidations;
   /**
    * @param network - Gearbox network type (e.g. `"Mainnet"`, `"Monad"`).
    * @param clientOptions - Connection options (RPC URLs, transport, or client).
@@ -109,6 +115,8 @@ class OnchainSDK extends ChainContractsRegister {
     }
     this.accounts = new CreditAccountsServiceV310(this);
     this.pools = new PoolService(this);
+    this.liquidations = new LiquidationsService(this);
+    this.#withdrawalCompressor = createWithdrawalCompressor(this);
   }
   /**
    * Initialises the SDK by reading live on-chain state.
@@ -255,6 +263,9 @@ class OnchainSDK extends ChainContractsRegister {
     this.#marketRegister.hydrate(state);
     this.#rwa = new RWARegistry(this);
     this.#rwa.setState(state.rwa);
+    if (state.withdrawals) {
+      this.#withdrawalCompressor?.hydrate(state.withdrawals);
+    }
     for (const [name, plugin] of TypedObjectUtils.entries(this.plugins)) {
       const pluginState = state.plugins[name];
       if (plugin.hydrate && pluginState) {
@@ -319,6 +330,7 @@ class OnchainSDK extends ChainContractsRegister {
       addressProvider: this.addressProvider.state,
       ...this.marketRegister.state,
       rwa: this.#rwa.state,
+      withdrawals: this.#withdrawalCompressor?.state,
       plugins: Object.fromEntries(
         TypedObjectUtils.entries(this.plugins).map(([name, plugin]) => [
           name,
@@ -536,12 +548,11 @@ class OnchainSDK extends ChainContractsRegister {
     return createRouter(this, routerAddr, routerV);
   }
   /**
-   * Lazily returns a withdrawal compressor contract for the current chain.
-   *
-   * @throws If no withdrawal compressor is supported on the current chain.
+   * Withdrawal compressor contract for the current chain, or `undefined`
+   * when no withdrawal compressor is supported on it.
    **/
   get withdrawalCompressor() {
-    return createWithdrawalCompressor(this);
+    return this.#withdrawalCompressor;
   }
 }
 export {

package/dist/esm/sdk/accounts/CreditAccountsServiceV310.js

@@ -767,14 +767,16 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     creditAccount,
     amount,
     token,
+    withdrawalPhantomToken,
     intent
   }) {
-    return this.sdk.withdrawalCompressor.getWithdrawalRequestResult(
+    return this.#withdrawalCompressor.getWithdrawalRequestResult({
       creditAccount,
       token,
       amount,
+      withdrawalPhantomToken,
       intent
-    );
+    });
   }
   /**
    * {@inheritDoc ICreditAccountsService.getPendingWithdrawals}
@@ -782,7 +784,7 @@ class CreditAccountsServiceV310 extends SDKConstruct {
   async getPendingWithdrawals({
     creditAccount
   }) {
-    const { claimable, pending } = await this.sdk.withdrawalCompressor.getCurrentWithdrawals(creditAccount);
+    const { claimable, pending } = await this.#withdrawalCompressor.getCurrentWithdrawals(creditAccount);
     return {
       claimableNow: claimable,
       pending
@@ -1849,6 +1851,17 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     }
     return suite.creditFacade.multicall(creditAccount, calls);
   }
+  /**
+   * Withdrawal compressor of the current chain.
+   * @throws If no withdrawal compressor is supported on the current chain.
+   **/
+  get #withdrawalCompressor() {
+    const compressor = this.sdk.withdrawalCompressor;
+    if (!compressor) {
+      throw new Error(`no withdrawal compressor on ${this.sdk.networkType}`);
+    }
+    return compressor;
+  }
 }
 export {
   CreditAccountsServiceV310

package/dist/esm/sdk/accounts/index.js

@@ -1,3 +1,4 @@
 export * from "./CreditAccountsServiceV310.js";
+export * from "./liquidations/index.js";
 export * from "./types.js";
 export * from "./withdrawal-compressor/index.js";

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

@@ -0,0 +1,188 @@
+import { SDKConstruct } from "../../base/index.js";
+import { WAD } from "../../constants/index.js";
+import { AddressSet } from "../../utils/index.js";
+import {
+  calcEstimatedProfit,
+  calcRepaymentAmount,
+  DUST_THRESHOLD,
+  pickMainAsset
+} from "./helpers.js";
+class LiquidationsService extends 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: WAD - 1n,
+      includeZeroDebt: false
+    });
+    const seen = new 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 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 > 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 = 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: calcRepaymentAmount(ca.totalValue, liquidationDiscount)
+      },
+      estimatedProfit: {
+        token: unwrappedUnderlying,
+        balance: calcEstimatedProfit(ca.totalValue, liquidationDiscount)
+      },
+      isDelayed: ca.tokens.some(
+        (t) => t.balance > DUST_THRESHOLD && !!compressor?.getWithdrawalSourceToken(t.token)
+      )
+    };
+  }
+}
+export {
+  LiquidationsService
+};

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

@@ -0,0 +1,41 @@
+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);
+  }
+}
+export {
+  MultichainLiquidationsService
+};

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

@@ -0,0 +1,36 @@
+import { PERCENTAGE_FACTOR } from "../../constants/index.js";
+import { hexEq } from "../../utils/index.js";
+const DUST_THRESHOLD = 10n;
+function calcRepaymentAmount(totalValue, liquidationDiscount) {
+  return totalValue * BigInt(liquidationDiscount) / PERCENTAGE_FACTOR;
+}
+function calcEstimatedProfit(totalValue, liquidationDiscount) {
+  return totalValue * (PERCENTAGE_FACTOR - BigInt(liquidationDiscount)) / PERCENTAGE_FACTOR;
+}
+function pickMainAsset(ca, convert) {
+  let bestValue = 0n;
+  let bestToken;
+  for (const t of ca.tokens) {
+    if (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;
+}
+export {
+  DUST_THRESHOLD,
+  calcEstimatedProfit,
+  calcRepaymentAmount,
+  pickMainAsset
+};

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

@@ -0,0 +1,4 @@
+export * from "./helpers.js";
+export * from "./LiquidationsService.js";
+export * from "./MultichainLiquidationsService.js";
+export * from "./types.js";