Fix qty calculation bug. Refactor mulitplier logic.

Author: aubBrooks919

program/src/processor/cancel_order.rs

@@ -163,17 +163,8 @@ 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_base_qty_posted = order_summary
-        .total_base_qty_posted
-        .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)
+    market_state
+        .unscale_order_summary(&mut order_summary)
         .unwrap();
 
     match side {

program/src/processor/new_order.rs

@@ -2,8 +2,8 @@
 use crate::{
     error::DexError,
     state::{CallBackInfo, DexState, FeeTier, Order, UserAccount},
+    utils::check_account_owner,
     utils::{check_account_key, check_signer},
-    utils::{check_account_owner, fp32_mul},
 };
 use agnostic_orderbook::error::AoError;
 use agnostic_orderbook::state::Side;
@@ -235,8 +235,6 @@ 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)?;
 
-    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 {
         msg!("The base order size is too small.");
@@ -262,11 +260,10 @@ 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_base_qty_scaled,
-        max_quote_qty: max_quote_qty_scaled,
+        max_base_qty: market_state.scale_base_amount(*max_base_qty),
+        max_quote_qty: market_state.scale_quote_amount(max_quote_qty),
         limit_price: *limit_price,
         side: FromPrimitive::from_u8(*side).unwrap(),
         match_limit: *match_limit,
@@ -294,25 +291,18 @@ 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_base_qty_posted = order_summary
-        .total_base_qty_posted
-        .checked_mul(market_state.base_currency_multiplier)
+    market_state
+        .unscale_order_summary(&mut order_summary)
         .unwrap();
-    order_summary.total_quote_qty = order_summary
-        .total_quote_qty
-        .checked_mul(market_state.quote_currency_multiplier)
+
+    let posted_quote_qty = market_state
+        .get_quote_from_base(order_summary.total_base_qty_posted, *limit_price)
         .unwrap();
 
     let (qty_to_transfer, transfer_destination, referral_fee) =
         match FromPrimitive::from_u8(*side).unwrap() {
             Side::Bid => {
                 // We update the order summary to properly handle the FOK order type
-                let posted_quote_qty =
-                    fp32_mul(order_summary.total_base_qty_posted, *limit_price).unwrap();
                 let matched_quote_qty = order_summary.total_quote_qty - posted_quote_qty;
                 let taker_fee = fee_tier.taker_fee(matched_quote_qty);
                 let royalties_fees = matched_quote_qty
@@ -343,8 +333,6 @@ pub(crate) fn process(
                     .base_token_free
                     .saturating_sub(order_summary.total_base_qty);
                 user_account.header.base_token_locked += order_summary.total_base_qty_posted;
-                let posted_quote_qty =
-                    fp32_mul(order_summary.total_base_qty_posted, *limit_price).unwrap();
                 let taken_quote_qty = order_summary.total_quote_qty - posted_quote_qty;
                 let taker_fee = fee_tier.taker_fee(taken_quote_qty);
                 let royalties_fees = taken_quote_qty
@@ -439,7 +427,7 @@ pub(crate) fn process(
         .saturating_sub(order_summary.total_base_qty_posted);
     user_account.header.accumulated_taker_quote_volume += order_summary
         .total_quote_qty
-        .saturating_sub(fp32_mul(order_summary.total_base_qty_posted, *limit_price).unwrap());
+        .saturating_sub(posted_quote_qty);
 
     Ok(())
 }

program/src/processor/swap.rs

@@ -177,8 +177,6 @@ pub(crate) fn process(
 
     let market_state = DexState::get(accounts.market)?;
 
-    let base_qty_scaled = base_qty / market_state.base_currency_multiplier;
-
     // Check the order size
     if base_qty < &market_state.min_base_order_size {
         msg!("The base order size is too small.");
@@ -199,7 +197,6 @@ 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(
@@ -213,10 +210,10 @@ pub(crate) fn process(
         match FromPrimitive::from_u8(*side).unwrap() {
             Side::Bid => (
                 u64::MAX,
-                quote_qty_scaled,
+                market_state.scale_quote_amount(quote_qty),
                 u64::MAX - (u64::MAX % tick_size),
             ),
-            Side::Ask => (base_qty_scaled, u64::MAX, 0),
+            Side::Ask => (market_state.scale_base_amount(*base_qty), u64::MAX, 0),
         };
 
     let invoke_params = agnostic_orderbook::instruction::new_order::Params {
@@ -250,17 +247,8 @@ 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_base_qty_posted = order_summary
-        .total_base_qty_posted
-        .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)
+    market_state
+        .unscale_order_summary(&mut order_summary)
         .unwrap();
 
     let referral_fee = fee_tier.referral_fee(order_summary.total_quote_qty);

program/src/state.rs

@@ -1,4 +1,4 @@
-use agnostic_orderbook::state::orderbook::CallbackInfo;
+use agnostic_orderbook::state::{orderbook::CallbackInfo, OrderSummary};
 use borsh::{BorshDeserialize, BorshSerialize};
 use bytemuck::{try_cast_slice_mut, try_from_bytes_mut, Pod, Zeroable};
 use num_derive::{FromPrimitive, ToPrimitive};
@@ -109,6 +109,40 @@ impl DexState {
         });
         a
     }
+
+    pub(crate) fn scale_quote_amount(&self, raw_quote_amount: u64) -> u64 {
+        raw_quote_amount / self.quote_currency_multiplier
+    }
+
+    pub(crate) fn scale_base_amount(&self, raw_base_amount: u64) -> u64 {
+        raw_base_amount / self.base_currency_multiplier
+    }
+
+    pub(crate) fn unscale_quote_amount(&self, scaled_quote_amount: u64) -> Option<u64> {
+        scaled_quote_amount.checked_mul(self.quote_currency_multiplier)
+    }
+
+    pub(crate) fn unscale_base_amount(&self, scaled_base_amount: u64) -> Option<u64> {
+        scaled_base_amount.checked_mul(self.base_currency_multiplier)
+    }
+
+    pub(crate) fn unscale_order_summary(&self, order_summary: &mut OrderSummary) -> Option<()> {
+        order_summary.total_base_qty = self.unscale_base_amount(order_summary.total_base_qty)?;
+        order_summary.total_base_qty_posted =
+            self.unscale_base_amount(order_summary.total_base_qty_posted)?;
+        order_summary.total_quote_qty = self.unscale_quote_amount(order_summary.total_quote_qty)?;
+        Some(())
+    }
+
+    pub(crate) fn get_quote_from_base(
+        &self,
+        raw_base_amount: u64,
+        scaled_price_fp32: u64,
+    ) -> Option<u64> {
+        fp32_mul(raw_base_amount, scaled_price_fp32)
+            .and_then(|n| n.checked_mul(self.quote_currency_multiplier))
+            .and_then(|n| n.checked_div(self.base_currency_multiplier))
+    }
 }
 
 /// This header describes a user account's state

program/tests/functional.rs

@@ -533,7 +533,7 @@ async fn test_dex() {
         },
         swap::Params {
             side: agnostic_orderbook::state::Side::Bid as u8,
-            base_qty: 10,
+            base_qty: 10_000,
             quote_qty: 100000,
             match_limit: 10,
             has_discount_token_account: 0,