@gearbox-protocol/sdk 3.0.0-vfour.21 → 3.0.0-vfour.211

package/dist/esm/dev/index.mjs

@@ -1,7 +1,385 @@
-import { PERCENTAGE_FACTOR, AP_ACL, WAD } from '../sdk/index.mjs';
-import { createTestClient, publicActions, walletActions, toHex, parseEther } from 'viem';
+import { createTestClient, publicActions, walletActions, toHex, isAddress, parseEther, createWalletClient, http, createPublicClient, stringToHex } from 'viem';
+import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
+import { SDKConstruct, childLogger, AddressMap, sendRawTx, ADDRESS_0X0, formatBN, ierc20Abi, MAX_UINT256, iDegenNftv2Abi, PERCENTAGE_FACTOR, AP_PRICE_FEED_COMPRESSOR, iPriceFeedCompressorAbi, rawTxToMulticallPriceUpdate, GearboxSDK, json_stringify, iAddressProviderV3Abi, ADDRESS_PROVIDER, iAddressProviderV3_1Abi, WAD } from '../sdk/index.mjs';
+import { writeFile, readFile } from 'node:fs/promises';
 
-// src/dev/calcLiquidatableLTs.ts
+// src/dev/AccountOpener.ts
+function createAnvilClient({
+  chain,
+  transport
+}) {
+  return createTestClient(
+    {
+      chain,
+      mode: "anvil",
+      transport,
+      cacheTime: 0,
+      pollingInterval: 50
+    }
+  ).extend(publicActions).extend(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: [toHex(timestamp)]
+    });
+    return block;
+  } catch {
+    return undefined;
+  }
+}
+
+// src/dev/AccountOpener.ts
+var AccountOpener = class extends SDKConstruct {
+  #service;
+  #anvil;
+  #logger;
+  #borrower;
+  #faucet;
+  constructor(service, options = {}) {
+    super(service.sdk);
+    this.#service = service;
+    this.#logger = 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 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 averageQuota = this.#getCollateralQuota(
+      cm,
+      collateral,
+      strategy.amount,
+      debt
+    );
+    const minQuota = this.#getCollateralQuota(
+      cm,
+      collateral,
+      strategy.minAmount,
+      debt
+    );
+    logger?.debug({ averageQuota, minQuota }, "calculated quotas");
+    const { tx, calls } = await this.#service.openCA({
+      creditManager: cm.creditManager.address,
+      averageQuota,
+      minQuota,
+      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 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?.info(`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 (isAddress(degenNFT) && degenNFT !== ADDRESS_0X0) {
+        degenNFTS[degenNFT] = (degenNFTS[degenNFT] ?? 0) + 1;
+      }
+    }
+    claimUSD = claimUSD * 11n / 10n;
+    this.#logger?.debug(`claiming ${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 ${formatBN(claimUSD, 8)} USD from faucet, tx: ${hash}`
+      );
+    }
+    this.#logger?.debug(
+      `borrower ${borrower.address} claimed equivalent of ${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: 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: ierc20Abi,
+        functionName: "approve",
+        args: [cm.creditManager.address, 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: 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: parseEther("100")
+      });
+      const hash = await this.#anvil.writeContract({
+        account: minter,
+        address: degenNFT,
+        abi: 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 = privateKeyToAccount(generatePrivateKey());
+      await this.#anvil.setBalance({
+        address: this.#borrower.address,
+        value: parseEther("100")
+      });
+      this.#logger?.info(`created borrower ${this.#borrower.address}`);
+    }
+    return this.#borrower;
+  }
+  #getCollateralQuota(cm, collateral, amount, debt) {
+    const { underlying, collateralTokens } = cm;
+    const inUnderlying = collateral.toLowerCase() === underlying.toLowerCase();
+    if (inUnderlying) {
+      return [];
+    }
+    const collateralLT = BigInt(collateralTokens[collateral]);
+    const market = this.sdk.marketRegister.findByCreditManager(
+      cm.creditManager.address
+    );
+    const quotaInfo = market.pool.pqk.quotas.mustGet(collateral);
+    const availableQuota = quotaInfo.limit - quotaInfo.totalQuoted;
+    if (availableQuota <= 0n) {
+      throw new Error(
+        `quota exceeded for asset ${this.labelAddress(collateral)} in ${cm.name}`
+      );
+    }
+    const desiredQuota = this.#calcQuota(amount, debt, collateralLT);
+    return [
+      {
+        token: collateral,
+        balance: desiredQuota < availableQuota ? desiredQuota : availableQuota
+      }
+    ];
+  }
+  #calcQuota(amount, debt, lt) {
+    let quota = amount * lt / PERCENTAGE_FACTOR;
+    quota = debt < quota ? debt : quota;
+    quota = quota * (PERCENTAGE_FACTOR + 500n) / PERCENTAGE_FACTOR;
+    return quota / PERCENTAGE_FACTOR * PERCENTAGE_FACTOR;
+  }
+};
 async function calcLiquidatableLTs(sdk, ca, factor = 9990n, logger) {
   const cm = sdk.marketRegister.findCreditManager(ca.creditManager);
   const market = sdk.marketRegister.findByCreditManager(ca.creditManager);
@@ -40,51 +418,242 @@ async function calcLiquidatableLTs(sdk, ca, factor = 9990n, logger) {
     if (token !== ca.underlying) {
       const newLT = oldLT * k / WAD;
       logger?.debug(
-        `proposed ${sdk.marketRegister.tokensMeta.mustGet(token).symbol} LT change: ${oldLT} => ${newLT} `
+        `proposed ${sdk.tokensMeta.symbol(token)} LT change: ${oldLT} => ${newLT} `
       );
       result[token] = Number(newLT);
     }
   }
   return result;
 }
