add tests for amm_can_fill_order and is_oracle_low_risk

Author: moosecat2

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

@@ -13053,3 +13053,94 @@ mod update_maker_fills_map {
         assert_eq!(*map.get(&maker_key).unwrap(), -2 * fill as i64);
     }
 }
+
+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 {
+        Order {
+            status: OrderStatus::Open,
+            market_type: MarketType::Perp,
+            slot: 100,
+            ..Order::default()
+        }
+    }
+
+    #[test]
+    fn older_than_oracle_delay_returns_true() {
+        let order = base_perp_order();
+        let clock_slot = 110u64;
+        let mm_oracle_delay = 10i64;
+
+        let is_low = order
+            .is_low_risk_for_amm(mm_oracle_delay, 20, clock_slot, false)
+            .unwrap();
+        assert!(is_low);
+    }
+
+    #[test]
+    fn not_older_than_delay_and_auction_not_complete_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)
+            .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();
+        assert!(is_low);
+    }
+
+    #[test]
+    fn safe_trigger_order_flag_sets_low_risk() {
+        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();
+        assert!(is_low);
+    }
+}

programs/drift/src/math/oracle.rs

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

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

@@ -336,3 +336,243 @@ mod get_trigger_price {
         assert_eq!(clamped_price, large_oracle_price + max_oracle_diff_large);
     }
 }
