bigz/improve-perp-match-get_fallback_price

programs/drift/src/controller/orders.rs

@@ -2089,25 +2089,22 @@ pub fn fulfill_perp_order_with_match(
         return Ok((0_u64, 0_u64, 0_u64));
     }
 
-    let (bid_price, ask_price) = market.amm.bid_ask_price(market.amm.reserve_price()?)?;
-
     let oracle_price = oracle_map.get_price_data(&market.amm.oracle)?.price;
-    let taker_direction = taker.orders[taker_order_index].direction;
+    let taker_direction: PositionDirection = taker.orders[taker_order_index].direction;
 
     let taker_price = if let Some(taker_limit_price) = taker_limit_price {
         taker_limit_price
     } else {
         let amm_available_liquidity =
             calculate_amm_available_liquidity(&market.amm, &taker_direction)?;
-        get_fallback_price(
+        market.amm.get_fallback_price(
             &taker_direction,
-            bid_price,
-            ask_price,
             amm_available_liquidity,
             oracle_price,
-        )?
+            taker.orders[taker_order_index].seconds_til_expiry(now)
+        )?.cast()?
     };
-
+        
     let taker_existing_position = taker
         .get_perp_position(market.market_index)?
         .base_asset_amount;

programs/drift/src/math/orders.rs

@@ -693,26 +693,6 @@ pub fn calculate_fill_price(
         .cast::<u64>()
 }
 
-pub fn get_fallback_price(
-    direction: &PositionDirection,
-    bid_price: u64,
-    ask_price: u64,
-    amm_available_liquidity: u64,
-    oracle_price: i64,
-) -> DriftResult<u64> {
-    let oracle_price = oracle_price.unsigned_abs();
-    match direction {
-        PositionDirection::Long if amm_available_liquidity > 0 => {
-            ask_price.safe_add(ask_price / 200)
-        }
-        PositionDirection::Long => oracle_price.safe_add(oracle_price / 20),
-        PositionDirection::Short if amm_available_liquidity > 0 => {
-            bid_price.safe_sub(bid_price / 200)
-        }
-        PositionDirection::Short => oracle_price.safe_sub(oracle_price / 20),
-    }
-}
-
 pub fn get_max_fill_amounts(
     user: &User,
     user_order_index: usize,

programs/drift/src/state/perp_market.rs

@@ -771,6 +771,45 @@
 }
 
 impl AMM {
+    pub fn get_fallback_price(self, 
+        direction: &PositionDirection,
+        amm_available_liquidity: u64, 
+        oracle_price: i64, 
+        seconds_til_order_expiry: i64,
+    ) -> DriftResult<i64> {
+        // PRICE_PRECISION
+        if direction.eq(&PositionDirection::Long) {
+            // pick amm ask + buffer if theres liquidity 
+            // otherwise be aggressive vs oracle + 1hr premium
+            if amm_available_liquidity >= self.min_order_size {
+                let reserve_price = self.reserve_price()?;
+                let amm_ask_price: i64 = self.ask_price(reserve_price)?.cast()?;
+                amm_ask_price
+                .safe_add(amm_ask_price / (seconds_til_order_expiry * 20).clamp(100, 200))
+            } else {
+                oracle_price.safe_add(self.last_ask_price_twap.cast::<i64>()?
+                .safe_sub(self.historical_oracle_data.last_oracle_price_twap)?
+                .max(0)
+                )?.safe_add(oracle_price / (seconds_til_order_expiry * 2).clamp(10, 50))
+            }
+        } else {
+            // pick amm bid - buffer if theres liquidity 
+            // otherwise be aggressive vs oracle + 1hr bid premium
+            if amm_available_liquidity >= self.min_order_size {
+                let reserve_price = self.reserve_price()?;
+                let amm_bid_price: i64 = self.bid_price(reserve_price)?.cast()?;
+                amm_bid_price
+                .safe_sub(amm_bid_price / (seconds_til_order_expiry * 20).clamp(100, 200))
+            } else {
+                oracle_price.safe_add(self.last_bid_price_twap.cast::<i64>()?
+                .safe_sub(self.historical_oracle_data.last_oracle_price_twap)?
+                .min(0)
+                )?.safe_add(oracle_price / (seconds_til_order_expiry * 2).clamp(10, 50))
+            }
+        }
+
+    }
+
     pub fn get_protocol_owned_position(self) -> DriftResult<i64> {
         self.base_asset_amount_with_amm
             .safe_add(self.base_asset_amount_with_unsettled_lp)?

programs/drift/src/state/user.rs

@@ -999,6 +999,10 @@ pub enum AssetType {
 }
 
 impl Order {
+    pub fn seconds_til_expiry(self, now: i64) -> i64 {
+        self.max_ts - now
+    }
+
     pub fn has_oracle_price_offset(self) -> bool {
         self.oracle_price_offset != 0
     }