@gearbox-protocol/sdk 13.4.0 → 13.5.0-next.1

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

@@ -1,3 +1,10 @@
+import {
+  decodeAbiParameters,
+  erc20Abi
+} from "viem";
+import { iSecuritizeDegenNFTAbi } from "../../abi/310/iSecuritizeDegenNFT.js";
+import { iSecuritizeKYCFactoryAbi } from "../../abi/310/iSecuritizeKYCFactory.js";
+import { iStateSerializerAbi } from "../../abi/iStateSerializer.js";
 import { iVersionAbi } from "../../abi/iVersion.js";
 import {
   AddressMap,
@@ -5,19 +12,36 @@ import {
   bytes32ToString,
   formatBN
 } from "../utils/index.js";
+import {
+  KYC_UNDERLYING_DEFAULT,
+  KYC_UNDERLYING_ON_DEMAND
+} from "./token-types.js";
 class TokensMeta extends AddressMap {
   #client;
-  #phantomTokensLoaded;
-  constructor(client) {
+  #tokenDataLoaded = new AddressSet();
+  #logger;
+  constructor(client, logger) {
     super(void 0, "tokensMeta");
     this.#client = client;
+    this.#logger = logger?.child?.({ name: "TokensMeta" }) ?? logger;
   }
   /**
    * Clears all token metadata
    **/
   reset() {
     this.clear();
-    this.#phantomTokensLoaded = void 0;
+    this.#tokenDataLoaded.clear();
+  }
+  upsert(address, value) {
+    let v = value;
+    const existing = this.get(address);
+    if (existing && v) {
+      v = {
+        ...existing,
+        ...v
+      };
+    }
+    super.upsert(address, v);
   }
   /**
    * Returns the symbol string for a token.
@@ -36,27 +60,78 @@ class TokensMeta extends AddressMap {
     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
+   * Returns true if the token is a phantom token, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
+  isPhantomToken(t) {
+    if (!this.#tokenDataLoaded.has(t.addr)) {
+      throw new Error(
+        `extended token data not loaded for ${t.symbol} (${t.addr})`
+      );
+    }
+    return !!t.contractType?.startsWith("PHANTOM_TOKEN::");
+  }
+  /**
+   * Returns true if the token is a KYC underlying token, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
+  isKYCUnderlying(t) {
+    if (!this.#tokenDataLoaded.has(t.addr)) {
+      throw new Error(
+        `extended token data not loaded for ${t.symbol} (${t.addr})`
+      );
+    }
+    return !!t.contractType?.startsWith("KYC_UNDERLYING::");
+  }
+  /**
+   * Returns true if the token is a DSToken, throws if the token data is not loaded
+   * @param t
+   * @returns
    */
-  phantomTokenType(token) {
-    if (!this.#phantomTokensLoaded?.has(token)) {
-      throw new Error("phantom token data not loaded");
+  isDSToken(t) {
+    if (!this.#tokenDataLoaded.has(t.addr)) {
+      throw new Error(
+        `extended token data not loaded for ${t.symbol} (${t.addr})`
+      );
     }
-    return this.mustGet(token).phantomTokenType;
+    return !!t.isDSToken;
   }
   /**
    * Returns a map of all phantom tokens
-   * Throws if the phantom token data is not loaded
+   * Throws if token data is not loaded
    */
   get phantomTokens() {
-    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;
+  }
+  /**
+   * Returns a map of all KYC underlying tokens
+   * Throws if token data is not loaded
+   */
+  get kycUnderlyings() {
+    const result = new AddressMap();
+    for (const [token, meta] of this.entries()) {
+      if (this.isKYCUnderlying(meta)) {
+        result.upsert(token, meta);
+      }
+    }
+    return result;
+  }
+  get dsTokens() {
+    const result = new AddressMap();
+    for (const [token, meta] of this.entries()) {
+      if (this.isDSToken(meta)) {
+        result.upsert(token, meta);
+      }
+    }
+    return result;
   }
   formatBN(arg0, arg1, arg2) {
     const token = typeof arg0 === "object" ? arg0.token : arg0;
@@ -87,30 +162,184 @@ class TokensMeta extends AddressMap {
     return meta;
   }
   /**
-   * Loads phantom token data for all known tokens from chain
+   * Loads token information about phantom tokens, KYC underlying tokens and DSTokens
+   *
+   * @param tokens - tokens to load data for, defaults to all tokens
    */
-  async loadPhantomTokens() {
-    this.#phantomTokensLoaded = new AddressSet();
-    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.map(
-        (t) => ({
-          address: t,
-          abi: iVersionAbi,
-          functionName: "contractType"
-        })
+      contracts: tokensToLoad.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;
+    this.#logger?.debug(`loaded ${resp.length} contract types`);
+    const kycFactories = new AddressSet();
+    for (let i = 0; i < tokensToLoad.length; i++) {
+      const meta = this.#overrideTokenMeta(
+        tokensToLoad[i],
+        resp[2 * i],
+        resp[2 * i + 1]
+      );
+      this.#tokenDataLoaded.add(tokensToLoad[i]);
+      if (this.isKYCUnderlying(meta)) {
+        kycFactories.add(meta.kycFactory);
+      }
+    }
+    this.#logger?.debug(`found ${kycFactories.size} KYC factories`);
+    await this.#loadDSTokens(kycFactories);
+  }
+  #overrideTokenMeta(token, contractTypeResp, serializeResp) {
+    const meta = this.mustGet(token);
+    if (contractTypeResp.status === "success") {
+      const contractType = 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 {
+        this.upsert(token, {
+          ...meta,
+          contractType
+        });
       }
-      this.#phantomTokensLoaded.add(tokens[i]);
+      this.#logger?.debug(`token ${meta.symbol} is ${contractType}`);
+    }
+    return this.mustGet(token);
+  }
+  #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]
+      });
+    }
+  }
+  async #loadDSTokens(kycFactories) {
+    const degenNFTs = await this.#client.multicall({
+      contracts: kycFactories.map((address) => {
+        return {
+          address,
+          abi: iSecuritizeKYCFactoryAbi,
+          functionName: "getDegenNFT"
+        };
+      }),
+      allowFailure: false,
+      batchSize: 0
+    });
+    const resp = await this.#client.multicall({
+      contracts: degenNFTs.map((address) => {
+        return {
+          address,
+          abi: iSecuritizeDegenNFTAbi,
+          functionName: "getDSTokens"
+        };
+      }),
+      allowFailure: false,
+      batchSize: 0
+    });
+    const dsToken = new AddressSet(resp.flat());
+    const tokensToLoad = dsToken.difference(new Set(this.keys()));
+    this.#logger?.debug(
+      `found ${dsToken.size} DSTokens in KYC factories, need to load ${tokensToLoad.size} basic metadata`
+    );
+    await this.#loadWithoutCompressor(tokensToLoad);
+    for (const token of dsToken) {
+      const meta = this.mustGet(token);
+      this.upsert(token, {
+        ...meta,
+        isDSToken: true
+      });
+      this.#tokenDataLoaded.add(token);
+      this.#logger?.debug(`token ${meta.symbol} (${token}) is a DSToken`);
+    }
+  }
+  async #loadWithoutCompressor(tokens_) {
+    if (tokens_.size === 0) {
+      return;
+    }
+    const tokens = Array.from(tokens_);
+    const resp = await this.#client.multicall({
+      contracts: tokens.flatMap(
+        (t) => [
+          {
+            address: t,
+            abi: erc20Abi,
+            functionName: "symbol"
+          },
+          {
+            address: t,
+            abi: erc20Abi,
+            functionName: "name"
+          },
+          {
+            address: t,
+            abi: erc20Abi,
+            functionName: "decimals"
+          }
+        ]
+      ),
+      allowFailure: false,
+      batchSize: 0
+    });
+    this.#logger?.debug(
+      `loaded ${resp.length} basic metadata without compressor`
+    );
+    for (let i = 0; i < tokens.length; i++) {
+      this.upsert(tokens[i], {
+        addr: tokens[i],
+        symbol: resp[3 * i],
+        name: resp[3 * i + 1],
+        decimals: resp[3 * i + 2]
+      });
     }
   }
 }

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

