Merge and integrate refund mechanism with subscription pausing

Author: Caleb Peterson

contracts/src/lib.rs

@@ -6,10 +6,10 @@ use soroban_sdk::{contract, contractimpl, contracttype, Address, Env, String, Ve
 #[contracttype]
 #[derive(Clone, Debug, PartialEq)]
 pub enum Interval {
-    Weekly,      // 604800s
-    Monthly,     // 2592000s (30 days)
-    Quarterly,   // 7776000s (90 days)
-    Yearly,      // 31536000s (365 days)
+    Weekly,    // 604800s
+    Monthly,   // 2592000s (30 days)
+    Quarterly, // 7776000s (90 days)
+    Yearly,    // 31536000s (365 days)
 }
 
 const MAX_PAUSE_DURATION: u64 = 2_592_000; // 30 days
@@ -63,6 +63,7 @@ pub struct Subscription {
     pub total_paid: i128,
     pub paused_at: u64,
     pub pause_duration: u64,
+    pub refund_requested_amount: i128,
 }
 
 #[contracttype]
@@ -215,6 +216,7 @@ impl SubTrackrContract {
             total_paid: 0,
             paused_at: 0,
             pause_duration: 0,
+            refund_requested_amount: 0,
         };
 
         env.storage()
@@ -379,6 +381,8 @@ impl SubTrackrContract {
             .get(&DataKey::Subscription(subscription_id))
             .expect("Subscription not found");
 
+        sub.subscriber.require_auth();
+
         // Handle auto-resume if needed
         if Self::check_and_resume_internal(&env, &mut sub) {
             env.storage()
@@ -414,6 +418,108 @@ impl SubTrackrContract {
             .set(&DataKey::Subscription(subscription_id), &sub);
     }
 
+    /// Request a refund for a subscription (can only be called by the subscriber)
+    pub fn request_refund(env: Env, subscription_id: u64, amount: i128) {
+        let mut sub: Subscription = env
+            .storage()
+            .persistent()
+            .get(&DataKey::Subscription(subscription_id))
+            .expect("Subscription not found");
+
+        sub.subscriber.require_auth();
+
+        assert!(amount > 0, "Refund amount must be positive");
+        assert!(
+            amount <= sub.total_paid,
+            "Refund amount cannot exceed total paid"
+        );
+
+        sub.refund_requested_amount = amount;
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::Subscription(subscription_id), &sub);
+
+        // Publish event
+        env.events().publish(
+            (String::from_str(&env, "refund_requested"), subscription_id),
+            (sub.subscriber.clone(), amount),
+        );
+    }
+
+    /// Approve a refund (can only be called by the admin)
+    pub fn approve_refund(env: Env, subscription_id: u64) {
+        let mut sub: Subscription = env
+            .storage()
+            .persistent()
+            .get(&DataKey::Subscription(subscription_id))
+            .expect("Subscription not found");
+
+        let admin: Address = env
+            .storage()
+            .instance()
+            .get(&DataKey::Admin)
+            .expect("Admin not set");
+        admin.require_auth();
+
+        let amount = sub.refund_requested_amount;
+        assert!(amount > 0, "No pending refund request");
+
+        let _plan: Plan = env
+            .storage()
+            .persistent()
+            .get(&DataKey::Plan(sub.plan_id))
+            .expect("Plan not found");
+
+        // TODO: Execute actual token transfer from merchant back to subscriber
+        // token::Client::new(&env, &plan.token).transfer(
+        //     &plan.merchant, &sub.subscriber, &amount
+        // );
+
+        sub.total_paid -= amount;
+        sub.refund_requested_amount = 0;
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::Subscription(subscription_id), &sub);
+
+        // Publish event
+        env.events().publish(
+            (String::from_str(&env, "refund_approved"), subscription_id),
+            (sub.subscriber.clone(), amount),
+        );
+    }
+
+    /// Reject a refund (can only be called by the admin)
+    pub fn reject_refund(env: Env, subscription_id: u64) {
+        let mut sub: Subscription = env
+            .storage()
+            .persistent()
+            .get(&DataKey::Subscription(subscription_id))
+            .expect("Subscription not found");
+
+        let admin: Address = env
+            .storage()
+            .instance()
+            .get(&DataKey::Admin)
+            .expect("Admin not set");
+        admin.require_auth();
+
+        assert!(sub.refund_requested_amount > 0, "No pending refund request");
+
+        sub.refund_requested_amount = 0;
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::Subscription(subscription_id), &sub);
+
+        // Publish event
+        env.events().publish(
+            (String::from_str(&env, "refund_rejected"), subscription_id),
+            sub.subscriber.clone(),
+        );
+    }
+
     // ── Queries ──
 
     /// Get plan details
@@ -653,7 +759,10 @@ mod test {
         client.resume_subscription(&subscriber, &sub_id);
         let resumed = client.get_subscription(&sub_id);
         assert_eq!(resumed.status, SubscriptionStatus::Active);
-        assert_eq!(resumed.next_charge_at, env.ledger().timestamp() + Interval::Monthly.seconds());
+        assert_eq!(
+            resumed.next_charge_at,
+            env.ledger().timestamp() + Interval::Monthly.seconds()
+        );
         assert!(resumed.next_charge_at > initial.next_charge_at);
     }
 
@@ -696,8 +805,33 @@ mod test {
             li.timestamp += Interval::Monthly.seconds();
         });
         client.charge_subscription(&sub_id);
-        
+
         let charged = client.get_subscription(&sub_id);
         assert_eq!(charged.total_paid, 500);
     }
+
+    #[test]
+    fn test_refund_flow() {
+        let env = Env::default();
+        let (client, _admin, _merchant, subscriber, _token) = setup(&env);
+        let sub_id = client.subscribe(&subscriber, &1);
+
+        // Charge the subscription at month 1
+        env.ledger().set_timestamp(86_400 * 31);
+        client.charge_subscription(&sub_id);
+
+        let sub = client.get_subscription(&sub_id);
+        assert_eq!(sub.total_paid, 500);
+
+        // Request refund
+        client.request_refund(&sub_id, &200);
+        let sub = client.get_subscription(&sub_id);
+        assert_eq!(sub.refund_requested_amount, 200);
+
+        // Approve refund
+        client.approve_refund(&sub_id);
+        let sub = client.get_subscription(&sub_id);
+        assert_eq!(sub.total_paid, 300);
+        assert_eq!(sub.refund_requested_amount, 0);
+    }
 }