@suilend/sdk 12.7.0 → 13.0.0-next.g803bba0

package/_generated/suilend/lending-market/functions.js

@@ -1,323 +1,901 @@
-import { PUBLISHED_AT } from "../index.js";
-import { ID } from "../../_dependencies/source/0x2/object/structs.js";
-import { obj, option, pure } from "../../_framework/util.js";
-import { RateLimiterExemption } from "./structs.js";
-export function borrow(tx, typeArgs, args) {
+import { ID } from '../../_dependencies/sui/object/structs.js';
+import { getPublishedAt } from '../../_envs/index.js';
+import { obj, option, pure } from '../../_framework/util.js';
+import { RateLimiterExemption } from './structs.js';
+export function init(tx, otw, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::borrow`,
-        typeArguments: typeArgs,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::init`,
+        arguments: [obj(tx, otw)],
+    });
+}
+/**
+ * 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 function createLendingMarket(tx, typeArg, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::create_lending_market`,
+        typeArguments: [typeArg],
+        arguments: [],
+    });
+}
+/**
+ * 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 function refreshReservePrice(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::refresh_reserve_price`,
+        typeArguments: [typeArg],
         arguments: [
             obj(tx, args.lendingMarket),
-            pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.obligationOwnerCap),
+            pure(tx, args.u64, `u64`),
             obj(tx, args.clock),
-            pure(tx, args.amount, `u64`),
+            obj(tx, args.priceInfoObject),
         ],
     });
 }
-export function migrate(tx, typeArg, args) {
+/**
+ * `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 function refreshReservePriceProCompatible(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::migrate`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::refresh_reserve_price_pro_compatible`,
         typeArguments: [typeArg],
         arguments: [
-            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            obj(tx, args.clock),
+            obj(tx, args.priceInfo),
         ],
     });
 }
-export function init(tx, otw) {
+/** Creates a new obligation. */
+export function createObligation(tx, typeArg, lendingMarket, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::init`,
-        arguments: [obj(tx, otw)],
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::create_obligation`,
+        typeArguments: [typeArg],
+        arguments: [obj(tx, lendingMarket)],
     });
 }
-export function claimFees(tx, typeArgs, args) {
+/**
+ * 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 function depositLiquidityAndMintCtokens(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::claim_fees`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::deposit_liquidity_and_mint_ctokens`,
         typeArguments: typeArgs,
         arguments: [
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.systemState),
+            obj(tx, args.clock),
+            obj(tx, args.deposit),
         ],
     });
 }
-export function addPoolReward(tx, typeArgs, args) {
+/**
+ * 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 function redeemCtokensAndWithdrawLiquidity(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::add_pool_reward`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
         typeArguments: typeArgs,
         arguments: [
-            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            pure(tx, args.isDepositReward, `bool`),
-            obj(tx, args.rewards),
-            pure(tx, args.startTimeMs, `u64`),
-            pure(tx, args.endTimeMs, `u64`),
             obj(tx, args.clock),
+            obj(tx, args.ctokens),
+            option(tx, `${RateLimiterExemption.$typeName}<${typeArgs[0]}, ${typeArgs[1]}>`, args.rateLimiterExemption),
         ],
     });
 }
-export function cancelPoolReward(tx, typeArgs, args) {
+/**
+ * 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 function redeemCtokensAndWithdrawLiquidityRequest(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::cancel_pool_reward`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::redeem_ctokens_and_withdraw_liquidity_request`,
         typeArguments: typeArgs,
         arguments: [
-            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            pure(tx, args.isDepositReward, `bool`),
-            pure(tx, args.rewardIndex, `u64`),
             obj(tx, args.clock),
+            obj(tx, args.ctokens),
+            option(tx, `${RateLimiterExemption.$typeName}<${typeArgs[0]}, ${typeArgs[1]}>`, args.rateLimiterExemption),
         ],
     });
 }
-export function claimRewards(tx, typeArgs, args) {
+/**
+ * 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 function depositCtokensIntoObligation(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::claim_rewards`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::deposit_ctokens_into_obligation`,
         typeArguments: typeArgs,
         arguments: [
             obj(tx, args.lendingMarket),
-            obj(tx, args.cap),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            obj(tx, args.obligationOwnerCap),
             obj(tx, args.clock),
-            pure(tx, args.reserveId, `u64`),
-            pure(tx, args.rewardIndex, `u64`),
-            pure(tx, args.isDepositReward, `bool`),
+            obj(tx, args.deposit),
         ],
     });
 }
-export function closePoolReward(tx, typeArgs, args) {
+/**
+ * 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 function borrow(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::close_pool_reward`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::borrow`,
         typeArguments: typeArgs,
         arguments: [
-            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            pure(tx, args.isDepositReward, `bool`),
-            pure(tx, args.rewardIndex, `u64`),
+            obj(tx, args.obligationOwnerCap),
+            obj(tx, args.clock),
+            pure(tx, args.amount, `u64`),
+        ],
+    });
+}
+/** Compound interest for reserve of type T */
+export function compoundInterest(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::compound_interest`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            obj(tx, args.clock),
+        ],
+    });
+}
+/** Refresh the obligation's state and assert no stale oracles */
+export function refreshObligation(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::refresh_obligation`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
             obj(tx, args.clock),
         ],
     });
 }
