@gearbox-protocol/sdk 3.0.0-vfour.13 → 3.0.0-vfour.131

package/README.md

@@ -3,7 +3,6 @@
 Gearbox core types SDK
 Contains core datastructures which are used across multiple gearbox services
 
-
 ### Important information for contributors
 
 As a contributor to the Gearbox Protocol GitHub repository, your pull requests indicate acceptance of our Gearbox Contribution Agreement. This agreement outlines that you assign the Intellectual Property Rights of your contributions to the Gearbox Foundation. This helps safeguard the Gearbox protocol and ensure the accumulation of its intellectual property. Contributions become part of the repository and may be used for various purposes, including commercial. As recognition for your expertise and work, you receive the opportunity to participate in the protocol's development and the potential to see your work integrated within it. The full Gearbox Contribution Agreement is accessible within the [repository](/ContributionAgreement) for comprehensive understanding. [Let's innovate together!]

package/dist/cjs/dev/index.cjs

@@ -1,9 +1,326 @@
 'use strict';
 
-var sdk = require('../sdk');
+var sdkGov = require('@gearbox-protocol/sdk-gov');
 var viem = require('viem');
+var accounts = require('viem/accounts');
+var sdk = require('../sdk');
+
+// src/dev/AccountOpener.ts
+function createAnvilClient({
+  chain,
+  transport
+}) {
+  return viem.createTestClient(
+    {
+      chain,
+      mode: "anvil",
+      transport,
+      cacheTime: 0
+    }
+  ).extend(viem.publicActions).extend(viem.walletActions).extend((client) => ({
+    anvilNodeInfo: () => anvilNodeInfo(client),
+    isAnvil: () => isAnvil(client),
+    evmMineDetailed: (timestamp) => evmMineDetailed(client, timestamp)
+  }));
+}
+async function isAnvil(client) {
+  try {
+    const resp = await client.request({
+      method: "anvil_nodeInfo",
+      params: []
+    });
+    return !!resp.currentBlockNumber;
+  } catch {
+    return false;
+  }
+}
+async function anvilNodeInfo(client) {
+  return client.request({
+    method: "anvil_nodeInfo",
+    params: []
+  });
+}
+async function evmMineDetailed(client, timestamp) {
+  try {
+    const [block] = await client.request({
+      method: "evm_mine_detailed",
+      params: [viem.toHex(timestamp)]
+    });
+    return block;
+  } catch {
+    return void 0;
+  }
+}
 
