@gearbox-protocol/sdk 13.0.0-next.3 → 13.0.0-next.31

package/dist/cjs/sdk/accounts/AbstractCreditAccountsService.js

@@ -41,6 +41,7 @@ const COMPRESSORS = {
   [import_chains.chains.Mainnet.id]: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
   [import_chains.chains.Monad.id]: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023"
 };
+const INVESTORS = new import_utils.AddressMap([], "investors");
 function getWithdrawalCompressorAddress(chainId) {
   return COMPRESSORS[chainId];
 }
@@ -102,6 +103,23 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     });
     return cad;
   }
+  /**
+   * Returns credit account data for a single account with the investor address resolved.
+   * Loads CA via getCreditAccountData; for KYC underlyings fetches the investor from the KYC factory's getInvestor(creditAccount), otherwise uses the account owner.
+   * @param account - Credit account address
+   * @param blockNumber - Optional block number for the read
+   * @returns CreditAccountDataWithInvestor (CA data + investor address), or undefined if the account is not found
+   */
+  async getCreditAccountDataWithInvestor(account, blockNumber) {
+    const ca = await this.getCreditAccountData(account, blockNumber);
+    if (!ca) return ca;
+    const marketSuite = this.sdk.marketRegister.findByCreditManager(
+      ca.creditManager
+    );
+    const factory = await marketSuite.getKYCFactory();
+    const investor = factory ? await factory.getInvestor(ca.creditAccount, true) : void 0;
+    return { ...ca, investor: investor ?? ca.owner };
+  }
   /**
    * Methods to get all credit accounts with some optional filtering
    * Performs all necessary price feed updates under the hood
@@ -110,7 +128,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
    * @param blockNumber
    * @returns returned credit accounts are sorted by health factor in ascending order
    */
