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

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

@@ -1,16 +1,24 @@
+import {
+  decodeAbiParameters
+} from "viem";
+import { iStateSerializerAbi } from "../../abi/iStateSerializer.js";
 import { iVersionAbi } from "../../abi/iVersion.js";
-import { bytes32ToString } from "../index.js";
-import { AddressMap, AddressSet, formatBN } from "../utils/index.js";
+import {
+  bytes32ToString,
+  KYC_UNDERLYING_DEFAULT,
+  KYC_UNDERLYING_ON_DEMAND
+} from "../index.js";
+import { AddressMap, formatBN } from "../utils/index.js";
 class TokensMeta extends 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;
@@ -18,28 +26,39 @@ class TokensMeta extends 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 AddressMap();
+    for (const [token, meta] of this.entries()) {
+      if (this.isPhantomToken(meta)) {
+        result.upsert(token, meta);
+      }
     }
-    return new AddressMap(
-      this.entries().filter(([_, v]) => !!v.phantomTokenType),
-      "phantomTokens"
-    );
+    return result;
+  }
+  get kycUnderlyings() {
+    const result = new 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;
@@ -60,30 +79,86 @@ class TokensMeta extends 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 AddressSet();
+  async loadTokenData() {
     const tokens = this.keys();
     const resp = await this.#client.multicall({
-      contracts: tokens.map(
-        (t) => ({
-          address: t,
-          abi: iVersionAbi,
-          functionName: "contractType"
-        })
+      contracts: tokens.flatMap(
+        (t) => [
+          {
+            address: t,
+            abi: iVersionAbi,
+            functionName: "contractType"
+          },
+          {
+            address: t,
+            abi: iStateSerializerAbi,
+            functionName: "serialize"
+          }
+        ]
       ),
       allowFailure: true,
       batchSize: 0
     });
-    for (let i = 0; i < resp.length; i++) {
-      if (resp[i].status === "success") {
-        const contractType = 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 = 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 === KYC_UNDERLYING_DEFAULT) {
+      const decoded = 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 === KYC_UNDERLYING_ON_DEMAND) {
+      const decoded = 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/esm/sdk/base/index.js

@@ -4,4 +4,5 @@ export * from "./Construct.js";
 export * from "./PlaceholderContract.js";
 export * from "./SDKConstruct.js";
 export * from "./TokensMeta.js";
+export * from "./token-types.js";
 export * from "./types.js";

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

@@ -7,6 +7,10 @@ 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";
 export {
+  KYC_UNDERLYING_DEFAULT,
+  KYC_UNDERLYING_ON_DEMAND,
   PHANTOM_TOKEN_CONTRACT_TYPES
 };

package/dist/esm/sdk/chain/chains.js

@@ -62,7 +62,8 @@ const chains = {
         "0x7a133fbd01736fd076158307c9476cc3877f1af5": "Invariant Group",
         "0x09d8305F49374AEA6A78aF6C996df2913e8f3b19": "Tulipa",
         "0x1b265b97eb169fb6668e3258007c3b0242c7bdbe": "kpk",
-        "0x9dddd1b9ce0ac8aa0c80e4ec141600b9bf0101c3": "Edge UltraYield"
+        "0x9dddd1b9ce0ac8aa0c80e4ec141600b9bf0101c3": "Edge UltraYield",
+        "0x601067eba24bb5b558a184fc082525637e96a42d": "Gami Labs"
       },
       testMarketConfigurators: {
         "0x99df7330bf42d596af2e9d9836d4fc2077c574aa": "M11 Credit"

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

@@ -4,5 +4,4 @@ export * from "./bot-permissions.js";
 export * from "./math.js";
 export * from "./networks.js";
 export * from "./periphery.js";
-export * from "./phantom-tokens.js";
 export * from "./versions.js";

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

@@ -41,6 +41,9 @@ class MarketSuite extends SDKConstruct {
     this.priceOracle = getOrCreatePriceOracle(sdk, marketData.priceOracle);
     this.lossPolicy = 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/esm/sdk/pools/PoolService.js

@@ -0,0 +1,296 @@
+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";
+import { iZapperAbi } from "../../abi/iZapper.js";
+import { iPoolV300Abi } from "../../abi/v300.js";
+import {
+  KYC_UNDERLYING_DEFAULT,
+  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";
+const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+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);
+        case 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 KYC_UNDERLYING_DEFAULT:
+          return this.depositTokensOut(pool, tokenIn, false);
+        case 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 KYC_UNDERLYING_DEFAULT: {
+          return this.depositMetadata(pool, tokenIn, tokenOut, false);
+        }
+        case 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 === KYC_UNDERLYING_ON_DEMAND) {
+        return void 0;
+      }
+    }
+    const { zapper } = meta;
+    if (zapper?.tokenIn.addr === NATIVE_ADDRESS) {
+      return {
+        target: zapper.baseParams.addr,
+        abi: iethZapperDepositsAbi,
+        functionName: "depositWithReferral",
+        args: [wallet, referralCode],
+        value: collateral.balance
+      };
+    } else if (zapper) {
+      return permit ? {
+        target: zapper.baseParams.addr,
+        abi: ierc20ZapperDepositsAbi,
+        functionName: "depositWithReferralAndPermit",
+        args: [
+          collateral.balance,
+          wallet,
+          referralCode,
+          permit.deadline,
+          permit.v,
+          permit.r,
+          permit.s
+        ]
+      } : {
+        target: zapper.baseParams.addr,
+        abi: ierc20ZapperDepositsAbi,
+        functionName: "depositWithReferral",
+        args: [collateral.balance, wallet, referralCode]
+      };
+    } else {
+      return {
+        target: pool,
+        abi: 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 === KYC_UNDERLYING_ON_DEMAND) {
+        return {
+          abi: ierc20Abi,
+          functionName: "approve",
+          args: [underlying.liquidityProvider, 0n],
+          target: underlying.asset
+        };
+      }
+    }
+    if (zapper) {
+      return permit ? {
+        target: zapper.zapper,
+        abi: iZapperAbi,
+        functionName: "redeemWithPermit",
+        args: [
+          amount,
+          account,
+          permit.deadline,
+          permit.v,
+          permit.r,
+          permit.s
+        ]
+      } : {
+        target: zapper.zapper,
+        abi: iZapperAbi,
+        functionName: "redeem",
+        args: [amount, account]
+      };
+    }
+    return {
+      target: pool,
+      abi: iPoolV300Abi,
+      functionName: "redeem",
+      args: [amount, account, account]
+    };
+  }
+  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) ?? [];
+    for (const z of zappers) {
+      if (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 AddressSet();
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const zappers = this.zappers.get(poolAddr) ?? [];
+    for (const z of zappers) {
+      if (hexEq(z.tokenIn.addr, tokenIn)) {
+        result.add(z.tokenOut.addr);
+      }
+    }
+    if (allowDirectDeposit && 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) => 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);
+  }
+}
+export {
+  PoolService
+};

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

