@gearbox-protocol/sdk 14.12.0-next.4 → 14.12.0-next.41

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

@@ -0,0 +1,210 @@
+import { SDKConstruct } from "../../base/index.js";
+import { WAD } from "../../constants/index.js";
+import { AddressSet } from "../../utils/index.js";
+import {
+  calcEstimatedProfit,
+  calcRepaymentAmount,
+  DUST_THRESHOLD,
+  pickMainAsset,
+  toLiquidatorWithdrawals
+} 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 };
+  }
+  /**
+   * {@inheritDoc ILiquidationsService.getLiquidatorWithdrawals}
+   **/
+  async getLiquidatorWithdrawals(props) {
+    if (props.networks && !props.networks.includes(this.sdk.networkType)) {
+      return [];
+    }
+    const compressor = this.sdk.withdrawalCompressor;
+    if (!compressor) {
+      return [];
+    }
+    await compressor.loadWithdrawableAssets();
+    const phantomTokens = new AddressSet(
+      compressor.getWithdrawableAssets().map((a) => a.withdrawalPhantomToken)
+    );
+    const current = await compressor.getExternalAccountCurrentWithdrawals(
+      props.liquidator,
+      ...phantomTokens.asArray()
+    );
+    return toLiquidatorWithdrawals(current, this.sdk.networkType);
+  }
+  /**
+   * 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,67 @@
+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);
+  }
+  /**
+   * {@inheritDoc ILiquidationsService.getLiquidatorWithdrawals}
+   **/
+  async getLiquidatorWithdrawals(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.getLiquidatorWithdrawals(props)
+      )
+    );
+    const withdrawals = [];
+    results.forEach((result, i) => {
+      const [network, chainSdk] = chains[i];
+      if (result.status === "fulfilled") {
+        withdrawals.push(...result.value);
+      } else {
+        chainSdk.logger?.warn(
+          result.reason,
+          `failed to get liquidator withdrawals on ${network}`
+        );
+      }
+    });
+    return withdrawals;
+  }
+}
+export {
+  MultichainLiquidationsService
+};

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

@@ -0,0 +1,62 @@
+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;
+}
+function toLiquidatorWithdrawals(current, network) {
+  const rows = [];
+  for (const w of current.claimable) {
+    for (const o of w.outputs) {
+      rows.push({
+        network,
+        sourceToken: w.token,
+        token: o.token,
+        amount: o.amount
+      });
+    }
+  }
+  for (const w of current.pending) {
+    for (const o of w.expectedOutputs) {
+      rows.push({
+        network,
+        sourceToken: w.token,
+        token: o.token,
+        amount: o.amount,
+        claimableAt: w.claimableAt
+      });
+    }
+  }
+  return rows;
+}
+export {
+  DUST_THRESHOLD,
+  calcEstimatedProfit,
+  calcRepaymentAmount,
+  pickMainAsset,
+  toLiquidatorWithdrawals
+};

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";

package/dist/esm/sdk/accounts/withdrawal-compressor/AbstractWithdrawalCompressorContract.js