-  async getCreditAccounts(options, blockNumber) {
+  async getCreditAccounts(options, blockNumber, priceUpdate) {
     const {
       creditManager,
       includeZeroDebt = false,
@@ -132,7 +150,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       maxHealthFactor,
       reverting: false
     };
-    const { txs: priceUpdateTxs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(
+    const { txs: priceUpdateTxs } = priceUpdate ?? await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(
       ignoreReservePrices ? { main: true } : void 0
     );
     const allCAs = [];
@@ -161,6 +179,75 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     );
     return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
   }
+  /**
+   * Returns all credit accounts matching the filter, with investor set on each item.
+   * Delegates to getCreditAccounts; when options.owner is set, also loads KYC credit accounts for that owner and merges them into the list. Result is sorted by health factor ascending.
+   * @param options - Filter options (owner, creditManager, health factor, etc.)
+   * @param blockNumber - Optional block number for the read
+   * @returns Array of credit accounts (with investor field), sorted by health factor ascending
+   */
+  async getCreditAccountsWithInvestor(options, blockNumber) {
+    const { owner, ignoreReservePrices = false } = options ?? {};
+    const priceUpdate = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(
+      ignoreReservePrices ? { main: true } : void 0
+    );
+    const { txs: priceUpdateTxs } = priceUpdate;
+    const [common, kyc] = await Promise.all([
+      this.getCreditAccounts(options, blockNumber),
+      owner ? this.getKYCCreditAccountsOfOwner(owner, priceUpdateTxs, blockNumber) : void 0
+    ]);
+    const allCAs = common.map(
+      (ca) => ({
+        ...ca,
+        investor: owner || ca.owner
+      })
+    );
+    allCAs.push(...kyc || []);
+    return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
+  }
+  async getKYCCreditAccountsOfOwner(owner, priceUpdateTxs, blockNumber) {
+    const suites = this.marketConfigurators.map((mc) => {
+      const suite = this.sdk.marketRegister.markets.find(
+        (m) => m.configurator.address === mc
+      );
+      return suite;
+    });
+    const kycCAAddresses = await this.getKYCCaOfInvestor(owner, suites);
+    const kycCAs = await this.loadSpecifiedAccounts(
+      kycCAAddresses,
+      priceUpdateTxs,
+      blockNumber
+    );
+    return kycCAs.map((ca) => ({
+      ...ca,
+      investor: owner
+    }));
+  }
+  /**
+   * Loads credit account data for the given addresses using simulateWithPriceUpdates.
+   * Applies the provided price update txs before reading, so returned data is consistent with up-to-date prices.
+   * @param accounts - Credit account addresses to load
+   * @param priceUpdateTxs - Price feed update txs to simulate before the read (e.g. from generatePriceFeedsUpdateTxs)
+   * @param blockNumber - Optional block number for the read
+   * @returns Array of CreditAccountData in the same order as accounts (throws if any getCreditAccountData call reverts)
+   */
+  async loadSpecifiedAccounts(accounts, priceUpdateTxs, blockNumber) {
+    if (accounts.length === 0) return [];
+    const list = await (0, import_viem2.simulateWithPriceUpdates)(this.client, {
+      priceUpdates: priceUpdateTxs,
+      contracts: accounts.map(
+        (account) => ({
+          abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+          address: this.#compressor,
+          functionName: "getCreditAccountData",
+          args: [account]
+        })
+      ),
+      blockNumber,
+      gas: this.sdk.gasLimit
+    });
+    return list;
+  }
   /**
    * Method to get all claimable rewards for credit account (ex. stkUSDS SKY rewards)
      Assosiates rewards by adapter + stakedPhantomToken
@@ -393,6 +480,13 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     closePath
   }) {
     const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    await this.sdk.tokensMeta.loadTokenData(cm.underlying);
+    const underlying = this.sdk.tokensMeta.mustGet(cm.underlying);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      throw new Error(
+        "closeCreditAccount is not supported for KYC underlying credit accounts"
+      );
+    }
     const routerCloseResult = closePath || await this.sdk.routerFor(ca).findBestClosePath({
       creditAccount: ca,
       creditManager: cm.creditManager,
@@ -412,7 +506,12 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
         (t) => this.prepareWithdrawToken(ca.creditFacade, t, import_constants.MAX_UINT256, to)
       )
     ];
-    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
+    const tx = await this.closeCreditAccountTx(
+      cm,
+      ca.creditAccount,
+      calls,
+      operation
+    );
     return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
   }
   /**
@@ -442,7 +541,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
         averageQuota
       })
     ];
-    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    const tx = await this.multicallTx(cm, creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -484,7 +583,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
         averageQuota
       })
     ];
-    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    const tx = await this.multicallTx(cm, creditAccount.creditAccount, calls);
     tx.value = ethAmount.toString(10);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
@@ -501,7 +600,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
   async changeDebt({
     creditAccount,
     amount,
-    addCollateral
+    collateral,
+    wrapAsset
   }) {
     if (amount === 0n) {
       throw new Error("debt increase or decrease must be non-zero");
@@ -515,27 +615,37 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       creditManager: creditAccount.creditManager,
       creditAccount
     });
-    const addCollateralCalls = addCollateral && isDecrease ? this.prepareAddCollateral(
+    const addCollateralCalls = collateral && isDecrease ? this.prepareAddCollateral(
       creditAccount.creditFacade,
       [
         {
-          token: creditAccount.underlying,
-          balance: change
+          token: collateral[0].token,
+          balance: collateral[0].balance
         }
       ],
       {}
     ) : [];
+    const unwrapCalls = wrapAsset && isDecrease ? await this.getKYCWrapCalls(
+      wrapAsset[0].balance,
+      creditAccount.creditManager
+    ) || [] : [];
+    if (addCollateralCalls.length > 0 && unwrapCalls.length === 0 && collateral && collateral?.[0].token !== creditAccount.underlying) {
+      throw new Error(
+        "Can't use collateral other than underlying for non KYC market"
+      );
+    }
     const underlyingEnabled = (creditAccount.enabledTokensMask & 1n) === 1n;
     const shouldEnable = !isDecrease && !underlyingEnabled;
     const calls = [
       ...priceUpdatesCalls,
       ...addCollateralCalls,
+      ...unwrapCalls,
       ...shouldEnable ? this.#prepareEnableTokens(creditAccount.creditFacade, [
         creditAccount.underlying
       ]) : [],
       this.#prepareChangeDebt(creditAccount.creditFacade, change, isDecrease)
     ];
-    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    const tx = await this.multicallTx(cm, creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -570,7 +680,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
         averageQuota
       })
     ];
-    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    const tx = await this.multicallTx(cm, creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -686,7 +796,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
         averageQuota
       })
     ];
-    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    const tx = await this.multicallTx(cm, creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -751,7 +861,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       compareBalances,
       ...quotaCalls
     ];
-    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    const tx = await this.multicallTx(cm, creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -778,48 +888,63 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       ),
       ...this.#prepareEnableTokens(ca.creditFacade, enabledTokens)
     ];
-    const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+    const tx = await this.multicallTx(cm, ca.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
+  /**
+   * Returns address to which approval should be given on collateral token
+   * It's credit manager for classical markets and special wallet for KYC markets
+   * @param options - {@link GetApprovalAddressProps}
+   * @returns
+   **/
+  async getApprovalAddress(options) {
+    const { creditManager } = options;
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const marketSuite = this.sdk.marketRegister.findByPool(suite.pool);
+    const factory = await marketSuite.getKYCFactory();
+    if (factory) {
+      if ("creditAccount" in options) {
+        return factory.getWallet(options.creditAccount);
+      }
+      return factory.precomputeWalletAddress(creditManager, options.borrower);
+    }
+    return suite.creditManager.address;
+  }
   /**
    * Executes swap specified by given calls, update quotas of affected tokens
-     - Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
-      -> update quotas -> (optionally: execute swap path for trading/strategy) -> 
-      -> (optionally: withdraw debt for lending)
-    - Basic open credit account: price update -> increase debt -> add collateral -> update quotas
-    - Lending: price update -> increase debt -> add collateral -> update quotas -> withdraw debt
-    - Strategy/trading: price update -> increase debt -> add collateral -> update quotas -> execute swap path
-    - In strategy is possible situation when collateral is added, but not swapped; the only swapped value in this case will be debt
-   * @param {bigint} ethAmount - native token amount to attach to tx
-   * @param {Address} creditManager - address of credit manager to open credit account on
-   * @param {Array<Asset>} collateral - array of collateral which can be just directly added or swapped using the path {@link Asset}
-   * @param {Record<Address, PermitResult>} permits - permits of collateral tokens (in any permittable token is present) {@link PermitResult}
-   * @param {bigint} debt - debt to open credit account with
-   * @param {boolean} withdrawDebt - flag to withdraw debt to wallet after opening credit account; 
-      used for borrowing functionality
-   * @param {bigint} referralCode - referral code to open credit account with
-   * @param {Address} to - wallet address to transfer credit account to\
-   * @param {Array<MultiCall>} calls - array of MultiCall from router methods findOpenStrategyPath {@link MultiCall}.
-      Used for trading and strategy functionality
-   * @param {Array<Asset>} averageQuota - average quota for tokens after open {@link Asset}
-   * @param {Array<Asset>} minQuota - minimum quota for tokens after open  {@link Asset}
+   * - Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
+   *  -> update quotas -> (optionally: execute swap path for trading/strategy) ->
+   *  -> (optionally: withdraw debt for lending)
+   *- Basic open credit account: price update -> increase debt -> add collateral -> update quotas
+   *- Lending: price update -> increase debt -> add collateral -> update quotas -> withdraw debt
+   *- Strategy/trading: price update -> increase debt -> add collateral -> update quotas -> execute swap path
+   *- In strategy is possible situation when collateral is added, but not swapped; the only swapped value in this case will be debt
    * @returns All necessary data to execute the transaction (call, credit facade)
-   */
-  async openCA({
-    ethAmount,
-    creditManager,
-    collateral,
-    permits,
-    debt,
-    withdrawDebt,
-    referralCode,
-    to,
-    calls: openPathCalls,
-    minQuota,
-    averageQuota
-  }) {
+   **/
+  async openCA(props) {
+    const {
+      ethAmount,
+      creditManager,
+      reopenCreditAccount,
+      collateral,
+      permits,
+      debt,
+      withdrawToken,
+      referralCode,
+      to,
+      calls: openPathCalls,
+      callsAfter,
+      minQuota,
+      averageQuota
+    } = props;
     const cmSuite = this.sdk.marketRegister.findCreditManager(creditManager);
     const cm = cmSuite.creditManager;
+    let tokenToWithdraw;
+    if (withdrawToken === true) {
+      tokenToWithdraw = cm.underlying;
+    } else if (typeof withdrawToken === "string") {
+      tokenToWithdraw = withdrawToken;
+    }
     const priceUpdatesCalls = await this.getPriceUpdatesForFacade({
       creditManager: cm.address,
       desiredQuotas: averageQuota
@@ -829,13 +954,27 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       this.#prepareIncreaseDebt(cm.creditFacade, debt),
       ...this.prepareAddCollateral(cm.creditFacade, collateral, permits),
       ...openPathCalls,
-      ...withdrawDebt ? [this.prepareWithdrawToken(cm.creditFacade, cm.underlying, debt, to)] : [],
+      // путь из underlying в withdrawal token
+      ...tokenToWithdraw ? [
+        this.prepareWithdrawToken(
+          cm.creditFacade,
+          tokenToWithdraw,
+          import_constants.MAX_UINT256,
+          to
+        )
+      ] : [],
       ...this.prepareUpdateQuotas(cm.creditFacade, {
         minQuota,
         averageQuota
-      })
+      }),
+      ...callsAfter ?? []
     ];
-    const tx = cmSuite.creditFacade.openCreditAccount(to, calls, referralCode);
+    let tx;
+    if (reopenCreditAccount) {
+      tx = await this.multicallTx(cmSuite, reopenCreditAccount, calls);
+    } else {
+      tx = await this.openCreditAccountTx(cmSuite, to, calls, referralCode);
+    }
     tx.value = ethAmount.toString(10);
     return { calls, tx, creditFacade: cmSuite.creditFacade };
   }
@@ -919,6 +1058,130 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     );
     return resp;
   }
