feat(subscription): Implement Subscription Service with USDC Payment and Ledger Standardization

Author: dharapandya85

contracts/assetsup/src/errors.rs

@@ -0,0 +1,20 @@
+use soroban_sdk::{contracterror};
+
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[repr(u32)]
+pub enum ContractError{
+    //general errors
+    Unauthorized=100,
+    AlreadyInitialized=101,
+
+    //Subscription errors
+    SubscriptionAlreadyExists=200,
+    SubscriptionNotFound=201,
+    SubscriptionNotActive=202,
+    SubscriptionActive=203,
+
+    //Payment errors
+    InsufficientPayment=300,
+    PaymentFailed=301,
+}

contracts/assetsup/src/lib.rs

@@ -1,11 +1,15 @@
 #![no_std]
-use soroban_sdk::{Address, Env, contract, contractimpl, contracttype};
+use soroban_sdk::{Address, Env, BytesN,contract, contractimpl};
+
+//Import types and modules
+mod errors;
+mod types;
+mod subscription;
+
+//Import types and contract logic
+use crate::types::DataKey;
+use crate::subscription::{SubscriptionContract, SubscriptionService};
 
-#[contracttype]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum DataKey {
-    Admin,
-}
 
 #[contract]
 pub struct AssetUpContract;
@@ -24,6 +28,29 @@ impl AssetUpContract {
     pub fn get_admin(env: Env) -> Address {
         env.storage().persistent().get(&DataKey::Admin).unwrap()
     }
-}
 
-mod tests;
+    //creates a new subscription
+    pub fn create_subscription(
+        env: Env,
+        id: BytesN<32>,
+        user: Address,
+        plan: crate::types::PlanType,
+        payment_token: Address,
+        duration_days: u32,
+    ) ->Result<crate::types::Subscription, errors::ContractError>{
+        SubscriptionService::create_subscription(env, id, user, plan, payment_token, duration_days)
+    } 
+    /// Cancels an active subscription.
+    pub fn cancel_subscription(env: Env, id:soroban_sdk::BytesN<32>) -> Result<crate::types::Subscription, errors::ContractError>{
+        SubscriptionService::cancel_subscription(env, id)
+    }
+    /// Retrieves subscription details.
+    pub fn get_subscription(env: Env, id:soroban_sdk::BytesN<32>) -> Result<crate::types::Subscription, errors::ContractError>{
+        SubscriptionService::get_subscription(env, id)
+    }
+}
+//export contract name for testing in other modules
+#[cfg(test)]
+mod tests{
+    
+}

contracts/assetsup/src/subscription.rs

