@gearbox-protocol/sdk 13.0.0-next.1 → 13.0.0-next.11

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

@@ -28,14 +28,14 @@ var import__ = require("../index.js");
 var import_utils = require("../utils/index.js");
 class TokensMeta extends import_utils.AddressMap {
   #client;
-  #tokenDataLoaded = false;
+  #tokenDataLoaded = new import_utils.AddressSet();
   constructor(client) {
     super(void 0, "tokensMeta");
     this.#client = client;
   }
   reset() {
     this.clear();
-    this.#tokenDataLoaded = false;
+    this.#tokenDataLoaded.clear();
   }
   symbol(token) {
     return this.mustGet(token).symbol;
@@ -44,14 +44,18 @@ class TokensMeta extends import_utils.AddressMap {
     return this.mustGet(token).decimals;
   }
   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::");
   }
   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::");
   }
@@ -97,11 +101,17 @@ class TokensMeta extends import_utils.AddressMap {
   }
   /**
    * Loads token information about phantom token and KYC underlying tokens
+   *
+   * @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,10 +128,10 @@ 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]);
+    for (let i = 0; i < tokensToLoad.length; i++) {
+      this.#overrideTokenMeta(tokensToLoad[i], resp[i], resp[i + 1]);
+      this.#tokenDataLoaded.add(tokensToLoad[i]);
     }
-    this.#tokenDataLoaded = true;
   }
   #overrideTokenMeta(token, contractTypeResp, serializeResp) {
     const meta = this.mustGet(token);

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

@@ -22,6 +22,7 @@ __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"),
@@ -30,5 +31,6 @@ __reExport(market_exports, require("./pricefeeds/index.js"), module.exports);
   ...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/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/pools/PoolService.js

@@ -21,7 +21,6 @@ __export(PoolService_exports, {
   PoolService: () => PoolService
 });
 module.exports = __toCommonJS(PoolService_exports);
-var import_peripheryCompressor = require("../../abi/compressors/peripheryCompressor.js");
 var import_iERC20 = require("../../abi/iERC20.js");
 var import_iERC20ZapperDeposits = require("../../abi/iERC20ZapperDeposits.js");
 var import_iETHZapperDeposits = require("../../abi/iETHZapperDeposits.js");
@@ -29,99 +28,65 @@ var import_iZapper = require("../../abi/iZapper.js");
 var import_v300 = require("../../abi/v300.js");
 var import_base = require("../base/index.js");
 var import__ = require("../index.js");
-var import_extraZappers = require("./extraZappers.js");
+var import_utils = require("../utils/index.js");
 const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+const POOL_TOKENS_TO_MIGRATE = new import_utils.AddressMap([
+  // v2 diesels
+  ["0x6CFaF95457d7688022FC53e7AbE052ef8DFBbdBA", "dDAI"],
+  ["0xc411dB5f5Eb3f7d552F9B8454B2D74097ccdE6E3", "dUSDC"],
+  ["0xe753260F1955e8678DCeA8887759e07aa57E8c54", "dWBTC"],
+  ["0xF21fc650C1B34eb0FDE786D52d23dA99Db3D6278", "dWETH"],
+  ["0x2158034dB06f06dcB9A786D2F1F8c38781bA779d", "dwstETH"],
+  ["0x8A1112AFef7F4FC7c066a77AABBc01b3Fff31D47", "dFRAX"]
+]);
 class PoolService extends import_base.SDKConstruct {
-  #zappers;
-  get zappers() {
-    if (!this.#zappers) {
-      throw new Error("zappers not loaded, call loadZappers first");
-    }
-    return this.#zappers;
-  }
-  async loadZappers(force) {
-    if (!force && this.#zappers) {
-      return;
-    }
-    const [pcAddr] = this.sdk.addressProvider.mustGetLatest(
-      import__.AP_PERIPHERY_COMPRESSOR,
-      import__.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__.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 });
-        }
-      } else {
-        this.sdk.logger?.error(
-          `failed to load zapper for market configurator ${this.labelAddress(
-            marketConfigurator
-          )} and pool ${this.labelAddress(pool)}: ${error}`
-        );
-      }
-    }
-    for (const z of import_extraZappers.extraZappers[this.networkType] ?? []) {
-      this.#addZapper(z);
-    }
-  }
   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);
+          return this.#depositTokensIn(pool, false);
         case import_base.KYC_UNDERLYING_ON_DEMAND:
           return [underlying.asset];
       }
     }
-    return this.depositTokensIn(pool, true);
+    return this.#depositTokensIn(pool, true);
   }
   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);
+          return this.#depositTokensOut(pool, tokenIn, false);
         case import_base.KYC_UNDERLYING_ON_DEMAND:
           return [];
       }
     }
-    return this.depositTokensOut(pool, tokenIn, true);
+    return this.#depositTokensOut(pool, tokenIn, true);
   }
   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(pool, tokenIn, tokenOut, false);
+          return this.#depositMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
         }
         case import_base.KYC_UNDERLYING_ON_DEMAND:
           return {
             zapper: void 0,
             approveTarget: underlying.liquidityProvider,
-            permissible: false
+            permissible: false,
+            type: "kyc-on-demand"
           };
       }
     }
-    return this.depositMetadata(pool, tokenIn, tokenOut, true);
+    return this.#depositMetadata("classic", pool, tokenIn, tokenOut, true);
   }
   addLiquidity(props) {
     const { collateral, meta, permit, referralCode, pool, wallet } = props;
@@ -132,7 +97,7 @@ class PoolService extends import_base.SDKConstruct {
       }
     }
     const { zapper } = meta;
-    if (zapper?.tokenIn.addr === NATIVE_ADDRESS) {
+    if (zapper?.tokenIn.addr?.toLowerCase() === NATIVE_ADDRESS.toLowerCase()) {
       return {
         target: zapper.baseParams.addr,
         abi: import_iETHZapperDeposits.iethZapperDepositsAbi,
@@ -209,13 +174,17 @@ class PoolService extends import_base.SDKConstruct {
       args: [amount, account, account]
     };
   }
-  depositTokensIn(poolAddr, allowDirectDeposit) {
+  #getDepositZappers(poolAddr) {
+    const zappers = this.sdk.marketRegister.poolZappers(poolAddr);
+    return zappers.filter((z) => z.type !== "migration");
+  }
+  #depositTokensIn(poolAddr, allowDirectDeposit) {
     const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
     const result = new import__.AddressSet();
     if (allowDirectDeposit) {
       result.add(pool.underlying);
     }
-    const zappers = this.zappers.get(poolAddr) ?? [];
+    const zappers = this.#getDepositZappers(poolAddr);
     for (const z of zappers) {
       if ((0, import__.hexEq)(z.tokenOut.addr, poolAddr)) {
         result.add(z.tokenIn.addr);
@@ -226,14 +195,18 @@ class PoolService extends import_base.SDKConstruct {
         `No tokensIn found for pool ${this.labelAddress(poolAddr)}`
       );
     }
-    return result.asArray();
+    const r = result.asArray().filter((t) => !POOL_TOKENS_TO_MIGRATE.has(t));
+    return r;
   }
-  depositTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
+  #depositTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
     const result = new import__.AddressSet();
     const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
-    const zappers = this.zappers.get(poolAddr) ?? [];
+    const zappers = this.#getDepositZappers(poolAddr);
     for (const z of zappers) {
       if ((0, import__.hexEq)(z.tokenIn.addr, tokenIn)) {
+        if (!(0, import__.hexEq)(z.tokenOut.addr, poolAddr)) {
+          console.log("found", "z.tokenOut.addr", z.tokenOut.addr);
+        }
         result.add(z.tokenOut.addr);
       }
     }
@@ -242,20 +215,40 @@ class PoolService extends import_base.SDKConstruct {
     }
     if (result.size === 0) {
       throw new Error(
-        `No tokensOut found for tokenIn ${this.labelAddress(tokenIn)} on pool ${this.labelAddress(poolAddr)}`
+        `No tokensOut found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} on pool ${this.labelAddress(poolAddr)}`
       );
     }
-    return result.asArray();
+    const r = result.asArray();
+    return r;
   }
-  depositMetadata(poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
+  #getDepositZapper(poolAddr, tokenIn, tokenOut) {
+    const zappers = this.sdk.marketRegister.getZapper(poolAddr, tokenIn, tokenOut)?.filter((z) => z.type !== "migration");
+    if (zappers && zappers.length > 1) {
+      throw new Error(
+        `Multiple zappers found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} and tokenOut ${this.labelAddress(
+          tokenOut
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return zappers?.[0];
+  }
+  #depositMetadata(type, poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
     if (!tokenOut) {
       throw new Error("tokenOut is required for classic pool deposit");
     }
     const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
-    const zapper = this.getZapper(poolAddr, tokenIn, tokenOut);
+    const zapper = this.#getDepositZapper(poolAddr, tokenIn, tokenOut);
     if (!zapper && !allowDirectDeposit) {
       throw new Error(
-        `No zapper found for tokenIn ${this.labelAddress(tokenIn)} and tokenOut ${this.labelAddress(tokenOut)} on pool ${this.labelAddress(poolAddr)}`
+        `No zapper found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} and tokenOut ${this.labelAddress(
+          tokenOut
+        )} on pool ${this.labelAddress(poolAddr)}`
       );
     }
     return {
@@ -264,41 +257,10 @@ class PoolService extends import_base.SDKConstruct {
       approveTarget: zapper?.baseParams.addr ?? pool.pool.address,
       // TODO: instead of permissible, return permitType зависимости от tokenIn
       // "none" | "eip2612" | "dai_like";
-      permissible: !!zapper && tokenIn !== NATIVE_ADDRESS
+      permissible: !!zapper && tokenIn !== NATIVE_ADDRESS,
+      type
     };
   }
-  getZapper(pool, tokenIn, tokenOut) {
-    return this.zappers.get(pool)?.find(
-      (z) => (0, import__.hexEq)(z.tokenIn.addr, tokenIn) && (0, import__.hexEq)(z.tokenOut.addr, tokenOut)
-    );
-  }
-  mustGetZapper(poolAddr, tokenIn, tokenOut) {
-    const result = this.getZapper(poolAddr, tokenIn, tokenOut);
-    if (!result) {
-      throw new Error(
-        `No zapper found for tokenIn ${this.labelAddress(tokenIn)} and tokenOut ${this.labelAddress(tokenOut)} on pool ${this.labelAddress(poolAddr)}`
-      );
-    }
-    return result;
-  }
-  #addZapper(z) {
-    const existing = this.zappers.get(z.pool);
-    if (existing) {
-      const hasZapper = existing.some(
-        (zz) => (0, import__.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);
-    }
-  }
   #describeUnderlying(pool) {
     const market = this.sdk.marketRegister.findByPool(pool);
     return this.sdk.tokensMeta.mustGet(market.underlying);

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

@@ -8,17 +8,17 @@ import {
   KYC_UNDERLYING_DEFAULT,
   KYC_UNDERLYING_ON_DEMAND
 } from "../index.js";
-import { AddressMap, formatBN } from "../utils/index.js";
+import { AddressMap, AddressSet, formatBN } from "../utils/index.js";
 class TokensMeta extends AddressMap {
   #client;
-  #tokenDataLoaded = false;
+  #tokenDataLoaded = new AddressSet();
   constructor(client) {
     super(void 0, "tokensMeta");
     this.#client = client;
   }
   reset() {
     this.clear();
-    this.#tokenDataLoaded = false;
+    this.#tokenDataLoaded.clear();
   }
   symbol(token) {
     return this.mustGet(token).symbol;
@@ -27,14 +27,18 @@ class TokensMeta extends AddressMap {
     return this.mustGet(token).decimals;
   }
   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::");
   }
   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::");
   }
@@ -80,11 +84,17 @@ class TokensMeta extends AddressMap {
   }
   /**
    * Loads token information about phantom token and KYC underlying tokens
+   *
+   * @param tokens - tokens to load data for, defaults to all tokens
    */
