@gearbox-protocol/sdk 14.0.0 → 14.1.0

package/dist/esm/sdk/market/kyc/KYCRegistry.js

@@ -0,0 +1,253 @@
+import { decodeAbiParameters } from "viem";
+import { iKYCCompressorAbi } from "../../../abi/kyc/iKYCCompressor.js";
+import {
+  KYC_ON_DEMAND_LP_MONOPOLIZED,
+  KYC_UNDERLYING_DEFAULT,
+  KYC_UNDERLYING_ON_DEMAND,
+  SDKConstruct
+} from "../../base/index.js";
+import { AP_KYC_COMPRESSOR, VERSION_RANGE_310 } from "../../constants/index.js";
+import { AddressMap, bytes32ToString } from "../../utils/index.js";
+import {
+  KYC_FACTORY_SECURITIZE,
+  SecuritizeKYCFactory
+} from "./securitize/index.js";
+class KYCRegistry extends SDKConstruct {
+  #state;
+  #factories = new AddressMap();
+  /**
+   * @internal
+   *
+   * Returns delegated multicalls for loading all KYC underlying tokens from the on-chain KYC compressor.
+   * Used by the SDK to compose batched RPC calls.
+   *
+   * @param configurators - Market configurators to query.
+   * @param kycFactories - KYC factory contracts to query.
+   */
+  getLoadMulticalls(configurators, kycFactories = []) {
+    if (!kycFactories.length) return [];
+    const [kycCompressorAddress] = this.sdk.addressProvider.mustGetLatest(
+      AP_KYC_COMPRESSOR,
+      VERSION_RANGE_310
+    );
+    return [
+      {
+        call: {
+          abi: iKYCCompressorAbi,
+          address: kycCompressorAddress,
+          functionName: "getKYCMarketsData",
+          args: [configurators, kycFactories]
+        },
+        onResult: (resp) => this.setState(resp)
+      }
+    ];
+  }
+  /**
+   * Fetches decoded investor data from the on-chain KYC compressor.
+   *
+   * Each factory produces its own investor data (e.g. registered tokens,
+   * cached signatures, EIP-712 messages to sign).
+   *
+   * @param investor - Investor EOA address.
+   * @param factories_ - Optional subset of factory addresses to query.
+   *   When omitted, all loaded factories are used.
+   */
+  async getInvestorData(investor, factories_) {
+    const [kycCompressorAddress] = this.sdk.addressProvider.mustGetLatest(
+      AP_KYC_COMPRESSOR,
+      VERSION_RANGE_310
+    );
+    let factories = this.#factories.values();
+    if (factories_?.length) {
+      factories = factories_.map((f) => this.#factories.mustGet(f));
+    }
+    const resp = await this.client.readContract({
+      abi: iKYCCompressorAbi,
+      address: kycCompressorAddress,
+      functionName: "getKYCInvestorData",
+      args: [investor, factories.map((f) => f.address)]
+    });
+    const result = [];
+    for (let i = 0; i < factories.length; i++) {
+      const factory = factories[i];
+      const factoryData = resp[i];
+      const investorData = factory.decodeInvestorData(factoryData);
+      result.push(investorData);
+    }
+    return result;
+  }
+  /** All loaded KYC factory instances. */
+  get factories() {
+    return this.#factories.values();
+  }
+  /** Raw KYC compressor response, or `undefined` before attach/hydrate. */
+  get state() {
+    return this.#state;
+  }
+  /**
+   * Returns a human-readable snapshot of the KYC state.
+   */
+  stateHuman(raw) {
+    return {
+      factories: this.factories.map((f) => f.stateHuman(raw))
+    };
+  }
+  /**
+   * @internal
+   *
+   * Replaces the internal state with a new KYC compressor response.
+   * Rebuilds token metadata for KYC underlyings and re-instantiates factory
+   * wrappers.
+   */
+  setState(resp) {
+    this.#state = resp;
+    for (const u of resp?.[0] ?? []) {
+      this.#loadUnderlyingTokenData(u);
+    }
+    this.#factories.clear();
+    for (const f of resp?.[1] ?? []) {
+      this.#loadKYCFactoryData(f);
+    }
+  }
+  #loadUnderlyingTokenData(u) {
+    const contractType = bytes32ToString(u.baseParams.contractType);
+    const meta = this.tokensMeta.get(u.baseParams.addr);
+    if (!meta) {
+      throw new Error(
+        `KYC underlying token ${contractType} (${u.baseParams.addr}) not found in tokensMeta`
+      );
+    }
+    switch (contractType) {
+      case KYC_UNDERLYING_DEFAULT:
+        this.#loadKYCUnderlyingDefault(meta, u);
+        break;
+      case KYC_UNDERLYING_ON_DEMAND:
+        this.#loadKYCUnderlyingOnDemand(meta, u);
+        break;
+      default:
+        if (this.sdk.strictContractTypes) {
+          throw new Error(`Unknown KYC underlying type: ${contractType}`);
+        }
+        this.logger?.warn(`unknown KYC underlying type: ${contractType}`);
+    }
+  }
+  #loadKYCUnderlyingDefault(meta, data) {
+    const decoded = decodeAbiParameters(
+      [
+        { name: "factory", type: "address" },
+        { name: "asset", type: "address" }
+      ],
+      data.baseParams.serializedParams
+    );
+    this.tokensMeta.upsert(data.baseParams.addr, {
+      ...meta,
+      contractType: KYC_UNDERLYING_DEFAULT,
+      kycFactory: decoded[0],
+      asset: decoded[1]
+    });
+  }
+  #loadKYCUnderlyingOnDemand(meta, data) {
+    const decoded = decodeAbiParameters(
+      [
+        { name: "factory", type: "address" },
+        { name: "asset", type: "address" },
+        { name: "pool", type: "address" },
+        { name: "liquidityProvider", type: "address" },
+        { name: "marketConfigurator", type: "address" },
+        { name: "allowedDepositors", type: "address[]" }
+      ],
+      data.baseParams.serializedParams
+    );
+    const lpMeta = this.#getOnDemandLPMeta(data.extraDetails);
+    if (decoded[3] !== lpMeta.addr) {
+      throw new Error(
+        `Liquidity provider mismatch: ${decoded[3]} !== ${lpMeta.addr} for on-demand underlying ${data.baseParams.addr}`
+      );
+    }
+    this.tokensMeta.upsert(data.baseParams.addr, {
+      ...meta,
+      contractType: KYC_UNDERLYING_ON_DEMAND,
+      kycFactory: decoded[0],
+      asset: decoded[1],
+      pool: decoded[2],
+      marketConfigurator: decoded[4],
+      allowedDepositors: decoded[5],
+      // liquidityProvider: decoded[3],
+      liquidityProvider: lpMeta
+    });
+  }
+  #getOnDemandLPMeta(extraDetails) {
+    const [decoded] = decodeAbiParameters(
+      [
+        {
+          name: "baseParams",
+          type: "tuple",
+          components: [
+            { name: "addr", type: "address" },
+            { name: "version", type: "uint256" },
+            { name: "contractType", type: "bytes32" },
+            { name: "serializedParams", type: "bytes" }
+          ]
+        }
+      ],
+      extraDetails
+    );
+    const contractType = bytes32ToString(decoded.contractType);
+    switch (contractType) {
+      case KYC_ON_DEMAND_LP_MONOPOLIZED:
+        return this.#getOnDemandLPMonopolizedMeta(
+          decoded.addr,
+          decoded.version,
+          decoded.serializedParams
+        );
+      default:
+        throw new Error(`Unknown on-demand LP contract type: ${contractType}`);
+    }
+  }
+  #getOnDemandLPMonopolizedMeta(addr, version, serializedParams) {
+    const [marketConfigurator, depositor, pools] = decodeAbiParameters(
+      [
+        { name: "marketConfigurator", type: "address" },
+        { name: "depositor", type: "address" },
+        {
+          name: "pools",
+          type: "tuple[]",
+          components: [
+            { name: "pool", type: "address" },
+            { name: "wrappedUnderlying", type: "address" },
+            { name: "unwrappedUnderlying", type: "address" },
+            { name: "depositAllowance", type: "uint256" },
+            { name: "claimableAmount", type: "uint256" }
+          ]
+        }
+      ],
+      serializedParams
+    );
+    return {
+      addr,
+      version,
+      contractType: KYC_ON_DEMAND_LP_MONOPOLIZED,
+      marketConfigurator,
+      depositor,
+      pools: [...pools]
+    };
+  }
+  #loadKYCFactoryData(data) {
+    const contractType = bytes32ToString(data.baseParams.contractType);
+    switch (contractType) {
+      case KYC_FACTORY_SECURITIZE:
+        this.#factories.upsert(
+          data.baseParams.addr,
+          new SecuritizeKYCFactory(this.sdk, data)
+        );
+        break;
+      default:
+        throw new Error(
+          `Unknown KYC factory type: ${contractType} for ${data.baseParams.addr}`
+        );
+    }
+  }
+}
+export {
+  KYCRegistry
+};

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

@@ -0,0 +1,3 @@
+export * from "./KYCRegistry.js";
+export * from "./securitize/index.js";
+export * from "./types.js";

package/dist/esm/sdk/market/kyc/securitize/SecuritizeKYCFactory.js

@@ -0,0 +1,218 @@
+import { decodeAbiParameters } from "viem";
+import { iSecuritizeKYCFactoryAbi } from "../../../../abi/kyc/iSecuritizeKYCFactory.js";
+import { BaseContract } from "../../../base/index.js";
+import { AddressMap, AddressSet } from "../../../utils/index.js";
+import { KYC_FACTORY_SECURITIZE } from "./constants.js";
+const abi = iSecuritizeKYCFactoryAbi;
+class SecuritizeKYCFactory extends BaseContract {
+  #sdk;
+  #investorCache = new AddressMap();
+  degenNFT;
+  owner;
+  dsTokens;
+  contractType = KYC_FACTORY_SECURITIZE;
+  constructor(sdk, data) {
+    super(sdk, {
+      ...data.baseParams,
+      name: "SecuritizeKYCFactory",
+      abi
+    });
+    this.#sdk = sdk;
+    const decoded = decodeAbiParameters(
+      [
+        { name: "owner", type: "address" },
+        { name: "degenNFT", type: "address" },
+        {
+          name: "dsTokensData",
+          type: "tuple[]",
+          components: [
+            { name: "token", type: "address" },
+            { name: "registrar", type: "address" },
+            { name: "operators", type: "address[]" }
+          ]
+        }
+      ],
+      data.baseParams.serializedParams
+    );
+    this.owner = decoded[0];
+    this.degenNFT = decoded[1];
+    for (const t of data.tokens) {
+      this.tokensMeta.upsert(t.addr, t);
+    }
+    this.dsTokens = decoded[2].map((t) => ({
+      address: t.token,
+      registrar: t.registrar,
+      operators: [...t.operators]
+    }));
+  }
+  /**
+   * {@inheritDoc IKYCFactory.decodeInvestorData}
+   */
+  decodeInvestorData(data) {
+    const { creditAccounts, extraDetails } = data;
+    const [registeredTokens, cachedSignatures, registerVaultMessages] = decodeAbiParameters(
+      [
+        { name: "registeredTokens", type: "address[]" },
+        {
+          name: "cachedSignatures",
+          type: "tuple[]",
+          components: [...registerMessageTuple]
+        },
+        {
+          name: "registerVaultMessages",
+          type: "tuple[]",
+          components: [...registerVaultMessageTuple]
+        }
+      ],
+      extraDetails
+    );
+    return {
+      type: KYC_FACTORY_SECURITIZE,
+      factory: this.address,
+      cachedSignatures: [...cachedSignatures],
+      registerVaultMessages: [...registerVaultMessages],
+      registeredTokens: [...registeredTokens],
+      creditAccounts: creditAccounts.map((ca) => {
+        const [registeredTokens2] = decodeAbiParameters(
+          [{ name: "registeredTokens", type: "address[]" }],
+          ca.extraDetails
+        );
+        return {
+          ...ca,
+          registeredTokens: [...registeredTokens2]
+        };
+      })
+    };
+  }
+  /**
+   * {@inheritDoc IKYCFactory.getInvestor}
+   */
+  async getInvestor(creditAccount, fromCache) {
+    if (fromCache && this.#investorCache.has(creditAccount)) {
+      return this.#investorCache.mustGet(creditAccount);
+    }
+    const investor = await this.contract.read.getInvestor([creditAccount]);
+    if (fromCache) {
+      this.#investorCache.upsert(creditAccount, investor);
+    }
+    return investor;
+  }
+  /**
+   * {@inheritDoc IKYCFactory.getApprovalAddress}
+   */
+  async getApprovalAddress(options) {
+    if ("creditAccount" in options) {
+      return this.getWallet(options.creditAccount);
+    }
+    return this.#precomputeWalletAddress(
+      options.creditManager,
+      options.borrower
+    );
+  }
+  /**
+   * {@inheritDoc IKYCFactory.getWallet}
+   */
+  async getWallet(creditAccount) {
+    return this.contract.read.getWallet([creditAccount]);
+  }
+  /**
+   * {@inheritDoc IKYCFactory.multicall}
+   */
+  multicall(creditAccount, calls, options) {
+    const { tokensToRegister = [], signaturesToCache = [] } = options ?? {};
+    return this.createRawTx({
+      functionName: "multicall",
+      args: [creditAccount, calls, tokensToRegister, signaturesToCache]
+    });
+  }
+  /**
+   * {@inheritDoc IKYCFactory.getOpenAccountRequirements}
+   */
+  async getOpenAccountRequirements(investor, props) {
+    const [investorData] = await this.#sdk.kyc.getInvestorData(investor, [
+      this.address
+    ]);
+    const tokensToRegister = new AddressSet([props.tokenOutAddress]);
+    const registredTokens = new AddressSet(investorData.registeredTokens);
+    const signedTokens = new AddressSet(
+      investorData.cachedSignatures.map((s) => s.token)
+    );
+    const unsignedTokens = tokensToRegister.difference(signedTokens);
+    const securitizeTokensToRegister = tokensToRegister.difference(registredTokens);
+    const requiredSignatures = investorData.registerVaultMessages.filter(
+      (m) => unsignedTokens.has(m.token)
+    );
+    return {
+      type: KYC_FACTORY_SECURITIZE,
+      securitizeTokensToRegister: Array.from(securitizeTokensToRegister),
+      tokensToRegister: Array.from(tokensToRegister),
+      requiredSignatures
+    };
+  }
+  /**
+   * {@inheritDoc IKYCFactory.openCreditAccount}
+   */
+  openCreditAccount(creditManager, calls, options) {
+    const { tokensToRegister = [], signaturesToCache = [] } = options ?? {};
+    return this.createRawTx({
+      functionName: "openCreditAccount",
+      args: [creditManager, calls, tokensToRegister, signaturesToCache]
+    });
+  }
+  stateHuman(_raw) {
+    return {
+      ...super.stateHuman(_raw),
+      owner: this.labelAddress(this.owner),
+      degenNFT: this.labelAddress(this.degenNFT),
+      dsTokens: this.dsTokens.map((t) => ({
+        ...this.tokensMeta.mustGet(t.address),
+        registrar: this.labelAddress(t.registrar),
+        operators: t.operators.map((o) => this.labelAddress(o))
+      }))
+    };
+  }
+  /**
+   * Precomputes the wallet address that will own a new credit account
+   * for the given investor in the given credit manager.
+   *
+   * @param creditManager - credit manager address
+   * @param investor - investor address
+   **/
+  async #precomputeWalletAddress(creditManager, investor) {
+    return this.contract.read.precomputeWalletAddress([
+      creditManager,
+      investor
+    ]);
+  }
+}
+const registerMessageTuple = [
+  { name: "token", type: "address" },
+  {
+    name: "signature",
+    type: "tuple",
+    components: [
+      { name: "deadline", type: "uint256" },
+      { name: "signature", type: "bytes" }
+    ]
+  }
+];
+const registerVaultMessageTuple = [
+  {
+    name: "domain",
+    type: "tuple",
+    components: [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ]
+  },
+  { name: "investor", type: "address" },
+  { name: "operator", type: "address" },
+  { name: "token", type: "address" },
+  { name: "nonce", type: "uint256" },
+  { name: "deadline", type: "uint256" }
+];
+export {
+  SecuritizeKYCFactory
+};

