@gearbox-protocol/sdk 13.0.0-next.16 → 13.0.0-next.18

package/dist/cjs/abi/310/iSecuritizeKYCFactory.js

@@ -50,6 +50,13 @@ const iSecuritizeKYCFactoryAbi = [
     outputs: [{ name: "", type: "address[]", internalType: "address[]" }],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "getDSTokens",
+    inputs: [],
+    outputs: [{ name: "", type: "address[]", internalType: "address[]" }],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "getInvestor",

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

@@ -787,43 +787,52 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     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);
+    await this.sdk.tokensMeta.loadTokenData(suite.underlying);
+    const underlying = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      const factory = new import_market.SecuritizeKYCFactory(this.sdk, underlying.kycFactory);
+      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,
-    withdrawToken,
-    referralCode,
-    to,
-    calls: openPathCalls,
-    minQuota,
-    averageQuota
-  }) {
+   **/
+  async openCA(props) {
+    const {
+      ethAmount,
+      creditManager,
+      reopenCreditAccount,
+      collateral,
+      permits,
+      debt,
+      withdrawToken,
+      referralCode,
+      to,
+      calls: openPathCalls,
+      minQuota,
+      averageQuota
+    } = props;
     const cmSuite = this.sdk.marketRegister.findCreditManager(creditManager);
     const cm = cmSuite.creditManager;
     let tokenToWithdraw;
@@ -855,7 +864,12 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
         averageQuota
       })
     ];
-    const tx = await this.openCreditAccountTx(cmSuite, 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 };
   }
@@ -1208,8 +1222,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     await this.sdk.tokensMeta.loadTokenData(suite.underlying);
     const underlying = this.sdk.tokensMeta.mustGet(suite.underlying);
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      const tokensToRegister = [];
       const factory = new import_market.SecuritizeKYCFactory(this.sdk, underlying.kycFactory);