-function createAnvilClient({
-  chain,
-  transport
-}) {
-  return createTestClient(
-    {
-      chain,
-      mode: "anvil",
-      transport,
-      cacheTime: 0
-    }
-  ).extend(publicActions).extend(walletActions).extend((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 evmMineDetailed(client, timestamp) {
-  try {
-    const [block] = await client.request({
-      method: "evm_mine_detailed",
-      params: [toHex(timestamp)]
-    });
-    return block;
-  } catch {
-    return void 0;
+
+// src/dev/abi/iPriceFeedStore.ts
+var iPriceFeedStoreAbi = [
+  {
+    type: "function",
+    name: "addPriceFeed",
+    inputs: [
+      { name: "priceFeed", type: "address", internalType: "address" },
+      { name: "stalenessPeriod", type: "uint32", internalType: "uint32" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "allowPriceFeed",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "priceFeed", type: "address", internalType: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "contractType",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "forbidPriceFeed",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "priceFeed", type: "address", internalType: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getAllowanceTimestamp",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "priceFeed", type: "address", internalType: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getKnownPriceFeeds",
+    inputs: [],
+    outputs: [{ name: "", type: "address[]", internalType: "address[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getKnownTokens",
+    inputs: [],
+    outputs: [{ name: "", type: "address[]", internalType: "address[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getPriceFeeds",
+    inputs: [{ name: "token", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "address[]", internalType: "address[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getStalenessPeriod",
+    inputs: [{ name: "priceFeed", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint32", internalType: "uint32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getTokenPriceFeedsMap",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct ConnectedPriceFeed[]",
+        components: [
+          { name: "token", type: "address", internalType: "address" },
+          { name: "priceFeeds", type: "address[]", internalType: "address[]" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isAllowedPriceFeed",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "priceFeed", type: "address", internalType: "address" }
+    ],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setStalenessPeriod",
+    inputs: [
+      { name: "priceFeed", type: "address", internalType: "address" },
+      { name: "stalenessPeriod", type: "uint32", internalType: "uint32" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "version",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "AddPriceFeed",
+    inputs: [
+      {
+        name: "priceFeed",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "stalenessPeriod",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AllowPriceFeed",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "priceFeed",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "ForbidPriceFeed",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "priceFeed",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetStalenessPeriod",
+    inputs: [
+      {
+        name: "priceFeed",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "stalenessPeriod",
+        type: "uint32",
+        indexed: false,
+        internalType: "uint32"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "CallerIsNotOwnerException",
+    inputs: [{ name: "caller", type: "address", internalType: "address" }]
+  },
+  {
+    type: "error",
+    name: "PriceFeedAlreadyAddedException",
+    inputs: [{ name: "priceFeed", type: "address", internalType: "address" }]
+  },
+  {
+    type: "error",
+    name: "PriceFeedIsNotAllowedException",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "priceFeed", type: "address", internalType: "address" }
+    ]
+  },
+  {
+    type: "error",
+    name: "PriceFeedNotKnownException",
+    inputs: [{ name: "priceFeed", type: "address", internalType: "address" }]
   }
-}
+];
 
 // src/dev/abi/v3.ts
 var iaclAbi = [
@@ -186,6 +755,21 @@ var iaclAbi = [
     name: "AddressNotUnpausableAdminException"
   }
 ];
+var iaclTraitAbi = [
+  {
+    type: "function",
+    name: "acl",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  }
+];
 var iCreditConfiguratorV3Abi = [
   {
     type: "function",
@@ -1448,18 +2032,219 @@ var iCreditManagerV3Abi = [
   }
 ];
 
-// src/dev/setLTs.ts
-async function setLTs(sdk, cm, newLTs, logger) {
-  const aclAddr = sdk.addressProvider.getLatestVersion(AP_ACL);
-  const configuratorAddr = await sdk.provider.publicClient.readContract({
+// src/dev/PriceFeedStore.ts
+var PriceFeedStore = class extends SDKConstruct {
+  #store;
+  #compressor;
+  #logger;
+  constructor(sdk) {
+    super(sdk);
+    this.#store = this.sdk.addressProvider.getAddress("PRICE_FEED_STORE");
+    this.#compressor = this.sdk.addressProvider.getLatestVersion(
+      AP_PRICE_FEED_COMPRESSOR
+    );
+    this.#logger = sdk.logger?.child?.({
+      module: "PriceFeedStore"
+    });
+  }
+  async load(update = true) {
+    const pfMap = await this.provider.publicClient.readContract({
+      address: this.#store,
+      abi: iPriceFeedStoreAbi,
+      functionName: "getTokenPriceFeedsMap"
+    });
+    const addresses = pfMap.flatMap((f) => f.priceFeeds);
+    const nodes = await this.#loadFromCompressor(addresses, update);
+    const result = new AddressMap();
+    for (const { token, priceFeeds } of pfMap) {
+      result.upsert(
+        token,
+        priceFeeds.map((pf) => nodes.find((n) => n.baseParams.addr === pf)).filter(Boolean)
+      );
+    }
+    return result;
+  }
+  async #loadFromCompressor(priceFeeds, update = true) {
+    let result = await this.provider.publicClient.readContract({
+      address: this.#compressor,
+      abi: iPriceFeedCompressorAbi,
+      functionName: "loadPriceFeedTree",
+      args: [priceFeeds]
+    });
+    if (update) {
+      const feeds = result.map((f) => this.sdk.priceFeeds.create(f));
+      const { txs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(feeds);
+      const resp = await this.provider.publicClient.multicall({
+        contracts: [
+          ...txs.map(rawTxToMulticallPriceUpdate),
+          {
+            address: this.#compressor,
+            abi: iPriceFeedCompressorAbi,
+            functionName: "loadPriceFeedTree",
+            args: [priceFeeds]
+          }
+        ],
+        allowFailure: false
+      });
+      result = resp.pop();
+    }
+    this.#logger?.debug(
+      `loaded ${result.length} price feed nodes from compressor`
+    );
+    return [...result];
+  }
+};
+var SDKExample = class {
+  #sdk;
+  #logger;
+  constructor(logger) {
+    this.#logger = logger;
+  }
+  async run(opts) {
+    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: 48e4,
+      addressProvider,
+      logger: this.#logger,
+      ignoreUpdateablePrices: true,
+      marketConfigurators
+    });
+    await this.#safeMigrateFaucet(addressProvider);
+    const puTx = await this.#sdk.priceFeeds.getUpdatePriceFeedsTx(marketConfigurators);
+    const updater = createWalletClient({
+      account: privateKeyToAccount(
+        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+        // well-known anvil private key
+      ),
+      transport: http(anvilUrl)
+    });
+    const publicClient = createPublicClient({
+      transport: http(anvilUrl)
+    });
+    const hash = await sendRawTx(updater, { tx: puTx });
+    await publicClient.waitForTransactionReceipt({ hash });
+    await this.#sdk.marketRegister.loadMarkets(marketConfigurators, true);
+    try {
+      await this.#sdk.marketRegister.loadZappers();
+    } catch (e) {
+      this.#logger?.error(`failed to load zappers: ${e}`);
+    }
+    this.#logger?.info("attached sdk");
+    if (outFile) {
+      try {
+        await writeFile(
+          outFile,
+          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 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;
+  }
+  async #safeMigrateFaucet(addressProvider) {
+    try {
+      await this.#migrateFaucet(addressProvider);
+      this.#logger?.info("faucet migrated successfully");
+    } catch (e) {
+      this.#logger?.error(`faucet migration failed: ${e}`);
+    }
+  }
+  /**
+   * Migrates faucet from address provider v3 to v3.1
+   * @param addressProvider 3.1 address provider
+   */
+  async #migrateFaucet(addressProvider) {
+    const anvil = createAnvilClient({
+      chain: this.sdk.provider.chain,
+      transport: this.sdk.provider.transport
+    });
+    const [faucetAddr, owner] = await anvil.multicall({
+      contracts: [
+        {
+          abi: iAddressProviderV3Abi,
+          address: ADDRESS_PROVIDER[this.sdk.provider.networkType],
+          functionName: "getAddressOrRevert",
+          args: [stringToHex("FAUCET", { size: 32 }), 0n]
+        },
+        {
+          abi: iAddressProviderV3_1Abi,
+          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: iAddressProviderV3_1Abi,
+      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");
+    }
+  }
+  get sdk() {
+    if (!this.#sdk) {
+      throw new Error("sdk is not attached");
+    }
+    return this.#sdk;
+  }
+};
+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 = createAnvilClient({
-    transport: sdk.provider.transport,
-    chain: sdk.provider.chain
-  });
   await anvil.impersonateAccount({
     address: configuratorAddr
   });
@@ -1468,27 +2253,114 @@ async function setLTs(sdk, cm, newLTs, logger) {
     value: 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.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: 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(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(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: 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 });
+}
 
-export { calcLiquidatableLTs, createAnvilClient, evmMineDetailed, isAnvil, setLTs };
+export { AccountOpener, PriceFeedStore, SDKExample, anvilNodeInfo, calcLiquidatableLTs, createAnvilClient, evmMineDetailed, isAnvil, setLTZero, setLTs };