@gearbox-protocol/sdk 3.0.0-vfour.285 → 3.0.0-vfour.286

package/dist/cjs/adapters/{plugin.js → GearboxAdaptersPlugin.js}

@@ -16,11 +16,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var plugin_exports = {};
-__export(plugin_exports, {
+var GearboxAdaptersPlugin_exports = {};
+__export(GearboxAdaptersPlugin_exports, {
   GearboxAdaptersPlugin: () => GearboxAdaptersPlugin
 });
-module.exports = __toCommonJS(plugin_exports);
+module.exports = __toCommonJS(GearboxAdaptersPlugin_exports);
 var import_sdk = require("../sdk/index.js");
 var import_BalancerV2VaultAdapterContract = require("./BalancerV2VaultAdapterContract.js");
 var import_BalancerV3RouterAdapterContract = require("./BalancerV3RouterAdapterContract.js");
@@ -43,71 +43,74 @@ var import_UniswapV3AdapterContract = require("./UniswapV3AdapterContract.js");
 var import_VelodromeV2AdapterContract = require("./VelodromeV2AdapterContract.js");
 var import_WstETHV1AdapterContract = require("./WstETHV1AdapterContract.js");
 var import_YearnV2AdapterContract = require("./YearnV2AdapterContract.js");
-const GearboxAdaptersPlugin = {
-  name: "Adapters",
-  createContract(sdk, data) {
+class GearboxAdaptersPlugin extends import_sdk.SDKConstruct {
+  name = "Adapters";
+  createContract(data) {
     const args = data;
     const adapterType = (0, import_sdk.bytes32ToString)(
       args.baseParams.contractType
     );
     switch (adapterType) {
       case "ADAPTER::UNISWAP_V2_ROUTER":
-        return new import_UniswapV2AdapterContract.UniswapV2AdapterContract(sdk, args);
+        return new import_UniswapV2AdapterContract.UniswapV2AdapterContract(this.sdk, args);
       case "ADAPTER::UNISWAP_V3_ROUTER":
-        return new import_UniswapV3AdapterContract.UniswapV3AdapterContract(sdk, args);
+        return new import_UniswapV3AdapterContract.UniswapV3AdapterContract(this.sdk, args);
       case "ADAPTER::CURVE_V1_2ASSETS":
-        return new import_Curve2AssetsAdapterContract.Curve2AssetsAdapterContract(sdk, args);
+        return new import_Curve2AssetsAdapterContract.Curve2AssetsAdapterContract(this.sdk, args);
       case "ADAPTER::CURVE_V1_3ASSETS":
-        return new import_Curve3AssetsAdapterContract.Curve3AssetsAdapterContract(sdk, args);
+        return new import_Curve3AssetsAdapterContract.Curve3AssetsAdapterContract(this.sdk, args);
       case "ADAPTER::CURVE_V1_4ASSETS":
-        return new import_Curve4AssetsAdapterContract.Curve4AssetsAdapterContract(sdk, args);
+        return new import_Curve4AssetsAdapterContract.Curve4AssetsAdapterContract(this.sdk, args);
       case "ADAPTER::CURVE_V1_STECRV_POOL":
-        return new import_CurveV1AdapterStETHContract.CurveV1AdapterStETHContract(sdk, args);
+        return new import_CurveV1AdapterStETHContract.CurveV1AdapterStETHContract(this.sdk, args);
       case "ADAPTER::CURVE_V1_WRAPPER":
-        return new import_CurveV1StableNGAdapterContract.CurveV1StableNGAdapterContract(sdk, args);
+        return new import_CurveV1StableNGAdapterContract.CurveV1StableNGAdapterContract(this.sdk, args);
       case "ADAPTER::CVX_V1_BASE_REWARD_POOL":
-        return new import_ConvexV1BaseRewardPoolAdapterContract.ConvexV1BaseRewardPoolAdapterContract(sdk, args);
+        return new import_ConvexV1BaseRewardPoolAdapterContract.ConvexV1BaseRewardPoolAdapterContract(this.sdk, args);
       case "ADAPTER::CVX_V1_BOOSTER":
-        return new import_ConvexV1BoosterAdapterContract.ConvexV1BoosterAdapterContract(sdk, args);
+        return new import_ConvexV1BoosterAdapterContract.ConvexV1BoosterAdapterContract(this.sdk, args);
       case "ADAPTER::CURVE_STABLE_NG":
-        return new import_CurveV1StableNGAdapterContract.CurveV1StableNGAdapterContract(sdk, args);
+        return new import_CurveV1StableNGAdapterContract.CurveV1StableNGAdapterContract(this.sdk, args);
       case "ADAPTER::LIDO_WSTETH_V1":
-        return new import_WstETHV1AdapterContract.WstETHV1AdapterContract(sdk, args);
+        return new import_WstETHV1AdapterContract.WstETHV1AdapterContract(this.sdk, args);
       case "ADAPTER::BALANCER_VAULT":
-        return new import_BalancerV2VaultAdapterContract.BalancerV2VaultAdapterContract(sdk, args);
+        return new import_BalancerV2VaultAdapterContract.BalancerV2VaultAdapterContract(this.sdk, args);
       case "ADAPTER::BALANCER_V3_ROUTER":
-        return new import_BalancerV3RouterAdapterContract.BalancerV3RouterAdapterContract(sdk, args);
+        return new import_BalancerV3RouterAdapterContract.BalancerV3RouterAdapterContract(this.sdk, args);
       case "ADAPTER::ERC4626_VAULT":
-        return new import_ERC4626AdapterContract.ERC4626AdapterContract(sdk, args);
+        return new import_ERC4626AdapterContract.ERC4626AdapterContract(this.sdk, args);
       case "ADAPTER::VELODROME_V2_ROUTER":
-        return new import_VelodromeV2AdapterContract.VelodromeV2RouterAdapterContract(sdk, args);
+        return new import_VelodromeV2AdapterContract.VelodromeV2RouterAdapterContract(this.sdk, args);
       case "ADAPTER::CAMELOT_V3_ROUTER":
-        return new import_CamelotV3AdapterContract.CamelotV3AdapterContract(sdk, args);
+        return new import_CamelotV3AdapterContract.CamelotV3AdapterContract(this.sdk, args);
       case "ADAPTER::YEARN_V2":
-        return new import_YearnV2AdapterContract.YearnV2RouterAdapterContract(sdk, args);
+        return new import_YearnV2AdapterContract.YearnV2RouterAdapterContract(this.sdk, args);
       case "ADAPTER::MELLOW_LRT_VAULT":
-        return new import_MellowVaultAdapterContract.MellowVaultAdapterContract(sdk, args);
+        return new import_MellowVaultAdapterContract.MellowVaultAdapterContract(this.sdk, args);
       case "ADAPTER::MELLOW_ERC4626_VAULT":
-        return new import_MellowERC4626VaultAdapterContract.MellowERC4626VaultAdapterContract(sdk, args);
+        return new import_MellowERC4626VaultAdapterContract.MellowERC4626VaultAdapterContract(this.sdk, args);
       case "ADAPTER::PENDLE_ROUTER":
-        return new import_PendleRouterAdapterContract.PendleRouterAdapterContract(sdk, args);
+        return new import_PendleRouterAdapterContract.PendleRouterAdapterContract(this.sdk, args);
       case "ADAPTER::DAI_USDS_EXCHANGE":
-        return new import_DaiUsdsAdapterContract.DaiUsdsAdapterContract(sdk, args);
+        return new import_DaiUsdsAdapterContract.DaiUsdsAdapterContract(this.sdk, args);
       case "ADAPTER::STAKING_REWARDS":
-        return new import_StakingRewardsAdapterContract.StakingRewardsAdapterContract(sdk, args);
+        return new import_StakingRewardsAdapterContract.StakingRewardsAdapterContract(this.sdk, args);
       default: {
         const err = new Error(
           `Adapter type ${adapterType} not supported for adapter at ${args.baseParams.addr}`
         );
-        if (sdk.strictContractTypes) {
+        if (this.sdk.strictContractTypes) {
           throw err;
         }
-        sdk.logger?.error(err);
+        this.sdk.logger?.error(err);
         return void 0;
       }
     }
   }
-};
+  stateHuman(raw) {
+    return {};
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GearboxAdaptersPlugin

package/dist/cjs/adapters/index.js

@@ -15,10 +15,10 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var adapters_exports = {};
 module.exports = __toCommonJS(adapters_exports);
-__reExport(adapters_exports, require("./plugin.js"), module.exports);
+__reExport(adapters_exports, require("./GearboxAdaptersPlugin.js"), module.exports);
 __reExport(adapters_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./plugin.js"),
+  ...require("./GearboxAdaptersPlugin.js"),
   ...require("./types.js")
 });

package/dist/cjs/dev/index.js

@@ -18,8 +18,8 @@ module.exports = __toCommonJS(dev_exports);
 __reExport(dev_exports, require("./AccountOpener.js"), module.exports);
 __reExport(dev_exports, require("./calcLiquidatableLTs.js"), module.exports);
 __reExport(dev_exports, require("./createAnvilClient.js"), module.exports);
+__reExport(dev_exports, require("./migrateFaucet.js"), module.exports);
 __reExport(dev_exports, require("./PriceFeedStore.js"), module.exports);
-__reExport(dev_exports, require("./SDKExample.js"), module.exports);
 __reExport(dev_exports, require("./setLTs.js"), module.exports);
 __reExport(dev_exports, require("./setLTZero.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
@@ -27,8 +27,8 @@ __reExport(dev_exports, require("./setLTZero.js"), module.exports);
   ...require("./AccountOpener.js"),
   ...require("./calcLiquidatableLTs.js"),
   ...require("./createAnvilClient.js"),
+  ...require("./migrateFaucet.js"),
   ...require("./PriceFeedStore.js"),
-  ...require("./SDKExample.js"),
   ...require("./setLTs.js"),
   ...require("./setLTZero.js")
 });

package/dist/cjs/dev/migrateFaucet.js

@@ -0,0 +1,94 @@
+"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 migrateFaucet_exports = {};
+__export(migrateFaucet_exports, {
+  migrateFaucet: () => migrateFaucet
+});
+module.exports = __toCommonJS(migrateFaucet_exports);
+var import_viem = require("viem");
+var import_v300 = require("../abi/v300.js");
+var import_v310 = require("../abi/v310.js");
+var import_sdk = require("../sdk/index.js");
+var import_createAnvilClient = require("./createAnvilClient.js");
+async function unsafeMigrateFaucet(sdk) {
+  const anvil = (0, import_createAnvilClient.createAnvilClient)({
+    chain: sdk.provider.chain,
+    transport: sdk.provider.transport
+  });
+  const [faucetAddr, owner] = await anvil.multicall({
+    contracts: [
+      {
+        abi: import_v300.iAddressProviderV300Abi,
+        address: import_sdk.ADDRESS_PROVIDER[sdk.provider.networkType],
+        functionName: "getAddressOrRevert",
+        args: [(0, import_viem.stringToHex)("FAUCET", { size: 32 }), 0n]
+      },
+      {
+        abi: import_v310.iAddressProviderV310Abi,
+        address: sdk.addressProvider.address,
+        functionName: "owner",
+        args: []
+      }
+    ],
+    allowFailure: false
+  });
+  sdk.logger?.debug(`faucet address: ${faucetAddr}, owner: ${owner}`);
+  await anvil.impersonateAccount({ address: owner });
+  await anvil.setBalance({
+    address: owner,
+    value: (0, import_viem.parseEther)("1000")
+  });
+  const balance = await anvil.getBalance({ address: owner });
+  sdk.logger?.debug(`owner balance: ${(0, import_viem.formatEther)(balance)} ETH`);
+  const { request } = await anvil.simulateContract({
+    chain: anvil.chain,
+    account: owner,
+    address: sdk.addressProvider.address,
+    abi: import_v310.iAddressProviderV310Abi,
+    functionName: "setAddress",
+    args: [(0, import_viem.stringToHex)("FAUCET", { size: 32 }), faucetAddr, false]
+  });
+  sdk.logger?.debug("estimated setAddress call");
+  const hash = await anvil.writeContract({
+    chain: anvil.chain,
+    account: owner,
+    address: sdk.addressProvider.address,
+    abi: import_v310.iAddressProviderV310Abi,
+    functionName: "setAddress",
+    args: [(0, import_viem.stringToHex)("FAUCET", { size: 32 }), faucetAddr, false],
+    gas: request.gas ? request.gas * 11n / 10n : void 0
+  });
+  const receipt = await anvil.waitForTransactionReceipt({ hash });
+  await anvil.stopImpersonatingAccount({ address: owner });
+  if (receipt.status === "reverted") {
+    throw new Error("faucet migration reverted");
+  }
+}
+async function migrateFaucet(sdk) {
+  try {
+    await unsafeMigrateFaucet(sdk);
+    sdk.logger?.info("faucet migrated successfully");
+  } catch (e) {
+    sdk.logger?.error(`faucet migration failed: ${e}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  migrateFaucet
+});

package/dist/cjs/sdk/GearboxSDK.js

@@ -32,10 +32,12 @@ var import_router = require("./router/index.js");
 var import_utils = require("./utils/index.js");
 var import_internal = require("./utils/internal/index.js");
 var import_viem2 = require("./utils/viem/index.js");
+const ERR_NOT_ATTACHED = new Error("Gearbox SDK not attached");
 class GearboxSDK {
   #hooks = new import_internal.Hooks();
   // Represents chain object
   #provider;
+  plugins;
   // Block which was use for data query
   #currentBlock;
   #timestamp;
@@ -50,7 +52,6 @@ class GearboxSDK {
   // Router contract
   #router;
   logger;
-  plugins;
   /**
    * Interest rate models can be reused across chain (and SDK operates on chain level)
    * TODO: use whatever interface is necessary for InterestRateModels
@@ -124,8 +125,14 @@ class GearboxSDK {
     this.#provider = options.provider;
     this.logger = options.logger;
     this.priceFeeds = new import_pricefeeds.PriceFeedRegister(this);
-    this.plugins = options.plugins ?? [];
     this.strictContractTypes = options.strictContractTypes ?? false;
+    const pluginsInstances = {};
+    for (const [name, PluginConstructor] of Object.entries(
+      options.plugins ?? {}
+    )) {
+      pluginsInstances[name] = new PluginConstructor(this);
+    }
+    this.plugins = pluginsInstances;
   }
   async #attach(opts) {
     const {
@@ -187,6 +194,13 @@ class GearboxSDK {
     } catch (e) {
       this.logger?.warn("Router not found", e);
     }
+    for (const [name, plugin] of Object.entries(this.plugins)) {
+      if (plugin.attach) {
+        this.logger?.debug(`attaching plugin ${name}`);
+        await plugin.attach();
+        this.logger?.debug(`attached plugin ${name}`);
+      }
+    }
     this.logger?.info(`attach time: ${Date.now() - time} ms`);
     return this;
   }
@@ -246,6 +260,12 @@ class GearboxSDK {
         gearStakingV3: this.gearStakingContract.stateHuman(raw)
       },
       tokens: this.tokensMeta.values(),
+      plugins: Object.fromEntries(
+        Object.entries(this.plugins).map(([name, plugin]) => [
+          name,
+          plugin.stateHuman(raw)
+        ])
+      ),
       ...this.marketRegister.stateHuman(raw)
     };
   }
@@ -268,7 +288,7 @@ class GearboxSDK {
    */
   async syncState(opts) {
     let { blockNumber, timestamp } = opts ?? {};
-    if (!blockNumber) {
+    if (!blockNumber || !timestamp) {
       const block = await this.provider.publicClient.getBlock({
         blockTag: "latest"
       });
@@ -301,7 +321,7 @@ class GearboxSDK {
     await this.marketRegister.syncState();
     this.#currentBlock = blockNumber;
     this.#timestamp = timestamp;
-    await this.#hooks.triggerHooks("syncState");
+    await this.#hooks.triggerHooks("syncState", { blockNumber, timestamp });
     this.#syncing = false;
     this.logger?.debug(`synced state to block ${blockNumber}`);
   }
@@ -310,49 +330,49 @@ class GearboxSDK {
   }
   get currentBlock() {
     if (this.#currentBlock === void 0) {
-      throw new Error("Gearbox SDK not attached");
+      throw ERR_NOT_ATTACHED;
     }
     return this.#currentBlock;
   }
   get timestamp() {
     if (this.#timestamp === void 0) {
-      throw new Error("Gearbox SDK not attached");
+      throw ERR_NOT_ATTACHED;
     }
     return this.#timestamp;
   }
   get gear() {
     if (this.#gear === void 0) {
-      throw new Error("Gearbox SDK not attached");
+      throw ERR_NOT_ATTACHED;
     }
     return this.#gear;
   }
   get addressProvider() {
     if (this.#addressProvider === void 0) {
-      throw new Error("Gearbox SDK not attached");
+      throw ERR_NOT_ATTACHED;
     }
     return this.#addressProvider;
   }
   get botListContract() {
     if (this.#botListContract === void 0) {
-      throw new Error("Gearbox SDK not attached");
+      throw ERR_NOT_ATTACHED;
     }
     return this.#botListContract;
   }
   get gearStakingContract() {
     if (this.#gearStakingContract === void 0) {
-      throw new Error("Gearbox SDK not attached");
+      throw ERR_NOT_ATTACHED;
     }
     return this.#gearStakingContract;
   }
   get marketRegister() {
     if (this.#marketRegister === void 0) {
-      throw new Error("Gearbox SDK not attached");
+      throw ERR_NOT_ATTACHED;
     }
     return this.#marketRegister;
   }
   get router() {
     if (this.#router === void 0) {
-      throw new Error("Gearbox SDK not attached");
+      throw ERR_NOT_ATTACHED;
     }
     return this.#router;
   }

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

@@ -34,7 +34,6 @@ class MarketRegister extends import_base.SDKConstruct {
    * Mapping pool.address -> MarketSuite
    */
   #markets = new import_utils.AddressMap(void 0, "markets");
-  #zappers = new import_utils.AddressMap(void 0, "zappers");
   #marketFilter;
   constructor(sdk, markets) {
     super(sdk);
@@ -55,43 +54,6 @@ class MarketRegister extends import_base.SDKConstruct {
     }
     await this.#loadMarkets(marketConfigurators, [], ignoreUpdateablePrices);
   }
-  async loadZappers() {
-    const pcAddr = this.sdk.addressProvider.getAddress(
-      import_constants.AP_PERIPHERY_COMPRESSOR,
-      310
-    );
-    this.#logger?.debug(`loading zappers with periphery compressor ${pcAddr}`);
-    const resp = await this.provider.publicClient.multicall({
-      contracts: this.markets.map((m) => ({
-        abi: import_compressors.iPeripheryCompressorAbi,
-        address: pcAddr,
-        functionName: "getZappers",
-        args: [m.configurator.address, m.pool.pool.address]
-      })),
-      allowFailure: true
-    });
-    for (let i = 0; i < resp.length; i++) {
-      const { status, result, error } = resp[i];
-      const marketConfigurator = this.markets[i].configurator.address;
-      const pool = this.markets[i].pool.pool.address;
-      if (status === "success") {
-        const list = result;
-        this.#zappers.upsert(
-          pool,
-          list.map((z) => ({ ...z, pool }))
-        );
-      } else {
-        this.#logger?.error(
-          `failed to load zapper for market configurator ${this.labelAddress(marketConfigurator)} and pool ${this.labelAddress(pool)}: ${error}`
-        );
-      }
-    }
-    const zappersTokens = this.#zappers.values().flatMap((l) => l.flatMap((z) => [z.tokenIn, z.tokenOut]));
-    for (const t of zappersTokens) {
-      this.sdk.tokensMeta.upsert(t.addr, t);
-      this.sdk.provider.addressLabels.set(t.addr, t.symbol);
-    }
-  }
   get marketFilter() {
     return this.#marketFilter;
   }
@@ -192,16 +154,7 @@ class MarketRegister extends import_base.SDKConstruct {
   }
   stateHuman(raw = true) {
     return {
-      markets: this.markets.map((market) => market.stateHuman(raw)),
-      zappers: this.zappers.values().flatMap(
-        (l) => l.flatMap((z) => ({
-          address: z.baseParams.addr,
-          contractType: z.baseParams.contractType,
-          version: Number(z.baseParams.version),
-          tokenIn: this.labelAddress(z.tokenIn.addr),
-          tokenOut: this.labelAddress(z.tokenOut.addr)
-        }))
-      )
+      markets: this.markets.map((market) => market.stateHuman(raw))
     };
   }
   get pools() {
@@ -261,9 +214,6 @@ class MarketRegister extends import_base.SDKConstruct {
   get marketsMap() {
     return this.#markets;
   }
-  get zappers() {
-    return this.#zappers;
-  }
   get markets() {
     return this.#markets.values();
   }

package/dist/cjs/sdk/market/adapters/factory.js

@@ -25,18 +25,18 @@ var import_utils = require("../../utils/index.js");
 var import_PlaceholderAdapterContracts = require("./PlaceholderAdapterContracts.js");
 function createAdapter(sdk, args) {
   const adapterType = (0, import_utils.bytes32ToString)(args.baseParams.contractType);
-  for (const plugin of sdk.plugins) {
+  for (const [name, plugin] of Object.entries(sdk.plugins)) {
     try {
-      const adapter = plugin.createContract(sdk, args);
+      const adapter = plugin.createContract?.(args);
       if (adapter) {
         sdk.logger?.info(
-          ` ${adapterType} v${args.baseParams.version} created using plugin ${plugin.name}`
+          ` ${adapterType} v${args.baseParams.version} created using plugin ${name}`
         );
         return adapter;
       }
     } catch (e) {
       sdk.logger?.warn(
-        `plugin ${plugin.name} error while trying to create ${adapterType} v${args.baseParams.version}: ${e}`
+        `plugin ${name} error while trying to create ${adapterType} v${args.baseParams.version}: ${e}`
       );
     }
   }

package/dist/cjs/zappers/GearboxZappersPlugin.js

@@ -0,0 +1,94 @@
+"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 GearboxZappersPlugin_exports = {};
+__export(GearboxZappersPlugin_exports, {
+  GearboxZappersPlugin: () => GearboxZappersPlugin
+});
+module.exports = __toCommonJS(GearboxZappersPlugin_exports);
+var import_compressors = require("../abi/compressors.js");
+var import_sdk = require("../sdk/index.js");
+var import_sdk2 = require("../sdk/index.js");
+class GearboxZappersPlugin extends import_sdk.SDKConstruct {
+  #zappers;
+  async attach() {
+    await this.loadZappers();
+  }
+  async loadZappers() {
+    this.#zappers = new import_sdk2.AddressMap(void 0, "zappers");
+    const pcAddr = this.sdk.addressProvider.getAddress(
+      import_sdk.AP_PERIPHERY_COMPRESSOR,
+      310
+    );
+    this.sdk.logger?.debug(
+      `loading zappers with periphery compressor ${pcAddr}`
+    );
+    const markets = this.sdk.marketRegister.markets;
+    const resp = await this.provider.publicClient.multicall({
+      contracts: markets.map((m) => ({
+        abi: import_compressors.iPeripheryCompressorAbi,
+        address: pcAddr,
+        functionName: "getZappers",
+        args: [m.configurator.address, m.pool.pool.address]
+      })),
+      allowFailure: true
+    });
+    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") {
+        const list = result;
+        this.#zappers.upsert(
+          pool,
+          list.map((z) => ({ ...z, pool }))
+        );
+      } else {
+        this.sdk.logger?.error(
+          `failed to load zapper for market configurator ${this.labelAddress(marketConfigurator)} and pool ${this.labelAddress(pool)}: ${error}`
+        );
+      }
+    }
+    const zappersTokens = this.#zappers.values().flatMap((l) => l.flatMap((z) => [z.tokenIn, z.tokenOut]));
+    for (const t of zappersTokens) {
+      this.sdk.tokensMeta.upsert(t.addr, t);
+      this.sdk.provider.addressLabels.set(t.addr, t.symbol);
+    }
+  }
+  get zappers() {
+    if (!this.#zappers) {
+      throw new Error("zappers plugin not attached");
+    }
+    return this.#zappers;
+  }
+  stateHuman(raw) {
+    return this.zappers.values().flatMap(
+      (l) => l.flatMap((z) => ({
+        address: z.baseParams.addr,
+        contractType: z.baseParams.contractType,
+        version: Number(z.baseParams.version),
+        tokenIn: this.labelAddress(z.tokenIn.addr),
+        tokenOut: this.labelAddress(z.tokenOut.addr)
+      }))
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GearboxZappersPlugin
+});

package/dist/cjs/zappers/index.js

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

package/dist/cjs/zappers/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

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