+      const tokensToRegister = await factory.getDSTokens();
       return factory.openCreditAccount(
         suite.creditManager.address,
         calls,

package/dist/cjs/sdk/base/ChainContractsRegister.js

@@ -48,7 +48,7 @@ class ChainContractsRegister {
   logger;
   constructor(client, logger) {
     this.client = client;
-    this.tokensMeta = new import_TokensMeta.TokensMeta(client);
+    this.tokensMeta = new import_TokensMeta.TokensMeta(client, logger);
     this.logger = logger;
   }
   resetContracts() {

package/dist/cjs/sdk/base/TokensMeta.js

@@ -22,16 +22,19 @@ __export(TokensMeta_exports, {
 });
 module.exports = __toCommonJS(TokensMeta_exports);
 var import_viem = require("viem");
+var import_iSecuritizeKYCFactory = require("../../abi/310/iSecuritizeKYCFactory.js");
 var import_iStateSerializer = require("../../abi/iStateSerializer.js");
 var import_iVersion = require("../../abi/iVersion.js");
-var import__ = require("../index.js");
 var import_utils = require("../utils/index.js");
+var import_token_types = require("./token-types.js");
 class TokensMeta extends import_utils.AddressMap {
   #client;
   #tokenDataLoaded = new import_utils.AddressSet();
-  constructor(client) {
+  #logger;
+  constructor(client, logger) {
     super(void 0, "tokensMeta");
     this.#client = client;
+    this.#logger = logger?.child?.({ name: "TokensMeta" }) ?? logger;
   }
   reset() {
     this.clear();
@@ -43,6 +46,11 @@ class TokensMeta extends import_utils.AddressMap {
   decimals(token) {
     return this.mustGet(token).decimals;
   }
+  /**
+   * Returns true if the token is a phantom token, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
   isPhantomToken(t) {
     if (!this.#tokenDataLoaded.has(t.addr)) {
       throw new Error(
@@ -51,6 +59,11 @@ class TokensMeta extends import_utils.AddressMap {
     }
     return "contractType" in t && t.contractType.startsWith("PHANTOM_TOKEN::");
   }
+  /**
+   * Returns true if the token is a KYC underlying token, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
   isKYCUnderlying(t) {
     if (!this.#tokenDataLoaded.has(t.addr)) {
       throw new Error(
@@ -59,9 +72,22 @@ class TokensMeta extends import_utils.AddressMap {
     }
     return "contractType" in t && t.contractType.startsWith("KYC_UNDERLYING::");
   }
+  /**
+   * Returns true if the token is a DSToken, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
+  isDSToken(t) {
+    if (!this.#tokenDataLoaded.has(t.addr)) {
+      throw new Error(
+        `extended token data not loaded for ${t.symbol} (${t.addr})`
+      );
+    }
+    return !!t.isDSToken;
+  }
   /**
    * Returns a map of all phantom tokens
-   * Throws if the phantom token data is not loaded
+   * Throws if token data is not loaded
    */
   get phantomTokens() {
     const result = new import_utils.AddressMap();
@@ -72,6 +98,10 @@ class TokensMeta extends import_utils.AddressMap {
     }
     return result;
   }
+  /**
+   * Returns a map of all KYC underlying tokens
+   * Throws if token data is not loaded
+   */
   get kycUnderlyings() {
     const result = new import_utils.AddressMap();
     for (const [token, meta] of this.entries()) {
@@ -81,6 +111,15 @@ class TokensMeta extends import_utils.AddressMap {
     }
     return result;
   }
+  get dsTokens() {
+    const result = new import_utils.AddressMap();
+    for (const [token, meta] of this.entries()) {
+      if (this.isDSToken(meta)) {
+        result.upsert(token, meta);
+      }
+    }
+    return result;
+  }
   formatBN(arg0, arg1, arg2) {
     const token = typeof arg0 === "object" ? arg0.token : arg0;
     const amount = typeof arg0 === "object" ? arg0.balance : arg1;
@@ -100,7 +139,7 @@ class TokensMeta extends import_utils.AddressMap {
     return meta;
   }
   /**
-   * Loads token information about phantom token and KYC underlying tokens
+   * Loads token information about phantom tokens, KYC underlying tokens and DSTokens
    *
    * @param tokens - tokens to load data for, defaults to all tokens
    */
@@ -128,15 +167,26 @@ class TokensMeta extends import_utils.AddressMap {
       allowFailure: true,
       batchSize: 0
     });
+    this.#logger?.debug(`loaded ${resp.length} contract types`);
+    const kycFactories = new import_utils.AddressSet();
     for (let i = 0; i < tokensToLoad.length; i++) {
-      this.#overrideTokenMeta(tokensToLoad[i], resp[2 * i], resp[2 * i + 1]);
+      const meta = this.#overrideTokenMeta(
+        tokensToLoad[i],
+        resp[2 * i],
+        resp[2 * i + 1]
+      );
       this.#tokenDataLoaded.add(tokensToLoad[i]);
+      if (this.isKYCUnderlying(meta)) {
+        kycFactories.add(meta.kycFactory);
+      }
     }
+    this.#logger?.debug(`found ${kycFactories.size} KYC factories`);
+    await this.#loadDSTokens(kycFactories);
   }
   #overrideTokenMeta(token, contractTypeResp, serializeResp) {
     const meta = this.mustGet(token);
     if (contractTypeResp.status === "success") {
-      const contractType = (0, import__.bytes32ToString)(contractTypeResp.result);
+      const contractType = (0, import_utils.bytes32ToString)(contractTypeResp.result);
       if (contractType.startsWith("KYC_UNDERLYING::")) {
         if (serializeResp.status === "success") {
           this.#overrideKYCUnderlying(meta, contractType, serializeResp.result);
@@ -151,10 +201,12 @@ class TokensMeta extends import_utils.AddressMap {
           contractType
         });
       }
+      this.#logger?.debug(`token ${meta.symbol} is ${contractType}`);
     }
+    return this.mustGet(token);
   }
   #overrideKYCUnderlying(meta, contractType, serialized) {
-    if (contractType === import__.KYC_UNDERLYING_DEFAULT) {
+    if (contractType === import_token_types.KYC_UNDERLYING_DEFAULT) {
       const decoded = (0, import_viem.decodeAbiParameters)(
         [
           { type: "address", name: "kycFactory" },
@@ -168,7 +220,7 @@ class TokensMeta extends import_utils.AddressMap {
         kycFactory: decoded[0],
         asset: decoded[1]
       });
-    } else if (contractType === import__.KYC_UNDERLYING_ON_DEMAND) {
+    } else if (contractType === import_token_types.KYC_UNDERLYING_ON_DEMAND) {
       const decoded = (0, import_viem.decodeAbiParameters)(
         [
           { type: "address", name: "kycFactory" },
@@ -188,6 +240,72 @@ class TokensMeta extends import_utils.AddressMap {
       });
     }
   }
+  async #loadDSTokens(kycFactories) {
+    const resp = await this.#client.multicall({
+      contracts: kycFactories.map((address) => ({
+        address,
+        abi: import_iSecuritizeKYCFactory.iSecuritizeKYCFactoryAbi,
+        functionName: "getDSTokens"
+      })),
+      allowFailure: false,
+      batchSize: 0
+    });
+    const dsToken = new import_utils.AddressSet(resp.flat());
+    const tokensToLoad = dsToken.difference(new Set(this.keys()));
+    this.#logger?.debug(
+      `found ${dsToken.size} DSTokens in KYC factories, need to load ${tokensToLoad.size} basic metadata`
+    );
+    await this.#loadWithoutCompressor(tokensToLoad);
+    for (const token of dsToken) {
+      const meta = this.mustGet(token);
+      this.upsert(token, {
+        ...meta,
+        isDSToken: true
+      });
+      this.#tokenDataLoaded.add(token);
+      this.#logger?.debug(`token ${meta.symbol} (${token}) is a DSToken`);
+    }
+  }
+  async #loadWithoutCompressor(tokens_) {
+    if (tokens_.size === 0) {
+      return;
+    }
+    const tokens = Array.from(tokens_);
+    const resp = await this.#client.multicall({
+      contracts: tokens.flatMap(
+        (t) => [
+          {
+            address: t,
+            abi: import_viem.erc20Abi,
+            functionName: "symbol"
+          },
+          {
+            address: t,
+            abi: import_viem.erc20Abi,
+            functionName: "name"
+          },
+          {
+            address: t,
+            abi: import_viem.erc20Abi,
+            functionName: "decimals"
+          }
+        ]
+      ),
+      allowFailure: false,
+      batchSize: 0
+    });
+    this.#logger?.debug(
+      `loaded ${resp.length} basic metadata without compressor`
+    );
+    for (let i = 0; i < tokens.length; i++) {
+      this.upsert(tokens[i], {
+        addr: tokens[i],
+        symbol: resp[3 * i],
+        name: resp[3 * i + 1],
+        decimals: resp[3 * i + 2]
+      });
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -32,6 +32,19 @@ class SecuritizeKYCFactory extends import_base.BaseContract {
       abi
     });
   }
