@gearbox-protocol/sdk 14.0.0-next.9 → 14.1.0-next.1

package/dist/cjs/sdk/market/kyc/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var kyc_exports = {};
+module.exports = __toCommonJS(kyc_exports);
+__reExport(kyc_exports, require("./KYCRegistry.js"), module.exports);
+__reExport(kyc_exports, require("./securitize/index.js"), module.exports);
+__reExport(kyc_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./KYCRegistry.js"),
+  ...require("./securitize/index.js"),
+  ...require("./types.js")
+});

package/dist/cjs/sdk/market/kyc/securitize/SecuritizeKYCFactory.js

@@ -0,0 +1,242 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SecuritizeKYCFactory_exports = {};
+__export(SecuritizeKYCFactory_exports, {
+  SecuritizeKYCFactory: () => SecuritizeKYCFactory
+});
+module.exports = __toCommonJS(SecuritizeKYCFactory_exports);
+var import_viem = require("viem");
+var import_iSecuritizeKYCFactory = require("../../../../abi/kyc/iSecuritizeKYCFactory.js");
+var import_base = require("../../../base/index.js");
+var import_utils = require("../../../utils/index.js");
+var import_constants = require("./constants.js");
+const abi = import_iSecuritizeKYCFactory.iSecuritizeKYCFactoryAbi;
+class SecuritizeKYCFactory extends import_base.BaseContract {
+  #sdk;
+  #investorCache = new import_utils.AddressMap();
+  degenNFT;
+  owner;
+  dsTokens;
+  contractType = import_constants.KYC_FACTORY_SECURITIZE;
+  constructor(sdk, data) {
+    super(sdk, {
+      ...data.baseParams,
+      name: "SecuritizeKYCFactory",
+      abi
+    });
+    this.#sdk = sdk;
+    const decoded = (0, import_viem.decodeAbiParameters)(
+      [
+        { name: "owner", type: "address" },
+        { name: "degenNFT", type: "address" },
+        {
+          name: "dsTokensData",
+          type: "tuple[]",
+          components: [
+            { name: "token", type: "address" },
+            { name: "registrar", type: "address" },
+            { name: "operators", type: "address[]" }
+          ]
+        }
+      ],
+      data.baseParams.serializedParams
+    );
+    this.owner = decoded[0];
+    this.degenNFT = decoded[1];
+    for (const t of data.tokens) {
+      this.tokensMeta.upsert(t.addr, t);
+    }
+    this.dsTokens = decoded[2].map((t) => ({
+      address: t.token,
+      registrar: t.registrar,
+      operators: [...t.operators]
+    }));
+  }
+  /**
+   * {@inheritDoc IKYCFactory.decodeInvestorData}
+   */
+  decodeInvestorData(data) {
+    const { creditAccounts, extraDetails } = data;
+    const [registeredTokens, cachedSignatures, registerVaultMessages] = (0, import_viem.decodeAbiParameters)(
+      [
+        { name: "registeredTokens", type: "address[]" },
+        {
+          name: "cachedSignatures",
+          type: "tuple[]",
+          components: [...registerMessageTuple]
+        },
+        {
+          name: "registerVaultMessages",
+          type: "tuple[]",
+          components: [...registerVaultMessageTuple]
+        }
+      ],
+      extraDetails
+    );
+    return {
+      type: import_constants.KYC_FACTORY_SECURITIZE,
+      factory: this.address,
+      cachedSignatures: [...cachedSignatures],
+      registerVaultMessages: [...registerVaultMessages],
+      registeredTokens: [...registeredTokens],
+      creditAccounts: creditAccounts.map((ca) => {
+        const [registeredTokens2] = (0, import_viem.decodeAbiParameters)(
+          [{ name: "registeredTokens", type: "address[]" }],
+          ca.extraDetails
+        );
+        return {
+          ...ca,
+          registeredTokens: [...registeredTokens2]
+        };
+      })
+    };
+  }
+  /**
+   * {@inheritDoc IKYCFactory.getInvestor}
+   */
+  async getInvestor(creditAccount, fromCache) {
+    if (fromCache && this.#investorCache.has(creditAccount)) {
+      return this.#investorCache.mustGet(creditAccount);
+    }
+    const investor = await this.contract.read.getInvestor([creditAccount]);
+    if (fromCache) {
+      this.#investorCache.upsert(creditAccount, investor);
+    }
+    return investor;
+  }
+  /**
+   * {@inheritDoc IKYCFactory.getApprovalAddress}
+   */
+  async getApprovalAddress(options) {
+    if ("creditAccount" in options) {
+      return this.getWallet(options.creditAccount);
+    }
+    return this.#precomputeWalletAddress(
+      options.creditManager,
+      options.borrower
+    );
+  }
+  /**
+   * {@inheritDoc IKYCFactory.getWallet}
+   */
+  async getWallet(creditAccount) {
+    return this.contract.read.getWallet([creditAccount]);
+  }
+  /**
+   * {@inheritDoc IKYCFactory.multicall}
+   */
+  multicall(creditAccount, calls, options) {
+    const { tokensToRegister = [], signaturesToCache = [] } = options ?? {};
+    return this.createRawTx({
+      functionName: "multicall",
+      args: [creditAccount, calls, tokensToRegister, signaturesToCache]
+    });
+  }
+  /**
+   * {@inheritDoc IKYCFactory.getOpenAccountRequirements}
+   */
+  async getOpenAccountRequirements(investor, props) {
+    const [investorData] = await this.#sdk.kyc.getInvestorData(investor, [
+      this.address
+    ]);
+    const tokensToRegister = new import_utils.AddressSet([props.tokenOutAddress]);
+    const registredTokens = new import_utils.AddressSet(investorData.registeredTokens);
+    const signedTokens = new import_utils.AddressSet(
+      investorData.cachedSignatures.map((s) => s.token)
+    );
+    const unsignedTokens = tokensToRegister.difference(signedTokens);
+    const securitizeTokensToRegister = tokensToRegister.difference(registredTokens);
+    const requiredSignatures = investorData.registerVaultMessages.filter(
+      (m) => unsignedTokens.has(m.token)
+    );
+    return {
+      type: import_constants.KYC_FACTORY_SECURITIZE,
+      securitizeTokensToRegister: Array.from(securitizeTokensToRegister),
+      tokensToRegister: Array.from(tokensToRegister),
+      requiredSignatures
+    };
+  }
+  /**
+   * {@inheritDoc IKYCFactory.openCreditAccount}
+   */
+  openCreditAccount(creditManager, calls, options) {
+    const { tokensToRegister = [], signaturesToCache = [] } = options ?? {};
+    return this.createRawTx({
+      functionName: "openCreditAccount",
+      args: [creditManager, calls, tokensToRegister, signaturesToCache]
+    });
+  }
+  stateHuman(_raw) {
+    return {
+      ...super.stateHuman(_raw),
+      owner: this.labelAddress(this.owner),
+      degenNFT: this.labelAddress(this.degenNFT),
+      dsTokens: this.dsTokens.map((t) => ({
+        ...this.tokensMeta.mustGet(t.address),
+        registrar: this.labelAddress(t.registrar),
+        operators: t.operators.map((o) => this.labelAddress(o))
+      }))
+    };
+  }
+  /**
+   * Precomputes the wallet address that will own a new credit account
+   * for the given investor in the given credit manager.
+   *
+   * @param creditManager - credit manager address
+   * @param investor - investor address
+   **/
+  async #precomputeWalletAddress(creditManager, investor) {
+    return this.contract.read.precomputeWalletAddress([
+      creditManager,
+      investor
+    ]);
+  }
+}
+const registerMessageTuple = [
+  { name: "token", type: "address" },
+  {
+    name: "signature",
+    type: "tuple",
+    components: [
+      { name: "deadline", type: "uint256" },
+      { name: "signature", type: "bytes" }
+    ]
+  }
+];
+const registerVaultMessageTuple = [
+  {
+    name: "domain",
+    type: "tuple",
+    components: [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ]
+  },
+  { name: "investor", type: "address" },
+  { name: "operator", type: "address" },
+  { name: "token", type: "address" },
+  { name: "nonce", type: "uint256" },
+  { name: "deadline", type: "uint256" }
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SecuritizeKYCFactory
+});

