@gearbox-protocol/sdk 14.0.0 → 14.1.0

package/dist/cjs/dev/AccountOpener.js

@@ -52,6 +52,7 @@ class AccountOpener extends import_sdk.SDKConstruct {
   #minDebtMultiplier;
   #allowMint;
   #leverageDelta;
+  #poolService;
   constructor(service, options_ = {}) {
     super(service.sdk);
     const {
@@ -77,6 +78,7 @@ class AccountOpener extends import_sdk.SDKConstruct {
     this.#poolDepositMultiplier = BigInt(poolDepositMultiplier);
     this.#minDebtMultiplier = BigInt(minDebtMultiplier);
     this.#leverageDelta = BigInt(leverageDelta);
+    this.#poolService = new import_sdk.PoolService(service.sdk);
     this.#logger?.info(
       {
         borrower: (0, import_accounts.privateKeyToAccount)(this.borrowerKey).address,
@@ -114,6 +116,10 @@ class AccountOpener extends import_sdk.SDKConstruct {
       },
       "opening credit accounts"
     );
+    await Promise.all([
+      this.sdk.tokensMeta.loadTokenData(),
+      this.sdk.marketRegister.loadZappers()
+    ]);
     let deposits = [];
     if (depositIntoPools) {
       try {
@@ -465,9 +471,34 @@ class AccountOpener extends import_sdk.SDKConstruct {
       this.#logger?.debug(
         `depositor balance in underlying: ${this.sdk.tokensMeta.formatBN(pool.underlying, allowance, { symbol: true })}`
       );
+      const tokensOut = this.#poolService.getDepositTokensOut(
+        address,
+        underlying
+      );
+      this.#logger?.debug(
+        { tokensOut: tokensOut.map((t) => this.labelAddress(t)) },
+        "deposit tokens out"
+      );
+      if (tokensOut.length === 0) {
+        throw new Error(`no tokens out found for pool ${poolName}`);
+      }
+      const tokenOut = tokensOut[0];
+      const metadata = this.#poolService.getDepositMetadata(
+        address,
+        underlying,
+        tokenOut
+      );
+      this.logger?.debug(
+        {
+          underlying: this.labelAddress(underlying),
+          tokenOut: this.labelAddress(tokenOut),
+          ...metadata
+        },
+        "pool deposit metadata"
+      );
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address: underlying,
+        address: metadata.approveTarget,
         abi: import_iERC20.ierc20Abi,
         functionName: "approve",
         args: [address, allowance],
@@ -484,12 +515,21 @@ class AccountOpener extends import_sdk.SDKConstruct {
       this.#logger?.debug(
         `depositor approved underlying for pool ${poolName}: ${txHash}`
       );
+      const depositCall = this.#poolService.addLiquidity({
+        collateral: { token: underlying, balance: amount },
+        pool: address,
+        wallet: depositor.address,
+        meta: metadata
+      });
+      if (!depositCall) {
+        throw new Error(`no deposit call could be created for ${poolName}`);
+      }
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address,
-        abi: import_generated.iPoolV310Abi,
-        functionName: "deposit",
-        args: [amount, depositor.address],
+        address: depositCall.target,
+        abi: depositCall.abi,
+        functionName: depositCall.functionName,
+        args: depositCall.args,
         chain: this.#anvil.chain
       });
       receipt = await this.#anvil.waitForTransactionReceipt({ hash: txHash });

package/dist/cjs/sdk/OnchainSDK.js

@@ -27,11 +27,13 @@ var import_base = require("./base/index.js");
 var import_chain = require("./chain/index.js");
 var import_constants = require("./constants/index.js");
 var import_core = require("./core/index.js");
+var import_market = require("./market/index.js");
 var import_MarketRegister = require("./market/MarketRegister.js");
 var import_pricefeeds = require("./market/pricefeeds/index.js");
 var import_plugins = require("./plugins/index.js");
 var import_router = require("./router/index.js");
 var import_utils = require("./utils/index.js");
