sdk still has errors

Author: moosecat2

programs/drift/src/controller/orders/amm_jit_tests.rs

@@ -2489,17 +2489,6 @@ pub mod amm_jit {
             let makers_and_referrers = UserMap::load_one(&maker_account_info).unwrap();
 
             let order_index = 0;
-            let user_can_skip_auction_duration =
-                taker.can_skip_auction_duration(&taker_stats).unwrap();
-            let is_amm_available = get_amm_is_available(
-                &taker.orders[order_index],
-                auction_duration,
-                &market,
-                &mut oracle_map,
-                slot,
-                user_can_skip_auction_duration,
-            );
-
             // fulfill with match
             fulfill_perp_order(
                 &mut taker,

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

@@ -13056,7 +13056,6 @@ mod update_maker_fills_map {
 
 mod order_is_low_risk_for_amm {
     use super::*;
-    use crate::math::orders::get_posted_slot_from_clock_slot;
     use crate::state::user::{OrderBitFlag, OrderStatus};
 
     fn base_perp_order() -> Order {
@@ -13075,61 +13074,28 @@ mod order_is_low_risk_for_amm {
         let mm_oracle_delay = 10i64;
 
         let is_low = order
-            .is_low_risk_for_amm(mm_oracle_delay, 20, clock_slot, false)
+            .is_low_risk_for_amm(mm_oracle_delay, clock_slot, false)
             .unwrap();
         assert!(is_low);
     }
 
     #[test]
-    fn not_older_than_delay_and_auction_not_complete_returns_false() {
+    fn not_older_than_delay_returns_false() {
         let order = base_perp_order();
         let clock_slot = 110u64;
 
         let mm_oracle_delay = 11i64;
-        let min_auction_duration = 10u8;
 
         let is_low = order
-            .is_low_risk_for_amm(mm_oracle_delay, min_auction_duration, clock_slot, false)
+            .is_low_risk_for_amm(mm_oracle_delay, clock_slot, false)
             .unwrap();
         assert!(!is_low);
     }
 
-    #[test]
-    fn non_signed_auction_boundary_and_past_duration() {
-        let order = base_perp_order(); // slot = 100
-
-        let is_low_at_boundary = order.is_low_risk_for_amm(1000, 10, 110, false).unwrap();
-        assert!(!is_low_at_boundary);
-        let is_low_past = order.is_low_risk_for_amm(1000, 10, 111, false).unwrap();
-        assert!(is_low_past);
-    }
-
-    #[test]
-    fn signed_message_duration_gate() {
-        let mut order = base_perp_order();
-        order.add_bit_flag(OrderBitFlag::SignedMessage);
-
-        let posted_slot = 5_000u64;
-        order.posted_slot_tail = get_posted_slot_from_clock_slot(posted_slot);
-
-        let clock_slot_9 = posted_slot + 9;
-        let min_auction_duration = 10u8;
-        let is_low_9 = order
-            .is_low_risk_for_amm(10_000, min_auction_duration, clock_slot_9, false)
-            .unwrap();
-        assert!(!is_low_9);
-
-        let clock_slot_10 = posted_slot + 10;
-        let is_low_10 = order
-            .is_low_risk_for_amm(10_000, min_auction_duration, clock_slot_10, false)
-            .unwrap();
-        assert!(is_low_10);
-    }
-
     #[test]
     fn liquidation_always_low_risk() {
         let order = base_perp_order();
-        let is_low = order.is_low_risk_for_amm(0, 255, order.slot, true).unwrap();
+        let is_low = order.is_low_risk_for_amm(0, order.slot, true).unwrap();
         assert!(is_low);
     }
 
@@ -13138,9 +13104,7 @@ mod order_is_low_risk_for_amm {
         let mut order = base_perp_order();
         order.add_bit_flag(OrderBitFlag::SafeTriggerOrder);
 
-        let is_low = order
-            .is_low_risk_for_amm(0, 255, order.slot, false)
-            .unwrap();
+        let is_low = order.is_low_risk_for_amm(0, order.slot, false).unwrap();
         assert!(is_low);
     }
 }

programs/drift/src/math/oracle.rs

@@ -101,7 +101,7 @@ pub fn is_oracle_valid_for_action(
                     oracle_validity,
                     OracleValidity::Valid
                         | OracleValidity::StaleForAMM {
-                            immediate: true,
+                            immediate: _,
                             low_risk: false
                         }
                 )

programs/drift/src/state/perp_market.rs

@@ -700,14 +700,6 @@ impl PerpMarket {
         }
     }
 
-    pub fn get_min_perp_auction_duration(&self, default_min_auction_duration: u8) -> u8 {
-        if self.amm.taker_speed_bump_override != 0 {
-            self.amm.taker_speed_bump_override.max(0).unsigned_abs()
-        } else {
-            default_min_auction_duration
-        }
-    }
-
     pub fn get_trigger_price(
         &self,
         oracle_price: i64,
@@ -876,9 +868,6 @@ impl PerpMarket {
             return Ok(false);
         }
 
-        let min_auction_duration =
-            self.get_min_perp_auction_duration(state.min_perp_auction_duration);
-
         // We are already using safe oracle data from MM oracle.
         // But AMM isnt available if we could have used MM oracle but fell back due to price diff
         // This is basically early volatility protection
@@ -899,14 +888,17 @@ impl PerpMarket {
         let safe_oracle_price_data = mm_oracle_price_data.get_safe_oracle_price_data();
         let order_is_low_risk_for_amm = order.is_low_risk_for_amm(
             safe_oracle_price_data.delay,
-            min_auction_duration,
             clock_slot,
             fill_mode.is_liquidation(),
         )?;
         let oracle_valid_for_amm_fill_low_risk = is_oracle_valid_for_action(
             safe_oracle_validity,
             Some(DriftAction::FillOrderAmmLowRisk),
         )?;
+        if !oracle_valid_for_amm_fill_low_risk {
+            msg!("AMM cannot fill order: oracle not valid for low risk fills");
+            return Ok(false);
+        }
         let can_fill_low_risk = order_is_low_risk_for_amm && oracle_valid_for_amm_fill_low_risk;
 
         // Proceed if order is low risk and we can fill it. Otherwise check if we can higher risk order immediately

programs/drift/src/state/perp_market/tests.rs

@@ -102,61 +102,6 @@ mod get_margin_ratio {
     }
 }
 
-mod get_min_perp_auction_duration {
-    use crate::state::perp_market::{PerpMarket, AMM};
-    use crate::State;
-
-    #[test]
-    fn test_get_speed_bump() {
-        let perp_market = PerpMarket {
-            amm: AMM {
-                taker_speed_bump_override: 0,
-                ..AMM::default()
-            },
-            ..PerpMarket::default()
-        };
-
-        let state = State {
-            min_perp_auction_duration: 10,
-            ..State::default()
-        };
-
-        // no override uses state value
-        assert_eq!(
-            perp_market.get_min_perp_auction_duration(state.min_perp_auction_duration),
-            10
-        );
-
-        let perp_market = PerpMarket {
-            amm: AMM {
-                taker_speed_bump_override: -1,
-                ..AMM::default()
-            },
-            ..PerpMarket::default()
-        };
-
-        // -1 override disables speed bump
-        assert_eq!(
-            perp_market.get_min_perp_auction_duration(state.min_perp_auction_duration),
-            0
-        );
-
-        let perp_market = PerpMarket {
-            amm: AMM {
-                taker_speed_bump_override: 20,
-                ..AMM::default()
-            },
-            ..PerpMarket::default()
-        };
-
-        // positive override uses override value
-        assert_eq!(
-            perp_market.get_min_perp_auction_duration(state.min_perp_auction_duration),
-            20
-        );
-    }
-}
-
 mod get_trigger_price {
     use crate::state::perp_market::HistoricalOracleData;
     use crate::state::perp_market::{PerpMarket, AMM};

programs/drift/src/state/user.rs

@@ -8,8 +8,7 @@ use crate::math::constants::{
 };
 use crate::math::margin::MarginRequirementType;
 use crate::math::orders::{
-    apply_protected_maker_limit_price_offset, get_posted_slot_from_clock_slot,
-    standardize_base_asset_amount, standardize_price,
+    apply_protected_maker_limit_price_offset, standardize_base_asset_amount, standardize_price,
 };
 use crate::math::position::{
     calculate_base_asset_value_and_pnl_with_oracle_price, calculate_perp_liability_value,
@@ -1529,7 +1528,6 @@ impl Order {
     pub fn is_low_risk_for_amm(
         &self,
         mm_oracle_delay: i64,
-        min_auction_duration: u8,
         clock_slot: u64,
         is_liquidation: bool,
     ) -> DriftResult<bool> {
@@ -1542,15 +1540,7 @@ impl Order {
             clock_minus_delay >= self.slot.cast::<i64>()?
         };
 
-        let order_older_than_min_auction_duration = if self.is_signed_msg() {
-            let clock_slot_tail = get_posted_slot_from_clock_slot(clock_slot);
-            clock_slot_tail.wrapping_sub(self.posted_slot_tail) >= min_auction_duration
-        } else {
-            is_auction_complete(self.slot, min_auction_duration, clock_slot)?
-        };
-
         Ok(order_older_than_oracle_delay
-            || order_older_than_min_auction_duration
             || is_liquidation
             || self.is_bit_flag_set(OrderBitFlag::SafeTriggerOrder))
     }

sdk/src/math/auction.ts

@@ -1,4 +1,4 @@
-import { isOneOfVariant, isVariant, Order, PositionDirection } from '../types';
+import { AMM, isOneOfVariant, isVariant, MarketType, Order, PositionDirection } from '../types';
 import { BN } from '@coral-xyz/anchor';
 import {
 	ONE,
@@ -8,9 +8,9 @@ import {
 } from '../constants/numericConstants';
 import { getVariant, OrderBitFlag, PerpMarketAccount } from '../types';
 import { getPerpMarketTierNumber } from './tiers';
-import { MMOraclePriceData } from '../oracles/types';
+import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
 import { isLowRiskForAmm } from './orders';
-import { isOracleValid } from './oracles';
+import { getOracleValidity, isOracleValid } from './oracles';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
 	if (order.auctionDuration === 0) {
@@ -20,23 +20,33 @@ export function isAuctionComplete(order: Order, slot: number): boolean {
 	return new BN(slot).sub(order.slot).gt(new BN(order.auctionDuration));
 }
 
-export function isFallbackAvailableLiquiditySource(
+export function isFallbackAvailableLiquiditySource<T extends MarketType>(
 	order: Order,
-	mmOracleData: MMOraclePriceData,
+	marketType: T,
+	oraclePriceData: T extends { spot: unknown }
+		? OraclePriceData
+		: MMOraclePriceData,
 	slot: number,
+	amm?: AMM,
 	isLiquidation?: boolean,
 ): boolean {
+	if (isVariant(marketType, 'spot')) {
+		return true;
+	}
 
 	const isOrderLowRiskForAmm = isLowRiskForAmm(
 		order,
-		mmOracleData,
+		oraclePriceData as MMOraclePriceData,
 		slot,
 		isLiquidation,
 	);
-	isOracleValid
+
+	// const oracleValidity = getOracleValidity(
+
+	// )
 
 
-	return new BN(slot).sub(order.slot).gt(new BN(minAuctionDuration));
+	return true;
 }
 
 /**
@@ -264,11 +274,17 @@ export function getTriggerAuctionStartPrice(params: {
 			? BN.min(
 				offsetSlow.add(fracOfLongSpreadInPrice),
 				offsetFast.sub(fracOfShortSpreadInPrice)
+			)
+				offsetSlow.add(fracOfLongSpreadInPrice),
+			offsetFast.sub(fracOfShortSpreadInPrice)
 			)
 			: BN.max(
 				offsetSlow.sub(fracOfShortSpreadInPrice),
 				offsetFast.add(fracOfLongSpreadInPrice)
 			);
+		offsetSlow.sub(fracOfShortSpreadInPrice),
+			offsetFast.add(fracOfLongSpreadInPrice)
+			);
 	}
 
 	let startBuffer = -3500;