@gearbox-protocol/sdk 3.0.0-vfour.90 → 3.0.0-vfour.92

package/dist/cjs/sdk/index.cjs

@@ -22320,986 +22320,1081 @@ var MarketRegister = class extends SDKConstruct {
     return this.#curators;
   }
 };
-
-// src/sdk/accounts/CreditAccountsService.ts
-var CreditAccountsService = class extends SDKConstruct {
-  #compressor;
-  constructor(sdk) {
-    super(sdk);
-    this.#compressor = sdk.addressProvider.getLatestVersion(
-      AP_CREDIT_ACCOUNT_COMPRESSOR
+var PathOptionFactory = class _PathOptionFactory {
+  // TODO: get rid of token data from SDK
+  static generatePathOptions(balances, network, loopsInTx) {
+    const curvePools = _PathOptionFactory.getCurvePools(balances);
+    const balancerPools = _PathOptionFactory.getBalancerPools(balances);
+    const curveInitPO = curvePools.map((symbol) => {
+      return {
+        target: sdkGov.tokenDataByNetwork[network][symbol],
+        option: 0,
+        totalOptions: sdkGov.contractParams[sdkGov.curveTokens[symbol].pool].tokens.length
+      };
+    });
+    const balancerInitPO = balancerPools.map((symbol) => {
+      return {
+        target: sdkGov.tokenDataByNetwork[network][symbol],
+        option: 0,
+        totalOptions: sdkGov.balancerLpTokens[symbol].underlying.length
+      };
+    });
+    const initPO = [...curveInitPO, ...balancerInitPO];
+    const totalLoops = initPO.reduce(
+      (acc, item) => acc * item.totalOptions,
+      1
     );
-  }
-  /**
-   * Returns single credit account data, or undefined if it's not found
-   * Performs all necessary price feed updates under the hood
-   * @param account
-   * @param options
-   * @returns
-   */
-  async getCreditAccountData(account, options) {
-    const blockNumber = options?.blockNumber;
-    let raw;
-    try {
-      raw = await this.provider.publicClient.readContract({
-        abi: iCreditAccountCompressorAbi,
-        address: this.#compressor,
-        functionName: "getCreditAccountData",
-        args: [account],
-        blockNumber
-      });
-    } catch (e) {
-      return void 0;
-    }
-    if (raw.success) {
-      return raw;
+    const result = [];
+    let currentPo = [...initPO];
+    for (let i = 0; i < totalLoops; i++) {
+      if (i % loopsInTx === 0) {
+        result.push(currentPo);
+      }
+      if (i < totalLoops - 1) {
+        currentPo = _PathOptionFactory.next(currentPo);
+      }
     }
-    const { txs: priceUpdateTxs, timestamp: _ } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
-    const resp = await simulateMulticall(this.provider.publicClient, {
-      contracts: [
-        ...priceUpdateTxs.map(rawTxToMulticallPriceUpdate),
-        {
-          abi: iCreditAccountCompressorAbi,
-          address: this.#compressor,
-          functionName: "getCreditAccountData",
-          args: [account]
-        }
-      ],
-      allowFailure: false,
-      gas: 550000000n,
-      batchSize: 0,
-      // we cannot have price updates and compressor request in different batches
-      blockNumber
-    });
-    const cad = resp.pop();
-    return cad;
+    return result;
   }
-  /**
-   * Methods to get all credit accounts with some optional filtering
-   * Performs all necessary price feed updates under the hood
-   *
-   * TODO: do we want to expose pagination?
-   * TODO: do we want to expose "reverting"?
-   * TODO: do we want to expose MarketFilter in any way? If so, we need to check that the MarketFilter is compatibled with attached markets?
-   * @param args
-   * @param options
-   * @returns returned credit accounts are sorted by health factor in ascending order
-   */
-  async getCreditAccounts(args, options) {
-    const {
-      creditManager,
-      includeZeroDebt = false,
-      maxHealthFactor = 65535,
-      // TODO: this will change to bigint
-      minHealthFactor = 0,
-      owner = ADDRESS_0X0
-    } = args ?? {};
-    const arg0 = creditManager ?? {
-      curators: [],
-      pools: this.pools,
-      underlying: ADDRESS_0X0
-    };
-    const caFilter = {
-      owner,
-      includeZeroDebt,
-      minHealthFactor,
-      maxHealthFactor
-    };
-    const { txs: priceUpdateTxs, timestamp: _ } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
-    const allCAs = [];
-    for (const reverting of [false, true]) {
-      let offset = 0n;
-      do {
-        const [accounts, newOffset] = await this.#getCreditAccounts(
-          [arg0, { ...caFilter, reverting }, offset],
-          priceUpdateTxs,
-          options
-        );
-        allCAs.push(...accounts);
-        offset = newOffset;
-      } while (offset !== 0n);
+  static getCurvePools(balances) {
+    const nonZeroBalances = balances.filter((b) => b.balance > 1n);
+    const curvePools = nonZeroBalances.map((b) => sdkGov.getTokenSymbol(b.token)).filter((symbol) => sdkGov.isCurveLPToken(symbol));
+    const yearnCurveTokens = Object.entries(sdkGov.yearnTokens).filter(([, data]) => sdkGov.isCurveLPToken(data.underlying)).map(([token]) => token);
+    const curvePoolsFromYearn = nonZeroBalances.map((b) => sdkGov.getTokenSymbol(b.token)).filter((symbol) => yearnCurveTokens.includes(symbol)).map(
+      (symbol) => sdkGov.yearnTokens[symbol].underlying
+    );
+    const convexCurveTokens = Object.entries(sdkGov.convexTokens).filter(([, data]) => sdkGov.isCurveLPToken(data.underlying)).map(([token]) => token);
+    const curvePoolsFromConvex = nonZeroBalances.map((b) => sdkGov.getTokenSymbol(b.token)).filter((symbol) => convexCurveTokens.includes(symbol)).map((symbol) => sdkGov.convexTokens[symbol].underlying);
+    const curveSet = /* @__PURE__ */ new Set([
+      ...curvePools,
+      ...curvePoolsFromYearn,
+      ...curvePoolsFromConvex
+    ]);
+    return Array.from(curveSet.values());
+  }
+  static getBalancerPools(balances) {
+    const nonZeroBalances = Object.entries(balances).filter(
+      ([, balance]) => balance.balance > 1
+    );
+    const balancerPools = nonZeroBalances.map(([token]) => sdkGov.getTokenSymbol(token)).filter((symbol) => sdkGov.isBalancerLPToken(symbol));
+    const balancerAuraTokens = Object.entries(sdkGov.auraTokens).filter(([, data]) => sdkGov.isBalancerLPToken(data.underlying)).map(([token]) => token);
+    const balancerTokensFromAura = nonZeroBalances.map(([token]) => sdkGov.getTokenSymbol(token)).filter((symbol) => balancerAuraTokens.includes(symbol)).map(
+      (symbol) => sdkGov.auraTokens[symbol].underlying
+    );
+    const balancerSet = /* @__PURE__ */ new Set([...balancerPools, ...balancerTokensFromAura]);
+    return Array.from(balancerSet.values());
+  }
+  static next(path) {
+    let newPath = [...path];
+    for (let i = path.length - 1; i >= 0; i--) {
+      const po = { ...newPath[i] };
+      po.option++;
+      newPath[i] = po;
+      if (po.option < po.totalOptions) return newPath;
+      po.option = 0;
     }
-    return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
+    throw new Error("Path options overflow");
   }
-  /**
-   * Generates transaction to liquidate credit account
-   * @param account
-   * @param to Address to transfer underlying left after liquidation
-   * @param slippage
-   * @returns
-   */
-  async fullyLiquidate(account, to, slippage = 50n) {
-    const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
-    const routerCloseResult = await this.sdk.router.findBestClosePath({
-      creditAccount: account,
-      creditManager: cm.creditManager,
-      slippage
+};
+
+// src/sdk/router/RouterV3Contract.ts
+var MAX_GAS_PER_ROUTE = 200000000n;
+var GAS_PER_BLOCK = 400000000n;
+var LOOPS_PER_TX = Number(GAS_PER_BLOCK / MAX_GAS_PER_ROUTE);
+var SWAP_OPERATIONS = {
+  EXACT_INPUT: 0,
+  EXACT_INPUT_ALL: 1,
+  EXACT_OUTPUT: 2
+};
+var RouterV3Contract = class extends BaseContract {
+  #connectors;
+  #hooks = new Hooks();
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "RouterV3",
+      abi: routerV3Abi
     });
-    const priceUpdates = await this.getPriceUpdatesForFacade(account);
-    const tx = cm.creditFacade.liquidateCreditAccount(
-      account.creditAccount,
-      to,
-      [...priceUpdates, ...routerCloseResult.calls]
-    );
-    return { tx, routerCloseResult };
+    this.#connectors = sdkGov.getConnectors(sdk.provider.networkType);
   }
+  addHook = this.#hooks.addHook.bind(this.#hooks);
+  removeHook = this.#hooks.removeHook.bind(this.#hooks);
   /**
-   * Closes credit account or sets debt to zero (but keep account)
-   * @param operation
-   * @param creditAccount
-   * @param assetsToWithdraw Tokens to withdraw from credit account
-   * @param to Address to withdraw underlying to
+   * Finds all available swaps for NORMAL tokens
+   * @param ca
+   * @param cm
+   * @param swapOperation
+   * @param tokenIn
+   * @param tokenOut
+   * @param amount
+   * @param leftoverAmount
    * @param slippage
-   * @param closePath
    * @returns
    */
-  async closeCreditAccount({
-    operation,
-    assetsToWithdraw,
+  async findAllSwaps({
     creditAccount: ca,
-    to,
-    slippage = 50n,
-    closePath
+    creditManager: cm,
+    swapOperation,
+    tokenIn,
+    tokenOut,
+    amount,
+    leftoverAmount,
+    slippage
   }) {
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
-    const routerCloseResult = closePath || await this.sdk.router.findBestClosePath({
-      creditAccount: ca,
-      creditManager: cm.creditManager,
-      slippage
-    });
-    const calls = [
-      ...routerCloseResult.calls,
-      ...this.#prepareDisableQuotas(ca),
-      ...this.#prepareDecreaseDebt(ca),
-      ...this.#prepareDisableTokens(ca),
-      ...assetsToWithdraw.map(
-        (t) => this.#prepareWithdrawToken(ca, t, MAX_UINT256, to)
-      )
-    ];
-    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
-    return { tx, calls, routerCloseResult };
-  }
-  /**
-   * Repays credit account or sets debt to zero (but keep account)
-   * @param operation
-   * @param creditAccount
-   * @param assetsToWithdraw Tokens to withdraw from credit account
-   * @param collateralAssets Tokens to pay for
-   * @param to Address to withdraw underlying to
-   * @param slippage
-   * @param permits
-   * @returns
-   */
-  async repayCreditAccount({
-    operation,
-    collateralAssets,
-    assetsToWithdraw,
-    creditAccount: ca,
-    permits,
-    to
-  }) {
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
-    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
-    const calls = [
-      ...this.#prepareAddCollateralCalls(addCollateral, ca, permits),
-      ...this.#prepareDisableQuotas(ca),
-      ...this.#prepareDecreaseDebt(ca),
-      ...this.#prepareDisableTokens(ca),
-      // TODO: probably needs a way to handle reward tokens
-      ...assetsToWithdraw.map(
-        (t) => this.#prepareWithdrawToken(ca, t, MAX_UINT256, to)
-      )
-    ];
-    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
-    return { tx, calls };
+    const connectors = this.getAvailableConnectors(cm.collateralTokens);
+    const swapTask = {
+      swapOperation: SWAP_OPERATIONS[swapOperation],
+      creditAccount: ca.creditAccount,
+      tokenIn,
+      tokenOut,
+      connectors,
+      amount,
+      leftoverAmount
+    };
+    const { result } = await this.contract.simulate.findAllSwaps(
+      [swapTask, BigInt(slippage)],
+      {
+        gas: GAS_PER_BLOCK
+      }
+    );
+    const unique = {};
+    result.forEach((r) => {
+      const key = `${r.minAmount.toString()}${r.calls.map((c) => `${c.target.toLowerCase()}${c.callData}`).join("-")}`;
+      unique[key] = {
+        amount: r.amount,
+        minAmount: r.minAmount,
+        calls: [...r.calls]
+      };
+    });
+    return Object.values(unique);
   }
   /**
-   * Repays liquidatable credit account
+   * Finds best path to swap all Normal tokens and tokens "on the way" to target one and vice versa
    * @param creditAccount
-   * @param assetsToWithdraw Tokens to withdraw from credit account
-   * @param collateralAssets Tokens to pay for
-   * @param to Address to withdraw underlying to
+   * @param creditManager
+   * @param tokenIn
+   * @param tokenOut
+   * @param amount
    * @param slippage
    * @returns
    */
-  async repayAndLiquidateCreditAccount({
-    collateralAssets,
-    assetsToWithdraw,
+  async findOneTokenPath({
     creditAccount: ca,
-    permits,
-    to
+    creditManager: cm,
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage
   }) {
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
-    const priceUpdates = await this.getPriceUpdatesForFacade(ca);
-    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
-    const calls = [
-      ...priceUpdates,
-      ...this.#prepareAddCollateralCalls(addCollateral, ca, permits),
-      ...assetsToWithdraw.map(
-        (t) => this.#prepareWithdrawToken(ca, t, MAX_UINT256, to)
-      )
-    ];
-    const tx = cm.creditFacade.liquidateCreditAccount(
-      ca.creditAccount,
-      to,
-      calls
+    const connectors = this.getAvailableConnectors(cm.collateralTokens);
+    const { result } = await this.contract.simulate.findOneTokenPath(
+      [
+        tokenIn,
+        amount,
+        tokenOut,
+        ca.creditAccount,
+        connectors,
+        BigInt(slippage)
+      ],
+      {
+        gas: GAS_PER_BLOCK
+      }
     );
-    return { tx, calls };
-  }
-  /**
-   * Internal wrapper for CreditAccountCompressor.getCreditAccounts + price updates wrapped into multicall
-   * @param args
-   * @param priceUpdateTxs
-   * @param options
-   * @returns
-   */
-  async #getCreditAccounts(args, priceUpdateTxs, options) {
-    const blockNumber = options?.blockNumber;
-    if (priceUpdateTxs?.length) {
-      const resp = await simulateMulticall(this.provider.publicClient, {
-        contracts: [
-          ...priceUpdateTxs.map(rawTxToMulticallPriceUpdate),
-          {
-            abi: iCreditAccountCompressorAbi,
-            address: this.#compressor,
-            functionName: "getCreditAccounts",
-            args
-          }
-        ],
-        allowFailure: false,
-        gas: 550000000n,
-        batchSize: 0,
-        // we cannot have price updates and compressor request in different batches
-        blockNumber
-      });
-      const getCreditAccountsResp = resp.pop();
-      return getCreditAccountsResp;
-    }
-    return this.provider.publicClient.readContract({
-      abi: iCreditAccountCompressorAbi,
-      address: this.#compressor,
-      functionName: "getCreditAccounts",
-      args,
-      blockNumber
-    });
+    return {
+      amount: result.amount,
+      minAmount: result.minAmount,
+      calls: [...result.calls]
+    };
   }
   /**
-   * Returns raw txs that are needed to update all price feeds so that all credit accounts (possibly from different markets) compute
-   * @param accounts
-   * @returns
+   * @dev Finds the best path for opening Credit Account and converting all NORMAL tokens and LP token in the way to TARGET
+   * @param creditManager CreditManagerData which represents credit manager you want to use to open Credit Account
+   * @param expectedBalances Expected balances which would be on account accounting also debt. For example,
+   *    if you open an USDC Credit Account, borrow 50_000 USDC and provide 10 WETH and 10_USDC as collateral
+   *    from your own funds, expectedBalances should be: { "USDC": 60_000 * (10**6), "<address of WETH>": WAD.mul(10) }
+   * @param leftoverBalances Balances to keep on account after opening
+   * @param target Address of symbol of desired token
+   * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
+   * @returns PathFinderOpenStrategyResult which
    */
-  async getUpdateForAccounts(accounts) {
-    const tokensByPool = /* @__PURE__ */ new Map();
-    const oracleByPool = /* @__PURE__ */ new Map();
-    for (const acc of accounts) {
-      const market = this.sdk.marketRegister.findByCreditManager(
-        acc.creditManager
-      );
-      const pool = market.poolFactory.pool.address;
-      oracleByPool.set(pool, market.priceOracle);
-      for (const t of acc.tokens) {
-        if (t.balance > 10n) {
-          const tokens = tokensByPool.get(pool) ?? /* @__PURE__ */ new Set();
-          tokens.add(t.token);
-          tokensByPool.set(pool, tokens);
-        }
+  async findOpenStrategyPath({
+    creditManager: cm,
+    expectedBalances,
+    leftoverBalances,
+    target,
+    slippage
+  }) {
+    const [expectedMap, leftoverMap] = [
+      balancesMap(expectedBalances),
+      balancesMap(leftoverBalances)
+    ];
+    const input = cm.collateralTokens.map((token) => ({
+      token,
+      balance: expectedMap.get(token) ?? 0n
+    }));
+    const leftover = cm.collateralTokens.map((token) => ({
+      token,
+      balance: leftoverMap.get(token) ?? 0n
+    }));
+    const connectors = this.getAvailableConnectors(cm.collateralTokens);
+    const {
+      result: [outBalances, result]
+    } = await this.contract.simulate.findOpenStrategyPath(
+      [cm.address, input, leftover, target, connectors, BigInt(slippage)],
+      {
+        gas: GAS_PER_BLOCK
       }
-    }
-    const priceFeeds = [];
-    for (const [pool, priceFeedFactory] of oracleByPool.entries()) {
-      const tokens = Array.from(tokensByPool.get(pool) ?? []);
-      priceFeeds.push(...priceFeedFactory.priceFeedsForTokens(tokens));
-    }
-    return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
-  }
-  /**
-   * Returns account price updates in a non-encoded format
-   * @param acc
-   * @returns
-   */
-  async getOnDemandPriceUpdates(acc) {
-    const market = this.sdk.marketRegister.findByCreditManager(
-      acc.creditManager
     );
-    const update = await this.getUpdateForAccounts([acc]);
-    return market.priceOracle.onDemandPriceUpdates(update);
+    const balancesAfter = Object.fromEntries(
+      outBalances.map((b) => [b.token.toLowerCase(), b.balance])
+    );
+    return {
+      balances: {
+        ...balancesAfter,
+        [target]: (expectedMap.get(target) ?? 0n) + result.amount
+      },
+      minBalances: {
+        ...balancesAfter,
+        [target]: (expectedMap.get(target) ?? 0n) + result.minAmount
+      },
+      amount: result.amount,
+      minAmount: result.minAmount,
+      calls: [...result.calls]
+    };
   }
   /**
-   * Returns price updates in format that is accepted by various credit facade methods (multicall, close/liquidate, etc...)
-   * @param acc
-   * @returns
+   * @dev Finds the path to swap / withdraw all assets from CreditAccount into underlying asset
+   *   Can bu used for closing Credit Account and for liquidations as well.
+   * @param creditAccount CreditAccountStruct object used for close path computation
+   * @param creditManager CreditManagerSlice for corresponding credit manager
+   * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
+   * @return The best option in PathFinderCloseResult format, which
+   *          - underlyingBalance - total balance of underlying token
+   *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
    */
-  async getPriceUpdatesForFacade(acc) {
-    const cm = this.sdk.marketRegister.findCreditManager(acc.creditManager);
-    const updates = await this.getOnDemandPriceUpdates(acc);
-    return cm.creditFacade.encodeOnDemandPriceUpdates(updates);
-  }
-  #prepareDisableQuotas(ca) {
-    const calls = [];
-    for (const { token, quota } of ca.tokens) {
-      if (quota > 0n) {
-        calls.push({
-          target: ca.creditFacade,
-          callData: viem.encodeFunctionData({
-            abi: iCreditFacadeV3MulticallAbi,
-            functionName: "updateQuota",
-            args: [token, MIN_INT96, 0n]
-          })
-        });
-      }
-    }
-    return calls;
-  }
-  #prepareDecreaseDebt(ca) {
-    if (ca.debt > 0n) {
-      return [
-        {
-          target: ca.creditFacade,
-          callData: viem.encodeFunctionData({
-            abi: iCreditFacadeV3MulticallAbi,
-            functionName: "decreaseDebt",
-            args: [MAX_UINT256]
-          })
-        }
-      ];
-    }
-    return [];
-  }
-  #prepareDisableTokens(ca) {
-    const calls = [];
-    for (const t of ca.tokens) {
-      if (t.token !== ca.underlying && (t.mask & ca.enabledTokensMask) !== 0n && t.quota === 0n) {
-        calls.push({
-          target: ca.creditFacade,
-          callData: viem.encodeFunctionData({
-            abi: iCreditFacadeV3MulticallAbi,
-            functionName: "disableToken",
-            args: [t.token]
-          })
-        });
-      }
-    }
-    return calls;
-  }
-  #prepareWithdrawToken(ca, token, amount, to) {
-    return {
-      target: ca.creditFacade,
-      callData: viem.encodeFunctionData({
-        abi: iCreditFacadeV3MulticallAbi,
-        functionName: "withdrawCollateral",
-        args: [token, amount, to]
-      })
-    };
-  }
-  #prepareAddCollateralCalls(assets, ca, permits) {
-    const calls = assets.map(({ token, balance }) => {
-      const p = permits[token];
-      if (p) {
-        return {
-          target: ca.creditFacade,
-          callData: viem.encodeFunctionData({
-            abi: iCreditFacadeV3MulticallAbi,
-            functionName: "addCollateralWithPermit",
-            args: [token, balance, p.deadline, p.v, p.r, p.s]
-          })
-        };
-      }
-      return {
-        target: ca.creditFacade,
-        callData: viem.encodeFunctionData({
-          abi: iCreditFacadeV3MulticallAbi,
-          functionName: "addCollateral",
-          args: [token, balance]
-        })
-      };
-    });
-    return calls;
-  }
-  /**
-   * Returns addresses of pools of attached markets
-   */
-  get pools() {
-    return this.sdk.marketRegister.pools.map((p) => p.pool.address);
-  }
-};
-var AddressProviderContractV3_1 = class extends BaseContract {
-  #addresses = {};
-  versions = {};
-  latest = {};
-  constructor(sdk, address) {
-    super(sdk, {
-      addr: address,
-      name: "AddressProviderV3",
-      abi: iAddressProviderV3_1Abi
-    });
-  }
-  parseFunctionParams(params) {
-    switch (params.functionName) {
-      case "setAddress": {
-        if (params.args.length !== 3) {
-          const [key2, saveVersion2] = params.args;
-          return [key2, `${saveVersion2}`];
-        }
-        const [key, value, saveVersion] = params.args;
-        return [viem.bytesToString(viem.toBytes(key)), value, `${saveVersion}`];
-      }
-      default:
-        return void 0;
-    }
-  }
-  setInternalAddress(key, address, version) {
-    if (!this.#addresses[key]) {
-      this.#addresses[key] = {};
-    }
-    this.#addresses[key][version] = address;
-    if (!this.latest[key] || version > this.latest[key]) {
-      this.latest[key] = version;
-    }
-    if (!this.versions[key]) {
-      this.versions[key] = /* @__PURE__ */ new Set();
-    }
-    this.versions[key].add(version);
-  }
-  getAddress(contract, version = NO_VERSION) {
-    if (!this.#addresses[contract]) {
-      throw new Error(`Address ${contract}, version: ${version} not found`);
-    }
-    const result = this.#addresses[contract][version];
-    if (!result) {
-      throw new Error(`Address ${contract}, version: ${version} not found`);
-    }
-    return result;
-  }
-  getLatestVersion(contract) {
-    if (!this.latest[contract]) {
-      throw new Error(`Latest version for ${contract} not found`);
-    }
-    this.logger?.debug(
-      `Latest version found for ${contract} : ${this.latest[contract]}`
+  async findBestClosePath({
+    creditAccount: ca,
+    creditManager: cm,
+    slippage,
+    balances
+  }) {
+    const { pathOptions, expected, leftover, connectors } = this.getFindClosePathInput(
+      ca,
+      cm,
+      balances ? {
+        expectedBalances: assetsMap(balances.expectedBalances),
+        leftoverBalances: assetsMap(balances.leftoverBalances)
+      } : void 0
     );
-    return this.getAddress(contract, this.latest[contract]);
-  }
-  async syncState(blockNumber) {
-    const entries = await this.contract.read.getAllSavedContracts({
-      blockNumber
-    });
-    for (const log of entries) {
-      this.setInternalAddress(log.key, log.value, Number(log.version));
-    }
-  }
-  stateHuman(raw = true) {
-    return {
-      ...super.stateHuman(raw),
-      addresses: Object.entries(this.#addresses).map(([key, value]) => {
-        return Object.entries(value).map(([version, address]) => {
-          return {
-            key,
-            version,
-            address: this.sdk.provider.addressLabels.get(address)
-          };
-        });
-      }).reduce(
-        (acc, vals) => {
-          for (const val of vals) {
-            if (!acc[val.key]) {
-              acc[val.key] = {};
-            }
-            acc[val.key][val.version] = val.address;
-          }
-          return acc;
-        },
-        {}
-      )
-    };
-  }
-  processLog(log) {
-    switch (log.eventName) {
-      case "SetAddress": {
-        const parsedLog2 = viem.parseEventLogs({
-          abi: this.abi,
-          eventName: "SetAddress",
-          logs: [log]
-        })[0];
-        const key = parsedLog2.args.key;
-        this.setInternalAddress(
-          key,
-          log.args.value,
-          Number(parsedLog2.args.version)
-        );
-        break;
-      }
-      default:
-        this.logger?.warn(`Unknown event: ${log.eventName}`);
-        break;
-    }
-  }
-};
-
-// src/sdk/core/BotListV3Contract.ts
-var BotListContract = class extends BaseContract {
-  #approvedCreditManagers;
-  #currentBlock;
-  constructor(sdk, address) {
-    super(sdk, { addr: address, name: "BotListV3", abi: botListV3Abi });
-    this.#currentBlock = ADDRESS_PROVIDER_BLOCK[sdk.provider.networkType];
-  }
-  parseFunctionParams(params) {
-    switch (params.functionName) {
-      case "setCreditManagerApprovedStatus": {
-        const [creditManager, status] = params.args;
-        return [this.addressLabels.get(creditManager), `${status}`];
-      }
-      case "setBotSpecialPermissions": {
-        const [bot, creditManager, permissions] = params.args;
-        return [
-          this.addressLabels.get(bot),
-          this.addressLabels.get(creditManager),
-          botPermissionsToString(permissions)
-        ];
-      }
-      default:
-        return void 0;
-    }
-  }
-  async syncState(toBlock) {
-    const logs = await this.provider.publicClient.getContractEvents({
-      address: this.address,
-      abi: this.abi,
-      fromBlock: this.#currentBlock,
-      toBlock
+    await this.#hooks.triggerHooks("foundPathOptions", {
+      creditAccount: ca.creditAccount,
+      pathOptions,
+      expected,
+      leftover,
+      connectors
     });
-    logs.forEach((e) => this.processLog(e));
-    this.#currentBlock = toBlock;
-  }
-  processLog(log) {
-    switch (log.eventName) {
-      case "SetCreditManagerApprovedStatus":
-        if (log.args.approved) {
-          this.approvedCreditManagers.add(log.args.creditManager);
-        } else {
-          this.approvedCreditManagers.delete(log.args.creditManager);
-        }
-        break;
-      case "SetBotSpecialPermissions":
-        this.logger?.debug(
-          `Bot ${log.args.bot} has been given permissions ${botPermissionsToString(
-            log.args.permissions
-          )} for credit manager ${log.args.creditManager}`
-        );
-        break;
-      default:
-        this.logger?.warn(`Unknown event: ${log.eventName}`);
-        break;
+    let results = [];
+    for (const po of pathOptions) {
+      const { result: result2 } = await this.contract.simulate.findBestClosePath(
+        [
+          ca.creditAccount,
+          expected,
+          leftover,
+          connectors,
+          BigInt(slippage),
+          po,
+          BigInt(LOOPS_PER_TX),
+          false
+        ],
+        {
+          gas: GAS_PER_BLOCK
+        }
+      );
+      results.push({
+        ...result2,
+        calls: [...result2.calls]
+      });
     }
+    const bestResult = results.reduce(compareRouterResults, {
+      amount: 0n,
+      minAmount: 0n,
+      calls: []
+    });
+    const underlyingBalance = ca.tokens.find((t) => t.token === ca.underlying)?.balance ?? 0n;
+    const result = {
+      amount: bestResult.amount,
+      minAmount: bestResult.minAmount,
+      calls: bestResult.calls.map((c) => ({
+        callData: c.callData,
+        target: c.target
+      })),
+      underlyingBalance: underlyingBalance + bestResult.minAmount
+    };
+    return result;
   }
-  get approvedCreditManagers() {
-    if (!this.#approvedCreditManagers) {
-      throw new Error(
-        "BotListContract state needs to be synced to load approvedCreditManagers"
-      );
+  /**
+   * Finds input to be used with findBestClosePath
+   * @param ca
+   * @param cm
+   * @returns
+   */
+  getFindClosePathInput(ca, cm, balances) {
+    const b = balances || this.getDefaultExpectedAndLeftover(ca);
+    const { leftoverBalances, expectedBalances } = b;
+    const pathOptions = PathOptionFactory.generatePathOptions(
+      ca.tokens,
+      this.provider.networkType,
+      LOOPS_PER_TX
+    );
+    const expected = cm.collateralTokens.map((token) => {
+      const actual = expectedBalances.get(token)?.balance || 0n;
+      return {
+        token,
+        balance: actual > 10n ? actual : 0n
+      };
+    });
+    const leftover = cm.collateralTokens.map((token) => ({
+      token,
+      balance: leftoverBalances.get(token)?.balance || 1n
+    }));
+    const connectors = this.getAvailableConnectors(cm.collateralTokens);
+    return { expected, leftover, connectors, pathOptions };
+  }
+  getDefaultExpectedAndLeftover(ca) {
+    const expectedBalances = new AddressMap();
+    const leftoverBalances = new AddressMap();
+    for (const { token: t, balance, mask } of ca.tokens) {
+      const token = t;
+      const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
+      expectedBalances.upsert(token, { token, balance });
+      const decimals = this.sdk.tokensMeta.decimals(token);
+      const minBalance = 10n ** BigInt(Math.max(8, decimals) - 8);
+      if (balance < minBalance || !isEnabled) {
+        leftoverBalances.upsert(token, { token, balance });
+      }
     }
-    return this.#approvedCreditManagers;
+    return { expectedBalances, leftoverBalances };
   }
-  stateHuman(raw = true) {
-    return super.stateHuman(raw);
+  getAvailableConnectors(collateralTokens) {
+    return collateralTokens.filter(
+      (t) => this.#connectors.includes(t.toLowerCase())
+    );
   }
 };
+function compareRouterResults(a, b) {
+  return a.amount > b.amount ? a : b;
+}
+function balancesMap(assets) {
+  return new AddressMap(assets.map(({ token, balance }) => [token, balance]));
+}
+function assetsMap(assets) {
+  return new AddressMap(assets.map((a) => [a.token, a]));
+}
 
-// src/sdk/core/GearStakingV3Contract.ts
-var GearStakingContract = class extends BaseContract {
-  constructor(sdk, address) {
-    super(sdk, { addr: address, name: "GearStakingV3", abi: gearStakingV3Abi });
+// src/sdk/accounts/CreditAccountsService.ts
+var CreditAccountsService = class extends SDKConstruct {
+  #compressor;
+  constructor(sdk) {
+    super(sdk);
+    this.#compressor = sdk.addressProvider.getLatestVersion(
+      AP_CREDIT_ACCOUNT_COMPRESSOR
+    );
   }
-  parseFunctionParams(params) {
-    switch (params.functionName) {
-      case "setVotingContractStatus": {
-        const [address, status] = params.args;
-        return [this.addressLabels.get(address), VotingContractStatus[status]];
-      }
-      default:
-        return void 0;
+  /**
+   * Returns single credit account data, or undefined if it's not found
+   * Performs all necessary price feed updates under the hood
+   * @param account
+   * @param options
+   * @returns
+   */
+  async getCreditAccountData(account, options) {
+    const blockNumber = options?.blockNumber;
+    let raw;
+    try {
+      raw = await this.provider.publicClient.readContract({
+        abi: iCreditAccountCompressorAbi,
+        address: this.#compressor,
+        functionName: "getCreditAccountData",
+        args: [account],
+        blockNumber
+      });
+    } catch (e) {
+      return void 0;
     }
+    if (raw.success) {
+      return raw;
+    }
+    const { txs: priceUpdateTxs, timestamp: _ } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
+    const resp = await simulateMulticall(this.provider.publicClient, {
+      contracts: [
+        ...priceUpdateTxs.map(rawTxToMulticallPriceUpdate),
+        {
+          abi: iCreditAccountCompressorAbi,
+          address: this.#compressor,
+          functionName: "getCreditAccountData",
+          args: [account]
+        }
+      ],
+      allowFailure: false,
+      gas: 550000000n,
+      batchSize: 0,
+      // we cannot have price updates and compressor request in different batches
+      blockNumber
+    });
+    const cad = resp.pop();
+    return cad;
   }
-  stateHuman(raw = true) {
-    return {
-      ...super.stateHuman(raw),
-      successor: this.labelAddress(ADDRESS_0X0),
-      migrator: this.labelAddress(ADDRESS_0X0)
+  /**
+   * Methods to get all credit accounts with some optional filtering
+   * Performs all necessary price feed updates under the hood
+   *
+   * TODO: do we want to expose pagination?
+   * TODO: do we want to expose "reverting"?
+   * TODO: do we want to expose MarketFilter in any way? If so, we need to check that the MarketFilter is compatibled with attached markets?
+   * @param args
+   * @param options
+   * @returns returned credit accounts are sorted by health factor in ascending order
+   */
+  async getCreditAccounts(args, options) {
+    const {
+      creditManager,
+      includeZeroDebt = false,
+      maxHealthFactor = 65535,
+      // TODO: this will change to bigint
+      minHealthFactor = 0,
+      owner = ADDRESS_0X0
+    } = args ?? {};
+    const arg0 = creditManager ?? {
+      curators: [],
+      pools: this.pools,
+      underlying: ADDRESS_0X0
+    };
+    const caFilter = {
+      owner,
+      includeZeroDebt,
+      minHealthFactor,
+      maxHealthFactor
     };
+    const { txs: priceUpdateTxs, timestamp: _ } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
+    const allCAs = [];
+    for (const reverting of [false, true]) {
+      let offset = 0n;
+      do {
+        const [accounts, newOffset] = await this.#getCreditAccounts(
+          [arg0, { ...caFilter, reverting }, offset],
+          priceUpdateTxs,
+          options
+        );
+        allCAs.push(...accounts);
+        offset = newOffset;
+      } while (offset !== 0n);
+    }
+    return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
   }
-};
-var PathOptionFactory = class _PathOptionFactory {
-  // TODO: get rid of token data from SDK
-  static generatePathOptions(balances, network, loopsInTx) {
-    const curvePools = _PathOptionFactory.getCurvePools(balances);
-    const balancerPools = _PathOptionFactory.getBalancerPools(balances);
-    const curveInitPO = curvePools.map((symbol) => {
-      return {
-        target: sdkGov.tokenDataByNetwork[network][symbol],
-        option: 0,
-        totalOptions: sdkGov.contractParams[sdkGov.curveTokens[symbol].pool].tokens.length
-      };
+  /**
+   * Generates transaction to liquidate credit account
+   * @param account
+   * @param to Address to transfer underlying left after liquidation
+   * @param slippage
+   * @returns
+   */
+  async fullyLiquidate(account, to, slippage = 50n) {
+    const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
+    const routerCloseResult = await this.sdk.router.findBestClosePath({
+      creditAccount: account,
+      creditManager: cm.creditManager,
+      slippage
     });
-    const balancerInitPO = balancerPools.map((symbol) => {
-      return {
-        target: sdkGov.tokenDataByNetwork[network][symbol],
-        option: 0,
-        totalOptions: sdkGov.balancerLpTokens[symbol].underlying.length
-      };
+    const priceUpdates = await this.getPriceUpdatesForFacade(account);
+    const tx = cm.creditFacade.liquidateCreditAccount(
+      account.creditAccount,
+      to,
+      [...priceUpdates, ...routerCloseResult.calls]
+    );
+    return { tx, routerCloseResult };
+  }
+  /**
+   * Closes credit account or sets debt to zero (but keep account)
+   * @param operation
+   * @param creditAccount
+   * @param assetsToWithdraw Tokens to withdraw from credit account
+   * @param to Address to withdraw underlying to
+   * @param slippage
+   * @param closePath
+   * @returns
+   */
+  async closeCreditAccount({
+    operation,
+    assetsToWithdraw,
+    creditAccount: ca,
+    to,
+    slippage = 50n,
+    closePath
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const routerCloseResult = closePath || await this.sdk.router.findBestClosePath({
+      creditAccount: ca,
+      creditManager: cm.creditManager,
+      slippage
     });
-    const initPO = [...curveInitPO, ...balancerInitPO];
-    const totalLoops = initPO.reduce(
-      (acc, item) => acc * item.totalOptions,
-      1
+    const calls = [
+      ...routerCloseResult.calls,
+      ...this.#prepareDisableQuotas(ca),
+      ...this.#prepareDecreaseDebt(ca),
+      ...this.#prepareDisableTokens(ca),
+      ...assetsToWithdraw.map(
+        (t) => this.#prepareWithdrawToken(ca, t, MAX_UINT256, to)
+      )
+    ];
+    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, routerCloseResult };
+  }
+  /**
+   * Repays credit account or sets debt to zero (but keep account)
+   * @param operation
+   * @param creditAccount
+   * @param assetsToWithdraw Tokens to withdraw from credit account
+   * @param collateralAssets Tokens to pay for
+   * @param to Address to withdraw underlying to
+   * @param slippage
+   * @param permits
+   * @returns
+   */
+  async repayCreditAccount({
+    operation,
+    collateralAssets,
+    assetsToWithdraw,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const calls = [
+      ...this.#prepareAddCollateral(addCollateral, ca, permits),
+      ...this.#prepareDisableQuotas(ca),
+      ...this.#prepareDecreaseDebt(ca),
+      ...this.#prepareDisableTokens(ca),
+      // TODO: probably needs a way to handle reward tokens
+      ...assetsToWithdraw.map(
+        (t) => this.#prepareWithdrawToken(ca, t, MAX_UINT256, to)
+      )
+    ];
+    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls };
+  }
+  /**
+   * Repays liquidatable credit account
+   * @param creditAccount
+   * @param assetsToWithdraw Tokens to withdraw from credit account
+   * @param collateralAssets Tokens to pay for
+   * @param to Address to withdraw underlying to
+   * @param slippage
+   * @returns
+   */
+  async repayAndLiquidateCreditAccount({
+    collateralAssets,
+    assetsToWithdraw,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const priceUpdates = await this.getPriceUpdatesForFacade(ca);
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const calls = [
+      ...priceUpdates,
+      ...this.#prepareAddCollateral(addCollateral, ca, permits),
+      ...assetsToWithdraw.map(
+        (t) => this.#prepareWithdrawToken(ca, t, MAX_UINT256, to)
+      )
+    ];
+    const tx = cm.creditFacade.liquidateCreditAccount(
+      ca.creditAccount,
+      to,
+      calls
     );
-    const result = [];
-    let currentPo = [...initPO];
-    for (let i = 0; i < totalLoops; i++) {
-      if (i % loopsInTx === 0) {
-        result.push(currentPo);
-      }
-      if (i < totalLoops - 1) {
-        currentPo = _PathOptionFactory.next(currentPo);
-      }
-    }
-    return result;
+    return { tx, calls };
   }
-  static getCurvePools(balances) {
-    const nonZeroBalances = balances.filter((b) => b.balance > 1n);
-    const curvePools = nonZeroBalances.map((b) => sdkGov.getTokenSymbol(b.token)).filter((symbol) => sdkGov.isCurveLPToken(symbol));
-    const yearnCurveTokens = Object.entries(sdkGov.yearnTokens).filter(([, data]) => sdkGov.isCurveLPToken(data.underlying)).map(([token]) => token);
-    const curvePoolsFromYearn = nonZeroBalances.map((b) => sdkGov.getTokenSymbol(b.token)).filter((symbol) => yearnCurveTokens.includes(symbol)).map(
-      (symbol) => sdkGov.yearnTokens[symbol].underlying
+  async updateQuotas(props) {
+    const { creditAccount } = props;
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
     );
-    const convexCurveTokens = Object.entries(sdkGov.convexTokens).filter(([, data]) => sdkGov.isCurveLPToken(data.underlying)).map(([token]) => token);
-    const curvePoolsFromConvex = nonZeroBalances.map((b) => sdkGov.getTokenSymbol(b.token)).filter((symbol) => convexCurveTokens.includes(symbol)).map((symbol) => sdkGov.convexTokens[symbol].underlying);
-    const curveSet = /* @__PURE__ */ new Set([
-      ...curvePools,
-      ...curvePoolsFromYearn,
-      ...curvePoolsFromConvex
+    const priceUpdates = await this.getPriceUpdatesForFacade(creditAccount);
+    const calls = [
+      ...priceUpdates,
+      ...this.#prepareUpdateQuotas(props)
+    ];
+    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, [
+      ...priceUpdates,
+      ...this.#prepareUpdateQuotas(props)
     ]);
-    return Array.from(curveSet.values());
+    return {
+      tx,
+      calls
+    };
   }
-  static getBalancerPools(balances) {
-    const nonZeroBalances = Object.entries(balances).filter(
-      ([, balance]) => balance.balance > 1
+  async addCollateral(props) {
+    const { creditAccount, asset, permit, ethAmount } = props;
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
     );
-    const balancerPools = nonZeroBalances.map(([token]) => sdkGov.getTokenSymbol(token)).filter((symbol) => sdkGov.isBalancerLPToken(symbol));
-    const balancerAuraTokens = Object.entries(sdkGov.auraTokens).filter(([, data]) => sdkGov.isBalancerLPToken(data.underlying)).map(([token]) => token);
-    const balancerTokensFromAura = nonZeroBalances.map(([token]) => sdkGov.getTokenSymbol(token)).filter((symbol) => balancerAuraTokens.includes(symbol)).map(
-      (symbol) => sdkGov.auraTokens[symbol].underlying
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(creditAccount);
+    const addCollateralCalls = this.#prepareAddCollateral(
+      [asset],
+      creditAccount,
+      permit ? { [asset.token]: permit } : {}
     );
-    const balancerSet = /* @__PURE__ */ new Set([...balancerPools, ...balancerTokensFromAura]);
-    return Array.from(balancerSet.values());
+    const updateQuotaCalls = this.#prepareUpdateQuotas(props);
+    const calls = [
+      ...priceUpdatesCalls,
+      ...addCollateralCalls,
+      ...updateQuotaCalls
+    ];
+    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    tx.value = ethAmount.toString(10);
+    return { tx, calls };
   }
-  static next(path) {
-    let newPath = [...path];
-    for (let i = path.length - 1; i >= 0; i--) {
-      const po = { ...newPath[i] };
-      po.option++;
-      newPath[i] = po;
-      if (po.option < po.totalOptions) return newPath;
-      po.option = 0;
+  async changeDebt({
+    creditAccount,
+    amount
+  }) {
+    if (amount === 0n) {
+      throw new Error("debt increase or decrease must be non-zero");
     }
-    throw new Error("Path options overflow");
+    const isDecrease = amount < 0n;
+    const change = isDecrease ? -amount : amount;
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(creditAccount);
+    const underlyingEnabled = (creditAccount.enabledTokensMask & 1n) === 1n;
+    const shouldEnable = !isDecrease && !underlyingEnabled;
+    const calls = [
+      ...priceUpdatesCalls,
+      ...shouldEnable ? this.#prepareEnableTokens(creditAccount, [creditAccount.underlying]) : [],
+      {
+        target: creditAccount.creditFacade,
+        callData: viem.encodeFunctionData({
+          abi: iCreditFacadeV3MulticallAbi,
+          functionName: isDecrease ? "increaseDebt" : "decreaseDebt",
+          args: [change]
+        })
+      }
+    ];
+    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    return { tx, calls };
   }
-};
-
-// src/sdk/router/RouterV3Contract.ts
-var MAX_GAS_PER_ROUTE = 200000000n;
-var GAS_PER_BLOCK = 400000000n;
-var LOOPS_PER_TX = Number(GAS_PER_BLOCK / MAX_GAS_PER_ROUTE);
-var SWAP_OPERATIONS = {
-  EXACT_INPUT: 0,
-  EXACT_INPUT_ALL: 1,
-  EXACT_OUTPUT: 2
-};
-var RouterV3Contract = class extends BaseContract {
-  #connectors;
-  #hooks = new Hooks();
-  constructor(sdk, address) {
-    super(sdk, {
-      addr: address,
-      name: "RouterV3",
-      abi: routerV3Abi
+  /**
+   * Internal wrapper for CreditAccountCompressor.getCreditAccounts + price updates wrapped into multicall
+   * @param args
+   * @param priceUpdateTxs
+   * @param options
+   * @returns
+   */
+  async #getCreditAccounts(args, priceUpdateTxs, options) {
+    const blockNumber = options?.blockNumber;
+    if (priceUpdateTxs?.length) {
+      const resp = await simulateMulticall(this.provider.publicClient, {
+        contracts: [
+          ...priceUpdateTxs.map(rawTxToMulticallPriceUpdate),
+          {
+            abi: iCreditAccountCompressorAbi,
+            address: this.#compressor,
+            functionName: "getCreditAccounts",
+            args
+          }
+        ],
+        allowFailure: false,
+        gas: 550000000n,
+        batchSize: 0,
+        // we cannot have price updates and compressor request in different batches
+        blockNumber
+      });
+      const getCreditAccountsResp = resp.pop();
+      return getCreditAccountsResp;
+    }
+    return this.provider.publicClient.readContract({
+      abi: iCreditAccountCompressorAbi,
+      address: this.#compressor,
+      functionName: "getCreditAccounts",
+      args,
+      blockNumber
     });
-    this.#connectors = sdkGov.getConnectors(sdk.provider.networkType);
   }
-  addHook = this.#hooks.addHook.bind(this.#hooks);
-  removeHook = this.#hooks.removeHook.bind(this.#hooks);
   /**
-   * Finds all available swaps for NORMAL tokens
-   * @param ca
-   * @param cm
-   * @param swapOperation
-   * @param tokenIn
-   * @param tokenOut
-   * @param amount
-   * @param leftoverAmount
-   * @param slippage
+   * Returns raw txs that are needed to update all price feeds so that all credit accounts (possibly from different markets) compute
+   * @param accounts
    * @returns
    */
-  async findAllSwaps({
-    creditAccount: ca,
-    creditManager: cm,
-    swapOperation,
-    tokenIn,
-    tokenOut,
-    amount,
-    leftoverAmount,
-    slippage
-  }) {
-    const connectors = this.getAvailableConnectors(cm.collateralTokens);
-    const swapTask = {
-      swapOperation: SWAP_OPERATIONS[swapOperation],
-      creditAccount: ca.creditAccount,
-      tokenIn,
-      tokenOut,
-      connectors,
-      amount,
-      leftoverAmount
-    };
-    const { result } = await this.contract.simulate.findAllSwaps(
-      [swapTask, BigInt(slippage)],
-      {
-        gas: GAS_PER_BLOCK
+  async getUpdateForAccounts(accounts) {
+    const tokensByPool = /* @__PURE__ */ new Map();
+    const oracleByPool = /* @__PURE__ */ new Map();
+    for (const acc of accounts) {
+      const market = this.sdk.marketRegister.findByCreditManager(
+        acc.creditManager
+      );
+      const pool = market.poolFactory.pool.address;
+      oracleByPool.set(pool, market.priceOracle);
+      for (const t of acc.tokens) {
+        if (t.balance > 10n) {
+          const tokens = tokensByPool.get(pool) ?? /* @__PURE__ */ new Set();
+          tokens.add(t.token);
+          tokensByPool.set(pool, tokens);
+        }
       }
+    }
+    const priceFeeds = [];
+    for (const [pool, priceFeedFactory] of oracleByPool.entries()) {
+      const tokens = Array.from(tokensByPool.get(pool) ?? []);
+      priceFeeds.push(...priceFeedFactory.priceFeedsForTokens(tokens));
+    }
+    return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
+  }
+  /**
+   * Returns account price updates in a non-encoded format
+   * @param acc
+   * @returns
+   */
+  async getOnDemandPriceUpdates(acc) {
+    const market = this.sdk.marketRegister.findByCreditManager(
+      acc.creditManager
     );
-    const unique = {};
-    result.forEach((r) => {
-      const key = `${r.minAmount.toString()}${r.calls.map((c) => `${c.target.toLowerCase()}${c.callData}`).join("-")}`;
-      unique[key] = {
-        amount: r.amount,
-        minAmount: r.minAmount,
-        calls: [...r.calls]
-      };
-    });
-    return Object.values(unique);
+    const update = await this.getUpdateForAccounts([acc]);
+    return market.priceOracle.onDemandPriceUpdates(update);
   }
   /**
-   * Finds best path to swap all Normal tokens and tokens "on the way" to target one and vice versa
-   * @param creditAccount
-   * @param creditManager
-   * @param tokenIn
-   * @param tokenOut
-   * @param amount
-   * @param slippage
+   * Returns price updates in format that is accepted by various credit facade methods (multicall, close/liquidate, etc...)
+   * @param acc
    * @returns
    */
-  async findOneTokenPath({
-    creditAccount: ca,
-    creditManager: cm,
-    tokenIn,
-    tokenOut,
-    amount,
-    slippage
-  }) {
-    const connectors = this.getAvailableConnectors(cm.collateralTokens);
-    const { result } = await this.contract.simulate.findOneTokenPath(
-      [
-        tokenIn,
-        amount,
-        tokenOut,
-        ca.creditAccount,
-        connectors,
-        BigInt(slippage)
-      ],
-      {
-        gas: GAS_PER_BLOCK
+  async getPriceUpdatesForFacade(acc) {
+    const cm = this.sdk.marketRegister.findCreditManager(acc.creditManager);
+    const updates = await this.getOnDemandPriceUpdates(acc);
+    return cm.creditFacade.encodeOnDemandPriceUpdates(updates);
+  }
+  #prepareDisableQuotas(ca) {
+    const calls = [];
+    for (const { token, quota } of ca.tokens) {
+      if (quota > 0n) {
+        calls.push({
+          target: ca.creditFacade,
+          callData: viem.encodeFunctionData({
+            abi: iCreditFacadeV3MulticallAbi,
+            functionName: "updateQuota",
+            args: [token, MIN_INT96, 0n]
+          })
+        });
       }
-    );
+    }
+    return calls;
+  }
+  #prepareUpdateQuotas(props) {
+    const { creditAccount, averageQuota, minQuota } = props;
+    const minRecord = assetsMap(minQuota);
+    const calls = averageQuota.map((q) => {
+      const minAsset = minRecord.get(q.token);
+      const min = minAsset && minAsset?.balance > 0 ? minAsset.balance : 0n;
+      return {
+        target: creditAccount.creditFacade,
+        callData: viem.encodeFunctionData({
+          abi: iCreditFacadeV3MulticallAbi,
+          functionName: "updateQuota",
+          args: [q.token, q.balance, min]
+        })
+      };
+    });
+    return calls;
+  }
+  #prepareDecreaseDebt(ca) {
+    if (ca.debt > 0n) {
+      return [
+        {
+          target: ca.creditFacade,
+          callData: viem.encodeFunctionData({
+            abi: iCreditFacadeV3MulticallAbi,
+            functionName: "decreaseDebt",
+            args: [MAX_UINT256]
+          })
+        }
+      ];
+    }
+    return [];
+  }
+  #prepareDisableTokens(ca) {
+    const calls = [];
+    for (const t of ca.tokens) {
+      if (t.token !== ca.underlying && (t.mask & ca.enabledTokensMask) !== 0n && t.quota === 0n) {
+        calls.push({
+          target: ca.creditFacade,
+          callData: viem.encodeFunctionData({
+            abi: iCreditFacadeV3MulticallAbi,
+            functionName: "disableToken",
+            args: [t.token]
+          })
+        });
+      }
+    }
+    return calls;
+  }
+  #prepareEnableTokens(ca, tokens) {
+    return tokens.map((t) => ({
+      target: ca.creditFacade,
+      callData: viem.encodeFunctionData({
+        abi: iCreditFacadeV3MulticallAbi,
+        functionName: "enableToken",
+        args: [t]
+      })
+    }));
+  }
+  #prepareWithdrawToken(ca, token, amount, to) {
     return {
-      amount: result.amount,
-      minAmount: result.minAmount,
-      calls: [...result.calls]
+      target: ca.creditFacade,
+      callData: viem.encodeFunctionData({
+        abi: iCreditFacadeV3MulticallAbi,
+        functionName: "withdrawCollateral",
+        args: [token, amount, to]
+      })
     };
   }
+  #prepareAddCollateral(assets, ca, permits) {
+    const calls = assets.map(({ token, balance }) => {
+      const p = permits[token];
+      if (p) {
+        return {
+          target: ca.creditFacade,
+          callData: viem.encodeFunctionData({
+            abi: iCreditFacadeV3MulticallAbi,
+            functionName: "addCollateralWithPermit",
+            args: [token, balance, p.deadline, p.v, p.r, p.s]
+          })
+        };
+      }
+      return {
+        target: ca.creditFacade,
+        callData: viem.encodeFunctionData({
+          abi: iCreditFacadeV3MulticallAbi,
+          functionName: "addCollateral",
+          args: [token, balance]
+        })
+      };
+    });
+    return calls;
+  }
   /**
-   * @dev Finds the best path for opening Credit Account and converting all NORMAL tokens and LP token in the way to TARGET
-   * @param creditManager CreditManagerData which represents credit manager you want to use to open Credit Account
-   * @param expectedBalances Expected balances which would be on account accounting also debt. For example,
-   *    if you open an USDC Credit Account, borrow 50_000 USDC and provide 10 WETH and 10_USDC as collateral
-   *    from your own funds, expectedBalances should be: { "USDC": 60_000 * (10**6), "<address of WETH>": WAD.mul(10) }
-   * @param leftoverBalances Balances to keep on account after opening
-   * @param target Address of symbol of desired token
-   * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @returns PathFinderOpenStrategyResult which
+   * Returns addresses of pools of attached markets
    */
-  async findOpenStrategyPath({
-    creditManager: cm,
-    expectedBalances,
-    leftoverBalances,
-    target,
-    slippage
-  }) {
-    const [expectedMap, leftoverMap] = [
-      balancesMap(expectedBalances),
-      balancesMap(leftoverBalances)
-    ];
-    const input = cm.collateralTokens.map((token) => ({
-      token,
-      balance: expectedMap.get(token) ?? 0n
-    }));
-    const leftover = cm.collateralTokens.map((token) => ({
-      token,
-      balance: leftoverMap.get(token) ?? 0n
-    }));
-    const connectors = this.getAvailableConnectors(cm.collateralTokens);
-    const {
-      result: [outBalances, result]
-    } = await this.contract.simulate.findOpenStrategyPath(
-      [cm.address, input, leftover, target, connectors, BigInt(slippage)],
-      {
-        gas: GAS_PER_BLOCK
+  get pools() {
+    return this.sdk.marketRegister.pools.map((p) => p.pool.address);
+  }
+};
+var AddressProviderContractV3_1 = class extends BaseContract {
+  #addresses = {};
+  versions = {};
+  latest = {};
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "AddressProviderV3",
+      abi: iAddressProviderV3_1Abi
+    });
+  }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "setAddress": {
+        if (params.args.length !== 3) {
+          const [key2, saveVersion2] = params.args;
+          return [key2, `${saveVersion2}`];
+        }
+        const [key, value, saveVersion] = params.args;
+        return [viem.bytesToString(viem.toBytes(key)), value, `${saveVersion}`];
       }
+      default:
+        return void 0;
+    }
+  }
+  setInternalAddress(key, address, version) {
+    if (!this.#addresses[key]) {
+      this.#addresses[key] = {};
+    }
+    this.#addresses[key][version] = address;
+    if (!this.latest[key] || version > this.latest[key]) {
+      this.latest[key] = version;
+    }
+    if (!this.versions[key]) {
+      this.versions[key] = /* @__PURE__ */ new Set();
+    }
+    this.versions[key].add(version);
+  }
+  getAddress(contract, version = NO_VERSION) {
+    if (!this.#addresses[contract]) {
+      throw new Error(`Address ${contract}, version: ${version} not found`);
+    }
+    const result = this.#addresses[contract][version];
+    if (!result) {
+      throw new Error(`Address ${contract}, version: ${version} not found`);
+    }
+    return result;
+  }
+  getLatestVersion(contract) {
+    if (!this.latest[contract]) {
+      throw new Error(`Latest version for ${contract} not found`);
+    }
+    this.logger?.debug(
+      `Latest version found for ${contract} : ${this.latest[contract]}`
     );
-    const balancesAfter = Object.fromEntries(
-      outBalances.map((b) => [b.token.toLowerCase(), b.balance])
-    );
+    return this.getAddress(contract, this.latest[contract]);
+  }
+  async syncState(blockNumber) {
+    const entries = await this.contract.read.getAllSavedContracts({
+      blockNumber
+    });
+    for (const log of entries) {
+      this.setInternalAddress(log.key, log.value, Number(log.version));
+    }
+  }
+  stateHuman(raw = true) {
     return {
-      balances: {
-        ...balancesAfter,
-        [target]: (expectedMap.get(target) ?? 0n) + result.amount
-      },
-      minBalances: {
-        ...balancesAfter,
-        [target]: (expectedMap.get(target) ?? 0n) + result.minAmount
-      },
-      amount: result.amount,
-      minAmount: result.minAmount,
-      calls: [...result.calls]
+      ...super.stateHuman(raw),
+      addresses: Object.entries(this.#addresses).map(([key, value]) => {
+        return Object.entries(value).map(([version, address]) => {
+          return {
+            key,
+            version,
+            address: this.sdk.provider.addressLabels.get(address)
+          };
+        });
+      }).reduce(
+        (acc, vals) => {
+          for (const val of vals) {
+            if (!acc[val.key]) {
+              acc[val.key] = {};
+            }
+            acc[val.key][val.version] = val.address;
+          }
+          return acc;
+        },
+        {}
+      )
     };
   }
-  /**
-   * @dev Finds the path to swap / withdraw all assets from CreditAccount into underlying asset
-   *   Can bu used for closing Credit Account and for liquidations as well.
-   * @param creditAccount CreditAccountStruct object used for close path computation
-   * @param creditManager CreditManagerSlice for corresponding credit manager
-   * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @return The best option in PathFinderCloseResult format, which
-   *          - underlyingBalance - total balance of underlying token
-   *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
-   */
-  async findBestClosePath({
-    creditAccount: ca,
-    creditManager: cm,
-    slippage,
-    balances
-  }) {
-    const { pathOptions, expected, leftover, connectors } = this.getFindClosePathInput(
-      ca,
-      cm,
-      balances ? {
-        expectedBalances: assetsMap(balances.expectedBalances),
-        leftoverBalances: assetsMap(balances.leftoverBalances)
-      } : void 0
-    );
-    await this.#hooks.triggerHooks("foundPathOptions", {
-      creditAccount: ca.creditAccount,
-      pathOptions,
-      expected,
-      leftover,
-      connectors
+  processLog(log) {
+    switch (log.eventName) {
+      case "SetAddress": {
+        const parsedLog2 = viem.parseEventLogs({
+          abi: this.abi,
+          eventName: "SetAddress",
+          logs: [log]
+        })[0];
+        const key = parsedLog2.args.key;
+        this.setInternalAddress(
+          key,
+          log.args.value,
+          Number(parsedLog2.args.version)
+        );
+        break;
+      }
+      default:
+        this.logger?.warn(`Unknown event: ${log.eventName}`);
+        break;
+    }
+  }
+};
+
+// src/sdk/core/BotListV3Contract.ts
+var BotListContract = class extends BaseContract {
+  #approvedCreditManagers;
+  #currentBlock;
+  constructor(sdk, address) {
+    super(sdk, { addr: address, name: "BotListV3", abi: botListV3Abi });
+    this.#currentBlock = ADDRESS_PROVIDER_BLOCK[sdk.provider.networkType];
+  }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "setCreditManagerApprovedStatus": {
+        const [creditManager, status] = params.args;
+        return [this.addressLabels.get(creditManager), `${status}`];
+      }
+      case "setBotSpecialPermissions": {
+        const [bot, creditManager, permissions] = params.args;
+        return [
+          this.addressLabels.get(bot),
+          this.addressLabels.get(creditManager),
+          botPermissionsToString(permissions)
+        ];
+      }
+      default:
+        return void 0;
+    }
+  }
+  async syncState(toBlock) {
+    const logs = await this.provider.publicClient.getContractEvents({
+      address: this.address,
+      abi: this.abi,
+      fromBlock: this.#currentBlock,
+      toBlock
     });
-    let results = [];
-    for (const po of pathOptions) {
-      const { result: result2 } = await this.contract.simulate.findBestClosePath(
-        [
-          ca.creditAccount,
-          expected,
-          leftover,
-          connectors,
-          BigInt(slippage),
-          po,
-          BigInt(LOOPS_PER_TX),
-          false
-        ],
-        {
-          gas: GAS_PER_BLOCK
+    logs.forEach((e) => this.processLog(e));
+    this.#currentBlock = toBlock;
+  }
+  processLog(log) {
+    switch (log.eventName) {
+      case "SetCreditManagerApprovedStatus":
+        if (log.args.approved) {
+          this.approvedCreditManagers.add(log.args.creditManager);
+        } else {
+          this.approvedCreditManagers.delete(log.args.creditManager);
         }
+        break;
+      case "SetBotSpecialPermissions":
+        this.logger?.debug(
+          `Bot ${log.args.bot} has been given permissions ${botPermissionsToString(
+            log.args.permissions
+          )} for credit manager ${log.args.creditManager}`
+        );
+        break;
+      default:
+        this.logger?.warn(`Unknown event: ${log.eventName}`);
+        break;
+    }
+  }
+  get approvedCreditManagers() {
+    if (!this.#approvedCreditManagers) {
+      throw new Error(
+        "BotListContract state needs to be synced to load approvedCreditManagers"
       );
-      results.push({
-        ...result2,
-        calls: [...result2.calls]
-      });
     }
-    const bestResult = results.reduce(compareRouterResults, {
-      amount: 0n,
-      minAmount: 0n,
-      calls: []
-    });
-    const underlyingBalance = ca.tokens.find((t) => t.token === ca.underlying)?.balance ?? 0n;
-    const result = {
-      amount: bestResult.amount,
-      minAmount: bestResult.minAmount,
-      calls: bestResult.calls.map((c) => ({
-        callData: c.callData,
-        target: c.target
-      })),
-      underlyingBalance: underlyingBalance + bestResult.minAmount
-    };
-    return result;
+    return this.#approvedCreditManagers;
   }
-  /**
-   * Finds input to be used with findBestClosePath
-   * @param ca
-   * @param cm
-   * @returns
-   */
-  getFindClosePathInput(ca, cm, balances) {
-    const b = balances || this.getDefaultExpectedAndLeftover(ca);
-    const { leftoverBalances, expectedBalances } = b;
-    const pathOptions = PathOptionFactory.generatePathOptions(
-      ca.tokens,
-      this.provider.networkType,
-      LOOPS_PER_TX
-    );
-    const expected = cm.collateralTokens.map((token) => {
-      const actual = expectedBalances.get(token)?.balance || 0n;
-      return {
-        token,
-        balance: actual > 10n ? actual : 0n
-      };
-    });
-    const leftover = cm.collateralTokens.map((token) => ({
-      token,
-      balance: leftoverBalances.get(token)?.balance || 1n
-    }));
-    const connectors = this.getAvailableConnectors(cm.collateralTokens);
-    return { expected, leftover, connectors, pathOptions };
+  stateHuman(raw = true) {
+    return super.stateHuman(raw);
   }
-  getDefaultExpectedAndLeftover(ca) {
-    const expectedBalances = new AddressMap();
-    const leftoverBalances = new AddressMap();
-    for (const { token: t, balance, mask } of ca.tokens) {
-      const token = t;
-      const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
-      expectedBalances.upsert(token, { token, balance });
-      const decimals = this.sdk.tokensMeta.decimals(token);
-      const minBalance = 10n ** BigInt(Math.max(8, decimals) - 8);
-      if (balance < minBalance || !isEnabled) {
-        leftoverBalances.upsert(token, { token, balance });
+};
+
+// src/sdk/core/GearStakingV3Contract.ts
+var GearStakingContract = class extends BaseContract {
+  constructor(sdk, address) {
+    super(sdk, { addr: address, name: "GearStakingV3", abi: gearStakingV3Abi });
+  }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "setVotingContractStatus": {
+        const [address, status] = params.args;
+        return [this.addressLabels.get(address), VotingContractStatus[status]];
       }
+      default:
+        return void 0;
     }
-    return { expectedBalances, leftoverBalances };
   }
-  getAvailableConnectors(collateralTokens) {
-    return collateralTokens.filter(
-      (t) => this.#connectors.includes(t.toLowerCase())
-    );
+  stateHuman(raw = true) {
+    return {
+      ...super.stateHuman(raw),
+      successor: this.labelAddress(ADDRESS_0X0),
+      migrator: this.labelAddress(ADDRESS_0X0)
+    };
   }
 };
-function compareRouterResults(a, b) {
-  return a.amount > b.amount ? a : b;
-}
-function balancesMap(assets) {
-  return new AddressMap(assets.map(({ token, balance }) => [token, balance]));
-}
-function assetsMap(assets) {
-  return new AddressMap(assets.map((a) => [a.token, a]));
-}
-
-// src/sdk/GearboxSDK.ts
 var GearboxSDK = class _GearboxSDK {
   #hooks = new Hooks();
   // Represents chain object
@@ -23698,6 +23793,8 @@ exports.WstETHV1AdapterContract = WstETHV1AdapterContract;
 exports.YearnPriceFeedContract = YearnPriceFeedContract;
 exports.YearnV2RouterAdapterContract = YearnV2RouterAdapterContract;
 exports.ZeroPriceFeedContract = ZeroPriceFeedContract;
+exports.assetsMap = assetsMap;
+exports.balancesMap = balancesMap;
 exports.botPermissionsToString = botPermissionsToString;
 exports.bytes32ToString = bytes32ToString;
 exports.chains = chains;