@gearbox-protocol/sdk 3.0.0-vfour.17 → 3.0.0-vfour.170

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,362 @@
 'use strict';
 
-var sdk = require('../sdk');
 var viem = require('viem');
+var accounts = require('viem/accounts');
+var sdk = require('../sdk');
+var promises = require('fs/promises');
 
-// src/dev/calcLiquidatableLTs.ts
+// 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 undefined;
+  }
+}
+
+// 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) {
+    await this.#prepareBorrower(targets);
+    const toApprove = new sdk.AddressMap();
+    for (const c of targets) {
+      const cm = this.sdk.marketRegister.findCreditManager(c.creditManager);
+      const toApproveOnCM = toApprove.get(c.creditManager) ?? /* @__PURE__ */ new Set();
+      toApproveOnCM.add(cm.underlying);
+      toApprove.upsert(c.creditManager, toApproveOnCM);
+    }
+    for (const [cmAddr, tokens] of toApprove.entries()) {
+      const cm = this.sdk.marketRegister.findCreditManager(cmAddr);
+      for (const token of tokens) {
+        await this.#approve(token, cm);
+      }
+    }
+    for (let i = 0; i < targets.length; i++) {
+      const target = targets[i];
+      try {
+        await this.#openAccount(target, i + 1, targets.length);
+      } catch (e) {
+        this.#logger?.error(e);
+      }
+    }
+    const accounts = await this.getOpenedAccounts();
+    this.#logger?.info(`opened ${accounts.length} accounts`);
+    return accounts;
+  }
+  async #openAccount({ creditManager, collateral, leverage = 4, slippage = 50 }, index, total) {
+    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
+    });
+    logger?.debug(`opening account #${index}/${total}`);
+    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(strategy, "found open strategy");
+    const debt = minDebt * BigInt(leverage - 1);
+    const collateralLT = BigInt(cm.collateralTokens[collateral]);
+    const inUnderlying = collateral.toLowerCase() === underlying.toLowerCase();
+    const { tx, calls } = await this.#service.openCA({
+      creditManager: cm.creditManager.address,
+      averageQuota: inUnderlying ? [] : [
+        {
+          token: collateral,
+          balance: this.#calcQuota(strategy.amount, debt, collateralLT)
+        }
+      ],
+      minQuota: inUnderlying ? [] : [
+        {
+          token: collateral,
+          balance: this.#calcQuota(strategy.minAmount, debt, collateralLT)
+        }
+      ],
+      collateral: [{ token: underlying, balance: minDebt }],
+      debt,
+      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 ${index}/${total}`);
+  }
+  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 !== sdk.ADDRESS_0X0) {
+        degenNFTS[degenNFT] = (degenNFTS[degenNFT] ?? 0) + 1;
+      }
+    }
+    claimUSD = claimUSD * 11n / 10n;
+    this.#logger?.debug(`claiming ${sdk.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 ${sdk.formatBN(claimUSD, 8)} USD from faucet, tx: ${hash}`
+      );
+    }
+    this.#logger?.debug(
+      `borrower ${borrower.address} claimed equivalent of ${sdk.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();
+    const symbol = this.#service.sdk.tokensMeta.symbol(token);
+    try {
+      if (symbol === "USDT") {
+        const hash2 = await this.#anvil.writeContract({
+          account: borrower,
+          address: token,
+          abi: sdk.ierc20Abi,
+          functionName: "approve",
+          args: [cm.creditManager.address, 0n],
+          chain: this.#anvil.chain
+        });
+        await this.#anvil.waitForTransactionReceipt({
+          hash: hash2
+        });
+      }
+      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 ${symbol} (${token}), tx reverted: ${hash}`
+        );
+      } else {
+        this.#logger?.debug(
+          `allowed credit manager ${cm.creditManager.name} to spend ${symbol} (${token}), tx: ${hash}`
+        );
+      }
+    } catch (e) {
+      this.#logger?.error(
+        `failed to allowed credit manager ${cm.creditManager.name} to spend ${symbol} (${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;
+  }
+  #calcQuota(amount, debt, lt) {
+    let quota = amount * lt / sdk.PERCENTAGE_FACTOR;
+    quota = debt < quota ? debt : quota;
+    quota = quota * (sdk.PERCENTAGE_FACTOR + 500n) / sdk.PERCENTAGE_FACTOR;
+    return quota / sdk.PERCENTAGE_FACTOR * sdk.PERCENTAGE_FACTOR;
+  }
+  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,13 +395,101 @@ 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);
     }
   }
   return result;
 }