-  async loadTokenData() {
-    const tokens = this.keys();
+  async loadTokenData(...tokens) {
+    const tokenz = new 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,
@@ -101,10 +111,10 @@ class TokensMeta extends AddressMap {
       allowFailure: true,
       batchSize: 0
     });
-    for (let i = 0; i < tokens.length; i++) {
-      this.#overrideTokenMeta(tokens[i], resp[i], resp[i + 1]);
+    for (let i = 0; i < tokensToLoad.length; i++) {
+      this.#overrideTokenMeta(tokensToLoad[i], resp[i], resp[i + 1]);
+      this.#tokenDataLoaded.add(tokensToLoad[i]);
     }
-    this.#tokenDataLoaded = true;
   }
   #overrideTokenMeta(token, contractTypeResp, serializeResp) {
     const meta = this.mustGet(token);

package/dist/esm/sdk/market/MarketRegister.js

@@ -1,5 +1,4 @@
 import { marketCompressorAbi } from "../../abi/compressors/marketCompressor.js";
-import { SDKConstruct } from "../base/index.js";
 import {
   ADDRESS_0X0,
   AP_MARKET_COMPRESSOR,
@@ -9,7 +8,8 @@ import { AddressMap } from "../utils/index.js";
 import { simulateWithPriceUpdates } from "../utils/viem/index.js";
 import { MarketConfiguratorContract } from "./MarketConfiguratorContract.js";
 import { MarketSuite } from "./MarketSuite.js";
-class MarketRegister extends SDKConstruct {
+import { ZapperRegister } from "./ZapperRegister.js";
+class MarketRegister extends ZapperRegister {
   /**
    * Mapping pool.address -> MarketSuite
    */

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

@@ -1,4 +1,110 @@
-const extraZappers = {
+import { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
+import { SDKConstruct } from "../base/index.js";
+import {
+  AP_PERIPHERY_COMPRESSOR,
+  VERSION_RANGE_310
+} from "../constants/index.js";
+import { AddressMap, hexEq } from "../utils/index.js";
+class ZapperRegister extends 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(
+      AP_PERIPHERY_COMPRESSOR,
+      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: peripheryCompressorAbi,
+          address: pcAddr,
+          functionName: "getZappers",
+          args: [m.configurator.address, m.pool.pool.address]
+        })
+      ),
+      allowFailure: true,
+      batchSize: 0
+    });
+    this.#zappers = new 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) => 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) => hexEq(z.tokenIn.addr, tokenIn) && hexEq(z.tokenOut.addr, tokenOut)
+    );
+    return zappers;
+  }
+}
+const BROKEN_ZAPPERS = new AddressMap(
+  [["0x90D66b03EC4D462e42e3c7741049FB46a4a03B69", true]],
+  "brokenZappers"
+);
+const MIGRATION_ZAPPERS = {
   Mainnet: [
     {
       baseParams: {
@@ -107,6 +213,7 @@ const extraZappers = {
     }
   ]
 };
+const KYC_ZAPPERS = {};
 export {
-  extraZappers
+  ZapperRegister
 };

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

@@ -5,3 +5,4 @@ export * from "./MarketSuite.js";
 export * from "./oracle/index.js";
 export * from "./pool/index.js";
 export * from "./pricefeeds/index.js";
+export * from "./types.js";

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

@@ -1,4 +1,3 @@
-import { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
 import { ierc20Abi } from "../../abi/iERC20.js";
 import { ierc20ZapperDepositsAbi } from "../../abi/iERC20ZapperDeposits.js";
 import { iethZapperDepositsAbi } from "../../abi/iETHZapperDeposits.js";
@@ -9,106 +8,66 @@ import {
   KYC_UNDERLYING_ON_DEMAND,
   SDKConstruct
 } from "../base/index.js";
-import {
-  AddressMap,
-  AddressSet,
-  AP_PERIPHERY_COMPRESSOR,
-  hexEq,
-  VERSION_RANGE_310
-} from "../index.js";
-import { extraZappers } from "./extraZappers.js";
+import { AddressSet, hexEq } from "../index.js";
+import { AddressMap } from "../utils/index.js";
 const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+const POOL_TOKENS_TO_MIGRATE = new AddressMap([
+  // v2 diesels
+  ["0x6CFaF95457d7688022FC53e7AbE052ef8DFBbdBA", "dDAI"],
+  ["0xc411dB5f5Eb3f7d552F9B8454B2D74097ccdE6E3", "dUSDC"],
+  ["0xe753260F1955e8678DCeA8887759e07aa57E8c54", "dWBTC"],
+  ["0xF21fc650C1B34eb0FDE786D52d23dA99Db3D6278", "dWETH"],
+  ["0x2158034dB06f06dcB9A786D2F1F8c38781bA779d", "dwstETH"],
+  ["0x8A1112AFef7F4FC7c066a77AABBc01b3Fff31D47", "dFRAX"]
+]);
 class PoolService extends SDKConstruct {
-  #zappers;
-  get zappers() {
-    if (!this.#zappers) {
-      throw new Error("zappers not loaded, call loadZappers first");
-    }
-    return this.#zappers;
-  }
-  async loadZappers(force) {
-    if (!force && this.#zappers) {
-      return;
-    }
-    const [pcAddr] = this.sdk.addressProvider.mustGetLatest(
-      AP_PERIPHERY_COMPRESSOR,
-      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: peripheryCompressorAbi,
-          address: pcAddr,
-          functionName: "getZappers",
-          args: [m.configurator.address, m.pool.pool.address]
-        })
-      ),
-      allowFailure: true,
-      batchSize: 0
-    });
-    this.#zappers = new 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 });
-        }
-      } else {
-        this.sdk.logger?.error(
-          `failed to load zapper for market configurator ${this.labelAddress(
-            marketConfigurator
-          )} and pool ${this.labelAddress(pool)}: ${error}`
-        );
-      }
-    }
-    for (const z of extraZappers[this.networkType] ?? []) {
-      this.#addZapper(z);
-    }
-  }
   getDepositTokensIn(pool) {
     const underlying = this.#describeUnderlying(pool);
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
       switch (underlying.contractType) {
         case KYC_UNDERLYING_DEFAULT:
-          return this.depositTokensIn(pool, false);
+          return this.#depositTokensIn(pool, false);
         case KYC_UNDERLYING_ON_DEMAND:
           return [underlying.asset];
       }
     }