-export function reserve(tx, typeArgs, lendingMarket) {
+/**
+ * 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 function borrowRequest(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::reserve`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::borrow_request`,
         typeArguments: typeArgs,
-        arguments: [obj(tx, lendingMarket)],
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            obj(tx, args.obligationOwnerCap),
+            obj(tx, args.clock),
+            pure(tx, args.amount, `u64`),
+        ],
     });
 }
-// lending_market::reserve_config_builder has no published package to
-// regenerate a binding from yet, so this is hand-written to match the shape
-// codegen already produces for `reserve` above. Replace it with the real
-// generated output once this package publishes and the generator runs again.
-export function reserveConfigBuilder(tx, typeArgs, lendingMarket) {
+/**
+ * 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 function fulfillLiquidityRequest(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::reserve_config_builder`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::fulfill_liquidity_request`,
         typeArguments: typeArgs,
-        arguments: [obj(tx, lendingMarket)],
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            obj(tx, args.liquidityRequest),
+        ],
     });
 }
-export function compoundInterest(tx, typeArg, args) {
+/**
+ * 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 function withdrawCtokens(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::compound_interest`,
-        typeArguments: [typeArg],
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::withdraw_ctokens`,
+        typeArguments: typeArgs,
         arguments: [
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
+            obj(tx, args.obligationOwnerCap),
+            obj(tx, args.clock),
+            pure(tx, args.amount, `u64`),
+        ],
+    });
+}
+/**
+ * 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 function liquidate(tx, typeArgs, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::liquidate`,
+        typeArguments: typeArgs,
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
+            pure(tx, args.repayReserveArrayIndex, `u64`),
+            pure(tx, args.withdrawReserveArrayIndex, `u64`),
             obj(tx, args.clock),
+            obj(tx, args.repayCoins),
         ],
     });
 }
-export function depositLiquidityAndMintCtokens(tx, typeArgs, args) {
+/**
+ * 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 function repay(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::deposit_liquidity_and_mint_ctokens`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::repay`,
         typeArguments: typeArgs,
         arguments: [
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
             obj(tx, args.clock),
-            obj(tx, args.deposit),
+            obj(tx, args.maxRepayCoins),
         ],
     });
 }
-export function fulfillLiquidityRequest(tx, typeArgs, args) {
+/**
+ * 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 function forgive(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::fulfill_liquidity_request`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::forgive`,
         typeArguments: typeArgs,
         arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.liquidityRequest),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
+            obj(tx, args.clock),
+            pure(tx, args.maxForgiveAmount, `u64`),
         ],
     });
 }
-export function initStaker(tx, typeArgs, args) {
+/**
+ * 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 function claimRewards(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::init_staker`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::claim_rewards`,
         typeArguments: typeArgs,
         arguments: [
             obj(tx, args.lendingMarket),
-            obj(tx, args.lendingMarketOwnerCap),
-            pure(tx, args.suiReserveArrayIndex, `u64`),
-            obj(tx, args.treasuryCap),
+            obj(tx, args.cap),
+            obj(tx, args.clock),
+            pure(tx, args.reserveId, `u64`),
+            pure(tx, args.rewardIndex, `u64`),
+            pure(tx, args.isDepositReward, `bool`),
         ],
     });
 }
-export function maxBorrowAmount(tx, typeArg, args) {
+/**
+ * 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 function claimRewardsAndDeposit(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::max_borrow_amount`,
-        typeArguments: [typeArg],
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::claim_rewards_and_deposit`,
+        typeArguments: typeArgs,
         arguments: [
-            obj(tx, args.rateLimiter),
-            obj(tx, args.obligation),
-            obj(tx, args.reserve),
+            obj(tx, args.lendingMarket),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
             obj(tx, args.clock),
+            pure(tx, args.rewardReserveId, `u64`),
+            pure(tx, args.rewardIndex, `u64`),
+            pure(tx, args.isDepositReward, `bool`),
+            pure(tx, args.depositReserveId, `u64`),
         ],
     });
 }
-export function rebalanceStaker(tx, typeArg, args) {
+/**
+ * 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 function initStaker(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::rebalance_staker`,
-        typeArguments: [typeArg],
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::init_staker`,
+        typeArguments: typeArgs,
         arguments: [
             obj(tx, args.lendingMarket),
+            obj(tx, args.lendingMarketOwnerCap),
             pure(tx, args.suiReserveArrayIndex, `u64`),
-            obj(tx, args.systemState),
+            obj(tx, args.treasuryCap),
         ],
     });
 }
-export function unstakeSuiFromStaker(tx, typeArg, args) {
+/**
+ * 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 function rebalanceStaker(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::unstake_sui_from_staker`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::rebalance_staker`,
         typeArguments: [typeArg],
         arguments: [
             obj(tx, args.lendingMarket),
             pure(tx, args.suiReserveArrayIndex, `u64`),
-            obj(tx, args.liquidityRequest),
             obj(tx, args.systemState),
         ],
     });
 }
-export function updateReserveConfig(tx, typeArgs, args) {
+/**
+ * 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 function unstakeSuiFromStaker(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::update_reserve_config`,
-        typeArguments: typeArgs,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::unstake_sui_from_staker`,
+        typeArguments: [typeArg],
         arguments: [
-            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
-            pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.config),
+            pure(tx, args.suiReserveArrayIndex, `u64`),
+            obj(tx, args.liquidityRequest),
+            obj(tx, args.systemState),
         ],
     });
 }
-export function withdrawCtokens(tx, typeArgs, args) {
+/** Get a reference to the lending market's reserves vector. */
+export function reserves(tx, typeArg, lendingMarket, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::withdraw_ctokens`,
-        typeArguments: typeArgs,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::reserves`,
+        typeArguments: [typeArg],
+        arguments: [obj(tx, lendingMarket)],
+    });
+}
+export function maxBorrowAmount(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::max_borrow_amount`,
+        typeArguments: [typeArg],
         arguments: [
-            obj(tx, args.lendingMarket),
-            pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.obligationOwnerCap),
+            obj(tx, args.rateLimiter),
+            obj(tx, args.obligation),
+            obj(tx, args.reserve),
             obj(tx, args.clock),
-            pure(tx, args.amount, `u64`),
         ],
     });
 }
-export function obligation(tx, typeArg, args) {
+export function maxWithdrawAmount(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::obligation`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::max_withdraw_amount`,
         typeArguments: [typeArg],
         arguments: [
-            obj(tx, args.lendingMarket),
-            pure(tx, args.obligationId, `${ID.$typeName}`),
+            obj(tx, args.rateLimiter),
+            obj(tx, args.obligation),
+            obj(tx, args.reserve),
+            obj(tx, args.clock),
         ],
     });
 }
-export function createObligation(tx, typeArg, lendingMarket) {
+/** Get the obligation ID from an `ObligationOwnerCap`. */
+export function obligationId(tx, typeArg, cap, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::create_obligation`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::obligation_id`,
         typeArguments: [typeArg],
-        arguments: [obj(tx, lendingMarket)],
+        arguments: [obj(tx, cap)],
     });
 }
-export function reserveArrayIndex(tx, typeArgs, lendingMarket) {
+/**
+ * Get the array index of a reserve by its coin type.
+ * slow function. use sparingly.
+ */
+export function reserveArrayIndex(tx, typeArgs, lendingMarket, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::reserve_array_index`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::reserve_array_index`,
         typeArguments: typeArgs,
         arguments: [obj(tx, lendingMarket)],
     });
 }
-export function forgive(tx, typeArgs, args) {
+/** Get a reference to a reserve by its coin type. */
+export function reserve(tx, typeArgs, lendingMarket, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::forgive`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::reserve`,
         typeArguments: typeArgs,
-        arguments: [
-            obj(tx, args.lendingMarketOwnerCap),
-            obj(tx, args.lendingMarket),
-            pure(tx, args.reserveArrayIndex, `u64`),
-            pure(tx, args.obligationId, `${ID.$typeName}`),
-            obj(tx, args.clock),
-            pure(tx, args.maxForgiveAmount, `u64`),
-        ],
+        arguments: [obj(tx, lendingMarket)],
     });
 }
-export function liquidate(tx, typeArgs, args) {
+/**
+ * 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 function reserveConfigBuilder(tx, typeArgs, lendingMarket, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::liquidate`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::reserve_config_builder`,
         typeArguments: typeArgs,
+        arguments: [obj(tx, lendingMarket)],
+    });
+}
+/** Get a reference to an obligation by its ID. */
+export function obligation(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::obligation`,
+        typeArguments: [typeArg],
         arguments: [
             obj(tx, args.lendingMarket),
             pure(tx, args.obligationId, `${ID.$typeName}`),
-            pure(tx, args.repayReserveArrayIndex, `u64`),
-            pure(tx, args.withdrawReserveArrayIndex, `u64`),
-            obj(tx, args.clock),
-            obj(tx, args.repayCoins),
         ],
     });
 }
