@gearbox-protocol/sdk 3.0.0-vfourabi.1 → 3.0.0-vfourabi.3

package/src/dev/SDKExample.ts

@@ -0,0 +1,167 @@
+import { readFile, writeFile } from "node:fs/promises";
+
+import type { Address } from "viem";
+import { isAddress, parseEther, stringToHex } from "viem";
+
+import { iAddressProviderV300Abi } from "../abi/v300";
+import { iAddressProviderV310Abi } from "../abi/v310";
+import type { ILogger } from "../sdk";
+import { ADDRESS_PROVIDER, GearboxSDK, json_stringify } from "../sdk";
+import { createAnvilClient } from "./createAnvilClient";
+
+export interface SDKExampleOptions {
+  addressProvider?: string;
+  addressProviderJson?: string;
+  marketConfigurators: Address[];
+  anvilUrl?: string;
+  outFile?: string;
+}
+
+export class SDKExample {
+  #sdk?: GearboxSDK;
+  #logger?: ILogger;
+
+  constructor(logger?: ILogger) {
+    this.#logger = logger;
+  }
+
+  public async run(opts: SDKExampleOptions) {
+    const {
+      addressProvider: ap,
+      addressProviderJson,
+      marketConfigurators,
+      anvilUrl = "http://127.0.0.1:8545",
+      outFile,
+    } = opts;
+    const addressProvider = await this.#readConfigAddress(
+      "addressProvider",
+      ap,
+      addressProviderJson,
+    );
+
+    this.#sdk = await GearboxSDK.attach({
+      rpcURLs: [anvilUrl],
+      timeout: 480_000,
+      addressProvider,
+      logger: this.#logger,
+      ignoreUpdateablePrices: false,
+      marketConfigurators,
+    });
+    this.#logger?.info("attached sdk");
+    try {
+      await this.#sdk.marketRegister.loadZappers();
+    } catch (e) {
+      this.#logger?.error(`failed to load zappers: ${e}`);
+    }
+
+    await Promise.allSettled(
+      this.#sdk.marketRegister.marketConfigurators.map(m =>
+        m.loadCuratorName(),
+      ),
+    );
+    this.#logger?.info("loaded curator names");
+
+    if (outFile) {
+      try {
+        await writeFile(
+          outFile,
+          json_stringify(this.#sdk.stateHuman()),
+          "utf-8",
+        );
+      } catch (e) {
+        this.#logger?.error(`failed to write to ${outFile}: ${e}`);
+      }
+    }
+  }
+
+  public async migrateFaucet(addressProvider: Address): Promise<void> {
+    try {
+      await this.#migrateFaucet(addressProvider);
+      this.#logger?.info("faucet migrated successfully");
+    } catch (e) {
+      this.#logger?.error(`faucet migration failed: ${e}`);
+    }
+  }
+
+  async #readConfigAddress(
+    name: string,
+    value?: string,
+    file?: string,
+  ): Promise<Address> {
+    let result = value;
+
+    if (!result) {
+      if (!file) {
+        throw new Error(`${name} is not specified`);
+      }
+
+      this.#logger?.debug(`reading ${name} json ${file}`);
+      const apFile = await readFile(file, "utf-8").then(JSON.parse);
+      result = apFile[name];
+    }
+    if (!result) {
+      throw new Error(`${name} is not specified`);
+    }
+    if (!isAddress(result)) {
+      throw new Error(`${name} is not a valid address: ${result}`);
+    }
+
+    this.#logger?.info(`using ${name} ${result}`);
+    return result;
+  }
+
+  /**
+   * Migrates faucet from address provider v3 to v3.1
+   * @param addressProvider 3.1 address provider
+   */
+  async #migrateFaucet(addressProvider: Address): Promise<void> {
+    const anvil = createAnvilClient({
+      chain: this.sdk.provider.chain,
+      transport: this.sdk.provider.transport,
+    });
+
+    const [faucetAddr, owner] = await anvil.multicall({
+      contracts: [
+        {
+          abi: iAddressProviderV300Abi,
+          address: ADDRESS_PROVIDER[this.sdk.provider.networkType],
+          functionName: "getAddressOrRevert",
+          args: [stringToHex("FAUCET", { size: 32 }), 0n],
+        },
+        {
+          abi: iAddressProviderV310Abi,
+          address: addressProvider,
+          functionName: "owner",
+          args: [],
+        },
+      ],
+      allowFailure: false,
+    });
+    this.#logger?.debug(`faucet address: ${faucetAddr}, owner: ${owner}`);
+    await anvil.impersonateAccount({ address: owner });
+    await anvil.setBalance({
+      address: owner,
+      value: parseEther("100"),
+    });
+    const hash = await anvil.writeContract({
+      chain: anvil.chain,
+      account: owner,
+      address: addressProvider,
+      abi: iAddressProviderV310Abi,
+      functionName: "setAddress",
+      args: [stringToHex("FAUCET", { size: 32 }), faucetAddr, true],
+    });
+    const receipt = await anvil.waitForTransactionReceipt({ hash });
+    await anvil.stopImpersonatingAccount({ address: owner });
+    if (receipt.status === "reverted") {
+      throw new Error("faucet migration reverted");
+    }
+  }
+
+  public get sdk(): GearboxSDK {
+    if (!this.#sdk) {
+      throw new Error("sdk is not attached");
+    }
+    return this.#sdk;
+  }
+}