package/dist/cjs/sdk/market/kyc/securitize/constants.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  KYC_FACTORY_SECURITIZE: () => KYC_FACTORY_SECURITIZE
+});
+module.exports = __toCommonJS(constants_exports);
+const KYC_FACTORY_SECURITIZE = "KYC_FACTORY::SECURITIZE";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KYC_FACTORY_SECURITIZE
+});

package/dist/cjs/sdk/market/kyc/securitize/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var securitize_exports = {};
+module.exports = __toCommonJS(securitize_exports);
+__reExport(securitize_exports, require("./constants.js"), module.exports);
+__reExport(securitize_exports, require("./SecuritizeKYCFactory.js"), module.exports);
+__reExport(securitize_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./constants.js"),
+  ...require("./SecuritizeKYCFactory.js"),
+  ...require("./types.js")
+});

package/dist/cjs/sdk/market/kyc/securitize/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/sdk/{accounts/utils.js → market/kyc/types.js}

@@ -16,23 +16,19 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  stringifyGetCreditAccountsArgs: () => stringifyGetCreditAccountsArgs
+var types_exports = {};
+__export(types_exports, {
+  KYC_FACTORY_TYPES: () => KYC_FACTORY_TYPES,
+  isKYCFactory: () => isKYCFactory
 });
