Merge branch 'beta'

Author: doomsower

src/config/deleverage-liquidator.ts

@@ -17,7 +17,7 @@ export const DeleverageLiquidatorSchema = z.object({
    * Address of the partial liquidation bot (for deleverage)
    */
   partialLiquidationBot: ZodAddress()
-    .default("0xd9f080c7d9a7202a816d32075a9b50fa8c6c504a")
+    // .default("0xc73a6741c77164dd06ff6edb09e8374abdf75c19")
     .register(zommandRegistry, {
       flags: "--partial-liquidation-bot <address>",
       description: "Address of the partial liquidation bot (for deleverage)",

src/services/HealthCheckerService.ts

@@ -92,6 +92,8 @@ export default class HealthCheckerService {
       address: this.client.address,
       balance: this.client.balance,
       currentBlock: this.sdk.currentBlock,
+      minHealthFactor: this.scanner.minHealthFactor,
+      maxHealthFactor: this.scanner.maxHealthFactor,
       timestamp: {
         value: timestamp,
         status: (!!threshold && now - timestamp <= threshold

src/services/PartialLiquidationBotV310Contract.ts

@@ -0,0 +1,67 @@
+import { BaseContract, type GearboxSDK } from "@gearbox-protocol/sdk";
+import { iPartialLiquidationBotV310Abi } from "@gearbox-protocol/sdk/plugins/bots";
+import type { Address } from "viem";
+
+const abi = iPartialLiquidationBotV310Abi;
+type abi = typeof abi;
+
+export class PartialLiquidationBotV310Contract extends BaseContract<abi> {
+  public static get(
+    sdk: GearboxSDK,
+    address: Address,
+  ): PartialLiquidationBotV310Contract {
+    const existing = sdk.contracts.get(address) as
+      | PartialLiquidationBotV310Contract
+      | undefined;
+    return existing ?? new PartialLiquidationBotV310Contract(sdk, address);
+  }
+
+  #minHealthFactor?: bigint;
+  #maxHealthFactor?: bigint;
+
+  constructor(sdk: GearboxSDK, address: Address) {
+    super(sdk, {
+      abi,
+      addr: address,
+      contractType: "partialLiquidationBot",
+      version: 310,
+    });
+  }
+
+  public async loadHealthFactors(): Promise<[bigint, bigint]> {
+    if (!this.#minHealthFactor || !this.#maxHealthFactor) {
+      const [minHealthFactor, maxHealthFactor] = await this.client.multicall({
+        contracts: [
+          {
+            address: this.address,
+            abi: this.abi,
+            functionName: "minHealthFactor",
+          },
+          {
+            address: this.address,
+            abi: this.abi,
+            functionName: "maxHealthFactor",
+          },
+        ],
+        allowFailure: false,
+      });
+      this.#minHealthFactor = BigInt(minHealthFactor);
+      this.#maxHealthFactor = BigInt(maxHealthFactor);
+    }
+    return [this.#minHealthFactor, this.#maxHealthFactor];
+  }
+
+  public get minHealthFactor(): bigint {
+    if (!this.#minHealthFactor) {
+      throw new Error("minHealthFactor not loaded");
+    }
+    return this.#minHealthFactor;
+  }
+
+  public get maxHealthFactor(): bigint {
+    if (!this.#maxHealthFactor) {
+      throw new Error("maxHealthFactor not loaded");
+    }
+    return this.#maxHealthFactor;
+  }
+}

src/services/Scanner.ts

@@ -7,21 +7,24 @@ import type {
 import {
   AddressSet,
   hexEq,
+  isVersionRange,
   MAX_UINT256,
   PERCENTAGE_FACTOR,
+  VERSION_RANGE_310,
   WAD,
 } from "@gearbox-protocol/sdk";
 import { iBotListV310Abi } from "@gearbox-protocol/sdk/abi/310/generated";
 import { iCreditManagerV300Abi } from "@gearbox-protocol/sdk/abi/v300";
-import { iPartialLiquidationBotV310Abi } from "@gearbox-protocol/sdk/plugins/bots";
 import type { Address, Block } from "viem";
 import { getContract } from "viem";
 import type { Config } from "../config/index.js";
 import { DI } from "../di.js";
 import { type ILogger, Logger } from "../log/index.js";
+import { DELEVERAGE_PERMISSIONS } from "../utils/permissions.js";
 import type Client from "./Client.js";
 import type { ILiquidatorService } from "./liquidate/index.js";
 import { type INotifier, ZeroHFAccountsMessage } from "./notifier/index.js";
+import { PartialLiquidationBotV310Contract } from "./PartialLiquidationBotV310Contract.js";
 
 const RESTAKING_CMS: Partial<Record<NetworkType, Address>> = {
   Mainnet:
@@ -80,20 +83,18 @@ export class Scanner {
       this.#maxHealthFactor = MAX_UINT256;
     }
     if (this.config.liquidationMode === "deleverage") {
+      const [botMinHealthFactor] = await PartialLiquidationBotV310Contract.get(
+        this.caService.sdk,
+        this.config.partialLiquidationBot,
+      ).loadHealthFactors();
       if (this.config.optimistic) {
         this.#minHealthFactor = 0n;
         this.#maxHealthFactor = MAX_UINT256;
       } else {
         this.#minHealthFactor = WAD;
-        const botMinHealthFactor = await this.client.pub.readContract({
-          address: this.config.partialLiquidationBot,
-          abi: iPartialLiquidationBotV310Abi,
-          functionName: "minHealthFactor",
-        });
-        this.#maxHealthFactor =
-          (BigInt(botMinHealthFactor) * WAD) / PERCENTAGE_FACTOR;
+        this.#maxHealthFactor = (botMinHealthFactor * WAD) / PERCENTAGE_FACTOR;
         this.log.info(
-          `deleverage bot max health factor is ${botMinHealthFactor / 100}%  (${this.#maxHealthFactor})`,
+          `deleverage bot max health factor is ${botMinHealthFactor / 100n}%  (${this.#maxHealthFactor})`,
         );
       }
     }
@@ -411,27 +412,33 @@ export class Scanner {
   }
 
   async #filterDeleverageAccounts(
-    accounts: CreditAccountData[],
+    accounts_: CreditAccountData[],
     partialLiquidationBot: Address,
     blockNumber?: bigint,
   ): Promise<CreditAccountData[]> {
-    const botList = this.caService.sdk.botListContract?.address;
-    if (!botList) {
-      this.log.warn(
-        "bot list contract not found, skipping deleverage accounts filtering",
-      );
-      return accounts;
+    if (this.config.optimistic) {
+      return accounts_;
     }
+
+    const accounts = accounts_.filter(ca => {
+      const cm = this.caService.sdk.marketRegister.findCreditManager(
+        ca.creditManager,
+      );
+      return isVersionRange(cm.creditFacade.version, VERSION_RANGE_310);
+    });
+
     const res = await this.client.pub.multicall({
-      contracts: accounts.map(
-        ca =>
-          ({
-            address: botList,
-            abi: iBotListV310Abi,
-            functionName: "getBotStatus",
-            args: [partialLiquidationBot, ca.creditAccount],
-          }) as const,
-      ),
+      contracts: accounts.map(ca => {
+        const cm = this.caService.sdk.marketRegister.findCreditManager(
+          ca.creditManager,
+        );
+        return {
+          address: cm.creditFacade.botList,
+          abi: iBotListV310Abi,
+          functionName: "getBotStatus",
+          args: [partialLiquidationBot, ca.creditAccount],
+        } as const;
+      }),
       allowFailure: true,
       blockNumber,
     });
@@ -442,15 +449,19 @@ export class Scanner {
       const r = res[i];
       if (r.status === "success") {
         const [permissions, forbidden] = r.result;
-        if (!!permissions && !forbidden) {
+        if (
+          !!permissions &&
+          !forbidden &&
+          (permissions & DELEVERAGE_PERMISSIONS) === DELEVERAGE_PERMISSIONS
+        ) {
           result.push(ca);
         }
       } else if (r.status === "failure") {
         errored++;
       }
     }
     this.log.debug(
-      { errored, before: accounts.length, after: result.length, botList },
+      { errored, before: accounts_.length, after: result.length },
       "filtered accounts for deleverage",
     );
     return result;
@@ -474,6 +485,14 @@ export class Scanner {
     return this.#liquidatableAccounts;
   }
 
+  public get minHealthFactor(): bigint {
+    return this.#minHealthFactor;
+  }
+
+  public get maxHealthFactor(): bigint {
+    return this.#maxHealthFactor;
+  }
+
   public async stop(): Promise<void> {
     this.#unwatch?.();
     this.log.info("stopped");

src/services/liquidate/LiquidationStrategyDeleverage.ts

@@ -0,0 +1,130 @@
+import {
+  type CreditAccountData,
+  type MultiCall,
+  PERCENTAGE_FACTOR,
+  VERSION_RANGE_310,
+} from "@gearbox-protocol/sdk";
+import { iCreditFacadeMulticallV310Abi } from "@gearbox-protocol/sdk/abi/310/generated";
+import { encodeFunctionData, parseEther } from "viem";
+import type {
+  DeleverageLiquidatorSchema,
+  LiqduiatorConfig,
+} from "../../config/index.js";
+import { DI } from "../../di.js";
+import { type ILogger, Logger } from "../../log/index.js";
+import { DELEVERAGE_PERMISSIONS } from "../../utils/permissions.js";
+import { PartialLiquidationBotV310Contract } from "../PartialLiquidationBotV310Contract.js";
+import LiquidationStrategyPartial from "./LiquidationStrategyPartial.js";
+import type {
+  ILiquidationStrategy,
+  MakeLiquidatableResult,
+  PartialLiquidationPreview,
+} from "./types.js";
+
+export default class LiquidationStrategyDeleverage
+  extends LiquidationStrategyPartial
+  implements ILiquidationStrategy<PartialLiquidationPreview>
+{
+  @DI.Inject(DI.Config)
+  // @ts-expect-error
+  config!: LiqduiatorConfig<DeleverageLiquidatorSchema>;
+
+  @Logger("DeleverageStrategy")
+  // @ts-expect-error
+  logger!: ILogger;
+
+  public override isApplicable(ca: CreditAccountData): boolean {
+    return this.checkAccountVersion(ca, VERSION_RANGE_310);
+  }
+
+  public override async makeLiquidatable(
+    ca: CreditAccountData,
+  ): Promise<MakeLiquidatableResult> {
+    if (!this.isApplicable(ca)) {
+      throw new Error("cannot deleverage: account is not applicable");
+    }
+    const result = await super.makeLiquidatable(ca);
+    const { creditFacade } = this.sdk.marketRegister.findCreditManager(
+      ca.creditManager,
+    );
+
+    // await this.client.anvil.impersonateAccount({
+    //   address: creditFacade.botList,
+    // });
+
+    // const hash = await this.client.anvil.writeContract({
+    //   account: creditFacade.address,
+    //   chain: this.client.anvil.chain,
+    //   address: creditFacade.botList,
+    //   abi: iBotListV310Abi,
+    //   functionName: "setBotPermissions",
+    //   args: [
+    //     ca.creditAccount,
+    //     this.config.partialLiquidationBot,
+    //     DELEVERAGE_PERMISSIONS,
+    //   ],
+    // });
+    // this.logger.debug(
+    //   `set bot permissions for account ${ca.creditAccount} in tx ${hash}`,
+    // );
+    // const receipt = await this.client.pub.waitForTransactionReceipt({
+    //   hash,
+    // });
+    // if (receipt.status === "reverted") {
+    //   throw new Error(
+    //     `failed to set bot permissions for account ${ca.creditAccount} in tx ${hash}`,
+    //   );
+    // }
+    // await this.client.anvil.stopImpersonatingAccount({
+    //   address: creditFacade.botList,
+    // });
+    await this.client.anvil.impersonateAccount({ address: ca.owner });
+
+    const addBotCall: MultiCall = {
+      target: creditFacade.address,
+      callData: encodeFunctionData({
+        abi: iCreditFacadeMulticallV310Abi,
+        functionName: "setBotPermissions",
+        args: [this.config.partialLiquidationBot, DELEVERAGE_PERMISSIONS],
+      }),
+    };
+
+    const tx = creditFacade.multicall(ca.creditAccount, [addBotCall]);
+
+    await this.client.anvil.setBalance({
+      address: ca.owner,
+      value: parseEther("100"),
+    });
+    const hash = await this.client.anvil.sendTransaction({
+      account: ca.owner,
+      chain: this.client.anvil.chain,
+      to: tx.to,
+      data: tx.callData,
+    });
+    const receipt = await this.client.anvil.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `failed to set bot permissions for account ${ca.creditAccount} in tx ${hash}: reverted`,
+      );
+    } else {
+      this.logger.debug(
+        `set bot permissions for account ${ca.creditAccount} in tx ${hash}`,
+      );
+    }
+    await this.client.anvil.stopImpersonatingAccount({ address: ca.owner });
+
+    return result;
+  }
+
+  protected override ignoreReservePrices(_ca: CreditAccountData): boolean {
+    return false;
+  }
+
+  protected override optimisticHF(_ca: CreditAccountData): bigint {
+    const minHF = PartialLiquidationBotV310Contract.get(
+      this.sdk,
+      this.config.partialLiquidationBot,
+    ).minHealthFactor;
+    return (minHF * 9990n) / PERCENTAGE_FACTOR;
+  }
+}