+  /**
+   * Returns multicall entries to redeem (unwrap) KYC ERC-4626 vault shares into underlying for the given credit manager.
+   * Used when withdrawing debt from a KYC market: redeems adapter vault shares so the underlying can be withdrawn.
+   * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+   * @param amount - Number of vault shares (adapter tokens) to redeem
+   * @param creditManager - Credit manager address
+   * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+   */
+  async getKYCUnwrapCalls(amount, creditManager) {
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (!this.sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return void 0;
+    }
+    const adapter = suite.creditManager.adapters.get(meta.addr);
+    const adapterAddress = adapter?.address;
+    if (!adapterAddress) {
+      return void 0;
+    }
+    const mc = [
+      {
+        target: adapterAddress,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: ierc4626AdapterAbi,
+          functionName: "redeem",
+          args: [amount, import_constants.ADDRESS_0X0, import_constants.ADDRESS_0X0]
+        })
+      }
+    ];
+    return mc;
+  }
+  /**
+   * Returns multicall entries to deposit (wrap) underlying into KYC ERC-4626 vault shares for the given credit manager.
+   * Used when adding debt on a KYC market: deposits underlying into the adapter vault so shares are minted on the account.
+   * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+   * @param amount - Amount of underlying assets to deposit into the vault (in underlying decimals)
+   * @param creditManager - Credit manager address
+   * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+   */
+  async getKYCWrapCalls(amount, creditManager) {
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (!this.sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return void 0;
+    }
+    const adapter = suite.creditManager.adapters.get(meta.addr);
+    const adapterAddress = adapter?.address;
+    if (!adapterAddress) {
+      return void 0;
+    }
+    const mc = [
+      {
+        target: adapterAddress,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: ierc4626AdapterAbi,
+          functionName: "deposit",
+          args: [amount, import_constants.ADDRESS_0X0]
+        })
+      }
+    ];
+    return mc;
+  }
+  /**
+   * Returns multicall entries to call redeemDiff on the KYC ERC-4626 adapter for the given credit manager.
+   * Redeems the leftover vault shares (e.g. after repaying debt) so the account does not hold excess KYC vault tokens.
+   * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+   * @param amount - Leftover vault share amount to redeem (in adapter/vault decimals)
+   * @param creditManager - Credit manager address
+   * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+   */
+  async getRedeemDiffCalls(amount, creditManager) {
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (!this.sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return void 0;
+    }
+    const adapter = suite.creditManager.adapters.get(meta.addr);
+    const adapterAddress = adapter?.address;
+    if (!adapterAddress) {
+      return void 0;
+    }
+    const mc = [
+      {
+        target: adapterAddress,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: ierc4626AdapterAbi,
+          functionName: "redeemDiff",
+          args: [amount]
+        })
+      }
+    ];
+    return mc;
+  }
+  /**
+   * Returns multicall entries to call depositDiff on the KYC ERC-4626 adapter for the given credit manager.
+   * Deposits the leftover underlying (e.g. after decreasing debt) into the vault so the account does not hold excess underlying.
+   * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+   * @param amount - Leftover underlying amount to deposit into the vault (in underlying decimals)
+   * @param creditManager - Credit manager address
+   * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+   */
+  async getDepositDiffCalls(amount, creditManager) {
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (!this.sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return void 0;
+    }
+    const adapter = suite.creditManager.adapters.get(meta.addr);
+    const adapterAddress = adapter?.address;
+    if (!adapterAddress) {
+      return void 0;
+    }
+    const mc = [
+      {
+        target: adapterAddress,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: ierc4626AdapterAbi,
+          functionName: "depositDiff",
+          args: [amount]
+        })
+      }
+    ];
+    return mc;
+  }
   /**
    * Returns raw txs that are needed to update all price feeds so that all credit accounts (possibly from different markets) compute
    *
@@ -1176,78 +1439,174 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       import_constants.VERSION_RANGE_310
     )[0];
   }
+  /**
+   * Wrapper that selects between credit facade and KYC factory
+   * @param suite
+   * @param to
+   * @param calls
+   * @param referralCode
+   * @returns
+   */
+  async openCreditAccountTx(suite, to, calls, referralCode) {
+    const marketSuite = this.sdk.marketRegister.findByPool(suite.pool);
+    const factory = await marketSuite.getKYCFactory();
+    if (factory) {
+      const tokensToRegister = await factory.getDSTokens();
+      return factory.openCreditAccount(
+        suite.creditManager.address,
+        calls,
+        tokensToRegister
+      );
+    }
+    return suite.creditFacade.openCreditAccount(to, calls, referralCode ?? 0n);
+  }
+  /**
+   * Wrapper that selects between credit facade and KYC factory
+   * @param suite
+   * @param creditAccount
+   * @param calls
+   * @returns
+   */
+  async multicallTx(suite, creditAccount, calls) {
+    const marketSuite = this.sdk.marketRegister.findByCreditManager(
+      suite.creditManager.address
+    );
+    const factory = await marketSuite.getKYCFactory();
+    if (factory) {
+      const tokensToRegister = [];
+      return factory.multicall(creditAccount, calls, tokensToRegister);
+    }
+    return suite.creditFacade.multicall(creditAccount, calls);
+  }
+  /**
+   * Wrapper that selects between credit facade and KYC factory
+   * @param suite
+   * @param creditAccount
+   * @param calls
+   * @param operation
+   * @returns
+   */
+  async closeCreditAccountTx(suite, creditAccount, calls, operation) {
+    const marketSuite = this.sdk.marketRegister.findByCreditManager(
+      suite.creditManager.address
+    );
+    const factory = await marketSuite.getKYCFactory();
+    if (operation === "close") {
+      if (factory) {
+        throw new Error(
+          "CloseOptions=close is not supported for KYC underlying credit accounts"
+        );
+      }
+      return suite.creditFacade.closeCreditAccount(creditAccount, calls);
+    }
+    if (factory) {
+      const tokensToRegister = [];
+      return factory.multicall(creditAccount, calls, tokensToRegister);
+    }
+    return suite.creditFacade.multicall(creditAccount, calls);
+  }
+  /**
+   * Returns all KYC credit account addresses for an investor across the given market suites.
+   * Resolves KYC factory per suite, then multicalls each factory's getCreditAccounts(investor).
+   * @param investor - Owner address to query
+   * @param suites - Market suites (KYC factories are resolved for each; undefined entries are skipped)
+   * @returns Flat array of credit account addresses from all KYC markets
+   */
+  async getKYCCaOfInvestor(investor, suites) {
+    if (suites.length === 0 || investor === import_constants.ADDRESS_0X0) return [];
+    const factories = await Promise.all(
+      suites.map((suite) => suite ? suite.getKYCFactory() : void 0)
+    );
+    const safeFactories = factories.reduce(
+      (acc, v) => {
+        if (v) {
+          acc.push(v);
+        }
+        return acc;
+      },
+      []
+    );
+    const allResp = await this.client.multicall({
+      contracts: [
+        ...safeFactories.map((factory) => {
+          return {
+            abi: factory.abi,
+            address: factory.address,
+            functionName: "getCreditAccounts",
+            args: [investor]
+          };
+        })
+      ],
+      allowFailure: true,
+      batchSize: 0
+    });
+    const caLists = safeFactories.reduce((acc, _, index) => {
+      const response = allResp[index];
+      acc.push(...response.result || []);
+      return acc;
+    }, []);
+    return caLists;
+  }
 }
