@suilend/sdk 4.0.0 → 5.1.0

package/client.d.ts

@@ -1,3 +1,4 @@
+import { SuiClientTypes } from "@mysten/sui/client";
 import { SuiGrpcClient } from "@mysten/sui/grpc";
 import { Transaction, TransactionObjectArgument, TransactionObjectInput } from "@mysten/sui/transactions";
 import { SuiPriceServiceConnection, SuiPythClient } from "@pythnetwork/pyth-sui-js";
@@ -10,6 +11,17 @@ export declare const ADMIN_ADDRESS: string;
 export declare const LENDING_MARKET_REGISTRY_ID: string;
 export declare const LENDING_MARKET_ID: string, LENDING_MARKET_TYPE: string;
 export declare const STEAMM_LM_LENDING_MARKET_ID: string, STEAMM_LM_LENDING_MARKET_TYPE: string;
+export declare function getLatestPackageId(suiGrpcClient: SuiGrpcClient, upgradeCapId: string): Promise<any>;
+/**
+ * Lists every owned object of `type`, following pagination.
+ *
+ * `object_type` matches all instantiations when the type params are omitted
+ * (`0x2::coin::Coin` returns every `Coin<T>`), so passing a bare struct type
+ * lets one request serve callers that each only want their own type args.
+ * Filter the result on `obj.type` — comparing via normalizeStructTag, since
+ * the node returns fully-normalized addresses.
+ */
+export declare function listAllOwnedObjects<Include extends SuiClientTypes.ObjectInclude>(suiGrpcClient: SuiGrpcClient, owner: string, type: string, include?: Include): Promise<SuiClientTypes.Object<Include>[]>;
 export type ObligationWithUnclaimedRewards = {
     id: string;
     lendingMarketId?: string;
@@ -34,6 +46,14 @@ export declare class SuilendClient {
     pythConnection: SuiPriceServiceConnection;
     constructor(lendingMarket: LendingMarket<string>, suiGrpcClient: SuiGrpcClient);
     static initialize(lendingMarketId: string, lendingMarketType: string, suiGrpcClient: SuiGrpcClient, logPackageId?: boolean): Promise<SuilendClient>;
+    /**
+     * Same as `initialize`, but fetches every LendingMarket object in one
+     * request rather than one per market.
+     */
+    static initializeAll(lendingMarkets: {
+        id: string;
+        type: string;
+    }[], suiGrpcClient: SuiGrpcClient, logPackageId?: boolean): Promise<SuilendClient[]>;
     static getFeeReceivers(suiGrpcClient: SuiGrpcClient, lendingMarketId: string): Promise<{
         receivers: string[];
         weights: string[];
@@ -44,6 +64,7 @@ export declare class SuilendClient {
     };
     static getObligationOwnerCaps(ownerId: string, lendingMarketTypeArgs: string[], suiGrpcClient: SuiGrpcClient): Promise<ObligationOwnerCap<string>[]>;
     static getObligation(obligationId: string, lendingMarketTypeArgs: string[], suiGrpcClient: SuiGrpcClient): Promise<Obligation<string>>;
+    static getObligations(obligationIds: string[], lendingMarketTypeArgs: string[], suiGrpcClient: SuiGrpcClient): Promise<Obligation<string>[]>;
     getObligation(obligationId: string): Promise<Obligation<string>>;
     static getLendingMarketOwnerCapId(ownerId: string, lendingMarketTypeArgs: string[], suiGrpcClient: SuiGrpcClient): Promise<string | undefined>;
     getLendingMarketOwnerCapId(ownerId: string): Promise<string | undefined>;

package/client.js

@@ -1,4 +1,4 @@
-import { SUI_CLOCK_OBJECT_ID, SUI_SYSTEM_STATE_OBJECT_ID, normalizeStructTag, toHex, } from "@mysten/sui/utils";
+import { SUI_CLOCK_OBJECT_ID, SUI_SYSTEM_STATE_OBJECT_ID, normalizeStructTag, normalizeSuiObjectId, toHex, } from "@mysten/sui/utils";
 import { SuiPriceServiceConnection, SuiPythClient, } from "@pythnetwork/pyth-sui-js";
 import { extractCTokenCoinType, getAllCoins, getSpendableCoin, } from "@suilend/sui-core";
 import { PriceInfoObject } from "./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs.js";
@@ -14,6 +14,7 @@ import { createReserveConfig, } from "./_generated/suilend/reserve-config/functi
 import { PRIMARY_PYTH_ENDPOINT } from "./lib/pyth.js";
 import { createJsonRpcAdapter } from "./lib/pythAdapter.js";
 import { Side } from "./lib/types.js";
+import { chunkedMultiGet } from "./utils/obligation.js";
 const SUI_COINTYPE = "0x2::sui::SUI";
 const NORMALIZED_SUI_COINTYPE = normalizeStructTag(SUI_COINTYPE);
 const isSui = (coinType) => normalizeStructTag(coinType) === NORMALIZED_SUI_COINTYPE;
@@ -46,12 +47,86 @@ export const [STEAMM_LM_LENDING_MARKET_ID, STEAMM_LM_LENDING_MARKET_TYPE] = proc
         "0xc1888ec1b81a414e427a44829310508352aec38252ee0daa9f8b181b6947de9f",
         "0x0a071f4976abae1a7f722199cf0bfcbe695ef9408a878e7d12a7ca87b7e582a6::lp_rewards::LP_REWARDS",
     ];
-async function getLatestPackageId(suiGrpcClient, upgradeCapId) {
-    const { object } = await suiGrpcClient.getObject({
+// Keyed by upgradeCapId. Only dedupes calls that are still in flight — e.g.
+// initializing N lending markets at once each calling SuilendClient.initialize()
+// with the same upgrade cap. Deliberately not cached past settlement: this
+// runs on long-running indexer processes, and caching a success forever would
+// mean a real on-chain package upgrade is never picked up without a restart;
+// caching a failure forever would permanently break initialize() for one
+// transient RPC error.
+const latestPackageIdCache = new Map();
+export async function getLatestPackageId(suiGrpcClient, upgradeCapId) {
+    const cached = latestPackageIdCache.get(upgradeCapId);
+    if (cached)
+        return cached;
+    const promise = suiGrpcClient
+        .getObject({
         objectId: upgradeCapId,
         include: { json: true },
-    });
-    return object.json.package;
+    })
+        .then(({ object }) => object.json.package)
+        .finally(() => latestPackageIdCache.delete(upgradeCapId));
+    latestPackageIdCache.set(upgradeCapId, promise);
+    return promise;
+}
+// Keyed by owner + type + include mask, and scoped to the issuing client: two
+// SuiGrpcClients can point at different endpoints or networks (this file builds
+// beta-vs-mainnet constants off NEXT_PUBLIC_SUILEND_USE_BETA_MARKET, and a
+// frontend swapping RPCs holds both clients briefly), so one client must never
+// be served another's in-flight response.
+//
+// Same in-flight-only contract as latestPackageIdCache above: N lending markets
+// asking for the same owner's caps at once collapse to one request, and the
+// entry is dropped on settle so long-running processes never serve a stale
+// object list.
+const ownedObjectsCache = new WeakMap();
+function ownedObjectsCacheFor(suiGrpcClient) {
+    const existing = ownedObjectsCache.get(suiGrpcClient);
+    if (existing)
+        return existing;
+    const created = new Map();
+    ownedObjectsCache.set(suiGrpcClient, created);
+    return created;
+}
+/**
+ * Lists every owned object of `type`, following pagination.
+ *
+ * `object_type` matches all instantiations when the type params are omitted
+ * (`0x2::coin::Coin` returns every `Coin<T>`), so passing a bare struct type
+ * lets one request serve callers that each only want their own type args.
+ * Filter the result on `obj.type` — comparing via normalizeStructTag, since
+ * the node returns fully-normalized addresses.
+ */
+export async function listAllOwnedObjects(suiGrpcClient, owner, type, include) {
+    // Encodes each flag's value, not just its presence, so {content: true} and
+    // {content: false} cannot collide on one key.
+    const key = `${owner}|${type}|${Object.entries(include ?? {})
+        .map(([flag, value]) => `${flag}=${value}`)
+        .sort()
+        .join(",")}`;
+    const cache = ownedObjectsCacheFor(suiGrpcClient);
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    const promise = (async () => {
+        const allObjs = [];
+        let cursor = null;
+        let hasNextPage = true;
+        while (hasNextPage) {
+            const objs = await suiGrpcClient.listOwnedObjects({
+                owner,
+                cursor,
+                type,
+                include,
+            });
+            allObjs.push(...objs.objects);
+            cursor = objs.cursor;
+            hasNextPage = objs.hasNextPage;
+        }
+        return allObjs;
+    })().finally(() => cache.delete(key));
+    cache.set(key, promise);
+    return promise;
 }
 export class SuilendClient {
     lendingMarket;
@@ -75,6 +150,53 @@ export class SuilendClient {
         setPublishedAt(publishedAt);
         return new SuilendClient(lendingMarket, suiGrpcClient);
     }
+    /**
+     * Same as `initialize`, but fetches every LendingMarket object in one
+     * request rather than one per market.
+     */
+    static async initializeAll(lendingMarkets, suiGrpcClient, logPackageId) {
+        // Refreshed even for an empty list, so PUBLISHED_AT parity with
+        // initialize() holds for every call — move-call targets are built off that
+        // module global regardless of how many clients came back.
+        const publishedAt = await getLatestPackageId(suiGrpcClient, SUILEND_UPGRADE_CAP_ID);
+        if (logPackageId)
+            console.log("@suilend/sdk | publishedAt:", publishedAt);
+        setPublishedAt(publishedAt);
+        if (lendingMarkets.length === 0)
+            return [];
+        const { objects } = await suiGrpcClient.getObjects({
+            objectIds: lendingMarkets.map((lendingMarket) => lendingMarket.id),
+            include: { content: true },
+        });
+        // Paired by objectId rather than by position: BatchGetObjectsResponse
+        // documents no ordering guarantee, and every object here is a
+        // LendingMarket, so a type check cannot catch a reordered response — it
+        // would silently attach the wrong type arg to a market.
+        const objectById = new Map();
+        const failures = [];
+        for (const object of objects) {
+            // The error branch of GetObjectResult carries no objectId, so a failed
+            // entry cannot be attributed by id. Rather than fall back to position —
+            // which the pairing above deliberately does not trust — failures are
+            // identified by which requested ids are missing below.
+            if (object instanceof Error)
+                failures.push(object);
+            else
+                objectById.set(normalizeSuiObjectId(object.objectId), object);
+        }
+        return lendingMarkets.map(({ id, type }) => {
+            const object = objectById.get(normalizeSuiObjectId(id));
+            if (!object)
+                throw new Error(`Failed to fetch lending market ${id}${failures.length > 0 ? `: ${failures[0].message}` : ""}`, failures.length > 0 ? { cause: failures[0] } : undefined);
+            // Compares the full parameterized type, not just the struct name: an
+            // id/type pair built from two drifted lists would otherwise pass and
+            // decode under the wrong phantom type.
+            const expectedType = normalizeStructTag(`${PACKAGE_ID}::lending_market::LendingMarket<${type}>`);
+            if (normalizeStructTag(object.type) !== expectedType)
+                throw new Error(`object at id ${id} is not a LendingMarket<${type}> (got ${object.type})`);
+            return new SuilendClient(LendingMarket.fromBcs(phantom(type), object.content), suiGrpcClient);
+        });
+    }
     static async getFeeReceivers(suiGrpcClient, lendingMarketId) {
         const { dynamicField } = await suiGrpcClient.getDynamicField({
             parentId: lendingMarketId,
@@ -102,21 +224,11 @@ export class SuilendClient {
         return ownerCap;
     }
     static async getObligationOwnerCaps(ownerId, lendingMarketTypeArgs, suiGrpcClient) {
-        const allObjs = [];
-        let cursor = null;
-        let hasNextPage = true;
-        while (hasNextPage) {
-            const objs = await suiGrpcClient.listOwnedObjects({
-                owner: ownerId,
-                cursor,
-                type: `${PACKAGE_ID}::lending_market::ObligationOwnerCap<${lendingMarketTypeArgs[0]}>`,
-                include: { content: true },
-            });
-            allObjs.push(...objs.objects);
-            cursor = objs.cursor;
-            hasNextPage = objs.hasNextPage;
-        }
-        return allObjs.map((obj) => ObligationOwnerCap.fromBcs(phantom(lendingMarketTypeArgs[0]), obj.content));
+        const allObjs = await listAllOwnedObjects(suiGrpcClient, ownerId, `${PACKAGE_ID}::lending_market::ObligationOwnerCap`, { content: true });
+        const type = normalizeStructTag(`${PACKAGE_ID}::lending_market::ObligationOwnerCap<${lendingMarketTypeArgs[0]}>`);
+        return allObjs
+            .filter((obj) => normalizeStructTag(obj.type) === type)
+            .map((obj) => ObligationOwnerCap.fromBcs(phantom(lendingMarketTypeArgs[0]), obj.content));
     }
     static async getObligation(obligationId, lendingMarketTypeArgs, suiGrpcClient) {
         const { object } = await suiGrpcClient.getObject({
@@ -125,18 +237,27 @@ export class SuilendClient {
         });
         return Obligation.fromBcs(phantom(lendingMarketTypeArgs[0]), object.content);
     }
+    // Batched analog of getObligation — chunkedMultiGet issues one getObjects
+    // call per 50 ids, run concurrently, instead of one getObject round-trip
+    // per id.
+    static async getObligations(obligationIds, lendingMarketTypeArgs, suiGrpcClient) {
+        if (obligationIds.length === 0)
+            return [];
+        const objects = await chunkedMultiGet(suiGrpcClient, obligationIds);
+        return objects.map((object) => {
+            if (object instanceof Error)
+                throw object;
+            return Obligation.fromBcs(phantom(lendingMarketTypeArgs[0]), object.content);
+        });
+    }
     async getObligation(obligationId) {
         return SuilendClient.getObligation(obligationId, this.lendingMarket.$typeArgs, this.suiGrpcClient);
     }
     static async getLendingMarketOwnerCapId(ownerId, lendingMarketTypeArgs, suiGrpcClient) {
-        const objs = await suiGrpcClient.listOwnedObjects({
-            owner: ownerId,
-            type: `${PACKAGE_ID}::lending_market::LendingMarketOwnerCap<${lendingMarketTypeArgs[0]}>`,
-        });
-        if (objs.objects.length > 0)
-            return objs.objects[0].objectId;
-        else
-            return undefined;
+        const allObjs = await listAllOwnedObjects(suiGrpcClient, ownerId, `${PACKAGE_ID}::lending_market::LendingMarketOwnerCap`);
+        const type = normalizeStructTag(`${PACKAGE_ID}::lending_market::LendingMarketOwnerCap<${lendingMarketTypeArgs[0]}>`);
+        return allObjs.find((obj) => normalizeStructTag(obj.type) === type)
+            ?.objectId;
     }
     async getLendingMarketOwnerCapId(ownerId) {
         return SuilendClient.getLendingMarketOwnerCapId(ownerId, this.lendingMarket.$typeArgs, this.suiGrpcClient);

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;

package/lib/initialize.js

@@ -1,12 +1,11 @@
 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-core";
-import { LENDING_MARKET_ID, SuilendClient } from "../client.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, getCoinMetadataMap, getPrice, isSendPoints, isSteammPoints, } from "@suilend/sui-core";
+import { LENDING_MARKET_ID, SuilendClient, listAllOwnedObjects, } 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]: [
@@ -85,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 = async (suiGrpcClient, suilendClient, lendingMarketMetadata, fallbackPythEndpoint) => {
+/**
+ * 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));
@@ -100,35 +171,35 @@ export const initializeSuilend = async (suiGrpcClient, suilendClient, lendingMar
             reservesWithoutTemporaryPythPriceFeeds.push(reserve);
         }
     }
-    // Get a working Pyth endpoint (try primary, fallback to fallbackPythEndpoint if provided)
-    const pythEndpoint = await getWorkingPythEndpoint(fallbackPythEndpoint);
-    const pythConnection = new SuiPriceServiceConnection(pythEndpoint, {
-        timeout: 30 * 1000,
-    });
-    const [refreshedReservesWithoutTemporaryPythPriceFeeds] = await Promise.all([
-        simulate.refreshReservePrice(reservesWithoutTemporaryPythPriceFeeds, pythConnection),
-        Promise.all(reservesWithTemporaryPythPriceFeeds.map((reserve) => (async () => {
-            let cachedUsdPrice;
-            try {
-                cachedUsdPrice = await 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,
@@ -193,6 +264,7 @@ export const initializeSuilend = async (suiGrpcClient, suilendClient, lendingMar
         lendingMarket,
         coinMetadataMap,
         refreshedRawReserves,
+        unpricedCoinTypes,
         reserveMap,
         reserveCoinTypes: uniqueReserveCoinTypes,
         reserveCoinMetadataMap,
@@ -230,7 +302,9 @@ export const initializeObligations = async (suiGrpcClient, suilendClient, refres
             const hasStrategies = Object.values(STRATEGY_TYPE_INFO_MAP).some((info) => info.lendingMarketId === suilendClient.lendingMarket.id);
             if (!hasStrategies)
                 return [];
-            const objects = await getAllOwnedObjects(suiGrpcClient, address, `${STRATEGY_WRAPPER_PACKAGE_ID_V1}::strategy_wrapper::StrategyOwnerCap<${suilendClient.lendingMarket.$typeArgs[0]}>`);
+            const allObjects = await listAllOwnedObjects(suiGrpcClient, address, `${STRATEGY_WRAPPER_PACKAGE_ID_V1}::strategy_wrapper::StrategyOwnerCap`, { json: true });
+            const type = normalizeStructTag(`${STRATEGY_WRAPPER_PACKAGE_ID_V1}::strategy_wrapper::StrategyOwnerCap<${suilendClient.lendingMarket.$typeArgs[0]}>`);
+            const objects = allObjects.filter((obj) => normalizeStructTag(obj.type) === type);
             return objects.map((obj) => {
                 const json = obj.json;
                 const id = json.id;
@@ -248,10 +322,10 @@ export const initializeObligations = async (suiGrpcClient, suilendClient, refres
         })(),
         SuilendClient.getObligationOwnerCaps(address, suilendClient.lendingMarket.$typeArgs, suiGrpcClient),
     ]);
-    const obligations = (await Promise.all([
+    const obligations = (await SuilendClient.getObligations([
         ...strategyOwnerCaps.map((soc) => soc.obligationId),
         ...obligationOwnerCaps.map((ownerCap) => ownerCap.obligationId),
-    ].map((obligationId) => SuilendClient.getObligation(obligationId, suilendClient.lendingMarket.$typeArgs, suiGrpcClient))))
+    ], suilendClient.lendingMarket.$typeArgs, suiGrpcClient))
         .map((rawObligation) => simulate.refreshObligation(rawObligation, refreshedRawReserves))
         .map((refreshedObligation) => parseObligation(refreshedObligation, reserveMap, strategyOwnerCaps.some((soc) => soc.obligationId === refreshedObligation.id)))
         .sort((a, b) => +b.netValueUsd.minus(a.netValueUsd));

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,3 +1,4 @@
+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
@@ -37,3 +38,26 @@ export const getWorkingPythEndpoint = async (fallbackPythEndpoint) => {
         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,
+    });
+};

package/package.json

@@ -1 +1 @@
-{"name":"@suilend/sdk","version":"4.0.0","private":false,"description":"A TypeScript SDK for interacting with the Suilend program","author":"Suilend","license":"MIT","main":"./index.js","exports":{".":"./index.js","./mmt":"./mmt.js","./strategies":"./strategies.js","./client":"./client.js","./utils":"./utils/index.js","./utils/simulate":"./utils/simulate.js","./utils/obligation":"./utils/obligation.js","./utils/events":"./utils/events.js","./margin":"./margin/index.js","./lib/transactions":"./lib/transactions.js","./lib/strategyOwnerCap":"./lib/strategyOwnerCap.js","./lib/constants":"./lib/constants.js","./lib/types":"./lib/types.js","./lib":"./lib/index.js","./lib/pyth":"./lib/pyth.js","./lib/liquidityMining":"./lib/liquidityMining.js","./lib/initialize":"./lib/initialize.js","./lib/pythAdapter":"./lib/pythAdapter.js","./swap":"./swap/index.js","./swap/transaction":"./swap/transaction.js","./swap/quote":"./swap/quote.js","./parsers/reserve":"./parsers/reserve.js","./parsers/rateLimiter":"./parsers/rateLimiter.js","./parsers":"./parsers/index.js","./parsers/apiReserveAssetDataEvent":"./parsers/apiReserveAssetDataEvent.js","./parsers/obligation":"./parsers/obligation.js","./parsers/lendingMarket":"./parsers/lendingMarket.js","./api":"./api/index.js","./api/events":"./api/events.js","./margin/utils":"./margin/utils/index.js","./margin/margin/market":"./margin/margin/market.js","./margin/margin/version":"./margin/margin/version.js","./margin/margin/position":"./margin/margin/position.js","./margin/margin/router":"./margin/margin/router.js","./margin/margin/admin_cap":"./margin/margin/admin_cap.js","./margin/margin/permissions":"./margin/margin/permissions.js","./_generated/suilend":"./_generated/suilend/index.js","./_generated/_framework/reified":"./_generated/_framework/reified.js","./_generated/_framework/util":"./_generated/_framework/util.js","./_generated/_framework/vector":"./_generated/_framework/vector.js","./_generated/suilend/lending-market-registry/functions":"./_generated/suilend/lending-market-registry/functions.js","./_generated/suilend/obligation/structs":"./_generated/suilend/obligation/structs.js","./_generated/suilend/reserve-config/structs":"./_generated/suilend/reserve-config/structs.js","./_generated/suilend/reserve-config/functions":"./_generated/suilend/reserve-config/functions.js","./_generated/suilend/rate-limiter/structs":"./_generated/suilend/rate-limiter/structs.js","./_generated/suilend/rate-limiter/functions":"./_generated/suilend/rate-limiter/functions.js","./_generated/suilend/cell/structs":"./_generated/suilend/cell/structs.js","./_generated/suilend/liquidity-mining/structs":"./_generated/suilend/liquidity-mining/structs.js","./_generated/suilend/lending-market/structs":"./_generated/suilend/lending-market/structs.js","./_generated/suilend/lending-market/functions":"./_generated/suilend/lending-market/functions.js","./_generated/suilend/decimal/structs":"./_generated/suilend/decimal/structs.js","./_generated/suilend/reserve/structs":"./_generated/suilend/reserve/structs.js","./margin/margin/deps/suilend/lending_market":"./margin/margin/deps/suilend/lending_market.js","./margin/margin/deps/sui/vec_set":"./margin/margin/deps/sui/vec_set.js","./margin/margin/deps/std/type_name":"./margin/margin/deps/std/type_name.js","./_generated/_dependencies/source/0x1":"./_generated/_dependencies/source/0x1/index.js","./_generated/_dependencies/source/0x2":"./_generated/_dependencies/source/0x2/index.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/index.js","./_generated/_dependencies/source/0x1/option/structs":"./_generated/_dependencies/source/0x1/option/structs.js","./_generated/_dependencies/source/0x1/ascii/structs":"./_generated/_dependencies/source/0x1/ascii/structs.js","./_generated/_dependencies/source/0x1/type-name/structs":"./_generated/_dependencies/source/0x1/type-name/structs.js","./_generated/_dependencies/source/0x2/balance/structs":"./_generated/_dependencies/source/0x2/balance/structs.js","./_generated/_dependencies/source/0x2/object/structs":"./_generated/_dependencies/source/0x2/object/structs.js","./_generated/_dependencies/source/0x2/object-table/structs":"./_generated/_dependencies/source/0x2/object-table/structs.js","./_generated/_dependencies/source/0x2/bag/structs":"./_generated/_dependencies/source/0x2/bag/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-identifier/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-identifier/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-feed/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-feed/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/i64/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/i64/structs.js"},"types":"./index.d.ts","scripts":{"build":"rm -rf ./dist && bun tsc && node ./fix-esm-imports.js","typecheck":"tsc --noEmit","lint:ci":"tsc --noEmit","prettier":"prettier --write src/","release":"bun run build && bun ./release.js && cd ./dist && npm publish --access public"},"repository":{"type":"git","url":"git+https://github.com/fireflyprotocol/lending-mono.git","directory":"ts/sdks/sdk"},"dependencies":{"@bluefin-exchange/bluefin7k-aggregator-sdk":"^7.3.0","@cetusprotocol/aggregator-sdk":"^1.5.7","@flowx-finance/sdk":"^2.1.0","@pythnetwork/pyth-sui-js":"2.2.0","@suilend/springsui-sdk":"^4.0.0","bignumber.js":"^9.1.2","bn.js":"^5.2.2","crypto-js":"^4.2.0","lodash":"^4.17.21","p-limit":"3.1.0","uuid":"^11.0.3"},"devDependencies":{"@types/bn.js":"^5.2.0","@types/lodash":"^4.17.20","ts-node":"^10.9.2","typescript":"^5.6.3","@tsconfig/recommended":"^1.0.8","@types/node":"^22.9.0"},"peerDependencies":{"@mysten/bcs":"^2.0.5","@mysten/sui":"2.17.0","@suilend/sui-core":"^0.1.0"},"type":"module"}
+{"name":"@suilend/sdk","version":"5.1.0","private":false,"description":"A TypeScript SDK for interacting with the Suilend program","author":"Suilend","license":"MIT","main":"./index.js","exports":{".":"./index.js","./mmt":"./mmt.js","./strategies":"./strategies.js","./client":"./client.js","./utils":"./utils/index.js","./utils/simulate":"./utils/simulate.js","./utils/obligation":"./utils/obligation.js","./utils/events":"./utils/events.js","./margin":"./margin/index.js","./lib/transactions":"./lib/transactions.js","./lib/strategyOwnerCap":"./lib/strategyOwnerCap.js","./lib/constants":"./lib/constants.js","./lib/types":"./lib/types.js","./lib":"./lib/index.js","./lib/pyth":"./lib/pyth.js","./lib/liquidityMining":"./lib/liquidityMining.js","./lib/initialize":"./lib/initialize.js","./lib/pythAdapter":"./lib/pythAdapter.js","./swap":"./swap/index.js","./swap/transaction":"./swap/transaction.js","./swap/quote":"./swap/quote.js","./parsers/reserve":"./parsers/reserve.js","./parsers/rateLimiter":"./parsers/rateLimiter.js","./parsers":"./parsers/index.js","./parsers/apiReserveAssetDataEvent":"./parsers/apiReserveAssetDataEvent.js","./parsers/obligation":"./parsers/obligation.js","./parsers/lendingMarket":"./parsers/lendingMarket.js","./api":"./api/index.js","./api/events":"./api/events.js","./margin/utils":"./margin/utils/index.js","./margin/margin/market":"./margin/margin/market.js","./margin/margin/version":"./margin/margin/version.js","./margin/margin/position":"./margin/margin/position.js","./margin/margin/router":"./margin/margin/router.js","./margin/margin/admin_cap":"./margin/margin/admin_cap.js","./margin/margin/permissions":"./margin/margin/permissions.js","./_generated/suilend":"./_generated/suilend/index.js","./_generated/_framework/reified":"./_generated/_framework/reified.js","./_generated/_framework/util":"./_generated/_framework/util.js","./_generated/_framework/vector":"./_generated/_framework/vector.js","./_generated/suilend/lending-market-registry/functions":"./_generated/suilend/lending-market-registry/functions.js","./_generated/suilend/obligation/structs":"./_generated/suilend/obligation/structs.js","./_generated/suilend/reserve-config/structs":"./_generated/suilend/reserve-config/structs.js","./_generated/suilend/reserve-config/functions":"./_generated/suilend/reserve-config/functions.js","./_generated/suilend/rate-limiter/structs":"./_generated/suilend/rate-limiter/structs.js","./_generated/suilend/rate-limiter/functions":"./_generated/suilend/rate-limiter/functions.js","./_generated/suilend/cell/structs":"./_generated/suilend/cell/structs.js","./_generated/suilend/liquidity-mining/structs":"./_generated/suilend/liquidity-mining/structs.js","./_generated/suilend/lending-market/structs":"./_generated/suilend/lending-market/structs.js","./_generated/suilend/lending-market/functions":"./_generated/suilend/lending-market/functions.js","./_generated/suilend/decimal/structs":"./_generated/suilend/decimal/structs.js","./_generated/suilend/reserve/structs":"./_generated/suilend/reserve/structs.js","./margin/margin/deps/suilend/lending_market":"./margin/margin/deps/suilend/lending_market.js","./margin/margin/deps/sui/vec_set":"./margin/margin/deps/sui/vec_set.js","./margin/margin/deps/std/type_name":"./margin/margin/deps/std/type_name.js","./_generated/_dependencies/source/0x1":"./_generated/_dependencies/source/0x1/index.js","./_generated/_dependencies/source/0x2":"./_generated/_dependencies/source/0x2/index.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/index.js","./_generated/_dependencies/source/0x1/option/structs":"./_generated/_dependencies/source/0x1/option/structs.js","./_generated/_dependencies/source/0x1/ascii/structs":"./_generated/_dependencies/source/0x1/ascii/structs.js","./_generated/_dependencies/source/0x1/type-name/structs":"./_generated/_dependencies/source/0x1/type-name/structs.js","./_generated/_dependencies/source/0x2/balance/structs":"./_generated/_dependencies/source/0x2/balance/structs.js","./_generated/_dependencies/source/0x2/object/structs":"./_generated/_dependencies/source/0x2/object/structs.js","./_generated/_dependencies/source/0x2/object-table/structs":"./_generated/_dependencies/source/0x2/object-table/structs.js","./_generated/_dependencies/source/0x2/bag/structs":"./_generated/_dependencies/source/0x2/bag/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-identifier/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-identifier/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-feed/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-feed/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/i64/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/i64/structs.js"},"types":"./index.d.ts","scripts":{"build":"rm -rf ./dist && bun tsc && node ./fix-esm-imports.js","typecheck":"tsc --noEmit && tsc --noEmit -p tsconfig.test.json","test":"bun test tests/","lint:ci":"bun run typecheck","prettier":"prettier --write src/ tests/","release":"bun run build && bun ./release.js && cd ./dist && npm publish --access public"},"repository":{"type":"git","url":"git+https://github.com/fireflyprotocol/lending-mono.git","directory":"ts/sdks/sdk"},"dependencies":{"@bluefin-exchange/bluefin7k-aggregator-sdk":"^7.3.0","@cetusprotocol/aggregator-sdk":"^1.5.7","@flowx-finance/sdk":"^2.1.0","@pythnetwork/pyth-sui-js":"2.2.0","@suilend/springsui-sdk":"^4.0.0","bignumber.js":"^9.1.2","bn.js":"^5.2.2","crypto-js":"^4.2.0","lodash":"^4.17.21","p-limit":"3.1.0","uuid":"^11.0.3"},"devDependencies":{"@types/bn.js":"^5.2.0","@types/lodash":"^4.17.20","ts-node":"^10.9.2","typescript":"^6.0.3","@tsconfig/recommended":"^1.0.8","@types/node":"^22.9.0"},"peerDependencies":{"@mysten/bcs":"^2.0.5","@mysten/sui":"2.17.0","@suilend/sui-core":"^1.0.0"},"type":"module"}

package/utils/obligation.d.ts

@@ -1,9 +1,13 @@
+import { SuiClientTypes } from "@mysten/sui/client";
 import { SuiGraphQLClient } from "@mysten/sui/graphql";
 import { SuiGrpcClient } from "@mysten/sui/grpc";
 import { Obligation } from "../_generated/suilend/obligation/structs";
 import { ParsedObligation } from "../parsers";
 export declare function fetchAllObligationsForMarketWithHandler(suiGrpcClient: SuiGrpcClient, lendingMarketId: string, lendingMarketType: string, chunkHandler: (obligations: Obligation<string>[]) => Promise<void>): Promise<void>;
 export declare function fetchAllObligationsForMarket(suiGrpcClient: SuiGrpcClient, lendingMarketId: string, lendingMarketType: string): Promise<Obligation<string>[]>;
+export declare function chunkedMultiGet(suiGrpcClient: SuiGrpcClient, objectIds: string[]): Promise<(Error | SuiClientTypes.Object<{
+    content: true;
+}>)[]>;
 export type FormattedObligationHistory = NonLiquidationHistoryEvent | LiquidationHistoryEvent;
 export type NonLiquidationHistoryEvent = {
     reserveId: string;

package/utils/obligation.js

@@ -66,7 +66,7 @@ export async function fetchAllObligationsForMarket(suiGrpcClient, lendingMarketI
     }
     return obligations;
 }
-async function chunkedMultiGet(suiGrpcClient, objectIds) {
+export async function chunkedMultiGet(suiGrpcClient, objectIds) {
     const limit = pLimit(30);
     const results = [];
     const chunks = splitIntoChunks(objectIds, 50);

package/utils/simulate.d.ts

@@ -1,4 +1,4 @@
-import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
+import { PriceFeed, SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 import BigNumber from "bignumber.js";
 import { Decimal } from "../_generated/suilend/decimal/structs";
 import { PoolRewardManager, UserRewardManager } from "../_generated/suilend/liquidity-mining/structs";
@@ -22,6 +22,73 @@ export declare const calculateDepositAprPercent: (reserve: Reserve<string>) => B
 export declare const compoundReserveInterest: (reserve: Reserve<string>, nowS: number) => Reserve<string>;
 export declare const updatePoolRewardsManager: (manager: PoolRewardManager, nowMs: number) => PoolRewardManager;
 export declare const refreshReservePrice: (reserves: Reserve<string>[], pythConnection: SuiPriceServiceConnection) => Promise<Reserve<string>[]>;
+/**
+ * A connection that can report which of the requested feeds it could not serve,
+ * instead of failing the whole batch. Structural on purpose: any object with
+ * this method qualifies, so a caller can inject its own client without this
+ * package depending on it.
+ */
+export interface PartialPriceFeedSource {
+    getLatestPriceFeedsPartial(ids: string[]): Promise<{
+        feeds: PriceFeed[];
+        missing: string[];
+    }>;
+}
+/**
+ * Whether this connection can report WHICH requested feeds it could not serve.
+ *
+ * Exported because it is a precondition callers need to check, not just an
+ * internal branch: `tolerateMissingPriceFeeds` is meaningless without it (see
+ * `refreshReservesForInitialize`, which refuses the combination).
+ */
+export declare function canReportMissingPriceFeeds(connection: SuiPriceServiceConnection | PartialPriceFeedSource): connection is PartialPriceFeedSource;
+/**
+ * The remedy both gap-tolerance failure paths point at.
+ *
+ * One constant because the two paths fail at different moments for the same
+ * underlying reason — `refreshReservesForInitialize` refuses up front on
+ * capability, `refreshReservePriceTolerant` only once an endpoint actually
+ * rejects a batch — and separately worded advice for one cause is how the two
+ * drift apart.
+ */
+export declare const PARTIAL_FETCH_REQUIRED_HINT = "inject a connection implementing getLatestPriceFeedsPartial (e.g. a failover connection that reports per-feed gaps)";
+/**
+ * Like `refreshReservePrice`, but a reserve whose feed no endpoint can serve
+ * keeps the price already in its on-chain state instead of failing every other
+ * reserve with it.
+ *
+ * `refreshReservePrice` is all-or-nothing in both directions, and both are
+ * hazardous once an endpoint stops carrying every feed: a missing feed throws
+ * (so one retired market blinds pricing for the whole lending market), while an
+ * undefined response silently returns EVERY reserve at its stale price with no
+ * signal at all. Hermes v2 rejects an entire batch when any requested id is
+ * unknown, which makes both reachable in practice.
+ *
+ * This reports `unpricedCoinTypes` rather than deciding what an unpriceable
+ * reserve means — that judgement needs reserve config the caller has and this
+ * function should not second-guess. Nothing is ever fabricated here.
+ *
+ * TWO THINGS A CALLER MUST KNOW:
+ *
+ * 1. An unpriced reserve is returned in `reserves` carrying whatever price its
+ *    on-chain state holds — which may be ZERO for a reserve that was never
+ *    priced on-chain. Folding `reserves` into collateral or borrow-limit math
+ *    without first excluding `unpricedCoinTypes` therefore prices that reserve
+ *    at literal zero. `unpricedCoinTypes` is the only thing distinguishing a
+ *    real price from a kept one; it is not optional to read.
+ * 2. Tolerance requires a connection that can REPORT a gap
+ *    (`getLatestPriceFeedsPartial`). Handed a stock `SuiPriceServiceConnection`,
+ *    this falls back to the all-or-nothing fetch, which Hermes v2 answers with
+ *    a 404 for the whole batch when any id is unknown — so there is nothing
+ *    left to be tolerant with. That fetch is kept because it is correct for an
+ *    endpoint that OMITS unknown ids rather than rejecting the batch, but the
+ *    failure is re-thrown with attribution rather than surfacing as a bare HTTP
+ *    error. `refreshReservesForInitialize` rejects the combination outright.
+ */
+export declare const refreshReservePriceTolerant: (reserves: Reserve<string>[], pythConnection: SuiPriceServiceConnection | PartialPriceFeedSource) => Promise<{
+    reserves: Reserve<string>[];
+    unpricedCoinTypes: string[];
+}>;
 export declare const updateUserRewardManager: (poolManager: PoolRewardManager, userRewardManager: UserRewardManager, nowMs: number) => UserRewardManager;
 export declare const refreshObligation: (unrefreshedObligation: Obligation<string>, refreshedReserves: Reserve<string>[]) => Obligation<string>;
 export declare const numberToDecimal: (value: number) => Decimal;

package/utils/simulate.js

@@ -1,5 +1,5 @@
 import { bcs } from "@mysten/sui/bcs";
-import { toHex } from "@mysten/sui/utils";
+import { normalizeStructTag, toHex } from "@mysten/sui/utils";
 import BigNumber from "bignumber.js";
 import { v4 as uuidv4 } from "uuid";
 import { Decimal } from "../_generated/suilend/decimal/structs.js";
@@ -118,25 +118,151 @@ export const updatePoolRewardsManager = (manager, nowMs) => {
     updatedManager.lastUpdateTimeMs = BigInt(nowMs);
     return updatedManager;
 };
+/** The Pyth feed id a reserve is priced from, in the response's `id` encoding. */
+const reserveFeedId = (reserve) => toHex(new Uint8Array(reserve.priceIdentifier.bytes));
+/**
+ * Index feeds by id for O(1) lookup, keeping the FIRST entry per id.
+ *
+ * First-wins matches the `priceFeeds.find(...)` this replaced, so a duplicated
+ * id in a response resolves to the same feed it always did. Pyth does not
+ * duplicate ids today; the point is that switching to a Map is not allowed to
+ * quietly change which one is picked if it ever does.
+ */
+const indexFeedsById = (priceFeeds) => {
+    const byId = new Map();
+    for (const feed of priceFeeds)
+        if (!byId.has(feed.id))
+            byId.set(feed.id, feed);
+    return byId;
+};
+/**
+ * Apply a feed's price to a COPY of `reserve`.
+ *
+ * Shared by both refresh functions so the price-mapping math has exactly one
+ * definition. It was duplicated verbatim, which meant a change to how a feed
+ * becomes a price had to be made twice or the two silently diverged.
+ *
+ * The two functions still own their own control flow — what a MISSING feed
+ * means is precisely where they are supposed to differ (see
+ * `refreshReservePriceTolerant`).
+ */
+const withFeedPrice = (reserve, priceFeed) => {
+    const newReserve = { ...reserve };
+    newReserve.price = stringToDecimal(priceFeed.getPriceUnchecked().getPriceAsNumberUnchecked().toString());
+    newReserve.smoothedPrice = stringToDecimal(priceFeed.getEmaPriceUnchecked().getPriceAsNumberUnchecked().toString());
+    newReserve.priceLastUpdateTimestampS = BigInt(priceFeed.getPriceUnchecked().publishTime);
+    return newReserve;
+};
 export const refreshReservePrice = async (reserves, pythConnection) => {
-    const priceIdentifiers = Array.from(new Set(reserves.map((r) => toHex(new Uint8Array(r.priceIdentifier.bytes)))));
+    const priceIdentifiers = Array.from(new Set(reserves.map(reserveFeedId)));
     const priceFeeds = await pythConnection.getLatestPriceFeeds(priceIdentifiers);
+    // Deliberately NOT a throw, and deliberately not expressed over the tolerant
+    // function below: consumers outside this repo depend on `undefined` meaning
+    // "keep every reserve's existing price". Hazardous (see the tolerant
+    // function's comment), but changing it here would turn a quiet failure loud
+    // under callers who never asked for that.
     if (!priceFeeds)
         return reserves;
+    const byId = indexFeedsById(priceFeeds);
     const updatedReserves = [];
     for (let i = 0; i < reserves.length; i++) {
         const reserve = reserves[i];
-        const priceFeed = priceFeeds.find((p) => p.id === toHex(new Uint8Array(reserve.priceIdentifier.bytes)));
+        const priceFeed = byId.get(reserveFeedId(reserve));
         if (!priceFeed)
             throw new Error(`Price feed not found for reserve ${reserve.coinType.name}`);
-        const newReserve = { ...reserve };
-        newReserve.price = stringToDecimal(priceFeed.getPriceUnchecked().getPriceAsNumberUnchecked().toString());
-        newReserve.smoothedPrice = stringToDecimal(priceFeed.getEmaPriceUnchecked().getPriceAsNumberUnchecked().toString());
-        newReserve.priceLastUpdateTimestampS = BigInt(priceFeed.getPriceUnchecked().publishTime);
-        updatedReserves.push(newReserve);
+        updatedReserves.push(withFeedPrice(reserve, priceFeed));
     }
     return updatedReserves;
 };
+/**
+ * Whether this connection can report WHICH requested feeds it could not serve.
+ *
+ * Exported because it is a precondition callers need to check, not just an
+ * internal branch: `tolerateMissingPriceFeeds` is meaningless without it (see
+ * `refreshReservesForInitialize`, which refuses the combination).
+ */
+export function canReportMissingPriceFeeds(connection) {
+    return (typeof connection.getLatestPriceFeedsPartial ===
+        "function");
+}
+/**
+ * The remedy both gap-tolerance failure paths point at.
+ *
+ * One constant because the two paths fail at different moments for the same
+ * underlying reason — `refreshReservesForInitialize` refuses up front on
+ * capability, `refreshReservePriceTolerant` only once an endpoint actually
+ * rejects a batch — and separately worded advice for one cause is how the two
+ * drift apart.
+ */
+export const PARTIAL_FETCH_REQUIRED_HINT = "inject a connection implementing getLatestPriceFeedsPartial (e.g. a failover connection that reports per-feed gaps)";
+/**
+ * Like `refreshReservePrice`, but a reserve whose feed no endpoint can serve
+ * keeps the price already in its on-chain state instead of failing every other
+ * reserve with it.
+ *
+ * `refreshReservePrice` is all-or-nothing in both directions, and both are
+ * hazardous once an endpoint stops carrying every feed: a missing feed throws
+ * (so one retired market blinds pricing for the whole lending market), while an
+ * undefined response silently returns EVERY reserve at its stale price with no
+ * signal at all. Hermes v2 rejects an entire batch when any requested id is
+ * unknown, which makes both reachable in practice.
+ *
+ * This reports `unpricedCoinTypes` rather than deciding what an unpriceable
+ * reserve means — that judgement needs reserve config the caller has and this
+ * function should not second-guess. Nothing is ever fabricated here.
+ *
+ * TWO THINGS A CALLER MUST KNOW:
+ *
+ * 1. An unpriced reserve is returned in `reserves` carrying whatever price its
+ *    on-chain state holds — which may be ZERO for a reserve that was never
+ *    priced on-chain. Folding `reserves` into collateral or borrow-limit math
+ *    without first excluding `unpricedCoinTypes` therefore prices that reserve
+ *    at literal zero. `unpricedCoinTypes` is the only thing distinguishing a
+ *    real price from a kept one; it is not optional to read.
+ * 2. Tolerance requires a connection that can REPORT a gap
+ *    (`getLatestPriceFeedsPartial`). Handed a stock `SuiPriceServiceConnection`,
+ *    this falls back to the all-or-nothing fetch, which Hermes v2 answers with
+ *    a 404 for the whole batch when any id is unknown — so there is nothing
+ *    left to be tolerant with. That fetch is kept because it is correct for an
+ *    endpoint that OMITS unknown ids rather than rejecting the batch, but the
+ *    failure is re-thrown with attribution rather than surfacing as a bare HTTP
+ *    error. `refreshReservesForInitialize` rejects the combination outright.
+ */
+export const refreshReservePriceTolerant = async (reserves, pythConnection) => {
+    const priceIdentifiers = Array.from(new Set(reserves.map(reserveFeedId)));
+    let priceFeeds;
+    if (canReportMissingPriceFeeds(pythConnection)) {
+        priceFeeds = (await pythConnection.getLatestPriceFeedsPartial(priceIdentifiers)).feeds;
+    }
+    else {
+        try {
+            priceFeeds = await pythConnection.getLatestPriceFeeds(priceIdentifiers);
+        }
+        catch (error) {
+            // Not swallowed — a transport failure must stay a failure, or every
+            // reserve silently reports as unpriced and the caller cannot tell a dead
+            // endpoint from a retired feed. Re-thrown only to name the cause, which a
+            // bare "HTTP error! status: 404" does not.
+            throw new Error(`Tolerant price refresh failed on an all-or-nothing connection: ${error instanceof Error ? error.message : String(error)}. This connection cannot report which feeds are missing, so an endpoint that rejects the whole batch over one unknown id (Hermes v2) defeats tolerance entirely — ${PARTIAL_FETCH_REQUIRED_HINT}.`, { cause: error });
+        }
+    }
+    const byId = indexFeedsById(priceFeeds ?? []);
+    const unpricedCoinTypes = [];
+    const updatedReserves = reserves.map((reserve) => {
+        const priceFeed = byId.get(reserveFeedId(reserve));
+        if (!priceFeed) {
+            // Normalized to match every other coin type this SDK returns
+            // (`reserveMap`, `reserveCoinTypes`, and the parsers are all
+            // normalizeStructTag'd). The raw on-chain form never compares equal to
+            // one of those keys — it lacks the `0x` prefix — so reporting it raw made
+            // the cross-reference this field exists for silently never match.
+            unpricedCoinTypes.push(normalizeStructTag(reserve.coinType.name));
+            return reserve;
+        }
+        return withFeedPrice(reserve, priceFeed);
+    });
+    return { reserves: updatedReserves, unpricedCoinTypes };
+};
 export const updateUserRewardManager = (poolManager, userRewardManager, nowMs) => {
     const updatedUserRewardManager = { ...userRewardManager };
     for (let i = 0; i < poolManager.poolRewards.length; i++) {