Merge remote-tracking branch 'upstream/master' into update/v2.85.0

Author: jordy25519

.github/workflows/release.yml

@@ -0,0 +1,30 @@
+name: Release
+on:
+  release:
+    types: [published]
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/[email protected]
+
+    - name: Set up Python
+      uses: actions/[email protected]
+      with:
+        python-version: '3.10.10'
+
+    - name: Install and configure Poetry
+      run: |
+        cd python
+        curl -sSL https://install.python-poetry.org | python3 -
+      env:
+        POETRY_VERSION: 1.4.2
+
+    - name: Build
+      run: poetry build
+      working-directory: python
+
+    - name: Publish
+      run: poetry publish --username=__token__ --password=${{ secrets.PYPI_TOKEN }}
+      working-directory: python

.gitignore

@@ -16,4 +16,5 @@ python/poetry.lock
 __pycache__/
 *.pyc
 *.pyo
-*.pyd
+*.pyd
+rust/.env

Cargo.toml

@@ -2,6 +2,9 @@
 members = [
     "programs/*"
 ]
+exclude = [
+    "rust"
+]
 
 [profile.release]
 overflow-checks = true

programs/jit-proxy/src/error.rs

@@ -21,4 +21,6 @@ pub enum ErrorCode {
     UnprofitableArb,
     #[msg("PositionLimitBreached")]
     PositionLimitBreached,
+    #[msg("NoFill")]
+    NoFill,
 }

programs/jit-proxy/src/instructions/jit.rs

@@ -32,6 +32,27 @@ pub fn jit<'info>(ctx: Context<'_, '_, 'info, 'info, Jit<'info>>, params: JitPar
     let market_index = taker_order.market_index;
     let taker_direction = taker_order.direction;
 
+    let slots_left = taker_order
+        .slot
+        .safe_add(taker_order.auction_duration.cast()?)?
+        .cast::<i64>()?
+        .safe_sub(slot.cast()?)?;
+    msg!(
+        "slot = {} auction duration = {} slots_left = {}",
+        slot,
+        taker_order.auction_duration,
+        slots_left
+    );
+
+    msg!(
+        "taker order type {:?} auction start {} auction end {} limit price {} oracle price offset {}",
+        taker_order.order_type,
+        taker_order.auction_start_price,
+        taker_order.auction_end_price,
+        taker_order.price,
+        taker_order.oracle_price_offset
+    );
+
     let remaining_accounts_iter = &mut ctx.remaining_accounts.iter().peekable();
     let AccountMaps {
         perp_market_map,
@@ -45,20 +66,45 @@ pub fn jit<'info>(ctx: Context<'_, '_, 'info, 'info, Jit<'info>>, params: JitPar
         None,
     )?;
 
-    let (oracle_price, tick_size) = if market_type == DriftMarketType::Perp {
+    let (oracle_price, tick_size, min_order_size) = if market_type == DriftMarketType::Perp {
         let perp_market = perp_market_map.get_ref(&market_index)?;
         let oracle_price = oracle_map.get_price_data(&perp_market.amm.oracle)?.price;
 
-        (oracle_price, perp_market.amm.order_tick_size)
+        (
+            oracle_price,
+            perp_market.amm.order_tick_size,
+            perp_market.amm.min_order_size,
+        )
     } else {
         let spot_market = spot_market_map.get_ref(&market_index)?;
         let oracle_price = oracle_map.get_price_data(&spot_market.oracle)?.price;
 
-        (oracle_price, spot_market.order_tick_size)
+        (
+            oracle_price,
+            spot_market.order_tick_size,
+            spot_market.min_order_size,
+        )
     };
 
     let taker_price =
-        taker_order.force_get_limit_price(Some(oracle_price), None, slot, tick_size)?;
+        match taker_order.get_limit_price(Some(oracle_price), None, slot, tick_size)? {
+            Some(price) => price,
+            None if market_type == DriftMarketType::Perp => {
+                msg!("taker order didnt have price. deriving fallback");
+                // if the order doesn't have a price, drift users amm price for taker price
+                let perp_market = perp_market_map.get_ref(&market_index)?;
+                let reserve_price = perp_market.amm.reserve_price()?;
+                match taker_direction {
+                    PositionDirection::Long => perp_market.amm.ask_price(reserve_price)?,
+                    PositionDirection::Short => perp_market.amm.bid_price(reserve_price)?,
+                }
+            }
+            None => {
+                // Shouldnt be possible for spot
+                msg!("taker order didnt have price");
+                return Err(ErrorCode::TakerOrderNotFound.into());
+            }
+        };
 
     let maker_direction = taker_direction.opposite();
     let maker_worst_price = params.get_worst_price(oracle_price, taker_direction)?;
@@ -84,9 +130,41 @@ pub fn jit<'info>(ctx: Context<'_, '_, 'info, 'info, Jit<'info>>, params: JitPar
             }
         }
     }