@@ -5,4 +5,5 @@ export * from "./errors.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

@@ -65,7 +65,8 @@ const chains = {
         "0x601067eba24bb5b558a184fc082525637e96a42d": "Gami Labs"
       },
       testMarketConfigurators: {
-        "0x99df7330bf42d596af2e9d9836d4fc2077c574aa": "M11 Credit"
+        "0x99df7330bf42d596af2e9d9836d4fc2077c574aa": "M11 Credit",
+        "0xE0527dE5908B3fc2e054B7eEE0DeF6c9965AbF24": "Securitize"
       },
       isPublic: true,
       wellKnownToken: {

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/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,11 @@ 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
+   */
   #markets = new AddressMap(void 0, "markets");
   #marketFilter;
   #marketConfigurators = new AddressMap(

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

@@ -41,6 +41,12 @@ class MarketSuite extends SDKConstruct {
     this.priceOracle = createPriceOracle(sdk, marketData.priceOracle);
     this.lossPolicy = createLossPolicy(sdk, marketData.lossPolicy);
   }
+  get underlying() {
+    return this.pool.underlying;
+  }
+  async getKYCFactory() {
+    return this.pool.getKYCFactory();
+  }
   get dirty() {
     return this.configurator.dirty || this.pool.dirty || this.priceOracle.dirty || this.creditManagers.some((cm) => cm.dirty);
   }

package/dist/esm/{plugins/zappers/extraZappers.js → sdk/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/market/pool/PoolSuite.js

@@ -55,6 +55,9 @@ class PoolSuite extends SDKConstruct {
   get underlying() {
     return this.pool.underlying;
   }
+  async getKYCFactory() {
+    return this.pool.getKYCFactory();
+  }
   get dirty() {
     return this.pool.dirty || this.rateKeeper.dirty || this.pqk.dirty || this.interestRateModel.dirty;
   }

package/dist/esm/sdk/market/pool/PoolV310Contract.js

@@ -7,16 +7,20 @@ import {
   formatBNvalue,
   percentFmt
 } from "../../utils/index.js";
+import { SecuritizeKYCFactory } from "./SecuritizeKYCFactory.js";
 const abi = [...iPoolV310Abi, ...iPausableAbi];
 class PoolV310Contract extends BaseContract {
   creditManagerDebtParams;
-  constructor(options, data) {
+  #sdk;
+  #kycFactory;
+  constructor(sdk, data) {
     const { baseParams, creditManagerDebtParams, ...rest } = data;
-    super(options, {
+    super(sdk, {
       ...data.baseParams,
       name: `PoolV3(${data.name})`,
       abi
     });
+    this.#sdk = sdk;
     Object.assign(this, rest);
     this.creditManagerDebtParams = new AddressMap(
       creditManagerDebtParams.map((p) => [p.creditManager, p])
@@ -28,6 +32,17 @@ class PoolV310Contract extends BaseContract {
       symbol: data.symbol
     });
   }
+  async getKYCFactory() {
+    if (this.#kycFactory) {
+      return this.#kycFactory;
+    }
+    await this.#sdk.tokensMeta.loadTokenData(this.underlying);
+    const u = this.#sdk.tokensMeta.mustGet(this.underlying);
+    if (this.#sdk.tokensMeta.isKYCUnderlying(u)) {
+      this.#kycFactory = new SecuritizeKYCFactory(this.#sdk, u.kycFactory);
+    }
+    return this.#kycFactory;
+  }
   stateHuman(raw = true) {
     return {
       ...super.stateHuman(raw),

package/dist/esm/sdk/market/pool/SecuritizeKYCFactory.js

@@ -0,0 +1,73 @@
+import { iSecuritizeDegenNFTAbi } from "../../../abi/310/iSecuritizeDegenNFT.js";
+import { iSecuritizeKYCFactoryAbi } from "../../../abi/310/iSecuritizeKYCFactory.js";
+import { BaseContract } from "../../base/index.js";
+import { AddressMap } from "../../index.js";
+const abi = iSecuritizeKYCFactoryAbi;
+class SecuritizeKYCFactory extends BaseContract {
+  investorCache;
+  #degenNFT;
+  constructor(options, address) {
+    super(options, {
+      addr: address,
+      name: "SecuritizeKYCFactory",
+      abi
+    });
+  }
+  async precomputeWalletAddress(creditManager, investor) {
+    return this.contract.read.precomputeWalletAddress([
+      creditManager,
+      investor
+    ]);
+  }
+  async getWallet(creditAccount) {
+    return this.contract.read.getWallet([creditAccount]);
+  }
+  /**
+   * Returns the investor address for a credit account.
+   * @param creditAccount - Credit account address
+   * @param fromCache - If true, use and update an in-memory cache (creditAccount -> investor). On cache miss, loads from contract and stores the result for future calls.
+   */
+  async getInvestor(creditAccount, fromCache) {
+    if (fromCache && this.investorCache?.has(creditAccount)) {
+      return this.investorCache.get(creditAccount);
+    }
+    const investor = await this.contract.read.getInvestor([creditAccount]);
+    if (fromCache) {
+      if (!this.investorCache) {
+        this.investorCache = new AddressMap();
+      }
+      this.investorCache.upsert(creditAccount, investor);
+    }
+    return investor;
+  }
+  async getDSTokens() {
+    const degenNFT = await this.getDegenNFT();
+    const tokens = await this.client.readContract({
+      address: degenNFT,
+      abi: iSecuritizeDegenNFTAbi,
+      functionName: "getDSTokens"
+    });
+    return [...tokens];
+  }
+  multicall(creditAccount, calls, tokensToRegister) {
+    return this.createRawTx({
+      functionName: "multicall",
+      args: [creditAccount, calls, tokensToRegister]
+    });
+  }
+  openCreditAccount(creditManager, calls, tokensToRegister) {
+    return this.createRawTx({
+      functionName: "openCreditAccount",
+      args: [creditManager, calls, tokensToRegister]
+    });
+  }
+  async getDegenNFT() {
+    if (!this.#degenNFT) {
+      this.#degenNFT = await this.contract.read.getDegenNFT();
+    }
+    return this.#degenNFT;
+  }
+}
+export {
+  SecuritizeKYCFactory
+};

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

@@ -1,4 +1,6 @@
 export * from "./GaugeContract.js";
 export * from "./LinearInterestRateModelContract.js";
 export * from "./PoolSuite.js";
+export * from "./PoolV310Contract.js";
+export * from "./SecuritizeKYCFactory.js";
 export * from "./types.js";