program: add cancelOrdersByPrice

programs/drift/src/controller/orders.rs

@@ -521,6 +521,77 @@ pub fn cancel_orders(
     Ok(canceled_order_ids)
 }
 
+pub fn cancel_orders_by_price(
+    user: &mut User,
+    user_key: &Pubkey,
+    perp_market_map: &PerpMarketMap,
+    spot_market_map: &SpotMarketMap,
+    oracle_map: &mut OracleMap,
+    now: i64,
+    slot: u64,
+    direction: Option<PositionDirection>,
+    max_price: Option<u64>,
+    min_price: Option<u64>,
+) -> DriftResult {
+
+    // check max_price or min_price is set
+    if max_price.is_none() && min_price.is_none() {
+        return Err(ErrorCode::MissingPriceParameters);
+    }
+
+    for order_index in 0..user.orders.len() {
+        // get cur order
+        let order = &user.orders[order_index];
+
+        // check open
+        if order.status != OrderStatus::Open {
+            continue;
+        }
+
+        // check direction
+        if let Some(direction) = direction{
+            if order.direction != direction {
+                continue;
+            }
+        }
+
+
+        // filter by price
+        if let Some(max_price) = max_price {
+            if order.price <= max_price {
+                continue;
+            }
+        }
+
+        if let Some(min_price) = min_price {
+            if order.price >= min_price {
+                continue;
+            }
+        }
+
+        // cancel order
+        cancel_order(
+            order_index,
+            user,
+            user_key,
+            perp_market_map,
+            spot_market_map,
+            oracle_map,
+            now,
+            slot,
+            OrderActionExplanation::None,
+            None,
+            0,
+            false,
+        )?;
+    }
+
+    user.update_last_active_slot(slot);
+
+    Ok(())
+}
+
+
 pub fn cancel_order_by_order_id(
     order_id: u32,
     user: &AccountLoader<User>,

programs/drift/src/error.rs

@@ -575,6 +575,8 @@ pub enum ErrorCode {
     LiquidationOrderFailedToFill,
     #[msg("Invalid prediction market order")]
     InvalidPredictionMarketOrder,
+    #[msg("Missing both maximum and minimum price parameters.")]
+    MissingPriceParameters,
 }
 
 #[macro_export]

programs/drift/src/instructions/user.rs

@@ -963,6 +963,50 @@ pub fn handle_cancel_orders_by_ids<'c: 'info, 'info>(
     Ok(())
 }
 
+#[access_control(
+    exchange_not_paused(&ctx.accounts.state)
+)]
+pub fn handle_cancel_orders_by_price<'c: 'info, 'info>(
+    ctx: Context<'_, '_, 'c, 'info, CancelOrder>,
+    max_price: Option<u64>,
+    min_price: Option<u64>,
+    direction: Option<PositionDirection>,
+) -> Result<()> {
+    let clock = &Clock::get()?;
+    let state = &ctx.accounts.state;
+
+    let AccountMaps {
+        perp_market_map,
+        spot_market_map,
+        mut oracle_map,
+    } = load_maps(
+        &mut ctx.remaining_accounts.iter().peekable(),
+        &MarketSet::new(),
+        &MarketSet::new(),
+        clock.slot,
+        Some(state.oracle_guard_rails),
+    )?;
+
+    let user_key = ctx.accounts.user.key();
+    let mut user = load_mut!(ctx.accounts.user)?;
+
+    controller::orders::cancel_orders_by_price(
+        &mut user,
+        &user_key,
+        &perp_market_map,
+        &spot_market_map,
+        &mut oracle_map,
+        clock.unix_timestamp,
+        clock.slot,
+        direction,
+        max_price,
+        min_price,
+    )?;
+
+    Ok(())
+
+}
+
 #[access_control(
     exchange_not_paused(&ctx.accounts.state)
 )]

programs/drift/src/lib.rs

@@ -113,6 +113,15 @@ pub mod drift {
         handle_cancel_order_by_user_id(ctx, user_order_id)
     }
 
+    pub fn cancel_orders_by_price<'c: 'info, 'info>(
+        ctx: Context<'_, '_, 'c, 'info, CancelOrder>,
+        max_price: Option<u64>,
+        min_price: Option<u64>,
+        direction: Option<PositionDirection>,
+    ) -> Result<()> {
+        handle_cancel_orders_by_price(ctx, max_price, min_price, direction)
+    }
+
     pub fn cancel_orders<'c: 'info, 'info>(
         ctx: Context<'_, '_, 'c, 'info, CancelOrder<'info>>,
         market_type: Option<MarketType>,

sdk/src/driftClient.ts

@@ -3355,6 +3355,57 @@ export class DriftClient {
 		});
 	}
 
+	public async cancelOrdersByPrice(
+		direction: PositionDirection,
+		maxPrice?: BN,
+		minPrice?: BN,
+		txParams?: TxParams,
+		subAccountId?: number
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(
+				await this.getCancelOrdersByPriceIx(
+					direction,
+					maxPrice,
+					minPrice,
+					subAccountId
+				),
+				txParams
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getCancelOrdersByPriceIx(
+		direction: PositionDirection,
+		maxPrice?: BN,
+		minPrice?: BN,
+		subAccountId?: number
+	): Promise<TransactionInstruction> {
+		const user = await this.getUserAccountPublicKey(subAccountId);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(subAccountId)],
+			useMarketLastSlotCache: true,
+		});
+
+		return await this.program.instruction.cancelOrdersByPrice(
+			maxPrice || null,
+			minPrice || null,
+			direction,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user,
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
 	public async cancelOrders(
 		marketType?: MarketType,
 		marketIndex?: number,