-    return this.depositTokensIn(pool, true);
+    return this.#depositTokensIn(pool, true);
   }
   getDepositTokensOut(pool, tokenIn) {
     const underlying = this.#describeUnderlying(pool);
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
       switch (underlying.contractType) {
         case KYC_UNDERLYING_DEFAULT:
-          return this.depositTokensOut(pool, tokenIn, false);
+          return this.#depositTokensOut(pool, tokenIn, false);
         case KYC_UNDERLYING_ON_DEMAND:
           return [];
       }
     }
-    return this.depositTokensOut(pool, tokenIn, true);
+    return this.#depositTokensOut(pool, tokenIn, true);
   }
   getDepositMetadata(pool, tokenIn, tokenOut) {
     const underlying = this.#describeUnderlying(pool);
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
       switch (underlying.contractType) {
         case KYC_UNDERLYING_DEFAULT: {
-          return this.depositMetadata(pool, tokenIn, tokenOut, false);
+          return this.#depositMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
         }
         case KYC_UNDERLYING_ON_DEMAND:
           return {
             zapper: void 0,
             approveTarget: underlying.liquidityProvider,
-            permissible: false
+            permissible: false,
+            type: "kyc-on-demand"
           };
       }
     }
-    return this.depositMetadata(pool, tokenIn, tokenOut, true);
+    return this.#depositMetadata("classic", pool, tokenIn, tokenOut, true);
   }
   addLiquidity(props) {
     const { collateral, meta, permit, referralCode, pool, wallet } = props;
@@ -119,7 +78,7 @@ class PoolService extends SDKConstruct {
       }
     }
     const { zapper } = meta;