-// src/dev/calcLiquidatableLTs.ts
+// src/dev/AccountOpener.ts
+var AccountOpener = class {
+  #service;
+  #anvil;
+  #logger;
+  #borrower;
+  #faucet;
+  constructor(service, options = {}) {
+    this.#service = service;
+    this.#logger = sdk.childLogger("AccountOpener", service.sdk.logger);
+    this.#anvil = createAnvilClient({
+      chain: service.sdk.provider.chain,
+      transport: service.sdk.provider.transport
+    });
+    this.#faucet = options.faucet ?? service.sdk.addressProvider.getAddress("FAUCET");
+  }
+  get borrower() {
+    if (!this.#borrower) {
+      throw new Error("borrower can be used only after openCreditAccounts");
+    }
+    return this.#borrower.address;
+  }
+  /**
+   * Tries to open account with underlying only in each CM
+   */
+  async openCreditAccounts(targets) {
+    const borrower = await this.#prepareBorrower(targets);
+    for (const target of targets) {
+      try {
+        await this.#openAccount(target);
+      } catch (e) {
+        this.#logger?.error(e);
+      }
+    }
+    const accounts = await this.#service.getCreditAccounts({
+      owner: borrower.address
+    });
+    this.#logger?.info(`opened ${accounts.length} accounts`);
+  }
+  async #openAccount({
+    creditManager,
+    collateral,
+    leverage = 4,
+    slippage = 50
+  }) {
+    const borrower = await this.#getBorrower();
+    const cm = this.sdk.marketRegister.findCreditManager(creditManager);
+    const symbol = this.sdk.tokensMeta.symbol(collateral);
+    const logger = this.#logger?.child?.({
+      creditManager: cm.name,
+      collateral: symbol
+    });
+    const { minDebt, underlying } = cm.creditFacade;
+    const expectedBalances = [];
+    const leftoverBalances = [];
+    for (const t of Object.keys(cm.collateralTokens)) {
+      const token = t;
+      expectedBalances.push({
+        token,
+        balance: token === underlying ? BigInt(leverage) * minDebt : 1n
+      });
+      leftoverBalances.push({
+        token,
+        balance: 1n
+      });
+    }
+    logger?.debug("looking for open strategy");
+    const strategy = await this.sdk.router.findOpenStrategyPath({
+      creditManager: cm.creditManager,
+      expectedBalances,
+      leftoverBalances,
+      slippage,
+      target: collateral
+    });
+    logger?.debug("found open strategy");
+    const { tx, calls } = await this.#service.openCA({
+      creditManager: cm.creditManager.address,
+      averageQuota: [],
+      minQuota: [],
+      collateral: [{ token: underlying, balance: minDebt }],
+      debt: minDebt * BigInt(leverage - 1),
+      calls: strategy.calls,
+      ethAmount: 0n,
+      permits: {},
+      to: borrower.address,
+      referralCode: 0n
+    });
+    for (let i = 0; i < calls.length; i++) {
+      const call = calls[i];
+      logger?.debug(
+        `call #${i + 1}: ${this.sdk.parseFunctionData(call.target, call.callData)}`
+      );
+    }
+    logger?.debug("prepared open account transaction");
+    const hash = await sdk.sendRawTx(this.#anvil, {
+      tx,
+      account: borrower
+    });
+    logger?.debug(`send transaction ${hash}`);
+    const receipt = await this.#anvil.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new Error(`open credit account tx ${hash} reverted`);
+    }
+    logger?.debug(
+      `opened credit account in ${cm.name} with collateral ${symbol}`
+    );
+    return this.getOpenedAccounts();
+  }
+  async getOpenedAccounts() {
+    return await this.#service.getCreditAccounts({
+      owner: this.borrower
+    });
+  }
+  /**
+   * Creates borrower wallet,
+   * Sets ETH balance,
+   * Gets tokens from faucet,
+   * Approves collateral tokens to credit manager,
+   * Gets DEGEN_NFT,
+   */
+  async #prepareBorrower(targets) {
+    const borrower = await this.#getBorrower();
+    let claimUSD = 0n;
+    let degenNFTS = {};
+    for (const target of targets) {
+      const cm = this.sdk.marketRegister.findCreditManager(
+        target.creditManager
+      );
+      const market = this.sdk.marketRegister.findByCreditManager(
+        target.creditManager
+      );
+      const { minDebt, degenNFT } = cm.creditFacade;
+      claimUSD += market.priceOracle.convertToUSD(cm.underlying, minDebt);
+      if (viem.isAddress(degenNFT) && degenNFT !== sdkGov.ADDRESS_0X0) {
+        degenNFTS[degenNFT] = (degenNFTS[degenNFT] ?? 0) + 1;
+      }
+      for (const t of Object.keys(cm.collateralTokens)) {
+        await this.#approve(t, cm);
+      }
+    }
+    claimUSD = claimUSD * 11n / 10n;
+    this.#logger?.debug(`claiming ${sdkGov.formatBN(claimUSD, 8)} USD from faucet`);
+    let hash = await this.#anvil.writeContract({
+      account: borrower,
+      address: this.#faucet,
+      abi: [
+        {
+          type: "function",
+          inputs: [
+            { name: "amountUSD", internalType: "uint256", type: "uint256" }
+          ],
+          name: "claim",
+          outputs: [],
+          stateMutability: "nonpayable"
+        }
+      ],
+      functionName: "claim",
+      args: [claimUSD],
+      chain: this.#anvil.chain
+    });
+    let receipt = await this.#anvil.waitForTransactionReceipt({
+      hash
+    });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `borrower ${borrower.address} failed to claimed equivalent of ${sdkGov.formatBN(claimUSD, 8)} USD from faucet, tx: ${hash}`
+      );
+    }
+    this.#logger?.debug(
+      `borrower ${borrower.address} claimed equivalent of ${sdkGov.formatBN(claimUSD, 8)} USD from faucet, tx: ${hash}`
+    );
+    for (const [degenNFT, amount] of Object.entries(degenNFTS)) {
+      await this.#mintDegenNft(degenNFT, borrower.address, amount);
+    }
+    this.#logger?.debug("prepared borrower");
+    return borrower;
+  }
+  async #approve(token, cm) {
+    const borrower = await this.#getBorrower();
+    try {
+      const hash = await this.#anvil.writeContract({
+        account: borrower,
+        address: token,
+        abi: sdk.ierc20Abi,
+        functionName: "approve",
+        args: [cm.creditManager.address, sdk.MAX_UINT256],
+        chain: this.#anvil.chain
+      });
+      const receipt = await this.#anvil.waitForTransactionReceipt({
+        hash
+      });
+      if (receipt.status === "reverted") {
+        this.#logger?.error(
+          `failed to allowed credit manager ${cm.creditManager.name} to spend ${token}, tx reverted: ${hash}`
+        );
+      } else {
+        this.#logger?.debug(
+          `allowed credit manager ${cm.creditManager.name} to spend ${token}, tx: ${hash}`
+        );
+      }
+    } catch (e) {
+      this.#logger?.error(
+        `failed to allowed credit manager ${cm.creditManager.name} to spend ${token}: ${e}`
+      );
+    }
+  }
+  async #mintDegenNft(degenNFT, to, amount) {
+    if (amount <= 0) {
+      return;
+    }
+    let minter;
+    try {
+      minter = await this.#anvil.readContract({
+        address: degenNFT,
+        abi: sdk.iDegenNftv2Abi,
+        functionName: "minter"
+      });
+    } catch (e) {
+      this.#logger?.error(`failed to get minter of degenNFT ${degenNFT}: ${e}`);
+      return;
+    }
+    try {
+      await this.#anvil.impersonateAccount({ address: minter });
+      await this.#anvil.setBalance({
+        address: minter,
+        value: viem.parseEther("100")
+      });
+      const hash = await this.#anvil.writeContract({
+        account: minter,
+        address: degenNFT,
+        abi: sdk.iDegenNftv2Abi,
+        functionName: "mint",
+        args: [to, BigInt(amount)],
+        chain: this.#anvil.chain
+      });
+      const receipt = await this.#anvil.waitForTransactionReceipt({
+        hash
+      });
+      if (receipt.status === "reverted") {
+        this.#logger?.error(
+          `failed to mint ${amount} degenNFT ${degenNFT} to borrower ${to}, tx reverted: ${hash}`
+        );
+      }
+      this.#logger?.debug(
+        `minted ${amount} degenNFT ${degenNFT} to borrower ${to}, tx: ${hash}`
+      );
+    } catch (e) {
+      this.#logger?.error(
+        `failed to mint ${amount} degenNFT ${degenNFT} to borrower ${to}: ${e}`
+      );
+    } finally {
+      await this.#anvil.stopImpersonatingAccount({ address: minter });
+    }
+  }
+  async #getBorrower() {
+    if (!this.#borrower) {
+      this.#borrower = accounts.privateKeyToAccount(accounts.generatePrivateKey());
+      await this.#anvil.setBalance({
+        address: this.#borrower.address,
+        value: viem.parseEther("100")
+      });
+      this.#logger?.info(`created borrower ${this.#borrower.address}`);
+    }
+    return this.#borrower;
+  }
+  get sdk() {
+    return this.#service.sdk;
+  }
+};
 async function calcLiquidatableLTs(sdk$1, ca, factor = 9990n, logger) {
   const cm = sdk$1.marketRegister.findCreditManager(ca.creditManager);
   const market = sdk$1.marketRegister.findByCreditManager(ca.creditManager);
@@ -42,7 +359,7 @@ async function calcLiquidatableLTs(sdk$1, ca, factor = 9990n, logger) {
     if (token !== ca.underlying) {
       const newLT = oldLT * k / sdk.WAD;
       logger?.debug(
-        `proposed ${sdk$1.marketRegister.tokensMeta.mustGet(token).symbol} LT change: ${oldLT} => ${newLT} `
+        `proposed ${sdk$1.tokensMeta.symbol(token)} LT change: ${oldLT} => ${newLT} `
       );
       result[token] = Number(newLT);
     }
@@ -150,6 +467,21 @@ var iaclAbi = [
     name: "AddressNotUnpausableAdminException"
   }
 ];
+var iaclTraitAbi = [
+  {
+    type: "function",
+    name: "acl",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  }
+];
 var iCreditConfiguratorV3Abi = [
   {
     type: "function",
@@ -1413,17 +1745,17 @@ var iCreditManagerV3Abi = [
 ];
 
 // src/dev/setLTs.ts
-async function setLTs(sdk$1, cm, newLTs, logger) {
-  const aclAddr = sdk$1.addressProvider.getLatestVersion(sdk.AP_ACL);
-  const configuratorAddr = await sdk$1.provider.publicClient.readContract({
+async function setLTs(anvil, cm, newLTs, logger) {
+  const aclAddr = await anvil.readContract({
+    address: cm.creditConfigurator,
+    abi: iaclTraitAbi,
+    functionName: "acl"
+  });
+  const configuratorAddr = await anvil.readContract({
     address: aclAddr,
     abi: iaclAbi,
     functionName: "owner"
   });
-  const anvil = sdk.createAnvilClient({
-    transport: sdk$1.provider.transport,
-    chain: sdk$1.provider.chain
-  });
   await anvil.impersonateAccount({
     address: configuratorAddr
   });
@@ -1432,28 +1764,121 @@ async function setLTs(sdk$1, cm, newLTs, logger) {
     value: viem.parseEther("100")
   });
   for (const [t, lt] of Object.entries(newLTs)) {
-    await anvil.writeContract({
-      chain: anvil.chain,
-      address: cm.creditConfigurator.address,
-      account: configuratorAddr,
-      abi: iCreditConfiguratorV3Abi,
-      functionName: "setLiquidationThreshold",
-      args: [t, lt]
-    });
-    const newLT = await anvil.readContract({
-      address: cm.creditManager.address,
-      abi: iCreditManagerV3Abi,
-      functionName: "liquidationThresholds",
-      args: [t]
-    });
-    logger?.debug(
-      `set ${sdk$1.marketRegister.tokensMeta.mustGet(t).symbol} LT to ${newLT}`
-    );
+    try {
+      await anvil.writeContract({
+        chain: anvil.chain,
+        address: cm.creditConfigurator,
+        account: configuratorAddr,
+        abi: iCreditConfiguratorV3Abi,
+        functionName: "setLiquidationThreshold",
+        args: [t, lt]
+      });
+      const newLT = await anvil.readContract({
+        address: cm.baseParams.addr,
+        abi: iCreditManagerV3Abi,
+        functionName: "liquidationThresholds",
+        args: [t]
+      });
+      logger?.debug(`set ${t} LT to ${newLT}`);
+    } catch {
+    }
   }
   await anvil.stopImpersonatingAccount({
     address: configuratorAddr
   });
 }
+async function setLTZero(anvil, cm, logger) {
+  const aclAddr = await anvil.readContract({
+    address: cm.creditConfigurator,
+    abi: iaclTraitAbi,
+    functionName: "acl"
+  });
+  const configuratorAddr = await anvil.readContract({
+    address: aclAddr,
+    abi: iaclAbi,
+    functionName: "owner"
+  });
+  await anvil.impersonateAccount({
+    address: configuratorAddr
+  });
+  await anvil.setBalance({
+    address: configuratorAddr,
+    value: viem.parseEther("100")
+  });
+  let hash = await anvil.writeContract({
+    chain: anvil.chain,
+    address: cm.creditConfigurator,
+    account: configuratorAddr,
+    abi: iCreditConfiguratorV3Abi,
+    functionName: "setFees",
+    args: [
+      cm.feeInterest,
+      cm.liquidationDiscount - 1,
+      Number(sdk.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: iCreditConfiguratorV3Abi,
+    functionName: "setFees",
+    args: [
+      cm.feeInterest,
+      cm.feeLiquidation,
+      Number(sdk.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: viem.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: iCreditManagerV3Abi,
+    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: iCreditManagerV3Abi,
+    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 });
+}
 
+exports.AccountOpener = AccountOpener;
+exports.anvilNodeInfo = anvilNodeInfo;
 exports.calcLiquidatableLTs = calcLiquidatableLTs;
+exports.createAnvilClient = createAnvilClient;
+exports.evmMineDetailed = evmMineDetailed;
+exports.isAnvil = isAnvil;
+exports.setLTZero = setLTZero;
 exports.setLTs = setLTs;

package/dist/cjs/dev/index.d.ts

@@ -1,5 +1,26 @@
-import { Address } from 'viem';
-import { GearboxSDK, CreditAccountData, ILogger, CreditFactory } from '../sdk';
+import { Address, TestRpcSchema, Hex, Block, Prettify, Client, Transport, Chain, TestActions, PublicClient, WalletClient } from 'viem';
+import { CreditAccountsService, CreditAccountData, GearboxSDK, ILogger, CreditManagerState } from '../sdk';
+
+interface AccountOpenerOptions {
+    faucet?: Address;
+}
+interface TargetAccount {
+    creditManager: Address;
+    collateral: Address;
+    leverage?: number;
+    slippage?: number;
+}
+declare class AccountOpener {
+    #private;
+    constructor(service: CreditAccountsService, options?: AccountOpenerOptions);
+    get borrower(): Address;
+    /**
+     * Tries to open account with underlying only in each CM
+     */
+    openCreditAccounts(targets: TargetAccount[]): Promise<void>;
+    getOpenedAccounts(): Promise<CreditAccountData[]>;
+    private get 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
@@ -7,12 +28,83 @@ import { GearboxSDK, CreditAccountData, ILogger, CreditFactory } from '../sdk';
  */
 declare function calcLiquidatableLTs(sdk: GearboxSDK, ca: CreditAccountData, factor?: bigint, logger?: ILogger): Promise<Record<Address, number>>;
 
+interface AnvilNodeInfo {
+    currentBlockNumber: string;
+    currentBlockTimestamp: number;
+    currentBlockHash: string;
+    hardFork: string;
+    transactionOrder: string;
+    environment: {
+        baseFee: string;
+        chainId: number;
+        gasLimit: string;
+        gasPrice: string;
+    };
+    forkConfig: {
+        forkUrl: string;
+        forkBlockNumber: string;
+        forkRetryBackoff: number;
+    };
+}
+type AnvilRPCSchema = [
+    ...TestRpcSchema<"anvil">,
+    {
+        Method: "anvil_nodeInfo";
+        Parameters: [];
+        ReturnType: AnvilNodeInfo;
+    },
+    {
+        Method: "evm_mine_detailed";
+        Parameters: [Hex];
+        ReturnType: Block<Hex>[];
+    }
+];
+type AnvilActions = {
+    anvilNodeInfo: () => Promise<AnvilNodeInfo>;
+    isAnvil: () => Promise<boolean>;
+    evmMineDetailed: (
+    /**
+     * Block timestamp in seconds
+     */
+    timestamp: bigint | number) => Promise<Block<Hex> | undefined>;
+};
+type AnvilClient = Prettify<{
+    mode: "anvil";
+} & Client<Transport, Chain, undefined, AnvilRPCSchema, AnvilActions & TestActions>> & PublicClient & WalletClient;
+interface AnvilClientConfig<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined> {
+    transport: transport;
+    chain?: chain;
+}
+declare function createAnvilClient({ chain, transport, }: AnvilClientConfig): AnvilClient;
+/**
+ * View action to detect if client is an anvil client
+ * @param client
+ * @returns
+ */
+declare function isAnvil(client: Client<any, any, any, AnvilRPCSchema, any>): Promise<boolean>;
+/**
+ * Anvil node info
+ * @param client
+ * @returns
+ */
+declare function anvilNodeInfo(client: Client<any, any, any, AnvilRPCSchema, any>): Promise<AnvilNodeInfo>;
+/**
+ * Safely tries to mine block with given timestamp
+ * @param client
+ * @param timestamp in seconds
+ * @returns
+ */
+declare function evmMineDetailed(client: Client<any, any, any, AnvilRPCSchema, any>, timestamp: bigint | number): Promise<Block<Hex> | undefined>;
+
 /**
  * Helper function to set liquidation thresholds on credit manager via anvil impersonation
  * @param sdk
  * @param cm
  * @param newLTs
  */
-declare function setLTs(sdk: GearboxSDK, cm: CreditFactory, newLTs: Record<Address, number>, logger?: ILogger): Promise<void>;
+declare function setLTs(anvil: AnvilClient, cm: CreditManagerState, newLTs: Record<Address, number>, logger?: ILogger): Promise<void>;
+
+type ZeroLTCMSlice = Pick<CreditManagerState, "creditConfigurator" | "feeInterest" | "liquidationDiscount" | "feeLiquidationExpired" | "liquidationDiscountExpired" | "feeLiquidation" | "name" | "underlying" | "baseParams">;
+declare function setLTZero(anvil: AnvilClient, cm: ZeroLTCMSlice, logger?: ILogger): Promise<void>;
 
-export { calcLiquidatableLTs, setLTs };
+export { AccountOpener, type AccountOpenerOptions, type AnvilActions, type AnvilClient, type AnvilClientConfig, type AnvilNodeInfo, type AnvilRPCSchema, type TargetAccount, anvilNodeInfo, calcLiquidatableLTs, createAnvilClient, evmMineDetailed, isAnvil, setLTZero, setLTs };