-    let maker_price = taker_price;
 
-    let taker_base_asset_amount_unfilled = taker_order.get_base_asset_amount_unfilled(None)?;
+    let maker_price = if market_type == DriftMarketType::Perp {
+        let perp_market = perp_market_map.get_ref(&market_index)?;
+        let reserve_price = perp_market.amm.reserve_price()?;
+
+        let maker_price = match maker_direction {
+            PositionDirection::Long => {
+                let amm_bid_price = perp_market.amm.bid_price(reserve_price)?;
+
+                // if amm price is better than maker, use amm price to ensure fill
+                if taker_price <= amm_bid_price {
+                    amm_bid_price.min(maker_worst_price)
+                } else {
+                    taker_price
+                }
+            }
+            PositionDirection::Short => {
+                let amm_ask_price = perp_market.amm.ask_price(reserve_price)?;
+
+                if taker_price >= amm_ask_price {
+                    amm_ask_price.max(maker_worst_price)
+                } else {
+                    taker_price
+                }
+            }
+        };
+
+        maker_price
+    } else {
+        taker_price
+    };
+
+    let taker_base_asset_amount_unfilled = taker_order
+        .get_base_asset_amount_unfilled(None)?
+        .max(min_order_size);
     let maker_existing_position = if market_type == DriftMarketType::Perp {
         let perp_market = perp_market_map.get_ref(&market_index)?;
         let perp_position = maker.get_perp_position(market_index);
@@ -111,6 +189,7 @@ pub fn jit<'info>(ctx: Context<'_, '_, 'info, 'info, Jit<'info>>, params: JitPar
         maker_direction,
         taker_base_asset_amount_unfilled,
         maker_existing_position,
+        min_order_size,
     ) {
         Ok(size) => size,
         Err(e) => {
@@ -144,7 +223,36 @@ pub fn jit<'info>(ctx: Context<'_, '_, 'info, 'info, Jit<'info>>, params: JitPar
     drop(taker);
     drop(maker);
 
-    place_and_make(ctx, params.taker_order_id, order_params)?;
+    place_and_make(&ctx, params.taker_order_id, order_params)?;
+
+    let taker = ctx.accounts.taker.load()?;
+
+    let taker_base_asset_amount_unfilled_after = match taker.get_order(params.taker_order_id) {
+        Some(order) => order.get_base_asset_amount_unfilled(None)?,
+        None => 0,
+    };
+
+    if taker_base_asset_amount_unfilled_after == taker_base_asset_amount_unfilled {
+        // taker order failed to fill
+        msg!(
+            "taker price = {} maker price = {} oracle price = {}",
+            taker_price,
+            maker_price,
+            oracle_price
+        );
+        msg!("jit params {:?}", params);
+        if market_type == DriftMarketType::Perp {
+            let perp_market = perp_market_map.get_ref(&market_index)?;
+            let reserve_price = perp_market.amm.reserve_price()?;
+            let (bid_price, ask_price) = perp_market.amm.bid_ask_price(reserve_price)?;
+            msg!(
+                "vamm bid price = {} vamm ask price = {}",
+                bid_price,
+                ask_price
+            );
+        }
+        return Err(ErrorCode::NoFill.into());
+    }
 
     Ok(())
 }
@@ -213,15 +321,17 @@ fn check_position_limits(
     maker_direction: PositionDirection,
     taker_base_asset_amount_unfilled: u64,
     maker_existing_position: i64,
+    min_order_size: u64,
 ) -> Result<u64> {
     if maker_direction == PositionDirection::Long {
         let size = params.max_position.safe_sub(maker_existing_position)?;
 
-        if size <= 0 {
+        if size <= min_order_size.cast()? {
             msg!(
-                "maker existing position {} >= max position {}",
+                "maker existing position {} >= max position {} + min order size {}",
                 maker_existing_position,
-                params.max_position
+                params.max_position,
+                min_order_size
             );
             return Err(ErrorCode::PositionLimitBreached.into());
         }
@@ -230,11 +340,12 @@ fn check_position_limits(
     } else {
         let size = maker_existing_position.safe_sub(params.min_position)?;
 
-        if size <= 0 {
+        if size <= min_order_size.cast()? {
             msg!(
-                "maker existing position {} <= min position {}",
+                "maker existing position {} <= min position {} + min order size {}",
                 maker_existing_position,
-                params.min_position
+                params.min_position,
+                min_order_size
             );
             return Err(ErrorCode::PositionLimitBreached.into());
         }
@@ -256,55 +367,55 @@ mod tests {
         };
 
         // same direction, doesn't breach
-        let result = check_position_limits(params, PositionDirection::Long, 10, 40);
+        let result = check_position_limits(params, PositionDirection::Long, 10, 40, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 10);
-        let result = check_position_limits(params, PositionDirection::Short, 10, -40);
+        let result = check_position_limits(params, PositionDirection::Short, 10, -40, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 10);
 
         // same direction, whole order breaches, only takes enough to hit limit
-        let result = check_position_limits(params, PositionDirection::Long, 100, 40);
+        let result = check_position_limits(params, PositionDirection::Long, 100, 40, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 60);
-        let result = check_position_limits(params, PositionDirection::Short, 100, -40);
+        let result = check_position_limits(params, PositionDirection::Short, 100, -40, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 60);
 
         // opposite direction, doesn't breach
-        let result = check_position_limits(params, PositionDirection::Long, 10, -40);
+        let result = check_position_limits(params, PositionDirection::Long, 10, -40, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 10);
-        let result = check_position_limits(params, PositionDirection::Short, 10, 40);
+        let result = check_position_limits(params, PositionDirection::Short, 10, 40, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 10);
 
         // opposite direction, whole order breaches, only takes enough to take flipped limit
-        let result = check_position_limits(params, PositionDirection::Long, 200, -40);
+        let result = check_position_limits(params, PositionDirection::Long, 200, -40, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 140);
-        let result = check_position_limits(params, PositionDirection::Short, 200, 40);
+        let result = check_position_limits(params, PositionDirection::Short, 200, 40, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 140);
 
         // opposite direction, maker already breached, allows reducing
-        let result = check_position_limits(params, PositionDirection::Long, 200, -150);
+        let result = check_position_limits(params, PositionDirection::Long, 200, -150, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 200);
-        let result = check_position_limits(params, PositionDirection::Short, 200, 150);
+        let result = check_position_limits(params, PositionDirection::Short, 200, 150, 0);
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 200);
 
         // same direction, maker already breached, errors
-        let result = check_position_limits(params, PositionDirection::Long, 200, 150);
+        let result = check_position_limits(params, PositionDirection::Long, 200, 150, 0);
         assert!(result.is_err());
-        let result = check_position_limits(params, PositionDirection::Short, 200, -150);
+        let result = check_position_limits(params, PositionDirection::Short, 200, -150, 0);
         assert!(result.is_err());
     }
 }
 
 fn place_and_make<'info>(
-    ctx: Context<'_, '_, '_, 'info, Jit<'info>>,
+    ctx: &Context<'_, '_, '_, 'info, Jit<'info>>,
     taker_order_id: u32,
     order_params: OrderParams,
 ) -> Result<()> {

programs/jit-proxy/src/state.rs

@@ -8,6 +8,7 @@ pub enum PostOnlyParam {
     None,
     MustPostOnly, // Tx fails if order can't be post only
     TryPostOnly,  // Tx succeeds and order not placed if can't be post only
+    Slide,        // Modify price to be post only if can't be post only
 }
 
 impl PostOnlyParam {
@@ -16,6 +17,7 @@ impl PostOnlyParam {
             PostOnlyParam::None => DriftPostOnlyParam::None,
             PostOnlyParam::MustPostOnly => DriftPostOnlyParam::MustPostOnly,
             PostOnlyParam::TryPostOnly => DriftPostOnlyParam::TryPostOnly,
+            PostOnlyParam::Slide => DriftPostOnlyParam::Slide,
         }
     }
 }

python/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
-name = "jit_proxy"
-version = "0.1.0"
+name = "drift_jit_proxy"
+version = "0.1.3"
 description = "python sdk for drift protocol v2 jit proxy program"
 authors = ["Frank <[email protected]>"]
 readme = "README.md"
@@ -13,10 +13,10 @@ python = "^3.10"
 python-dotenv = "^1.0.0"
 solana = "^0.30.1"
 anchorpy = "^0.17.1"
-driftpy = "0.7.9"
+driftpy = "0.7.35"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
-# 
+# 

python/sdk/jit_proxy/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.0"
+__version__ = "0.1.1"