[2.3] Implement cancel_order() (#49)

* feat(order): implement cancel_order instruction

* chore: re-trigger CI

Author: Harshbhargav45

src/instruction.rs

@@ -215,14 +215,16 @@ pub struct CancelOrderAccounts<'a> {
     pub trader_quote_ata: &'a AccountView,
     pub base_vault: &'a AccountView,
     pub quote_vault: &'a AccountView,
+    pub base_mint: &'a AccountView,
+    pub quote_mint: &'a AccountView,
     pub token_program: &'a AccountView,
 }
 
 impl<'a> TryFrom<&'a [AccountView]> for CancelOrderAccounts<'a> {
     type Error = FluxDexError;
 
     fn try_from(accounts: &'a [AccountView]) -> Result<Self, Self::Error> {
-        if accounts.len() != 8 {
+        if accounts.len() != 10 {
             return Err(FluxDexError::InvalidAccountCount);
         }
 
@@ -234,6 +236,8 @@ impl<'a> TryFrom<&'a [AccountView]> for CancelOrderAccounts<'a> {
             trader_quote_ata,
             base_vault,
             quote_vault,
+            base_mint,
+            quote_mint,
             token_program,
         ] = accounts
         else {
@@ -247,14 +251,18 @@ impl<'a> TryFrom<&'a [AccountView]> for CancelOrderAccounts<'a> {
 
         // Writable - all mutable accounts
         if !trader.is_writable()
-            || !market.is_writable()
             || !order.is_writable()
             || !trader_base_ata.is_writable()
             || !trader_quote_ata.is_writable()
         {
             return Err(FluxDexError::AccountNotWritable);
         }
 
+        // Vaults must be writable for the token transfer CPI.
+        if !base_vault.is_writable() || !quote_vault.is_writable() {
+            return Err(FluxDexError::AccountNotWritable);
+        }
+
         // Duplicate mutable account guard
         if trader_base_ata.address() == trader_quote_ata.address() {
             return Err(FluxDexError::DuplicateMutableAccount);
@@ -273,6 +281,8 @@ impl<'a> TryFrom<&'a [AccountView]> for CancelOrderAccounts<'a> {
             trader_quote_ata,
             base_vault,
             quote_vault,
+            base_mint,
+            quote_mint,
             token_program,
         })
     }

src/processor.rs

@@ -22,6 +22,10 @@ const MARKET_ACCOUNT_INDEX: usize = 1;
 /// Must match [`PlaceOrderAccounts`] (trader, market, **order**, …).
 const ORDER_ACCOUNT_INDEX: usize = 2;
 
+/// Index of the Order account within the `CancelOrder` account list.
+/// Must match [`CancelOrderAccounts`] (trader, market, **order**, …).
+const CANCEL_ORDER_ACCOUNT_INDEX: usize = 2;
+
 /// Minimum byte length of an SPL Token (or Token-2022 base) `Mint` account.
 const MINT_ACCOUNT_LEN: usize = 82;
 
@@ -524,14 +528,248 @@ fn transfer_checked(
     invoke_signed(&ix, &[source, mint, destination, authority], &[])
 }
 
+/// Invoke SPL Token `transfer_checked` where the authority is a PDA. The PDA
+/// signer seeds are provided so the CPI can be signed on behalf of the PDA.
+#[inline]
+#[allow(clippy::too_many_arguments)]
+fn transfer_checked_pda(
+    token_program: &Address,
+    source: &AccountView,
+    mint: &AccountView,
+    destination: &AccountView,
+    authority: &AccountView,
+    amount: u64,
+    decimals: u8,
+    signer: Signer,
+) -> ProgramResult {
+    let mut data = [0u8; 10];
+    data[0] = TOKEN_IX_TRANSFER_CHECKED;
+    data[1..9].copy_from_slice(&amount.to_le_bytes());
+    data[9] = decimals;
+
+    let accounts = [
+        InstructionAccount::new(source.address(), true, false),
+        InstructionAccount::readonly(mint.address()),
+        InstructionAccount::new(destination.address(), true, false),
+        InstructionAccount::new(authority.address(), false, true),
+    ];
+    let ix = InstructionView {
+        program_id: token_program,
+        accounts: &accounts,
+        data: &data,
+    };
+    invoke_signed(&ix, &[source, mint, destination, authority], &[signer])
+}
+
 /// Cancel an open order.                   (TDD §5, ticket 2.3)