-const iMellowClaimerAdapterAbi = [
+const ierc4626AdapterAbi = [
   {
-    type: "function",
-    name: "getMultiVaultSubvaultIndices",
-    inputs: [{ name: "multiVault", type: "address", internalType: "address" }],
-    outputs: [
-      {
-        name: "subvaultIndices",
-        type: "uint256[]",
-        internalType: "uint256[]"
-      },
-      {
-        name: "withdrawalIndices",
-        type: "uint256[][]",
-        internalType: "uint256[][]"
-      }
+    inputs: [
+      { name: "assets", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" }
     ],
-    stateMutability: "view"
+    name: "deposit",
+    outputs: [{ name: "useSafePrices", type: "bool", internalType: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
   },
   {
-    type: "function",
-    name: "getUserSubvaultIndices",
     inputs: [
-      { name: "multiVault", type: "address", internalType: "address" },
-      { name: "user", type: "address", internalType: "address" }
+      { name: "shares", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" },
+      { name: "owner", type: "address", internalType: "address" }
     ],
-    outputs: [
+    name: "redeem",
+    outputs: [{ name: "useSafePrices", type: "bool", internalType: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
       {
-        name: "subvaultIndices",
-        type: "uint256[]",
-        internalType: "uint256[]"
-      },
+        name: "leftoverAmount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    name: "redeemDiff",
+    outputs: [
       {
-        name: "withdrawalIndices",
-        type: "uint256[][]",
-        internalType: "uint256[][]"
+        name: "useSafePrices",
+        type: "bool",
+        internalType: "bool"
       }
     ],
-    stateMutability: "view"
+    stateMutability: "nonpayable",
+    type: "function"
   },
   {
-    type: "function",
-    name: "multiAccept",
     inputs: [
-      { name: "multiVault", type: "address", internalType: "address" },
       {
-        name: "subvaultIndices",
-        type: "uint256[]",
-        internalType: "uint256[]"
-      },
-      { name: "indices", type: "uint256[][]", internalType: "uint256[][]" }
+        name: "leftoverAmount",
+        type: "uint256",
+        internalType: "uint256"
+      }
     ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "multiAcceptAndClaim",
-    inputs: [
-      { name: "multiVault", type: "address", internalType: "address" },
+    name: "depositDiff",
+    outputs: [
       {
-        name: "subvaultIndices",
-        type: "uint256[]",
-        internalType: "uint256[]"
-      },
-      { name: "indices", type: "uint256[][]", internalType: "uint256[][]" },
-      { name: "", type: "address", internalType: "address" },
-      { name: "maxAssets", type: "uint256", internalType: "uint256" }
+        name: "useSafePrices",
+        type: "bool",
+        internalType: "bool"
+      }
     ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable"
+    stateMutability: "nonpayable",
+    type: "function"
   }
 ];
 // Annotate the CommonJS export names for ESM import in node: