@suilend/sdk 3.0.8 → 5.0.0

package/lib/initialize.d.ts

@@ -1,5 +1,6 @@
 import { SuiClientTypes } from "@mysten/sui/client";
 import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 import BigNumber from "bignumber.js";
 import { Reserve } from "../_generated/suilend/reserve/structs";
 import { SuilendClient } from "../client";
@@ -9,7 +10,87 @@ export declare const RESERVES_CUSTOM_ORDER: Record<string, string[]>;
 export declare const NORMALIZED_MAYA_COINTYPE: string;
 export declare const NORMALIZED_mPOINTS_COINTYPE: string;
 export declare const NORMALIZED_TREATS_COINTYPE: string;
-export declare const initializeSuilend: (suiGrpcClient: SuiGrpcClient, suilendClient: SuilendClient, lendingMarketMetadata?: LendingMarketMetadata, fallbackPythEndpoint?: string) => Promise<{
+/**
+ * Price reserves for `initializeSuilend`, honouring the opt-in tolerance flag.
+ *
+ * Extracted so both branches are directly testable — the difference between
+ * them is a throw, which is the whole reason the flag exists and is exactly
+ * what a regression here would silently change.
+ */
+export declare const refreshReservesForInitialize: (reserves: Reserve<string>[], pythConnection: SuiPriceServiceConnection, tolerateMissingPriceFeeds?: boolean) => Promise<{
+    reserves: Reserve<string>[];
+    unpricedCoinTypes: string[];
+}>;
+/**
+ * Price the temporary-Pyth-feed reserves from the cached-price service, in
+ * place, and report which ones ended up with a FABRICATED price.
+ *
+ * These reserves never reach the Pyth refresh at all, so nothing else can
+ * report them. When the cached lookup fails the price falls back to a
+ * hardcoded 0.0001 — a placeholder chosen to be non-zero, not a market price —
+ * and previously that was indistinguishable from a real quote: the reserve
+ * carried a plausible-looking number and appeared in no gap report.
+ *
+ * Extracted for the same reason as `refreshReservesForInitialize`:
+ * `initializeSuilend` needs a gRPC client and a SuilendClient, so logic left
+ * inline in it cannot be tested, and "is this price real" is not something to
+ * leave unverified.
+ */
+export declare const priceTemporaryPythFeedReserves: (reserves: Reserve<string>[], fetchPrice?: (coinType: string) => Promise<number | undefined>) => Promise<string[]>;
+export declare const initializeSuilend: (suiGrpcClient: SuiGrpcClient, suilendClient: SuilendClient, lendingMarketMetadata?: LendingMarketMetadata, fallbackPythEndpoint?: string, options?: {
+    /**
+     * Price connection to use instead of the one this function would build.
+     *
+     * Without this, the connection is constructed here and never exposed, so a
+     * caller cannot authenticate it, point it at a different Hermes deployment,
+     * or give it failover — it is unreachable from outside.
+     *
+     * SUPERSEDES `fallbackPythEndpoint`, which is ignored when this is set.
+     * That parameter is a hint for building a connection, and there is nothing
+     * left to build; it engages only when a `/live` probe fails, which tests
+     * whether Hermes is UP, not whether it still serves your feeds (a 401 or a
+     * per-feed 404 never trips it). Supply failover on the connection you
+     * inject — a multi-endpoint connection covers strictly more than the probe
+     * did.
+     *
+     * YOU ALSO OWN THE TIMEOUT. The connection this function builds for itself
+     * uses 30s; pyth-sui-js defaults to 5s, so an injected connection
+     * constructed with default options gets a 6x tighter deadline than
+     * initializeSuilend used to guarantee. Nothing here can impose a timeout on
+     * an object it did not construct — set it when you build the connection.
+     *
+     * Must be a `SuiPriceServiceConnection` (a subclass is fine, and is how you
+     * add `getLatestPriceFeedsPartial`). Not the structural
+     * `PartialPriceFeedSource` shape: with `tolerateMissingPriceFeeds` off this
+     * connection goes to `refreshReservePrice`, which needs the class's own
+     * `getLatestPriceFeeds`. The lower-level `refreshReservePriceTolerant` does
+     * accept the structural shape, since it only ever needs the partial fetch.
+     */
+    pythConnection?: SuiPriceServiceConnection;
+    /**
+     * Let a reserve whose feed no endpoint can serve keep the price already in
+     * its on-chain state, instead of failing the whole market. Off by default.
+     *
+     * OPT-IN because it trades a loud failure for a quiet one, and only the
+     * caller knows which it wants. A UI is usually better off failing visibly
+     * than rendering a stale price with no indication; a liquidator watching 45
+     * reserves is better off pricing the 41 it can than going blind over the 4
+     * it cannot.
+     *
+     * REQUIRES `pythConnection` to implement `getLatestPriceFeedsPartial` —
+     * throws otherwise, rather than degrading to the identical hard failure
+     * this flag exists to avoid. The connection this function builds for itself
+     * is all-or-nothing, so the flag cannot be used alone.
+     *
+     * Callers that enable this MUST read `unpricedCoinTypes` and decide per
+     * reserve what a kept price is allowed to mean — nothing here makes that
+     * judgement for them. An unpriced reserve stays in `refreshedRawReserves`
+     * carrying its on-chain price, which may be zero, so folding that array
+     * into collateral or borrow-limit math without excluding those coin types
+     * prices them at literal zero.
+     */
+    tolerateMissingPriceFeeds?: boolean;
+}) => Promise<{
     lendingMarket: {
         version: bigint;
         reserves: {
@@ -148,6 +229,7 @@ export declare const initializeSuilend: (suiGrpcClient: SuiGrpcClient, suilendCl
     };
     coinMetadataMap: Record<string, SuiClientTypes.CoinMetadata>;
     refreshedRawReserves: Reserve<string>[];
+    unpricedCoinTypes: string[];
     reserveMap: Record<string, {
         config: {
             $typeName: string;
@@ -257,10 +339,10 @@ export declare const initializeSuilend: (suiGrpcClient: SuiGrpcClient, suilendCl
         totalDeposits: BigNumber;
     }>;
     reserveCoinTypes: string[];
-    reserveCoinMetadataMap: Record<string, import("@suilend/sui-fe").Token>;
+    reserveCoinMetadataMap: Record<string, import("@suilend/sui-core").Token>;
     rewardCoinTypes: string[];
     activeRewardCoinTypes: string[];
-    rewardCoinMetadataMap: Record<string, import("@suilend/sui-fe").Token>;
+    rewardCoinMetadataMap: Record<string, import("@suilend/sui-core").Token>;
 }>;
 export declare const initializeSuilendRewards: (reserveMap: Record<string, ParsedReserve>, activeRewardCoinTypes: string[]) => Promise<{
     rewardPriceMap: Record<string, BigNumber | undefined>;

package/lib/initialize.js

@@ -1,21 +1,11 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { normalizeStructTag } from "@mysten/sui/utils";
-import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 import BigNumber from "bignumber.js";
-import { NORMALIZED_ALKIMI_COINTYPE, NORMALIZED_AUSD_COINTYPE, NORMALIZED_BLUE_COINTYPE, NORMALIZED_BUCK_COINTYPE, NORMALIZED_DEEP_COINTYPE, NORMALIZED_DMC_COINTYPE, NORMALIZED_FUD_COINTYPE, NORMALIZED_HAEDAL_COINTYPE, NORMALIZED_HIPPO_COINTYPE, NORMALIZED_IKA_COINTYPE, NORMALIZED_KOBAN_COINTYPE, NORMALIZED_LBTC_COINTYPE, NORMALIZED_NS_COINTYPE, NORMALIZED_SEND_COINTYPE, NORMALIZED_SEND_POINTS_S1_COINTYPE, NORMALIZED_SEND_POINTS_S2_COINTYPE, NORMALIZED_SOL_COINTYPE, NORMALIZED_SUI_COINTYPE, NORMALIZED_UP_COINTYPE, NORMALIZED_USDB_COINTYPE, NORMALIZED_USDC_COINTYPE, NORMALIZED_USDsui_COINTYPE, NORMALIZED_WAL_COINTYPE, NORMALIZED_WBTC_COINTYPE, NORMALIZED_WETH_COINTYPE, NORMALIZED_XAUm_COINTYPE, NORMALIZED_eEARN_COINTYPE, NORMALIZED_eTHIRD_COINTYPE, NORMALIZED_flSUI_COINTYPE, NORMALIZED_fpSUI_COINTYPE, NORMALIZED_fudSUI_COINTYPE, NORMALIZED_iSUI_COINTYPE, NORMALIZED_jugSUI_COINTYPE, NORMALIZED_kSUI_COINTYPE, NORMALIZED_mSUI_COINTYPE, NORMALIZED_mUSD_COINTYPE, NORMALIZED_oshiSUI_COINTYPE, NORMALIZED_sSUI_COINTYPE, NORMALIZED_sdeUSD_COINTYPE, NORMALIZED_stratSUI_COINTYPE, NORMALIZED_suiETH_COINTYPE, NORMALIZED_suiUSDT_COINTYPE, NORMALIZED_suiUSDe_COINTYPE, NORMALIZED_suiWBTC_COINTYPE, NORMALIZED_trevinSUI_COINTYPE, NORMALIZED_upSUI_COINTYPE, NORMALIZED_wUSDC_COINTYPE, NORMALIZED_wUSDT_COINTYPE, NORMALIZED_xBTC_COINTYPE, NORMALIZED_yapSUI_COINTYPE, TEMPORARY_PYTH_PRICE_FEED_COINTYPES, getAllOwnedObjects, getCoinMetadataMap, getPrice, isSendPoints, isSteammPoints, } from "@suilend/sui-fe";
+import { NORMALIZED_ALKIMI_COINTYPE, NORMALIZED_AUSD_COINTYPE, NORMALIZED_BLUE_COINTYPE, NORMALIZED_BUCK_COINTYPE, NORMALIZED_DEEP_COINTYPE, NORMALIZED_DMC_COINTYPE, NORMALIZED_FUD_COINTYPE, NORMALIZED_HAEDAL_COINTYPE, NORMALIZED_HIPPO_COINTYPE, NORMALIZED_IKA_COINTYPE, NORMALIZED_KOBAN_COINTYPE, NORMALIZED_LBTC_COINTYPE, NORMALIZED_NS_COINTYPE, NORMALIZED_SEND_COINTYPE, NORMALIZED_SEND_POINTS_S1_COINTYPE, NORMALIZED_SEND_POINTS_S2_COINTYPE, NORMALIZED_SOL_COINTYPE, NORMALIZED_SUI_COINTYPE, NORMALIZED_UP_COINTYPE, NORMALIZED_USDB_COINTYPE, NORMALIZED_USDC_COINTYPE, NORMALIZED_USDsui_COINTYPE, NORMALIZED_WAL_COINTYPE, NORMALIZED_WBTC_COINTYPE, NORMALIZED_WETH_COINTYPE, NORMALIZED_XAUm_COINTYPE, NORMALIZED_eEARN_COINTYPE, NORMALIZED_eTHIRD_COINTYPE, NORMALIZED_flSUI_COINTYPE, NORMALIZED_fpSUI_COINTYPE, NORMALIZED_fudSUI_COINTYPE, NORMALIZED_iSUI_COINTYPE, NORMALIZED_jugSUI_COINTYPE, NORMALIZED_kSUI_COINTYPE, NORMALIZED_mSUI_COINTYPE, NORMALIZED_mUSD_COINTYPE, NORMALIZED_oshiSUI_COINTYPE, NORMALIZED_sSUI_COINTYPE, NORMALIZED_sdeUSD_COINTYPE, NORMALIZED_stratSUI_COINTYPE, NORMALIZED_suiETH_COINTYPE, NORMALIZED_suiUSDT_COINTYPE, NORMALIZED_suiUSDe_COINTYPE, NORMALIZED_suiWBTC_COINTYPE, NORMALIZED_trevinSUI_COINTYPE, NORMALIZED_upSUI_COINTYPE, NORMALIZED_wUSDC_COINTYPE, NORMALIZED_wUSDT_COINTYPE, NORMALIZED_xBTC_COINTYPE, NORMALIZED_yapSUI_COINTYPE, TEMPORARY_PYTH_PRICE_FEED_COINTYPES, getAllOwnedObjects, getCoinMetadataMap, getPrice, isSendPoints, isSteammPoints, } from "@suilend/sui-core";
 import { LENDING_MARKET_ID, SuilendClient } from "../client.js";
 import { parseLendingMarket, parseObligation } from "../parsers/index.js";
 import * as simulate from "../utils/simulate.js";
 import { WAD } from "./constants.js";
-import { getWorkingPythEndpoint } from "./pyth.js";
+import { resolvePythConnection } from "./pyth.js";
 import { STRATEGY_TYPE_INFO_MAP, STRATEGY_WRAPPER_PACKAGE_ID_V1, } from "./strategyOwnerCap.js";
 export const RESERVES_CUSTOM_ORDER = {
     [LENDING_MARKET_ID]: [
@@ -94,7 +84,79 @@ const TREATS_COINTYPE = "0x0dadb7fa2771c2952f96161fc1f0c105d1f22d53926b9ff2498a8
 export const NORMALIZED_MAYA_COINTYPE = normalizeStructTag(MAYA_COINTYPE);
 export const NORMALIZED_mPOINTS_COINTYPE = normalizeStructTag(mPOINTS_COINTYPE);
 export const NORMALIZED_TREATS_COINTYPE = normalizeStructTag(TREATS_COINTYPE);
-export const initializeSuilend = (suiGrpcClient, suilendClient, lendingMarketMetadata, fallbackPythEndpoint) => __awaiter(void 0, void 0, void 0, function* () {
+/**
+ * Price reserves for `initializeSuilend`, honouring the opt-in tolerance flag.
+ *
+ * Extracted so both branches are directly testable — the difference between
+ * them is a throw, which is the whole reason the flag exists and is exactly
+ * what a regression here would silently change.
+ */
+export const refreshReservesForInitialize = async (reserves, pythConnection, tolerateMissingPriceFeeds) => {
+    if (tolerateMissingPriceFeeds) {
+        // Tolerance is only expressible over a connection that can report WHICH
+        // feeds it could not serve. A stock SuiPriceServiceConnection cannot: the
+        // method does not exist in pyth-sui-js, so the tolerant path would fall
+        // back to the all-or-nothing fetch, and Hermes v2 404s the whole batch over
+        // one unknown id — the caller would get the same hard failure as before the
+        // flag existed, having explicitly asked not to.
+        //
+        // Rejected here rather than left to degrade quietly, because the pairing is
+        // otherwise invisible: nothing in the flag's name or type says it needs a
+        // connection the SDK cannot build for itself. Checked on CAPABILITY, not on
+        // whether a connection was injected — injecting a stock one is equally
+        // useless. Direct callers of refreshReservePriceTolerant keep the strict
+        // fallback, which is correct for an endpoint that omits unknown ids.
+        if (!simulate.canReportMissingPriceFeeds(pythConnection)) {
+            throw new Error(`tolerateMissingPriceFeeds requires a connection that can report per-feed gaps. The connection in use is all-or-nothing, so an endpoint that rejects the whole batch over one unknown feed would fail initialization regardless of this flag — ${simulate.PARTIAL_FETCH_REQUIRED_HINT}. Note that patching SuiPriceServiceConnection.prototype does NOT satisfy this: it can reroute getLatestPriceFeeds but cannot add a per-feed gap report.`);
+        }
+        return simulate.refreshReservePriceTolerant(reserves, pythConnection);
+    }
+    // Default path, behaviourally identical to what this function did before the
+    // flag existed: throws if any requested feed is absent from the response.
+    return {
+        reserves: await simulate.refreshReservePrice(reserves, pythConnection),
+        unpricedCoinTypes: [],
+    };
+};
+/**
+ * Price the temporary-Pyth-feed reserves from the cached-price service, in
+ * place, and report which ones ended up with a FABRICATED price.
+ *
+ * These reserves never reach the Pyth refresh at all, so nothing else can
+ * report them. When the cached lookup fails the price falls back to a
+ * hardcoded 0.0001 — a placeholder chosen to be non-zero, not a market price —
+ * and previously that was indistinguishable from a real quote: the reserve
+ * carried a plausible-looking number and appeared in no gap report.
+ *
+ * Extracted for the same reason as `refreshReservesForInitialize`:
+ * `initializeSuilend` needs a gRPC client and a SuilendClient, so logic left
+ * inline in it cannot be tested, and "is this price real" is not something to
+ * leave unverified.
+ */
+export const priceTemporaryPythFeedReserves = async (reserves, fetchPrice = getPrice) => {
+    const fabricatedPriceCoinTypes = [];
+    await Promise.all(reserves.map(async (reserve) => {
+        const coinType = normalizeStructTag(reserve.coinType.name);
+        let cachedUsdPrice;
+        try {
+            cachedUsdPrice = await fetchPrice(coinType);
+        }
+        catch (err) {
+            console.error(err);
+        }
+        if (cachedUsdPrice === undefined) {
+            cachedUsdPrice = 0.0001; // Non-zero price override if no price
+            fabricatedPriceCoinTypes.push(coinType);
+        }
+        const parsedCachedUsdPrice = BigInt(+new BigNumber(cachedUsdPrice)
+            .times(WAD)
+            .integerValue(BigNumber.ROUND_DOWN));
+        reserve.price.value = parsedCachedUsdPrice;
+        reserve.smoothedPrice.value = parsedCachedUsdPrice;
+    }));
+    return fabricatedPriceCoinTypes;
+};
+export const initializeSuilend = async (suiGrpcClient, suilendClient, lendingMarketMetadata, fallbackPythEndpoint, options) => {
     const nowMs = Date.now();
     const nowS = Math.floor(nowMs / 1000);
     const interestCompoundedRawReserves = suilendClient.lendingMarket.reserves.map((r) => simulate.compoundReserveInterest(r, nowS));
@@ -109,35 +171,35 @@ export const initializeSuilend = (suiGrpcClient, suilendClient, lendingMarketMet
             reservesWithoutTemporaryPythPriceFeeds.push(reserve);
         }
     }
-    // Get a working Pyth endpoint (try primary, fallback to fallbackPythEndpoint if provided)
-    const pythEndpoint = yield getWorkingPythEndpoint(fallbackPythEndpoint);
-    const pythConnection = new SuiPriceServiceConnection(pythEndpoint, {
-        timeout: 30 * 1000,
-    });
-    const [refreshedReservesWithoutTemporaryPythPriceFeeds] = yield Promise.all([
-        simulate.refreshReservePrice(reservesWithoutTemporaryPythPriceFeeds, pythConnection),
-        Promise.all(reservesWithTemporaryPythPriceFeeds.map((reserve) => (() => __awaiter(void 0, void 0, void 0, function* () {
-            let cachedUsdPrice;
-            try {
-                cachedUsdPrice = yield getPrice(normalizeStructTag(reserve.coinType.name));
-            }
-            catch (err) {
-                console.error(err);
-            }
-            if (cachedUsdPrice === undefined)
-                cachedUsdPrice = 0.0001; // Non-zero price override if no price
-            const parsedCachedUsdPrice = BigInt(+new BigNumber(cachedUsdPrice)
-                .times(WAD)
-                .integerValue(BigNumber.ROUND_DOWN));
-            reserve.price.value = parsedCachedUsdPrice;
-            reserve.smoothedPrice.value = parsedCachedUsdPrice;
-        }))())),
+    const pythConnection = await resolvePythConnection(options?.pythConnection, fallbackPythEndpoint);
+    const [refreshedWithoutTemporary, fabricatedPriceCoinTypes] = await Promise.all([
+        refreshReservesForInitialize(reservesWithoutTemporaryPythPriceFeeds, pythConnection, options?.tolerateMissingPriceFeeds),
+        priceTemporaryPythFeedReserves(reservesWithTemporaryPythPriceFeeds),
     ]);
     // Recombine reserves back into a single array
     const refreshedRawReserves = [
-        ...refreshedReservesWithoutTemporaryPythPriceFeeds,
+        ...refreshedWithoutTemporary.reserves,
         ...reservesWithTemporaryPythPriceFeeds,
     ];
+    // Reserves NOT carrying a real refreshed price, from either cause: no endpoint
+    // served the Pyth feed (needs `tolerateMissingPriceFeeds`, else the refresh
+    // threw), or a temporary-feed reserve fell back to a fabricated placeholder
+    // (independent of that flag). Surfaced rather than logged-and-forgotten: only
+    // the caller knows whether a given reserve can safely hold such a price.
+    //
+    // Normalized, matching `reserveMap` / `reserveCoinTypes` keys. Entries in
+    // `refreshedRawReserves` carry the RAW on-chain `coinType.name`, which never
+    // compares equal to these (no `0x` prefix), so filtering that array means
+    // normalizing first:
+    //
+    //   const unpriced = new Set(unpricedCoinTypes);
+    //   refreshedRawReserves.filter(
+    //     (r) => !unpriced.has(normalizeStructTag(r.coinType.name)),
+    //   );
+    const unpricedCoinTypes = [
+        ...refreshedWithoutTemporary.unpricedCoinTypes,
+        ...fabricatedPriceCoinTypes,
+    ];
     const miscCoinTypes = [
         NORMALIZED_SEND_POINTS_S1_COINTYPE,
         NORMALIZED_SEND_POINTS_S2_COINTYPE,
@@ -164,12 +226,16 @@ export const initializeSuilend = (suiGrpcClient, suilendClient, lendingMarketMet
     const uniqueReserveCoinTypes = Array.from(new Set(reserveCoinTypes));
     const uniqueRewardCoinTypes = Array.from(new Set(rewardCoinTypes));
     const uniqueActiveRewardsCoinTypes = Array.from(new Set(activeRewardCoinTypes));
-    const [miscCoinMetadataMap, reserveCoinMetadataMap, rewardCoinMetadataMap] = yield Promise.all([
+    const [miscCoinMetadataMap, reserveCoinMetadataMap, rewardCoinMetadataMap] = await Promise.all([
         getCoinMetadataMap(uniqueMiscCoinTypes),
         getCoinMetadataMap(uniqueReserveCoinTypes),
         getCoinMetadataMap(uniqueRewardCoinTypes),
     ]);
-    const coinMetadataMap = Object.assign(Object.assign(Object.assign({}, miscCoinMetadataMap), reserveCoinMetadataMap), rewardCoinMetadataMap);
+    const coinMetadataMap = {
+        ...miscCoinMetadataMap,
+        ...reserveCoinMetadataMap,
+        ...rewardCoinMetadataMap,
+    };
     // const walReserve = refreshedRawReserves.find(
     //   (r) => normalizeStructTag(r.coinType.name) === NORMALIZED_WAL_COINTYPE,
     // );
@@ -193,11 +259,12 @@ export const initializeSuilend = (suiGrpcClient, suilendClient, lendingMarketMet
                 return aCustomOrderIndex > -1 ? -1 : 1;
         });
     }
-    const reserveMap = lendingMarket.reserves.reduce((acc, reserve) => (Object.assign(Object.assign({}, acc), { [reserve.coinType]: reserve })), {});
+    const reserveMap = lendingMarket.reserves.reduce((acc, reserve) => ({ ...acc, [reserve.coinType]: reserve }), {});
     return {
         lendingMarket,
         coinMetadataMap,
         refreshedRawReserves,
+        unpricedCoinTypes,
         reserveMap,
         reserveCoinTypes: uniqueReserveCoinTypes,
         reserveCoinMetadataMap,
@@ -205,15 +272,15 @@ export const initializeSuilend = (suiGrpcClient, suilendClient, lendingMarketMet
         activeRewardCoinTypes: uniqueActiveRewardsCoinTypes,
         rewardCoinMetadataMap,
     };
-});
-export const initializeSuilendRewards = (reserveMap, activeRewardCoinTypes) => __awaiter(void 0, void 0, void 0, function* () {
-    const rewardPriceMap = Object.entries(reserveMap).reduce((acc, [coinType, reserve]) => (Object.assign(Object.assign({}, acc), { [coinType]: reserve.price })), {});
+};
+export const initializeSuilendRewards = async (reserveMap, activeRewardCoinTypes) => {
+    const rewardPriceMap = Object.entries(reserveMap).reduce((acc, [coinType, reserve]) => ({ ...acc, [coinType]: reserve.price }), {});
     rewardPriceMap[NORMALIZED_TREATS_COINTYPE] = new BigNumber(0.1);
     const reservelessActiveRewardCoinTypes = activeRewardCoinTypes.filter((coinType) => !(isSendPoints(coinType) ||
         isSteammPoints(coinType) ||
         coinType === NORMALIZED_MAYA_COINTYPE ||
         coinType === NORMALIZED_mPOINTS_COINTYPE) && !rewardPriceMap[coinType]);
-    const reservelessActiveRewardCachedUsdPrices = yield Promise.all(reservelessActiveRewardCoinTypes.map((coinType) => getPrice(coinType)));
+    const reservelessActiveRewardCachedUsdPrices = await Promise.all(reservelessActiveRewardCoinTypes.map((coinType) => getPrice(coinType)));
     for (let i = 0; i < reservelessActiveRewardCoinTypes.length; i++) {
         const cachedUsdPrice = reservelessActiveRewardCachedUsdPrices[i];
         if (cachedUsdPrice === undefined)
@@ -221,8 +288,8 @@ export const initializeSuilendRewards = (reserveMap, activeRewardCoinTypes) => _
         rewardPriceMap[reservelessActiveRewardCoinTypes[i]] = new BigNumber(cachedUsdPrice);
     }
     return { rewardPriceMap };
-});
-export const initializeObligations = (suiGrpcClient, suilendClient, refreshedRawReserves, reserveMap, address) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const initializeObligations = async (suiGrpcClient, suilendClient, refreshedRawReserves, reserveMap, address) => {
     if (!address)
         return {
             strategyOwnerCaps: [],
@@ -230,12 +297,12 @@ export const initializeObligations = (suiGrpcClient, suilendClient, refreshedRaw
             obligationOwnerCaps: [],
             obligations: [],
         };
-    const [strategyOwnerCaps, obligationOwnerCaps] = yield Promise.all([
-        (() => __awaiter(void 0, void 0, void 0, function* () {
+    const [strategyOwnerCaps, obligationOwnerCaps] = await Promise.all([
+        (async () => {
             const hasStrategies = Object.values(STRATEGY_TYPE_INFO_MAP).some((info) => info.lendingMarketId === suilendClient.lendingMarket.id);
             if (!hasStrategies)
                 return [];
-            const objects = yield getAllOwnedObjects(suiGrpcClient, address, `${STRATEGY_WRAPPER_PACKAGE_ID_V1}::strategy_wrapper::StrategyOwnerCap<${suilendClient.lendingMarket.$typeArgs[0]}>`);
+            const objects = await getAllOwnedObjects(suiGrpcClient, address, `${STRATEGY_WRAPPER_PACKAGE_ID_V1}::strategy_wrapper::StrategyOwnerCap<${suilendClient.lendingMarket.$typeArgs[0]}>`);
             return objects.map((obj) => {
                 const json = obj.json;
                 const id = json.id;
@@ -250,10 +317,10 @@ export const initializeObligations = (suiGrpcClient, suilendClient, refreshedRaw
                 };
                 return result;
             });
-        }))(),
+        })(),
         SuilendClient.getObligationOwnerCaps(address, suilendClient.lendingMarket.$typeArgs, suiGrpcClient),
     ]);
-    const obligations = (yield Promise.all([
+    const obligations = (await Promise.all([
         ...strategyOwnerCaps.map((soc) => soc.obligationId),
         ...obligationOwnerCaps.map((ownerCap) => ownerCap.obligationId),
     ].map((obligationId) => SuilendClient.getObligation(obligationId, suilendClient.lendingMarket.$typeArgs, suiGrpcClient))))
@@ -269,4 +336,4 @@ export const initializeObligations = (suiGrpcClient, suilendClient, refreshedRaw
         obligationOwnerCaps,
         obligations: nonStrategyObligations,
     };
-});
+};

package/lib/liquidityMining.js

@@ -1,6 +1,6 @@
 import BigNumber from "bignumber.js";
 import cloneDeep from "lodash/cloneDeep.js";
-import { MS_PER_YEAR, NORMALIZED_eEARN_COINTYPE, NORMALIZED_eTHIRD_COINTYPE, NORMALIZED_sdeUSD_COINTYPE, isSendPoints, } from "@suilend/sui-fe";
+import { MS_PER_YEAR, NORMALIZED_eEARN_COINTYPE, NORMALIZED_eTHIRD_COINTYPE, NORMALIZED_sdeUSD_COINTYPE, isSendPoints, } from "@suilend/sui-core";
 import { WAD } from "./constants.js";
 import { Side } from "./types.js";
 export const getDepositShare = (reserve, share) => share.div(10 ** reserve.mintDecimals).times(reserve.cTokenExchangeRate);
@@ -12,7 +12,7 @@ export const formatRewards = (parsedReserveMap, coinMetadataMap, priceMap, oblig
     const rewardMap = {};
     const getRewardSummary = (reserve, poolReward, side) => {
         const rewardCoinMetadata = coinMetadataMap[poolReward.coinType];
-        const rewardPrice = priceMap === null || priceMap === void 0 ? void 0 : priceMap[poolReward.coinType];
+        const rewardPrice = priceMap?.[poolReward.coinType];
         const isActive = nowMs >= poolReward.startTimeMs && nowMs < poolReward.endTimeMs;
         const aprPercent = rewardPrice
             ? new BigNumber(reserve.depositsPoolRewardManager.totalShares.toString()).eq(0)
@@ -48,7 +48,7 @@ export const formatRewards = (parsedReserveMap, coinMetadataMap, priceMap, oblig
                 perDay,
                 side,
             },
-            obligationClaims: Object.fromEntries((obligations !== null && obligations !== void 0 ? obligations : [])
+            obligationClaims: Object.fromEntries((obligations ?? [])
                 .map((obligation) => {
                 const claim = getObligationClaim(obligation, poolReward, side === Side.DEPOSIT
                     ? reserve.depositsPoolRewardManager.id
@@ -96,7 +96,7 @@ const getObligationClaim = (obligation, poolReward, reservePoolManagerId, reserv
     if (!userReward)
         return;
     return {
-        claimableAmount: (userReward === null || userReward === void 0 ? void 0 : userReward.earnedRewards)
+        claimableAmount: userReward?.earnedRewards
             ? new BigNumber(userReward.earnedRewards.value.toString())
                 .div(WAD)
                 .div(10 ** poolReward.mintDecimals)
@@ -132,26 +132,22 @@ export const getDedupedPerDayRewards = (filteredRewards) => {
     return result;
 };
 export const getRewardsAprPercent = (side, filteredRewards) => getDedupedAprRewards(filteredRewards).reduce((acc, reward) => acc.plus(reward.stats.aprPercent.times(side === Side.DEPOSIT ? 1 : -1)), new BigNumber(0));
-export const getStakingYieldAprPercent = (side, coinType, lstStatsMap, sdeUsdAprPercent, eThirdAprPercent, eEarnAprPercent) => {
-    var _a;
-    return side === Side.DEPOSIT
-        ? coinType === NORMALIZED_sdeUSD_COINTYPE
-            ? sdeUsdAprPercent
-            : coinType === NORMALIZED_eTHIRD_COINTYPE
-                ? eThirdAprPercent
-                : coinType === NORMALIZED_eEARN_COINTYPE
-                    ? eEarnAprPercent
-                    : (_a = lstStatsMap[coinType]) === null || _a === void 0 ? void 0 : _a.aprPercent
-        : undefined;
-};
+export const getStakingYieldAprPercent = (side, coinType, lstStatsMap, sdeUsdAprPercent, eThirdAprPercent, eEarnAprPercent) => side === Side.DEPOSIT
+    ? coinType === NORMALIZED_sdeUSD_COINTYPE
+        ? sdeUsdAprPercent
+        : coinType === NORMALIZED_eTHIRD_COINTYPE
+            ? eThirdAprPercent
+            : coinType === NORMALIZED_eEARN_COINTYPE
+                ? eEarnAprPercent
+                : lstStatsMap[coinType]?.aprPercent
+    : undefined;
 export const getTotalAprPercent = (side, aprPercent, filteredRewards, stakingYieldAprPercent) => aprPercent
     .plus(getRewardsAprPercent(side, filteredRewards))
-    .plus(stakingYieldAprPercent !== null && stakingYieldAprPercent !== void 0 ? stakingYieldAprPercent : 0);
+    .plus(stakingYieldAprPercent ?? 0);
 export const getNetAprPercent = (obligation, rewardMap, lstStatsMap, sdeUsdAprPercent, eThirdAprPercent, eEarnAprPercent, noShares) => {
     const weightedDepositedAmountUsd_aprPercent = obligation.deposits.reduce((acc, deposit) => {
-        var _a;
         const weightedDepositedAmountUsd_baseAprPercent = deposit.reserve.depositAprPercent.times(deposit.depositedAmountUsd);
-        const weightedDepositedAmountUsd_stakingYieldAprPercent = new BigNumber((_a = getStakingYieldAprPercent(Side.DEPOSIT, deposit.reserve.coinType, lstStatsMap, sdeUsdAprPercent, eThirdAprPercent, eEarnAprPercent)) !== null && _a !== void 0 ? _a : 0).times(deposit.depositedAmountUsd);
+        const weightedDepositedAmountUsd_stakingYieldAprPercent = new BigNumber(getStakingYieldAprPercent(Side.DEPOSIT, deposit.reserve.coinType, lstStatsMap, sdeUsdAprPercent, eThirdAprPercent, eEarnAprPercent) ?? 0).times(deposit.depositedAmountUsd);
         const weightedDepositedAmountUsd_rewardsAprPercent = getRewardsAprPercent(Side.DEPOSIT, getFilteredRewards(rewardMap[deposit.reserve.coinType].deposit)).times(!noShares
             ? getDepositShareUsd(deposit.reserve, new BigNumber(deposit.userRewardManager.share.toString()))
             : deposit.depositedAmountUsd);

package/lib/pyth.d.ts

@@ -1,3 +1,4 @@
+import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 export declare const PRIMARY_PYTH_ENDPOINT = "https://hermes.pyth.network";
 /**
  * Tests if the primary Pyth connection endpoint is working by checking the /live endpoint
@@ -10,3 +11,18 @@ export declare const testPrimaryPythConnection: () => Promise<boolean>;
  * @returns The endpoint URL that is working, or the primary endpoint if fallback fails
  */
 export declare const getWorkingPythEndpoint: (fallbackPythEndpoint?: string) => Promise<string>;
+/**
+ * Pick the price connection `initializeSuilend` will use.
+ *
+ * Lives here rather than in initialize.ts for two reasons: it belongs beside
+ * getWorkingPythEndpoint, the thing it decides whether to call; and this module
+ * imports nothing, so the seam is testable without resolving
+ * `@suilend/sui-core` (whose in-repo `exports` points at a .js file that does
+ * not exist, making initialize.ts unimportable from source).
+ *
+ * Skipping the probe for an injected connection is deliberate, not an
+ * optimisation. getWorkingPythEndpoint fetches hermes.pyth.network/live, which
+ * answers for whether Hermes is up — not for whether it still serves the
+ * caller's feeds, and not for whether the caller is even pointed at Hermes.
+ */
+export declare const resolvePythConnection: (pythConnectionOverride?: SuiPriceServiceConnection, fallbackPythEndpoint?: string) => Promise<SuiPriceServiceConnection>;

package/lib/pyth.js

@@ -1,20 +1,12 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
+import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 export const PRIMARY_PYTH_ENDPOINT = "https://hermes.pyth.network";
 /**
  * Tests if the primary Pyth connection endpoint is working by checking the /live endpoint
  * @returns true if the connection is working, false otherwise
  */
-export const testPrimaryPythConnection = () => __awaiter(void 0, void 0, void 0, function* () {
+export const testPrimaryPythConnection = async () => {
     try {
-        const res = yield fetch(`${PRIMARY_PYTH_ENDPOINT}/live`, {
+        const res = await fetch(`${PRIMARY_PYTH_ENDPOINT}/live`, {
             signal: AbortSignal.timeout(5 * 1000), // 5 second timeout
         });
         return res.ok;
@@ -23,15 +15,15 @@ export const testPrimaryPythConnection = () => __awaiter(void 0, void 0, void 0,
         console.warn(`[testPrimaryPythConnection] Pyth connection test failed for ${PRIMARY_PYTH_ENDPOINT}:`, err);
         return false;
     }
-});
+};
 /**
  * Gets a working Pyth connection endpoint, trying primary first, then fallback if provided
  * @param fallbackPythEndpoint Optional fallback endpoint
  * @returns The endpoint URL that is working, or the primary endpoint if fallback fails
  */
-export const getWorkingPythEndpoint = (fallbackPythEndpoint) => __awaiter(void 0, void 0, void 0, function* () {
+export const getWorkingPythEndpoint = async (fallbackPythEndpoint) => {
     // Test primary endpoint first
-    const primaryWorking = yield testPrimaryPythConnection();
+    const primaryWorking = await testPrimaryPythConnection();
     if (primaryWorking) {
         console.log(`[getWorkingPythEndpoint] Using primary Pyth endpoint: ${PRIMARY_PYTH_ENDPOINT}`);
         return PRIMARY_PYTH_ENDPOINT;
@@ -45,4 +37,27 @@ export const getWorkingPythEndpoint = (fallbackPythEndpoint) => __awaiter(void 0
         console.error(`[getWorkingPythEndpoint] Primary Pyth endpoint failed, no fallback provided, using primary anyway`);
         return PRIMARY_PYTH_ENDPOINT;
     }
-});
+};
+/**
+ * Pick the price connection `initializeSuilend` will use.
+ *
+ * Lives here rather than in initialize.ts for two reasons: it belongs beside
+ * getWorkingPythEndpoint, the thing it decides whether to call; and this module
+ * imports nothing, so the seam is testable without resolving
+ * `@suilend/sui-core` (whose in-repo `exports` points at a .js file that does
+ * not exist, making initialize.ts unimportable from source).
+ *
+ * Skipping the probe for an injected connection is deliberate, not an
+ * optimisation. getWorkingPythEndpoint fetches hermes.pyth.network/live, which
+ * answers for whether Hermes is up — not for whether it still serves the
+ * caller's feeds, and not for whether the caller is even pointed at Hermes.
+ */
+export const resolvePythConnection = async (pythConnectionOverride, fallbackPythEndpoint) => {
+    if (pythConnectionOverride)
+        return pythConnectionOverride;
+    // Get a working Pyth endpoint (try primary, fallback to fallbackPythEndpoint if provided)
+    const pythEndpoint = await getWorkingPythEndpoint(fallbackPythEndpoint);
+    return new SuiPriceServiceConnection(pythEndpoint, {
+        timeout: 30 * 1000,
+    });
+};