feat: testing with score timestamp

Author: VladasZ

Cargo.lock

@@ -17,7 +17,7 @@ sha256 = "1.3.0"
 mutants = "0.0.3"
 sha2 = "0.10"
 serde = "1.0"
-visu = "0.2.3"
+visu = "0.2.4"
 crypto-hash = "0.3.4"
 itertools = "0.13"
 tokio = { version = "1.37", features = ["full"] }

Cargo.toml

@@ -71,7 +71,8 @@ impl Contract {
 
         for jar in &unlocked_jars {
             let product = self.get_product(&jar.product_id);
-            let (available_interest, remainder) = jar.get_interest(score, &product, now);
+
+            let (available_interest, remainder) = jar.get_interest(&score, &product, now);
 
             let interest_to_claim = amount.map_or(available_interest, |amount| {
                 cmp::min(available_interest, amount.0 - accumulator.get_total().0)
@@ -82,7 +83,8 @@ impl Contract {
 
                 jar.claim_remainder = remainder;
 
-                jar.claim(available_interest, interest_to_claim, now).lock();
+                jar.claim(available_interest, interest_to_claim, &product, &score, now)
+                    .lock();
 
                 accumulator.add(jar.id, interest_to_claim);
 
@@ -167,7 +169,13 @@ impl Contract {
 
                 jar.unlock();
 
-                if jar.should_be_closed(&product, now) {
+                let score = self
+                    .account_score
+                    .get(&jar_before_transfer.account_id)
+                    .copied()
+                    .unwrap_or_default();
+
+                if jar.should_be_closed(&score, &product, now) {
                     self.delete_jar(&jar_before_transfer.account_id, jar_before_transfer.id);
                 }
             }

contract/src/claim/api.rs

@@ -4,7 +4,7 @@ use near_sdk::{json_types::U128, test_utils::test_env::alice, PromiseOrValue};
 use sweat_jar_model::{
     api::{ClaimApi, JarApi, WithdrawApi},
     claimed_amount_view::ClaimedAmountView,
-    U32,
+    AccountScore, U32,
 };
 
 use crate::{
@@ -44,8 +44,8 @@ fn claim_total_detailed_when_having_tokens() {
     let product_term = product.get_lockup_term().unwrap();
     let test_duration = product_term + 100;
 
-    let jar_0_expected_interest = jar_0.get_interest(0, &product, test_duration).0;
-    let jar_1_expected_interest = jar_1.get_interest(0, &product, test_duration).0;
+    let jar_0_expected_interest = jar_0.get_interest(&AccountScore::default(), &product, test_duration).0;
+    let jar_1_expected_interest = jar_1.get_interest(&AccountScore::default(), &product, test_duration).0;
 
     context.set_block_timestamp_in_ms(test_duration);
 
@@ -77,8 +77,8 @@ fn claim_partially_detailed_when_having_tokens() {
     let product_term = product.get_lockup_term().unwrap();
     let test_duration = product_term + 100;
 
-    let jar_0_expected_interest = jar_0.get_interest(0, &product, test_duration).0;
-    let jar_1_expected_interest = jar_1.get_interest(0, &product, test_duration).0 - 1;
+    let jar_0_expected_interest = jar_0.get_interest(&AccountScore::default(), &product, test_duration).0;
+    let jar_1_expected_interest = jar_1.get_interest(&AccountScore::default(), &product, test_duration).0 - 1;
 
     context.set_block_timestamp_in_ms(test_duration);
 
@@ -115,8 +115,8 @@ fn claim_pending_withdraw_jar() {
     let product_term = product.get_lockup_term().unwrap();
     let test_duration = product_term + 100;
 
-    let jar_0_expected_interest = jar_0.get_interest(0, &product, test_duration);
-    let jar_1_expected_interest = jar_1.get_interest(0, &product, test_duration).0 - 1;
+    let jar_0_expected_interest = jar_0.get_interest(&AccountScore::default(), &product, test_duration);
+    let jar_1_expected_interest = jar_1.get_interest(&AccountScore::default(), &product, test_duration).0 - 1;
 
     context.set_block_timestamp_in_ms(test_duration);
 
@@ -152,7 +152,7 @@ fn claim_partially_detailed_when_having_tokens_and_request_sum_of_single_deposit
     let product_term = product.get_lockup_term().unwrap();
     let test_duration = product_term + 100;
 
-    let jar_0_expected_interest = jar_0.get_interest(0, &product, test_duration).0;
+    let jar_0_expected_interest = jar_0.get_interest(&AccountScore::default(), &product, test_duration).0;
 
     context.set_block_timestamp_in_ms(test_duration);
 

contract/src/claim/tests.rs

@@ -48,8 +48,8 @@ impl Contract {
 
         let score = self.account_score.get(&account_id).copied().unwrap_or_default();
 
-        let withdraw_jar = jar.withdrawn(score, &product, principal, now);
-        let should_be_closed = withdraw_jar.should_be_closed(&product, now);
+        let withdraw_jar = jar.withdrawn(&score, &product, principal, now);
+        let should_be_closed = withdraw_jar.should_be_closed(&score, &product, now);
 
         if should_be_closed {
             self.delete_jar(&withdraw_jar.account_id, withdraw_jar.id);
@@ -132,7 +132,7 @@ impl JarApi for Contract {
         let score = self.account_score.get(&account_id).copied().unwrap_or_default();
 
         for jar in self.account_jars_with_ids(&account_id, &jar_ids) {
-            let interest = jar.get_interest(score, &self.get_product(&jar.product_id), now).0;
+            let interest = jar.get_interest(&score, &self.get_product(&jar.product_id), now).0;
 
             detailed_amounts.insert(U32(jar.id), U128(interest));
             total_amount += interest;

contract/src/jar/api.rs

@@ -3,13 +3,13 @@ use std::{cmp, cmp::min};
 use ed25519_dalek::{Signature, VerifyingKey, PUBLIC_KEY_LENGTH, SIGNATURE_LENGTH};
 use near_sdk::{
     env,
-    env::{panic_str, sha256},
+    env::{block_timestamp_ms, panic_str, sha256},
     json_types::{Base64VecU8, U128, U64},
     near, require, AccountId,
 };
 use sweat_jar_model::{
     jar::{JarId, JarView},
-    ProductId, TokenAmount, MS_IN_YEAR,
+    AccountScore, ProductId, TokenAmount, MS_IN_DAY, MS_IN_YEAR,
 };
 
 use crate::{
@@ -50,8 +50,8 @@ impl JarLastVersion {
         self.is_pending_withdraw = false;
     }
 
-    pub(crate) fn apply_penalty(&mut self, product: &Product, is_applied: bool, now: Timestamp) {
-        let current_interest = self.get_interest(0, product, now).0;
+    pub(crate) fn apply_penalty(&mut self, score: &AccountScore, product: &Product, is_applied: bool, now: Timestamp) {
+        let current_interest = self.get_interest(score, product, now).0;
 
         self.cache = Some(JarCache {
             updated_at: now,
@@ -60,8 +60,14 @@ impl JarLastVersion {
         self.is_penalty_applied = is_applied;
     }
 
-    pub(crate) fn top_up(&mut self, amount: TokenAmount, product: &Product, now: Timestamp) -> &mut Self {
-        let current_interest = self.get_interest(0, product, now).0;
+    pub(crate) fn top_up(
+        &mut self,
+        score: &AccountScore,
+        amount: TokenAmount,
+        product: &Product,
+        now: Timestamp,
+    ) -> &mut Self {
+        let current_interest = self.get_interest(score, product, now).0;
 
         self.principal += amount;
         self.cache = Some(JarCache {
@@ -75,18 +81,32 @@ impl JarLastVersion {
         &mut self,
         available_yield: TokenAmount,
         claimed_amount: TokenAmount,
+        product: &Product,
+        score: &AccountScore,
         now: Timestamp,
     ) -> &mut Self {
         self.claimed_balance += claimed_amount;
+
+        let updated_at = if product.is_score_product() {
+            let block_timestamp = block_timestamp_ms();
+            if block_timestamp - score.last_update >= MS_IN_DAY {
+                score.last_update + MS_IN_DAY
+            } else {
+                now
+            }
+        } else {
+            now
+        };
+
         self.cache = Some(JarCache {
-            updated_at: now,
+            updated_at,
             interest: available_yield - claimed_amount,
         });
         self
     }
 
-    pub(crate) fn should_be_closed(&self, product: &Product, now: Timestamp) -> bool {
-        !product.is_flexible() && self.principal == 0 && self.get_interest(0, product, now).0 == 0
+    pub(crate) fn should_be_closed(&self, score: &AccountScore, product: &Product, now: Timestamp) -> bool {
+        !product.is_flexible() && self.principal == 0 && self.get_interest(score, product, now).0 == 0
     }
 
     /// Indicates whether a user can withdraw tokens from the jar at the moment or not.
@@ -138,10 +158,17 @@ impl JarLastVersion {
         )
     }
 
-    pub(crate) fn get_interest(&self, score: u32, product: &Product, now: Timestamp) -> (TokenAmount, u64) {
-        let score = min(product.score_cap, score);
-        let apy = self.get_apy(product) + Self::get_score_apy(score, product);
-        self.get_interest_with_apy(apy, product, now)
+    pub(crate) fn get_interest(
+        &self,
+        account_score: &AccountScore,
+        product: &Product,
+        now: Timestamp,
+    ) -> (TokenAmount, u64) {
+        let (score_apy, adjusted_timestamp) = Self::get_score_apy(account_score, product);
+
+        let apy = self.get_apy(product) + score_apy;
+
+        self.get_interest_with_apy(apy, product, adjusted_timestamp.unwrap_or(now))
     }
 
     pub(crate) fn get_apy(&self, product: &Product) -> UDecimal {
@@ -157,12 +184,24 @@ impl JarLastVersion {
         }
     }
 
-    pub(crate) fn get_score_apy(score: u32, product: &Product) -> UDecimal {
+    pub(crate) fn get_score_apy(account_score: &AccountScore, product: &Product) -> (UDecimal, Option<Timestamp>) {
         if product.score_cap == 0 {
-            return UDecimal::default();
+            return (UDecimal::default(), None);
         }
 
-        UDecimal::new(score.into(), 5)
+        let now = block_timestamp_ms();
+
+        let score = min(product.score_cap, account_score.score);
+
+        let apy = UDecimal::new(score.into(), 5);
+
+        // A 24 hours has passed since last steps update.
+        // We need to wait for the next update form the server before updating score interest
+        if now - account_score.last_update >= MS_IN_DAY {
+            (apy, Some(account_score.last_update + MS_IN_DAY))
+        } else {
+            (apy, None)
+        }
     }
 
     fn get_interest_until_date(&self, product: &Product, now: Timestamp) -> Timestamp {
@@ -221,9 +260,11 @@ impl Contract {
 
         let now = env::block_timestamp_ms();
 
+        let score = self.account_score.get(account).copied().unwrap_or_default();
+
         let principal = self
             .get_jar_mut_internal(account, jar_id)
-            .top_up(amount.0, &product, now)
+            .top_up(&score, amount.0, &product, now)
             .principal;
 
         emit(EventKind::TopUp(TopUpData { id: jar_id, amount }));

contract/src/jar/model/common.rs

@@ -8,7 +8,7 @@ use near_sdk::{
     serde::{Deserialize, Serialize},
     AccountId,
 };
-use sweat_jar_model::{jar::JarId, ProductId, Score, TokenAmount};
+use sweat_jar_model::{jar::JarId, AccountScore, ProductId, TokenAmount};
 
 use crate::{
     common::Timestamp,
@@ -85,7 +85,13 @@ impl JarVersioned {
         self
     }
 
-    pub fn withdrawn(&self, score: Score, product: &Product, withdrawn_amount: TokenAmount, now: Timestamp) -> Self {
+    pub fn withdrawn(
+        &self,
+        score: &AccountScore,
+        product: &Product,
+        withdrawn_amount: TokenAmount,
+        now: Timestamp,
+    ) -> Self {
         JarV1 {
             principal: self.principal - withdrawn_amount,
             cache: Some(JarCache {

contract/src/jar/model/versioned.rs

@@ -2,7 +2,7 @@
 
 use fake::Fake;
 use near_sdk::Timestamp;
-use sweat_jar_model::MS_IN_YEAR;
+use sweat_jar_model::{AccountScore, MS_IN_YEAR};
 
 use crate::{
     common::udecimal::UDecimal,
@@ -15,7 +15,7 @@ fn get_interest_before_maturity() {
     let product = Product::new().lockup_term(2 * MS_IN_YEAR);
     let jar = Jar::new(0).principal(100_000_000);
 
-    let interest = jar.get_interest(0, &product, MS_IN_YEAR).0;
+    let interest = jar.get_interest(&AccountScore::default(), &product, MS_IN_YEAR).0;
     assert_eq!(12_000_000, interest);
 }
 
@@ -24,7 +24,9 @@ fn get_interest_after_maturity() {
     let product = Product::new();
     let jar = Jar::new(0).principal(100_000_000);
 
-    let interest = jar.get_interest(0, &product, 400 * 24 * 60 * 60 * 1000).0;
+    let interest = jar
+        .get_interest(&AccountScore::default(), &product, 400 * 24 * 60 * 60 * 1000)
+        .0;
     assert_eq!(12_000_000, interest);
 }
 
@@ -33,12 +35,21 @@ fn interest_precision() {
     let product = Product::new().apy(Apy::Constant(UDecimal::new(1, 0)));
     let jar = Jar::new(0).principal(MS_IN_YEAR as u128);
 
-    assert_eq!(jar.get_interest(0, &product, 10000000000).0, 10000000000);
-    assert_eq!(jar.get_interest(0, &product, 10000000001).0, 10000000001);
+    assert_eq!(
+        jar.get_interest(&AccountScore::default(), &product, 10000000000).0,
+        10000000000
+    );
+    assert_eq!(
+        jar.get_interest(&AccountScore::default(), &product, 10000000001).0,
+        10000000001
+    );
 
     for _ in 0..100 {
         let time: Timestamp = (10..MS_IN_YEAR).fake();
-        assert_eq!(jar.get_interest(0, &product, time).0, time as u128);
+        assert_eq!(
+            jar.get_interest(&AccountScore::default(), &product, time).0,
+            time as u128
+        );
     }
 }
 

contract/src/jar/tests/tests.rs

@@ -6,7 +6,7 @@ use near_sdk::{
 };
 use near_self_update_proc::SelfUpdate;
 use product::model::{Apy, Product};
-use sweat_jar_model::{api::InitApi, jar::JarId, ProductId, Score};
+use sweat_jar_model::{api::InitApi, jar::JarId, AccountScore, ProductId};
 
 use crate::jar::model::{AccountJarsLegacy, Jar};
 
@@ -55,7 +55,7 @@ pub struct Contract {
 
     pub account_jars_v1: LookupMap<AccountId, AccountJarsLegacy>,
 
-    pub account_score: LookupMap<AccountId, Score>,
+    pub account_score: LookupMap<AccountId, AccountScore>,
 }
 
 #[near]

contract/src/lib.rs

@@ -25,8 +25,10 @@ impl PenaltyApi for Contract {
 
         assert_penalty_apy(&product.apy);
 
+        let score = self.account_score.get(&account_id).copied().unwrap_or_default();
+
         self.get_jar_mut_internal(&account_id, jar_id)
-            .apply_penalty(&product, value, now);
+            .apply_penalty(&score, &product, value, now);
 
         emit(ApplyPenalty(PenaltyData {
             id: jar_id,
@@ -50,6 +52,8 @@ impl PenaltyApi for Contract {
                 .get_mut(&account_id)
                 .unwrap_or_else(|| env::panic_str(&format!("Account '{account_id}' doesn't exist")));
 
+            let score = self.account_score.get(&account_id).copied().unwrap_or_default();
+
             for jar_id in jars {
                 let jar_id = jar_id.0;
 
@@ -61,7 +65,7 @@ impl PenaltyApi for Contract {
                     .unwrap_or_else(|| env::panic_str(&format!("Product '{}' doesn't exist", jar.product_id)));
 
                 assert_penalty_apy(&product.apy);
-                jar.apply_penalty(&product, value, now);
+                jar.apply_penalty(&score, &product, value, now);
 
                 applied_jars.push(jar_id);
             }