Merge pull request #165 from Abdulazeem-code/feature/144-fee-discount-system

feat: Implement tiered fee discounts for merchants based on transacti…

Author: codebestia

contracts/shade/src/components/admin.rs

@@ -131,12 +131,54 @@ pub fn get_fee(env: &Env, token: &Address) -> i128 {
         .unwrap_or(0)
 }
 
-pub fn calculate_fee(env: &Env, token: &Address, amount: i128) -> i128 {
-    let fee_bps: i128 = get_fee(env, token);
-    if fee_bps == 0 {
+pub fn calculate_fee(env: &Env, merchant: &Address, token: &Address, amount: i128) -> i128 {
+    let base_fee = get_fee(env, token);
+    if base_fee == 0 {
         return 0;
     }
-    (amount * fee_bps) / 10_000i128
+
+    let volume = get_merchant_volume(env, merchant);
+    let discount_bps = discount_bps_for_volume(volume);
+
+    if discount_bps > 0 {
+        events::publish_fee_discount_applied_event(
+            env,
+            merchant.clone(),
+            volume,
+            discount_bps,
+            env.ledger().timestamp(),
+        );
+    }
+
+    let fee = amount * base_fee / 10_000;
+    fee - (fee * discount_bps / 10_000)
+}
+
+pub fn get_merchant_volume(env: &Env, merchant: &Address) -> i128 {
+    env.storage()
+        .persistent()
+        .get(&DataKey::MerchantVolume(merchant.clone()))
+        .unwrap_or(0)
+}
+
+pub fn add_merchant_volume(env: &Env, merchant: &Address, amount: i128) {
+    let current = get_merchant_volume(env, merchant);
+    env.storage().persistent().set(
+        &DataKey::MerchantVolume(merchant.clone()),
+        &(current + amount),
+    );
+}
+
+fn discount_bps_for_volume(volume: i128) -> i128 {
+    if volume >= 100_000 {
+        50
+    } else if volume >= 50_000 {
+        25
+    } else if volume >= 10_000 {
+        10
+    } else {
+        0
+    }
 }
 
 pub fn propose_fee(env: &Env, admin: &Address, token: &Address, fee: i128) {

contracts/shade/src/components/invoice.rs

@@ -532,11 +532,11 @@ pub fn pay_invoice_partial(env: &Env, payer: &Address, invoice_id: u64, amount:
         panic_with_error!(env, ContractError::TokenNotAccepted);
     }
 
-    let fee_amount = admin::calculate_fee(env, &invoice.token, amount);
+    let merchant_account_id = merchant::get_merchant_account(env, invoice.merchant_id);
+    let fee_amount = admin::calculate_fee(env, &merchant_account_id, &invoice.token, amount);
     let merchant_amount = amount - fee_amount;
 
     let token_client = token::TokenClient::new(env, &invoice.token);
-    let merchant_account_id = merchant::get_merchant_account(env, invoice.merchant_id);
 
     token_client.transfer(payer, &merchant_account_id, &merchant_amount);
     if fee_amount > 0 {

contracts/shade/src/components/subscription.rs

@@ -47,7 +47,7 @@ pub fn create_subscription_plan(
         panic_with_error!(env, ContractError::TokenNotAccepted);
     }
 
-    let fee_amount = admin::calculate_fee(env, &token, amount);
+    let fee_amount = admin::calculate_fee(env, &merchant, &token, amount);
     if amount < fee_amount {
         panic_with_error!(env, ContractError::InvalidAmount);
     }
@@ -141,7 +141,7 @@ pub fn charge_subscription(env: &Env, subscription_id: u64) {
         panic_with_error!(env, ContractError::ChargeTooEarly);
     }
 
-    let fee = admin::calculate_fee(env, &plan.token, plan.amount);
+    let fee = admin::calculate_fee(env, &plan.merchant, &plan.token, plan.amount);
     let merchant_amount = plan.amount - fee;
 
     let token_client = token::TokenClient::new(env, &plan.token);

contracts/shade/src/events.rs

@@ -356,6 +356,30 @@ pub fn publish_account_restricted_event(
     .publish(env);
 }
 
+#[contractevent]
+pub struct FeeDiscountAppliedEvent {
+    pub merchant: Address,
+    pub volume: i128,
+    pub discount_bps: i128,
+    pub timestamp: u64,
+}
+
+pub fn publish_fee_discount_applied_event(
+    env: &Env,
+    merchant: Address,
+    volume: i128,
+    discount_bps: i128,
+    timestamp: u64,
+) {
+    FeeDiscountAppliedEvent {
+        merchant,
+        volume,
+        discount_bps,
+        timestamp,
+    }
+    .publish(env);
+}
+
 // Kept merchant_amount from your branch AND merchant_account from main — both are useful.
 #[contractevent]
 pub struct InvoicePaidEvent {

contracts/shade/src/interface.rs

@@ -73,6 +73,8 @@ pub trait ShadeTrait {
         merchant_address: Address,
         status: bool,
     );
+    fn calculate_fee(env: Env, merchant: Address, token: Address, amount: i128) -> i128;
+    fn get_merchant_volume(env: Env, merchant: Address) -> i128;
     fn set_merchant_account(env: Env, merchant: Address, account: Address);
     fn get_merchant_account(env: Env, merchant_id: u64) -> Address;
     fn pay_invoice(env: Env, payer: Address, invoice_id: u64);

contracts/shade/src/shade.rs

@@ -238,6 +238,14 @@ impl ShadeTrait for Shade {
         merchant_component::restrict_merchant_account(&env, &caller, &merchant_address, status);
     }
 
+    fn calculate_fee(env: Env, merchant: Address, token: Address, amount: i128) -> i128 {
+        admin_component::calculate_fee(&env, &merchant, &token, amount)
+    }
+
+    fn get_merchant_volume(env: Env, merchant: Address) -> i128 {
+        admin_component::get_merchant_volume(&env, &merchant)
+    }
+
     fn set_merchant_account(env: Env, merchant: Address, account: Address) {
         merchant_component::set_merchant_account(&env, &merchant, &account);
     }

contracts/shade/src/tests/mod.rs

@@ -4,6 +4,7 @@ pub mod test_access_control;
 pub mod test_account_factory;
 pub mod test_admin_payment;
 pub mod test_admin_transfer;
+pub mod test_fee_discount;
 // pub mod test_batch_token_whitelist;
 pub mod test_calculate_fee;
 pub mod test_date_range_filter;

contracts/shade/src/tests/test_calculate_fee.rs

@@ -29,13 +29,19 @@ fn setup(env: &Env) -> (Address, ShadeClient<'_>, Address) {
 #[test]
 fn test_calculate_fee_returns_zero_when_no_fee_set() {
     let env = Env::default();
-    let (_admin, client, token) = setup(&env);
+    let (admin, client, token) = setup(&env);
     let contract_id = client.address.clone();
 
     env.as_contract(&contract_id, || {
-        assert_eq!(admin_component::calculate_fee(&env, &token, 0), 0);
-        assert_eq!(admin_component::calculate_fee(&env, &token, 1_000), 0);
-        assert_eq!(admin_component::calculate_fee(&env, &token, 1_000_000), 0);
+        assert_eq!(admin_component::calculate_fee(&env, &admin, &token, 0), 0);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 1_000),
+            0
+        );
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 1_000_000),
+            0
+        );
     });
 }
 
@@ -49,7 +55,7 @@ fn test_calculate_fee_zero_amount() {
     client.set_fee(&admin, &token, &500); // 5%
 
     env.as_contract(&contract_id, || {
-        assert_eq!(admin_component::calculate_fee(&env, &token, 0), 0);
+        assert_eq!(admin_component::calculate_fee(&env, &admin, &token, 0), 0);
     });
 }
 
@@ -63,7 +69,10 @@ fn test_calculate_fee_5_percent() {
     client.set_fee(&admin, &token, &500);
 
     env.as_contract(&contract_id, || {
-        assert_eq!(admin_component::calculate_fee(&env, &token, 1_000), 50);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 1_000),
+            50
+        );
     });
 }
 