@@ -1,3 +1,2 @@
-export * from "./AbstractPoolService.js";
-export * from "./createPoolService.js";
+export * from "./PoolService.js";
 export * from "./types.js";

package/dist/types/abi/iStateSerializer.d.ts

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

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

@@ -1,40 +1,31 @@
-import type { Address, Chain, PublicClient, Transport } from "viem";
-import { type PhantomTokenContractType } from "../index.js";
+import { type Address, type Chain, type PublicClient, type Transport } from "viem";
 import type { Asset } from "../router/index.js";
 import { AddressMap } from "../utils/index.js";
-import type { TokenMetaData } from "./types.js";
+import type { KYCTokenMeta, PhantomTokenMeta, TokenMetaData } from "./token-types.js";
 export interface FormatBNOptions {
     precision?: number;
     symbol?: boolean;
 }
-export interface TokenMetaDataExtended extends TokenMetaData {
-    /**
-     * Undefined if token is not a phantom token
-     */
-    phantomTokenType?: PhantomTokenContractType;
-}
-export declare class TokensMeta extends AddressMap<TokenMetaDataExtended> {
+export declare class TokensMeta extends AddressMap<TokenMetaData> {
     #private;
     constructor(client: PublicClient<Transport, Chain>);
     reset(): void;
     symbol(token: Address): string;
     decimals(token: Address): number;
-    /**
-     * 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: Address): PhantomTokenContractType | undefined;
+    isPhantomToken(t: TokenMetaData): t is PhantomTokenMeta;
+    isKYCUnderlying(t: TokenMetaData): t is KYCTokenMeta;
     /**
      * Returns a map of all phantom tokens
      * Throws if the phantom token data is not loaded
      */
-    get phantomTokens(): AddressMap<TokenMetaDataExtended>;
+    get phantomTokens(): AddressMap<PhantomTokenMeta>;
+    get kycUnderlyings(): AddressMap<KYCTokenMeta>;
     formatBN(asset: Asset, options?: FormatBNOptions): string;
     formatBN(token: Address, amount: number | bigint | string | undefined, options?: FormatBNOptions): string;
     findBySymbol(symbol: string): TokenMetaData | undefined;
     mustFindBySymbol(symbol: string): TokenMetaData;
     /**
-     * Loads phantom token data for all known tokens from chain
+     * Loads token information about phantom token and KYC underlying tokens
      */
-    loadPhantomTokens(): Promise<void>;
+    loadTokenData(): Promise<void>;
 }

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

@@ -4,4 +4,5 @@ export * from "./Construct.js";
 export * from "./PlaceholderContract.js";
 export * from "./SDKConstruct.js";
 export * from "./TokensMeta.js";
+export * from "./token-types.js";
 export * from "./types.js";

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

@@ -0,0 +1,25 @@
+import type { Address } from "viem";
+import type { MarketData, Unarray } from "./types.js";
+export type SimpleTokenMeta = Unarray<MarketData["tokens"]>;
+export declare const PHANTOM_TOKEN_CONTRACT_TYPES: readonly ["PHANTOM_TOKEN::CONVEX", "PHANTOM_TOKEN::INFINIFI_UNWIND", "PHANTOM_TOKEN::INFRARED", "PHANTOM_TOKEN::MELLOW_WITHDRAWAL", "PHANTOM_TOKEN::MIDAS_REDEMPTION", "PHANTOM_TOKEN::STAKING_REWARDS", "PHANTOM_TOKEN::UPSHIFT_WITHDRAW"];
+export declare const KYC_UNDERLYING_DEFAULT = "KYC_UNDERLYING::DEFAULT";
+export declare const KYC_UNDERLYING_ON_DEMAND = "KYC_UNDERLYING::ON_DEMAND";
+export type KYCUnderlyingContractType = typeof KYC_UNDERLYING_DEFAULT | typeof KYC_UNDERLYING_ON_DEMAND;
+export type PhantomTokenContractType = (typeof PHANTOM_TOKEN_CONTRACT_TYPES)[number];
+export type PhantomTokenMeta = SimpleTokenMeta & {
+    contractType: PhantomTokenContractType;
+};
+export type KYCDefaultTokenMeta = SimpleTokenMeta & {
+    contractType: typeof KYC_UNDERLYING_DEFAULT;
+    kycFactory: Address;
+    asset: Address;
+};
+export type KYCOnDemandTokenMeta = SimpleTokenMeta & {
+    contractType: typeof KYC_UNDERLYING_ON_DEMAND;
+    kycFactory: Address;
+    asset: Address;
+    pool: Address;
+    liquidityProvider: Address;
+};
+export type KYCTokenMeta = KYCDefaultTokenMeta | KYCOnDemandTokenMeta;
+export type TokenMetaData = SimpleTokenMeta | PhantomTokenMeta | KYCTokenMeta;

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

@@ -26,7 +26,6 @@ export type CreditManagerState = CreditSuiteState["creditManager"];
 export type CreditFacadeState = CreditSuiteState["creditFacade"];
 export type CreditConfiguratorState = CreditSuiteState["creditConfigurator"];
 export type AdapterData = Unarray<CreditSuiteState["adapters"]>;
-export type TokenMetaData = Unarray<MarketData["tokens"]>;
 export type PoolState = MarketData["pool"];
 export type QuotaKeeperState = MarketData["quotaKeeper"];
 export type QuotaState = Unarray<QuotaKeeperState["quotas"]>;

package/dist/types/sdk/chain/chains.d.ts

@@ -1,6 +1,6 @@
 import type { Address, Chain } from "viem";
 import { z } from "zod/v4";
-export type Curator = "Chaos Labs" | "K3" | "cp0x" | "Re7" | "Invariant Group" | "Tulipa" | "M11 Credit" | "kpk" | "Hyperithm" | "Edge UltraYield" | "TelosC";
+export type Curator = "Chaos Labs" | "K3" | "cp0x" | "Re7" | "Invariant Group" | "Tulipa" | "M11 Credit" | "kpk" | "Hyperithm" | "Edge UltraYield" | "TelosC" | "Gami Labs";
 export interface GearboxChain extends Chain {
     network: NetworkType;
     defaultMarketConfigurators: Record<Address, Curator>;

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

@@ -4,5 +4,4 @@ export * from "./bot-permissions.js";
 export * from "./math.js";
 export * from "./networks.js";
 export * from "./periphery.js";
-export * from "./phantom-tokens.js";
 export * from "./versions.js";

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

@@ -21,6 +21,7 @@ export declare class MarketSuite extends SDKConstruct {
      */
     readonly state: MarketData;
     constructor(sdk: GearboxSDK, marketData: MarketData);
+    get underlying(): Address;
     get dirty(): boolean;
     get watchAddresses(): Set<Address>;
     stateHuman(raw?: boolean): MarketStateHuman;