program: update-max-borrow-token-amount-deltas (#1801)

* program: update-max-borrow-token-amount-deltas

* fix tests

* sdk match

* update changelog

Author: 0xbigz

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Features
 
+- program: update max borrow delta/utilization thresholds ([#1760](https://github.com/drift-labs/protocol-v2/pull/1801))
+
 ### Fixes
 
 ### Breaking
@@ -18,13 +20,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Features
 
 ### Fixes
+
 - program: update-fee-tier-validates ([#1798](https://github.com/drift-labs/protocol-v2/pull/1798))
 
 ### Breaking
 
 ## [2.131.0] - 2025-08-04
 
 ### Features
+
 - program: update stake + volume fee tier determination ([#1792](https://github.com/drift-labs/protocol-v2/pull/1792))
 
 ### Fixes

programs/drift/src/controller/spot_balance/tests.rs

@@ -489,7 +489,7 @@ fn test_check_withdraw_limits() {
         0,
     )
     .unwrap();
-    assert_eq!(mbt, 642857);
+    assert_eq!(mbt, 700000);
 
     let valid_withdraw = check_withdraw_limits(&spot_market, Some(&user), Some(0)).unwrap();
     assert!(valid_withdraw);
@@ -578,7 +578,7 @@ fn test_check_withdraw_limits_below_optimal_utilization() {
     assert_eq!(mdt_dep, 153000000000000);
 
     assert_eq!(max_bor, 142800000000000);
-    assert_eq!(mbt_bor, 151342857142857);
+    assert_eq!(mbt_bor, 163000000000000);
 
     let valid_withdraw = check_withdraw_limits(&sol_spot_market, None, None).unwrap();
     assert_eq!(valid_withdraw, true);
@@ -626,17 +626,17 @@ fn test_check_withdraw_limits_above_optimal_utilization() {
         initial_liability_weight: 12 * SPOT_WEIGHT_PRECISION / 10,
         maintenance_liability_weight: 11 * SPOT_WEIGHT_PRECISION / 10,
         deposit_balance: 200_000 * SPOT_BALANCE_PRECISION, // 200k sol
-        borrow_balance: 155_000 * SPOT_BALANCE_PRECISION,
+        borrow_balance: 160_000 * SPOT_BALANCE_PRECISION,
         liquidator_fee: LIQUIDATION_FEE_PRECISION / 1000,
         deposit_token_twap: 204000000000000_u64,
-        borrow_token_twap: 192200000000000_u64,
-        utilization_twap: 890000, // 89%
+        borrow_token_twap: 199200000000000_u64,
+        utilization_twap: 929000, // 92.9%
         status: MarketStatus::Active,
 
         ..SpotMarket::default()
     };
 
-    assert_eq!(sol_spot_market.get_utilization().unwrap(), 928480);
+    assert_eq!(sol_spot_market.get_utilization().unwrap(), 958431);
     assert!(
         sol_spot_market.get_utilization().unwrap() > sol_spot_market.optimal_utilization as u128
     ); // below optimal util
@@ -673,14 +673,14 @@ fn test_check_withdraw_limits_above_optimal_utilization() {
             .unwrap();
 
     assert_eq!(deposit_tokens_1, 204000000000000);
-    assert_eq!(borrow_tokens_1, 189410000000000);
+    assert_eq!(borrow_tokens_1, 195520000000000);
 
     // utilization bands differ from others
-    assert_eq!(min_dep, 200433862433862);
+    assert_eq!(min_dep, 202716433385173);
     assert_eq!(mdt_dep, 153000000000000);
 
-    assert_eq!(max_bor, 192780000000000);
-    assert_eq!(mbt_bor, 178500000000000);
+    assert_eq!(max_bor, 196758000000000);
+    assert_eq!(mbt_bor, 189428571428572);
 
     // without passing a user, since borrows are above the built in limit of 80% will fail
     let valid_withdraw = check_withdraw_limits(&sol_spot_market, None, None).unwrap();

programs/drift/src/math/spot_withdraw.rs

@@ -39,22 +39,22 @@ pub fn calculate_max_borrow_token_amount(
     let lesser_deposit_amount = deposit_token_amount.min(deposit_token_twap);
 
     let max_borrow_token = if pool_id == 0 {
-        // main pool between ~30-87.5% utilization with friction on twap in 14% increments
+        // main pool between ~30-92.5% utilization with friction on twap in 20% increments
 
         withdraw_guard_threshold
             .max(
                 (lesser_deposit_amount / 3)
-                    .max(borrow_token_twap.safe_add(lesser_deposit_amount / 7)?)
-                    .min(lesser_deposit_amount.safe_sub(lesser_deposit_amount / 8)?),
+                    .max(borrow_token_twap.safe_add(lesser_deposit_amount / 5)?)
+                    .min(lesser_deposit_amount.safe_sub(lesser_deposit_amount / 14)?),
             )
             .min(max_token_borrows)
     } else {
-        // isolated pools between 50-90% utilization with friction on twap in 33% increments
+        // isolated pools between 50-95% utilization with friction on twap in 33% increments
         withdraw_guard_threshold
             .max(
                 (lesser_deposit_amount / 2)
                     .max(borrow_token_twap.safe_add(lesser_deposit_amount / 3)?)
-                    .min(lesser_deposit_amount.safe_sub(lesser_deposit_amount / 10)?),
+                    .min(lesser_deposit_amount.safe_sub(lesser_deposit_amount / 20)?),
             )
             .min(max_token_borrows)
     };

sdk/src/math/spotBalance.ts

@@ -593,7 +593,7 @@ export function calculateWithdrawLimit(
 				),
 				lesserDepositAmount.sub(lesserDepositAmount.div(new BN(8)))
 			)
-		); // main pool between ~15-80% utilization with 10% friction on twap
+		); // main pool between ~30-92.5% utilization with friction on twap in 20% increments
 	} else {
 		maxBorrowTokensTwap = BN.max(
 			spotMarket.withdrawGuardThreshold,
@@ -602,9 +602,9 @@ export function calculateWithdrawLimit(
 					marketDepositTokenAmount.div(new BN(2)),
 					borrowTokenTwapLive.add(lesserDepositAmount.div(new BN(3)))
 				),
-				lesserDepositAmount.sub(lesserDepositAmount.div(new BN(10)))
+				lesserDepositAmount.sub(lesserDepositAmount.div(new BN(20)))
 			)
-		); // isolated pool between ~50-90% utilization with 33% friction on twap
+		); // isolated pools between 50-95% utilization with friction on twap in 33% increments
 	}
 
 	const minDepositTokensTwap = depositTokenTwapLive.sub(