@suilend/sdk 14.3.0 → 16.0.0

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

@@ -271,6 +271,9 @@ export function depositCtokensIntoObligation(tx, typeArgs, args, options) {
  * This function will panic if:
  * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
  * * The borrow amount is zero (ETooSmall).
+ * * The market is paused (EMarketPaused).
+ * * The reserve is paused (EReservePaused).
+ * * Borrow is held by `hold_operation_until` (EOperationHeld).
  * * 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).
@@ -339,6 +342,9 @@ export function refreshObligation(tx, typeArg, args, options) {
  * This function will panic if:
  * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
  * * The borrow amount is zero (ETooSmall).
+ * * The market is paused (EMarketPaused).
+ * * The reserve is paused (EReservePaused).
+ * * Borrow is held by `hold_operation_until` (EOperationHeld).
  * * 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).
@@ -420,6 +426,10 @@ export function fulfillLiquidityRequest(tx, typeArgs, args, options) {
  * This function will panic if:
  * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
  * * The withdraw amount is zero (ETooSmall).
+ * * The market is paused (EMarketPaused).
+ * * The reserve is paused (EReservePaused).
+ * * Withdraw is held by `hold_operation_until` and the obligation is not exempted by
+ * `set_withdraw_hold_exempt` (EOperationHeld).
  * * 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.
@@ -464,6 +474,9 @@ export function withdrawCtokens(tx, typeArgs, args, options) {
  * This function will panic if:
  * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
  * * The repay amount is zero (ETooSmall).
+ * * The market is paused (EMarketPaused).
+ * * The repay or withdraw reserve is paused (EReservePaused).
+ * * Liquidate is held by `hold_operation_until` (EOperationHeld).
  * * 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.
@@ -652,13 +665,6 @@ export function claimRewardsAndDeposit(tx, typeArgs, args, options) {
  * 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:
@@ -709,6 +715,19 @@ export function rebalanceStaker(tx, typeArg, args, options) {
         ],
     });
 }
