Merge pull request #2276 from multiversx/order-book-fungible

Order book refactor (FungiblePayment) + big num proportion methods

Author: andrei-marinica

contracts/examples/order-book/pair/src/common.rs

@@ -15,17 +15,10 @@ pub enum OrderType {
     Sell,
 }
 
-/// TODO: naming conflict with new FungiblePayment type in the framework, switch to that
-#[derive(ManagedVecItem, Clone)]
-pub struct OrderBookFungiblePayment<M: ManagedTypeApi> {
-    pub token_id: TokenId<M>,
-    pub amount: BigUint<M>,
-}
-
 #[derive(ManagedVecItem, Clone)]
 pub struct Transfer<M: ManagedTypeApi> {
     pub to: ManagedAddress<M>,
-    pub payment: OrderBookFungiblePayment<M>,
+    pub payment: FungiblePayment<M>,
 }
 
 #[type_abi]
@@ -52,7 +45,7 @@ pub struct DealConfig {
 #[type_abi]
 #[derive(TopEncode, TopDecode, Clone)]
 pub struct OrderInputParams<M: ManagedTypeApi> {
-    pub amount: BigUint<M>,
+    pub amount: NonZeroBigUint<M>,
     pub match_provider: ManagedAddress<M>,
     pub fee_config: FeeConfig<M>,
     pub deal_config: DealConfig,
@@ -64,8 +57,8 @@ pub struct Order<M: ManagedTypeApi> {
     pub id: u64,
     pub creator: ManagedAddress<M>,
     pub match_provider: ManagedAddress<M>,
-    pub input_amount: BigUint<M>,
-    pub output_amount: BigUint<M>,
+    pub input_amount: NonZeroBigUint<M>,
+    pub output_amount: NonZeroBigUint<M>,
     pub fee_config: FeeConfig<M>,
     pub deal_config: DealConfig,
     pub create_epoch: u64,
@@ -84,7 +77,7 @@ pub trait CommonModule {
     fn new_order(
         &self,
         id: u64,
-        payment: OrderBookFungiblePayment<Self::Api>,
+        payment: FungiblePayment<Self::Api>,
         params: OrderInputParams<Self::Api>,
         order_type: OrderType,
     ) -> Order<Self::Api> {
@@ -101,23 +94,25 @@ pub trait CommonModule {
         }
     }
 
-    fn rule_of_three(&self, part: &BigUint, total: &BigUint, value: &BigUint) -> BigUint {
-        &(part * value) / total
-    }
-
-    fn calculate_fee_amount(&self, amount: &BigUint, fee_config: &FeeConfig<Self::Api>) -> BigUint {
+    fn calculate_fee_amount(
+        &self,
+        amount: &NonZeroBigUint,
+        fee_config: &FeeConfig<Self::Api>,
+    ) -> BigUint {
         match fee_config.fee_type {
             FeeConfigEnum::Fixed => fee_config.fixed_fee.clone(),
-            FeeConfigEnum::Percent => amount * fee_config.percent_fee / PERCENT_BASE_POINTS,
+            FeeConfigEnum::Percent => amount
+                .as_big_uint()
+                .proportion(fee_config.percent_fee, PERCENT_BASE_POINTS),
         }
     }
 
     fn calculate_amount_after_fee(
         &self,
-        amount: &BigUint,
+        amount: &NonZeroBigUint,
         fee_config: &FeeConfig<Self::Api>,
     ) -> BigUint {
-        amount - &self.calculate_fee_amount(amount, fee_config)
+        amount.as_big_uint() - &self.calculate_fee_amount(amount, fee_config)
     }
 
     #[view(getFirstTokenId)]

contracts/examples/order-book/pair/src/orders.rs

@@ -5,8 +5,8 @@ use crate::common::{FEE_PENALTY_INCREASE_EPOCHS, FEE_PENALTY_INCREASE_PERCENT};
 use super::{common, events, validation};
 
 use super::common::{
-    FREE_ORDER_FROM_STORAGE_MIN_PENALTIES, Order, OrderBookFungiblePayment, OrderInputParams,
-    OrderType, PERCENT_BASE_POINTS, Transfer,
+    FREE_ORDER_FROM_STORAGE_MIN_PENALTIES, Order, OrderInputParams, OrderType, PERCENT_BASE_POINTS,
+    Transfer,
 };
 
 #[multiversx_sc::module]
@@ -15,7 +15,7 @@ pub trait OrdersModule:
 {
     fn create_order(
         &self,
-        payment: OrderBookFungiblePayment<Self::Api>,
+        payment: FungiblePayment<Self::Api>,
         params: OrderInputParams<Self::Api>,
         order_type: OrderType,
     ) {
@@ -150,33 +150,35 @@ pub trait OrdersModule:
             "Too early to free order"
         );
 
+        // penalty_count is at least FREE_ORDER_FROM_STORAGE_MIN_PENALTIES (6),
+        // so this cannot be zero
         let penalty_percent = penalty_count * FEE_PENALTY_INCREASE_PERCENT;
-        let penalty_amount = self.rule_of_three(
-            &BigUint::from(penalty_percent),
-            &BigUint::from(PERCENT_BASE_POINTS),
-            &order.input_amount,
-        );
-        let amount = &order.input_amount - &penalty_amount;
-
-        let creator_transfer = Transfer {
-            to: order.creator.clone(),
-            payment: OrderBookFungiblePayment {
-                token_id: token_id.clone(),
-                amount,
-            },
-        };
-        let caller_transfer = Transfer {
-            to: caller.clone(),
-            payment: OrderBookFungiblePayment {
-                token_id,
-                amount: penalty_amount,
-            },
-        };
+
+        let penalty_amount = order
+            .input_amount
+            .as_big_uint()
+            .proportion(penalty_percent, PERCENT_BASE_POINTS);
+
+        let creator_amount = order.input_amount.as_big_uint() - &penalty_amount;
 
         self.orders(order_id).clear();
+
         let mut transfers = ManagedVec::new();
-        transfers.push(creator_transfer);
-        transfers.push(caller_transfer);
+        if let Some(creator_amount_nz) = NonZeroBigUint::new(creator_amount) {
+            let creator_transfer = Transfer {
+                to: order.creator.clone(),
+                payment: FungiblePayment::new(token_id.clone(), creator_amount_nz),
+            };
+            transfers.push(creator_transfer);
+        }
+
+        if let Some(penalty_amount_nz) = NonZeroBigUint::new(penalty_amount) {
+            let caller_transfer = Transfer {
+                to: caller.clone(),
+                payment: FungiblePayment::new(token_id.clone(), penalty_amount_nz),
+            };
+            transfers.push(caller_transfer);
+        }
         self.execute_transfers(transfers);
 
         order
@@ -199,21 +201,23 @@ pub trait OrdersModule:
 
         let penalty_count = (epoch - order.create_epoch) / FEE_PENALTY_INCREASE_EPOCHS;
         let penalty_percent = penalty_count * FEE_PENALTY_INCREASE_PERCENT;
-        let penalty_amount = self.rule_of_three(
-            &BigUint::from(penalty_percent),
-            &BigUint::from(PERCENT_BASE_POINTS),
-            &order.input_amount,
-        );
-        let amount = &order.input_amount - &penalty_amount;
+        let penalty_amount = order
+            .input_amount
+            .as_big_uint()
+            .proportion(penalty_percent, PERCENT_BASE_POINTS);
 
-        let transfer = Transfer {
-            to: caller.clone(),
-            payment: OrderBookFungiblePayment { token_id, amount },
-        };
+        let amount = order.input_amount.as_big_uint() - &penalty_amount;
 
         self.orders(order_id).clear();
+
         let mut transfers = ManagedVec::new();
-        transfers.push(transfer);
+        if let Some(nz_amount) = NonZeroBigUint::new(amount) {
+            let transfer = Transfer {
+                to: caller.clone(),
+                payment: FungiblePayment::new(token_id, nz_amount),
+            };
+            transfers.push(transfer);
+        }
         self.execute_transfers(transfers);
 
         order
@@ -297,8 +301,8 @@ pub trait OrdersModule:
         let mut amount_requested = BigUint::zero();
 
         orders.iter().for_each(|x| {
-            amount_paid += &x.input_amount;
-            amount_requested += &x.output_amount;
+            amount_paid += x.input_amount.as_big_uint();
+            amount_requested += x.output_amount.as_big_uint();
         });
 
         (amount_paid, amount_requested)
@@ -312,54 +316,50 @@ pub trait OrdersModule:
         leftover: BigUint,
     ) -> ManagedVec<Transfer<Self::Api>> {
         let mut transfers: ManagedVec<Self::Api, Transfer<Self::Api>> = ManagedVec::new();
-
-        let mut match_provider_transfer = Transfer {
-            to: self.blockchain().get_caller(),
-            payment: OrderBookFungiblePayment {
-                token_id: token_requested.clone(),
-                amount: BigUint::zero(),
-            },
-        };
+        let mut match_provider_amount_accumulator = BigUint::zero();
 
         for order in orders.iter() {
             let match_provider_amount =
                 self.calculate_fee_amount(&order.output_amount, &order.fee_config);
-            let creator_amount = &order.output_amount - &match_provider_amount;
+            let creator_amount = order.output_amount.as_big_uint() - &match_provider_amount;
 
-            let order_deal = self.rule_of_three(&order.input_amount, &total_paid, &leftover);
-            let match_provider_deal_amount = self.rule_of_three(
-                &order.deal_config.match_provider_percent.into(),
-                &PERCENT_BASE_POINTS.into(),
-                &order_deal,
+            let order_deal = order.input_amount.as_big_uint() * &leftover / &total_paid;
+            let match_provider_deal_amount = order_deal.proportion(
+                order.deal_config.match_provider_percent,
+                PERCENT_BASE_POINTS,
             );
             let creator_deal_amount = &order_deal - &match_provider_deal_amount;
 
             transfers.push(Transfer {
                 to: order.creator.clone(),
-                payment: OrderBookFungiblePayment {
-                    token_id: token_requested.clone(),
-                    amount: creator_amount + creator_deal_amount,
-                },
+                payment: FungiblePayment::new(
+                    token_requested.clone(),
+                    NonZeroBigUint::new_or_panic(creator_amount + creator_deal_amount),
+                ),
             });
 
-            match_provider_transfer.payment.amount +=
-                match_provider_amount + match_provider_deal_amount;
+            match_provider_amount_accumulator += match_provider_amount + match_provider_deal_amount;
+        }
+
+        if match_provider_amount_accumulator > 0 {
+            transfers.push(Transfer {
+                to: self.blockchain().get_caller(),
+                payment: FungiblePayment::new(
+                    token_requested.clone(),
+                    NonZeroBigUint::new_or_panic(match_provider_amount_accumulator),
+                ),
+            });
         }
-        transfers.push(match_provider_transfer);
 
         transfers
     }
 
     fn execute_transfers(&self, transfers: ManagedVec<Transfer<Self::Api>>) {
         for transfer in &transfers {
-            if transfer.payment.amount > 0 {
-                let token_id = transfer.payment.token_id.clone();
-                let amount = NonZeroBigUint::new(transfer.payment.amount.clone()).unwrap();
-                self.tx()
-                    .to(&transfer.to)
-                    .payment(Payment::new(token_id, 0, amount))
-                    .transfer();
-            }
+            self.tx()
+                .to(&transfer.to)
+                .payment(transfer.payment.as_payment_refs())
+                .transfer();
         }
     }
 

contracts/examples/order-book/pair/src/validation.rs

@@ -1,19 +1,16 @@
 use multiversx_sc::imports::*;
 
-use crate::common::{FeeConfig, FeeConfigEnum, OrderBookFungiblePayment};
-
 use super::{
     common,
     common::{
-        FEE_PENALTY_INCREASE_PERCENT, MAX_ORDERS_PER_USER, Order, OrderInputParams,
-        PERCENT_BASE_POINTS,
+        FEE_PENALTY_INCREASE_PERCENT, FeeConfig, FeeConfigEnum, MAX_ORDERS_PER_USER, Order,
+        OrderInputParams, PERCENT_BASE_POINTS,
     },
 };
 
 #[multiversx_sc::module]
 pub trait ValidationModule: common::CommonModule {
     fn require_valid_order_input_amount(&self, params: &OrderInputParams<Self::Api>) {
-        require!(params.amount != BigUint::zero(), "Amount cannot be zero");
         require!(
             self.calculate_fee_amount(
                 &params.amount,
@@ -38,7 +35,7 @@ pub trait ValidationModule: common::CommonModule {
         match params.fee_config.fee_type.clone() {
             FeeConfigEnum::Fixed => {
                 require!(
-                    params.fee_config.fixed_fee < params.amount,
+                    params.fee_config.fixed_fee < *params.amount.as_big_uint(),
                     "Invalid fee config fixed amount"
                 );
             }
@@ -68,7 +65,7 @@ pub trait ValidationModule: common::CommonModule {
         self.require_valid_order_input_deal_config(params);
     }
 
-    fn require_valid_buy_payment(&self) -> OrderBookFungiblePayment<Self::Api> {
+    fn require_valid_buy_payment(&self) -> FungiblePayment<Self::Api> {
         let payment = self.call_value().single();
         let second_token_id = self.second_token_id().get();
         require!(
@@ -80,13 +77,10 @@ pub trait ValidationModule: common::CommonModule {
             "Token id and second token id should be the same"
         );
 
-        OrderBookFungiblePayment {
-            token_id: payment.token_identifier.clone(),
-            amount: payment.amount.as_big_uint().clone(),
-        }
+        FungiblePayment::new(payment.token_identifier.clone(), payment.amount.clone())
     }
 
-    fn require_valid_sell_payment(&self) -> OrderBookFungiblePayment<Self::Api> {
+    fn require_valid_sell_payment(&self) -> FungiblePayment<Self::Api> {
         let payment = self.call_value().single();
         let first_token_id = self.first_token_id().get();
         require!(payment.is_fungible(), "Payment is not a fungible token");
@@ -95,10 +89,7 @@ pub trait ValidationModule: common::CommonModule {
             "Token id and first token id should be the same"
         );
 
-        OrderBookFungiblePayment {
-            token_id: payment.token_identifier.clone(),
-            amount: payment.amount.as_big_uint().clone(),
-        }
+        FungiblePayment::new(payment.token_identifier.clone(), payment.amount.clone())
     }
 
     fn require_valid_match_input_order_ids(&self, order_ids: &ManagedVec<u64>) {

contracts/feature-tests/basic-features/src/big_num_methods.rs

@@ -109,7 +109,7 @@ pub trait BigIntMethods {
     }
 
     #[endpoint]
-    fn bigint_overwrite_i64(&self, bi: BigInt, small: i64) -> BigInt {
+    fn bigint_overwrite_i64(&self, mut bi: BigInt, small: i64) -> BigInt {
         bi.overwrite_i64(small);
         bi
     }

framework/base/src/err_msg.rs

@@ -48,6 +48,7 @@ pub const BIG_UINT_EXCEEDS_SLICE: &str = "big uint as_bytes exceed target slice"
 pub const BIG_UINT_SUB_NEGATIVE: &str = "cannot subtract because result would be negative";
 pub const UNSIGNED_NEGATIVE: &str = "cannot convert to unsigned, number is negative";
 pub const ZERO_VALUE_NOT_ALLOWED: &str = "zero value not allowed";
+pub const PROPORTION_OVERFLOW_ERR: &str = "proportion overflow";
 
 pub const DESERIALIZATION_INVALID_BYTE: &str = "call data deserialization error: not a valid byte";
 pub const DESERIALIZATION_NOT_32_BYTES: &str =