Merge pull request #90 from Daniel4000-dev/fix-tiny-streams-math

Fix tiny streams math

Author: elizabetheonoja-art

contracts/substream_contracts/src/lib.rs

@@ -1,7 +1,6 @@
 #![no_std]
 #[cfg(test)]
 extern crate std;
-
 use soroban_sdk::token::Client as TokenClient;
 use soroban_sdk::{contract, contractevent, contractimpl, contracttype, vec, Address, Env, Vec};
 
@@ -12,6 +11,7 @@ const GRACE_PERIOD: u64 = 24 * 60 * 60;
 const GENESIS_NFT_ADDRESS: &str = "CAS3J7GYCCX7RRBHAHXDUY3OOWFMTIDDNVGCH6YOY7W7Y7G656H2HHMA";
 const DISCOUNT_BPS: i128 = 2000; 
 const SIX_MONTHS: u64 = 180 * 24 * 60 * 60;
+const PRECISION_MULTIPLIER: i128 = 1_000_000_000;
 
 // --- Helper: Charge Calculation ---
 fn calculate_discounted_charge(start_time: u64, charge_start: u64, now: u64, base_rate: i128) -> i128 {
@@ -74,11 +74,11 @@ pub struct Subscription {
     pub last_collected: u64,
     pub start_time: u64,
     pub last_funds_exhausted: u64,
-    pub free_to_paid_emitted: bool,
-    pub creators: Vec<Address>,
-    pub percentages: Vec<u32>,
+    pub creators: soroban_sdk::Vec<Address>,
+    pub percentages: soroban_sdk::Vec<u32>,
     pub payer: Address,
     pub beneficiary: Address,
+    pub accrued_remainder: i128, // Dust/fractional units that haven't been paid as tokens
 }
 
 #[contracttype]
@@ -232,7 +232,7 @@ impl SubStreamContract {
         TipReceived { user, creator, token, amount }.publish(&env);
     }
 
-    pub fn subscribe_group(env: Env, payer: Address, channel_id: Address, token: Address, amount: i128, rate_per_second: i128, creators: Vec<Address>, percentages: Vec<u32>) {
+    pub fn subscribe_group(env: Env, payer: Address, channel_id: Address, token: Address, amount: i128, rate_per_second: i128, creators: soroban_sdk::Vec<Address>, percentages: soroban_sdk::Vec<u32>) {
         // Validate exactly 5 creators
         if creators.len() != 5 {
             panic!("group channel must contain exactly 5 creators");
@@ -449,17 +449,19 @@ fn distribute_and_collect(env: &Env, beneficiary: &Address, stream_id: &Address,
     }
 
     let available_balance = sub.balance.max(0);
-    let amount_to_payout = amount_to_collect.min(available_balance);
+    let total_accrued = amount_to_collect.saturating_add(sub.accrued_remainder);
+    let amount_to_payout_nano = total_accrued.min(available_balance.saturating_add(sub.accrued_remainder));
+    let amount_to_payout_tokens = amount_to_payout_nano / PRECISION_MULTIPLIER;
 
-    if amount_to_payout > 0 {
+    if amount_to_payout_tokens > 0 {
         let token_client = TokenClient::new(env, &sub.token);
         let creators_len = sub.creators.len();
-        let mut remaining = amount_to_payout;
+        let mut remaining = amount_to_payout_tokens;
 
         for i in 0..creators_len {
             let creator = sub.creators.get(i).unwrap();
             let share = sub.percentages.get(i).unwrap() as i128;
-            let payout = if i + 1 == creators_len { remaining } else { (amount_to_payout * share) / 100 };
+            let payout = if i + 1 == creators_len { remaining } else { (amount_to_payout_tokens * share) / 100 };
             remaining -= payout;
             if payout > 0 {
                 credit_creator_earnings(env, &creator, payout);
@@ -469,6 +471,7 @@ fn distribute_and_collect(env: &Env, beneficiary: &Address, stream_id: &Address,
     }
 
     sub.balance -= amount_to_collect;
+    sub.accrued_remainder = total_accrued - (amount_to_payout_tokens * PRECISION_MULTIPLIER);
     sub.last_collected = now;
     set_subscription(env, &key, &sub);
     amount_to_collect
@@ -482,7 +485,7 @@ fn top_up_internal(env: &Env, beneficiary: &Address, stream_id: &Address, amount
     let token_client = TokenClient::new(env, &sub.token);
     token_client.transfer(&sub.payer, &env.current_contract_address(), &amount);
 
-    sub.balance += amount;
+    sub.balance += amount * PRECISION_MULTIPLIER;
     if sub.balance > 0 { sub.last_funds_exhausted = 0; }
     set_subscription(env, &key, &sub);
     distribute_and_collect(env, beneficiary, stream_id, None);
@@ -500,7 +503,10 @@ fn cancel_internal(env: &Env, beneficiary: &Address, stream_id: &Address) {
 
     if sub.balance > 0 {
         let token_client = TokenClient::new(env, &sub.token);
-        token_client.transfer(&env.current_contract_address(), &sub.payer, &sub.balance);
+        let refund_amount = sub.balance / PRECISION_MULTIPLIER;
+        if refund_amount > 0 {
+            token_client.transfer(&env.current_contract_address(), &sub.payer, &refund_amount);
+        }
     }
     for i in 0..sub.creators.len() {
         let creator = sub.creators.get(i).unwrap();
@@ -510,7 +516,7 @@ fn cancel_internal(env: &Env, beneficiary: &Address, stream_id: &Address) {
     env.storage().temporary().remove(&key);
 }
 
-fn subscribe_core(env: &Env, payer: &Address, beneficiary: &Address, stream_id: &Address, token: &Address, amount: i128, rate: i128, creators: Vec<Address>, percentages: Vec<u32>) {
+fn subscribe_core(env: &Env, payer: &Address, beneficiary: &Address, stream_id: &Address, token: &Address, amount: i128, rate: i128, creators: soroban_sdk::Vec<Address>, percentages: soroban_sdk::Vec<u32>) {
     payer.require_auth();
     let key = subscription_key(beneficiary, stream_id);
     if subscription_exists(env, &key) { panic!("exists"); }
@@ -523,7 +529,7 @@ fn subscribe_core(env: &Env, payer: &Address, beneficiary: &Address, stream_id:
     let sub = Subscription {
         token: token.clone(),
         tier: Tier { rate_per_second: rate, trial_duration: FREE_TRIAL_DURATION },
-        balance: amount,
+        balance: amount * PRECISION_MULTIPLIER,
         last_collected: now,
         start_time: now,
         last_funds_exhausted: 0,
@@ -532,6 +538,7 @@ fn subscribe_core(env: &Env, payer: &Address, beneficiary: &Address, stream_id:
         percentages,
         payer: payer.clone(),
         beneficiary: beneficiary.clone(),
+        accrued_remainder: 0,
     };
     set_subscription(env, &key, &sub);
     for i in 0..creators_for_stats.len() {
@@ -549,3 +556,5 @@ fn is_creator_paused(env: &Env, creator: &Address) -> bool {
 mod test;
 #[cfg(test)]
 mod test_withdrawal_consistency;
+#[cfg(test)]
+mod test_tiny_streams;

contracts/substream_contracts/src/test.rs

@@ -1,4 +1,4 @@
-#![cfg(test)]
+#![cfg(test)]
 
 use super::*;
 use soroban_sdk::{
@@ -41,7 +41,7 @@ fn test_is_subscribed_active() {
     let client = SubStreamContractClient::new(&env, &contract_id);
 
     env.ledger().set_timestamp(100);
-    client.subscribe(&subscriber, &creator, &token.address, &1000, &1);
+    client.subscribe(&subscriber, &creator, &token.address, &1000, &1_000_000_000);
 
     env.ledger().set_timestamp(105);
     assert!(client.is_subscribed(&subscriber, &creator));
@@ -64,7 +64,7 @@ fn test_is_subscribed_expired() {
     let client = SubStreamContractClient::new(&env, &contract_id);
 
     env.ledger().set_timestamp(100);
-    client.subscribe(&subscriber, &creator, &token.address, &10, &10);
+    client.subscribe(&subscriber, &creator, &token.address, &10, &10_000_000_000);
 
     env.ledger().set_timestamp(100 + WEEK + 2);
     assert!(!client.is_subscribed(&subscriber, &creator));
@@ -145,7 +145,7 @@ fn test_free_trial_ignores_claims_within_first_week() {
 
     let start = 100u64;
     env.ledger().set_timestamp(start);
-    client.subscribe(&subscriber, &creator, &token.address, &300, &3);
+    client.subscribe(&subscriber, &creator, &token.address, &300, &3_000_000_000);
 
     env.ledger().set_timestamp(start + WEEK - 1);
     client.collect(&subscriber, &creator);
@@ -207,7 +207,7 @@ fn test_cancel_before_minimum_duration() {
     let client = SubStreamContractClient::new(&env, &contract_id);
 
     env.ledger().set_timestamp(100);
-    client.subscribe(&subscriber, &creator, &token.address, &100, &1);
+    client.subscribe(&subscriber, &creator, &token.address, &100, &1_000_000_000);
 
     env.ledger().set_timestamp(100 + 3600);
     client.cancel(&subscriber, &creator);
@@ -231,7 +231,7 @@ fn test_cancel_after_minimum_duration() {
 
     let start = 100u64;
     env.ledger().set_timestamp(start);
-    client.subscribe(&subscriber, &creator, &token.address, &100, &1);
+    client.subscribe(&subscriber, &creator, &token.address, &100, &1_000_000_000);
 
     env.ledger().set_timestamp(start + DAY + 10);
     client.cancel(&subscriber, &creator);
@@ -257,7 +257,7 @@ fn test_cancel_exactly_at_minimum_duration() {
     let client = SubStreamContractClient::new(&env, &contract_id);
 
     env.ledger().set_timestamp(100);
-    client.subscribe(&subscriber, &creator, &token.address, &100, &1);
+    client.subscribe(&subscriber, &creator, &token.address, &100, &1_000_000_000);
 
     env.ledger().set_timestamp(100 + DAY);
     client.cancel(&subscriber, &creator);
@@ -288,7 +288,7 @@ fn test_top_up() {
     let client = SubStreamContractClient::new(&env, &contract_id);
 
     env.ledger().set_timestamp(0);
-    client.subscribe(&subscriber, &creator, &token.address, &100, &1);
+    client.subscribe(&subscriber, &creator, &token.address, &100, &1_000_000_000);
     assert_eq!(token.balance(&contract_id), 100);
 
     client.top_up(&subscriber, &creator, &50);
@@ -343,7 +343,7 @@ fn test_group_subscribe_and_collect_split() {
         &channel_id,
         &token.address,
         &500,
-        &10,
+        &10_000_000_000,
         &creators,
         &percentages,
     );
@@ -394,7 +394,7 @@ fn test_group_requires_exactly_five_creators() {
         &channel_id,
         &token.address,
         &100,
-        &1,
+        &1_000_000_000,
         &creators,
         &percentages,
     );
@@ -437,7 +437,7 @@ fn test_group_percentages_must_sum_to_100() {
         &channel_id,
         &token.address,
         &100,
-        &1,
+        &1_000_000_000,
         &creators,
         &percentages,
     );
@@ -480,7 +480,7 @@ fn test_group_cancel_collects_and_refunds_remaining_balance() {
         &channel_id,
         &token.address,
         &200,
-        &1,
+        &1_000_000_000,
         &creators,
         &percentages,
     );
@@ -592,7 +592,7 @@ fn test_flash_stream_attack_within_single_ledger() {
     env.ledger().set_timestamp(ledger_time);
 
     // Attacker subscribes with minimal amount to bypass content gates
-    client.subscribe(&attacker, &creator, &token.address, &10, &1);
+    client.subscribe(&attacker, &creator, &token.address, &10, &1_000_000_000);
 
     // Check that subscription is active immediately (within same ledger)
     assert!(client.is_subscribed(&attacker, &creator));
@@ -636,7 +636,7 @@ fn test_flash_stream_attack_multiple_quick_subscriptions() {
         let subscriber = Address::generate(&env);
 
         // Subscribe with minimal amount
-        client.subscribe(&subscriber, &creator, &token.address, &5, &1);
+        client.subscribe(&subscriber, &creator, &token.address, &5, &1_000_000_000);
 
         // Verify subscription is active
         assert!(client.is_subscribed(&subscriber, &creator));
@@ -668,7 +668,7 @@ fn test_flash_stream_attack_grace_period_exploitation() {
     env.ledger().set_timestamp(start_time);
 
     // Subscribe with very small amount that will be exhausted quickly
-    client.subscribe(&attacker, &creator, &token.address, &10, &100);
+    client.subscribe(&attacker, &creator, &token.address, &10, &100_000_000_000);
 
     // Fast forward to exhaust funds but stay within grace period
     let exhaust_time = start_time + 10; // 10 seconds later
@@ -686,7 +686,7 @@ fn test_flash_stream_attack_grace_period_exploitation() {
 
     env.ledger().set_timestamp(exhaust_time + 1); // 1 second later
 
-    client.subscribe(&new_attacker, &creator, &token.address, &5, &1);
+    client.subscribe(&new_attacker, &creator, &token.address, &5, &1_000_000_000);
 
     // Both subscriptions should be active (original in grace period, new one active)
     assert!(client.is_subscribed(&attacker, &creator));
@@ -722,7 +722,7 @@ fn test_blacklist_user_prevents_subscription() {
 
     // Attempt to subscribe should fail
     let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-        client.subscribe(&malicious_user, &creator, &token.address, &100, &1);
+        client.subscribe(&malicious_user, &creator, &token.address, &100, &1_000_000_000);
     }));
 
     assert!(result.is_err());
@@ -754,7 +754,7 @@ fn test_unblacklist_user_allows_subscription() {
     assert!(!client.is_user_blacklisted(&creator, &user));
 
     // Now subscription should work
-    client.subscribe(&user, &creator, &token.address, &100, &1);
+    client.subscribe(&user, &creator, &token.address, &100, &1_000_000_000);
     assert!(client.is_subscribed(&user, &creator));
 }
 
@@ -835,7 +835,7 @@ fn test_blacklist_prevents_group_subscription() {
             &channel_id,
             &token.address,
             &100,
-            &1,
+            &1_000_000_000,
             &creators,
             &percentages,
         );
@@ -871,12 +871,12 @@ fn test_blacklist_only_affects_specific_creator() {
 
     // Subscription to creator_1 should fail
     let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-        client.subscribe(&user, &creator_1, &token.address, &100, &1);
+        client.subscribe(&user, &creator_1, &token.address, &100, &1_000_000_000);
     }));
     assert!(result.is_err());
 
     // Subscription to creator_2 should succeed
-    client.subscribe(&user, &creator_2, &token.address, &100, &1);
+    client.subscribe(&user, &creator_2, &token.address, &100, &1_000_000_000);
     assert!(client.is_subscribed(&user, &creator_2));
 }
 
@@ -898,7 +898,7 @@ fn test_blacklist_with_existing_subscription() {
     let client = SubStreamContractClient::new(&env, &contract_id);
 
     // User subscribes first
-    client.subscribe(&user, &creator, &token.address, &100, &1);
+    client.subscribe(&user, &creator, &token.address, &100, &1_000_000_000);
     assert!(client.is_subscribed(&user, &creator));
 
     // Creator then blacklists the user
@@ -912,7 +912,7 @@ fn test_blacklist_with_existing_subscription() {
     client.cancel(&user, &creator);
 
     let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-        client.subscribe(&user, &creator, &token.address, &100, &1);
+        client.subscribe(&user, &creator, &token.address, &100, &1_000_000_000);
     }));
     assert!(result.is_err());
 }

contracts/substream_contracts/src/test_tiny_streams.rs

@@ -0,0 +1,63 @@
+#![cfg(test)]
+
+use super::*;
+use soroban_sdk::{
+    testutils::{Address as _, Ledger},
+    token, Address, Env,
+};
+
+fn create_token_contract<'a>(env: &Env, admin: &Address) -> token::Client<'a> {
+    let sac = env.register_stellar_asset_contract_v2(admin.clone());
+    token::Client::new(env, &sac.address())
+}
+
+#[test]
+fn test_tiny_stream_rounding() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let subscriber = Address::generate(&env);
+    let creator = Address::generate(&env);
+    let admin = Address::generate(&env);
+
+    let token = create_token_contract(&env, &admin);
+    let token_admin = token::StellarAssetClient::new(&env, &token.address);
+    token_admin.mint(&subscriber, &1_000_000_000);
+
+    let contract_id = env.register(SubStreamContract, ());
+    let client = SubStreamContractClient::new(&env, &contract_id);
+
+    let start = 100u64;
+    env.ledger().set_timestamp(start);
+
+    // Suppose we want a stream of 1 unit every 2 seconds (0.5 units/sec).
+    // Now we can specify it as 0.5 * PRECISION_MULTIPLIER = 500,000_000
+    let rate = 500_000_000; 
+    
+    // Subscribe with 1000 units
+    client.subscribe(&subscriber, &creator, &token.address, &1000, &rate);
+
+    let week = 7 * 24 * 60 * 60;
+    env.ledger().set_timestamp(start + week + 100);
+    client.collect(&subscriber, &creator);
+
+    // 100 seconds after trial at 0.5 units/sec = 50 units.
+    assert_eq!(token.balance(&creator), 50, "Rate 0.5 should stream 50 units in 100 seconds");
+
+    // Now let's try a very low but non-zero rate: 10 units per week.
+    // 10 units / (7*24*3600) sec = 10 / 604800 units/sec.
+    // Represented in nano: (10 * 10^9) / 604800 = 16534.
+    let tiny_rate = 16534; 
+    let subscriber2 = Address::generate(&env);
+    token_admin.mint(&subscriber2, &1_000_000_000);
+    client.subscribe(&subscriber2, &creator, &token.address, &1000, &tiny_rate);
+    
+    env.ledger().set_timestamp(start + week + week + week + 100); 
+    client.collect(&subscriber2, &creator);
+    assert_eq!(token.balance(&creator), 50 + 9, "Should be 9 units (9.9997 accrued)");
+
+    // Wait 100 more seconds - the 0.0003 remainder + 100 * 16534 should reach 10 units
+    env.ledger().set_timestamp(start + week + week + week + 200);
+    client.collect(&subscriber2, &creator);
+    assert_eq!(token.balance(&creator), 50 + 10, "Should have accumulated enough dust to reach 10th unit");
+}