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();
 
@@ -155,32 +172,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);
     }
@@ -189,7 +208,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

@@ -13,6 +13,7 @@ pub enum VaultError {
     ReclaimTooEarly = 7,
     ContractPaused = 8,
     ExpertRateNotSet = 9,
+    FeeTooHigh = 11,
     ExpertNotVerified = 10,
     SessionAlreadyStarted = 11,
     Overflow = 12,

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,15 @@ 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)
+    }
+
+    /// Set an expert's own rate per second
     /// 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.
@@ -227,3 +229,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)
+}

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

@@ -685,143 +685,155 @@ fn test_reject_nonexistent_booking() {
     assert!(result.is_err());
 }
 
-// ==================== Key Rotation Tests ====================
+// ==================== Platform Fee Tests ====================
 
 #[test]
-fn test_transfer_admin_success() {
+fn test_set_fee_and_treasury() {
     let env = Env::default();
     env.mock_all_auths();
 
-    let admin_a = Address::generate(&env);
-    let admin_b = Address::generate(&env);
-    let token = Address::generate(&env);
+    let admin = Address::generate(&env);
     let oracle = Address::generate(&env);
-    let registry = Address::generate(&env);
-
-    let client = create_client(&env);
-    client.init(&admin_a, &token, &oracle, &registry);
-
-    // Admin A transfers to Admin B
-    let result = client.try_transfer_admin(&admin_b);
-    assert!(result.is_ok());
-}
-
-#[test]
-fn test_new_admin_can_pause_after_transfer() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let admin_a = Address::generate(&env);
-    let admin_b = Address::generate(&env);
     let token = Address::generate(&env);
-    let oracle = Address::generate(&env);
-    let registry = Address::generate(&env);
+    let treasury = Address::generate(&env);
 
     let client = create_client(&env);
-    client.init(&admin_a, &token, &oracle, &registry);
-    client.transfer_admin(&admin_b);
+    client.init(&admin, &token, &oracle);
+
+    let res = client.try_set_fee(&1000_u32);
+    assert!(res.is_ok());
 
-    // New admin B can pause and unpause
-    assert!(client.try_pause().is_ok());
-    assert!(client.try_unpause().is_ok());
+    let res = client.try_set_treasury(&treasury);
+    assert!(res.is_ok());
 }
 
 #[test]
