@gearbox-protocol/sdk 13.0.0-next.2 → 13.0.0-next.20

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

@@ -22,20 +22,34 @@ __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 = false;
-  constructor(client) {
+  #tokenDataLoaded = new import_utils.AddressSet();
+  #logger;
+  constructor(client, logger) {
     super(void 0, "tokensMeta");
     this.#client = client;
+    this.#logger = logger?.child?.({ name: "TokensMeta" }) ?? logger;
   }
   reset() {
     this.clear();
-    this.#tokenDataLoaded = false;
+    this.#tokenDataLoaded.clear();
+  }
+  upsert(address, value) {
+    let v = value;
+    const existing = this.get(address);
+    if (existing && v) {
+      v = {
+        ...existing,
+        ...v
+      };
+    }
+    super.upsert(address, v);
   }
   symbol(token) {
     return this.mustGet(token).symbol;
@@ -43,21 +57,48 @@ 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) {
-      throw new Error("extended token data not loaded");
+    if (!this.#tokenDataLoaded.has(t.addr)) {
+      throw new Error(
+        `extended token data not loaded for ${t.symbol} (${t.addr})`
+      );
     }
     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) {
-      throw new Error("extended token data not loaded");
+    if (!this.#tokenDataLoaded.has(t.addr)) {
+      throw new Error(
+        `extended token data not loaded for ${t.symbol} (${t.addr})`
+      );
     }
     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();
@@ -68,6 +109,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()) {
@@ -77,6 +122,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;
@@ -96,12 +150,18 @@ 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
    */
-  async loadTokenData() {
-    const tokens = this.keys();
+  async loadTokenData(...tokens) {
+    const tokenz = new import_utils.AddressSet(tokens.length > 0 ? tokens : this.keys());
+    const tokensToLoad = Array.from(tokenz.difference(this.#tokenDataLoaded));
+    if (tokensToLoad.length === 0) {
+      return;
+    }
     const resp = await this.#client.multicall({
-      contracts: tokens.flatMap(
+      contracts: tokensToLoad.flatMap(
         (t) => [
           {
             address: t,
@@ -118,15 +178,26 @@ class TokensMeta extends import_utils.AddressMap {
       allowFailure: true,
       batchSize: 0
     });
-    for (let i = 0; i < tokens.length; i++) {
-      this.#overrideTokenMeta(tokens[i], resp[i], resp[i + 1]);
+    this.#logger?.debug(`loaded ${resp.length} contract types`);
+    const kycFactories = new import_utils.AddressSet();
+    for (let i = 0; i < tokensToLoad.length; i++) {
+      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.#tokenDataLoaded = true;
+    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);
@@ -141,10 +212,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" },
@@ -158,7 +231,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" },
@@ -178,6 +251,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/MarketRegister.js

@@ -22,13 +22,13 @@ __export(MarketRegister_exports, {
 });
 module.exports = __toCommonJS(MarketRegister_exports);
 var import_marketCompressor = require("../../abi/compressors/marketCompressor.js");
-var import_base = require("../base/index.js");
 var import_constants = require("../constants/index.js");
 var import_utils = require("../utils/index.js");
 var import_viem = require("../utils/viem/index.js");
 var import_MarketConfiguratorContract = require("./MarketConfiguratorContract.js");
 var import_MarketSuite = require("./MarketSuite.js");
-class MarketRegister extends import_base.SDKConstruct {
+var import_ZapperRegister = require("./ZapperRegister.js");
+class MarketRegister extends import_ZapperRegister.ZapperRegister {
   /**
    * Mapping pool.address -> MarketSuite
    */

package/dist/cjs/sdk/{pools/extraZappers.js → market/ZapperRegister.js}

@@ -16,12 +16,115 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var extraZappers_exports = {};
-__export(extraZappers_exports, {
-  extraZappers: () => extraZappers
+var ZapperRegister_exports = {};
+__export(ZapperRegister_exports, {
+  ZapperRegister: () => ZapperRegister
 });
-module.exports = __toCommonJS(extraZappers_exports);
-const extraZappers = {
+module.exports = __toCommonJS(ZapperRegister_exports);
+var import_peripheryCompressor = require("../../abi/compressors/peripheryCompressor.js");
+var import_base = require("../base/index.js");
+var import_constants = require("../constants/index.js");
+var import_utils = require("../utils/index.js");
+class ZapperRegister extends import_base.SDKConstruct {
+  /**
+   * Mapping pool.address -> ZapperData[]
+   * Needs to be loaded explicitly using loadZappers method
+   */
+  #zappers;
+  /**
+   * Load zappers for all pools using periphery compressor, adds hardcoded zappers
+   */
+  async loadZappers(force) {
+    if (!force && this.#zappers) {
+      return;
+    }
+    const [pcAddr] = this.sdk.addressProvider.mustGetLatest(
+      import_constants.AP_PERIPHERY_COMPRESSOR,
+      import_constants.VERSION_RANGE_310
+    );
+    this.logger?.debug(`loading zappers with periphery compressor ${pcAddr}`);
+    const markets = this.sdk.marketRegister.markets;
+    const resp = await this.client.multicall({
+      contracts: markets.map(
+        (m) => ({
+          abi: import_peripheryCompressor.peripheryCompressorAbi,
+          address: pcAddr,
+          functionName: "getZappers",
+          args: [m.configurator.address, m.pool.pool.address]
+        })
+      ),
+      allowFailure: true,
+      batchSize: 0
+    });
+    this.#zappers = new import_utils.AddressMap(void 0, "zappers");
+    for (let i = 0; i < resp.length; i++) {
+      const { status, result, error } = resp[i];
+      const marketConfigurator = markets[i].configurator.address;
+      const pool = markets[i].pool.pool.address;
+      if (status === "success") {
+        for (const z of result) {
+          this.#addZapper({ ...z, pool, type: "base" });
+        }
+      } else {
+        this.logger?.error(
+          `failed to load zapper for market configurator ${this.labelAddress(
+            marketConfigurator
+          )} and pool ${this.labelAddress(pool)}: ${error}`
+        );
+      }
+    }
+    for (const z of KYC_ZAPPERS[this.networkType] ?? []) {
+      this.#addZapper({ ...z, type: "kyc" });
+    }
+    for (const z of MIGRATION_ZAPPERS[this.networkType] ?? []) {
+      this.#addZapper({ ...z, type: "migration" });
+    }
+  }
+  #addZapper(z) {
+    if (BROKEN_ZAPPERS.has(z.baseParams.addr)) {
+      return;
+    }
+    const existing = this.zappers.get(z.pool);
+    if (existing) {
+      const hasZapper = existing.some(
+        (zz) => (0, import_utils.hexEq)(zz.baseParams.addr, z.baseParams.addr)
+      );
+      if (!hasZapper) {
+        existing.push(z);
+      }
+    } else {
+      this.zappers.upsert(z.pool, [z]);
+    }
+    const zappersTokens = [z.tokenIn, z.tokenOut];
+    for (const t of zappersTokens) {
+      this.sdk.tokensMeta.upsert(t.addr, t);
+      this.sdk.setAddressLabel(t.addr, t.symbol);
+    }
+  }
+  get zappers() {
+    if (!this.#zappers) {
+      throw new Error("zappers not loaded, call loadZappers first");
+    }
+    return this.#zappers;
+  }
+  poolZappers(pool) {
+    return this.zappers.get(pool) ?? [];
+  }
+  /**
+   * Can return multiple zappers if there are multiple zappers for the same tokenIn and tokenOut
+   */
+  getZapper(pool, tokenIn, tokenOut) {
+    const zappers = this.zappers.get(pool)?.filter(
+      (z) => (0, import_utils.hexEq)(z.tokenIn.addr, tokenIn) && (0, import_utils.hexEq)(z.tokenOut.addr, tokenOut)
+    );
+    return zappers;
+  }
+}
+const BROKEN_ZAPPERS = new import_utils.AddressMap(
+  [["0x90D66b03EC4D462e42e3c7741049FB46a4a03B69", true]],
+  "brokenZappers"
+);
+const MIGRATION_ZAPPERS = {
   Mainnet: [
     {
       baseParams: {
@@ -130,7 +233,8 @@ const extraZappers = {
     }
   ]
 };
+const KYC_ZAPPERS = {};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  extraZappers
+  ZapperRegister
 });

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

@@ -17,18 +17,22 @@ var market_exports = {};
 module.exports = __toCommonJS(market_exports);
 __reExport(market_exports, require("./adapters/index.js"), module.exports);
 __reExport(market_exports, require("./credit/index.js"), module.exports);
+__reExport(market_exports, require("./kyc/index.js"), module.exports);
 __reExport(market_exports, require("./MarketRegister.js"), module.exports);
 __reExport(market_exports, require("./MarketSuite.js"), module.exports);
 __reExport(market_exports, require("./oracle/index.js"), module.exports);
 __reExport(market_exports, require("./pool/index.js"), module.exports);
 __reExport(market_exports, require("./pricefeeds/index.js"), module.exports);
+__reExport(market_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./adapters/index.js"),
   ...require("./credit/index.js"),
+  ...require("./kyc/index.js"),
   ...require("./MarketRegister.js"),
   ...require("./MarketSuite.js"),
   ...require("./oracle/index.js"),
   ...require("./pool/index.js"),
-  ...require("./pricefeeds/index.js")
+  ...require("./pricefeeds/index.js"),
+  ...require("./types.js")
 });

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

@@ -0,0 +1,64 @@
+"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_iSecuritizeKYCFactory = require("../../../abi/310/iSecuritizeKYCFactory.js");
+var import_base = require("../../base/index.js");
+const abi = import_iSecuritizeKYCFactory.iSecuritizeKYCFactoryAbi;
+class SecuritizeKYCFactory extends import_base.BaseContract {
+  constructor(options, address) {
+    super(options, {
+      addr: address,
+      name: "SecuritizeKYCFactory",
+      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",
+      args: [creditAccount, calls, tokensToRegister]
+    });
+  }
+  openCreditAccount(creditManager, calls, tokensToRegister) {
+    return this.createRawTx({
+      functionName: "openCreditAccount",
+      args: [creditManager, calls, tokensToRegister]
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SecuritizeKYCFactory
+});

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

@@ -0,0 +1,22 @@
+"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("./SecuritizeKYCFactory.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./SecuritizeKYCFactory.js")
+});

package/dist/cjs/sdk/market/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);