-    if (zapper?.tokenIn.addr === NATIVE_ADDRESS) {
+    if (zapper?.tokenIn.addr?.toLowerCase() === NATIVE_ADDRESS.toLowerCase()) {
       return {
         target: zapper.baseParams.addr,
         abi: iethZapperDepositsAbi,
@@ -196,13 +155,17 @@ class PoolService extends SDKConstruct {
       args: [amount, account, account]
     };
   }
-  depositTokensIn(poolAddr, allowDirectDeposit) {
+  #getDepositZappers(poolAddr) {
+    const zappers = this.sdk.marketRegister.poolZappers(poolAddr);
+    return zappers.filter((z) => z.type !== "migration");
+  }
+  #depositTokensIn(poolAddr, allowDirectDeposit) {
     const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
     const result = new AddressSet();
     if (allowDirectDeposit) {
       result.add(pool.underlying);
     }
-    const zappers = this.zappers.get(poolAddr) ?? [];
+    const zappers = this.#getDepositZappers(poolAddr);
     for (const z of zappers) {
       if (hexEq(z.tokenOut.addr, poolAddr)) {
         result.add(z.tokenIn.addr);
@@ -213,14 +176,18 @@ class PoolService extends SDKConstruct {
         `No tokensIn found for pool ${this.labelAddress(poolAddr)}`
       );
     }
-    return result.asArray();
+    const r = result.asArray().filter((t) => !POOL_TOKENS_TO_MIGRATE.has(t));
+    return r;
   }
-  depositTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
+  #depositTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
     const result = new AddressSet();
     const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
-    const zappers = this.zappers.get(poolAddr) ?? [];
+    const zappers = this.#getDepositZappers(poolAddr);
     for (const z of zappers) {
       if (hexEq(z.tokenIn.addr, tokenIn)) {
+        if (!hexEq(z.tokenOut.addr, poolAddr)) {
+          console.log("found", "z.tokenOut.addr", z.tokenOut.addr);
+        }
         result.add(z.tokenOut.addr);
       }
     }
@@ -229,20 +196,40 @@ class PoolService extends SDKConstruct {
     }
     if (result.size === 0) {
       throw new Error(
-        `No tokensOut found for tokenIn ${this.labelAddress(tokenIn)} on pool ${this.labelAddress(poolAddr)}`
+        `No tokensOut found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    const r = result.asArray();
+    return r;
+  }
+  #getDepositZapper(poolAddr, tokenIn, tokenOut) {
+    const zappers = this.sdk.marketRegister.getZapper(poolAddr, tokenIn, tokenOut)?.filter((z) => z.type !== "migration");
+    if (zappers && zappers.length > 1) {
+      throw new Error(
+        `Multiple zappers found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} and tokenOut ${this.labelAddress(
+          tokenOut
+        )} on pool ${this.labelAddress(poolAddr)}`
       );
     }
-    return result.asArray();
+    return zappers?.[0];
   }
-  depositMetadata(poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
+  #depositMetadata(type, poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
     if (!tokenOut) {
       throw new Error("tokenOut is required for classic pool deposit");
     }
     const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
-    const zapper = this.getZapper(poolAddr, tokenIn, tokenOut);
+    const zapper = this.#getDepositZapper(poolAddr, tokenIn, tokenOut);
     if (!zapper && !allowDirectDeposit) {
       throw new Error(
-        `No zapper found for tokenIn ${this.labelAddress(tokenIn)} and tokenOut ${this.labelAddress(tokenOut)} on pool ${this.labelAddress(poolAddr)}`
+        `No zapper found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} and tokenOut ${this.labelAddress(
+          tokenOut
+        )} on pool ${this.labelAddress(poolAddr)}`
       );
     }
     return {
@@ -251,41 +238,10 @@ class PoolService extends SDKConstruct {
       approveTarget: zapper?.baseParams.addr ?? pool.pool.address,
       // TODO: instead of permissible, return permitType зависимости от tokenIn
       // "none" | "eip2612" | "dai_like";
-      permissible: !!zapper && tokenIn !== NATIVE_ADDRESS
+      permissible: !!zapper && tokenIn !== NATIVE_ADDRESS,
+      type
     };
   }
-  getZapper(pool, tokenIn, tokenOut) {
-    return this.zappers.get(pool)?.find(
-      (z) => hexEq(z.tokenIn.addr, tokenIn) && hexEq(z.tokenOut.addr, tokenOut)
-    );
-  }
-  mustGetZapper(poolAddr, tokenIn, tokenOut) {
-    const result = this.getZapper(poolAddr, tokenIn, tokenOut);
-    if (!result) {
-      throw new Error(
-        `No zapper found for tokenIn ${this.labelAddress(tokenIn)} and tokenOut ${this.labelAddress(tokenOut)} on pool ${this.labelAddress(poolAddr)}`
-      );
-    }
-    return result;
-  }
-  #addZapper(z) {
-    const existing = this.zappers.get(z.pool);
-    if (existing) {
-      const hasZapper = existing.some(
-        (zz) => 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);
-    }
-  }
   #describeUnderlying(pool) {
     const market = this.sdk.marketRegister.findByPool(pool);
     return this.sdk.tokensMeta.mustGet(market.underlying);

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

@@ -26,6 +26,8 @@ export declare class TokensMeta extends AddressMap<TokenMetaData> {
     mustFindBySymbol(symbol: string): TokenMetaData;
     /**
      * Loads token information about phantom token and KYC underlying tokens
+     *
+     * @param tokens - tokens to load data for, defaults to all tokens
      */
-    loadTokenData(): Promise<void>;
+    loadTokenData(...tokens: Address[]): Promise<void>;
 }

package/dist/types/sdk/market/MarketRegister.d.ts

@@ -1,6 +1,5 @@
 import type { Address } from "viem";
 import type { MarketData, MarketFilter } from "../base/index.js";
-import { SDKConstruct } from "../base/index.js";
 import type { GearboxSDK } from "../GearboxSDK.js";
 import type { MarketStateHuman } from "../types/index.js";
 import { AddressMap } from "../utils/index.js";
@@ -9,7 +8,8 @@ import { MarketConfiguratorContract } from "./MarketConfiguratorContract.js";
 import { MarketSuite } from "./MarketSuite.js";
 import type { IPriceOracleContract } from "./oracle/index.js";
 import type { PoolSuite } from "./pool/index.js";
-export declare class MarketRegister extends SDKConstruct {
+import { ZapperRegister } from "./ZapperRegister.js";
+export declare class MarketRegister extends ZapperRegister {
     #private;
     constructor(sdk: GearboxSDK, ignoreMarkets?: Address[]);
     hydrate(state: MarketData[]): void;

package/dist/types/sdk/market/ZapperRegister.d.ts

@@ -0,0 +1,17 @@
+import type { Address } from "viem";
+import { SDKConstruct } from "../base/index.js";
+import { AddressMap } from "../utils/index.js";
+import type { ZapperData } from "./types.js";
+export declare class ZapperRegister extends SDKConstruct {
+    #private;
+    /**
+     * Load zappers for all pools using periphery compressor, adds hardcoded zappers
+     */
+    loadZappers(force?: boolean): Promise<void>;
+    get zappers(): AddressMap<ZapperData[]>;
+    poolZappers(pool: Address): ZapperData[];
+    /**
+     * Can return multiple zappers if there are multiple zappers for the same tokenIn and tokenOut
+     */
+    getZapper(pool: Address, tokenIn: Address, tokenOut: Address): Array<ZapperData> | undefined;
+}

package/dist/types/sdk/market/index.d.ts

@@ -5,3 +5,4 @@ export * from "./MarketSuite.js";
 export * from "./oracle/index.js";
 export * from "./pool/index.js";
 export * from "./pricefeeds/index.js";
+export * from "./types.js";

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

@@ -0,0 +1,10 @@
+import type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from "abitype";
+import type { Address } from "viem";
+import type { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
+import type { Unarray } from "../base/index.js";
+type CompressorZapperData = Unarray<AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof peripheryCompressorAbi, "getZappers">["outputs"]>>;
+export interface ZapperData extends CompressorZapperData {
+    pool: Address;
+    type: "migration" | "kyc" | "base";
+}
+export {};

package/dist/types/sdk/pools/PoolService.d.ts

@@ -1,19 +1,11 @@
 import type { Address } from "viem";
 import { SDKConstruct } from "../base/index.js";
-import { AddressMap } from "../index.js";
-import type { AddLiquidityProps, DepositMetadata, IPoolsService, PoolServiceCall, RemoveLiquidityProps, ZapperData } from "./types.js";
+import type { AddLiquidityProps, DepositMetadata, IPoolsService, PoolServiceCall, RemoveLiquidityProps } from "./types.js";
 export declare class PoolService extends SDKConstruct implements IPoolsService {
     #private;
-    get zappers(): AddressMap<ZapperData[]>;
-    loadZappers(force?: boolean): Promise<void>;
     getDepositTokensIn(pool: Address): Address[];
     getDepositTokensOut(pool: Address, tokenIn: Address): Address[];
     getDepositMetadata(pool: Address, tokenIn: Address, tokenOut?: Address): DepositMetadata;
     addLiquidity(props: AddLiquidityProps): PoolServiceCall | undefined;
     removeLiquidity(props: RemoveLiquidityProps): PoolServiceCall;
-    protected depositTokensIn(poolAddr: Address, allowDirectDeposit: boolean): Address[];
-    protected depositTokensOut(poolAddr: Address, tokenIn: Address, allowDirectDeposit: boolean): Address[];
-    protected depositMetadata(poolAddr: Address, tokenIn: Address, tokenOut?: Address, allowDirectDeposit?: boolean): DepositMetadata;
-    protected getZapper(pool: Address, tokenIn: Address, tokenOut: Address): ZapperData | undefined;
-    protected mustGetZapper(poolAddr: Address, tokenIn: Address, tokenOut: Address): ZapperData;
 }

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

@@ -1,14 +1,8 @@
-import type { Abi, AbiParametersToPrimitiveTypes, ExtractAbiFunction } from "abitype";
+import type { Abi } from "abitype";
 import type { Address, ContractFunctionArgs, ContractFunctionName } from "viem";
-import type { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
-import type { Unarray } from "../base/index.js";
+import type { ZapperData } from "../market/index.js";
 import type { Asset } from "../router/index.js";
 import type { PoolData_Legacy } from "../sdk-legacy/index.js";
-import type { AddressMap } from "../utils/index.js";
-type CompressorZapperData = Unarray<AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof peripheryCompressorAbi, "getZappers">["outputs"]>>;
-export interface ZapperData extends CompressorZapperData {
-    pool: Address;
-}
 interface PermitResult {
     r: Address;
     s: Address;
@@ -57,16 +51,12 @@ export interface DepositMetadata {
      * If true, user can avoid approval step and deposit with permit
      */
     permissible: boolean;
-}
-export interface IPoolsService {
     /**
-     * Mapping of pool address -> zappers for that pool
+     * Type of deposit
      */
-    zappers: AddressMap<ZapperData[]>;
-    /**
-     * Load zappers for all pools using periphery compressor, adds hardcoded zappers
-     */
-    loadZappers(force?: boolean): Promise<void>;
+    type: "kyc-on-demand" | "kyc-default" | "classic";
+}
+export interface IPoolsService {
     /**
      * Returns list of tokens that can be deposited to a pool
      * @param pool

package/package.json

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

package/dist/types/sdk/pools/extraZappers.d.ts

@@ -1,9 +0,0 @@
-import type { NetworkType } from "../../sdk/index.js";
-import type { ZapperData } from "./types.js";
-/**
- * Temporary zappers
- *
- * On paper we have periphery compressor, but we don't use it because we don't add zappers to market configurator as periphery contract and this is unnecessary action for risk curator
- * Zappers for KYC markets are always in compressor, though
- */
-export declare const extraZappers: Partial<Record<NetworkType, ZapperData[]>>;