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

package/dist/cjs/{sdk/pools/PoolServiceV310.js → abi/iStateSerializer.js}

@@ -16,15 +16,21 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var PoolServiceV310_exports = {};
-__export(PoolServiceV310_exports, {
-  PoolServiceV310: () => PoolServiceV310
+var iStateSerializer_exports = {};
+__export(iStateSerializer_exports, {
+  iStateSerializerAbi: () => iStateSerializerAbi
 });
-module.exports = __toCommonJS(PoolServiceV310_exports);
-var import_AbstractPoolService = require("./AbstractPoolService.js");
-class PoolServiceV310 extends import_AbstractPoolService.AbstractPoolService {
-}
+module.exports = __toCommonJS(iStateSerializer_exports);
+const iStateSerializerAbi = [
+  {
+    type: "function",
+    inputs: [],
+    name: "serialize",
+    outputs: [{ name: "serializedData", internalType: "bytes", type: "bytes" }],
+    stateMutability: "view"
+  }
+];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PoolServiceV310
+  iStateSerializerAbi
 });

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

@@ -21,19 +21,21 @@ __export(TokensMeta_exports, {
   TokensMeta: () => TokensMeta
 });
 module.exports = __toCommonJS(TokensMeta_exports);
+var import_viem = require("viem");
+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");
 class TokensMeta extends import_utils.AddressMap {
   #client;
-  #phantomTokensLoaded;
+  #tokenDataLoaded = false;
   constructor(client) {
     super(void 0, "tokensMeta");
     this.#client = client;
   }
   reset() {
     this.clear();
-    this.#phantomTokensLoaded = void 0;
+    this.#tokenDataLoaded = false;
   }
   symbol(token) {
     return this.mustGet(token).symbol;
@@ -41,28 +43,39 @@ class TokensMeta extends import_utils.AddressMap {
   decimals(token) {
     return this.mustGet(token).decimals;
   }
-  /**
-   * Returns the phantom token type for a given token, or undefined for normal tokens
-   * Throws if the phantom token data is not loaded
-   */
-  phantomTokenType(token) {
-    if (!this.#phantomTokensLoaded?.has(token)) {
-      throw new Error("phantom token data not loaded");
+  isPhantomToken(t) {
+    if (!this.#tokenDataLoaded) {
+      throw new Error("extended token data not loaded");
     }
-    return this.mustGet(token).phantomTokenType;
+    return "contractType" in t && t.contractType.startsWith("PHANTOM_TOKEN::");
+  }
+  isKYCUnderlying(t) {
+    if (!this.#tokenDataLoaded) {
+      throw new Error("extended token data not loaded");
+    }
+    return "contractType" in t && t.contractType.startsWith("KYC_UNDERLYING::");
   }
   /**
    * Returns a map of all phantom tokens
    * Throws if the phantom token data is not loaded
    */
   get phantomTokens() {
-    if (!this.#phantomTokensLoaded) {
-      throw new Error("phantom tokens not loaded");
+    const result = new import_utils.AddressMap();
+    for (const [token, meta] of this.entries()) {
+      if (this.isPhantomToken(meta)) {
+        result.upsert(token, meta);
+      }
     }
-    return new import_utils.AddressMap(
-      this.entries().filter(([_, v]) => !!v.phantomTokenType),
-      "phantomTokens"
-    );
+    return result;
+  }
+  get kycUnderlyings() {
+    const result = new import_utils.AddressMap();
+    for (const [token, meta] of this.entries()) {
+      if (this.isKYCUnderlying(meta)) {
+        result.upsert(token, meta);
+      }
+    }
+    return result;
   }
   formatBN(arg0, arg1, arg2) {
     const token = typeof arg0 === "object" ? arg0.token : arg0;
@@ -83,30 +96,86 @@ class TokensMeta extends import_utils.AddressMap {
     return meta;
   }
   /**
-   * Loads phantom token data for all known tokens from chain
+   * Loads token information about phantom token and KYC underlying tokens
    */
-  async loadPhantomTokens() {
-    this.#phantomTokensLoaded = new import_utils.AddressSet();
+  async loadTokenData() {
     const tokens = this.keys();
     const resp = await this.#client.multicall({
-      contracts: tokens.map(
-        (t) => ({
-          address: t,
-          abi: import_iVersion.iVersionAbi,
-          functionName: "contractType"
-        })
+      contracts: tokens.flatMap(
+        (t) => [
+          {
+            address: t,
+            abi: import_iVersion.iVersionAbi,
+            functionName: "contractType"
+          },
+          {
+            address: t,
+            abi: import_iStateSerializer.iStateSerializerAbi,
+            functionName: "serialize"
+          }
+        ]
       ),
       allowFailure: true,
       batchSize: 0
     });
-    for (let i = 0; i < resp.length; i++) {
-      if (resp[i].status === "success") {
-        const contractType = (0, import__.bytes32ToString)(resp[i].result);
-        if (contractType.startsWith("PHANTOM_TOKEN::")) {
-          this.mustGet(tokens[i]).phantomTokenType = contractType;
+    for (let i = 0; i < tokens.length; i++) {
+      this.#overrideTokenMeta(tokens[i], resp[i], resp[i + 1]);
+    }
+    this.#tokenDataLoaded = true;
+  }
+  #overrideTokenMeta(token, contractTypeResp, serializeResp) {
+    const meta = this.mustGet(token);
+    if (contractTypeResp.status === "success") {
+      const contractType = (0, import__.bytes32ToString)(contractTypeResp.result);
+      if (contractType.startsWith("KYC_UNDERLYING::")) {
+        if (serializeResp.status === "success") {
+          this.#overrideKYCUnderlying(meta, contractType, serializeResp.result);
+        } else {
+          throw new Error(
+            `token ${meta.symbol} (${token}) is ${contractType} but serialize failed: ${serializeResp.error}`
+          );
         }
+      } else if (contractType.startsWith("PHANTOM_TOKEN::")) {
+        this.upsert(token, {
+          ...meta,
+          contractType
+        });
       }
-      this.#phantomTokensLoaded.add(tokens[i]);
+    }
+  }
+  #overrideKYCUnderlying(meta, contractType, serialized) {
+    if (contractType === import__.KYC_UNDERLYING_DEFAULT) {
+      const decoded = (0, import_viem.decodeAbiParameters)(
+        [
+          { type: "address", name: "kycFactory" },
+          { type: "address", name: "asset" }
+        ],
+        serialized
+      );
+      this.upsert(meta.addr, {
+        ...meta,
+        contractType,
+        kycFactory: decoded[0],
+        asset: decoded[1]
+      });
+    } else if (contractType === import__.KYC_UNDERLYING_ON_DEMAND) {
+      const decoded = (0, import_viem.decodeAbiParameters)(
+        [
+          { type: "address", name: "kycFactory" },
+          { type: "address", name: "asset" },
+          { type: "address", name: "pool" },
+          { type: "address", name: "liquidityProvider" }
+        ],
+        serialized
+      );
+      this.upsert(meta.addr, {
+        ...meta,
+        contractType,
+        kycFactory: decoded[0],
+        asset: decoded[1],
+        pool: decoded[2],
+        liquidityProvider: decoded[3]
+      });
     }
   }
 }

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

@@ -21,6 +21,7 @@ __reExport(base_exports, require("./Construct.js"), module.exports);
 __reExport(base_exports, require("./PlaceholderContract.js"), module.exports);
 __reExport(base_exports, require("./SDKConstruct.js"), module.exports);
 __reExport(base_exports, require("./TokensMeta.js"), module.exports);
+__reExport(base_exports, require("./token-types.js"), module.exports);
 __reExport(base_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -30,5 +31,6 @@ __reExport(base_exports, require("./types.js"), module.exports);
   ...require("./PlaceholderContract.js"),
   ...require("./SDKConstruct.js"),
   ...require("./TokensMeta.js"),
+  ...require("./token-types.js"),
   ...require("./types.js")
 });

package/dist/cjs/sdk/{constants/phantom-tokens.js → base/token-types.js}

@@ -16,11 +16,13 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var phantom_tokens_exports = {};
-__export(phantom_tokens_exports, {
+var token_types_exports = {};
+__export(token_types_exports, {
+  KYC_UNDERLYING_DEFAULT: () => KYC_UNDERLYING_DEFAULT,
+  KYC_UNDERLYING_ON_DEMAND: () => KYC_UNDERLYING_ON_DEMAND,
   PHANTOM_TOKEN_CONTRACT_TYPES: () => PHANTOM_TOKEN_CONTRACT_TYPES
 });
-module.exports = __toCommonJS(phantom_tokens_exports);
+module.exports = __toCommonJS(token_types_exports);
 const PHANTOM_TOKEN_CONTRACT_TYPES = [
   "PHANTOM_TOKEN::CONVEX",
   "PHANTOM_TOKEN::INFINIFI_UNWIND",
@@ -30,7 +32,11 @@ const PHANTOM_TOKEN_CONTRACT_TYPES = [
   "PHANTOM_TOKEN::STAKING_REWARDS",
   "PHANTOM_TOKEN::UPSHIFT_WITHDRAW"
 ];
+const KYC_UNDERLYING_DEFAULT = "KYC_UNDERLYING::DEFAULT";
+const KYC_UNDERLYING_ON_DEMAND = "KYC_UNDERLYING::ON_DEMAND";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  KYC_UNDERLYING_DEFAULT,
+  KYC_UNDERLYING_ON_DEMAND,
   PHANTOM_TOKEN_CONTRACT_TYPES
 });

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

@@ -21,7 +21,6 @@ __reExport(constants_exports, require("./bot-permissions.js"), module.exports);
 __reExport(constants_exports, require("./math.js"), module.exports);
 __reExport(constants_exports, require("./networks.js"), module.exports);
 __reExport(constants_exports, require("./periphery.js"), module.exports);
-__reExport(constants_exports, require("./phantom-tokens.js"), module.exports);
 __reExport(constants_exports, require("./versions.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -31,6 +30,5 @@ __reExport(constants_exports, require("./versions.js"), module.exports);
   ...require("./math.js"),
   ...require("./networks.js"),
   ...require("./periphery.js"),
-  ...require("./phantom-tokens.js"),
   ...require("./versions.js")
 });

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

@@ -62,6 +62,9 @@ class MarketSuite extends import_base.SDKConstruct {
     this.priceOracle = (0, import_oracle.getOrCreatePriceOracle)(sdk, marketData.priceOracle);
     this.lossPolicy = (0, import_loss_policy.createLossPolicy)(sdk, marketData.lossPolicy);
   }
+  get underlying() {
+    return this.pool.underlying;
+  }
   get dirty() {
     return this.configurator.dirty || this.pool.dirty || this.priceOracle.dirty || this.creditManagers.some((cm) => cm.dirty);
   }

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

@@ -0,0 +1,310 @@
+"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 PoolService_exports = {};
+__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");
+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");
+const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+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);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [underlying.asset];
+      }
+    }
+    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);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [];
+      }
+    }
+    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);
+        }
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return {
+            zapper: void 0,
+            approveTarget: underlying.liquidityProvider,
+            permissible: false
+          };
+      }
+    }
+    return this.depositMetadata(pool, tokenIn, tokenOut, true);
+  }
+  addLiquidity(props) {
+    const { collateral, meta, permit, referralCode, pool, wallet } = props;
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      if (underlying.contractType === import_base.KYC_UNDERLYING_ON_DEMAND) {
+        return void 0;
+      }
+    }
+    const { zapper } = meta;
+    if (zapper?.tokenIn.addr === NATIVE_ADDRESS) {
+      return {
+        target: zapper.baseParams.addr,
+        abi: import_iETHZapperDeposits.iethZapperDepositsAbi,
+        functionName: "depositWithReferral",
+        args: [wallet, referralCode],
+        value: collateral.balance
+      };
+    } else if (zapper) {
+      return permit ? {
+        target: zapper.baseParams.addr,
+        abi: import_iERC20ZapperDeposits.ierc20ZapperDepositsAbi,
+        functionName: "depositWithReferralAndPermit",
+        args: [
+          collateral.balance,
+          wallet,
+          referralCode,
+          permit.deadline,
+          permit.v,
+          permit.r,
+          permit.s
+        ]
+      } : {
+        target: zapper.baseParams.addr,
+        abi: import_iERC20ZapperDeposits.ierc20ZapperDepositsAbi,
+        functionName: "depositWithReferral",
+        args: [collateral.balance, wallet, referralCode]
+      };
+    } else {
+      return {
+        target: pool,
+        abi: import_v300.iPoolV300Abi,
+        functionName: "depositWithReferral",
+        args: [collateral.balance, wallet, referralCode]
+      };
+    }
+  }
+  removeLiquidity(props) {
+    const { pool, amount, account, zapper, permit } = props;
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      if (underlying.contractType === import_base.KYC_UNDERLYING_ON_DEMAND) {
+        return {
+          abi: import_iERC20.ierc20Abi,
+          functionName: "approve",
+          args: [underlying.liquidityProvider, 0n],
+          target: underlying.asset
+        };
+      }
+    }
+    if (zapper) {
+      return permit ? {
+        target: zapper.zapper,
+        abi: import_iZapper.iZapperAbi,
+        functionName: "redeemWithPermit",
+        args: [
+          amount,
+          account,
+          permit.deadline,
+          permit.v,
+          permit.r,
+          permit.s
+        ]
+      } : {
+        target: zapper.zapper,
+        abi: import_iZapper.iZapperAbi,
+        functionName: "redeem",
+        args: [amount, account]
+      };
+    }
+    return {
+      target: pool,
+      abi: import_v300.iPoolV300Abi,
+      functionName: "redeem",
+      args: [amount, account, account]
+    };
+  }
+  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) ?? [];
+    for (const z of zappers) {
+      if ((0, import__.hexEq)(z.tokenOut.addr, poolAddr)) {
+        result.add(z.tokenIn.addr);
+      }
+    }
+    if (result.size === 0) {
+      throw new Error(
+        `No tokensIn found for pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return result.asArray();
+  }
+  depositTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
+    const result = new import__.AddressSet();
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const zappers = this.zappers.get(poolAddr) ?? [];
+    for (const z of zappers) {
+      if ((0, import__.hexEq)(z.tokenIn.addr, tokenIn)) {
+        result.add(z.tokenOut.addr);
+      }
+    }
+    if (allowDirectDeposit && (0, import__.hexEq)(tokenIn, pool.underlying)) {
+      result.add(poolAddr);
+    }
+    if (result.size === 0) {
+      throw new Error(
+        `No tokensOut found for tokenIn ${this.labelAddress(tokenIn)} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return result.asArray();
+  }
+  depositMetadata(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);
+    if (!zapper && !allowDirectDeposit) {
+      throw new Error(
+        `No zapper found for tokenIn ${this.labelAddress(tokenIn)} and tokenOut ${this.labelAddress(tokenOut)} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return {
+      zapper,
+      // zapper or pool itself
+      approveTarget: zapper?.baseParams.addr ?? pool.pool.address,
+      // TODO: instead of permissible, return permitType зависимости от tokenIn
+      // "none" | "eip2612" | "dai_like";
+      permissible: !!zapper && tokenIn !== NATIVE_ADDRESS
+    };
+  }
+  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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PoolService
+});

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

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

package/dist/esm/abi/iStateSerializer.js

@@ -0,0 +1,12 @@
+const iStateSerializerAbi = [
+  {
+    type: "function",
+    inputs: [],
+    name: "serialize",
+    outputs: [{ name: "serializedData", internalType: "bytes", type: "bytes" }],
+    stateMutability: "view"
+  }
+];
+export {
+  iStateSerializerAbi
+};