package/src/dev/abi.ts

@@ -0,0 +1,14 @@
+import { parseAbi } from "viem";
+
+export const iaclTraitAbi = parseAbi([
+  "function acl() external view returns (address)",
+]);
+
+export const iOwnableAbi = parseAbi([
+  "function owner() external view returns (address)",
+]);
+
+export const iDegenNftv2Abi = parseAbi([
+  "function minter() external view returns (address)",
+  "function mint(address to, uint256 amount) external",
+]);

package/src/dev/calcLiquidatableLTs.ts

@@ -0,0 +1,77 @@
+import type { Address } from "viem";
+
+import type { CreditAccountData, GearboxSDK, ILogger } from "../sdk";
+import { PERCENTAGE_FACTOR, WAD } from "../sdk";
+
+/**
+ * Given credit accounts, calculates new liquidation thresholds that needs to be set to drop account health factor a bit to make it eligible for partial liquidation
+ * @param ca
+ */
+export async function calcLiquidatableLTs(
+  sdk: GearboxSDK,
+  ca: CreditAccountData,
+  factor = 9990n,
+  logger?: ILogger,
+): Promise<Record<Address, number>> {
+  const cm = sdk.marketRegister.findCreditManager(ca.creditManager);
+  const market = sdk.marketRegister.findByCreditManager(ca.creditManager);
+
+  // Sort account tokens by weighted value descending, but underlying token comes last
+  const weightedBalances = ca.tokens
+    .filter(({ token, balance }) => {
+      const minBalance =
+        10n ** BigInt(Math.max(8, sdk.tokensMeta.decimals(token)) - 8);
+      return balance > minBalance;
+    })
+    .map(t => {
+      const { token, balance } = t;
+      const balanceU = market.priceOracle.convertToUnderlying(token, balance);
+      const lt = BigInt(cm.creditManager.liquidationThresholds.mustGet(token));
+      return {
+        token,
+        weightedBalance: (balanceU * lt) / PERCENTAGE_FACTOR,
+        lt,
+      };
+    })
+    .sort((a, b) => {
+      if (a.token === ca.underlying) return 1;
+      if (b.token === ca.underlying) return -1;
+      return b.weightedBalance > a.weightedBalance ? 1 : -1;
+    });
+
+  // LTnew = LT * k, where
+  //
+  //        totalDebt - B_underlying * LT_underlying
+  // k = -------------------------------------------------------------
+  //                    sum(p * b* LT)
+  let divisor = 0n;
+  let dividend =
+    (factor * (ca.debt + ca.accruedInterest + ca.accruedFees)) /
+    PERCENTAGE_FACTOR; // TODO: USDT fee
+  for (const { token, weightedBalance } of weightedBalances) {
+    if (token === ca.underlying) {
+      dividend -= weightedBalance;
+    } else {
+      divisor += weightedBalance;
+    }
+  }
+  if (divisor === 0n) {
+    throw new Error("warning: assets have zero weighted value in underlying");
+  }
+  if (dividend <= 0n) {
+    throw new Error(`warning: account balance in underlying covers debt`);
+  }
+  const k = (WAD * dividend) / divisor;
+
+  const result: Record<Address, number> = {};
+  for (const { token, lt: oldLT } of weightedBalances) {
+    if (token !== ca.underlying) {
+      const newLT = (oldLT * k) / WAD;
+      logger?.debug(
+        `proposed ${sdk.tokensMeta.symbol(token)} LT change: ${oldLT} => ${newLT} `,
+      );
+      result[token] = Number(newLT);
+    }
+  }
+  return result;
+}