+var SDKExample = class {
+  #sdk;
+  #logger;
+  constructor(logger) {
+    this.#logger = logger;
+  }
+  async run(opts) {
+    const {
+      addressProvider: ap,
+      addressProviderJson,
+      marketConfigurator: mc,
+      marketConfiguratorJson,
+      anvilUrl = "http://127.0.0.1:8545",
+      outFile
+    } = opts;
+    const addressProvider = await this.#readConfigAddress(
+      "addressProvider",
+      ap,
+      addressProviderJson
+    );
+    const marketConfigurator = await this.#readConfigAddress(
+      "marketConfigurator",
+      mc,
+      marketConfiguratorJson
+    );
+    this.#sdk = await sdk.GearboxSDK.attach({
+      rpcURLs: [anvilUrl],
+      timeout: 48e4,
+      addressProvider,
+      logger: this.#logger,
+      ignoreUpdateablePrices: true,
+      marketConfigurators: [marketConfigurator]
+    });
+    const puTx = await this.#sdk.priceFeeds.getUpdatePriceFeedsTx([
+      marketConfigurator
+    ]);
+    const updater = viem.createWalletClient({
+      account: accounts.privateKeyToAccount(
+        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+        // well-known anvil private key
+      ),
+      transport: viem.http(anvilUrl)
+    });
+    const publicClient = viem.createPublicClient({
+      transport: viem.http(anvilUrl)
+    });
+    const hash = await sdk.sendRawTx(updater, { tx: puTx });
+    await publicClient.waitForTransactionReceipt({ hash });
+    await this.#sdk.marketRegister.loadMarkets([marketConfigurator], true);
+    this.#logger?.info("attached sdk");
+    if (outFile) {
+      try {
+        await promises.writeFile(
+          outFile,
+          sdk.json_stringify(this.#sdk.stateHuman()),
+          "utf-8"
+        );
+      } catch (e) {
+        this.#logger?.error(`failed to write to ${outFile}: ${e}`);
+      }
+    }
+  }
+  async #readConfigAddress(name, value, file) {
+    let result = value;
+    if (!result) {
+      if (!file) {
+        throw new Error(`${name} is not specified`);
+      }
+      this.#logger?.debug(`reading ${name} json ${file}`);
+      const apFile = await promises.readFile(file, "utf-8").then(JSON.parse);
+      result = apFile[name];
+    }
+    if (!result) {
+      throw new Error(`${name} is not specified`);
+    }
+    if (!viem.isAddress(result)) {
+      throw new Error(`${name} is not a valid address: ${result}`);
+    }
+    this.#logger?.info(`using ${name} ${result}`);
+    return result;
+  }
+  get sdk() {
+    if (!this.#sdk) {
+      throw new Error("sdk is not attached");
+    }
+    return this.#sdk;
+  }
+};
 
 // src/dev/abi/v3.ts
 var iaclAbi = [
@@ -150,6 +591,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 +1869,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 +1888,122 @@ 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.address,
+        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.SDKExample = SDKExample;
+exports.anvilNodeInfo = anvilNodeInfo;
 exports.calcLiquidatableLTs = calcLiquidatableLTs;
+exports.createAnvilClient = createAnvilClient;
+exports.evmMineDetailed = evmMineDetailed;
+exports.isAnvil = isAnvil;
+exports.setLTZero = setLTZero;
 exports.setLTs = setLTs;