@@ -77,7 +86,10 @@ fn test_calculate_fee_1_percent() {
     client.set_fee(&admin, &token, &100);
 
     env.as_contract(&contract_id, || {
-        assert_eq!(admin_component::calculate_fee(&env, &token, 10_000), 100);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 10_000),
+            100
+        );
     });
 }
 
@@ -91,7 +103,10 @@ fn test_calculate_fee_10_percent() {
     client.set_fee(&admin, &token, &1_000);
 
     env.as_contract(&contract_id, || {
-        assert_eq!(admin_component::calculate_fee(&env, &token, 5_000), 500);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 5_000),
+            500
+        );
     });
 }
 
@@ -105,7 +120,10 @@ fn test_calculate_fee_100_percent() {
     client.set_fee(&admin, &token, &10_000);
 
     env.as_contract(&contract_id, || {
-        assert_eq!(admin_component::calculate_fee(&env, &token, 1_000), 1_000);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 1_000),
+            1_000
+        );
     });
 }
 
@@ -121,10 +139,16 @@ fn test_calculate_fee_truncates_fractional_result() {
 
     env.as_contract(&contract_id, || {
         // Too small to produce a whole unit
-        assert_eq!(admin_component::calculate_fee(&env, &token, 1), 0);
-        assert_eq!(admin_component::calculate_fee(&env, &token, 9_999), 0);
+        assert_eq!(admin_component::calculate_fee(&env, &admin, &token, 1), 0);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 9_999),
+            0
+        );
         // Exactly at the boundary: 10_000 * 1 / 10_000 = 1
-        assert_eq!(admin_component::calculate_fee(&env, &token, 10_000), 1);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 10_000),
+            1
+        );
     });
 }
 
@@ -138,13 +162,19 @@ fn test_calculate_fee_reflects_updated_fee() {
     client.set_fee(&admin, &token, &200); // 2%
 
     env.as_contract(&contract_id, || {
-        assert_eq!(admin_component::calculate_fee(&env, &token, 10_000), 200);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 10_000),
+            200
+        );
     });
 
     client.set_fee(&admin, &token, &500); // updated to 5%
 
     env.as_contract(&contract_id, || {
-        assert_eq!(admin_component::calculate_fee(&env, &token, 10_000), 500);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token, 10_000),
+            500
+        );
     });
 }
 
@@ -160,7 +190,7 @@ fn test_calculate_fee_large_amount() {
 
     env.as_contract(&contract_id, || {
         assert_eq!(
-            admin_component::calculate_fee(&env, &token, 1_000_000_000),
+            admin_component::calculate_fee(&env, &admin, &token, 1_000_000_000),
             25_000_000
         );
     });
@@ -184,7 +214,13 @@ fn test_calculate_fee_per_token_independence() {
     client.set_fee(&admin, &token_b, &700); // 7%
 
     env.as_contract(&contract_id, || {
-        assert_eq!(admin_component::calculate_fee(&env, &token_a, 10_000), 300);
-        assert_eq!(admin_component::calculate_fee(&env, &token_b, 10_000), 700);
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token_a, 10_000),
+            300
+        );
+        assert_eq!(
+            admin_component::calculate_fee(&env, &admin, &token_b, 10_000),
+            700
+        );
     });
 }