+  async precomputeWalletAddress(creditManager, investor) {
+    return this.contract.read.precomputeWalletAddress([
+      creditManager,
+      investor
+    ]);
+  }
+  async getWallet(creditAccount) {
+    return this.contract.read.getWallet([creditAccount]);
+  }
+  async getDSTokens() {
+    const tokens = await this.contract.read.getDSTokens();
+    return [...tokens];
+  }
   multicall(creditAccount, calls, tokensToRegister) {
     return this.createRawTx({
       functionName: "multicall",

package/dist/esm/abi/310/iSecuritizeKYCFactory.js

@@ -27,6 +27,13 @@ const iSecuritizeKYCFactoryAbi = [
     outputs: [{ name: "", type: "address[]", internalType: "address[]" }],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "getDSTokens",
+    inputs: [],
+    outputs: [{ name: "", type: "address[]", internalType: "address[]" }],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "getInvestor",

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

@@ -779,43 +779,52 @@ class AbstractCreditAccountService extends SDKConstruct {
     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);
+    await this.sdk.tokensMeta.loadTokenData(suite.underlying);
+    const underlying = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      const factory = new SecuritizeKYCFactory(this.sdk, underlying.kycFactory);
+      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,
-    withdrawToken,
-    referralCode,
-    to,
-    calls: openPathCalls,
-    minQuota,
-    averageQuota
-  }) {
+   **/
+  async openCA(props) {
+    const {
+      ethAmount,
+      creditManager,
+      reopenCreditAccount,
+      collateral,
+      permits,
+      debt,
+      withdrawToken,
+      referralCode,
+      to,
+      calls: openPathCalls,
+      minQuota,
+      averageQuota
+    } = props;
     const cmSuite = this.sdk.marketRegister.findCreditManager(creditManager);
     const cm = cmSuite.creditManager;
     let tokenToWithdraw;
@@ -847,7 +856,12 @@ class AbstractCreditAccountService extends SDKConstruct {
         averageQuota
       })
     ];
-    const tx = await this.openCreditAccountTx(cmSuite, 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 };
   }
@@ -1200,8 +1214,8 @@ class AbstractCreditAccountService extends SDKConstruct {
     await this.sdk.tokensMeta.loadTokenData(suite.underlying);
     const underlying = this.sdk.tokensMeta.mustGet(suite.underlying);
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      const tokensToRegister = [];
       const factory = new SecuritizeKYCFactory(this.sdk, underlying.kycFactory);
+      const tokensToRegister = await factory.getDSTokens();
       return factory.openCreditAccount(
         suite.creditManager.address,
         calls,

package/dist/esm/sdk/base/ChainContractsRegister.js

@@ -25,7 +25,7 @@ class ChainContractsRegister {
   logger;
   constructor(client, logger) {
     this.client = client;
-    this.tokensMeta = new TokensMeta(client);
+    this.tokensMeta = new TokensMeta(client, logger);
     this.logger = logger;
   }
   resetContracts() {

package/dist/esm/sdk/base/TokensMeta.js

@@ -1,20 +1,28 @@
 import {
-  decodeAbiParameters
+  decodeAbiParameters,
+  erc20Abi
 } from "viem";
+import { iSecuritizeKYCFactoryAbi } from "../../abi/310/iSecuritizeKYCFactory.js";
 import { iStateSerializerAbi } from "../../abi/iStateSerializer.js";
 import { iVersionAbi } from "../../abi/iVersion.js";
 import {
+  AddressMap,
+  AddressSet,
   bytes32ToString,
+  formatBN
+} from "../utils/index.js";
+import {
   KYC_UNDERLYING_DEFAULT,
   KYC_UNDERLYING_ON_DEMAND
-} from "../index.js";
-import { AddressMap, AddressSet, formatBN } from "../utils/index.js";
+} from "./token-types.js";
 class TokensMeta extends AddressMap {
   #client;
   #tokenDataLoaded = new AddressSet();
-  constructor(client) {
+  #logger;
+  constructor(client, logger) {
     super(void 0, "tokensMeta");
     this.#client = client;
+    this.#logger = logger?.child?.({ name: "TokensMeta" }) ?? logger;
   }
   reset() {
     this.clear();
@@ -26,6 +34,11 @@ class TokensMeta extends AddressMap {
   decimals(token) {
     return this.mustGet(token).decimals;
   }
+  /**
+   * Returns true if the token is a phantom token, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
   isPhantomToken(t) {
     if (!this.#tokenDataLoaded.has(t.addr)) {
       throw new Error(
@@ -34,6 +47,11 @@ class TokensMeta extends AddressMap {
     }
     return "contractType" in t && t.contractType.startsWith("PHANTOM_TOKEN::");
   }
+  /**
+   * Returns true if the token is a KYC underlying token, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
   isKYCUnderlying(t) {
     if (!this.#tokenDataLoaded.has(t.addr)) {
       throw new Error(
@@ -42,9 +60,22 @@ class TokensMeta extends AddressMap {
     }
     return "contractType" in t && t.contractType.startsWith("KYC_UNDERLYING::");
   }
+  /**
+   * Returns true if the token is a DSToken, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
+  isDSToken(t) {
+    if (!this.#tokenDataLoaded.has(t.addr)) {
+      throw new Error(
+        `extended token data not loaded for ${t.symbol} (${t.addr})`
+      );
+    }
+    return !!t.isDSToken;
+  }
   /**
    * Returns a map of all phantom tokens
-   * Throws if the phantom token data is not loaded
+   * Throws if token data is not loaded
    */
   get phantomTokens() {
     const result = new AddressMap();
@@ -55,6 +86,10 @@ class TokensMeta extends AddressMap {
     }
     return result;
   }
+  /**
+   * Returns a map of all KYC underlying tokens
+   * Throws if token data is not loaded
+   */
   get kycUnderlyings() {
     const result = new AddressMap();
     for (const [token, meta] of this.entries()) {
@@ -64,6 +99,15 @@ class TokensMeta extends AddressMap {
     }
     return result;
   }
+  get dsTokens() {
+    const result = new AddressMap();
+    for (const [token, meta] of this.entries()) {
+      if (this.isDSToken(meta)) {
+        result.upsert(token, meta);
+      }
+    }
+    return result;
+  }
   formatBN(arg0, arg1, arg2) {
     const token = typeof arg0 === "object" ? arg0.token : arg0;
     const amount = typeof arg0 === "object" ? arg0.balance : arg1;
@@ -83,7 +127,7 @@ class TokensMeta extends AddressMap {
     return meta;
   }
   /**
-   * Loads token information about phantom token and KYC underlying tokens
+   * Loads token information about phantom tokens, KYC underlying tokens and DSTokens
    *
    * @param tokens - tokens to load data for, defaults to all tokens
    */
@@ -111,10 +155,21 @@ class TokensMeta extends AddressMap {
       allowFailure: true,
       batchSize: 0
     });
+    this.#logger?.debug(`loaded ${resp.length} contract types`);
+    const kycFactories = new AddressSet();
     for (let i = 0; i < tokensToLoad.length; i++) {
-      this.#overrideTokenMeta(tokensToLoad[i], resp[2 * i], resp[2 * i + 1]);
+      const meta = this.#overrideTokenMeta(
+        tokensToLoad[i],
+        resp[2 * i],
+        resp[2 * i + 1]
+      );
       this.#tokenDataLoaded.add(tokensToLoad[i]);
+      if (this.isKYCUnderlying(meta)) {
+        kycFactories.add(meta.kycFactory);
+      }
     }
+    this.#logger?.debug(`found ${kycFactories.size} KYC factories`);
+    await this.#loadDSTokens(kycFactories);
   }
   #overrideTokenMeta(token, contractTypeResp, serializeResp) {
     const meta = this.mustGet(token);
@@ -134,7 +189,9 @@ class TokensMeta extends AddressMap {
           contractType
         });
       }
+      this.#logger?.debug(`token ${meta.symbol} is ${contractType}`);
     }
+    return this.mustGet(token);
   }
   #overrideKYCUnderlying(meta, contractType, serialized) {
     if (contractType === KYC_UNDERLYING_DEFAULT) {
@@ -171,6 +228,72 @@ class TokensMeta extends AddressMap {
       });
     }
   }
+  async #loadDSTokens(kycFactories) {
+    const resp = await this.#client.multicall({
+      contracts: kycFactories.map((address) => ({
+        address,
+        abi: iSecuritizeKYCFactoryAbi,
+        functionName: "getDSTokens"
+      })),
+      allowFailure: false,
+      batchSize: 0
+    });
+    const dsToken = new AddressSet(resp.flat());
+    const tokensToLoad = dsToken.difference(new Set(this.keys()));
+    this.#logger?.debug(
+      `found ${dsToken.size} DSTokens in KYC factories, need to load ${tokensToLoad.size} basic metadata`
+    );
+    await this.#loadWithoutCompressor(tokensToLoad);
+    for (const token of dsToken) {
+      const meta = this.mustGet(token);
+      this.upsert(token, {
+        ...meta,
+        isDSToken: true
+      });
+      this.#tokenDataLoaded.add(token);
+      this.#logger?.debug(`token ${meta.symbol} (${token}) is a DSToken`);
+    }
+  }
+  async #loadWithoutCompressor(tokens_) {
+    if (tokens_.size === 0) {
+      return;
+    }
+    const tokens = Array.from(tokens_);
+    const resp = await this.#client.multicall({
+      contracts: tokens.flatMap(
+        (t) => [
+          {
+            address: t,
+            abi: erc20Abi,
+            functionName: "symbol"
+          },
+          {
+            address: t,
+            abi: erc20Abi,
+            functionName: "name"
+          },
+          {
+            address: t,
+            abi: erc20Abi,
+            functionName: "decimals"
+          }
+        ]
+      ),
+      allowFailure: false,
+      batchSize: 0
+    });
+    this.#logger?.debug(
+      `loaded ${resp.length} basic metadata without compressor`
+    );
+    for (let i = 0; i < tokens.length; i++) {
+      this.upsert(tokens[i], {
+        addr: tokens[i],
+        symbol: resp[3 * i],
+        name: resp[3 * i + 1],
+        decimals: resp[3 * i + 2]
+      });
+    }
+  }
 }
 export {
   TokensMeta

package/dist/esm/sdk/market/kyc/SecuritizeKYCFactory.js

@@ -9,6 +9,19 @@ class SecuritizeKYCFactory extends BaseContract {
       abi
     });
   }