+var import_viem2 = require("./utils/viem/index.js");
 const STATE_VERSION = 1;
 function createViemClient(opts, chain) {
   if ("client" in opts) {
@@ -60,6 +62,7 @@ class OnchainSDK extends import_base.ChainContractsRegister {
   #syncing = false;
   #attached = false;
   #addressProvider;
+  #kyc;
   #marketRegister;
   #priceFeeds;
   /**
@@ -87,6 +90,7 @@ class OnchainSDK extends import_base.ChainContractsRegister {
     super(client, options?.logger);
     this.strictContractTypes = options?.strictContractTypes ?? false;
     this.plugins = options?.plugins ?? {};
+    this.#kyc = new import_market.KYCRegistry(this);
     for (const plugin of Object.values(this.plugins)) {
       plugin.sdk = this;
     }
@@ -116,6 +120,7 @@ class OnchainSDK extends import_base.ChainContractsRegister {
     const marketConfigurators = mcs ?? import_utils.TypedObjectUtils.keys(
       this.client.chain.defaultMarketConfigurators
     );
+    const kycFactories = options?.kycFactories ?? this.client.chain.kycFactories;
     this.logger?.info(
       {
         networkType: this.networkType,
@@ -153,10 +158,33 @@ class OnchainSDK extends import_base.ChainContractsRegister {
     );
     await this.#addressProvider.syncState(this.currentBlock);
     this.#marketRegister = new import_MarketRegister.MarketRegister(this, ignoreMarkets);
-    await this.#marketRegister.loadMarkets(
-      marketConfigurators,
-      ignoreUpdateablePrices
-    );
+    if (!marketConfigurators.length) {
+      this.logger?.warn(
+        "no market configurators provided, skipping market loading"
+      );
+    } else {
+      const delegated = [
+        ...this.#marketRegister.getLoadMulticalls(marketConfigurators),
+        ...this.#kyc.getLoadMulticalls(marketConfigurators, kycFactories)
+      ];
+      let txs = [];
+      if (!ignoreUpdateablePrices) {
+        const updatables = await this.#priceFeeds.getPartialUpdatablePriceFeeds(
+          marketConfigurators
+        );
+        const updates = await this.#priceFeeds.generatePriceFeedsUpdateTxs(updatables);
+        txs = updates.txs;
+      }
+      this.logger?.debug(
+        { configurators: marketConfigurators },
+        `calling getMarkets with ${txs.length} price updates in block ${this.currentBlock}`
+      );
+      await (0, import_viem2.executeDelegatedMulticalls)(this.client, delegated, {
+        priceUpdates: txs,
+        blockNumber: this.currentBlock,
+        gas: this.gasLimit
+      });
+    }
     const pluginsList = import_utils.TypedObjectUtils.entries(this.plugins);
     const pluginResponse = await Promise.allSettled(
       pluginsList.map(([name, plugin]) => {
@@ -209,6 +237,8 @@ class OnchainSDK extends import_base.ChainContractsRegister {
     );
     this.#marketRegister = new import_MarketRegister.MarketRegister(this, ignoreMarkets);
     this.#marketRegister.hydrate(state.markets);
+    this.#kyc = new import_market.KYCRegistry(this);
+    this.#kyc.setState(state.kyc);
     for (const [name, plugin] of import_utils.TypedObjectUtils.entries(this.plugins)) {
       const pluginState = state.plugins[name];
       if (plugin.hydrate && pluginState) {
@@ -252,6 +282,7 @@ class OnchainSDK extends import_base.ChainContractsRegister {
         addressProviderV3: this.addressProvider.stateHuman(raw)
       },
       tokens: this.tokensMeta.values(),
+      kyc: this.#kyc.stateHuman(raw),
       plugins: Object.fromEntries(
         import_utils.TypedObjectUtils.entries(this.plugins).map(([name, plugin]) => [
           name,
@@ -271,6 +302,7 @@ class OnchainSDK extends import_base.ChainContractsRegister {
       timestamp: this.timestamp,
       addressProvider: this.addressProvider.state,
       markets: this.marketRegister.state,
+      kyc: this.#kyc.state,
       plugins: Object.fromEntries(
         import_utils.TypedObjectUtils.entries(this.plugins).map(([name, plugin]) => [
           name,
@@ -438,9 +470,27 @@ class OnchainSDK extends import_base.ChainContractsRegister {
     return this.#marketRegister;
   }
   /**
+   * KYC register for KYC-wrapped underlying tokens and factories.
+   *
+   * @throws If the SDK has not been attached or hydrated yet.
+   **/
+  get kyc() {
+    if (this.#kyc === void 0) {
+      throw new import_core.SdkNotAttachedError();
+    }
+    return this.#kyc;
+  }
+  /**
+   * @internal
    * Resolves the appropriate router contract for a given credit manager,
    * credit facade, or explicit version range.
-   */
+   *
+   * @param params - Identifies the context: a credit manager address/state,
+   *   a credit facade address/state, or a {@link VersionRange}.
+   * @returns The matching router contract instance.
+   * @throws If the credit facade version is unsupported or no router is
+   *   registered for the resolved version range.
+   **/
   routerFor(params) {
     let routerRange;
     if (Array.isArray(params)) {

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

@@ -22,6 +22,7 @@ __export(AbstractCreditAccountsService_exports, {
   getWithdrawalCompressorAddress: () => getWithdrawalCompressorAddress
 });
 module.exports = __toCommonJS(AbstractCreditAccountsService_exports);
+var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_generated = require("../../abi/310/generated.js");
 var import_creditAccountCompressor = require("../../abi/compressors/creditAccountCompressor.js");
@@ -29,6 +30,7 @@ var import_peripheryCompressor = require("../../abi/compressors/peripheryCompres
 var import_rewardsCompressor = require("../../abi/compressors/rewardsCompressor.js");
 var import_IWithdrawalCompressorV310 = require("../../abi/IWithdrawalCompressorV310.js");
 var import_iBaseRewardPool = require("../../abi/iBaseRewardPool.js");
+var import_iKYCFactory = require("../../abi/kyc/iKYCFactory.js");
 var import_base = require("../base/index.js");
 var import_chains = require("../chain/chains.js");
 var import_constants = require("../constants/index.js");
@@ -76,24 +78,40 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     } catch (_e) {
       return void 0;
     }
+    const marketSuite = this.sdk.marketRegister.findByCreditManager(
+      raw.creditManager
+    );
+    const factory = marketSuite.kycFactory;
+    let ca;
+    let investor;
     if (raw.success) {
-      return raw;
+      ca = raw;
+      investor = await factory?.getInvestor(raw.creditAccount, false);
+    } else {
+      const { txs: priceUpdateTxs } = await this.getUpdateForAccount(raw);
+      [ca, investor] = await (0, import_viem2.simulateWithPriceUpdates)(this.client, {
+        priceUpdates: priceUpdateTxs,
+        contracts: [
+          {
+            abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+            address: this.#compressor,
+            functionName: "getCreditAccountData",
+            args: [account]
+          },
+          ...factory ? [
+            {
+              abi: import_iKYCFactory.iKYCFactoryAbi,
+              address: factory.address,
+              functionName: "getInvestor",
+              args: [raw.creditAccount]
+            }
+          ] : []
+        ],
+        blockNumber,
+        gas: this.sdk.gasLimit
+      });
     }
-    const { txs: priceUpdateTxs } = await this.getUpdateForAccount(raw);
-    const [cad] = await (0, import_viem2.simulateWithPriceUpdates)(this.client, {
-      priceUpdates: priceUpdateTxs,
-      contracts: [
-        {
-          abi: import_creditAccountCompressor.creditAccountCompressorAbi,
-          address: this.#compressor,
-          functionName: "getCreditAccountData",
-          args: [account]
-        }
-      ],
-      blockNumber,
-      gas: this.sdk.gasLimit
-    });
-    return cad;
+    return { ...ca, investor };
   }
   /**
    * {@inheritDoc ICreditAccountsService.getCreditAccounts}
@@ -149,6 +167,99 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     );
     return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
   }
+  /**
+   * {@inheritDoc ICreditAccountsService.getBorrowerCreditAccounts}
+   **/
+  async getBorrowerCreditAccounts(borrower, options, blockNumber) {
+    const {
+      creditManager,
+      includeZeroDebt = false,
+      maxHealthFactor = import_constants.MAX_UINT256,
+      minHealthFactor = 0n,
+      ignoreReservePrices = false
+    } = options ?? {};
+    const { txs: priceUpdateTxs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(
+      ignoreReservePrices ? { main: true } : void 0
+    );
+    const investorDataList = await this.sdk.kyc.getInvestorData(borrower);
+    const kycAccountAddresses = investorDataList.flatMap(
+      (d) => d.creditAccounts.map((ca) => ca.creditAccount)
+    );
+    const cmFilter = creditManager ? {
+      configurators: [],
+      creditManagers: [creditManager],
+      pools: [],
+      underlying: import_constants.ADDRESS_0X0
+    } : {
+      configurators: this.marketConfigurators,
+      creditManagers: [],
+      pools: [],
+      underlying: import_constants.ADDRESS_0X0
+    };
+    const permissiveFilter = {
+      owner: borrower,
+      includeZeroDebt: true,
+      minHealthFactor: 0n,
+      maxHealthFactor: import_constants.MAX_UINT256,
+      reverting: false
+    };
+    const kycContracts = kycAccountAddresses.map(
+      (account) => ({
+        abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+        address: this.#compressor,
+        functionName: "getCreditAccountData",
+        args: [account]
+      })
+    );
+    const getCreditAccountsContracts = [false, true].map(
+      (reverting) => ({
+        abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+        address: this.#compressor,
+        functionName: "getCreditAccounts",
+        args: [cmFilter, { ...permissiveFilter, reverting }, 0n]
+      })
+    );
+    const allContracts = [...kycContracts, ...getCreditAccountsContracts];
+    const results = await (0, import_viem2.simulateWithPriceUpdates)(this.client, {
+      priceUpdates: priceUpdateTxs,
+      contracts: allContracts,
+      blockNumber,
+      gas: this.sdk.gasLimit
+    });
+    const kycResults = results.slice(
+      0,
+      kycAccountAddresses.length
+    );
+    const normalResults = results.slice(kycAccountAddresses.length);
+    const seen = new import_utils.AddressSet();
+    const allCAs = [];
+    for (const ca of kycResults) {
+      if (!seen.has(ca.creditAccount)) {
+        seen.add(ca.creditAccount);
+        allCAs.push({ ...ca, investor: borrower });
+      }
+    }
+    for (const [accounts] of normalResults) {
+      for (const ca of accounts) {
+        if (!seen.has(ca.creditAccount)) {
+          seen.add(ca.creditAccount);
+          allCAs.push({ ...ca, investor: void 0 });
+        }
+      }
+    }
+    const filtered = allCAs.filter((ca) => {
+      if (!includeZeroDebt && ca.debt === 0n) return false;
+      if (ca.healthFactor < minHealthFactor) return false;
+      if (ca.healthFactor > maxHealthFactor) return false;
+      if (creditManager && !(0, import_utils.hexEq)(ca.creditManager, creditManager))
+        return false;
+      return true;
+    });
+    this.logger?.debug(
+      `loaded ${allCAs.length} borrower credit accounts (${kycResults.length} KYC, ${filtered.length} after filter)`
+    );
+    return filtered.sort((a, b) => Number(a.healthFactor - b.healthFactor));
+  }
   /**
    * {@inheritDoc ICreditAccountsService.getRewards}
    **/
@@ -358,6 +469,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,
@@ -463,8 +581,18 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       ],
       {}
     ) : [];
+    const unwrapCalls = collateral && isDecrease ? await this.getKYCUnwrapCalls(
+      collateral[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 operationCalls = [
       ...addCollateralCalls,
+      ...unwrapCalls,
       this.#prepareChangeDebt(creditAccount.creditFacade, change, isDecrease)
     ];
     const calls = await this.prependPriceUpdates(
@@ -672,6 +800,29 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     const tx = await this.multicallTx(cm, creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
+  /**
+   * {@inheritDoc ICreditAccountsService.getApprovalAddress}
+   **/
+  async getApprovalAddress(options) {
+    const { creditManager } = options;
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const marketSuite = this.sdk.marketRegister.findByPool(suite.pool);
+    const factory = marketSuite.kycFactory;
+    if (factory) {
+      return factory.getApprovalAddress(options);
+    }
+    return suite.creditManager.address;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getOpenAccountRequirements}
+   */
+  async getOpenAccountRequirements(borrower, creditManager, props) {
+    const { kycFactory } = this.sdk.marketRegister.findByCreditManager(creditManager);
+    if (!kycFactory) {
+      return void 0;
+    }
+    return kycFactory.getOpenAccountRequirements(borrower, props);
+  }
   /**
    * {@inheritDoc ICreditAccountsService.openCA}
    **/
@@ -689,7 +840,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       calls: openPathCalls,
       callsAfter,
       minQuota,
-      averageQuota
+      averageQuota,
+      kycOptions
     } = props;
     const cmSuite = this.sdk.marketRegister.findCreditManager(creditManager);
     const cm = cmSuite.creditManager;
@@ -723,7 +875,13 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     if (reopenCreditAccount) {
       tx = await this.multicallTx(cmSuite, reopenCreditAccount, calls);
     } else {
-      tx = await this.openCreditAccountTx(cmSuite, to, calls, referralCode);
+      tx = await this.openCreditAccountTx(
+        cmSuite,
+        to,
+        calls,
+        referralCode,
+        kycOptions
+      );
     }
     tx.value = ethAmount.toString(10);
     return { calls, tx, creditFacade: cmSuite.creditFacade };
@@ -806,6 +964,131 @@ 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: import_integrations_v3.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: import_integrations_v3.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: import_integrations_v3.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: import_integrations_v3.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
    * {@inheritDoc ICreditAccountsService.getOnDemandPriceUpdates}
    **/
   async getOnDemandPriceUpdates(account, ignoreReservePrices) {
@@ -1060,9 +1343,19 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
    * @param to
    * @param calls
    * @param referralCode
+   * @param kycOptions
    * @returns
    */
-  async openCreditAccountTx(suite, to, calls, referralCode) {
+  async openCreditAccountTx(suite, to, calls, referralCode, kycOptions) {
+    const marketSuite = this.sdk.marketRegister.findByPool(suite.pool);
+    const factory = marketSuite.kycFactory;
+    if (factory) {
+      return factory.openCreditAccount(
+        suite.creditManager.address,
+        calls,
+        kycOptions
+      );
+    }
     return suite.creditFacade.openCreditAccount(to, calls, referralCode ?? 0n);
   }
   /**
@@ -1070,9 +1363,17 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
    * @param suite
    * @param creditAccount
    * @param calls
+   * @param kycOptions
    * @returns
    */
-  async multicallTx(suite, creditAccount, calls) {
+  async multicallTx(suite, creditAccount, calls, kycOptions) {
+    const marketSuite = this.sdk.marketRegister.findByCreditManager(
+      suite.creditManager.address
+    );
+    const factory = marketSuite.kycFactory;
+    if (factory) {
+      return factory.multicall(creditAccount, calls, kycOptions);
+    }
     return suite.creditFacade.multicall(creditAccount, calls);
   }
   /**
@@ -1081,12 +1382,25 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
    * @param creditAccount
    * @param calls
    * @param operation
+   * @param kycOptions
    * @returns
    */
-  async closeCreditAccountTx(suite, creditAccount, calls, operation) {
+  async closeCreditAccountTx(suite, creditAccount, calls, operation, kycOptions) {
+    const marketSuite = this.sdk.marketRegister.findByCreditManager(
+      suite.creditManager.address
+    );
+    const factory = marketSuite.kycFactory;
     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) {
+      return factory.multicall(creditAccount, calls, kycOptions);
+    }
     return suite.creditFacade.multicall(creditAccount, calls);
   }
 }