@@ -0,0 +1,130 @@
+use soroban_sdk::{
+    contractimpl, token, Address, BytesN, Env,
+};
+use crate::errors::ContractError;
+use crate::types::{DataKey, PlanType, Subscription, SubscriptionStatus};
+
+const LEDGERS_PER_DAY: u32 = 17280; //constants for ledgers
+
+/// Trait defining the public contract interface for subscription operations.
+pub trait SubscriptionContract {
+    /// Creates a new subscription for a user.
+    /// 
+    /// # Arguments
+    fn create_subscription(
+        env: Env,
+        id: BytesN<32>,
+        user: Address,
+        plan: PlanType,
+        payment_token: Address,
+        duration_days: u32,
+    ) -> Result<Subscription, ContractError>;
+    /// Cancels an active subscription.
+    fn cancel_subscription(
+        env: Env,
+        id: BytesN<32>,
+    ) -> Result<Subscription, ContractError>;
+    /// Retrives the details of a subscription 
+    fn get_subscription(
+        env: Env,
+        id: BytesN<32>,
+    ) -> Result<Subscription, ContractError>;
+}
+pub struct SubscriptionService;
+
+impl SubscriptionContract for SubscriptionService {
+    fn create_subscription(
+        env: Env,
+        id: BytesN<32>,
+        user: Address,
+        plan: PlanType,
+        payment_token: Address,
+        duration_days: u32,
+    ) -> Result<Subscription, ContractError> {
+        // 1. Authorization check
+        user.require_auth();
+
+        // 2. Existence check
+        let sub_key = DataKey::Subscription(id.clone());
+        if env.storage().persistent().has(&sub_key) {
+            return Err(ContractError::SubscriptionAlreadyExists);
+        }
+
+        // 3. Payment Logic
+        let token_client = token::Client::new(&env, &payment_token);
+        let amount=plan.get_price_7_decimal();
+        let recipient=env.current_contract_address();
+
+        // simualate token transfer from user to contract(payment)
+        //User has executed an 'approve' call on the token contract
+        //The contract pulls the token
+        token_client.transfer_from(&user,&user, &recipient, &amount);
+
+        // 4. Calculate Dates
+        let current_ledger=env.ledger().sequence();
+        //let seconds_in_day=24*60*60;
+        //let ledgers_in_day=seconds_in_day/env.ledger().close_time_resolution();
+        let duration_ledgers= duration_days.checked_mul(LEDGERS_PER_DAY).unwrap_or(u32::MAX); //for simplicity, 1 day=1 ledger
+
+        let start_date=current_ledger;
+        let end_date=current_ledger.checked_add(duration_ledgers).unwrap_or(u32::MAX);
+
+        // 5. Create and store subscription object
+        let new_subscription = Subscription {
+            id: id.clone(),
+            user: user,
+            plan: plan,
+            status: SubscriptionStatus::Active,
+            payment_token: payment_token,
+            start_date: start_date,
+            end_date:end_date,
+        };
+
+        env.storage().persistent().set(&sub_key, &new_subscription);
+
+        Ok(new_subscription)
+    }
+
+    fn cancel_subscription(
+        env: Env,
+        id: BytesN<32>,
+    ) -> Result<Subscription, ContractError> {
+        let sub_key = DataKey::Subscription(id.clone());
+
+        //1. Retrieve subscription
+        let mut subscription: Subscription = env
+            .storage()
+            .persistent()
+            .get(&sub_key)
+            .ok_or(ContractError::SubscriptionNotFound)?;
+
+        //2. Authorization check(only the subscriber can cancel)
+        subscription.user.require_auth();
+
+        // 3. Status check
+        if subscription.status != SubscriptionStatus::Active {
+            return Err(ContractError::SubscriptionNotActive);
+        }
+
+        // 4. Update status and date
+        subscription.status = SubscriptionStatus::Cancelled;
+        subscription.end_date = env.ledger().sequence(); //end immediately
+        
+        // 5.Store update
+        env.storage().persistent().set(&sub_key, &subscription);
+
+        Ok(subscription)
+    }
+
+    fn get_subscription(
+        env: Env,
+        id: BytesN<32>,
+    ) -> Result<Subscription, ContractError> {
+        let sub_key = DataKey::Subscription(id.clone());
+        env.storage()
+            .persistent()
+            .get(&sub_key)
+            .ok_or(ContractError::SubscriptionNotFound)
+
+    }
+}

contracts/assetsup/src/tests/common.rs

@@ -0,0 +1,37 @@
+#![cfg(test)]
+
+extern crate std;
+use soroban_sdk::{
+    testutils::Address as _,
+    token,
+    vec,
+    Address, Env
+};
+
+use crate::{AssetUpContractClient, AssetUpContract};
+
+/// Helper to set up the contract and environment specifically for subscription tests.
+pub fn setup_subscription_test_env()->(Env, AssetUpContractClient<'static>, Address, token::Client) {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    //set ledger state for predictable date/time logic
+    env.ledger().set_sequence(100);
+    env.ledger().set_close_time_resolution(5); // 5 seconds per ledger
+    
+    let contract_id = env.register_contract(None, AssetUpContract);
+    let client = AssetUpContractClient::new(&env, &contract_id);
+    let admin= Address::generate(&env);
+
+    //Initialize contract
+    client.initialize(&admin);
+
+    //MOck token setup(USDC)
+    let admin = Address::generate(&env);
+    // Use token::StellarAsset for a standard token mock 
+    let token_contract_id = env.register_contract_wasm(&token_admin, token::StellarAssetContract);
+    let token_client=token::Client::new(&env, &token_contract_id);
+
+    (env,client,admin, token_client)
+
+}

contracts/assetsup/src/tests/contract_init.rs

@@ -0,0 +1,37 @@
+#![cfg(test)]
+
+extern crate std;
+
+use crate::{AssetUpContract, AssetUpContractClient};
+use soroban_sdk::{Address, Env, testutils::Address as _};
+
+/// Setup text environment with contract and addresses
+
+pub fn setup_test_environment() -> (Env, AssetUpContractClient<'static>, Address) {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = env.register_contract(None, AssetUpContract);
+    let client = AssetUpContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+
+    (env, client, admin)
+}
+
+#[test]
+fn test_initialize() {
+    let (_env, client, admin) = setup_test_environment();
+    client.initialize(&admin);
+    let saved_admin = client.get_admin();
+
+    assert_eq!(admin, saved_admin);
+}
+
+#[test]
+#[should_panic(expected="Contract is already initialized")]
+fn test_initialize_panic() {
+    let (_env, client, admin) = setup_test_environment();
+    client.initialize(&admin);
+    client.initialize(&admin);
+}