-fn test_old_admin_loses_privileges_after_transfer() {
+fn test_fee_cap_at_2000_bps() {
     let env = Env::default();
     env.mock_all_auths();
 
-    let admin_a = Address::generate(&env);
-    let admin_b = Address::generate(&env);
-    let token = Address::generate(&env);
+    let admin = Address::generate(&env);
     let oracle = Address::generate(&env);
-    let registry = Address::generate(&env);
+    let token = Address::generate(&env);
 
     let client = create_client(&env);
-    client.init(&admin_a, &token, &oracle, &registry);
-    client.transfer_admin(&admin_b);
+    client.init(&admin, &token, &oracle);
 
-    // Remove all mocked auths — now only explicit auth will pass
-    env.set_auths(&[]);
+    let res = client.try_set_fee(&2000_u32);
+    assert!(res.is_ok());
 
-    // Without any valid auth for admin_b, pause should fail
-    // (admin_b is now the required auth, but no auth is mocked)
-    let result = client.try_pause();
-    assert!(result.is_err());
+    let res = client.try_set_fee(&2001_u32);
+    assert!(res.is_err());
 }
 
 #[test]
-fn test_set_oracle_success() {
+fn test_finalize_with_10_percent_fee() {
     let env = Env::default();
     env.mock_all_auths();
 
     let admin = Address::generate(&env);
-    let token = Address::generate(&env);
-    let oracle_old = Address::generate(&env);
-    let oracle_new = Address::generate(&env);
-    let registry = create_mock_registry(&env);
-
-    let token_admin = Address::generate(&env);
-    let token_contract = create_token_contract(&env, &token_admin);
     let user = Address::generate(&env);
     let expert = Address::generate(&env);
-    token_contract.mint(&user, &10_000);
+    let oracle = Address::generate(&env);
+    let treasury = Address::generate(&env);
+
+    let token_admin = Address::generate(&env);
+    let token = create_token_contract(&env, &token_admin);
+    token.mint(&user, &10_000);
 
     let client = create_client(&env);
-    client.init(&admin, &token_contract.address, &oracle_old, &registry);
+    client.init(&admin, &token.address, &oracle);
 
-    // Book a session
-    client.set_my_rate(&expert, &10_i128);
-    let booking_id = client.book_session(&user, &expert, &100);
+    // 10% fee = 1000 BPS
+    client.set_fee(&1000_u32);
+    client.set_treasury(&treasury);
 
-    // Rotate oracle to new address
-    let result = client.try_set_oracle(&oracle_new);
-    assert!(result.is_ok());
+    // rate = 10/s, max_duration = 100s => deposit = 1000
+    let booking_id = {
+        client.set_my_rate(&expert, &10_i128);
+        client.book_session(&user, &expert, &100_u64)
+    };
 
-    // New oracle can finalize
-    let result = client.try_finalize_session(&booking_id, &50);
-    assert!(result.is_ok());
+    assert_eq!(token.balance(&user), 9_000);
+
+    // finalize at 100s => gross_expert_pay = 1000
+    // fee = 1000 * 1000 / 10000 = 100
+    // expert_net = 900, refund = 0
+    client.finalize_session(&booking_id, &100_u64);
+
+    assert_eq!(token.balance(&treasury), 100);
+    assert_eq!(token.balance(&expert), 900);
+    assert_eq!(token.balance(&user), 9_000);
+    assert_eq!(token.balance(&client.address), 0);
 }
 
 #[test]
-fn test_non_admin_cannot_transfer_admin() {
+fn test_finalize_with_fee_and_partial_refund() {
     let env = Env::default();
     env.mock_all_auths();
 
     let admin = Address::generate(&env);
-    let attacker = Address::generate(&env);
-    let token = Address::generate(&env);
+    let user = Address::generate(&env);
+    let expert = Address::generate(&env);
     let oracle = Address::generate(&env);
-    let registry = Address::generate(&env);
+    let treasury = Address::generate(&env);
+
+    let token_admin = Address::generate(&env);
+    let token = create_token_contract(&env, &token_admin);
+    token.mint(&user, &10_000);
 
     let client = create_client(&env);
-    client.init(&admin, &token, &oracle, &registry);
+    client.init(&admin, &token.address, &oracle);
 
-    // Clear auths so attacker has no authorization
-    env.set_auths(&[]);
+    // 10% fee
+    client.set_fee(&1000_u32);
+    client.set_treasury(&treasury);
 
-    let result = client.try_transfer_admin(&attacker);
-    assert!(result.is_err());
+    // rate = 10/s, max_duration = 100s => deposit = 1000
+    let booking_id = {
+        client.set_my_rate(&expert, &10_i128);
+        client.book_session(&user, &expert, &100_u64)
+    };
+
+    // finalize at 50s => gross_expert_pay = 500
+    // fee = 500 * 1000 / 10000 = 50
+    // expert_net = 450, refund = 500
+    client.finalize_session(&booking_id, &50_u64);
+
+    assert_eq!(token.balance(&treasury), 50);
+    assert_eq!(token.balance(&expert), 450);
+    assert_eq!(token.balance(&user), 9_500);
+    assert_eq!(token.balance(&client.address), 0);
 }
 
 #[test]
-fn test_non_admin_cannot_set_oracle() {
+fn test_finalize_zero_fee_behaves_as_before() {
     let env = Env::default();
     env.mock_all_auths();
 
     let admin = Address::generate(&env);
-    let attacker = Address::generate(&env);
-    let token = Address::generate(&env);
+    let user = Address::generate(&env);
+    let expert = Address::generate(&env);
     let oracle = Address::generate(&env);
-    let registry = Address::generate(&env);
+
+    let token_admin = Address::generate(&env);
+    let token = create_token_contract(&env, &token_admin);
+    token.mint(&user, &10_000);
 
     let client = create_client(&env);
-    client.init(&admin, &token, &oracle, &registry);
+    client.init(&admin, &token.address, &oracle);
 
-    env.set_auths(&[]);
+    let booking_id = {
+        client.set_my_rate(&expert, &10_i128);
+        client.book_session(&user, &expert, &100_u64)
+    };
 
-    let result = client.try_set_oracle(&attacker);
-    assert!(result.is_err());
+    // no fee set (defaults to 0)
+    client.finalize_session(&booking_id, &100_u64);
+
+    assert_eq!(token.balance(&expert), 1_000);
+    assert_eq!(token.balance(&user), 9_000);
+    assert_eq!(token.balance(&client.address), 0);
 }
 
 // ==================== Expert Rate Tests ====================