-/// Account context: CancelOrderAccounts (8 accounts)
+/// Account context: CancelOrderAccounts (10 accounts)
 /// Args: CancelOrderArgs
+///
+/// Validates the order is Open and belongs to the signing trader, transfers the
+/// locked tokens from the market vault back to the trader's ATA via a
+/// Market-PDA-signed `transfer_checked` CPI, and sets the order status to
+/// Cancelled.
 pub fn cancel_order(
-    _program_id: &Address,
-    _accounts: &mut [AccountView],
-    _instruction_data: &[u8],
+    program_id: &Address,
+    accounts: &mut [AccountView],
+    instruction_data: &[u8],
 ) -> ProgramResult {
+    // --- Deserialize args ---
+    let args = wincode::deserialize::<crate::instruction::CancelOrderArgs>(instruction_data)
+        .map_err(|_| FluxDexError::InvalidInstructionData)?;
+
+    // --- Structural account validation ---
+    let ctx = crate::instruction::CancelOrderAccounts::try_from(&*accounts)?;
+    let token_program = ctx.token_program.address();
+
+    // --- Market: owner + discriminator, snapshot needed fields ---
+    if !ctx.market.owned_by(program_id) {
+        return Err(FluxDexError::InvalidAccountOwner.into());
+    }
+    let (m_base_mint, m_quote_mint, m_base_vault, m_quote_vault, m_bump) = {
+        let data = ctx
+            .market
+            .try_borrow()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        let market = Market::from_account(&data)?;
+        (
+            market.base_mint,
+            market.quote_mint,
+            market.base_vault,
+            market.quote_vault,
+            market.bump,
+        )
+    };
+
+    // --- Verify the market PDA is canonical (re-derive from stored bump) ---
+    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());
+    }
+
+    // --- Bind passed vaults/mints to the market's recorded identities ---
+    if ctx.base_vault.address().to_bytes() != m_base_vault
+        || ctx.quote_vault.address().to_bytes() != m_quote_vault
+    {
+        return Err(FluxDexError::InvalidArgument.into());
+    }
+    if ctx.base_mint.address().to_bytes() != m_base_mint
+        || ctx.quote_mint.address().to_bytes() != m_quote_mint
+    {
+        return Err(FluxDexError::InvalidTokenMint.into());
+    }
+
+    // --- Validate mint accounts are token-program-owned ---
+    validate_mint(ctx.base_mint, token_program)?;
+    validate_mint(ctx.quote_mint, token_program)?;
+
+    // --- Order: owner + discriminator, validate status and trader ---
+    if !ctx.order.owned_by(program_id) {
+        return Err(FluxDexError::InvalidAccountOwner.into());
+    }
+    let (o_side, o_price, o_quantity, o_filled, o_bump) = {
+        let data = ctx
+            .order
+            .try_borrow()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        let order = Order::from_account(&data)?;
+
+        // Only Open orders can be cancelled.
+        if order.status()? != OrderStatus::Open {
+            return Err(FluxDexError::OrderNotOpen.into());
+        }
+
+        // Only the order's trader can cancel.
+        if order.trader != ctx.trader.address().to_bytes() {
+            return Err(FluxDexError::MissingRequiredSigner.into());
+        }
+
+        // Order must belong to this market.
+        if order.market != ctx.market.address().to_bytes() {
+            return Err(FluxDexError::InvalidArgument.into());
+        }
+
+        (
+            order.side()?,
+            order.price(),
+            order.quantity(),
+            order.filled(),
+            order.bump,
+        )
+    };
+
+    // --- Verify the order PDA is canonical ---
+    // Use create_program_address (O(1)) with stored bump instead of the
+    // expensive find_program_address (iterates up to 256 bumps, ~6k CU).
+    let market_bytes = ctx.market.address().to_bytes();
+    let trader_bytes = ctx.trader.address().to_bytes();
+    let order_id_bytes = args.order_id.to_le_bytes();
+    let order_pda = Address::create_program_address(
+        &[
+            b"order",
+            &market_bytes,
+            &trader_bytes,
+            &order_id_bytes,
+            &[o_bump],
+        ],
+        program_id,
+    )
+    .map_err(|_| FluxDexError::InvalidPdaSeeds)?;
+    if &order_pda != ctx.order.address() {
+        return Err(FluxDexError::InvalidPdaSeeds.into());
+    }
+
+    // --- Determine refund amount and the custody leg ---
+    // Refund the unfilled portion: Buy locked price*(quantity-filled) quote,
+    // Sell locked (quantity-filled) base.
+    let remaining = o_quantity
+        .checked_sub(o_filled)
+        .ok_or(FluxDexError::ArithmeticOverflow)?;
+
+    let (source_vault, dest_ata, mint_account, refund_amount) = match o_side {
+        Side::Buy => (
+            ctx.quote_vault,
+            ctx.trader_quote_ata,
+            ctx.quote_mint,
+            o_price
+                .checked_mul(remaining)
+                .ok_or(FluxDexError::ArithmeticOverflow)?,
+        ),
+        Side::Sell => (
+            ctx.base_vault,
+            ctx.trader_base_ata,
+            ctx.base_mint,
+            remaining,
+        ),
+    };
+
+    // --- Read mint decimals for transfer_checked ---
+    let decimals = read_mint_decimals(mint_account)?;
+
+    // --- Snapshot the vault balance before the CPI ---
+    let vault_balance_before = {
+        let data = source_vault
+            .try_borrow()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        data.get(TOKEN_AMOUNT_OFFSET..TOKEN_AMOUNT_OFFSET + 8)
+            .and_then(|b| b.try_into().ok())
+            .map(u64::from_le_bytes)
+            .ok_or(FluxDexError::InvalidInstructionData)?
+    };
+
+    // --- CPI: transfer_checked from vault → trader ATA (Market PDA signs) ---
+    let market_bump_seed = [m_bump];
+    let market_seeds = [
+        Seed::from(b"market".as_ref()),
+        Seed::from(m_base_mint.as_ref()),
+        Seed::from(m_quote_mint.as_ref()),
+        Seed::from(market_bump_seed.as_ref()),
+    ];
+    let market_signer = Signer::from(&market_seeds[..]);
+
+    transfer_checked_pda(
+        token_program,
+        source_vault,
+        mint_account,
+        dest_ata,
+        ctx.market,
+        refund_amount,
+        decimals,
+        market_signer,
+    )?;
+
+    // --- Re-check vault balance after CPI ---
+    let vault_balance_after = {
+        let data = source_vault
+            .try_borrow()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        data.get(TOKEN_AMOUNT_OFFSET..TOKEN_AMOUNT_OFFSET + 8)
+            .and_then(|b| b.try_into().ok())
+            .map(u64::from_le_bytes)
+            .ok_or(FluxDexError::InvalidInstructionData)?
+    };
+    if vault_balance_before
+        .checked_sub(vault_balance_after)
+        .ok_or(FluxDexError::ArithmeticOverflow)?
+        != refund_amount
+    {
+        return Err(FluxDexError::AtomicSettlementFailed.into());
+    }
+
+    // --- Update the order status to Cancelled ---
+    {
+        let order_account = &mut accounts[CANCEL_ORDER_ACCOUNT_INDEX];
+        let mut order_data = order_account
+            .try_borrow_mut()
+            .map_err(|_| FluxDexError::InvalidInstructionData)?;
+        let order = Order::from_account_mut(&mut order_data)?;
+        order.status = u8::from(OrderStatus::Cancelled);
+    }
+
     Ok(())
 }