+  async precomputeWalletAddress(creditManager, investor) {
+    return this.contract.read.precomputeWalletAddress([
+      creditManager,
+      investor
+    ]);
+  }
+  async getWallet(creditAccount) {
+    return this.contract.read.getWallet([creditAccount]);
+  }
+  async getDSTokens() {
+    const tokens = await this.contract.read.getDSTokens();
+    return [...tokens];
+  }
   multicall(creditAccount, calls, tokensToRegister) {
     return this.createRawTx({
       functionName: "multicall",

package/dist/types/abi/310/iSecuritizeKYCFactory.d.ts

@@ -42,6 +42,16 @@ export declare const iSecuritizeKYCFactoryAbi: readonly [{
         readonly internalType: "address[]";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getDSTokens";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "getInvestor";

package/dist/types/sdk/accounts/AbstractCreditAccountsService.d.ts

@@ -5,7 +5,7 @@ import type { GearboxSDK } from "../GearboxSDK.js";
 import { type CreditSuite, type OnDemandPriceUpdates, type PriceUpdateV300, type PriceUpdateV310, type UpdatePriceFeedsResult } from "../market/index.js";
 import { type Asset, type RouterCASlice } from "../router/index.js";
 import type { MultiCall, RawTx } from "../types/index.js";
-import type { AccountToCheck, AddCollateralProps, ChangeDeptProps, ClaimDelayedProps, CloseCreditAccountProps, CloseCreditAccountResult, CloseOptions, CreditAccountOperationResult, EnableTokensProps, ExecuteSwapProps, FullyLiquidateProps, FullyLiquidateResult, GetConnectedBotsResult, GetConnectedMigrationBotsResult, GetCreditAccountsOptions, GetPendingWithdrawalsProps, GetPendingWithdrawalsResult, OpenCAProps, PermitResult, PrepareUpdateQuotasProps, PreviewDelayedWithdrawalProps, PreviewDelayedWithdrawalResult, PriceUpdatesOptions, Rewards, StartDelayedWithdrawalProps, UpdateQuotasProps } from "./types.js";
+import type { AccountToCheck, AddCollateralProps, ChangeDeptProps, ClaimDelayedProps, CloseCreditAccountProps, CloseCreditAccountResult, CloseOptions, CreditAccountOperationResult, EnableTokensProps, ExecuteSwapProps, FullyLiquidateProps, FullyLiquidateResult, GetApprovalAddressProps, GetConnectedBotsResult, GetConnectedMigrationBotsResult, GetCreditAccountsOptions, GetPendingWithdrawalsProps, GetPendingWithdrawalsResult, OpenCAProps, PermitResult, PrepareUpdateQuotasProps, PreviewDelayedWithdrawalProps, PreviewDelayedWithdrawalResult, PriceUpdatesOptions, Rewards, StartDelayedWithdrawalProps, UpdateQuotasProps } from "./types.js";
 export interface CreditAccountServiceOptions {
     batchSize?: number;
 }
@@ -149,31 +149,25 @@ export declare abstract class AbstractCreditAccountService extends SDKConstruct
      * @returns All necessary data to execute the transaction (call, credit facade)
      */
     enableTokens({ enabledTokens, disabledTokens, creditAccount: ca, }: EnableTokensProps): Promise<CreditAccountOperationResult>;
+    /**
+     * 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
+     **/
+    getApprovalAddress(options: GetApprovalAddressProps): Promise<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)
-     */
-    openCA({ ethAmount, creditManager, collateral, permits, debt, withdrawToken, referralCode, to, calls: openPathCalls, minQuota, averageQuota, }: OpenCAProps): Promise<CreditAccountOperationResult>;
+     **/
+    openCA(props: OpenCAProps): Promise<CreditAccountOperationResult>;
     /**
      * Returns borrow rate with 4 digits precision (10000 = 100%)
      * @param ca

package/dist/types/sdk/accounts/types.d.ts

@@ -291,6 +291,10 @@ export interface OpenCAProps extends PrepareUpdateQuotasProps {
      * Address of credit manager to open credit account on
      */
     creditManager: Address;
+    /**
+     * Optional address of credit account to reopen
+     */
+    reopenCreditAccount?: Address;
     /**
      * Wallet address to transfer credit account to
      */
@@ -435,6 +439,16 @@ export interface LlamathenaProportionalWithdrawProps extends PrepareUpdateQuotas
      */
     creditAccount: RouterCASlice;
 }
+/**
+ * Options to get approval address for collateral token
+ */
+export type GetApprovalAddressProps = {
+    creditManager: Address;
+    borrower: Address;
+} | {
+    creditManager: Address;
+    creditAccount: Address;
+};
 export interface ICreditAccountsService extends Construct {
     sdk: GearboxSDK;
     /**
@@ -553,6 +567,13 @@ export interface ICreditAccountsService extends Construct {
      * @returns All necessary data to execute the transaction (call, credit facade)
      */
     enableTokens(props: EnableTokensProps): Promise<CreditAccountOperationResult>;
+    /**
+     * 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 props - {@link GetApprovalAddressProps}
+     * @returns
+     */
+    getApprovalAddress(props: GetApprovalAddressProps): Promise<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 ->

package/dist/types/sdk/base/TokensMeta.d.ts

@@ -1,31 +1,53 @@
 import { type Address, type Chain, type PublicClient, type Transport } from "viem";
 import type { Asset } from "../router/index.js";
+import type { ILogger } from "../types/logger.js";
 import { AddressMap } from "../utils/index.js";
-import type { KYCTokenMeta, PhantomTokenMeta, TokenMetaData } from "./token-types.js";
+import { type DSTokenMeta, type KYCTokenMeta, type PhantomTokenMeta, type TokenMetaData } from "./token-types.js";
 export interface FormatBNOptions {
     precision?: number;
     symbol?: boolean;
 }
 export declare class TokensMeta extends AddressMap<TokenMetaData> {
     #private;
-    constructor(client: PublicClient<Transport, Chain>);
+    constructor(client: PublicClient<Transport, Chain>, logger?: ILogger);
     reset(): void;
     symbol(token: Address): string;
     decimals(token: Address): number;
+    /**
+     * Returns true if the token is a phantom token, throws if the token data is not loaded
+     * @param t
+     * @returns
+     */
     isPhantomToken(t: TokenMetaData): t is PhantomTokenMeta;
+    /**
+     * Returns true if the token is a KYC underlying token, throws if the token data is not loaded
+     * @param t
+     * @returns
+     */
     isKYCUnderlying(t: TokenMetaData): t is KYCTokenMeta;
+    /**
+     * Returns true if the token is a DSToken, throws if the token data is not loaded
+     * @param t
+     * @returns
+     */
+    isDSToken(t: TokenMetaData): t is DSTokenMeta;
     /**
      * Returns a map of all phantom tokens
-     * Throws if the phantom token data is not loaded
+     * Throws if token data is not loaded
      */
     get phantomTokens(): AddressMap<PhantomTokenMeta>;
+    /**
+     * Returns a map of all KYC underlying tokens
+     * Throws if token data is not loaded
+     */
     get kycUnderlyings(): AddressMap<KYCTokenMeta>;
+    get dsTokens(): AddressMap<DSTokenMeta>;
     formatBN(asset: Asset, options?: FormatBNOptions): string;
     formatBN(token: Address, amount: number | bigint | string | undefined, options?: FormatBNOptions): string;
     findBySymbol(symbol: string): TokenMetaData | undefined;
     mustFindBySymbol(symbol: string): TokenMetaData;
     /**
-     * Loads token information about phantom token and KYC underlying tokens
+     * Loads token information about phantom tokens, KYC underlying tokens and DSTokens
      *
      * @param tokens - tokens to load data for, defaults to all tokens
      */

package/dist/types/sdk/base/token-types.d.ts

@@ -1,11 +1,14 @@
 import type { Address } from "viem";
 import type { MarketData, Unarray } from "./types.js";
-export type SimpleTokenMeta = Unarray<MarketData["tokens"]>;
+type TokenData = Unarray<MarketData["tokens"]>;
 export declare const PHANTOM_TOKEN_CONTRACT_TYPES: readonly ["PHANTOM_TOKEN::CONVEX", "PHANTOM_TOKEN::INFINIFI_UNWIND", "PHANTOM_TOKEN::INFRARED", "PHANTOM_TOKEN::MELLOW_WITHDRAWAL", "PHANTOM_TOKEN::MIDAS_REDEMPTION", "PHANTOM_TOKEN::STAKING_REWARDS", "PHANTOM_TOKEN::UPSHIFT_WITHDRAW"];
 export declare const KYC_UNDERLYING_DEFAULT = "KYC_UNDERLYING::DEFAULT";
 export declare const KYC_UNDERLYING_ON_DEMAND = "KYC_UNDERLYING::ON_DEMAND";
 export type KYCUnderlyingContractType = typeof KYC_UNDERLYING_DEFAULT | typeof KYC_UNDERLYING_ON_DEMAND;
 export type PhantomTokenContractType = (typeof PHANTOM_TOKEN_CONTRACT_TYPES)[number];
+export type SimpleTokenMeta = TokenData & {
+    isDSToken?: boolean;
+};
 export type PhantomTokenMeta = SimpleTokenMeta & {
     contractType: PhantomTokenContractType;
 };
@@ -21,5 +24,9 @@ export type KYCOnDemandTokenMeta = SimpleTokenMeta & {
     pool: Address;
     liquidityProvider: Address;
 };
+export type DSTokenMeta = Omit<SimpleTokenMeta, "isDSToken"> & {
+    isDSToken: true;
+};
 export type KYCTokenMeta = KYCDefaultTokenMeta | KYCOnDemandTokenMeta;
-export type TokenMetaData = SimpleTokenMeta | PhantomTokenMeta | KYCTokenMeta;
+export type TokenMetaData = SimpleTokenMeta | PhantomTokenMeta | KYCTokenMeta | DSTokenMeta;
+export {};

package/dist/types/sdk/market/kyc/SecuritizeKYCFactory.d.ts

@@ -46,6 +46,16 @@ declare const abi: readonly [{
         readonly internalType: "address[]";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getDSTokens";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "getInvestor";
@@ -426,6 +436,9 @@ declare const abi: readonly [{
 type abi = typeof abi;
 export declare class SecuritizeKYCFactory extends BaseContract<abi> {
     constructor(options: ConstructOptions, address: Address);
+    precomputeWalletAddress(creditManager: Address, investor: Address): Promise<Address>;
+    getWallet(creditAccount: Address): Promise<Address>;
+    getDSTokens(): Promise<Address[]>;
     multicall(creditAccount: Address, calls: MultiCall[], tokensToRegister: Address[]): RawTx;
     openCreditAccount(creditManager: Address, calls: MultiCall[], tokensToRegister: Address[]): RawTx;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "13.0.0-next.16",
+  "version": "13.0.0-next.18",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.js",