Confine multiplier abstraction to AOB

Author: aubBrooks919

program/src/processor/cancel_order.rs

@@ -151,11 +151,10 @@ pub(crate) fn process(
         asks: accounts.asks,
     };
 
-    let order_summary = match agnostic_orderbook::instruction::cancel_order::process::<CallBackInfo>(
-        program_id,
-        invoke_accounts,
-        invoke_params,
-    ) {
+    let mut order_summary = match agnostic_orderbook::instruction::cancel_order::process::<
+        CallBackInfo,
+    >(program_id, invoke_accounts, invoke_params)
+    {
         Err(error) => {
             error.print::<AoError>();
             return Err(DexError::AOBError.into());
@@ -164,6 +163,15 @@ pub(crate) fn process(
     };
     let side = get_side_from_order_id(order_id);
 
+    order_summary.total_base_qty = order_summary
+        .total_base_qty
+        .checked_mul(market_state.base_currency_multiplier)
+        .unwrap();
+    order_summary.total_quote_qty = order_summary
+        .total_quote_qty
+        .checked_mul(market_state.quote_currency_multiplier)
+        .unwrap();
+
     match side {
         Side::Bid => {
             user_account.header.quote_token_free = user_account

program/src/processor/consume_events.rs

@@ -168,24 +168,30 @@ fn consume_event(
             let FillEvent {
                 tag: _,
                 taker_side,
-                quote_size,
+                mut quote_size,
                 maker_order_id: _,
-                base_size,
+                mut base_size,
                 ..
             } = event;
+            quote_size = quote_size
+                .checked_mul(market_state.quote_currency_multiplier)
+                .unwrap();
+            base_size = base_size
+                .checked_mul(market_state.base_currency_multiplier)
+                .unwrap();
             let maker_account_info = &accounts[accounts
                 .binary_search_by_key(&maker_callback_info.user_account, |k| *k.key)
                 .map_err(|_| DexError::MissingUserAccount)?];
             let (taker_fee_tier, is_referred) = FeeTier::from_u8(taker_callback_info.fee_tier);
             let mut maker_account_data = maker_account_info.data.borrow_mut();
             let mut maker_account = UserAccount::from_buffer(&mut maker_account_data).unwrap();
             let (maker_fee_tier, _) = FeeTier::from_u8(maker_callback_info.fee_tier);
-            let taker_fee = taker_fee_tier.taker_fee(*quote_size);
-            let maker_rebate = maker_fee_tier.maker_rebate(*quote_size);
+            let taker_fee = taker_fee_tier.taker_fee(quote_size);
+            let maker_rebate = maker_fee_tier.maker_rebate(quote_size);
             let royalties_fee =
-                market_state.royalties_bps.checked_mul(*quote_size).unwrap() / 10_000;
+                market_state.royalties_bps.checked_mul(quote_size).unwrap() / 10_000;
             let referral_fee = if is_referred {
-                taker_fee_tier.referral_fee(*quote_size)
+                taker_fee_tier.referral_fee(quote_size)
             } else {
                 0
             };
@@ -215,19 +221,19 @@ fn consume_event(
                     maker_account.header.base_token_locked = maker_account
                         .header
                         .base_token_locked
-                        .checked_sub(*base_size)
+                        .checked_sub(base_size)
                         .unwrap();
                 }
                 Side::Ask => {
                     maker_account.header.base_token_free = maker_account
                         .header
                         .base_token_free
-                        .checked_add(*base_size)
+                        .checked_add(base_size)
                         .unwrap();
                     maker_account.header.quote_token_locked = maker_account
                         .header
                         .quote_token_locked
-                        .checked_sub(*quote_size)
+                        .checked_sub(quote_size)
                         .unwrap();
                     maker_account
                         .header
@@ -242,16 +248,16 @@ fn consume_event(
             maker_account.header.accumulated_maker_quote_volume = maker_account
                 .header
                 .accumulated_maker_quote_volume
-                .checked_add(*quote_size)
+                .checked_add(quote_size)
                 .unwrap();
             maker_account.header.accumulated_maker_base_volume = maker_account
                 .header
                 .accumulated_maker_base_volume
-                .checked_add(*base_size)
+                .checked_add(base_size)
                 .unwrap();
 
-            market_state.quote_volume = market_state.quote_volume.checked_add(*quote_size).unwrap();
-            market_state.base_volume = market_state.base_volume.checked_add(*base_size).unwrap();
+            market_state.quote_volume = market_state.quote_volume.checked_add(quote_size).unwrap();
+            market_state.base_volume = market_state.base_volume.checked_add(base_size).unwrap();
         }
         EventRef::Out(OutEventRef {
             event,
@@ -260,7 +266,7 @@ fn consume_event(
             let OutEvent {
                 side,
                 order_id,
-                base_size,
+                mut base_size,
                 ..
             } = event;
             let user_account_info = &accounts[accounts
@@ -269,23 +275,27 @@ fn consume_event(
             let mut user_account_data = user_account_info.data.borrow_mut();
             let mut user_account = UserAccount::from_buffer(&mut user_account_data).unwrap();
 
-            if *base_size != 0 {
+            base_size = base_size
+                .checked_mul(market_state.base_currency_multiplier)
+                .unwrap();
+
+            if base_size != 0 {
                 match Side::from_u8(*side).unwrap() {
                     Side::Ask => {
                         user_account.header.base_token_free = user_account
                             .header
                             .base_token_free
-                            .checked_add(*base_size)
+                            .checked_add(base_size)
                             .unwrap();
                         user_account.header.base_token_locked = user_account
                             .header
                             .base_token_locked
-                            .checked_sub(*base_size)
+                            .checked_sub(base_size)
                             .unwrap();
                     }
                     Side::Bid => {
                         let price = (order_id >> 64) as u64;
-                        let qty_to_transfer = fp32_mul(*base_size, price);
+                        let qty_to_transfer = fp32_mul(base_size, price);
                         user_account.header.quote_token_free = user_account
                             .header
                             .quote_token_free

program/src/processor/create_market.rs

@@ -176,7 +176,7 @@ pub(crate) fn process(
         base_volume: 0,
         quote_volume: 0,
         accumulated_fees: 0,
-        min_base_order_size: *min_base_order_size / *base_currency_multiplier,
+        min_base_order_size: *min_base_order_size,
         fee_type: MarketFeeType::Default as u8,
         _padding: [0; 6],
         royalties_bps: royalties_bps as u64,
@@ -186,7 +186,7 @@ pub(crate) fn process(
     };
 
     let invoke_params = agnostic_orderbook::instruction::create_market::Params {
-        min_base_order_size: *min_base_order_size,
+        min_base_order_size: *min_base_order_size / *base_currency_multiplier,
         tick_size: *tick_size,
     };
     let invoke_accounts = agnostic_orderbook::instruction::create_market::Accounts {

program/src/processor/new_order.rs

@@ -218,7 +218,7 @@ pub(crate) fn process(
     let Params {
         side,
         limit_price,
-        mut max_base_qty,
+        max_base_qty,
         mut max_quote_qty,
         order_type,
         self_trade_behavior,
@@ -235,11 +235,10 @@ pub(crate) fn process(
     let mut user_account_data = accounts.user.data.borrow_mut();
     let mut user_account = accounts.load_user_account(&mut user_account_data)?;
 
-    max_base_qty /= market_state.base_currency_multiplier;
-    max_quote_qty /= market_state.quote_currency_multiplier;
+    let max_base_qty_scaled = max_base_qty / market_state.base_currency_multiplier;
 
     // Check the order size
-    if max_base_qty < market_state.min_base_order_size {
+    if max_base_qty < &market_state.min_base_order_size {
         msg!("The base order size is too small.");
         return Err(ProgramError::InvalidArgument);
     }
@@ -263,10 +262,11 @@ pub(crate) fn process(
         // We make sure to leave enough quote quantity to pay for taker fees in the worst case
         max_quote_qty = fee_tier.remove_taker_fee(max_quote_qty);
     }
+    let max_quote_qty_scaled = max_quote_qty / market_state.quote_currency_multiplier;
 
     let invoke_params = agnostic_orderbook::instruction::new_order::Params {
-        max_base_qty,
-        max_quote_qty,
+        max_base_qty: max_base_qty_scaled,
+        max_quote_qty: max_quote_qty_scaled,
         limit_price: *limit_price,
         side: FromPrimitive::from_u8(*side).unwrap(),
         match_limit: *match_limit,
@@ -294,6 +294,15 @@ pub(crate) fn process(
         Ok(s) => s,
     };
 
+    order_summary.total_base_qty = order_summary
+        .total_base_qty
+        .checked_mul(market_state.base_currency_multiplier)
+        .unwrap();
+    order_summary.total_quote_qty = order_summary
+        .total_quote_qty
+        .checked_mul(market_state.quote_currency_multiplier)
+        .unwrap();
+
     let (qty_to_transfer, transfer_destination, referral_fee) =
         match FromPrimitive::from_u8(*side).unwrap() {
             Side::Bid => {
@@ -319,12 +328,7 @@ pub(crate) fn process(
                 user_account.header.base_token_free +=
                     order_summary.total_base_qty - order_summary.total_base_qty_posted;
 
-                (
-                    q.checked_mul(market_state.quote_currency_multiplier)
-                        .unwrap(),
-                    accounts.quote_vault,
-                    referral_fee,
-                )
+                (q, accounts.quote_vault, referral_fee)
             }
             Side::Ask => {
                 let q = order_summary
@@ -347,12 +351,7 @@ pub(crate) fn process(
                 user_account.header.quote_token_free += taken_quote_qty
                     .checked_sub(taker_fee + royalties_fees)
                     .unwrap();
-                (
-                    q.checked_mul(market_state.base_currency_multiplier)
-                        .unwrap(),
-                    accounts.base_vault,
-                    referral_fee,
-                )
+                (q, accounts.base_vault, referral_fee)
             }
         };
 
@@ -362,7 +361,7 @@ pub(crate) fn process(
             if *side == Side::Bid as u8 {
                 order_summary.total_quote_qty < max_quote_qty
             } else {
-                order_summary.total_base_qty < max_base_qty
+                &order_summary.total_base_qty < max_base_qty
             }
         }
         OrderType::PostOnly => order_summary.posted_order_id.is_none(),

program/src/processor/settle.rs

@@ -123,11 +123,7 @@ pub(crate) fn process(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramR
         accounts.destination_quote_account.key,
         accounts.market_signer.key,
         &[],
-        user_account
-            .header
-            .quote_token_free
-            .checked_mul(market_state.quote_currency_multiplier)
-            .unwrap(),
+        user_account.header.quote_token_free,
     )?;
 
     invoke_signed(
@@ -150,11 +146,7 @@ pub(crate) fn process(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramR
         accounts.destination_base_account.key,
         accounts.market_signer.key,
         &[],
-        user_account
-            .header
-            .base_token_free
-            .checked_mul(market_state.base_currency_multiplier)
-            .unwrap(),
+        user_account.header.base_token_free,
     )?;
 
     invoke_signed(

program/src/processor/swap.rs

@@ -167,7 +167,7 @@ pub(crate) fn process(
 ) -> ProgramResult {
     let Params {
         side,
-        mut base_qty,
+        base_qty,
         mut quote_qty,
         match_limit,
         has_discount_token_account,
@@ -177,11 +177,10 @@ pub(crate) fn process(
 
     let market_state = DexState::get(accounts.market)?;
 
-    base_qty /= market_state.base_currency_multiplier;
-    quote_qty /= market_state.quote_currency_multiplier;
+    let base_qty_scaled = base_qty / market_state.base_currency_multiplier;
 
     // Check the order size
-    if base_qty < market_state.min_base_order_size {
+    if base_qty < &market_state.min_base_order_size {
         msg!("The base order size is too small.");
         return Err(ProgramError::InvalidArgument);
     }
@@ -200,6 +199,7 @@ pub(crate) fn process(
         // 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 quote_qty_scaled = quote_qty / market_state.quote_currency_multiplier;
 
     let mut orderbook_guard = accounts.orderbook.data.borrow_mut();
     let orderbook = agnostic_orderbook::state::market_state::MarketState::from_buffer(
@@ -209,14 +209,19 @@ pub(crate) fn process(
     let tick_size = orderbook.tick_size;
     drop(orderbook_guard);
 
-    let (max_base_qty, max_quote_qty, limit_price) = match FromPrimitive::from_u8(*side).unwrap() {
-        Side::Bid => (u64::MAX, quote_qty, u64::MAX - (u64::MAX % tick_size)),
-        Side::Ask => (base_qty, u64::MAX, 0),
-    };
+    let (max_base_qty_scaled, max_quote_qty_scaled, limit_price) =
+        match FromPrimitive::from_u8(*side).unwrap() {
+            Side::Bid => (
+                u64::MAX,
+                quote_qty_scaled,
+                u64::MAX - (u64::MAX % tick_size),
+            ),
+            Side::Ask => (base_qty_scaled, u64::MAX, 0),
+        };
 
     let invoke_params = agnostic_orderbook::instruction::new_order::Params {
-        max_base_qty,
-        max_quote_qty,
+        max_base_qty: max_base_qty_scaled,
+        max_quote_qty: max_quote_qty_scaled,
         limit_price,
         side: FromPrimitive::from_u8(*side).unwrap(),
         match_limit: *match_limit,
@@ -245,6 +250,15 @@ pub(crate) fn process(
         Ok(s) => s,
     };
 
+    order_summary.total_base_qty = order_summary
+        .total_base_qty
+        .checked_mul(market_state.base_currency_multiplier)
+        .unwrap();
+    order_summary.total_quote_qty = order_summary
+        .total_quote_qty
+        .checked_mul(market_state.quote_currency_multiplier)
+        .unwrap();
+
     let referral_fee = fee_tier.referral_fee(order_summary.total_quote_qty);
     let royalties_fees = order_summary
         .total_quote_qty
@@ -259,18 +273,12 @@ pub(crate) fn process(
                 order_summary.total_quote_qty +=
                     fee_tier.taker_fee(order_summary.total_quote_qty) + royalties_fees;
 
-                let is_valid = order_summary.total_base_qty >= base_qty;
+                let is_valid = &order_summary.total_base_qty >= base_qty;
 
                 (
                     is_valid,
-                    order_summary
-                        .total_base_qty
-                        .checked_mul(market_state.base_currency_multiplier)
-                        .unwrap(),
-                    order_summary
-                        .total_quote_qty
-                        .checked_mul(market_state.quote_currency_multiplier)
-                        .unwrap(),
+                    order_summary.total_base_qty,
+                    order_summary.total_quote_qty,
                 )
             }
             Side::Ask => {
@@ -280,14 +288,10 @@ pub(crate) fn process(
 
                 (
                     is_valid,
-                    order_summary
-                        .total_base_qty
-                        .checked_mul(market_state.base_currency_multiplier)
-                        .unwrap(),
+                    order_summary.total_base_qty,
                     order_summary
                         .total_quote_qty
                         .checked_sub(taker_fee + royalties_fees)
-                        .and_then(|n| n.checked_mul(market_state.quote_currency_multiplier))
                         .unwrap(),
                 )
             }