Feat/payment vault events

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

@@ -1,11 +1,12 @@
-use soroban_sdk::{Address, Env};
-use crate::storage;
+use soroban_sdk::{Address, Env, token};
+use crate::storage::{self, Booking, BookingStatus};
 use crate::error::VaultError;
+use crate::events;
 
 pub fn initialize_vault(
-    env: &Env, 
-    admin: &Address, 
-    token: &Address, 
+    env: &Env,
+    admin: &Address,
+    token: &Address,
     oracle: &Address
 ) -> Result<(), VaultError> {
     // 1. Check if already initialized
@@ -18,5 +19,105 @@ pub fn initialize_vault(
     storage::set_token(env, token);
     storage::set_oracle(env, oracle);
 
+    Ok(())
+}
+
+pub fn create_booking(
+    env: &Env,
+    user: &Address,
+    expert: &Address,
+    rate: i128,
+    booked_duration: u64,
+) -> Result<u64, VaultError> {
+    // Require authorization from the user creating the booking
+    user.require_auth();
+
+    // Validate rate
+    if rate <= 0 {
+        return Err(VaultError::InvalidAmount);
+    }
+
+    // Calculate total deposit
+    let total_deposit = rate * (booked_duration as i128);
+
+    if total_deposit <= 0 {
+        return Err(VaultError::InvalidAmount);
+    }
+
+    // Get the token contract
+    let token_address = storage::get_token(env);
+    let token_client = token::Client::new(env, &token_address);
+
+    // Transfer tokens from user to this contract
+    let contract_address = env.current_contract_address();
+    token_client.transfer(user, &contract_address, &total_deposit);
+
+    // Generate booking ID and create booking
+    let booking_id = storage::get_next_booking_id(env);
+    let booking = Booking {
+        id: booking_id,
+        expert: expert.clone(),
+        user: user.clone(),
+        rate,
+        total_deposit,
+        booked_duration,
+        status: BookingStatus::Pending,
+    };
+
+    // Save booking
+    storage::save_booking(env, &booking);
+
+    Ok(booking_id)
+}
+
+pub fn finalize_session(
+    env: &Env,
+    booking_id: u64,
+    actual_duration: u64,
+) -> Result<(), VaultError> {
+    // 1. Require Oracle authorization
+    let oracle = storage::get_oracle(env);
+    oracle.require_auth();
+
+    // 2. Get booking and verify it exists
+    let booking = storage::get_booking(env, booking_id)
+        .ok_or(VaultError::BookingNotFound)?;
+
+    // 3. Verify booking is in Pending status
+    if booking.status != BookingStatus::Pending {
+        return Err(VaultError::BookingNotPending);
+    }
+
+    // 4. Calculate payments
+    let expert_pay = booking.rate * (actual_duration as i128);
+    let refund = booking.total_deposit - expert_pay;
+
+    // Ensure calculations are valid
+    if expert_pay < 0 || refund < 0 {
+        return Err(VaultError::InvalidAmount);
+    }
+
+    // 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);
+    }
+
+    // Refund user
+    if refund > 0 {
+        token_client.transfer(&contract_address, &booking.user, &refund);
+    }
+
+    // 7. Update booking status to Complete
+    storage::update_booking_status(env, booking_id, BookingStatus::Complete);
+
+    // 8. Emit SessionFinalized event
+    events::session_finalized(env, booking_id, actual_duration, expert_pay);
+
     Ok(())
 }

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

@@ -7,4 +7,7 @@ pub enum VaultError {
     NotInitialized = 1,
     AlreadyInitialized = 2,
     NotAuthorized = 3,
+    BookingNotFound = 4,
+    BookingNotPending = 5,
+    InvalidAmount = 6,
 }

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

@@ -0,0 +1,6 @@
+use soroban_sdk::{Env, symbol_short};
+
+pub fn session_finalized(env: &Env, booking_id: u64, actual_duration: u64, total_cost: i128) {
+    let topics = (symbol_short!("finalized"), booking_id);
+    env.events().publish(topics, (actual_duration, total_cost));
+}

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

@@ -2,6 +2,7 @@
 
 mod contract;
 mod error;
+mod events;
 mod storage;
 #[cfg(test)]
 mod test;
@@ -16,11 +17,33 @@ pub struct PaymentVaultContract;
 impl PaymentVaultContract {
     /// Initialize the vault with the Admin, the Payment Token, and the Oracle (Backend)
     pub fn init(
-        env: Env, 
-        admin: Address, 
-        token: Address, 
+        env: Env,
+        admin: Address,
+        token: Address,
         oracle: Address
     ) -> Result<(), VaultError> {
         contract::initialize_vault(&env, &admin, &token, &oracle)
     }
+
+    /// Create a booking for a consultation session
+    /// User deposits tokens upfront based on rate * booked_duration
+    pub fn create_booking(
+        env: Env,
+        user: Address,
+        expert: Address,
+        rate: i128,
+        booked_duration: u64,
+    ) -> Result<u64, VaultError> {
+        contract::create_booking(&env, &user, &expert, rate, booked_duration)
+    }
+
+    /// Finalize a session (Oracle-only)
+    /// Calculates payments based on actual duration and processes refunds
+    pub fn finalize_session(
+        env: Env,
+        booking_id: u64,
+        actual_duration: u64,
+    ) -> Result<(), VaultError> {
+        contract::finalize_session(&env, booking_id, actual_duration)
+    }
 }

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

@@ -6,6 +6,27 @@ pub enum DataKey {
     Admin,
     Token,
     Oracle,
+    Booking(u64), // Booking ID -> Booking
+    BookingCounter, // Counter for generating unique booking IDs
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum BookingStatus {
+    Pending,
+    Complete,
+}
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct Booking {
+    pub id: u64,
+    pub expert: Address,
+    pub user: Address,
+    pub rate: i128,           // Payment per second
+    pub total_deposit: i128,  // Total amount deposited by user
+    pub booked_duration: u64, // Booked duration in seconds
+    pub status: BookingStatus,
 }
 
 // --- Admin ---
@@ -37,4 +58,36 @@ pub fn set_oracle(env: &Env, oracle: &Address) {
 
 pub fn get_oracle(env: &Env) -> Address {
     env.storage().instance().get(&DataKey::Oracle).unwrap()
+}
+
+// --- Booking Counter ---
+pub fn get_next_booking_id(env: &Env) -> u64 {
+    let current: u64 = env
+        .storage()
+        .instance()
+        .get(&DataKey::BookingCounter)
+        .unwrap_or(0);
+    let next = current + 1;
+    env.storage().instance().set(&DataKey::BookingCounter, &next);
+    next
+}
+
+// --- Bookings ---
+pub fn save_booking(env: &Env, booking: &Booking) {
+    env.storage()
+        .persistent()
+        .set(&DataKey::Booking(booking.id), booking);
+}
+
+pub fn get_booking(env: &Env, booking_id: u64) -> Option<Booking> {
+    env.storage()
+        .persistent()
+        .get(&DataKey::Booking(booking_id))
+}
+
+pub fn update_booking_status(env: &Env, booking_id: u64, status: BookingStatus) {
+    if let Some(mut booking) = get_booking(env, booking_id) {
+        booking.status = status;
+        save_booking(env, &booking);
+    }
 }