Function process

program/src/processor/swap.rs:163–388

(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
)

}

pub(crate) fn process(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    let Params {
        side,
        base_qty,
        mut quote_qty,
        match_limit,
        has_discount_token_account,
        _padding: _,
    } = try_from_bytes(instruction_data).map_err(|_| ProgramError::InvalidInstructionData)?;
    let accounts = Accounts::parse(program_id, accounts, *has_discount_token_account != 0)?;

    let market_state = DexState::get(accounts.market)?;

    // Check the order size
    if base_qty < &market_state.min_base_order_size {
        msg!("The base order size is too small.");
        return Err(ProgramError::InvalidArgument);
    }

    check_accounts(program_id, &market_state, &accounts).unwrap();
    let fee_tier = accounts
        .discount_token_account
        .map(|a| FeeTier::get(&market_state, a, accounts.user_owner.key))
        .unwrap_or(Ok(FeeTier::Base))?;
    let callback_info = CallBackInfo {
        user_account: Pubkey::default(),
        fee_tier: fee_tier as u8
            | ((accounts.fee_referral_account.is_some() as u8) * REFERRAL_MASK),
    };
    if *side == Side::Bid as u8 {
        // We make sure to leave enough quote quantity to pay for taker fees in the worst case
        quote_qty = fee_tier.remove_taker_fee(quote_qty);
    }

    let mut orderbook_guard = accounts.orderbook.data.borrow_mut();
    let orderbook = asset_agnostic_orderbook::state::market_state::MarketState::from_buffer(
        &mut orderbook_guard,
        AccountTag::Market,
    )?;
    let tick_size = orderbook.tick_size;
    drop(orderbook_guard);

    let (max_base_qty_scaled, max_quote_qty_scaled, limit_price) =
        match FromPrimitive::from_u8(*side).unwrap() {
            Side::Bid => (
                u64::MAX,
                market_state.scale_quote_amount(quote_qty),
                u64::MAX - (u64::MAX % tick_size),
            ),
            Side::Ask => (market_state.scale_base_amount(*base_qty), u64::MAX, 0),
        };

    let invoke_params = asset_agnostic_orderbook::instruction::new_order::Params {
        max_base_qty: max_base_qty_scaled,