+
+mod amm_can_fill_order_tests {
+    use crate::controller::position::PositionDirection;
+    use crate::math::oracle::OracleValidity;
+    use crate::state::fill_mode::FillMode;
+    use crate::state::oracle::{MMOraclePriceData, OraclePriceData};
+    use crate::state::paused_operations::PerpOperation;
+    use crate::state::perp_market::{PerpMarket, AMM};
+    use crate::state::state::{State, ValidityGuardRails};
+    use crate::state::user::{Order, OrderStatus};
+    use crate::PRICE_PRECISION_I64;
+
+    fn base_state() -> State {
+        State {
+            min_perp_auction_duration: 10,
+            ..State::default()
+        }
+    }
+
+    fn base_market() -> PerpMarket {
+        PerpMarket {
+            amm: AMM {
+                mm_oracle_price: PRICE_PRECISION_I64,
+                mm_oracle_slot: 0,
+                order_step_size: 1,
+                amm_jit_intensity: 100,
+                ..AMM::default()
+            },
+            ..PerpMarket::default()
+        }
+    }
+
+    fn base_order() -> Order {
+        Order {
+            status: OrderStatus::Open,
+            slot: 0,
+            base_asset_amount: 1,
+            direction: PositionDirection::Long,
+            ..Order::default()
+        }
+    }
+
+    fn mm_oracle_ok_and_as_recent() -> (MMOraclePriceData, ValidityGuardRails) {
+        let exchange = OraclePriceData {
+            price: PRICE_PRECISION_I64,
+            confidence: 1,
+            delay: 5,
+            has_sufficient_number_of_data_points: true,
+            sequence_id: Some(100),
+        };
+        let mm =
+            MMOraclePriceData::new(PRICE_PRECISION_I64, 5, 100, OracleValidity::Valid, exchange)
+                .unwrap();
+        (mm, ValidityGuardRails::default())
+    }
+
+    #[test]
+    fn paused_operation_returns_false() {
+        let mut market = base_market();
+        // Pause AMM fill
+        market.paused_operations = PerpOperation::AmmFill as u8;
+        let order = base_order();
+        let state = base_state();
+        let (mm, guard) = mm_oracle_ok_and_as_recent();
+
+        let can = market
+            .amm_can_fill_order(
+                &order,
+                10,
+                FillMode::Fill,
+                &state,
+                OracleValidity::Valid,
+                true,
+                &mm,
+            )
+            .unwrap();
+        assert!(!can);
+    }
+
+    #[test]
+    fn mm_oracle_too_volatile_blocks() {
+        let market = base_market();
+        let order = base_order();
+        let state = base_state();
+
+        // Create MM oracle data with >1% diff vs exchange to force fallback and block
+        let exchange = OraclePriceData {
+            price: PRICE_PRECISION_I64, // 1.0
+            confidence: 1,
+            delay: 1,
+            has_sufficient_number_of_data_points: true,
+            sequence_id: Some(100),
+        };
+        // 3% higher than exchange
+        let mm = MMOraclePriceData::new(
+            PRICE_PRECISION_I64 + (PRICE_PRECISION_I64 / 33),
+            1,
+            99,
+            OracleValidity::Valid,
+            exchange,
+        )
+        .unwrap();
+
+        let can = market
+            .amm_can_fill_order(
+                &order,
+                10,
+                FillMode::Fill,
+                &state,
+                OracleValidity::Valid,
+                true,
+                &mm,
+            )
+            .unwrap();
+        assert!(!can);
+    }
+
+    #[test]
+    fn low_risk_path_succeeds_when_auction_elapsed() {
+        let market = base_market();
+        let mut order = base_order();
+        order.slot = 0;
+
+        let state = base_state();
+        let (mm, _) = mm_oracle_ok_and_as_recent();
+
+        // clock_slot sufficiently beyond min_auction_duration
+        let can = market
+            .amm_can_fill_order(
+                &order,
+                15,
+                FillMode::Fill,
+                &state,
+                OracleValidity::Valid,
+                true,
+                &mm,
+            )
+            .unwrap();
+        assert!(can);
+    }
+
+    #[test]
+    fn low_risk_path_succeeds_when_auction_elapsed_with_stale_for_immediate() {
+        let market = base_market();
+        let mut order = base_order();
+        order.slot = 0; // order placed at slot 0
+
+        let state = base_state();
+        let (mm, _) = mm_oracle_ok_and_as_recent();
+
+        // clock_slot sufficiently beyond min_auction_duration
+        let can = market
+            .amm_can_fill_order(
+                &order,
+                15,
+                FillMode::Fill,
+                &state,
+                OracleValidity::StaleForAMM {
+                    immediate: true,
+                    low_risk: false,
+                },
+                true,
+                &mm,
+            )
+            .unwrap();
+        assert!(can);
+    }
+
+    #[test]
+    fn high_risk_immediate_requires_user_and_market_skip() {
+        let mut market = base_market();
+        let mut order = base_order();
+        order.slot = 20;
+        market.amm.amm_jit_intensity = 100;
+
+        let state = base_state();
+        let (mm, _) = mm_oracle_ok_and_as_recent();
+
+        // cnat fill if user cant skip auction duration
+        let can1 = market
+            .amm_can_fill_order(
+                &order,
+                21,
+                FillMode::Fill,
+                &state,
+                OracleValidity::Valid,
+                false,
+                &mm,
+            )
+            .unwrap();
+        assert!(!can1);
+
+        // valid oracle for immediate and user can skip, market can skip due to low inventory => can fill
+        market.amm.base_asset_amount_with_amm = -2; // taker long improves balance
+        market.amm.order_step_size = 1;
+        market.amm.base_asset_reserve = 1_000_000;
+        market.amm.quote_asset_reserve = 1_000_000;
+        market.amm.sqrt_k = 1_000_000;
+        market.amm.max_base_asset_reserve = 2_000_000;
+        market.amm.min_base_asset_reserve = 0;
+
+        let can2 = market
+            .amm_can_fill_order(
+                &order,
+                21,
+                FillMode::Fill,
+                &state,
+                OracleValidity::Valid,
+                true,
+                &mm,
+            )
+            .unwrap();
+        assert!(can2);
+    }
+
+    #[test]
+    fn invalid_safe_oracle_validity_blocks_low_risk() {
+        let market = base_market();
+        let order = base_order();
+        let state = base_state();
+        let (mm, _) = mm_oracle_ok_and_as_recent();
+
+        // Order is old but invalid oracle validity
+        let can = market
+            .amm_can_fill_order(
+                &order,
+                20,
+                FillMode::Fill,
+                &state,
+                OracleValidity::StaleForAMM {
+                    immediate: true,
+                    low_risk: true,
+                },
+                true,
+                &mm,
+            )
+            .unwrap();
+        assert!(!can);
+    }
+}