package/src/dev/createAnvilClient.ts

@@ -0,0 +1,155 @@
+import type {
+  Block,
+  Chain,
+  Client,
+  Hex,
+  Prettify,
+  PublicClient,
+  TestActions,
+  TestRpcSchema,
+  Transport,
+  WalletClient,
+} from "viem";
+import { createTestClient, publicActions, toHex, walletActions } from "viem";
+
+export interface AnvilNodeInfo {
+  currentBlockNumber: string; // hexutil.Big is a big number in hex format
+  currentBlockTimestamp: number;
+  currentBlockHash: string;
+  hardFork: string;
+  transactionOrder: string;
+  environment: {
+    baseFee: string; // big.Int is a big number, represented as string in JSON
+    chainId: number;
+    gasLimit: string;
+    gasPrice: string;
+  };
+  forkConfig: {
+    forkUrl: string;
+    forkBlockNumber: string;
+    forkRetryBackoff: number;
+  };
+}
+
+export type AnvilRPCSchema = [
+  ...TestRpcSchema<"anvil">,
+  {
+    Method: "anvil_nodeInfo";
+    Parameters: [];
+    ReturnType: AnvilNodeInfo;
+  },
+  {
+    Method: "evm_mine_detailed";
+    Parameters: [Hex];
+    ReturnType: Block<Hex>[];
+  },
+];
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export type AnvilActions = {
+  anvilNodeInfo: () => Promise<AnvilNodeInfo>;
+  isAnvil: () => Promise<boolean>;
+  evmMineDetailed: (
+    /**
+     * Block timestamp in seconds
+     */
+    timestamp: bigint | number,
+  ) => Promise<Block<Hex> | undefined>;
+};
+
+export type AnvilClient = Prettify<
+  { mode: "anvil" } & Client<
+    Transport,
+    Chain,
+    undefined,
+    AnvilRPCSchema,
+    AnvilActions & TestActions
+  >
+> &
+  PublicClient &
+  WalletClient;
+
+export interface AnvilClientConfig<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+> {
+  transport: transport;
+  chain?: chain;
+}
+
+export function createAnvilClient({
+  chain,
+  transport,
+}: AnvilClientConfig): AnvilClient {
+  return createTestClient<"anvil", Transport, Chain, undefined, AnvilRPCSchema>(
+    {
+      chain,
+      mode: "anvil",
+      transport,
+      cacheTime: 0,
+      pollingInterval: 50,
+    },
+  )
+    .extend(publicActions)
+    .extend(walletActions)
+    .extend(client => ({
+      anvilNodeInfo: () => anvilNodeInfo(client),
+      isAnvil: () => isAnvil(client),
+      evmMineDetailed: (timestamp: bigint | number) =>
+        evmMineDetailed(client, timestamp),
+    })) as any;
+}
+
+/**
+ * View action to detect if client is an anvil client
+ * @param client
+ * @returns
+ */
+export async function isAnvil(
+  client: Client<any, any, any, AnvilRPCSchema, any>,
+): Promise<boolean> {
+  try {
+    const resp = await client.request({
+      method: "anvil_nodeInfo",
+      params: [],
+    });
+    return !!resp.currentBlockNumber;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Anvil node info
+ * @param client
+ * @returns
+ */
+export async function anvilNodeInfo(
+  client: Client<any, any, any, AnvilRPCSchema, any>,
+): Promise<AnvilNodeInfo> {
+  return client.request({
+    method: "anvil_nodeInfo",
+    params: [],
+  });
+}
+
+/**
+ * Safely tries to mine block with given timestamp
+ * @param client
+ * @param timestamp in seconds
+ * @returns
+ */
+export async function evmMineDetailed(
+  client: Client<any, any, any, AnvilRPCSchema, any>,
+  timestamp: bigint | number,
+): Promise<Block<Hex> | undefined> {
+  try {
+    const [block] = await client.request({
+      method: "evm_mine_detailed",
+      params: [toHex(timestamp)],
+    });
+    return block;
+  } catch {
+    return undefined;
+  }
+}

package/src/dev/index.ts

@@ -0,0 +1,7 @@
+export * from "./AccountOpener";
+export * from "./calcLiquidatableLTs";
+export * from "./createAnvilClient";
+export * from "./PriceFeedStore";
+export * from "./SDKExample";
+export * from "./setLTs";
+export * from "./setLTZero";

package/src/dev/setLTZero.ts

@@ -0,0 +1,127 @@
+import { parseEther } from "viem";
+
+import { iCreditConfiguratorV300Abi, iCreditManagerV300Abi } from "../abi/v300";
+import type { CreditManagerState, ILogger } from "../sdk";
+import { PERCENTAGE_FACTOR } from "../sdk";
+import { iaclTraitAbi, iOwnableAbi } from "./abi";
+import type { AnvilClient } from "./createAnvilClient";
+
+type ZeroLTCMSlice = Pick<
+  CreditManagerState,
+  | "creditConfigurator"
+  | "feeInterest"
+  | "liquidationDiscount"
+  | "feeLiquidationExpired"
+  | "liquidationDiscountExpired"
+  | "feeLiquidation"
+  | "name"
+  | "underlying"
+  | "baseParams"
+>;
+
+export async function setLTZero(
+  anvil: AnvilClient,
+  cm: ZeroLTCMSlice,
+  logger?: ILogger,
+): Promise<void> {
+  const aclAddr = await anvil.readContract({
+    address: cm.creditConfigurator,
+    abi: iaclTraitAbi,
+    functionName: "acl",
+  });
+  const configuratorAddr = await anvil.readContract({
+    address: aclAddr,
+    abi: iOwnableAbi,
+    functionName: "owner",
+  });
+
+  await anvil.impersonateAccount({
+    address: configuratorAddr,
+  });
+  await anvil.setBalance({
+    address: configuratorAddr,
+    value: parseEther("100"),
+  });
+
+  let hash = await anvil.writeContract({
+    chain: anvil.chain,
+    address: cm.creditConfigurator,
+    account: configuratorAddr,
+    abi: iCreditConfiguratorV300Abi,
+    functionName: "setFees",
+    args: [
+      cm.feeInterest,
+      cm.liquidationDiscount - 1,
+      Number(PERCENTAGE_FACTOR) - cm.liquidationDiscount,
+      cm.feeLiquidationExpired,
+      cm.liquidationDiscountExpired,
+    ],
+  });
+  await anvil.waitForTransactionReceipt({ hash });
+
+  logger?.debug(`[${cm.name}] setFees part 2`);
+  hash = await anvil.writeContract({
+    chain: anvil.chain,
+    address: cm.creditConfigurator,
+    account: configuratorAddr,
+    abi: iCreditConfiguratorV300Abi,
+    functionName: "setFees",
+    args: [
+      cm.feeInterest,
+      cm.feeLiquidation,
+      Number(PERCENTAGE_FACTOR) - cm.liquidationDiscount,
+      cm.feeLiquidationExpired,
+      cm.liquidationDiscountExpired,
+    ],
+  });
+  await anvil.waitForTransactionReceipt({ hash });
+
+  logger?.debug(`[${cm.name}] setFees done`);
+
+  await anvil.impersonateAccount({
+    address: cm.creditConfigurator,
+  });
+  await anvil.setBalance({
+    address: cm.creditConfigurator,
+    value: parseEther("100"),
+  });
+  logger?.debug(
+    `[${cm.name}] impresonating creditConfigurator ${cm.creditConfigurator}`,
+  );
+
+  logger?.debug(`[${cm.name}] setting liquidation threshold`);
+  hash = await anvil.writeContract({
+    chain: anvil.chain,
+    address: cm.baseParams.addr,
+    account: cm.creditConfigurator,
+    abi: iCreditManagerV300Abi,
+    functionName: "setCollateralTokenData",
+    args: [cm.underlying, 1, 1, Number(2n ** 40n - 1n), 0],
+  });
+  await anvil.waitForTransactionReceipt({ hash });
+
+  logger?.debug(`[${cm.name}] setting configurator ${cm.creditConfigurator}`);
+  hash = await anvil.writeContract({
+    chain: anvil.chain,
+    address: cm.baseParams.addr,
+    account: cm.creditConfigurator,
+    abi: iCreditManagerV300Abi,
+    functionName: "setCreditConfigurator",
+    args: [cm.creditConfigurator],
+  });
+  await anvil.waitForTransactionReceipt({ hash });
+
+  logger?.debug(`[${cm.name}] done`);
+  await anvil.stopImpersonatingAccount({
+    address: cm.creditConfigurator,
+  });
+  await anvil.stopImpersonatingAccount({ address: configuratorAddr });
+
+  /// Testing that LT is 1
+  // logger?.debug(`[${cm.name}] zero lt self-checking`);
+  // const cm2 = await dc300.read.getCreditManagerData([cm.addr]);
+  // if (cm2.liquidationThresholds.some(lt => lt > 1n)) {
+  //   throw new Error("LT is not 1");
+  // }
+  // logger?.info(`[${cm.name}] zero lt OK`);
+}

package/src/dev/setLTs.ts

@@ -0,0 +1,68 @@
+import type { Address } from "viem";
+import { parseEther } from "viem";
+
+import { iCreditConfiguratorV300Abi } from "../abi/v300";
+import { iCreditManagerV310Abi } from "../abi/v310";
+import type { ILogger } from "../sdk";
+import { iaclTraitAbi, iOwnableAbi } from "./abi";
+import type { AnvilClient } from "./createAnvilClient";
+
+export interface SetLTsCMSlice {
+  creditConfigurator: Address;
+  address: Address;
+}
+/**
+ * Helper function to set liquidation thresholds on credit manager via anvil impersonation
+ * @param sdk
+ * @param cm
+ * @param newLTs
+ */
+export async function setLTs(
+  anvil: AnvilClient,
+  cm: SetLTsCMSlice,
+  newLTs: Record<Address, number>,
+  logger?: ILogger,
+): Promise<void> {
+  const aclAddr = await anvil.readContract({
+    address: cm.creditConfigurator,
+    abi: iaclTraitAbi,
+    functionName: "acl",
+  });
+  const configuratorAddr = await anvil.readContract({
+    address: aclAddr,
+    abi: iOwnableAbi,
+    functionName: "owner",
+  });
+
+  await anvil.impersonateAccount({
+    address: configuratorAddr,
+  });
+  await anvil.setBalance({
+    address: configuratorAddr,
+    value: parseEther("100"),
+  });
+  for (const [t, lt] of Object.entries(newLTs)) {
+    try {
+      await anvil.writeContract({
+        chain: anvil.chain,
+        address: cm.creditConfigurator,
+        account: configuratorAddr,
+        abi: iCreditConfiguratorV300Abi,
+        functionName: "setLiquidationThreshold",
+        args: [t as Address, lt],
+      });
+      const newLT = await anvil.readContract({
+        address: cm.address,
+        abi: iCreditManagerV310Abi,
+        functionName: "liquidationThresholds",
+        args: [t as Address],
+      });
+      logger?.debug(`set ${t} LT to ${newLT}`);
+    } catch {
+      // in case when we try to set token that's not present
+    }
+  }
+  await anvil.stopImpersonatingAccount({
+    address: configuratorAddr,
+  });
+}