Feature/revenue service fee

contracts/payment-vault-contract/src/contract.rs

@@ -41,6 +41,23 @@ pub fn unpause(env: &Env) -> Result<(), VaultError> {
     Ok(())
 }
 
+pub fn set_fee(env: &Env, new_fee_bps: u32) -> Result<(), VaultError> {
+    let admin = storage::get_admin(env).ok_or(VaultError::NotInitialized)?;
+    admin.require_auth();
+    if new_fee_bps > 2000 {
+        return Err(VaultError::FeeTooHigh);
+    }
+    storage::set_fee_bps(env, new_fee_bps);
+    Ok(())
+}
+
+pub fn set_treasury(env: &Env, treasury: &Address) -> Result<(), VaultError> {
+    let admin = storage::get_admin(env).ok_or(VaultError::NotInitialized)?;
+    admin.require_auth();
+    storage::set_treasury(env, treasury);
+    Ok(())
+}
+
 pub fn set_my_rate(env: &Env, expert: &Address, rate_per_second: i128) -> Result<(), VaultError> {
     expert.require_auth();
 
@@ -221,32 +238,34 @@ pub fn finalize_session(
         return Err(VaultError::BookingNotPending);
     }
 
-    // 4. Calculate payments.
-    // rate_per_second is stored in atomic units of the payment token, so this
-    // multiplication is safe for any token precision as long as the product fits i128.
-    let expert_pay = booking
-        .rate_per_second
-        .checked_mul(actual_duration as i128)
-        .ok_or(VaultError::Overflow)?;
-    let refund = booking.total_deposit - expert_pay;
+    // 4. Calculate payments
+    let gross_expert_pay = booking.rate_per_second * (actual_duration as i128);
+    let refund = booking.total_deposit - gross_expert_pay;
 
-    // Ensure calculations are valid
-    if expert_pay < 0 || refund < 0 {
+    if gross_expert_pay < 0 || refund < 0 {
         return Err(VaultError::InvalidAmount);
     }
 
+    let fee_bps = storage::get_fee_bps(env);
+    let fee_amount = (gross_expert_pay * fee_bps as i128) / 10_000;
+    let expert_net_pay = gross_expert_pay - fee_amount;
+
     // 5. Get token contract
     let token_address = storage::get_token(env);
     let token_client = token::Client::new(env, &token_address);
     let contract_address = env.current_contract_address();
 
     // 6. Execute transfers
-    // Pay expert
-    if expert_pay > 0 {
-        token_client.transfer(&contract_address, &booking.expert, &expert_pay);
+    if fee_amount > 0 {
+        if let Some(treasury) = storage::get_treasury(env) {
+            token_client.transfer(&contract_address, &treasury, &fee_amount);
+        }
+    }
+
+    if expert_net_pay > 0 {
+        token_client.transfer(&contract_address, &booking.expert, &expert_net_pay);
     }
 
-    // Refund user
     if refund > 0 {
         token_client.transfer(&contract_address, &booking.user, &refund);
     }
@@ -255,7 +274,7 @@ pub fn finalize_session(
     storage::update_booking_status(env, booking_id, BookingStatus::Complete);
 
     // 8. Emit SessionFinalized event
-    events::session_finalized(env, booking_id, actual_duration, expert_pay);
+    events::session_finalized(env, booking_id, actual_duration, expert_net_pay, fee_amount);
 
     Ok(())
 }

contracts/payment-vault-contract/src/error.rs

@@ -16,6 +16,7 @@ pub enum VaultError {
     ExpertNotVerified = 10,
     SessionAlreadyStarted = 11,
     Overflow = 12,
+    FeeTooHigh = 13,
     BookingNotDisputed = 13,
     RemainderAlreadyRecovered = 14,
 }

contracts/payment-vault-contract/src/events.rs

@@ -15,9 +15,9 @@ pub fn booking_created(
 }
 
 /// Emitted when a session is finalized
-pub fn session_finalized(env: &Env, booking_id: u64, actual_duration: u64, total_cost: i128) {
+pub fn session_finalized(env: &Env, booking_id: u64, actual_duration: u64, expert_pay: i128, fee_amount: i128) {
     let topics = (symbol_short!("finalized"), booking_id);
-    env.events().publish(topics, (actual_duration, total_cost));
+    env.events().publish(topics, (actual_duration, expert_pay, fee_amount));
 }
 
 pub fn session_reclaimed(env: &Env, booking_id: u64, amount: i128) {

contracts/payment-vault-contract/src/lib.rs

@@ -39,6 +39,14 @@ impl PaymentVaultContract {
         contract::unpause(&env)
     }
 
+    pub fn set_fee(env: Env, new_fee_bps: u32) -> Result<(), VaultError> {
+        contract::set_fee(&env, new_fee_bps)
+    }
+
+    pub fn set_treasury(env: Env, treasury: Address) -> Result<(), VaultError> {
+        contract::set_treasury(&env, &treasury)
+    }
+
     /// Transfer admin rights to a new address (Admin-only)
     /// Old admin instantly loses all privileges
     pub fn transfer_admin(env: Env, new_admin: Address) -> Result<(), VaultError> {

contracts/payment-vault-contract/src/storage.rs

@@ -12,6 +12,8 @@ pub enum DataKey {
     BookingCounter,          // Counter for generating unique booking IDs
     UserBookings(Address),   // User Address -> Vec<u64> of booking IDs
     ExpertBookings(Address), // Expert Address -> Vec<u64> of booking IDs
+    FeeBps,
+    Treasury,
     IsPaused,                // Circuit breaker flag
     // ── Indexed User Booking List ──────────────────────────────────────────
     // Replaces the old Vec<u64> approach with O(1) per-write composite keys.
@@ -231,3 +233,24 @@ pub fn get_expert_rate(env: &Env, expert: &Address) -> Option<i128> {
         .persistent()
         .get(&DataKey::ExpertRate(expert.clone()))
 }
+
+// --- Fee BPS ---
+pub fn set_fee_bps(env: &Env, fee_bps: u32) {
+    env.storage().instance().set(&DataKey::FeeBps, &fee_bps);
+}
+
+pub fn get_fee_bps(env: &Env) -> u32 {
+    env.storage()
+        .instance()
+        .get(&DataKey::FeeBps)
+        .unwrap_or(0)
+}
+
+// --- Treasury ---
+pub fn set_treasury(env: &Env, treasury: &Address) {
+    env.storage().instance().set(&DataKey::Treasury, treasury);
+}
+
+pub fn get_treasury(env: &Env) -> Option<Address> {
+    env.storage().instance().get(&DataKey::Treasury)
+}