@suilend/sdk 12.7.0 → 13.0.0-next.g803bba0

package/_generated/suilend/lending-market/functions.d.ts

@@ -1,117 +1,356 @@
-import { Transaction, TransactionArgument, TransactionObjectInput } from "@mysten/sui/transactions";
-export interface BorrowArgs {
+import { Transaction, TransactionArgument, TransactionObjectInput, TransactionResult } from '@mysten/sui/transactions';
+import type { EnvConfig } from '../../_envs';
+export declare function init(tx: Transaction, otw: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/**
+ * Creates a new lending market, and sets the fee receivers.
+ *
+ * The function initializes a `LendingMarket` object with empty reserves
+ * and obligations, a default rate limiter, and the sender as the fee receiver.
+ *
+ * It then calls the `set_fee_receivers` function to set the initial fee receiver to the creator of the market with a weight of 100.
+ *
+ * # Returns
+ *
+ * * `LendingMarketOwnerCap<P>` - The ownership capability for the newly created lending market.
+ * * `LendingMarket<P>` - The newly created lending market object.
+ *
+ * # Panics
+ *
+ * This function calls `set_fee_receivers`, which can panic under the following conditions:
+ *
+ * * If the `receivers` and `weights` vectors do not have the same length (EInvalidFeeReceivers).
+ * * If the `receivers` vector is empty (EInvalidFeeReceivers).
+ * * If the sum of `weights` is zero (EInvalidFeeReceivers).
+ */
+export declare function createLendingMarket(tx: Transaction, typeArg: string, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface RefreshReservePriceArgs {
     lendingMarket: TransactionObjectInput;
-    reserveArrayIndex: bigint | TransactionArgument;
-    obligationOwnerCap: TransactionObjectInput;
+    u64: bigint | TransactionArgument;
     clock: TransactionObjectInput;
-    amount: bigint | TransactionArgument;
+    priceInfoObject: TransactionObjectInput;
 }
-export declare function borrow(tx: Transaction, typeArgs: [string, string], args: BorrowArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface MigrateArgs {
-    lendingMarketOwnerCap: TransactionObjectInput;
+/**
+ * Deprecated tombstone — kept only because Sui's upgrade compatibility rules
+ * freeze a published function's signature. Pyth froze every legacy on-chain
+ * feed at the 2026-08-26 cutover; nothing has written to one since, so this
+ * now aborts unconditionally instead of silently refreshing against a
+ * permanently-stale price. Use `refresh_reserve_price_pro_compatible`.
+ */
+export declare function refreshReservePrice(tx: Transaction, typeArg: string, args: RefreshReservePriceArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface RefreshReservePriceProCompatibleArgs {
     lendingMarket: TransactionObjectInput;
+    reserveArrayIndex: bigint | TransactionArgument;
+    clock: TransactionObjectInput;
+    priceInfo: TransactionObjectInput;
 }
-export declare function migrate(tx: Transaction, typeArg: string, args: MigrateArgs): import("@mysten/sui/transactions").TransactionResult;
-export declare function init(tx: Transaction, otw: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
-export interface ClaimFeesArgs {
+/**
+ * `refresh_reserve_price` against the upgraded Pyth package. From the
+ * 2026-08-18 cutover this is the only working refresh path; the legacy one
+ * above can no longer be supplied with a verifiable `PriceInfoObject`, and
+ * is retained only because published signatures are frozen.
+ */
+export declare function refreshReservePriceProCompatible(tx: Transaction, typeArg: string, args: RefreshReservePriceProCompatibleArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/** Creates a new obligation. */
+export declare function createObligation(tx: Transaction, typeArg: string, lendingMarket: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface DepositLiquidityAndMintCtokensArgs {
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
-    systemState: TransactionObjectInput;
+    clock: TransactionObjectInput;
+    deposit: TransactionObjectInput;
 }
-export declare function claimFees(tx: Transaction, typeArgs: [string, string], args: ClaimFeesArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface AddPoolRewardArgs {
-    lendingMarketOwnerCap: TransactionObjectInput;
+/**
+ * Deposits liquidity into a reserve and mints cTokens in return.
+ *
+ * This function allows a user to deposit a certain amount of a token into a reserve
+ * and receive cTokens, which represent their share of the reserve's assets.
+ * The amount of cTokens minted is proportional to the amount of liquidity deposited
+ * and the current cToken ratio of the reserve.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to deposit into.
+ * * `clock` - A reference to the `Clock` to compound interest before depositing.
+ * * `deposit` - The `Coin` object representing the liquidity to deposit.
+ *
+ * # Returns
+ *
+ * * `Coin<CToken<P, T>>` - A `Coin` of cTokens representing the deposited liquidity and accrued interest.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The deposit amount is zero (ETooSmall).
+ * * The `coin_type` of the reserve does not match the type of the deposited coin (EWrongType).
+ * * The deposit would exceed the reserve's deposit limit (`EDepositLimitExceeded` from the `reserve` module).
+ * * If ctokens are outstanding but unclaimed spread fees have consumed the entire total
+ * supply, leaving them unbacked (`EReserveInDeficit` from the `reserve` module).
+ * * The minted cToken amount is zero (ETooSmall).
+ * * `reserve_array_index` is out of bounds.
+ */
+export declare function depositLiquidityAndMintCtokens(tx: Transaction, typeArgs: [string, string], args: DepositLiquidityAndMintCtokensArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface RedeemCtokensAndWithdrawLiquidityArgs {
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
-    isDepositReward: boolean | TransactionArgument;
-    rewards: TransactionObjectInput;
-    startTimeMs: bigint | TransactionArgument;
-    endTimeMs: bigint | TransactionArgument;
     clock: TransactionObjectInput;
+    ctokens: TransactionObjectInput;
+    rateLimiterExemption: TransactionObjectInput | null;
 }
-export declare function addPoolReward(tx: Transaction, typeArgs: [string, string], args: AddPoolRewardArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface CancelPoolRewardArgs {
-    lendingMarketOwnerCap: TransactionObjectInput;
+/**
+ * Redeems cTokens for the underlying liquidity.
+ *
+ * This function allows a user to redeem their cTokens for the underlying asset.
+ * The amount of the underlying asset received depends on the amount of cTokens redeemed
+ * and the current cToken ratio of the reserve.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to redeem from.
+ * * `clock` - A reference to the `Clock` to compound interest before redeeming.
+ * * `ctokens` - The `Coin` of cTokens to redeem.
+ * * `rate_limiter_exemption` - An optional exemption from the rate limiter.
+ *
+ * # Returns
+ *
+ * * `Coin<T>` - A `Coin` of the underlying asset.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The amount of cTokens to redeem is zero (ETooSmall).
+ * * The `coin_type` of the reserve does not match the type of the cTokens (EWrongType).
+ * * If ctokens are outstanding but unclaimed spread fees have consumed the entire total
+ * supply, leaving them unbacked (`EReserveInDeficit` from the `reserve` module).
+ * * The redemption would violate the minimum available amount of the reserve (`EMinAvailableAmountViolated` from the `reserve` module).
+ * * The withdrawal amount exceeds the rate limit, and no exemption is provided.
+ * * The redemption would floor to zero underlying, i.e. this reserve's ctoken ratio is
+ * below one and the amount redeemed is below its reciprocal (ETooSmall). Refused rather
+ * than burning the ctokens for nothing, mirroring the deposit-side zero-mint refusal above.
+ * * `reserve_array_index` is out of bounds.
+ */
+export declare function redeemCtokensAndWithdrawLiquidity(tx: Transaction, typeArgs: [string, string], args: RedeemCtokensAndWithdrawLiquidityArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface RedeemCtokensAndWithdrawLiquidityRequestArgs {
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
-    isDepositReward: boolean | TransactionArgument;
-    rewardIndex: bigint | TransactionArgument;
     clock: TransactionObjectInput;
+    ctokens: TransactionObjectInput;
+    rateLimiterExemption: TransactionObjectInput | null;
 }
-export declare function cancelPoolReward(tx: Transaction, typeArgs: [string, string], args: CancelPoolRewardArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface ClaimRewardsArgs {
+/**
+ * Creates a liquidity request to withdraw liquidity by redeeming cTokens.
+ *
+ * Initiates the process of redeeming cTokens for the underlying asset.
+ * It checks for rate limit exemptions, processes the withdrawal against the rate limiter if necessary,
+ * and then creates a `LiquidityRequest` by calling the `redeem_ctokens` function in the `reserve` module.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to redeem from.
+ * * `clock` - A reference to the `Clock` to compound interest before redeeming.
+ * * `ctokens` - The `Coin` of cTokens to redeem.
+ * * `rate_limiter_exemption` - An optional exemption from the rate limiter.
+ *
+ * # Returns
+ *
+ * * `LiquidityRequest<P, T>` - A request to withdraw liquidity from the reserve.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The amount of cTokens to redeem is zero (ETooSmall).
+ * * The `coin_type` of the reserve does not match the type of the cTokens (EWrongType).
+ * * If ctokens are outstanding but unclaimed spread fees have consumed the entire total
+ * supply, leaving them unbacked (`EReserveInDeficit` from the `reserve` module).
+ * * The redemption would violate the minimum available amount of the reserve (`EMinAvailableAmountViolated` from the `reserve` module).
+ * * The withdrawal amount exceeds the rate limit, and no exemption is provided.
+ * * The redemption would floor to zero underlying, i.e. this reserve's ctoken ratio is
+ * below one and the amount redeemed is below its reciprocal (ETooSmall). Refused rather
+ * than burning the ctokens for nothing, mirroring the deposit-side zero-mint refusal above.
+ * * `reserve_array_index` is out of bounds.
+ */
+export declare function redeemCtokensAndWithdrawLiquidityRequest(tx: Transaction, typeArgs: [string, string], args: RedeemCtokensAndWithdrawLiquidityRequestArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface DepositCtokensIntoObligationArgs {
     lendingMarket: TransactionObjectInput;
-    cap: TransactionObjectInput;
+    reserveArrayIndex: bigint | TransactionArgument;
+    obligationOwnerCap: TransactionObjectInput;
     clock: TransactionObjectInput;
-    reserveId: bigint | TransactionArgument;
-    rewardIndex: bigint | TransactionArgument;
-    isDepositReward: boolean | TransactionArgument;
+    deposit: TransactionObjectInput;
 }
-export declare function claimRewards(tx: Transaction, typeArgs: [string, string], args: ClaimRewardsArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface ClosePoolRewardArgs {
-    lendingMarketOwnerCap: TransactionObjectInput;
+/**
+ * Deposits cTokens into an obligation, which can be used as collateral for borrowing.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve corresponding to the cTokens being deposited.
+ * * `obligation_owner_cap` - The ownership capability for the obligation.
+ * * `clock` - A reference to the `Clock`.
+ * * `deposit` - The `Coin` of cTokens to deposit.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The deposit amount is zero (ETooSmall).
+ * * The `coin_type` of the reserve does not match the type of the deposited cTokens (EWrongType).
+ * * `reserve_array_index` is out of bounds.
+ * * `obligation_id` is not a valid key in the `obligations` table.
+ */
+export declare function depositCtokensIntoObligation(tx: Transaction, typeArgs: [string, string], args: DepositCtokensIntoObligationArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface BorrowArgs {
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
-    isDepositReward: boolean | TransactionArgument;
-    rewardIndex: bigint | TransactionArgument;
+    obligationOwnerCap: TransactionObjectInput;
     clock: TransactionObjectInput;
+    amount: bigint | TransactionArgument;
 }
-export declare function closePoolReward(tx: Transaction, typeArgs: [string, string], args: ClosePoolRewardArgs): import("@mysten/sui/transactions").TransactionResult;
-export declare function reserve(tx: Transaction, typeArgs: [string, string], lendingMarket: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
-export declare function reserveConfigBuilder(tx: Transaction, typeArgs: [string, string], lendingMarket: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
+/**
+ * Borrows a specified amount of a token from a reserve. A fee is charged on the borrowed amount.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to borrow from.
+ * * `obligation_owner_cap` - The ownership capability for the obligation.
+ * * `clock` - A reference to the `Clock`.
+ * * `amount` - The amount to borrow.
+ *
+ * # Returns
+ *
+ * * `Coin<T>` - A `Coin` of the borrowed asset.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The borrow amount is zero (ETooSmall).
+ * * The `coin_type` of the reserve does not match the type of the asset being borrowed (EWrongType).
+ * * The reserve's price is stale (`EPriceStale` from the `reserve` module).
+ * * The borrow would exceed the reserve's borrow limit (`EBorrowLimitExceeded` from the `reserve` module).
+ * * The borrow would violate the minimum available amount of the reserve (`EMinAvailableAmountViolated` from the `reserve` module).
+ * * The obligation has stale oracle prices.
+ * * The borrow amount exceeds the rate limit.
+ * * `reserve_array_index` is out of bounds.
+ * * `obligation_id` is not a valid key in the `obligations` table.
+ */
+export declare function borrow(tx: Transaction, typeArgs: [string, string], args: BorrowArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
 export interface CompoundInterestArgs {
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
     clock: TransactionObjectInput;
 }
-export declare function compoundInterest(tx: Transaction, typeArg: string, args: CompoundInterestArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface DepositLiquidityAndMintCtokensArgs {
+/** Compound interest for reserve of type T */
+export declare function compoundInterest(tx: Transaction, typeArg: string, args: CompoundInterestArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface RefreshObligationArgs {
     lendingMarket: TransactionObjectInput;
-    reserveArrayIndex: bigint | TransactionArgument;
+    obligationId: string | TransactionArgument;
     clock: TransactionObjectInput;
-    deposit: TransactionObjectInput;
 }
-export declare function depositLiquidityAndMintCtokens(tx: Transaction, typeArgs: [string, string], args: DepositLiquidityAndMintCtokensArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface FulfillLiquidityRequestArgs {
+/** Refresh the obligation's state and assert no stale oracles */
+export declare function refreshObligation(tx: Transaction, typeArg: string, args: RefreshObligationArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface BorrowRequestArgs {
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
-    liquidityRequest: TransactionObjectInput;
-}
-export declare function fulfillLiquidityRequest(tx: Transaction, typeArgs: [string, string], args: FulfillLiquidityRequestArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface InitStakerArgs {
-    lendingMarket: TransactionObjectInput;
-    lendingMarketOwnerCap: TransactionObjectInput;
-    suiReserveArrayIndex: bigint | TransactionArgument;
-    treasuryCap: TransactionObjectInput;
-}
-export declare function initStaker(tx: Transaction, typeArgs: [string, string], args: InitStakerArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface MaxBorrowAmountArgs {
-    rateLimiter: TransactionObjectInput;
-    obligation: TransactionObjectInput;
-    reserve: TransactionObjectInput;
+    obligationOwnerCap: TransactionObjectInput;
     clock: TransactionObjectInput;
+    amount: bigint | TransactionArgument;
 }
-export declare function maxBorrowAmount(tx: Transaction, typeArg: string, args: MaxBorrowAmountArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface RebalanceStakerArgs {
-    lendingMarket: TransactionObjectInput;
-    suiReserveArrayIndex: bigint | TransactionArgument;
-    systemState: TransactionObjectInput;
-}
-export declare function rebalanceStaker(tx: Transaction, typeArg: string, args: RebalanceStakerArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface UnstakeSuiFromStakerArgs {
-    lendingMarket: TransactionObjectInput;
-    suiReserveArrayIndex: bigint | TransactionArgument;
-    liquidityRequest: TransactionObjectInput;
-    systemState: TransactionObjectInput;
-}
-export declare function unstakeSuiFromStaker(tx: Transaction, typeArg: string, args: UnstakeSuiFromStakerArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface UpdateReserveConfigArgs {
-    lendingMarketOwnerCap: TransactionObjectInput;
+/**
+ * Creates a borrow request for a specified amount of a token from a reserve. A fee is charged
+ * on the borrowed amount. The returned `LiquidityRequest` must be fulfilled by calling
+ * `fulfill_liquidity_request`.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to borrow from.
+ * * `obligation_owner_cap` - The ownership capability for the obligation.
+ * * `clock` - A reference to the `Clock`.
+ * * `amount` - The amount to borrow.
+ *
+ * # Returns
+ *
+ * * `LiquidityRequest<P, T>` - A request that must be fulfilled to complete the borrow.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The borrow amount is zero (ETooSmall).
+ * * The `coin_type` of the reserve does not match the type of the asset being borrowed (EWrongType).
+ * * The reserve's price is stale (`EPriceStale` from the `reserve` module).
+ * * The borrow would exceed the reserve's borrow limit (`EBorrowLimitExceeded` from the `reserve` module).
+ * * The borrow would violate the minimum available amount of the reserve (`EMinAvailableAmountViolated` from the `reserve` module).
+ * * The obligation has stale oracle prices.
+ * * The borrow amount exceeds the rate limit.
+ * * `reserve_array_index` is out of bounds.
+ * * `obligation_id` is not a valid key in the `obligations` table.
+ */
+export declare function borrowRequest(tx: Transaction, typeArgs: [string, string], args: BorrowRequestArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface FulfillLiquidityRequestArgs {
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
-    config: TransactionObjectInput;
+    liquidityRequest: TransactionObjectInput;
 }
-export declare function updateReserveConfig(tx: Transaction, typeArgs: [string, string], args: UpdateReserveConfigArgs): import("@mysten/sui/transactions").TransactionResult;
+/**
+ * Fulfills a liquidity request from a reserve.
+ *
+ * This function is called after a liquidity request has been created by either
+ * `redeem_ctokens_and_withdraw_liquidity_request` or `borrow_request`. It takes the
+ * `LiquidityRequest` and processes it, returning the requested amount of the
+ * underlying asset as a `Coin`.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to fulfill the request from.
+ * * `liquidity_request` - The `LiquidityRequest` to be fulfilled.
+ *
+ * # Returns
+ *
+ * * `Coin<T>` - A `Coin` of the underlying asset.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The `coin_type` of the reserve does not match the type of the liquidity request (EWrongType).
+ * * `reserve_array_index` is out of bounds.
+ */
+export declare function fulfillLiquidityRequest(tx: Transaction, typeArgs: [string, string], args: FulfillLiquidityRequestArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
 export interface WithdrawCtokensArgs {
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
@@ -119,14 +358,112 @@ export interface WithdrawCtokensArgs {
     clock: TransactionObjectInput;
     amount: bigint | TransactionArgument;
 }
-export declare function withdrawCtokens(tx: Transaction, typeArgs: [string, string], args: WithdrawCtokensArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface ObligationArgs {
+/**
+ * Withdraws cTokens from an obligation.
+ *
+ * This function allows a user to withdraw their cTokens from an obligation,
+ * making them available for redemption or transfer.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve corresponding to the cTokens being withdrawn.
+ * * `obligation_owner_cap` - The ownership capability for the obligation.
+ * * `clock` - A reference to the `Clock`.
+ * * `amount` - The amount of cTokens to withdraw. If `U64_MAX` is provided, the maximum possible amount will be withdrawn.
+ *
+ * # Returns
+ *
+ * * `Coin<CToken<P, T>>` - A `Coin` of the withdrawn cTokens.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The withdraw amount is zero (ETooSmall).
+ * * The `coin_type` of the reserve does not match the type of the cTokens being withdrawn (EWrongType).
+ * * The obligation has stale oracle prices.
+ * * The withdrawal would leave the obligation in an unhealthy state.
+ * * `reserve_array_index` is out of bounds.
+ * * `obligation_id` is not a valid key in the `obligations` table.
+ */
+export declare function withdrawCtokens(tx: Transaction, typeArgs: [string, string], args: WithdrawCtokensArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface LiquidateArgs {
     lendingMarket: TransactionObjectInput;
     obligationId: string | TransactionArgument;
+    repayReserveArrayIndex: bigint | TransactionArgument;
+    withdrawReserveArrayIndex: bigint | TransactionArgument;
+    clock: TransactionObjectInput;
+    repayCoins: TransactionObjectInput;
+}
+/**
+ * Liquidates an unhealthy obligation by repaying a borrow and seizing collateral.
+ *
+ * This function allows a liquidator to repay a portion of an unhealthy obligation's
+ * debt in exchange for a discounted amount of their collateral. Any leftover repay
+ * coins are returned to the liquidator.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `obligation_id` - The ID of the obligation to liquidate.
+ * * `repay_reserve_array_index` - The index of the reserve to repay the debt to.
+ * * `withdraw_reserve_array_index` - The index of the reserve to withdraw collateral from.
+ * * `clock` - A reference to the `Clock`.
+ * * `repay_coins` - A mutable reference to the `Coin` used to repay the debt.
+ *
+ * # Returns
+ *
+ * * `(Coin<CToken<P, Withdraw>>, RateLimiterExemption<P, Withdraw>)` - A tuple containing the withdrawn collateral as cTokens and a rate limiter exemption.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The repay amount is zero (ETooSmall).
+ * * The obligation is not unhealthy.
+ * * The obligation has stale oracle prices.
+ * * The `coin_type` of the repay reserve does not match the type of the repay coin.
+ * * The `coin_type` of the withdraw reserve does not match the type of the withdrawn cTokens.
+ * * `repay_reserve_array_index` or `withdraw_reserve_array_index` are out of bounds.
+ * * `obligation_id` is not a valid key in the `obligations` table.
+ */
+export declare function liquidate(tx: Transaction, typeArgs: [string, string, string], args: LiquidateArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface RepayArgs {
+    lendingMarket: TransactionObjectInput;
+    reserveArrayIndex: bigint | TransactionArgument;
+    obligationId: string | TransactionArgument;
+    clock: TransactionObjectInput;
+    maxRepayCoins: TransactionObjectInput;
 }
-export declare function obligation(tx: Transaction, typeArg: string, args: ObligationArgs): import("@mysten/sui/transactions").TransactionResult;
-export declare function createObligation(tx: Transaction, typeArg: string, lendingMarket: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
-export declare function reserveArrayIndex(tx: Transaction, typeArgs: [string, string], lendingMarket: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
+/**
+ * Repays a borrow, reducing the obligation's debt and increasing the reserve's liquidity.
+ *
+ * Any leftover repay coins are returned to the caller.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to repay the debt to.
+ * * `obligation_id` - The ID of the obligation to repay.
+ * * `clock` - A reference to the `Clock`.
+ * * `max_repay_coins` - A mutable reference to the `Coin` used to repay the debt.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The `coin_type` of the reserve does not match the type of the repay coin (EWrongType).
+ * * `reserve_array_index` is out of bounds.
+ * * `obligation_id` is not a valid key in the `obligations` table.
+ */
+export declare function repay(tx: Transaction, typeArgs: [string, string], args: RepayArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
 export interface ForgiveArgs {
     lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
@@ -135,34 +472,305 @@ export interface ForgiveArgs {
     clock: TransactionObjectInput;
     maxForgiveAmount: bigint | TransactionArgument;
 }
-export declare function forgive(tx: Transaction, typeArgs: [string, string], args: ForgiveArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface LiquidateArgs {
+/**
+ * Forgives a debt on an obligation, effectively reducing the borrow amount without requiring repayment.
+ *
+ * This is an admin-only function that can be used to handle bad debt or other special circumstances.
+ * It reduces the borrowed amount for a specific reserve within an obligation.
+ *
+ * # Arguments
+ *
+ * * `_` - The `LendingMarketOwnerCap` to authorize the operation.
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve for which to forgive the debt.
+ * * `obligation_id` - The ID of the obligation to forgive the debt for.
+ * * `clock` - A reference to the `Clock`.
+ * * `max_forgive_amount` - The maximum amount of debt to forgive.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `obligation_id` is not a valid key in the `obligations` table.
+ * * The obligation has stale oracle prices.
+ * * The `coin_type` of the reserve does not match the type of the debt being forgiven (EWrongType).
+ * * `reserve_array_index` is out of bounds.
+ * * If the forgiveness would leave the reserve's total supply below its ctoken supply in
+ * scaled units (`EForgiveWouldZeroBacking` from the `reserve` module).
+ */
+export declare function forgive(tx: Transaction, typeArgs: [string, string], args: ForgiveArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface ClaimRewardsArgs {
+    lendingMarket: TransactionObjectInput;
+    cap: TransactionObjectInput;
+    clock: TransactionObjectInput;
+    reserveId: bigint | TransactionArgument;
+    rewardIndex: bigint | TransactionArgument;
+    isDepositReward: boolean | TransactionArgument;
+}
+/**
+ * Claims rewards earned by an obligation.
+ *
+ * This function allows an obligation owner to claim rewards that have accrued
+ * from either depositing or borrowing on a reserve.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `cap` - The `ObligationOwnerCap` to authorize the operation.
+ * * `clock` - A reference to the `Clock`.
+ * * `reserve_id` - The array index of the reserve that is giving out the rewards.
+ * * `reward_index` - The index of the reward pool to claim from.
+ * * `is_deposit_reward` - A boolean indicating whether to claim deposit rewards (true) or borrow rewards (false).
+ *
+ * # Returns
+ *
+ * * `Coin<RewardType>` - A `Coin` containing the claimed rewards.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * It will also panic if the underlying `claim_rewards_by_obligation_id` panics.
+ */
+export declare function claimRewards(tx: Transaction, typeArgs: [string, string], args: ClaimRewardsArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface ClaimRewardsAndDepositArgs {
     lendingMarket: TransactionObjectInput;
     obligationId: string | TransactionArgument;
-    repayReserveArrayIndex: bigint | TransactionArgument;
-    withdrawReserveArrayIndex: bigint | TransactionArgument;
     clock: TransactionObjectInput;
-    repayCoins: TransactionObjectInput;
+    rewardReserveId: bigint | TransactionArgument;
+    rewardIndex: bigint | TransactionArgument;
+    isDepositReward: boolean | TransactionArgument;
+    depositReserveId: bigint | TransactionArgument;
+}
+/**
+ * Claims rewards earned by an obligation and deposits them back into the obligation.
+ *
+ * This is a permissionless function that can be called by anyone to "crank" rewards for a given obligation.
+ * It first claims the rewards from the specified reward pool and then, if the obligation has a borrow of the
+ * same asset, it repays the borrow. The remaining rewards are deposited as liquidity into the specified
+ * reserve and the resulting CTokens are deposited into the obligation to be used as collateral.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `obligation_id` - The ID of the obligation to claim rewards for and deposit into.
+ * * `clock` - A reference to the `Clock`.
+ * * `reward_reserve_id` - The array index of the reserve that is giving out the rewards.
+ * * `reward_index` - The index of the reward pool to claim from.
+ * * `is_deposit_reward` - A boolean indicating whether to claim deposit rewards (true) or borrow rewards (false).
+ * * `deposit_reserve_id` - The array index of the reserve to deposit the claimed rewards into.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The reward period is not over.
+ * * The `coin_type` of the deposit reserve does not match the type of the reward.
+ * * It will also panic if the underlying `claim_rewards_by_obligation_id` or `repay` or `deposit_liquidity_and_mint_ctokens` panics.
+ * * If ctokens are outstanding but unclaimed spread fees have consumed the entire total
+ * supply, leaving them unbacked (`EReserveInDeficit` from the `reserve` module).
+ *
+ * For expired points campaign types: instead of claiming
+ * and depositing, force-closes the UserReward entry on the obligation. The pool reward must
+ * have been cancelled and drained first. deposit_reserve_id is ignored.
+ */
+export declare function claimRewardsAndDeposit(tx: Transaction, typeArgs: [string, string], args: ClaimRewardsAndDepositArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface InitStakerArgs {
+    lendingMarket: TransactionObjectInput;
+    lendingMarketOwnerCap: TransactionObjectInput;
+    suiReserveArrayIndex: bigint | TransactionArgument;
+    treasuryCap: TransactionObjectInput;
+}
+/**
+ * Initializes a staker for a SUI reserve.
+ *
+ * This function is used to set up a staker for a SUI reserve, which allows the reserve
+ * to participate in staking and earn rewards. It can only be called by the owner of the
+ * lending market.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `_` - The `LendingMarketOwnerCap` to authorize the operation.
+ * * `sui_reserve_array_index` - The index of the SUI reserve to initialize the staker for.
+ * * `treasury_cap` - The `TreasuryCap` for the staker.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The reserve at `sui_reserve_array_index` is not a SUI reserve (EWrongType).
+ * * `sui_reserve_array_index` is out of bounds.
+ */
+export declare function initStaker(tx: Transaction, typeArgs: [string, string], args: InitStakerArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface RebalanceStakerArgs {
+    lendingMarket: TransactionObjectInput;
+    suiReserveArrayIndex: bigint | TransactionArgument;
+    systemState: TransactionObjectInput;
+}
+/**
+ * Rebalances a staker by staking or unstaking SUI to match the target staking amount.
+ *
+ * This function is a wrapper around `reserve::rebalance_staker`. It ensures that the
+ * lending market is on the correct version and that the specified reserve is a SUI
+ * reserve before proceeding with the rebalancing.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `sui_reserve_array_index` - The index of the SUI reserve to rebalance.
+ * * `system_state` - A mutable reference to the `SuiSystemState`.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The reserve at `sui_reserve_array_index` is not a SUI reserve (EWrongType).
+ * * `sui_reserve_array_index` is out of bounds.
+ */
+export declare function rebalanceStaker(tx: Transaction, typeArg: string, args: RebalanceStakerArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface UnstakeSuiFromStakerArgs {
+    lendingMarket: TransactionObjectInput;
+    suiReserveArrayIndex: bigint | TransactionArgument;
+    liquidityRequest: TransactionObjectInput;
+    systemState: TransactionObjectInput;
 }
-export declare function liquidate(tx: Transaction, typeArgs: [string, string, string], args: LiquidateArgs): import("@mysten/sui/transactions").TransactionResult;
-export declare function reserves(tx: Transaction, typeArg: string, lendingMarket: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
+/**
+ * Unstakes SUI from a staker.
+ *
+ * This function is a wrapper around `reserve::unstake_sui_from_staker`. It ensures that the
+ * lending market is on the correct version and that the specified reserve is a SUI
+ * reserve before proceeding with the unstaking.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `sui_reserve_array_index` - The index of the SUI reserve to unstake from.
+ * * `liquidity_request` - A reference to the `LiquidityRequest` for the unstake.
+ * * `system_state` - A mutable reference to the `SuiSystemState`.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `sui_reserve_array_index` is out of bounds.
+ */
+export declare function unstakeSuiFromStaker(tx: Transaction, typeArg: string, args: UnstakeSuiFromStakerArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/** Get a reference to the lending market's reserves vector. */
+export declare function reserves(tx: Transaction, typeArg: string, lendingMarket: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface MaxBorrowAmountArgs {
+    rateLimiter: TransactionObjectInput;
+    obligation: TransactionObjectInput;
+    reserve: TransactionObjectInput;
+    clock: TransactionObjectInput;
+}
+export declare function maxBorrowAmount(tx: Transaction, typeArg: string, args: MaxBorrowAmountArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
 export interface MaxWithdrawAmountArgs {
     rateLimiter: TransactionObjectInput;
     obligation: TransactionObjectInput;
     reserve: TransactionObjectInput;
     clock: TransactionObjectInput;
 }
-export declare function maxWithdrawAmount(tx: Transaction, typeArg: string, args: MaxWithdrawAmountArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface RepayArgs {
+export declare function maxWithdrawAmount(tx: Transaction, typeArg: string, args: MaxWithdrawAmountArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/** Get the obligation ID from an `ObligationOwnerCap`. */
+export declare function obligationId(tx: Transaction, typeArg: string, cap: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/**
+ * Get the array index of a reserve by its coin type.
+ * slow function. use sparingly.
+ */
+export declare function reserveArrayIndex(tx: Transaction, typeArgs: [string, string], lendingMarket: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/** Get a reference to a reserve by its coin type. */
+export declare function reserve(tx: Transaction, typeArgs: [string, string], lendingMarket: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/**
+ * Seeds a `ReserveConfigBuilder` from a reserve's live on-chain config in a
+ * single call, so the `&ReserveConfig` `reserve::config` returns never has
+ * to cross a PTB command boundary into `reserve_config::from`.
+ */
+export declare function reserveConfigBuilder(tx: Transaction, typeArgs: [string, string], lendingMarket: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface ObligationArgs {
     lendingMarket: TransactionObjectInput;
-    reserveArrayIndex: bigint | TransactionArgument;
     obligationId: string | TransactionArgument;
-    clock: TransactionObjectInput;
-    maxRepayCoins: TransactionObjectInput;
 }
-export declare function repay(tx: Transaction, typeArgs: [string, string], args: RepayArgs): import("@mysten/sui/transactions").TransactionResult;
-export declare function obligationId(tx: Transaction, typeArg: string, cap: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
+/** Get a reference to an obligation by its ID. */
+export declare function obligation(tx: Transaction, typeArg: string, args: ObligationArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/** Get the fee receiver address. */
+export declare function feeReceiver(tx: Transaction, typeArg: string, lendingMarket: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/** Get the amount of a rate limiter exemption. */
+export declare function rateLimiterExemptionAmount(tx: Transaction, typeArgs: [string, string], exemption: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface MigrateArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
+    lendingMarket: TransactionObjectInput;
+}
+/** Migrates the lending market to the current version. */
+export declare function migrate(tx: Transaction, typeArg: string, args: MigrateArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
 export interface AddReserveArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
+    lendingMarket: TransactionObjectInput;
+    priceInfoObject: TransactionObjectInput;
+    reserveConfig: TransactionObjectInput;
+    coinMetadata: TransactionObjectInput;
+    clock: TransactionObjectInput;
+}
+/**
+ * Deprecated tombstone — kept only because Sui's upgrade compatibility rules
+ * freeze a published function's signature. Pyth froze every legacy on-chain
+ * feed at the 2026-08-26 cutover; nothing has written to one since, so this
+ * now aborts unconditionally instead of creating a reserve seeded from a
+ * permanently-stale price. Use `add_reserve_pro_compatible`.
+ */
+export declare function addReserve(tx: Transaction, typeArgs: [string, string], args: AddReserveArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface AddReserveV2Args {
+    lendingMarketOwnerCap: TransactionObjectInput;
+    lendingMarket: TransactionObjectInput;
+    priceInfoObject: TransactionObjectInput;
+    reserveConfig: TransactionObjectInput;
+    currency: TransactionObjectInput;
+    clock: TransactionObjectInput;
+}
+/**
+ * Deprecated tombstone, for the same reason as `add_reserve`. Use
+ * `add_reserve_v2_pro_compatible`.
+ */
+export declare function addReserveV2(tx: Transaction, typeArgs: [string, string], args: AddReserveV2Args, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface AddReserveProCompatibleArgs {
     lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
     priceInfo: TransactionObjectInput;
@@ -170,103 +778,469 @@ export interface AddReserveArgs {
     coinMetadata: TransactionObjectInput;
     clock: TransactionObjectInput;
 }
-export declare function addReserve(tx: Transaction, typeArgs: [string, string], args: AddReserveArgs): import("@mysten/sui/transactions").TransactionResult;
-export declare function addReserveV2(tx: Transaction, typeArgs: [string, string], args: AddReserveArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface BorrowRequestArgs {
+/**
+ * `add_reserve` against the upgraded Pyth package. Only this path can
+ * consume payloads after the 2026-08-18 cutover.
+ */
+export declare function addReserveProCompatible(tx: Transaction, typeArgs: [string, string], args: AddReserveProCompatibleArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface AddReserveV2ProCompatibleArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
-    reserveArrayIndex: bigint | TransactionArgument;
-    obligationOwnerCap: TransactionObjectInput;
+    priceInfo: TransactionObjectInput;
+    config: TransactionObjectInput;
+    currency: TransactionObjectInput;
     clock: TransactionObjectInput;
-    amount: bigint | TransactionArgument;
 }
-export declare function borrowRequest(tx: Transaction, typeArgs: [string, string], args: BorrowRequestArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface ChangeReservePriceFeedArgs {
+/**
+ * `add_reserve_v2` against the upgraded Pyth package. Only this path can
+ * consume payloads after the 2026-08-18 cutover.
+ */
+export declare function addReserveV2ProCompatible(tx: Transaction, typeArgs: [string, string], args: AddReserveV2ProCompatibleArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface UpdateReserveConfigArgs {
     lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
-    priceInfoObj: TransactionObjectInput;
-    clock: TransactionObjectInput;
+    config: TransactionObjectInput;
 }
-export declare function changeReservePriceFeed(tx: Transaction, typeArgs: [string, string], args: ChangeReservePriceFeedArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface ClaimRewardsAndDepositArgs {
+/**
+ * Updates the configuration of a reserve.
+ *
+ * This function allows the owner of the lending market to update the configuration of a specific reserve.
+ * It can only be called by the owner of the lending market.
+ *
+ * # Arguments
+ *
+ * * `_` - The `LendingMarketOwnerCap` to authorize the operation.
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to update.
+ * * `config` - The new configuration for the reserve.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `reserve_array_index` is out of bounds.
+ * * The `coin_type` of the reserve does not match the type `T` (EWrongType).
+ */
+export declare function updateReserveConfig(tx: Transaction, typeArgs: [string, string], args: UpdateReserveConfigArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface SetReservePriceGuardArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
-    obligationId: string | TransactionArgument;
+    reserveArrayIndex: bigint | TransactionArgument;
+    maxPriceChangeBps: bigint | TransactionArgument;
+    minUpdateIntervalS: bigint | TransactionArgument;
     clock: TransactionObjectInput;
-    rewardReserveId: bigint | TransactionArgument;
-    rewardIndex: bigint | TransactionArgument;
-    isDepositReward: boolean | TransactionArgument;
-    depositReserveId: bigint | TransactionArgument;
 }
-export declare function claimRewardsAndDeposit(tx: Transaction, typeArgs: [string, string], args: ClaimRewardsAndDepositArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface ClaimRewardsByObligationIdArgs {
+/**
+ * Sets a reserve's price guard, bounding how far its price and smoothed price may
+ * move per `min_update_interval_s`. Seeds both anchors from the reserve's current
+ * prices, so widening the band and refreshing is how the owner admits a genuine move.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `reserve_array_index` is out of bounds.
+ * * The `coin_type` of the reserve does not match the type `T` (EWrongType).
+ * * The band reaches the reserve's liquidation buffer (EPriceBandAboveLiquidationBuffer).
+ */
+export declare function setReservePriceGuard(tx: Transaction, typeArgs: [string, string], args: SetReservePriceGuardArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface ChangeReservePriceFeedArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
-    obligationId: string | TransactionArgument;
+    u64: bigint | TransactionArgument;
+    priceInfoObject: TransactionObjectInput;
     clock: TransactionObjectInput;
-    reserveId: bigint | TransactionArgument;
-    rewardIndex: bigint | TransactionArgument;
-    isDepositReward: boolean | TransactionArgument;
-    failIfRewardPeriodNotOver: boolean | TransactionArgument;
 }
-export declare function claimRewardsByObligationId(tx: Transaction, typeArgs: [string, string], args: ClaimRewardsByObligationIdArgs): import("@mysten/sui/transactions").TransactionResult;
-export declare function createLendingMarket(tx: Transaction, typeArg: string): import("@mysten/sui/transactions").TransactionResult;
-export interface DepositCtokensIntoObligationArgs {
+/**
+ * Deprecated tombstone — kept only because Sui's upgrade compatibility rules
+ * freeze a published function's signature. Pyth froze every legacy on-chain
+ * feed at the 2026-08-26 cutover; nothing has written to one since, so this
+ * now aborts unconditionally instead of repointing a reserve at a
+ * permanently-stale feed. Use `change_reserve_price_feed_pro_compatible`.
+ */
+export declare function changeReservePriceFeed(tx: Transaction, typeArgs: [string, string], args: ChangeReservePriceFeedArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface ChangeReservePriceFeedProCompatibleArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
-    obligationOwnerCap: TransactionObjectInput;
+    priceInfoObj: TransactionObjectInput;
     clock: TransactionObjectInput;
-    deposit: TransactionObjectInput;
 }
-export declare function depositCtokensIntoObligation(tx: Transaction, typeArgs: [string, string], args: DepositCtokensIntoObligationArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface DepositCtokensIntoObligationByIdArgs {
+/**
+ * `change_reserve_price_feed` against the upgraded Pyth package. Same
+ * owner-cap gate and coin-type check; only the object's package differs.
+ */
+export declare function changeReservePriceFeedProCompatible(tx: Transaction, typeArgs: [string, string], args: ChangeReservePriceFeedProCompatibleArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface AddPoolRewardArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
-    obligationId: string | TransactionArgument;
+    isDepositReward: boolean | TransactionArgument;
+    rewards: TransactionObjectInput;
+    startTimeMs: bigint | TransactionArgument;
+    endTimeMs: bigint | TransactionArgument;
     clock: TransactionObjectInput;
-    deposit: TransactionObjectInput;
 }
-export declare function depositCtokensIntoObligationById(tx: Transaction, typeArgs: [string, string], args: DepositCtokensIntoObligationByIdArgs): import("@mysten/sui/transactions").TransactionResult;
-export declare function feeReceiver(tx: Transaction, typeArg: string, lendingMarket: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
-export interface NewObligationOwnerCapArgs {
+/**
+ * Adds a new reward pool to a reserve for either deposits or borrows.
+ *
+ * This function allows the owner of the lending market to incentivize users by adding rewards
+ * to a specific reserve. The rewards are distributed over a specified time period.
+ *
+ * # Arguments
+ *
+ * * `_` - The `LendingMarketOwnerCap` to authorize the operation.
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to add the reward pool to.
+ * * `is_deposit_reward` - A boolean indicating whether the reward is for deposits (`true`) or borrows (`false`).
+ * * `rewards` - The `Coin` containing the total amount of rewards to be distributed.
+ * * `start_time_ms` - The timestamp in milliseconds when the reward distribution starts.
+ * * `end_time_ms` - The timestamp in milliseconds when the reward distribution ends.
+ * * `clock` - A reference to the `Clock`.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `reserve_array_index` is out of bounds.
+ * * The underlying `liquidity_mining::add_pool_reward` function panics (e.g., if `start_time_ms` >= `end_time_ms` or reward amount is zero).
+ */
+export declare function addPoolReward(tx: Transaction, typeArgs: [string, string], args: AddPoolRewardArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface CancelPoolRewardArgs {
     lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
-    obligationId: string | TransactionArgument;
+    reserveArrayIndex: bigint | TransactionArgument;
+    isDepositReward: boolean | TransactionArgument;
+    rewardIndex: bigint | TransactionArgument;
+    clock: TransactionObjectInput;
 }
-export declare function newObligationOwnerCap(tx: Transaction, typeArg: string, args: NewObligationOwnerCapArgs): import("@mysten/sui/transactions").TransactionResult;
-export declare function rateLimiterExemptionAmount(tx: Transaction, typeArgs: [string, string], exemption: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
-export interface RedeemCtokensAndWithdrawLiquidityArgs {
+/**
+ * Cancels a reward pool from a reserve.
+ *
+ * This is an admin-only function that allows the lending market owner to cancel a reward pool
+ * that is currently active. When a reward pool is cancelled, any unallocated rewards are
+ * returned to the owner.
+ *
+ * # Arguments
+ *
+ * * `_` - The `LendingMarketOwnerCap` to authorize the operation.
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to cancel the reward pool from.
+ * * `is_deposit_reward` - A boolean indicating whether the reward is for deposits (`true`) or borrows (`false`).
+ * * `reward_index` - The index of the reward pool to cancel.
+ * * `clock` - A reference to the `Clock`.
+ *
+ * # Returns
+ *
+ * * `Coin<RewardType>` - A `Coin` containing the unallocated rewards from the cancelled pool.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `reserve_array_index` is out of bounds.
+ * * The underlying `liquidity_mining::cancel_pool_reward` function panics.
+ */
+export declare function cancelPoolReward(tx: Transaction, typeArgs: [string, string], args: CancelPoolRewardArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface ClosePoolRewardArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
+    isDepositReward: boolean | TransactionArgument;
+    rewardIndex: bigint | TransactionArgument;
     clock: TransactionObjectInput;
-    ctokens: TransactionObjectInput;
-    rateLimiterExemption: TransactionObjectInput | TransactionArgument | null;
 }
-export declare function redeemCtokensAndWithdrawLiquidity(tx: Transaction, typeArgs: [string, string], args: RedeemCtokensAndWithdrawLiquidityArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface RedeemCtokensAndWithdrawLiquidityRequestArgs {
+/**
+ * Closes a reward pool from a reserve after its distribution period has ended.
+ *
+ * This is an admin-only function that allows the lending market owner to close a reward pool
+ * that has finished distributing rewards. When a reward pool is closed, any unallocated rewards
+ * due to rounding or other factors are returned to the owner. This function can only be called
+ * after the pool's `end_time_ms` has passed.
+ *
+ * # Arguments
+ *
+ * * `_` - The `LendingMarketOwnerCap` to authorize the operation.
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to close the reward pool from.
+ * * `is_deposit_reward` - A boolean indicating whether the reward is for deposits (`true`) or borrows (`false`).
+ * * `reward_index` - The index of the reward pool to close.
+ * * `clock` - A reference to the `Clock`.
+ *
+ * # Returns
+ *
+ * * `Coin<RewardType>` - A `Coin` containing the unallocated rewards from the closed pool.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `reserve_array_index` is out of bounds.
+ * * The underlying `liquidity_mining::close_pool_reward` function panics (e.g., if the reward period is not over).
+ */
+export declare function closePoolReward(tx: Transaction, typeArgs: [string, string], args: ClosePoolRewardArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface DrainPointsRewardArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;
+    isDepositReward: boolean | TransactionArgument;
+    rewardIndex: bigint | TransactionArgument;
     clock: TransactionObjectInput;
-    ctokens: TransactionObjectInput;
-    rateLimiterExemption: TransactionObjectInput | TransactionArgument | null;
 }
-export declare function redeemCtokensAndWithdrawLiquidityRequest(tx: Transaction, typeArgs: [string, string], args: RedeemCtokensAndWithdrawLiquidityRequestArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface RefreshReservePriceArgs {
+/**
+ * Drains all remaining balance from a Suilend/Steamm points reward after its period has ended.
+ * UserReward entries are cleaned up when users next interact with the protocol.
+ * cancel_pool_reward must be called first to stop accumulation, then drain_points_reward to reclaim the remaining balance.
+ */
+export declare function drainPointsReward(tx: Transaction, typeArgs: [string, string], args: DrainPointsRewardArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface UpdateRateLimiterConfigArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
-    reserveArrayIndex: bigint | TransactionArgument;
     clock: TransactionObjectInput;
-    priceInfo: TransactionObjectInput;
+    config: TransactionObjectInput;
 }
-export declare function refreshReservePrice(tx: Transaction, typeArg: string, args: RefreshReservePriceArgs): import("@mysten/sui/transactions").TransactionResult;
+/**
+ * Updates the rate limiter configuration.
+ *
+ * This is an admin-only function that allows the lending market owner to update the rate
+ * limiter configuration. The new configuration will replace the existing one.
+ *
+ * # Arguments
+ *
+ * * `_` - The `LendingMarketOwnerCap` to authorize the operation.
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `clock` - A reference to the `Clock` to get the current timestamp.
+ * * `config` - The new `RateLimiterConfig` to apply.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ */
+export declare function updateRateLimiterConfig(tx: Transaction, typeArg: string, args: UpdateRateLimiterConfigArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
 export interface SetFeeReceiversArgs {
     lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
     receivers: Array<string | TransactionArgument> | TransactionArgument;
     weights: Array<bigint | TransactionArgument> | TransactionArgument;
 }
-export declare function setFeeReceivers(tx: Transaction, typeArg: string, args: SetFeeReceiversArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface UpdateRateLimiterConfigArgs {
+/**
+ * Sets the fee receivers for the lending market.
+ *
+ * This is an admin-only function that allows the lending market owner to set the fee receivers
+ * and their respective weights for distributing protocol fees. The fees are distributed
+ * proportionally based on these weights.
+ *
+ * # Arguments
+ *
+ * * `_` - The `LendingMarketOwnerCap` to authorize the operation.
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `receivers` - A vector of addresses that will receive the fees.
+ * * `weights` - A vector of weights corresponding to each receiver.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The `receivers` and `weights` vectors do not have the same length (EInvalidFeeReceivers).
+ * * The `receivers` vector is empty (EInvalidFeeReceivers).
+ * * The sum of `weights` is zero (EInvalidFeeReceivers).
+ */
+export declare function setFeeReceivers(tx: Transaction, typeArg: string, args: SetFeeReceiversArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface ClaimFeesArgs {
+    lendingMarket: TransactionObjectInput;
+    reserveArrayIndex: bigint | TransactionArgument;
+    systemState: TransactionObjectInput;
+}
+/**
+ * Claims the fees from a reserve and distributes them to the fee receivers.
+ *
+ * This is a permissionless entry function that can be called by anyone to trigger the
+ * distribution of accumulated protocol fees from a specific reserve. The fees, which
+ * can be in both the underlying asset and cTokens, are transferred to the fee receivers
+ * according to the weights configured via `set_fee_receivers`.
+ *
+ * # Arguments
+ *
+ * * `lending_market` - A mutable reference to the `LendingMarket`.
+ * * `reserve_array_index` - The index of the reserve to claim fees from.
+ * * `system_state` - A mutable reference to the `SuiSystemState`, required for claiming staking rewards.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The generic type `T` does not match the coin type of the reserve at `reserve_array_index` (EWrongType).
+ * * `reserve_array_index` is out of bounds.
+ * * The `FeeReceivers` dynamic field has not been set on the lending market.
+ */
+export declare function claimFees(tx: Transaction, typeArgs: [string, string], args: ClaimFeesArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface NewObligationOwnerCapArgs {
+    lendingMarketOwnerCap: TransactionObjectInput;
+    lendingMarket: TransactionObjectInput;
+    obligationId: string | TransactionArgument;
+}
+/**
+ * Creates a new obligation owner cap for an existing obligation.
+ *
+ * This is an admin-only function that allows the lending market owner to create a new
+ * `ObligationOwnerCap` for an obligation that already exists. This can be useful for
+ * recovery purposes or administrative actions where a new capability object is needed.
+ *
+ * # Arguments
+ *
+ * * `_` - The `LendingMarketOwnerCap` to authorize the operation.
+ * * `lending_market` - A reference to the `LendingMarket`.
+ * * `obligation_id` - The ID of the obligation to create a new owner cap for.
+ *
+ * # Returns
+ *
+ * * `ObligationOwnerCap<P>` - The newly created ownership capability for the specified obligation.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * The `obligation_id` is not found in the lending market's obligations (EInvalidObligationId).
+ */
+export declare function newObligationOwnerCap(tx: Transaction, typeArg: string, args: NewObligationOwnerCapArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface NewPauseCapArgs {
     lendingMarketOwnerCap: TransactionObjectInput;
     lendingMarket: TransactionObjectInput;
+    recipient: string | TransactionArgument;
+}
+/**
+ * Mints a fresh `EmergencyPauseCap` at the next generation, revoking every
+ * previously-issued cap for this market (their `generation` no longer matches).
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ */
+export declare function newPauseCap(tx: Transaction, typeArg: string, args: NewPauseCapArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface SetMarketPausedArgs {
+    cap: TransactionObjectInput;
+    lendingMarket: TransactionObjectInput;
+    paused: boolean | TransactionArgument;
+}
+/**
+ * Pauses or resumes the entire market. Gated on possession of the
+ * current-generation `EmergencyPauseCap`; a cap from a superseded generation aborts.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `cap` was not minted for this `lending_market` (EWrongLendingMarket).
+ * * `cap`'s generation has been superseded by a later `new_pause_cap` call (EStalePauseCap).
+ */
+export declare function setMarketPaused(tx: Transaction, typeArg: string, args: SetMarketPausedArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface SetReservePausedArgs {
+    cap: TransactionObjectInput;
+    lendingMarket: TransactionObjectInput;
+    reserveArrayIndex: bigint | TransactionArgument;
+    paused: boolean | TransactionArgument;
+}
+/**
+ * Pauses or resumes a single reserve. Gated on possession of the current-generation
+ * `EmergencyPauseCap`; a cap from a superseded generation aborts.
+ *
+ * # Panics
+ *
+ * This function will panic if:
+ * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `cap` was not minted for this `lending_market` (EWrongLendingMarket).
+ * * `cap`'s generation has been superseded by a later `new_pause_cap` call (EStalePauseCap).
+ * * `reserve_array_index` is out of bounds.
+ */
+export declare function setReservePaused(tx: Transaction, typeArg: string, args: SetReservePausedArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+/**
+ * True if the market has been paused. Absent the dynamic field, the market is
+ * unpaused. Pure: no aborts, no side effects. Public so a UI or bot can check
+ * pause state before building a PTB, instead of discovering it as an abort.
+ */
+export declare function isMarketPaused(tx: Transaction, typeArg: string, lendingMarket: TransactionObjectInput, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface AssertValidPauseCapArgs {
+    cap: TransactionObjectInput;
+    lendingMarket: TransactionObjectInput;
+}
+export declare function assertValidPauseCap(tx: Transaction, typeArg: string, args: AssertValidPauseCapArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface AssertNotPausedArgs {
+    lendingMarket: TransactionObjectInput;
+    reserve: TransactionObjectInput;
+}
+export declare function assertNotPaused(tx: Transaction, typeArg: string, args: AssertNotPausedArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface DepositCtokensIntoObligationByIdArgs {
+    lendingMarket: TransactionObjectInput;
+    reserveArrayIndex: bigint | TransactionArgument;
+    obligationId: string | TransactionArgument;
+    clock: TransactionObjectInput;
+    deposit: TransactionObjectInput;
+}
+export declare function depositCtokensIntoObligationById(tx: Transaction, typeArgs: [string, string], args: DepositCtokensIntoObligationByIdArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface ClaimRewardsByObligationIdArgs {
+    lendingMarket: TransactionObjectInput;
+    obligationId: string | TransactionArgument;
     clock: TransactionObjectInput;
+    reserveId: bigint | TransactionArgument;
+    rewardIndex: bigint | TransactionArgument;
+    isDepositReward: boolean | TransactionArgument;
+    failIfRewardPeriodNotOver: boolean | TransactionArgument;
+}
+export declare function claimRewardsByObligationId(tx: Transaction, typeArgs: [string, string], args: ClaimRewardsByObligationIdArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface AddReserveInternalProCompatibleArgs {
+    lendingMarket: TransactionObjectInput;
+    priceInfo: TransactionObjectInput;
     config: TransactionObjectInput;
+    decimals: number | TransactionArgument;
+    clock: TransactionObjectInput;
 }
-export declare function updateRateLimiterConfig(tx: Transaction, typeArg: string, args: UpdateRateLimiterConfigArgs): import("@mysten/sui/transactions").TransactionResult;
+export declare function addReserveInternalProCompatible(tx: Transaction, typeArgs: [string, string], args: AddReserveInternalProCompatibleArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;