fix: correct step jars period (#116)

Author: VladasZ

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "sweat_jar"
-version = "3.3.8"
+version = "3.3.10"
 authors = ["Sweat Economy"]
 edition = "2021"
 

contract/Cargo.toml

@@ -187,7 +187,7 @@ mod test {
     fn test_contract_version() {
         let admin = admin();
         let context = Context::new(admin);
-        assert_eq!(context.contract().contract_version(), "sweat_jar-3.3.8");
+        assert_eq!(context.contract().contract_version(), "sweat_jar-3.3.10");
     }
 
     #[test]
@@ -200,7 +200,7 @@ mod test {
             .to_json_event_string(),
             r#"EVENT_JSON:{
   "standard": "sweat_jar",
-  "version": "3.3.8",
+  "version": "3.3.10",
   "event": "top_up",
   "data": {
     "id": 10,
@@ -228,7 +228,7 @@ mod test {
             .to_json_event_string(),
             r#"EVENT_JSON:{
   "standard": "sweat_jar",
-  "version": "3.3.8",
+  "version": "3.3.10",
   "event": "create_jar",
   "data": {
     "id": 555,
@@ -248,7 +248,7 @@ mod test {
             SweatJarEvent::from(EventKind::Claim(vec![(1, 1.into()), (2, 2.into())])).to_json_event_string(),
             r#"EVENT_JSON:{
   "standard": "sweat_jar",
-  "version": "3.3.8",
+  "version": "3.3.10",
   "event": "claim",
   "data": [
     [
@@ -277,7 +277,7 @@ mod test {
             .to_json_event_string(),
             r#"EVENT_JSON:{
   "standard": "sweat_jar",
-  "version": "3.3.8",
+  "version": "3.3.10",
   "event": "record_score",
   "data": [
     {
@@ -306,7 +306,7 @@ mod test {
             SweatJarEvent::from(EventKind::OldScoreWarning((111, Local(5)))).to_json_event_string(),
             r#"EVENT_JSON:{
   "standard": "sweat_jar",
-  "version": "3.3.8",
+  "version": "3.3.10",
   "event": "old_score_warning",
   "data": [
     111,

contract/src/event.rs

@@ -160,7 +160,8 @@ impl JarLastVersion {
         let cache = self.cache.map(|c| c.interest).unwrap_or_default();
 
         if let Terms::Fixed(end_term) = &product.terms {
-            if now > end_term.lockup_term {
+            let end_term = cmp::max(now, self.created_at + end_term.lockup_term);
+            if now >= end_term {
                 return (cache, 0);
             }
         }

contract/src/jar/model/common.rs

@@ -17,7 +17,10 @@ type Chain = Vec<(Score, Local)>;
 pub struct AccountScore {
     pub updated: UTC,
     pub timezone: Timezone,
+    /// Scores buffer used for interest calculation. Can be invalidated on claim.
     scores: [Score; DAYS_STORED],
+    /// Score history values used for displaying it in application. Will not be invalidated during claim.
+    scores_history: [Score; DAYS_STORED],
 }
 
 impl AccountScore {
@@ -30,6 +33,7 @@ impl AccountScore {
             updated: block_timestamp_ms().into(),
             timezone,
             scores: [0; DAYS_STORED],
+            scores_history: [0; DAYS_STORED],
         }
     }
 
@@ -46,11 +50,13 @@ impl AccountScore {
     }
 
     pub fn active_score(&self) -> Score {
-        let today = self.timezone.today();
         let update_day = self.update_day();
+        let today = self.timezone.today();
 
-        if today == update_day {
-            self.scores[0]
+        if update_day == today {
+            self.scores_history[1]
+        } else if update_day == Local(today.0 - 1) {
+            self.scores_history[0]
         } else {
             0
         }
@@ -59,15 +65,26 @@ impl AccountScore {
     /// On claim we need to clear active scores so they aren't claimed twice or more.
     pub fn claim_score(&mut self) -> Vec<Score> {
         let today = self.timezone.today();
+        let update_day = self.update_day();
 
-        let result = if today == self.update_day() {
+        let result = if today == update_day {
             let score = self.scores[1];
             self.scores[1] = 0;
             vec![score]
         } else {
             let score = vec![self.scores[0], self.scores[1]];
             self.scores[0] = 0;
             self.scores[1] = 0;
+
+            // If scores were updated yesterday we shift history by 1 day
+            // If older that yesterday then we wipe it
+            if update_day == Local(today.0 - 1) {
+                self.scores_history[1] = self.scores_history[0];
+                self.scores_history[0] = 0;
+            } else {
+                self.scores_history = [0; DAYS_STORED];
+            }
+
             score
         };
 
@@ -93,6 +110,7 @@ impl AccountScore {
         for (score, day) in chain {
             let day_index: usize = day.0.try_into().unwrap();
             self.scores[day_index] += score;
+            self.scores_history[day_index] = self.scores_history[day_index].checked_add(score).unwrap_or(u16::MAX);
         }
         vec![]
     }
@@ -135,6 +153,7 @@ impl Default for AccountScore {
             updated: block_timestamp_ms().into(),
             timezone: Timezone::invalid(),
             scores: [0, 0],
+            scores_history: [0, 0],
         }
     }
 }
@@ -211,6 +230,7 @@ mod test {
             updated: UTC(MS_IN_DAY * 10),
             timezone: Timezone::hour_shift(0),
             scores: [1000, 2000],
+            scores_history: [1000, 2000],
         };
 
         let mut ctx = TestBuilder::new().build();
@@ -222,9 +242,15 @@ mod test {
         assert_eq!(score.updated, (MS_IN_DAY * 10).into());
         assert_eq!(score.scores(), (1006, 2005));
         assert_eq!(score.claim_score(), vec![2005]);
+        assert_eq!(score.active_score(), 2005);
 
         ctx.set_block_timestamp_in_ms(MS_IN_DAY * 11);
         assert_eq!(score.claim_score(), vec![1006, 0]);
+        assert_eq!(score.active_score(), 1006);
+
+        ctx.set_block_timestamp_in_ms(MS_IN_DAY * 12);
+        assert_eq!(score.claim_score(), vec![0, 0]);
+        assert_eq!(score.active_score(), 0);
     }
 
     #[test]
@@ -233,16 +259,21 @@ mod test {
             updated: UTC(MS_IN_DAY * 10),
             timezone: Timezone::hour_shift(0),
             scores: [1000, 2000],
+            scores_history: [1000, 2000],
         };
 
         let mut ctx = TestBuilder::new().build();
 
         ctx.set_block_timestamp_in_ms(MS_IN_DAY * 10);
 
-        assert_eq!(score.active_score(), 1000);
+        assert_eq!(score.active_score(), 2000);
 
         ctx.set_block_timestamp_in_ms(MS_IN_DAY * 11);
 
+        assert_eq!(score.active_score(), 1000);
+
+        ctx.set_block_timestamp_in_ms(MS_IN_DAY * 12);
+
         assert_eq!(score.active_score(), 0);
     }
 }

contract/src/score/account_score.rs

@@ -5,13 +5,13 @@ use near_sdk::{
     json_types::{I64, U128},
     store::LookupMap,
     test_utils::test_env::{alice, bob},
-    NearToken,
+    NearToken, Timestamp,
 };
 use sweat_jar_model::{
-    api::{ProductApi, ScoreApi, WithdrawApi},
+    api::{JarApi, ProductApi, ScoreApi, WithdrawApi},
     jar::JarId,
     product::RegisterProductCommand,
-    Score, Timezone, MS_IN_DAY, UTC,
+    Score, Timezone, MS_IN_DAY, MS_IN_HOUR, UTC,
 };
 
 use crate::{
@@ -70,7 +70,7 @@ fn same_interest_in_score_jar_as_in_const_jar() {
     const JAR: JarId = 0;
     const SCORE_JAR: JarId = 1;
 
-    const DAYS: u64 = 400;
+    const DAYS: u64 = 365;
     const HALF_PERIOD: u64 = DAYS / 2;
 
     set_test_log_events(false);
@@ -96,11 +96,8 @@ fn same_interest_in_score_jar_as_in_const_jar() {
     for day in 0..DAYS {
         ctx.set_block_timestamp_in_days(day);
 
-        ctx.switch_account(admin());
         ctx.record_score(UTC(day * MS_IN_DAY), 20_000, alice());
 
-        assert_eq!(ctx.contract().get_score_interest(alice()), Some(U128(20000)));
-
         compare_interest(&ctx);
 
         if day == HALF_PERIOD {
@@ -122,7 +119,13 @@ fn same_interest_in_score_jar_as_in_const_jar() {
 
     total_claimed += ctx.claim_total(alice());
 
-    assert_eq!(total_claimed, NearToken::from_near(24).as_yoctonear());
+    assert_eq!(
+        total_claimed,
+        // The difference here is because the step jars doesn't receive interest for the first day
+        // Because there were no steps at -1 day
+        // But trough entire staking period the values match for regular and for step jar
+        NearToken::from_near(24).as_yoctonear() - 65_753_424_657_534_246_575_344
+    );
 }
 
 #[test]
@@ -314,3 +317,99 @@ fn revert_scores_on_failed_claim() {
         }
     }
 }
+
+#[test]
+fn timestamps() {
+    const ALICE_JAR: JarId = 0;
+
+    set_test_log_events(false);
+
+    let mut ctx = TestBuilder::new()
+        .product(SCORE_PRODUCT, [APY(0), TermDays(10), ScoreCap(20_000)])
+        .jar(ALICE_JAR, JarField::Timezone(Timezone::hour_shift(4)))
+        .build();
+
+    ctx.contract()
+        .accounts
+        .get_mut(&alice())
+        .unwrap()
+        .jars
+        .first_mut()
+        .unwrap()
+        .created_at = 1729692817027;
+
+    ctx.set_block_timestamp_in_ms(1729694971000);
+
+    ctx.record_score(UTC(1729592064000), 8245, alice());
+
+    assert_eq!(
+        ctx.contract().get_total_interest(alice()).amount.total.0,
+        22589041095890410958904
+    );
+
+    for i in 0..100 {
+        ctx.set_block_timestamp_in_ms(1729694971000 + MS_IN_HOUR * i);
+
+        assert_eq!(
+            ctx.contract().get_total_interest(alice()).amount.total.0,
+            22589041095890410958904
+        );
+    }
+}
+
+#[test]
+fn test_steps_history() {
+    const ALICE_JAR: JarId = 0;
+    const BASE_TIME: Timestamp = 1729692817027;
+
+    set_test_log_events(false);
+
+    let mut ctx = TestBuilder::new()
+        .product(SCORE_PRODUCT, [APY(0), TermDays(10), ScoreCap(20_000)])
+        .jar(ALICE_JAR, JarField::Timezone(Timezone::hour_shift(4)))
+        .build();
+
+    ctx.contract()
+        .accounts
+        .get_mut(&alice())
+        .unwrap()
+        .jars
+        .first_mut()
+        .unwrap()
+        .created_at = BASE_TIME;
+
+    let check_score_interest = |ctx: &Context, val: u128| {
+        assert_eq!(ctx.contract().get_score_interest(alice()), Some(U128(val)));
+    };
+
+    ctx.set_block_timestamp_in_ms(BASE_TIME);
+
+    check_score_interest(&ctx, 0);
+
+    ctx.record_score(UTC(BASE_TIME - MS_IN_DAY), 8245, alice());
+
+    check_score_interest(&ctx, 8245);
+
+    ctx.set_block_timestamp_in_ms(BASE_TIME + MS_IN_DAY);
+
+    check_score_interest(&ctx, 0);
+
+    ctx.set_block_timestamp_in_ms(BASE_TIME + MS_IN_DAY * 10);
+
+    check_score_interest(&ctx, 0);
+
+    ctx.record_score(UTC(BASE_TIME + MS_IN_DAY * 10), 10000, alice());
+    ctx.record_score(UTC(BASE_TIME + MS_IN_DAY * 10), 101, alice());
+    ctx.record_score(UTC(BASE_TIME + MS_IN_DAY * 9), 9000, alice());
+    ctx.record_score(UTC(BASE_TIME + MS_IN_DAY * 9), 90, alice());
+
+    check_score_interest(&ctx, 9090);
+
+    ctx.set_block_timestamp_in_ms(BASE_TIME + MS_IN_DAY * 11);
+
+    check_score_interest(&ctx, 10101);
+
+    ctx.set_block_timestamp_in_ms(BASE_TIME + MS_IN_DAY * 12);
+
+    check_score_interest(&ctx, 0);
+}

contract/src/score/tests.rs

@@ -1,4 +1,4 @@
-use sweat_jar_model::{Score, MS_IN_DAY};
+use sweat_jar_model::{Score, MS_IN_DAY, MS_IN_MINUTE};
 
 use crate::product::model::Product;
 
@@ -14,6 +14,8 @@ pub(crate) enum ProductField {
     APY(u32),
     ScoreCap(Score),
     TermDays(u64),
+    #[allow(dead_code)]
+    TermMinutes(u64),
 }
 
 impl ProductBuilder for ProductField {
@@ -22,6 +24,7 @@ impl ProductBuilder for ProductField {
             ProductField::APY(apy) => product.apy(apy),
             ProductField::ScoreCap(cap) => product.score_cap(cap),
             ProductField::TermDays(days) => product.lockup_term(days * MS_IN_DAY),
+            ProductField::TermMinutes(days) => product.lockup_term(days * MS_IN_MINUTE),
         }
     }
 }