refactoring

Author: hawthorne-abendsen

src/extensions/env_extensions.rs

@@ -7,7 +7,7 @@ use crate::types;
 use types::{error::Error, subscription::Subscription};
 const ADMIN_KEY: &str = "admin";
 const BASE_FEE: &str = "base_fee";
-const LAST_SUBSCRIPTION_ID: &str = "last_subscription_id";
+const LAST_SUBSCRIPTION_ID: &str = "last";
 const TOKEN_KEY: &str = "token";
 
 pub trait EnvExtensions {

src/lib.rs

@@ -9,11 +9,11 @@ use soroban_sdk::{
     Env, Symbol, Vec,
 };
 use types::{
-    config_data::ConfigData, create_subscription::CreateSubscription, error::Error,
-    subscription::Subscription, subscription_status::SubscriptionStatus,
+    contract_config::ContractConfig, error::Error, subscription::Subscription,
+    subscription_init_params::SubscriptionInitParams, subscription_status::SubscriptionStatus,
 };
 
-const SUBS: Symbol = symbol_short!("SUBS");
+const REFLECTOR: Symbol = symbol_short!("reflector");
 
 // 1 day in milliseconds
 const DAY: u64 = 86400 * 1000;
@@ -42,7 +42,7 @@ impl SubscriptionContract {
     // # Panics
     //
     // Panics if the contract is already initialized
-    pub fn config(e: Env, config: ConfigData) {
+    pub fn config(e: Env, config: ContractConfig) {
         config.admin.require_auth();
         if e.is_initialized() {
             e.panic_with_error(Error::AlreadyInitialized);
@@ -80,8 +80,10 @@ impl SubscriptionContract {
     // Panics if the caller doesn't match admin address
     pub fn trigger(e: Env, timestamp: u64, trigger_hash: BytesN<32>) {
         e.panic_if_not_admin();
-        e.events()
-            .publish((SUBS, symbol_short!("trigger")), (timestamp, trigger_hash));
+        e.events().publish(
+            (REFLECTOR, symbol_short!("activated")),
+            (timestamp, trigger_hash),
+        );
     }
 
     // Updates the contract source code. Can be invoked only by the admin account.
@@ -113,10 +115,10 @@ impl SubscriptionContract {
         let mut total_charge: u64 = 0;
         let now = now(&e);
         let fee = e.get_fee();
-        let mut deactivated_subscriptions = Vec::new(&e);
+        let mut events = Vec::new(&e);
         for subscription_id in subscription_ids.iter() {
             if let Some(mut subscription) = e.get_subscription(subscription_id) {
-                let days = (now - subscription.last_charge) / DAY;
+                let days = (now - subscription.updated) / DAY;
                 if days == 0 {
                     continue;
                 }
@@ -125,30 +127,39 @@ impl SubscriptionContract {
                     charge = subscription.balance;
                 }
                 subscription.balance -= charge;
-                subscription.last_charge = now;
+                subscription.updated = now;
                 if subscription.balance < fee {
                     // Deactivate the subscription if the balance is less than the fee
                     subscription.status = SubscriptionStatus::Suspended;
-                    deactivated_subscriptions.push_back(subscription_id);
+                    events.push_back((
+                        (
+                            REFLECTOR,
+                            symbol_short!("suspended"),
+                            subscription.owner.clone(),
+                        ),
+                        (now, subscription_id),
+                    ));
                 }
                 e.set_subscription(subscription_id, &subscription);
 
+                events.push_back((
+                    (
+                        REFLECTOR,
+                        symbol_short!("charged"),
+                        subscription.owner,
+                    ),
+                    (now, subscription_id),
+                ));
+
                 total_charge += charge;
             }
         }
         // If there is nothing to charge, return
         if total_charge == 0 {
             return;
         }
-        //Publish the events
-        e.events()
-            .publish((SUBS, symbol_short!("charged")), (now, subscription_ids));
-
-        if !deactivated_subscriptions.is_empty() {
-            e.events().publish(
-                (SUBS, symbol_short!("suspended")),
-                deactivated_subscriptions,
-            );
+        for (event, data) in events.iter() {
+            e.events().publish(event, data);
         }
 
         //Burn the tokens
@@ -177,15 +188,15 @@ impl SubscriptionContract {
     // Panics if the subscription is invalid
     pub fn create_subscription(
         e: Env,
-        new_subscription: CreateSubscription,
+        new_subscription: SubscriptionInitParams,
         amount: u64,
     ) -> (u64, Subscription) {
-        panin_if_not_initialized(&e);
+        panic_if_not_initialized(&e);
         // Check the authorization
         new_subscription.owner.require_auth();
 
         // Check the amount
-        let activation_fee = get_activation_fee(&e);
+        let activation_fee = e.get_fee() * MIN_FEE_FACTOR;
         if amount < activation_fee {
             e.panic_with_error(Error::InvalidAmount);
         }
@@ -194,7 +205,7 @@ impl SubscriptionContract {
             e.panic_with_error(Error::InvalidHeartbeat);
         }
 
-        if new_subscription.threshold == 0 {
+        if new_subscription.threshold == 0 || new_subscription.threshold > 1000 {
             e.panic_with_error(Error::InvalidThreshold);
         }
 
@@ -209,20 +220,20 @@ impl SubscriptionContract {
         let subscription_id = e.get_last_subscription_id() + 1;
         let subscription = Subscription {
             owner: new_subscription.owner,
-            asset1: new_subscription.asset1,
-            asset2: new_subscription.asset2,
+            base: new_subscription.base,
+            quote: new_subscription.quote,
             threshold: new_subscription.threshold,
             heartbeat: new_subscription.heartbeat,
             webhook: new_subscription.webhook,
             balance: amount - activation_fee,
             status: SubscriptionStatus::Active,
-            last_charge: now(&e), // normalize to milliseconds
+            updated: now(&e), // normalize to milliseconds
         };
         e.set_subscription(subscription_id, &subscription);
         e.set_last_subscription_id(subscription_id);
-        let data = (subscription_id, subscription);
+        let data = (subscription_id, subscription.clone());
         e.events()
-            .publish((SUBS, symbol_short!("created")), data.clone());
+            .publish((REFLECTOR, symbol_short!("created"), subscription.owner), data.clone());
         return data;
     }
 
@@ -241,25 +252,24 @@ impl SubscriptionContract {
     // Panics if the subscription does not exist
     // Panics if the token transfer fails
     pub fn deposit(e: Env, from: Address, subscription_id: u64, amount: u64) {
-        panin_if_not_initialized(&e);
+        panic_if_not_initialized(&e);
         from.require_auth();
         if amount == 0 {
             e.panic_with_error(Error::InvalidAmount);
         }
         let mut subscription = e
             .get_subscription(subscription_id)
             .unwrap_or_else(|| panic_with_error!(e, Error::SubscriptionNotFound));
-        let activation_fee = get_activation_fee(&e);
         let mut burn_amount = 0;
-
+        let fee = e.get_fee();
         match subscription.status {
             SubscriptionStatus::Suspended => {
                 // Check if the subscription is suspended
-                if amount < activation_fee {
+                if amount < fee {
                     e.panic_with_error(Error::InvalidAmount);
                 }
                 // Set the activation fee as the burn amount
-                burn_amount = activation_fee;
+                burn_amount = fee;
                 subscription.status = SubscriptionStatus::Active;
             }
             SubscriptionStatus::Cancelled => {
@@ -273,8 +283,10 @@ impl SubscriptionContract {
 
         subscription.balance += amount - burn_amount;
         e.set_subscription(subscription_id, &subscription);
-        e.events()
-            .publish((SUBS, symbol_short!("deposit")), (subscription_id, amount));
+        e.events().publish(
+            (REFLECTOR, symbol_short!("deposited"), subscription.owner.clone()),
+            (subscription_id, subscription, amount),
+        );
     }
 
     // Withdraws funds from the subscription and deactivates it.
@@ -288,7 +300,7 @@ impl SubscriptionContract {
     // # Panics if the subscription is not active
     // # Panics if the token transfer fails
     pub fn cancel(e: Env, subscription_id: u64) {
-        panin_if_not_initialized(&e);
+        panic_if_not_initialized(&e);
         let mut subscription = e
             .get_subscription(subscription_id)
             .unwrap_or_else(|| panic_with_error!(e, Error::SubscriptionNotFound));
@@ -310,7 +322,7 @@ impl SubscriptionContract {
         subscription.balance = 0;
         e.set_subscription(subscription_id, &subscription);
         e.events()
-            .publish((SUBS, symbol_short!("cancelled")), subscription_id);
+            .publish((REFLECTOR, symbol_short!("cancelled"), subscription.owner), subscription_id);
     }
 
     // Gets the subscription by ID.
@@ -327,7 +339,7 @@ impl SubscriptionContract {
     //
     // Panics if the contract is not initialized
     pub fn get_subscription(e: Env, subscription_id: u64) -> Subscription {
-        panin_if_not_initialized(&e);
+        panic_if_not_initialized(&e);
         e.get_subscription(subscription_id)
             .unwrap_or_else(|| panic_with_error!(e, Error::SubscriptionNotFound))
     }
@@ -361,7 +373,7 @@ impl SubscriptionContract {
     //
     // Base fee
     pub fn fee(e: Env) -> u64 {
-        panin_if_not_initialized(&e);
+        panic_if_not_initialized(&e);
         e.get_fee()
     }
 
@@ -371,12 +383,12 @@ impl SubscriptionContract {
     //
     // Token address
     pub fn token(e: Env) -> Address {
-        panin_if_not_initialized(&e);
+        panic_if_not_initialized(&e);
         e.get_token()
     }
 }
 
-fn panin_if_not_initialized(e: &Env) {
+fn panic_if_not_initialized(e: &Env) {
     if !e.is_initialized() {
         panic_with_error!(e, Error::NotInitialized);
     }
@@ -386,10 +398,6 @@ fn get_token_client(e: &Env) -> TokenClient {
     TokenClient::new(e, &e.get_token())
 }
 
-fn get_activation_fee(e: &Env) -> u64 {
-    e.get_fee() * MIN_FEE_FACTOR
-}
-
 fn transfer_tokens_to_current_contract(e: &Env, from: &Address, amount: u64, burn_amount: u64) {
     transfer_tokens(e, from, &e.current_contract_address(), amount);
     if burn_amount > 0 {

src/test.rs

@@ -2,14 +2,14 @@
 
 use super::*;
 use soroban_sdk::{
-    symbol_short, testutils::{Address as _, Events, Ledger, LedgerInfo}, token::StellarAssetClient, vec, Bytes, Env, IntoVal, String
+    symbol_short, testutils::{Address as _, Ledger, LedgerInfo}, token::StellarAssetClient, vec, Bytes, Env, String
 };
 use types::{
-    asset::Asset, config_data::ConfigData, create_subscription::CreateSubscription,
+    asset::Asset, contract_config::ContractConfig, subscription_init_params::SubscriptionInitParams,
     ticker_asset::TickerAsset,
 };
 
-fn init_contract_with_admin<'a>() -> (Env, SubscriptionContractClient<'a>, ConfigData) {
+fn init_contract_with_admin<'a>() -> (Env, SubscriptionContractClient<'a>, ContractConfig) {
     let env = Env::default();
 
     let admin = Address::generate(&env);
@@ -20,7 +20,7 @@ fn init_contract_with_admin<'a>() -> (Env, SubscriptionContractClient<'a>, Confi
 
     let token = env.register_stellar_asset_contract(admin.clone());
 
-    let init_data = ConfigData {
+    let init_data = ContractConfig {
         admin: admin.clone(),
         token,
         fee: 100,
@@ -43,13 +43,13 @@ fn test() {
     let token_client = StellarAssetClient::new(&env, &config.token);
     token_client.mint(&owner, &1000);
 
-    let subscription = CreateSubscription {
+    let subscription = SubscriptionInitParams {
         owner: owner.clone(),
-        asset1: TickerAsset {
+        base: TickerAsset {
             asset: Asset::Other(symbol_short!("BTC")),
             source: String::from_str(&env, "source1"),
         },
-        asset2: TickerAsset {
+        quote: TickerAsset {
             asset: Asset::Other(symbol_short!("ETH")),
             source: String::from_str(&env, "source2"),
         },
@@ -59,42 +59,15 @@ fn test() {
     };
 
     // create subscription
-    let (subscription_id, data) = client.create_subscription(&subscription, &200);
+    let (subscription_id, _) = client.create_subscription(&subscription, &200);
     assert!(subscription_id == 1);
 
-    let mut event = (
-        client.address.clone(),
-        (symbol_short!("SUBS"), symbol_short!("created")).into_val(&env),
-        (1u64, data).into_val(&env),
-    );
-    assert_eq!(
-        vec![&env, env.events().all().last().unwrap()],
-        vec![&env, event]
-    );
-
     let trigger_hash: BytesN<32> = BytesN::from_array(&env, &[0; 32]);
     // heartbeat subscription
     client.trigger(&1u64, &trigger_hash);
-    event = (
-        client.address.clone(),
-        (symbol_short!("SUBS"), symbol_short!("trigger")).into_val(&env),
-        (1u64, trigger_hash).into_val(&env),
-    );
-
-    let trigger_event = vec![&env, env.events().all().last().unwrap()];
-    assert_eq!(trigger_event, vec![&env, event]);
 
     // deposit subscription
     client.deposit(&owner, &1, &100);
-    event = (
-        client.address.clone(),
-        (symbol_short!("SUBS"), symbol_short!("deposit")).into_val(&env),
-        (1u64, 100u64).into_val(&env),
-    );
-    assert_eq!(
-        vec![&env, env.events().all().last().unwrap()],
-        vec![&env, event]
-    );
 
     let mut subs = client.get_subscription(&subscription_id);
     assert_eq!(subs.balance, 200);
@@ -112,7 +85,7 @@ fn test() {
     subs = client.get_subscription(&subscription_id);
     assert_eq!(subs.balance, 0);
     assert_eq!(subs.status, SubscriptionStatus::Suspended);
-    assert_eq!(subs.last_charge, 86400 * 2 * 1000);
+    assert_eq!(subs.updated, 86400 * 2 * 1000);
 
     // deposit subscription to renew
     client.deposit(&owner, &1, &200);

src/types/config_data.rs src/types/contract_config.rssrc/types/config_data.rs renamed to src/types/contract_config.rs

@@ -4,7 +4,7 @@ use soroban_sdk::{contracttype, Address};
 #[derive(Clone, Debug, Eq, PartialEq)]
 
 // The configuration parameters for the contract.
-pub struct ConfigData {
+pub struct ContractConfig {
     // The admin address.
     pub admin: Address,
     // The base asset for the prices.

src/types/mod.rs

@@ -2,6 +2,6 @@ pub mod asset;
 pub mod ticker_asset;
 pub mod subscription;
 pub mod error;
-pub mod config_data;
-pub mod create_subscription;
+pub mod contract_config;
+pub mod subscription_init_params;
 pub mod subscription_status;