@@ -0,0 +1,264 @@
+import { isAddressEqual } from "viem";
+import { BaseContract } from "../../base/index.js";
+import { AddressMap } from "../../utils/index.js";
+import { decodeDelayedIntent } from "./intent-codec.js";
+const iCreditAccountAbi = [
+  {
+    type: "function",
+    name: "creditManager",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  }
+];
+const MAP_LABEL = "withdrawableAssets";
+class AbstractWithdrawalCompressorContract extends BaseContract {
+  #sdk;
+  #withdrawableAssets;
+  constructor(sdk, args) {
+    super(sdk, args);
+    this.#sdk = sdk;
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.hydrate}
+   **/
+  hydrate(state) {
+    this.#withdrawableAssets = new AddressMap(
+      Object.entries(state.withdrawableAssets),
+      MAP_LABEL
+    );
+  }
+  /**
+   * The contract is instantiated with the actual versioned ABI,
+   * this cast is type-level only (see {@link CommonAbi}).
+   **/
+  get common() {
+    return this.contract;
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.state}
+   **/
+  get state() {
+    return this.#withdrawableAssets ? { withdrawableAssets: this.#withdrawableAssets.asRecord() } : void 0;
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawableAssets}
+   **/
+  getWithdrawableAssets(...creditManagers) {
+    const cache = this.#withdrawableAssets;
+    if (!cache) {
+      throw new Error(
+        "withdrawable assets are not loaded, call loadWithdrawableAssets first"
+      );
+    }
+    if (creditManagers.length === 0) {
+      return cache.values().flat();
+    }
+    return creditManagers.flatMap((cm) => cache.get(cm) ?? []);
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.loadWithdrawableAssets}
+   **/
+  async loadWithdrawableAssets(force) {
+    if (this.#withdrawableAssets && !force) {
+      return this.getWithdrawableAssets();
+    }
+    const cms = this.#sdk.marketRegister.creditManagers.map(
+      (cm) => cm.creditManager.address
+    );
+    const resp = await this.client.multicall({
+      contracts: cms.map(
+        (cm) => ({
+          address: this.address,
+          abi: this.abi,
+          functionName: "getWithdrawableAssets",
+          args: [cm]
+        })
+      ),
+      allowFailure: true,
+      batchSize: 0
+    });
+    const cache = new AddressMap(void 0, MAP_LABEL);
+    for (let i = 0; i < resp.length; i++) {
+      const r = resp[i];
+      if (r.status !== "success") {
+        this.logger?.warn(
+          `failed to get withdrawable assets of credit manager ${cms[i]}: ${r.error}`
+        );
+        continue;
+      }
+      if (r.result.length > 0) {
+        cache.upsert(
+          cms[i],
+          r.result.map((a) => toWithdrawableAsset(a, cms[i]))
+        );
+      }
+    }
+    this.#withdrawableAssets = cache;
+    return this.getWithdrawableAssets();
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.findWithdrawableAssets}
+   **/
+  async findWithdrawableAssets(creditManager, token) {
+    await this.loadWithdrawableAssets();
+    return this.getWithdrawableAssets(creditManager).filter(
+      (a) => isAddressEqual(a.token, token)
+    );
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.findWithdrawableAssetsByPhantomToken}
+   **/
+  async findWithdrawableAssetsByPhantomToken(withdrawalPhantomToken) {
+    await this.loadWithdrawableAssets();
+    return this.getWithdrawableAssets().filter(
+      (a) => isAddressEqual(a.withdrawalPhantomToken, withdrawalPhantomToken)
+    );
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalPhantomToken}
+   **/
+  async getWithdrawalPhantomToken(creditManager, token) {
+    const [asset] = await this.findWithdrawableAssets(creditManager, token);
+    if (!asset) {
+      throw new Error(
+        `token ${token} is not withdrawable from credit manager ${creditManager}`
+      );
+    }
+    return asset.withdrawalPhantomToken;
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalSourceToken}
+   **/
+  getWithdrawalSourceToken(withdrawalPhantomToken) {
+    return this.getWithdrawableAssets().find(
+      (a) => isAddressEqual(a.withdrawalPhantomToken, withdrawalPhantomToken)
+    )?.token;
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getCurrentWithdrawals}
+   **/
+  async getCurrentWithdrawals(creditAccount) {
+    const [[claimable, pending], creditManager] = await this.client.multicall({
+      contracts: [
+        {
+          address: this.address,
+          abi: this.abi,
+          functionName: "getCurrentWithdrawals",
+          args: [creditAccount]
+        },
+        {
+          address: creditAccount,
+          abi: iCreditAccountAbi,
+          functionName: "creditManager"
+        }
+      ],
+      allowFailure: false,
+      batchSize: 0
+    });
+    return {
+      claimable: claimable.map((w) => toClaimableWithdrawal(w, creditManager)),
+      pending: pending.map((w) => toPendingWithdrawal(w, creditManager)).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
+    };
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getExternalAccountCurrentWithdrawals}
+   **/
+  async getExternalAccountCurrentWithdrawals(_account, ..._withdrawalTokens) {
+    this.#reportUnsupported("external account withdrawals");
+    return { claimable: [], pending: [] };
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalStatus}
+   **/
+  async getWithdrawalStatus(...redeemers) {
+    if (redeemers.length === 0) {
+      return [];
+    }
+    this.#reportUnsupported("withdrawal status");
+    return redeemers.map(() => "NULL");
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalRequestResult}
+   *
+   * Legacy compressors only support the 3-arg overload: `intent` and
+   * `withdrawalPhantomToken` are reported as unsupported (in non-strict mode
+   * the request is previewed without them).
+   **/
+  async getWithdrawalRequestResult({
+    creditAccount,
+    token,
+    amount,
+    withdrawalPhantomToken,
+    intent
+  }) {
+    if (intent) {
+      this.#reportUnsupported("withdrawal intents");
+    } else if (withdrawalPhantomToken) {
+      this.#reportUnsupported("withdrawal config selection");
+    }
+    const resp = await this.common.read.getWithdrawalRequestResult([
+      creditAccount,
+      token,
+      amount
+    ]);
+    return toRequestableWithdrawal(resp);
+  }
+  /**
+   * Reports that a feature is not supported by this compressor version:
+   * throws if `sdk.strictContractTypes` is `true`, otherwise logs a warning.
+   **/
+  #reportUnsupported(feature) {
+    const message = `${feature} is not supported by ${this.name} v${this.version}`;
+    if (this.#sdk.strictContractTypes) {
+      throw new Error(message);
+    }
+    this.logger?.warn(message);
+  }
+}
+function toWithdrawableAsset(a, creditManager) {
+  return { creditManager, ...a };
+}
+function toRequestableWithdrawal(resp) {
+  return {
+    token: resp.token,
+    amountIn: resp.amountIn,
+    outputs: [...resp.outputs],
+    requestCalls: [...resp.requestCalls],
+    claimableAt: resp.claimableAt
+  };
+}
+function toClaimableWithdrawal(w, creditManager) {
+  let intent;
+  if (creditManager && w.extraData && w.extraData !== "0x") {
+    intent = { ...decodeDelayedIntent(w.extraData), creditManager };
+  }
+  return {
+    token: w.token,
+    withdrawalPhantomToken: w.withdrawalPhantomToken,
+    withdrawalTokenSpent: w.withdrawalTokenSpent,
+    outputs: [...w.outputs],
+    claimCalls: [...w.claimCalls],
+    intent
+  };
+}
+function toPendingWithdrawal(w, creditManager) {
+  let intent;
+  if (creditManager && w.extraData && w.extraData !== "0x") {
+    intent = { ...decodeDelayedIntent(w.extraData), creditManager };
+  }
+  return {
+    token: w.token,
+    withdrawalPhantomToken: w.withdrawalPhantomToken,
+    expectedOutputs: [...w.expectedOutputs],
+    claimableAt: w.claimableAt,
+    intent
+  };
+}
+export {
+  AbstractWithdrawalCompressorContract,
+  iCreditAccountAbi,
+  toClaimableWithdrawal,
+  toPendingWithdrawal,
+  toRequestableWithdrawal
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/RedemptionLoggerV310Contract.js

@@ -0,0 +1,48 @@
+import { iRedemptionLoggerV310Abi } from "../../../abi/iRedemptionLoggerV310.js";
+import { BaseContract } from "../../base/index.js";
+import { InvalidDelayedIntentError } from "./errors.js";
+import { decodeDelayedIntent } from "./intent-codec.js";
+const abi = iRedemptionLoggerV310Abi;
+class RedemptionLoggerV310Contract extends BaseContract {
+  constructor(sdk, address, version) {
+    super(sdk, {
+      addr: address,
+      name: "RedemptionLogger",
+      abi,
+      version
+    });
+  }
+  /**
+   * Returns the redemption data logged for a redeemer; all-zero fields when
+   * nothing was logged for it.
+   **/
+  async getRedemptionLog(redeemer, blockNumber) {
+    return this.contract.read.redemptionLogs([redeemer], {
+      blockNumber
+    });
+  }
+  /**
+   * Reads the redemption log of a redeemer and decodes the recorded intent.
+   *
+   * @param redeemer - Redeemer contract the withdrawal is claimed from.
+   * @param blockNumber - Optional block number to read the log at.
+   * @returns The decoded intent, or `undefined` when the log carries none
+   * (including when nothing was logged for the redeemer).
+   * @throws InvalidDelayedIntentError when the logged `extraData` is
+   * non-empty but cannot be decoded as a `DelayedIntent`.
+   **/
+  async getDelayedIntent(redeemer, blockNumber) {
+    const log = await this.getRedemptionLog(redeemer, blockNumber);
+    if (!log.extraData || log.extraData === "0x") {
+      return void 0;
+    }
+    try {
+      return decodeDelayedIntent(log.extraData);
+    } catch (e) {
+      throw new InvalidDelayedIntentError(log.extraData, e);
+    }
+  }
+}
+export {
+  RedemptionLoggerV310Contract
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV310Contract.js

@@ -0,0 +1,16 @@
+import { iWithdrawalCompressorV310Abi } from "../../../abi/IWithdrawalCompressorV310.js";
+import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
+const abi = iWithdrawalCompressorV310Abi;
+class WithdrawalCompressorV310Contract extends AbstractWithdrawalCompressorContract {
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "WithdrawalCompressorV310",
+      abi,
+      version: 310
+    });
+  }
+}
+export {
+  WithdrawalCompressorV310Contract
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV311Contract.js

@@ -0,0 +1,16 @@
+import { iWithdrawalCompressorV311Abi } from "../../../abi/IWithdrawalCompressorV311.js";
+import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
+const abi = iWithdrawalCompressorV311Abi;
+class WithdrawalCompressorV311Contract extends AbstractWithdrawalCompressorContract {
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "WithdrawalCompressorV311",
+      abi,
+      version: 311
+    });
+  }
+}
+export {
+  WithdrawalCompressorV311Contract
+};