Merge pull request #51 from Turbin3/feature/match-orders-27

[2.7] match_orders: crank-fill, partial/full match, fee calc, self-match guard

Author: 0xfave

src/processor.rs

@@ -1077,10 +1077,199 @@ pub fn update_orderbook(
 /// Account context: MatchOrdersAccounts (7 accounts)
 /// Args: MatchOrdersArgs
 pub fn match_orders(
-    _program_id: &Address,
-    _accounts: &mut [AccountView],
+    program_id: &Address,
+    accounts: &mut [AccountView],
     _instruction_data: &[u8],
 ) -> ProgramResult {
+    let ctx = crate::instruction::MatchOrdersAccounts::try_from(&*accounts)?;
+
+    if !ctx.market.owned_by(program_id) {
+        return Err(FluxDexError::InvalidAccountOwner.into());
+    }
+
+    let (m_authority, m_base_mint, m_quote_mint, m_bump, m_fee_bps) = {
+        let data = ctx
+            .market
+            .try_borrow()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        let market = Market::from_account(&data)?;
+        (
+            market.authority,
+            market.base_mint,
+            market.quote_mint,
+            market.bump,
+            market.fee_bps(),
+        )
+    };
+
+    if ctx.crank_authority.address().to_bytes() != m_authority {
+        return Err(FluxDexError::UnauthorizedCrank.into());
+    }
+
+    let market_pda = Address::create_program_address(
+        &[b"market", &m_base_mint, &m_quote_mint, &[m_bump]],
+        program_id,
+    )
+    .map_err(|_| FluxDexError::InvalidPdaSeeds)?;
+    if &market_pda != ctx.market.address() {
+        return Err(FluxDexError::InvalidPdaSeeds.into());
+    }
+
+    let market_bytes = ctx.market.address().to_bytes();
+    let (orderbook_pda, _) =
+        Address::find_program_address(&[b"orderbook", &market_bytes], program_id);
+    if &orderbook_pda != ctx.orderbook.address() {
+        return Err(FluxDexError::InvalidPdaSeeds.into());
+    }
+
+    if !ctx.buyer_order.owned_by(program_id) || !ctx.seller_order.owned_by(program_id) {
+        return Err(FluxDexError::InvalidAccountOwner.into());
+    }
+
+    let (b_side, b_status, b_price, b_quantity, b_filled, b_trader, b_id, b_bump, b_market) = {
+        let data = ctx
+            .buyer_order
+            .try_borrow()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        let o = Order::from_account(&data)?;
+        (
+            o.side()?,
+            o.status()?,
+            o.price(),
+            o.quantity(),
+            o.filled(),
+            o.trader,
+            o.client_order_id(),
+            o.bump,
+            o.market,
+        )
+    };
+
+    let (s_side, s_status, s_price, s_quantity, s_filled, s_trader, s_id, s_bump, s_market) = {
+        let data = ctx
+            .seller_order
+            .try_borrow()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        let o = Order::from_account(&data)?;
+        (
+            o.side()?,
+            o.status()?,
+            o.price(),
+            o.quantity(),
+            o.filled(),
+            o.trader,
+            o.client_order_id(),
+            o.bump,
+            o.market,
+        )
+    };
+
+    if b_market != market_bytes || s_market != market_bytes {
+        return Err(FluxDexError::InvalidArgument.into());
+    }
+
+    let b_order_pda = Address::create_program_address(
+        &[
+            b"order",
+            &market_bytes,
+            &b_trader,
+            &b_id.to_le_bytes(),
+            &[b_bump],
+        ],
+        program_id,
+    )
+    .map_err(|_| FluxDexError::InvalidPdaSeeds)?;
+    if &b_order_pda != ctx.buyer_order.address() {
+        return Err(FluxDexError::InvalidPdaSeeds.into());
+    }
+
+    let s_order_pda = Address::create_program_address(
+        &[
+            b"order",
+            &market_bytes,
+            &s_trader,
+            &s_id.to_le_bytes(),
+            &[s_bump],
+        ],
+        program_id,
+    )
+    .map_err(|_| FluxDexError::InvalidPdaSeeds)?;
+    if &s_order_pda != ctx.seller_order.address() {
+        return Err(FluxDexError::InvalidPdaSeeds.into());
+    }
+
+    if b_status != OrderStatus::Open || s_status != OrderStatus::Open {
+        return Err(FluxDexError::OrderNotOpen.into());
+    }
+
+    if b_side != Side::Buy || s_side != Side::Sell {
+        return Err(FluxDexError::InvalidArgument.into());
+    }
+
+    if b_price != s_price {
+        return Err(FluxDexError::InvalidArgument.into());
+    }
+
+    if b_trader == s_trader {
+        return Err(FluxDexError::InvalidArgument.into());
+    }
+
+    let b_remaining = b_quantity
+        .checked_sub(b_filled)
+        .ok_or(FluxDexError::ArithmeticOverflow)?;
+    let s_remaining = s_quantity
+        .checked_sub(s_filled)
+        .ok_or(FluxDexError::ArithmeticOverflow)?;
+
+    if b_remaining == 0 || s_remaining == 0 {
+        return Err(FluxDexError::InvalidArgument.into());
+    }
+
+    let fill_quantity = b_remaining.min(s_remaining);
+    let fill_price = b_price;
+
+    let _fee = fill_price
+        .checked_mul(fill_quantity)
+        .ok_or(FluxDexError::ArithmeticOverflow)?
+        .checked_mul(m_fee_bps as u64)
+        .ok_or(FluxDexError::ArithmeticOverflow)?
+        .checked_div(10000)
+        .ok_or(FluxDexError::ArithmeticOverflow)?;
+
+    let new_b_filled = b_filled
+        .checked_add(fill_quantity)
+        .ok_or(FluxDexError::ArithmeticOverflow)?;
+    let new_s_filled = s_filled
+        .checked_add(fill_quantity)
+        .ok_or(FluxDexError::ArithmeticOverflow)?;
+
+    let b_fully_filled = new_b_filled == b_quantity;
+    let s_fully_filled = new_s_filled == s_quantity;
+
+    {
+        let buyer_account = &mut accounts[5]; // MatchOrdersAccounts buyer_order index
+        let mut buyer_data = buyer_account
+            .try_borrow_mut()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        let order = Order::from_account_mut(&mut buyer_data)?;
+        order.filled = new_b_filled.to_le_bytes();
+        if b_fully_filled {
+            order.status = u8::from(OrderStatus::Filled);
+        }
+    }
+
+    {
+        let seller_account = &mut accounts[6]; // MatchOrdersAccounts seller_order index
+        let mut seller_data = seller_account
+            .try_borrow_mut()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        let order = Order::from_account_mut(&mut seller_data)?;
+        order.filled = new_s_filled.to_le_bytes();
+        if s_fully_filled {
+            order.status = u8::from(OrderStatus::Filled);
+        }
+    }
+
     Ok(())
 }