+export function setStakerValidator(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::set_staker_validator`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(tx, args.lendingMarket),
+            obj(tx, args.lendingMarketOwnerCap),
+            pure(tx, args.suiReserveArrayIndex, `u64`),
+            pure(tx, args.validator, `address`),
+            obj(tx, args.systemState),
+        ],
+    });
+}
 /**
  * Unstakes SUI from a staker.
  *
@@ -761,6 +780,13 @@ export function maxBorrowAmount(tx, typeArg, args, options) {
         ],
     });
 }
+export function chargesRateLimiter(tx, typeArg, reserve, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::charges_rate_limiter`,
+        typeArguments: [typeArg],
+        arguments: [obj(tx, reserve)],
+    });
+}
 export function maxWithdrawAmount(tx, typeArg, args, options) {
     return tx.moveCall({
         target: `${getPublishedAt('suilend', options?.env)}::lending_market::max_withdraw_amount`,
@@ -929,14 +955,8 @@ export function addReserveV2ProCompatible(tx, typeArgs, args, options) {
  * 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.
+ * It can only be called by the owner of the lending market. Un-retiring a reserve clears its
+ * rate-limiter exemption and emits `ReserveRateLimiterExemptEvent`; retiring it again leaves it charged.
  *
  * # Panics
  *
@@ -957,6 +977,32 @@ export function updateReserveConfig(tx, typeArgs, args, options) {
         ],
     });
 }
+/**
+ * Exempts a retired reserve's redeems from the market's rate limiter, or charges them
+ * again. An exempt reserve's max withdraw is not capped by the remaining outflow. A
+ * config update that gives the reserve any open or close LTV, deposit limit or borrow
+ * limit clears the exemption, so it never outlives the reserve's retirement.
+ *
+ * # 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).
+ * * `exempt` is true and the reserve is not retired (EReserveNotRetired).
+ */
+export function setReserveRateLimiterExempt(tx, typeArgs, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::set_reserve_rate_limiter_exempt`,
+        typeArguments: typeArgs,
+        arguments: [
+            obj(tx, args.lendingMarketOwnerCap),
+            obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            pure(tx, args.exempt, `bool`),
+        ],
+    });
+}
 /**
  * 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
@@ -1027,17 +1073,6 @@ export function changeReservePriceFeedProCompatible(tx, typeArgs, args, options)
  * 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:
@@ -1068,15 +1103,6 @@ export function addPoolReward(tx, typeArgs, args, options) {
  * 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.
@@ -1110,15 +1136,6 @@ export function cancelPoolReward(tx, typeArgs, args, options) {
  * 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.
@@ -1169,13 +1186,6 @@ export function drainPointsReward(tx, typeArgs, args, options) {
  * 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:
@@ -1200,13 +1210,6 @@ export function updateRateLimiterConfig(tx, typeArg, args, options) {
  * 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:
@@ -1267,12 +1270,6 @@ export function claimFees(tx, typeArgs, args, options) {
  * `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.
@@ -1302,13 +1299,14 @@ export function newObligationOwnerCap(tx, typeArg, args, options) {
  *
  * This function will panic if:
  * * The `lending_market` version is not `CURRENT_VERSION` (EIncorrectVersion).
+ * * `owner_cap` was not minted for this `lending_market` (EWrongLendingMarket).
  */
 export function newPauseCap(tx, typeArg, args, options) {
     return tx.moveCall({
         target: `${getPublishedAt('suilend', options?.env)}::lending_market::new_pause_cap`,
         typeArguments: [typeArg],
         arguments: [
-            obj(tx, args.lendingMarketOwnerCap),
+            obj(tx, args.ownerCap),
             obj(tx, args.lendingMarket),
             pure(tx, args.recipient, `address`),
         ],
@@ -1360,6 +1358,170 @@ export function setReservePaused(tx, typeArg, args, options) {
         ],
     });
 }
+/**
+ * Lowers one reserve's protocol liquidation fee, so liquidators keep more of a capped
+ * bonus and stay paid deeper into a drawdown. Gated on the current-generation
+ * `EmergencyPauseCap` rather than the owner cap so it is reachable within the hour;
+ * it can only lower the fee, so raising it back stays with the owner cap. Only the fee
+ * field changes: the rest of the config is not rebuilt or re-validated against live
+ * oracle state, so the cut still works when confidence has widened. A cut emits
+ * `ProtocolLiquidationFeeLoweredEvent`; passing the current fee changes nothing and emits
+ * nothing.
+ *
+ * # 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.
+ * * The `coin_type` of the reserve does not match the type `T` (EWrongType).
+ * * `protocol_liquidation_fee_bps` is above the reserve's current fee
+ * (EProtocolLiquidationFeeNotLowered).
+ */
+export function lowerProtocolLiquidationFee(tx, typeArgs, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::lower_protocol_liquidation_fee`,
+        typeArguments: typeArgs,
+        arguments: [
+            obj(tx, args.cap),
+            obj(tx, args.lendingMarket),
+            pure(tx, args.reserveArrayIndex, `u64`),
+            pure(tx, args.protocolLiquidationFeeBps, `u64`),
+        ],
+    });
+}
+/**
+ * Holds one operation across the whole market until `until_ms`, independently of the
+ * market and reserve pauses. The hold lapses by itself once the clock reaches `until_ms`;
+ * a later call replaces it, and `until_ms = 0` lifts it at once. Every call starts a new
+ * hold generation for the operation, which ends withdraw exemptions granted under an
+ * earlier call. Holding borrow and liquidate while the market itself is unpaused reopens
+ * repay, deposit, withdraw and redeem first, so positions can be topped up before they can
+ * be liquidated.
+ *
+ * # 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).
+ * * `operation` is not 0 (borrow), 1 (liquidate) or 2 (withdraw) (EInvalidOperation).
+ * * `until_ms` is more than `MAX_OPERATION_HOLD_MS` past the clock (EHoldTooLong).
+ * * `until_ms` is not 0 and is at or before the clock (EHoldInPast).
+ */
+export function holdOperationUntil(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::hold_operation_until`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(tx, args.cap),
+            obj(tx, args.lendingMarket),
+            pure(tx, args.operation, `u8`),
+            pure(tx, args.untilMs, `u64`),
+            obj(tx, args.clock),
+        ],
+    });
+}
+/**
+ * Exempts one obligation from the current withdraw hold, or removes its exemption. An
+ * exempt obligation can still `withdraw_ctokens` while that hold lasts. The
+ * exemption records the hold's generation and lapses with it: once the hold ends, or any
+ * later `hold_operation_until` call replaces or lifts it, the obligation is held again
+ * until it is exempted anew, even under a new hold with the same `until_ms`. Setting the
+ * state the obligation already has emits nothing, and removing a lapsed exemption clears
+ * it without an event.
+ *
+ * # 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).
+ * * The `obligation_id` is not found in the lending market's obligations (EInvalidObligationId).
+ * * `exempt` is true and withdraw is not held (EWithdrawNotHeld).
+ */
+export function setWithdrawHoldExempt(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::set_withdraw_hold_exempt`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(tx, args.cap),
+            obj(tx, args.lendingMarket),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
+            pure(tx, args.exempt, `bool`),
+            obj(tx, args.clock),
+        ],
+    });
+}
+/**
+ * Aborts with `EOperationHeld` while withdraw is held, unless the obligation is exempt.
+ * Debt-free obligations are held too: otherwise a borrower could repay in full, withdraw
+ * and borrow again in one PTB at the same pushed price.
+ */
+export function assertWithdrawNotHeld(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::assert_withdraw_not_held`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
+            obj(tx, args.clock),
+        ],
+    });
+}
+/** True if `obligation_id` was exempted under the withdraw hold that is active now. */
+export function isWithdrawHoldExempt(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::is_withdraw_hold_exempt`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.obligationId, `${ID.$typeName}`),
+            obj(tx, args.clock),
+        ],
+    });
+}
+export function withdrawHoldGeneration(tx, typeArg, lendingMarket, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::withdraw_hold_generation`,
+        typeArguments: [typeArg],
+        arguments: [obj(tx, lendingMarket)],
+    });
+}
+/** The operation code that holds borrow. */
+export function operationBorrow(tx, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::operation_borrow`,
+        arguments: [],
+    });
+}
+/** The operation code that holds liquidate. */
+export function operationLiquidate(tx, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::operation_liquidate`,
+        arguments: [],
+    });
+}
+/** The operation code that holds withdrawing collateral from obligations. */
+export function operationWithdraw(tx, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::operation_withdraw`,
+        arguments: [],
+    });
+}
+/** True while a hold on `operation` has not yet lapsed. Absent the dynamic field, it is not. */
+export function isOperationHeld(tx, typeArg, args, options) {
+    return tx.moveCall({
+        target: `${getPublishedAt('suilend', options?.env)}::lending_market::is_operation_held`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(tx, args.lendingMarket),
+            pure(tx, args.operation, `u8`),
+            obj(tx, args.clock),
+        ],
+    });
+}
 /**
  * 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