-export function reserves(tx, typeArg, lendingMarket) {
+/** Get the fee receiver address. */
+export function feeReceiver(tx, typeArg, lendingMarket, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::reserves`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::fee_receiver`,
         typeArguments: [typeArg],
         arguments: [obj(tx, lendingMarket)],
     });
 }
-export function maxWithdrawAmount(tx, typeArg, args) {
+/** Get the amount of a rate limiter exemption. */
+export function rateLimiterExemptionAmount(tx, typeArgs, exemption, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::rate_limiter_exemption_amount`,
+        typeArguments: typeArgs,
+        arguments: [obj(tx, exemption)],
+    });
+}
+/** Migrates the lending market to the current version. */
+export function migrate(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::max_withdraw_amount`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::migrate`,
         typeArguments: [typeArg],
         arguments: [
-            obj(tx, args.rateLimiter),
-            obj(tx, args.obligation),
-            obj(tx, args.reserve),
-            obj(tx, args.clock),
+            obj(tx, args.lendingMarketOwnerCap),
+            obj(tx, args.lendingMarket),
         ],
     });
 }
-export function repay(tx, typeArgs, args) {
+/**
+ * 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 function addReserve(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::repay`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::add_reserve`,
         typeArguments: typeArgs,
         arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
-            pure(tx, args.reserveArrayIndex, `u64`),
-            pure(tx, args.obligationId, `${ID.$typeName}`),
+            obj(tx, args.priceInfoObject),
+            obj(tx, args.reserveConfig),
+            obj(tx, args.coinMetadata),
             obj(tx, args.clock),
-            obj(tx, args.maxRepayCoins),
         ],
     });
 }
-export function obligationId(tx, typeArg, cap) {
+/**
+ * Deprecated tombstone, for the same reason as `add_reserve`. Use
+ * `add_reserve_v2_pro_compatible`.
+ */
+export function addReserveV2(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::obligation_id`,
-        typeArguments: [typeArg],
-        arguments: [obj(tx, cap)],
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::add_reserve_v2`,
+        typeArguments: typeArgs,
+        arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
+            obj(tx, args.lendingMarket),
+            obj(tx, args.priceInfoObject),
+            obj(tx, args.reserveConfig),
+            obj(tx, args.currency),
+            obj(tx, args.clock),
+        ],
     });
 }
-export function addReserve(tx, typeArgs, args) {
+/**
+ * `add_reserve` against the upgraded Pyth package. Only this path can
+ * consume payloads after the 2026-08-18 cutover.
+ */
+export function addReserveProCompatible(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::add_reserve`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::add_reserve_pro_compatible`,
         typeArguments: typeArgs,
         arguments: [
             obj(tx, args.lendingMarketOwnerCap),
@@ -329,193 +907,529 @@ export function addReserve(tx, typeArgs, args) {
         ],
     });
 }
-export function addReserveV2(tx, typeArgs, args) {
+/**
+ * `add_reserve_v2` against the upgraded Pyth package. Only this path can
+ * consume payloads after the 2026-08-18 cutover.
+ */
+export function addReserveV2ProCompatible(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::add_reserve_v2`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::add_reserve_v2_pro_compatible`,
         typeArguments: typeArgs,
         arguments: [
             obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
             obj(tx, args.priceInfo),
             obj(tx, args.config),
-            obj(tx, args.coinMetadata),
+            obj(tx, args.currency),
             obj(tx, args.clock),
         ],
     });
 }
-export function borrowRequest(tx, typeArgs, args) {
+/**
+ * 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 function updateReserveConfig(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::borrow_request`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::update_reserve_config`,
         typeArguments: typeArgs,
         arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.obligationOwnerCap),
-            obj(tx, args.clock),
-            pure(tx, args.amount, `u64`),
+            obj(tx, args.config),
         ],
     });
 }
-export function changeReservePriceFeed(tx, typeArgs, args) {
+/**
+ * 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 function setReservePriceGuard(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::change_reserve_price_feed`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::set_reserve_price_guard`,
         typeArguments: typeArgs,
         arguments: [
             obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.priceInfoObj),
+            pure(tx, args.maxPriceChangeBps, `u64`),
+            pure(tx, args.minUpdateIntervalS, `u64`),
             obj(tx, args.clock),
         ],
     });
 }
-export function claimRewardsAndDeposit(tx, typeArgs, args) {
+/**
+ * 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 function changeReservePriceFeed(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::claim_rewards_and_deposit`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::change_reserve_price_feed`,
         typeArguments: typeArgs,
         arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
-            pure(tx, args.obligationId, `${ID.$typeName}`),
+            pure(tx, args.u64, `u64`),
+            obj(tx, args.priceInfoObject),
             obj(tx, args.clock),
-            pure(tx, args.rewardReserveId, `u64`),
-            pure(tx, args.rewardIndex, `u64`),
-            pure(tx, args.isDepositReward, `bool`),
-            pure(tx, args.depositReserveId, `u64`),
         ],
     });
 }
-export function claimRewardsByObligationId(tx, typeArgs, args) {
+/**
+ * `change_reserve_price_feed` against the upgraded Pyth package. Same
+ * owner-cap gate and coin-type check; only the object's package differs.
+ */
+export function changeReservePriceFeedProCompatible(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::claim_rewards_by_obligation_id`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::change_reserve_price_feed_pro_compatible`,
         typeArguments: typeArgs,
         arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
-            pure(tx, args.obligationId, `${ID.$typeName}`),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            obj(tx, args.priceInfoObj),
             obj(tx, args.clock),
-            pure(tx, args.reserveId, `u64`),
-            pure(tx, args.rewardIndex, `u64`),
+        ],
+    });
+}
+/**
+ * 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 function addPoolReward(tx, typeArgs, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::add_pool_reward`,
+        typeArguments: typeArgs,
+        arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
+            obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
             pure(tx, args.isDepositReward, `bool`),
-            pure(tx, args.failIfRewardPeriodNotOver, `bool`),
+            obj(tx, args.rewards),
+            pure(tx, args.startTimeMs, `u64`),
+            pure(tx, args.endTimeMs, `u64`),
+            obj(tx, args.clock),
         ],
     });
 }