-module.exports = __toCommonJS(utils_exports);
-function stringifyGetCreditAccountsArgs(args) {
-  const s = JSON.stringify(args, replacer);
-  return JSON.parse(s);
-}
-function replacer(_key, value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  } else {
-    return value;
-  }
+module.exports = __toCommonJS(types_exports);
+var import_securitize = require("./securitize/index.js");
+const KYC_FACTORY_TYPES = [import_securitize.KYC_FACTORY_SECURITIZE];
+function isKYCFactory(factory, type) {
+  return factory.contractType === type;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  stringifyGetCreditAccountsArgs
+  KYC_FACTORY_TYPES,
+  isKYCFactory
 });

package/dist/cjs/sdk/market/pool/PoolSuite.js

@@ -88,6 +88,9 @@ class PoolSuite extends import_base.SDKConstruct {
   get underlying() {
     return this.pool.underlying;
   }
+  get kycFactory() {
+    return this.pool.kycFactory;
+  }
   get dirty() {
     return this.pool.dirty || this.rateKeeper.dirty || this.pqk.dirty || this.interestRateModel.dirty;
   }

package/dist/cjs/sdk/market/pool/PoolV310Contract.js

@@ -28,13 +28,15 @@ var import_utils = require("../../utils/index.js");
 const abi = [...import_generated.iPoolV310Abi, ...import_iPausable.iPausableAbi];
 class PoolV310Contract extends import_base.BaseContract {
   creditManagerDebtParams;
-  constructor(options, data) {
+  #sdk;
+  constructor(sdk, data) {
     const { baseParams, creditManagerDebtParams, ...rest } = data;
-    super(options, {
+    super(sdk, {
       ...data.baseParams,
       name: `PoolV3(${data.name})`,
       abi
     });
+    this.#sdk = sdk;
     Object.assign(this, rest);
     this.creditManagerDebtParams = new import_utils.AddressMap(
       creditManagerDebtParams.map((p) => [p.creditManager, p])
@@ -46,6 +48,13 @@ class PoolV310Contract extends import_base.BaseContract {
       symbol: data.symbol
     });
   }
+  get kycFactory() {
+    const meta = this.#sdk.tokensMeta.mustGet(this.underlying);
+    if (this.#sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return this.#sdk.mustGetContract(meta.kycFactory);
+    }
+    return void 0;
+  }
   stateHuman(raw = true) {
     return {
       ...super.stateHuman(raw),

package/dist/cjs/sdk/market/pool/index.js

@@ -18,11 +18,13 @@ module.exports = __toCommonJS(pool_exports);
 __reExport(pool_exports, require("./GaugeContract.js"), module.exports);
 __reExport(pool_exports, require("./LinearInterestRateModelContract.js"), module.exports);
 __reExport(pool_exports, require("./PoolSuite.js"), module.exports);
+__reExport(pool_exports, require("./PoolV310Contract.js"), module.exports);
 __reExport(pool_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./GaugeContract.js"),
   ...require("./LinearInterestRateModelContract.js"),
   ...require("./PoolSuite.js"),
+  ...require("./PoolV310Contract.js"),
   ...require("./types.js")
 });

package/dist/cjs/sdk/market/pricefeeds/PriceFeedsRegister.js

@@ -237,13 +237,13 @@ class PriceFeedRegister extends import_base.SDKConstruct {
    * Loads PARTIAL information about all updatable price feeds from MarketCompressor
    * Discovered price feeds are not saved anywhere in PriceFeedRegister, and can later be used to load price feed updates
    */
-  async getPartialUpdatablePriceFeeds(configurators, pools) {
+  async getPartialUpdatablePriceFeeds(configurators) {
     const [priceFeedCompressorAddress] = this.sdk.addressProvider.mustGetLatest(
       import_constants.AP_PRICE_FEED_COMPRESSOR,
       import_constants.VERSION_RANGE_310
     );
     this.logger?.debug(
-      { configurators, pools },
+      { configurators },
       `calling getUpdatablePriceFeeds in block ${this.sdk.currentBlock}`
     );
     const result = await this.client.readContract({
@@ -253,7 +253,7 @@ class PriceFeedRegister extends import_base.SDKConstruct {
       args: [
         {
           configurators,
-          pools: pools ?? [],
+          pools: [],
           underlying: import_constants.ADDRESS_0X0
         }
       ],

package/dist/cjs/sdk/options.js

@@ -44,6 +44,12 @@ const AttachOptionsSchema = import_v4.z.object({
   addressProvider: (0, import_utils.ZodAddress)().optional(),
   /** Addresses of market configurator contracts to load. */
   marketConfigurators: import_v4.z.array((0, import_utils.ZodAddress)()).optional(),
+  /**
+   * Addresses of KYC factory contracts to load.
+   * If not set, all default KYC factories for the chain are loaded
+   * (from {@link GearboxChain.kycFactories})
+   **/
+  kycFactories: import_v4.z.array((0, import_utils.ZodAddress)()).optional(),
   /** Pin SDK to a specific block number during attach. */
   blockNumber: import_v4.z.union([import_v4.z.bigint().nonnegative(), import_v4.z.number().int().nonnegative()]).optional(),
   /** Skip fetching updatable price feeds on attach and sync. */

package/dist/cjs/sdk/pools/PoolService.js

@@ -22,6 +22,7 @@ __export(PoolService_exports, {
 });
 module.exports = __toCommonJS(PoolService_exports);
 var import_generated = require("../../abi/310/generated.js");
+var import_iERC20 = require("../../abi/iERC20.js");
 var import_iERC20ZapperDeposits = require("../../abi/iERC20ZapperDeposits.js");
 var import_iETHZapperDeposits = require("../../abi/iETHZapperDeposits.js");
 var import_iZapper = require("../../abi/iZapper.js");
@@ -30,28 +31,73 @@ var import_constants = require("../constants/index.js");
 var import_utils = require("../utils/index.js");
 class PoolService extends import_base.SDKConstruct {
   /**
-   * @inheritdoc IPoolsService.getDepositTokensIn
+   * {@inheritDoc IPoolsService.getDepositTokensIn}
    */
   getDepositTokensIn(pool) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#depositTokensIn(pool, false);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [underlying.asset];
+      }
+    }
     return this.#depositTokensIn(pool, true);
   }
   /**
-   * @inheritdoc IPoolsService.getDepositTokensOut
+   * {@inheritDoc IPoolsService.getDepositTokensOut}
    */
   getDepositTokensOut(pool, tokenIn) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#depositTokensOut(pool, tokenIn, false);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [];
+      }
+    }
     return this.#depositTokensOut(pool, tokenIn, true);
   }
   /**
-   * @inheritdoc IPoolsService.getDepositMetadata
+   * {@inheritDoc IPoolsService.getDepositMetadata}
    */
   getDepositMetadata(pool, tokenIn, tokenOut) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT: {
+          return this.#depositMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
+        }
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return {
+            zapper: void 0,
+            approveTarget: underlying.liquidityProvider.addr,
+            permissible: false,
+            type: "kyc-on-demand"
+          };
+      }
+    }
     return this.#depositMetadata("classic", pool, tokenIn, tokenOut, true);
   }
   /**
-   * @inheritdoc IPoolsService.addLiquidity
+   * {@inheritDoc IPoolsService.addLiquidity}
    */
   addLiquidity(props) {
     const { collateral, meta, permit, referralCode, pool, wallet } = props;
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      if (underlying.contractType === import_base.KYC_UNDERLYING_ON_DEMAND) {
+        return void 0;
+      }
+    }
     const { zapper } = meta;
     if (zapper && (0, import_utils.hexEq)(zapper.tokenIn.addr, import_constants.NATIVE_ADDRESS)) {
       return {
@@ -91,22 +137,51 @@ class PoolService extends import_base.SDKConstruct {
     }
   }
   /**
-   * @inheritdoc IPoolsService.getWithdrawalTokensIn
+   * {@inheritDoc IPoolsService.getWithdrawalTokensIn}
    */
   getWithdrawalTokensIn(pool) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#withdrawalTokensIn(pool, false);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [];
+      }
+    }
     return this.#withdrawalTokensIn(pool, true);
   }
   /**
-   * @inheritdoc IPoolsService.getWithdrawalTokensOut
+   * {@inheritDoc IPoolsService.getWithdrawalTokensOut}
    */
   getWithdrawalTokensOut(pool, tokenIn) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#withdrawalTokensOut(pool, tokenIn, false);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [underlying.asset];
+      }
+    }
     return this.#withdrawalTokensOut(pool, tokenIn, true);
   }
   /**
-   * @inheritdoc IPoolsService.removeLiquidity
+   * {@inheritDoc IPoolsService.removeLiquidity}
    */
   removeLiquidity(props) {
     const { pool, amount, meta, wallet, permit } = props;
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      if (underlying.contractType === import_base.KYC_UNDERLYING_ON_DEMAND) {
+        return {
+          abi: import_iERC20.ierc20Abi,
+          functionName: "approve",
+          args: [underlying.liquidityProvider, 0n],
+          target: underlying.asset
+        };
+      }
+    }
     if (meta.zapper) {
       return permit ? {
         target: meta.zapper.baseParams.addr,
@@ -135,9 +210,30 @@ class PoolService extends import_base.SDKConstruct {
     };
   }
   /**
-   * @inheritdoc IPoolsService.getWithdrawalMetadata
+   * {@inheritDoc IPoolsService.getWithdrawalMetadata}
    */
   getWithdrawalMetadata(pool, tokenIn, tokenOut) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT: {
+          return this.#withdrawalMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
+        }
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return {
+            zapper: void 0,
+            approveTarget: void 0,
+            permissible: false,
+            type: "kyc-on-demand"
+          };
+      }
+    }
     return this.#withdrawalMetadata("classic", pool, tokenIn, tokenOut, true);
   }
   /**
@@ -297,8 +393,6 @@ class PoolService extends import_base.SDKConstruct {
       zapper,
       // Approval target is zapper when routed, otherwise the pool contract.
       approveTarget: zapper?.baseParams.addr ?? pool.pool.address,
-      // TODO: instead of permissible, return permitType depending on tokenIn
-      // "none" | "eip2612" | "dai_like";
       permissible: !!zapper && !(0, import_utils.hexEq)(tokenIn, import_constants.NATIVE_ADDRESS),
       type
     };
@@ -326,8 +420,6 @@ class PoolService extends import_base.SDKConstruct {
       zapper,
       // Approval target exists only for zapper-based withdrawals.
       approveTarget: zapper?.baseParams.addr,
-      // TODO: instead of permissible, return permitType depending on tokenIn
-      // "none" | "eip2612" | "dai_like";
       permissible: !!zapper,
       type
     };