package/dist/esm/sdk/market/kyc/securitize/constants.js

@@ -0,0 +1,4 @@
+const KYC_FACTORY_SECURITIZE = "KYC_FACTORY::SECURITIZE";
+export {
+  KYC_FACTORY_SECURITIZE
+};

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

@@ -0,0 +1,3 @@
+export * from "./constants.js";
+export * from "./SecuritizeKYCFactory.js";
+export * from "./types.js";

package/dist/esm/sdk/market/kyc/types.js

@@ -0,0 +1,9 @@
+import { KYC_FACTORY_SECURITIZE } from "./securitize/index.js";
+const KYC_FACTORY_TYPES = [KYC_FACTORY_SECURITIZE];
+function isKYCFactory(factory, type) {
+  return factory.contractType === type;
+}
+export {
+  KYC_FACTORY_TYPES,
+  isKYCFactory
+};

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

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

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

@@ -10,13 +10,15 @@ import {
 const abi = [...iPoolV310Abi, ...iPausableAbi];
 class PoolV310Contract extends BaseContract {
   creditManagerDebtParams;
-  constructor(options, data) {
+  #sdk;
+  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 +30,13 @@ class PoolV310Contract extends BaseContract {
       symbol: data.symbol
     });
   }
+  get kycFactory() {
+    const meta = this.#sdk.tokensMeta.mustGet(this.underlying);
+    if (this.#sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return this.#sdk.mustGetContract(meta.kycFactory);
+    }
+    return void 0;
+  }
   stateHuman(raw = true) {
     return {
       ...super.stateHuman(raw),

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

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

package/dist/esm/sdk/market/pricefeeds/PriceFeedsRegister.js

@@ -221,13 +221,13 @@ class PriceFeedRegister extends SDKConstruct {
    * Loads PARTIAL information about all updatable price feeds from MarketCompressor
    * Discovered price feeds are not saved anywhere in PriceFeedRegister, and can later be used to load price feed updates
    */
-  async getPartialUpdatablePriceFeeds(configurators, pools) {
+  async getPartialUpdatablePriceFeeds(configurators) {
     const [priceFeedCompressorAddress] = this.sdk.addressProvider.mustGetLatest(
       AP_PRICE_FEED_COMPRESSOR,
       VERSION_RANGE_310
     );
     this.logger?.debug(
-      { configurators, pools },
+      { configurators },
       `calling getUpdatablePriceFeeds in block ${this.sdk.currentBlock}`
     );
     const result = await this.client.readContract({
@@ -237,7 +237,7 @@ class PriceFeedRegister extends SDKConstruct {
       args: [
         {
           configurators,
-          pools: pools ?? [],
+          pools: [],
           underlying: ADDRESS_0X0
         }
       ],

package/dist/esm/sdk/options.js

@@ -23,6 +23,12 @@ const AttachOptionsSchema = z.object({
   addressProvider: ZodAddress().optional(),
   /** Addresses of market configurator contracts to load. */
   marketConfigurators: z.array(ZodAddress()).optional(),
+  /**
+   * Addresses of KYC factory contracts to load.
+   * If not set, all default KYC factories for the chain are loaded
+   * (from {@link GearboxChain.kycFactories})
+   **/
+  kycFactories: z.array(ZodAddress()).optional(),
   /** Pin SDK to a specific block number during attach. */
   blockNumber: z.union([z.bigint().nonnegative(), z.number().int().nonnegative()]).optional(),
   /** Skip fetching updatable price feeds on attach and sync. */