@suilend/sdk 13.0.0-next.g803bba0 → 13.1.0-next.g093f417

package/_generated/suilend/reserve/structs.d.ts

@@ -648,6 +648,11 @@ export type ReserveAssetDataEventJSON = {
     $typeName: typeof ReserveAssetDataEvent.$typeName;
     $typeArgs: [];
 } & ReserveAssetDataEventJSONField;
+/**
+ * Deprecated: this struct's layout is frozen by Sui's upgrade-compatibility check, since
+ * it is already published on mainnet. Use `ReserveAssetDataEventV2` instead, which carries
+ * every field here plus `conf`.
+ */
 export declare class ReserveAssetDataEvent implements StructClass {
     __StructClass: true;
     static get $typeName(): `${string}::reserve::ReserveAssetDataEvent`;
@@ -693,6 +698,96 @@ export declare class ReserveAssetDataEvent implements StructClass {
     }>): ReserveAssetDataEvent;
     static fetch(client: ClientWithCoreApi, id: string): Promise<ReserveAssetDataEvent>;
 }
+export declare function isReserveAssetDataEventV2(type: string): boolean;
+export interface ReserveAssetDataEventV2Fields {
+    lendingMarketId: ToField<'address'>;
+    coinType: ToField<TypeName>;
+    reserveId: ToField<'address'>;
+    availableAmount: ToField<Decimal>;
+    supplyAmount: ToField<Decimal>;
+    borrowedAmount: ToField<Decimal>;
+    availableAmountUsdEstimate: ToField<Decimal>;
+    supplyAmountUsdEstimate: ToField<Decimal>;
+    borrowedAmountUsdEstimate: ToField<Decimal>;
+    borrowApr: ToField<Decimal>;
+    supplyApr: ToField<Decimal>;
+    ctokenSupply: ToField<'u64'>;
+    cumulativeBorrowRate: ToField<Decimal>;
+    price: ToField<Decimal>;
+    smoothedPrice: ToField<Decimal>;
+    priceLastUpdateTimestampS: ToField<'u64'>;
+    conf: ToField<Decimal>;
+}
+export type ReserveAssetDataEventV2Reified = Reified<ReserveAssetDataEventV2, ReserveAssetDataEventV2Fields>;
+export type ReserveAssetDataEventV2JSONField = {
+    lendingMarketId: string;
+    coinType: string;
+    reserveId: string;
+    availableAmount: ToJSON<Decimal>;
+    supplyAmount: ToJSON<Decimal>;
+    borrowedAmount: ToJSON<Decimal>;
+    availableAmountUsdEstimate: ToJSON<Decimal>;
+    supplyAmountUsdEstimate: ToJSON<Decimal>;
+    borrowedAmountUsdEstimate: ToJSON<Decimal>;
+    borrowApr: ToJSON<Decimal>;
+    supplyApr: ToJSON<Decimal>;
+    ctokenSupply: string;
+    cumulativeBorrowRate: ToJSON<Decimal>;
+    price: ToJSON<Decimal>;
+    smoothedPrice: ToJSON<Decimal>;
+    priceLastUpdateTimestampS: string;
+    conf: ToJSON<Decimal>;
+};
+export type ReserveAssetDataEventV2JSON = {
+    $typeName: typeof ReserveAssetDataEventV2.$typeName;
+    $typeArgs: [];
+} & ReserveAssetDataEventV2JSONField;
+export declare class ReserveAssetDataEventV2 implements StructClass {
+    __StructClass: true;
+    static get $typeName(): `${string}::reserve::ReserveAssetDataEventV2`;
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName: typeof ReserveAssetDataEventV2.$typeName;
+    readonly $fullTypeName: `${string}::reserve::ReserveAssetDataEventV2`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: typeof ReserveAssetDataEventV2.$isPhantom;
+    readonly lendingMarketId: ToField<'address'>;
+    readonly coinType: ToField<TypeName>;
+    readonly reserveId: ToField<'address'>;
+    readonly availableAmount: ToField<Decimal>;
+    readonly supplyAmount: ToField<Decimal>;
+    readonly borrowedAmount: ToField<Decimal>;
+    readonly availableAmountUsdEstimate: ToField<Decimal>;
+    readonly supplyAmountUsdEstimate: ToField<Decimal>;
+    readonly borrowedAmountUsdEstimate: ToField<Decimal>;
+    readonly borrowApr: ToField<Decimal>;
+    readonly supplyApr: ToField<Decimal>;
+    readonly ctokenSupply: ToField<'u64'>;
+    readonly cumulativeBorrowRate: ToField<Decimal>;
+    readonly price: ToField<Decimal>;
+    readonly smoothedPrice: ToField<Decimal>;
+    readonly priceLastUpdateTimestampS: ToField<'u64'>;
+    readonly conf: ToField<Decimal>;
+    private constructor();
+    static reified(): ReserveAssetDataEventV2Reified;
+    static get r(): ReserveAssetDataEventV2Reified;
+    static phantom(): PhantomReified<ToTypeStr<ReserveAssetDataEventV2>>;
+    static get p(): PhantomReified<ToTypeStr<ReserveAssetDataEventV2>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof ReserveAssetDataEventV2.instantiateBcs>;
+    static fromFields(fields: Record<string, any>): ReserveAssetDataEventV2;
+    static fromFieldsWithTypes(item: FieldsWithTypes): ReserveAssetDataEventV2;
+    static fromBcs(data: Uint8Array): ReserveAssetDataEventV2;
+    toJSONField(): ReserveAssetDataEventV2JSONField;
+    toJSON(): ReserveAssetDataEventV2JSON;
+    static fromJSONField(field: any): ReserveAssetDataEventV2;
+    static fromJSON(json: Record<string, any>): ReserveAssetDataEventV2;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): ReserveAssetDataEventV2;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<ReserveAssetDataEventV2>;
+}
 export declare function isClaimStakingRewardsEvent(type: string): boolean;
 export interface ClaimStakingRewardsEventFields {
     lendingMarketId: ToField<'address'>;

package/_generated/suilend/reserve/structs.js

@@ -1754,6 +1754,11 @@ export function isReserveAssetDataEvent(type) {
     return type
         === `${getTypeOrigin('suilend', 'reserve::ReserveAssetDataEvent')}::reserve::ReserveAssetDataEvent`;
 }
+/**
+ * Deprecated: this struct's layout is frozen by Sui's upgrade-compatibility check, since
+ * it is already published on mainnet. Use `ReserveAssetDataEventV2` instead, which carries
+ * every field here plus `conf`.
+ */
 export class ReserveAssetDataEvent {
     __StructClass = true;
     static get $typeName() {
@@ -1981,6 +1986,246 @@ export class ReserveAssetDataEvent {
         return ReserveAssetDataEvent.fromBcs(object.content);
     }
 }
+/* ============================== ReserveAssetDataEventV2 =============================== */
+export function isReserveAssetDataEventV2(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'reserve::ReserveAssetDataEventV2')}::reserve::ReserveAssetDataEventV2`;
+}
+export class ReserveAssetDataEventV2 {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::ReserveAssetDataEventV2')}::reserve::ReserveAssetDataEventV2`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ReserveAssetDataEventV2.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ReserveAssetDataEventV2.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    availableAmount;
+    supplyAmount;
+    borrowedAmount;
+    availableAmountUsdEstimate;
+    supplyAmountUsdEstimate;
+    borrowedAmountUsdEstimate;
+    borrowApr;
+    supplyApr;
+    ctokenSupply;
+    cumulativeBorrowRate;
+    price;
+    smoothedPrice;
+    priceLastUpdateTimestampS;
+    conf;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(ReserveAssetDataEventV2.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.lendingMarketId = fields.lendingMarketId;
+        this.coinType = fields.coinType;
+        this.reserveId = fields.reserveId;
+        this.availableAmount = fields.availableAmount;
+        this.supplyAmount = fields.supplyAmount;
+        this.borrowedAmount = fields.borrowedAmount;
+        this.availableAmountUsdEstimate = fields.availableAmountUsdEstimate;
+        this.supplyAmountUsdEstimate = fields.supplyAmountUsdEstimate;
+        this.borrowedAmountUsdEstimate = fields.borrowedAmountUsdEstimate;
+        this.borrowApr = fields.borrowApr;
+        this.supplyApr = fields.supplyApr;
+        this.ctokenSupply = fields.ctokenSupply;
+        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
+        this.price = fields.price;
+        this.smoothedPrice = fields.smoothedPrice;
+        this.priceLastUpdateTimestampS = fields.priceLastUpdateTimestampS;
+        this.conf = fields.conf;
+    }
+    static reified() {
+        const reifiedBcs = ReserveAssetDataEventV2.bcs;
+        return {
+            get typeName() {
+                return ReserveAssetDataEventV2.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ReserveAssetDataEventV2.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: ReserveAssetDataEventV2.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => ReserveAssetDataEventV2.fromFields(fields),
+            fromFieldsWithTypes: (item) => ReserveAssetDataEventV2.fromFieldsWithTypes(item),
+            fromBcs: (data) => ReserveAssetDataEventV2.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ReserveAssetDataEventV2.fromJSONField(field),
+            fromJSON: (json) => ReserveAssetDataEventV2.fromJSON(json),
+            fromCoreObject: (obj) => ReserveAssetDataEventV2.fromCoreObject(obj),
+            fetch: async (client, id) => ReserveAssetDataEventV2.fetch(client, id),
+            new: (fields) => {
+                return new ReserveAssetDataEventV2([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return ReserveAssetDataEventV2.reified();
+    }
+    static phantom() {
+        return phantom(ReserveAssetDataEventV2.reified());
+    }
+    static get p() {
+        return ReserveAssetDataEventV2.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('ReserveAssetDataEventV2', {
+            lending_market_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            coin_type: TypeName.bcs,
+            reserve_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            available_amount: Decimal.bcs,
+            supply_amount: Decimal.bcs,
+            borrowed_amount: Decimal.bcs,
+            available_amount_usd_estimate: Decimal.bcs,
+            supply_amount_usd_estimate: Decimal.bcs,
+            borrowed_amount_usd_estimate: Decimal.bcs,
+            borrow_apr: Decimal.bcs,
+            supply_apr: Decimal.bcs,
+            ctoken_supply: bcs.u64(),
+            cumulative_borrow_rate: Decimal.bcs,
+            price: Decimal.bcs,
+            smoothed_price: Decimal.bcs,
+            price_last_update_timestamp_s: bcs.u64(),
+            conf: Decimal.bcs,
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ReserveAssetDataEventV2.cachedBcs) {
+            ReserveAssetDataEventV2.cachedBcs = ReserveAssetDataEventV2.instantiateBcs();
+        }
+        return ReserveAssetDataEventV2.cachedBcs;
+    }
+    static fromFields(fields) {
+        return ReserveAssetDataEventV2.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            availableAmount: decodeFromFields(Decimal.reified(), fields.available_amount),
+            supplyAmount: decodeFromFields(Decimal.reified(), fields.supply_amount),
+            borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
+            availableAmountUsdEstimate: decodeFromFields(Decimal.reified(), fields.available_amount_usd_estimate),
+            supplyAmountUsdEstimate: decodeFromFields(Decimal.reified(), fields.supply_amount_usd_estimate),
+            borrowedAmountUsdEstimate: decodeFromFields(Decimal.reified(), fields.borrowed_amount_usd_estimate),
+            borrowApr: decodeFromFields(Decimal.reified(), fields.borrow_apr),
+            supplyApr: decodeFromFields(Decimal.reified(), fields.supply_apr),
+            ctokenSupply: decodeFromFields('u64', fields.ctoken_supply),
+            cumulativeBorrowRate: decodeFromFields(Decimal.reified(), fields.cumulative_borrow_rate),
+            price: decodeFromFields(Decimal.reified(), fields.price),
+            smoothedPrice: decodeFromFields(Decimal.reified(), fields.smoothed_price),
+            priceLastUpdateTimestampS: decodeFromFields('u64', fields.price_last_update_timestamp_s),
+            conf: decodeFromFields(Decimal.reified(), fields.conf),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isReserveAssetDataEventV2(item.type)) {
+            throw new Error('not a ReserveAssetDataEventV2 type');
+        }
+        return ReserveAssetDataEventV2.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            availableAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.available_amount),
+            supplyAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.supply_amount),
+            borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
+            availableAmountUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.available_amount_usd_estimate),
+            supplyAmountUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.supply_amount_usd_estimate),
+            borrowedAmountUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount_usd_estimate),
+            borrowApr: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrow_apr),
+            supplyApr: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.supply_apr),
+            ctokenSupply: decodeFromFieldsWithTypes('u64', item.fields.ctoken_supply),
+            cumulativeBorrowRate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_borrow_rate),
+            price: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.price),
+            smoothedPrice: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.smoothed_price),
+            priceLastUpdateTimestampS: decodeFromFieldsWithTypes('u64', item.fields.price_last_update_timestamp_s),
+            conf: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.conf),
+        });
+    }
+    static fromBcs(data) {
+        return ReserveAssetDataEventV2.fromFields(ReserveAssetDataEventV2.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            lendingMarketId: this.lendingMarketId,
+            coinType: this.coinType,
+            reserveId: this.reserveId,
+            availableAmount: this.availableAmount.toJSONField(),
+            supplyAmount: this.supplyAmount.toJSONField(),
+            borrowedAmount: this.borrowedAmount.toJSONField(),
+            availableAmountUsdEstimate: this.availableAmountUsdEstimate.toJSONField(),
+            supplyAmountUsdEstimate: this.supplyAmountUsdEstimate.toJSONField(),
+            borrowedAmountUsdEstimate: this.borrowedAmountUsdEstimate.toJSONField(),
+            borrowApr: this.borrowApr.toJSONField(),
+            supplyApr: this.supplyApr.toJSONField(),
+            ctokenSupply: this.ctokenSupply.toString(),
+            cumulativeBorrowRate: this.cumulativeBorrowRate.toJSONField(),
+            price: this.price.toJSONField(),
+            smoothedPrice: this.smoothedPrice.toJSONField(),
+            priceLastUpdateTimestampS: this.priceLastUpdateTimestampS.toString(),
+            conf: this.conf.toJSONField(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return ReserveAssetDataEventV2.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            availableAmount: decodeFromJSONField(Decimal.reified(), field.availableAmount),
+            supplyAmount: decodeFromJSONField(Decimal.reified(), field.supplyAmount),
+            borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
+            availableAmountUsdEstimate: decodeFromJSONField(Decimal.reified(), field.availableAmountUsdEstimate),
+            supplyAmountUsdEstimate: decodeFromJSONField(Decimal.reified(), field.supplyAmountUsdEstimate),
+            borrowedAmountUsdEstimate: decodeFromJSONField(Decimal.reified(), field.borrowedAmountUsdEstimate),
+            borrowApr: decodeFromJSONField(Decimal.reified(), field.borrowApr),
+            supplyApr: decodeFromJSONField(Decimal.reified(), field.supplyApr),
+            ctokenSupply: decodeFromJSONField('u64', field.ctokenSupply),
+            cumulativeBorrowRate: decodeFromJSONField(Decimal.reified(), field.cumulativeBorrowRate),
+            price: decodeFromJSONField(Decimal.reified(), field.price),
+            smoothedPrice: decodeFromJSONField(Decimal.reified(), field.smoothedPrice),
+            priceLastUpdateTimestampS: decodeFromJSONField('u64', field.priceLastUpdateTimestampS),
+            conf: decodeFromJSONField(Decimal.reified(), field.conf),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== ReserveAssetDataEventV2.$typeName) {
+            throw new Error(`not a ReserveAssetDataEventV2 json object: expected '${ReserveAssetDataEventV2.$typeName}' but got '${json.$typeName}'`);
+        }
+        return ReserveAssetDataEventV2.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isReserveAssetDataEventV2(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ReserveAssetDataEventV2 object`);
+        }
+        return ReserveAssetDataEventV2.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isReserveAssetDataEventV2(object.type)) {
+            throw new Error(`object at id ${id} is not a ReserveAssetDataEventV2 object`);
+        }
+        return ReserveAssetDataEventV2.fromBcs(object.content);
+    }
+}
 /* ============================== ClaimStakingRewardsEvent =============================== */
 export function isClaimStakingRewardsEvent(type) {
     type = compressSuiType(type);

package/client.d.ts

@@ -19,10 +19,12 @@ export interface PriceUpdate {
 }
 export declare function needsPriceRefresh(stalenessSeconds: number): boolean;
 export declare const ADMIN_ADDRESS = "0xb1ffbc2e1915f44b8f271a703becc1bf8aa79bc22431a58900a102892b783c25";
+export declare function getStrategyWrapperPackageId(): string;
+export declare function setStrategyWrapperPackageId(packageId: string): void;
 export declare const LENDING_MARKET_REGISTRY_ID = "0x64faff8d91a56c4f55debbb44767b009ee744a70bc2cc8e3bbd2718c92f85931";
 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>;
+export declare function getLatestPackageId(suiGrpcClient: SuiGrpcClient, upgradeCapId: string): Promise<string>;
 /**
  * Lists every owned object of `type`, following pagination.
  *
@@ -84,6 +86,12 @@ export declare class SuilendClient {
         id: string;
         type: string;
     }[], suiGrpcClient: SuiGrpcClient, logPackageId?: boolean): Promise<SuilendClient[]>;
+    /**
+     * Sets only the suilend package, to `publishedAt`, and leaves the
+     * strategy_wrapper package as it was. Callers that build strategy
+     * transactions must also call `setStrategyWrapperPackageId` with the
+     * strategy_wrapper package for MAIN's lending market version.
+     */
     static initializeAllFromObjects(lendingMarkets: {
         id: string;
         type: string;
@@ -94,6 +102,8 @@ export declare class SuilendClient {
     }>;
     /** A reserve's confidence multiplier `k`, in bps; pass `parsedReserve.config.additionalFields.id`. 0 when unset. */
     static getReserveConfidenceMultiplierBps(suiGrpcClient: SuiGrpcClient, additionalFieldsBagId: string): Promise<BigNumber>;
+    /** A reserve's stored Pyth confidence (the `ConfidenceKey` dynamic field on `reserve.id` directly, not inside `config.additionalFields`). Reads as 0 until the reserve's first price update writes it. */
+    static getReserveStoredConfidence(suiGrpcClient: SuiGrpcClient, reserveId: string): Promise<BigNumber>;
     static createNewLendingMarket(registryId: string, lendingMarketType: string, transaction: Transaction): {
         NestedResult: [number, number];
         $kind: "NestedResult";

package/client.js

@@ -1,9 +1,11 @@
 import { bcs } from "@mysten/sui/bcs";
-import { SUI_CLOCK_OBJECT_ID, SUI_SYSTEM_STATE_OBJECT_ID, isValidSuiAddress, normalizeStructTag, normalizeSuiObjectId, toHex, } from "@mysten/sui/utils";
+import { SUI_CLOCK_OBJECT_ID, SUI_SYSTEM_STATE_OBJECT_ID, isValidSuiAddress, normalizeStructTag, normalizeSuiAddress, normalizeSuiObjectId, toHex, } from "@mysten/sui/utils";
 import { SuiPythClient } from "@pythnetwork/pyth-sui-js";
 import BigNumber from "bignumber.js";
 import { extractCTokenCoinType, getAllCoins, getSpendableCoin, } from "@suilend/sui-core";
 import { phantom } from "./_generated/_framework/reified.js";
+import { Decimal } from "./_generated/suilend/decimal/structs.js";
+import { decimalToBigNumber } from "./utils/simulate.js";
 import { PKG_V10, setPublishedAt } from "./_generated/suilend/index.js";
 import { getPublishedAt } from "./_generated/_envs/index.js";
 import { PACKAGE_ID } from "./_generated/suilend/index.js";
@@ -58,6 +60,20 @@ const PUBLISHED_AT_BY_MARKET_VERSION = new Map([
         "0x59672975e15c58ffc9450f5236b6aa9fa2407d94b8081e634778aa01957d8c6f",
     ],
 ]);
+const STRATEGY_WRAPPER_UPGRADE_CAP_ID = "0x486ef016bd357fadf981aba35a6c31df8d4c0c4136b2e78fdda87cb2832f3033";
+const STRATEGY_WRAPPER_PACKAGE_ID_V7 = "0x864b66441e95323c320ee7584592769930a2d236b45d731011ee7a98eb785b35";
+const STRATEGY_WRAPPER_PACKAGE_ID_BY_MARKET_VERSION = new Map([
+    [BigInt(7), STRATEGY_WRAPPER_PACKAGE_ID_V7],
+]);
+let strategyWrapperPackage = STRATEGY_WRAPPER_PACKAGE_ID_V7;
+export function getStrategyWrapperPackageId() {
+    if (typeof strategyWrapperPackage !== "string")
+        throw new Error(`The strategy_wrapper package is unresolved: reading its UpgradeCap ${STRATEGY_WRAPPER_UPGRADE_CAP_ID} failed at MAIN lending market version ${LATEST_MARKET_VERSION}. Retry SuilendClient.initialize before building strategy transactions.`, { cause: strategyWrapperPackage.readError });
+    return strategyWrapperPackage;
+}
+export function setStrategyWrapperPackageId(packageId) {
+    strategyWrapperPackage = packageId;
+}
 export const LENDING_MARKET_REGISTRY_ID = "0x64faff8d91a56c4f55debbb44767b009ee744a70bc2cc8e3bbd2718c92f85931";
 export const [LENDING_MARKET_ID, LENDING_MARKET_TYPE] = [
     "0x84030d26d85eaa7035084a057f2f11f701b7e2e4eda87551becbc7c97505ece1",
@@ -84,7 +100,12 @@ export async function getLatestPackageId(suiGrpcClient, upgradeCapId) {
         objectId: upgradeCapId,
         include: { json: true },
     })
-        .then(({ object }) => object.json.package)
+        .then(({ object }) => {
+        const packageId = object.json?.package;
+        if (typeof packageId !== "string" || !isValidSuiAddress(packageId))
+            throw new Error(`UpgradeCap ${upgradeCapId} does not name a valid package id (got ${String(packageId)})`);
+        return normalizeSuiAddress(packageId);
+    })
         .finally(() => latestPackageIdCache.delete(upgradeCapId));
     latestPackageIdCache.set(upgradeCapId, promise);
     return promise;
@@ -244,13 +265,27 @@ function startLatestPackageIdRead(suiGrpcClient) {
     latestPackageId.catch(() => { });
     return latestPackageId;
 }
-async function publishedAtForMainVersion(mainVersion, latestPackageId) {
-    if (mainVersion === LATEST_MARKET_VERSION)
-        return latestPackageId;
-    const pinned = PUBLISHED_AT_BY_MARKET_VERSION.get(mainVersion);
-    if (!pinned)
-        throw new Error(`No suilend package is known for lending market version ${mainVersion} (MAIN ${LENDING_MARKET_ID})`);
-    return pinned;
+async function applyPackagesForMainVersion(suiGrpcClient, mainVersion, latestPackageId, logPackageId) {
+    if (mainVersion === LATEST_MARKET_VERSION) {
+        const [publishedAt, strategyWrapper] = await Promise.all([
+            latestPackageId,
+            getLatestPackageId(suiGrpcClient, STRATEGY_WRAPPER_UPGRADE_CAP_ID).catch((readError) => ({ readError })),
+        ]);
+        applyPublishedAt(publishedAt, logPackageId);
+        strategyWrapperPackage = strategyWrapper;
+        return;
+    }
+    const publishedAt = PUBLISHED_AT_BY_MARKET_VERSION.get(mainVersion);
+    const strategyWrapper = STRATEGY_WRAPPER_PACKAGE_ID_BY_MARKET_VERSION.get(mainVersion);
+    if (!publishedAt || !strategyWrapper) {
+        const unknown = [
+            ...(publishedAt ? [] : ["suilend"]),
+            ...(strategyWrapper ? [] : ["strategy_wrapper"]),
+        ];
+        throw new Error(`No ${unknown.join(" or ")} package is known for lending market version ${mainVersion} (MAIN ${LENDING_MARKET_ID})`);
+    }
+    applyPublishedAt(publishedAt, logPackageId);
+    strategyWrapperPackage = strategyWrapper;
 }
 async function readMainVersion(suiGrpcClient) {
     const { object } = await suiGrpcClient.getObject({
@@ -368,7 +403,7 @@ export class SuilendClient {
         const mainVersion = fetchedMainVersion ?? lendingMarket.version;
         if (lendingMarket.version !== mainVersion)
             throw new Error(versionMismatch(lendingMarketId, lendingMarket.version, mainVersion));
-        applyPublishedAt(await publishedAtForMainVersion(mainVersion, latestPackageId), logPackageId);
+        await applyPackagesForMainVersion(suiGrpcClient, mainVersion, latestPackageId, logPackageId);
         return new SuilendClient(lendingMarket, suiGrpcClient);
     }
     /**
@@ -396,12 +431,18 @@ export class SuilendClient {
         const mainVersion = fetchedMainVersion ??
             clients[lendingMarkets.findIndex(({ id }) => isMainMarket(id))]
                 .lendingMarket.version;
-        applyPublishedAt(await publishedAtForMainVersion(mainVersion, latestPackageId), logPackageId);
+        await applyPackagesForMainVersion(suiGrpcClient, mainVersion, latestPackageId, logPackageId);
         for (const { lendingMarket } of clients)
             if (lendingMarket.version !== mainVersion)
                 console.warn(`@suilend/sdk | ${versionMismatch(lendingMarket.id, lendingMarket.version, mainVersion)}`);
         return clients;
     }
+    /**
+     * Sets only the suilend package, to `publishedAt`, and leaves the
+     * strategy_wrapper package as it was. Callers that build strategy
+     * transactions must also call `setStrategyWrapperPackageId` with the
+     * strategy_wrapper package for MAIN's lending market version.
+     */
     static initializeAllFromObjects(lendingMarkets, objects, publishedAt, suiGrpcClient, logPackageId) {
         if (!isValidSuiAddress(publishedAt))
             throw new Error(`publishedAt ${publishedAt} is not a Sui package id`);
@@ -426,6 +467,17 @@ export class SuilendClient {
         });
         return new BigNumber(bcs.u64().parse(dynamicField.value.bcs));
     }
+    /** A reserve's stored Pyth confidence (the `ConfidenceKey` dynamic field on `reserve.id` directly, not inside `config.additionalFields`). Reads as 0 until the reserve's first price update writes it. */
+    static async getReserveStoredConfidence(suiGrpcClient, reserveId) {
+        const match = await findBagEntryByTypeSuffix(suiGrpcClient, reserveId, "::reserve::ConfidenceKey");
+        if (!match)
+            return new BigNumber(0);
+        const { dynamicField } = await suiGrpcClient.getDynamicField({
+            parentId: reserveId,
+            name: match.name,
+        });
+        return decimalToBigNumber(Decimal.fromBcs(dynamicField.value.bcs));
+    }
     static createNewLendingMarket(registryId, lendingMarketType, transaction) {
         const [ownerCap, lendingMarket] = createLendingMarket(transaction, lendingMarketType, transaction.object(registryId));
         transaction.moveCall({