-export function createLendingMarket(tx, typeArg) {
+/**
+ * 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 function cancelPoolReward(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::create_lending_market`,
-        typeArguments: [typeArg],
-        arguments: [],
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::cancel_pool_reward`,
+        typeArguments: typeArgs,
+        arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
+            obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            pure(tx, args.isDepositReward, `bool`),
+            pure(tx, args.rewardIndex, `u64`),
+            obj(tx, args.clock),
+        ],
     });
 }
-export function depositCtokensIntoObligation(tx, typeArgs, args) {
+/**
+ * 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 function closePoolReward(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::deposit_ctokens_into_obligation`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::close_pool_reward`,
         typeArguments: typeArgs,
         arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.obligationOwnerCap),
+            pure(tx, args.isDepositReward, `bool`),
+            pure(tx, args.rewardIndex, `u64`),
             obj(tx, args.clock),
-            obj(tx, args.deposit),
         ],
     });
 }
-export function depositCtokensIntoObligationById(tx, typeArgs, args) {
+/**
+ * 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 function drainPointsReward(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::deposit_ctokens_into_obligation_by_id`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::drain_points_reward`,
         typeArguments: typeArgs,
         arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            pure(tx, args.obligationId, `${ID.$typeName}`),
+            pure(tx, args.isDepositReward, `bool`),
+            pure(tx, args.rewardIndex, `u64`),
             obj(tx, args.clock),
-            obj(tx, args.deposit),
         ],
     });
 }
-export function feeReceiver(tx, typeArg, lendingMarket) {
+/**
+ * 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 function updateRateLimiterConfig(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::fee_receiver`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::update_rate_limiter_config`,
         typeArguments: [typeArg],
-        arguments: [obj(tx, lendingMarket)],
+        arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
+            obj(tx, args.lendingMarket),
+            obj(tx, args.clock),
+            obj(tx, args.config),
+        ],
     });
 }
-export function newObligationOwnerCap(tx, typeArg, args) {
+/**
+ * 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 function setFeeReceivers(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::new_obligation_owner_cap`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::set_fee_receivers`,
         typeArguments: [typeArg],
         arguments: [
             obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
-            pure(tx, args.obligationId, `${ID.$typeName}`),
+            pure(tx, args.receivers, `vector<address>`),
+            pure(tx, args.weights, `vector<u64>`),
         ],
     });
 }
-export function rateLimiterExemptionAmount(tx, typeArgs, exemption) {
+/**
+ * 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 function claimFees(tx, typeArgs, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::rate_limiter_exemption_amount`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::claim_fees`,
         typeArguments: typeArgs,
-        arguments: [obj(tx, exemption)],
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            obj(tx, args.systemState),
+        ],
     });
 }
-export function redeemCtokensAndWithdrawLiquidity(tx, typeArgs, args) {
+/**
+ * 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 function newObligationOwnerCap(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
-        typeArguments: typeArgs,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::new_obligation_owner_cap`,
+        typeArguments: [typeArg],
         arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
-            pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.clock),
-            obj(tx, args.ctokens),
-            option(tx, `${RateLimiterExemption.$typeName}<${typeArgs[0]}, ${typeArgs[1]}>`, args.rateLimiterExemption),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
         ],
     });
 }
-export function redeemCtokensAndWithdrawLiquidityRequest(tx, typeArgs, args) {
+/**
+ * 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 function newPauseCap(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::redeem_ctokens_and_withdraw_liquidity_request`,
-        typeArguments: typeArgs,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::new_pause_cap`,
+        typeArguments: [typeArg],
         arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
-            pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.clock),
-            obj(tx, args.ctokens),
-            option(tx, `${RateLimiterExemption.$typeName}<${typeArgs[0]}, ${typeArgs[1]}>`, args.rateLimiterExemption),
+            pure(tx, args.recipient, `address`),
         ],
     });
 }
-export function refreshReservePrice(tx, typeArg, args) {
+/**
+ * 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 function setMarketPaused(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::refresh_reserve_price`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::set_market_paused`,
         typeArguments: [typeArg],
         arguments: [
+            obj(tx, args.cap),
+            obj(tx, args.lendingMarket),
+            pure(tx, args.paused, `bool`),
+        ],
+    });
+}
+/**
+ * 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 function setReservePaused(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::set_reserve_paused`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(tx, args.cap),
             obj(tx, args.lendingMarket),
             pure(tx, args.reserveArrayIndex, `u64`),
-            obj(tx, args.clock),
-            obj(tx, args.priceInfo),
+            pure(tx, args.paused, `bool`),
         ],
     });
 }
-export function setFeeReceivers(tx, typeArg, args) {
+/**
+ * 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 function isMarketPaused(tx, typeArg, lendingMarket, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::set_fee_receivers`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::is_market_paused`,
+        typeArguments: [typeArg],
+        arguments: [obj(tx, lendingMarket)],
+    });
+}
+export function assertValidPauseCap(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::assert_valid_pause_cap`,
         typeArguments: [typeArg],
         arguments: [
-            obj(tx, args.lendingMarketOwnerCap),
+            obj(tx, args.cap),
             obj(tx, args.lendingMarket),
-            pure(tx, args.receivers, `vector<address>`),
-            pure(tx, args.weights, `vector<u64>`),
         ],
     });
 }
-export function updateRateLimiterConfig(tx, typeArg, args) {
+export function assertNotPaused(tx, typeArg, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::lending_market::update_rate_limiter_config`,
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::assert_not_paused`,
         typeArguments: [typeArg],
         arguments: [
-            obj(tx, args.lendingMarketOwnerCap),
             obj(tx, args.lendingMarket),
+            obj(tx, args.reserve),
+        ],
+    });
+}
+export function depositCtokensIntoObligationById(tx, typeArgs, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::deposit_ctokens_into_obligation_by_id`,
+        typeArguments: typeArgs,
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
+            obj(tx, args.clock),
+            obj(tx, args.deposit),
+        ],
+    });
+}
+export function claimRewardsByObligationId(tx, typeArgs, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::claim_rewards_by_obligation_id`,
+        typeArguments: typeArgs,
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
             obj(tx, args.clock),
+            pure(tx, args.reserveId, `u64`),
+            pure(tx, args.rewardIndex, `u64`),
+            pure(tx, args.isDepositReward, `bool`),
+            pure(tx, args.failIfRewardPeriodNotOver, `bool`),
+        ],
+    });
+}
+export function addReserveInternalProCompatible(tx, typeArgs, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::add_reserve_internal_pro_compatible`,
+        typeArguments: typeArgs,
+        arguments: [
+            obj(tx, args.lendingMarket),
+            obj(tx, args.priceInfo),
             obj(tx, args.config),
+            pure(tx, args.decimals, `u8`),
+            obj(tx, args.clock),
         ],
     });
 }