fix build

Author: vasyafromrussia

contract/src/assert.rs

@@ -6,7 +6,3 @@ use crate::jar::model::{Jar, JarV2};
 pub(crate) fn assert_not_locked(jar: &JarV2) {
     require!(!jar.is_pending_withdraw, "Another operation on this Jar is in progress");
 }
-
-pub(crate) fn assert_sufficient_balance(jar: &Jar, amount: TokenAmount) {
-    require!(jar.principal >= amount, "Insufficient balance");
-}

contract/src/claim/api.rs

@@ -1,7 +1,9 @@
 use std::collections::HashMap;
 
 use near_sdk::{env, ext_contract, json_types::U128, near_bindgen, AccountId, PromiseOrValue};
-use sweat_jar_model::{api::ClaimApi, claimed_amount_view::ClaimedAmountView, jar::AggregatedTokenAmountView};
+use sweat_jar_model::{
+    api::ClaimApi, claimed_amount_view::ClaimedAmountView, jar::AggregatedTokenAmountView, ProductId, TokenAmount,
+};
 
 use crate::{
     event::{emit, EventKind},
@@ -46,12 +48,14 @@ impl Contract {
         let now = env::block_timestamp_ms();
 
         let mut rollback_jars = HashMap::new();
-        for (product_id, jar) in account.jars.iter_mut() {
+        let mut interest_per_jar: HashMap<ProductId, (TokenAmount, u64)> = HashMap::new();
+
+        for (product_id, jar) in account.jars.iter() {
             if jar.is_pending_withdraw {
                 continue;
             }
 
-            rollback_jars.insert(product_id, jar.to_rollback());
+            rollback_jars.insert(product_id.clone(), jar.to_rollback());
 
             let product = self.products.get(product_id).expect("Product is not found");
             let (interest, remainder) = product.terms.get_interest(account, jar);
@@ -60,14 +64,18 @@ impl Contract {
                 continue;
             }
 
-            jar.claim(interest, remainder, now).lock();
-
+            interest_per_jar.insert(product_id.clone(), (interest, remainder));
             accumulator.add(product_id, interest);
         }
 
+        for (product_id, (interest, remainder)) in interest_per_jar {
+            let jar = account.get_jar_mut(&product_id);
+            jar.claim(interest, remainder, now).lock();
+        }
+
         let mut account_rollback = AccountV2Companion::default();
         account_rollback.score = Some(account.score);
-        account_rollback.jars = Some(*rollback_jars);
+        account_rollback.jars = Some(rollback_jars);
 
         account.score.claim_score();
 

contract/src/ft_receiver.rs

@@ -1,56 +1,56 @@
-// use near_contract_standards::fungible_token::receiver::FungibleTokenReceiver;
-// use near_sdk::{json_types::U128, near, require, serde_json, AccountId, PromiseOrValue};
-// use sweat_jar_model::jar::CeFiJar;
-//
-// use crate::{jar::model::JarTicket, near_bindgen, Base64VecU8, Contract, ContractExt};
-//
-// /// The `FtMessage` enum represents various commands for actions available via transferring tokens to an account
-// /// where this contract is deployed, using the payload in `ft_transfer_call`.
-// #[near(serializers=[json])]
-// #[serde(tag = "type", content = "data", rename_all = "snake_case")]
-// pub enum FtMessage {
-//     /// Represents a request to create a new jar for a corresponding product.
-//     Stake(StakeMessage),
-//
-//     /// Represents a request to create `DeFi` Jars from provided `CeFi` Jars.
-//     Migrate(Vec<CeFiJar>),
-// }
-//
-// /// The `StakeMessage` struct represents a request to create a new jar for a corresponding product.
-// #[near(serializers=[json])]
-// pub struct StakeMessage {
-//     /// Data of the `JarTicket` required for validating the request and specifying the product.
-//     ticket: JarTicket,
-//
-//     /// An optional ed25519 signature used to verify the authenticity of the request.
-//     signature: Option<Base64VecU8>,
-//
-//     /// An optional account ID representing the intended owner of the created jar.
-//     receiver_id: Option<AccountId>,
-// }
-//
-// #[near_bindgen]
-// impl FungibleTokenReceiver for Contract {
-//     fn ft_on_transfer(&mut self, sender_id: AccountId, amount: U128, msg: String) -> PromiseOrValue<U128> {
-//         self.assert_from_ft_contract();
-//
-//         let ft_message: FtMessage = serde_json::from_str(&msg).expect("Unable to deserialize msg");
-//
-//         match ft_message {
-//             FtMessage::Stake(message) => {
-//                 let receiver_id = message.receiver_id.unwrap_or(sender_id);
-//                 self.deposit(receiver_id, message.ticket, amount, message.signature);
-//             }
-//             FtMessage::Migrate(jars) => {
-//                 require!(sender_id == self.manager, "Migration can be performed only by admin");
-//
-//                 self.migrate_jars(jars, amount);
-//             }
-//         }
-//
-//         PromiseOrValue::Value(0.into())
-//     }
-// }
+use near_contract_standards::fungible_token::receiver::FungibleTokenReceiver;
+use near_sdk::{json_types::U128, near, require, serde_json, AccountId, PromiseOrValue};
+use sweat_jar_model::jar::CeFiJar;
+
+use crate::{jar::model::JarTicket, near_bindgen, Base64VecU8, Contract, ContractExt};
+
+/// The `FtMessage` enum represents various commands for actions available via transferring tokens to an account
+/// where this contract is deployed, using the payload in `ft_transfer_call`.
+#[near(serializers=[json])]
+#[serde(tag = "type", content = "data", rename_all = "snake_case")]
+pub enum FtMessage {
+    /// Represents a request to create a new jar for a corresponding product.
+    Stake(StakeMessage),
+
+    /// Represents a request to create `DeFi` Jars from provided `CeFi` Jars.
+    Migrate(Vec<CeFiJar>),
+}
+
+/// The `StakeMessage` struct represents a request to create a new jar for a corresponding product.
+#[near(serializers=[json])]
+pub struct StakeMessage {
+    /// Data of the `JarTicket` required for validating the request and specifying the product.
+    ticket: JarTicket,
+
+    /// An optional ed25519 signature used to verify the authenticity of the request.
+    signature: Option<Base64VecU8>,
+
+    /// An optional account ID representing the intended owner of the created jar.
+    receiver_id: Option<AccountId>,
+}
+
+#[near_bindgen]
+impl FungibleTokenReceiver for Contract {
+    fn ft_on_transfer(&mut self, sender_id: AccountId, amount: U128, msg: String) -> PromiseOrValue<U128> {
+        self.assert_from_ft_contract();
+
+        let ft_message: FtMessage = serde_json::from_str(&msg).expect("Unable to deserialize msg");
+
+        match ft_message {
+            FtMessage::Stake(message) => {
+                let receiver_id = message.receiver_id.unwrap_or(sender_id);
+                self.deposit(receiver_id, message.ticket, amount, message.signature);
+            }
+            FtMessage::Migrate(jars) => {
+                require!(sender_id == self.manager, "Migration can be performed only by admin");
+
+                self.migrate_jars(jars, amount);
+            }
+        }
+
+        PromiseOrValue::Value(0.into())
+    }
+}
 //
 // #[cfg(test)]
 // mod tests {

contract/src/internal.rs

@@ -5,7 +5,10 @@ use sweat_jar_model::jar::JarId;
 
 use crate::{
     env,
-    jar::{account::versioned::Account, model::Jar},
+    jar::{
+        account::versioned::Account,
+        model::{AccountJarsLegacy, Jar},
+    },
     AccountId, Contract,
 };
 
@@ -46,16 +49,18 @@ impl Contract {
         self.accounts.get(account_id).map(|record| record.jars.clone())
     }
 
-    pub(crate) fn get_account_legacy(&self, account_id: &AccountId) -> Option<&Account> {
+    pub(crate) fn get_account_legacy(&self, account_id: &AccountId) -> Option<Account> {
         if let Some(record) = self.account_jars_v1.get(account_id) {
-            return Account::from(record).into();
+            let account: Account = record.clone().into();
+            return Some(account);
         }
 
         if let Some(record) = self.account_jars_non_versioned.get(account_id) {
-            return Account::from(record).into();
+            let account: Account = record.clone().into();
+            return Some(account);
         }
 
-        self.accounts.get(account_id)
+        self.accounts.get(account_id).cloned()
     }
 
     pub(crate) fn add_new_jar(&mut self, account_id: &AccountId, jar: Jar) {

contract/src/jar/account/v1.rs

@@ -10,7 +10,7 @@ use crate::{
 };
 
 #[near]
-#[derive(Default, Debug, PartialEq)]
+#[derive(Default, Debug, PartialEq, Clone)]
 pub struct AccountV1 {
     /// The last jar ID. Is used as nonce in `get_ticket_hash` method.
     pub last_id: JarId,

contract/src/jar/account/versioned.rs

@@ -16,7 +16,7 @@ use crate::{
 
 pub type Account = AccountVersioned;
 
-#[derive(BorshSerialize, Debug, PartialEq)]
+#[derive(BorshSerialize, Debug, PartialEq, Clone)]
 #[borsh(crate = "near_sdk::borsh")]
 pub enum AccountVersioned {
     V1(AccountV1),

contract/src/jar/api.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, ops::Deref};
 
 use near_sdk::{env, json_types::U128, near_bindgen, require, AccountId};
 use sweat_jar_model::{
@@ -13,7 +13,7 @@ use crate::{
         model::Deposit,
         view::DetailedJarV2,
     },
-    product::model::v2::ProductV2,
+    product::model::v2::{InterestCalculator, ProductV2},
     Contract, ContractExt,
 };
 
@@ -22,18 +22,43 @@ impl Contract {
         require!(product.is_enabled, "The product is disabled");
 
         let account_id = env::predecessor_account_id();
-        let account = self.get_account_mut(&account_id);
-        let jar = account.get_jar_mut(&product.id);
-
         let now = env::block_timestamp_ms();
+
+        let account = self.get_account(&account_id);
+        let jar = account.get_jar(&product.id);
+
         let (amount, partition_index) = jar.get_liquid_balance(&product.terms, now);
 
         require!(amount > 0, "Nothing to restake");
 
-        self.update_jar_cache(account, &product.id);
+        self.update_jar_cache(&account_id, &product.id);
+
+        let account = self.get_account_mut(&account_id);
+        let jar = account.get_jar_mut(&product.id);
         jar.clean_up_deposits(partition_index);
         account.deposit(&product.id, amount);
     }
+
+    fn get_total_interest_for_account(&self, account: &AccountV2) -> AggregatedInterestView {
+        let mut detailed_amounts = HashMap::<ProductId, U128>::new();
+        let mut total_amount: TokenAmount = 0;
+
+        for (product_id, jar) in account.jars.iter() {
+            let product = self.get_product(product_id);
+            let interest = product.terms.get_interest(account, &jar).0;
+
+            detailed_amounts.insert(product_id.clone(), interest.into());
+            total_amount += interest;
+        }
+
+        AggregatedInterestView {
+            amount: AggregatedTokenAmountView {
+                detailed: detailed_amounts,
+                total: U128(total_amount),
+            },
+            timestamp: env::block_timestamp_ms(),
+        }
+    }
 }
 
 #[near_bindgen]
@@ -43,7 +68,11 @@ impl JarApi for Contract {
             return account
                 .jars
                 .iter()
-                .flat_map(|(product_id, jar)| DetailedJarV2(product_id.clone(), jar.clone()).into())
+                .flat_map(|(product_id, jar)| {
+                    let detailed_jar = &DetailedJarV2(product_id.clone(), jar.clone());
+                    let views: Vec<JarView> = detailed_jar.into();
+                    views
+                })
                 .collect();
         }
 
@@ -54,14 +83,13 @@ impl JarApi for Contract {
         vec![]
     }
 
-    // TODO: add v2 support
     fn get_total_interest(&self, account_id: AccountId) -> AggregatedInterestView {
         if let Some(account) = self.try_get_account(&account_id) {
-            return account.get_total_interest();
+            return self.get_total_interest_for_account(account);
         }
 
         if let Some(account) = self.get_account_legacy(&account_id) {
-            return AccountV2::from(account).get_total_interest();
+            return self.get_total_interest_for_account(&AccountV2::from(account.deref()));
         }
 
         AggregatedInterestView::default()
@@ -85,6 +113,7 @@ impl JarApi for Contract {
                 .jars
                 .keys()
                 .filter(|product_id| self.get_product(product_id).is_enabled)
+                .cloned()
                 .collect()
         });
         for product_id in product_ids.iter() {
@@ -105,29 +134,6 @@ impl JarApi for Contract {
     }
 }
 
-impl AccountV2 {
-    fn get_total_interest(&self) -> AggregatedInterestView {
-        let mut detailed_amounts = HashMap::<JarIdView, U128>::new();
-        let mut total_amount: TokenAmount = 0;
-
-        for (product_id, jar) in self.jars {
-            let product = self.get_product(&product_id);
-            let interest = product.terms.get_interest(self, &jar).0;
-
-            detailed_amounts.insert(product_id, interest.into());
-            total_amount += interest;
-        }
-
-        AggregatedInterestView {
-            amount: AggregatedTokenAmountView {
-                detailed: detailed_amounts,
-                total: U128(total_amount),
-            },
-            timestamp: env::block_timestamp_ms(),
-        };
-    }
-}
-
 impl From<&AccountV1> for AccountV2 {
     fn from(value: &AccountV1) -> Self {
         let mut account = AccountV2 {
@@ -137,7 +143,7 @@ impl From<&AccountV1> for AccountV2 {
             is_penalty_applied: false,
         };
 
-        for jar in value.jars {
+        for jar in value.jars.iter() {
             let deposit = Deposit::new(jar.created_at, jar.principal);
             account.push(&jar.product_id, deposit);
 

contract/src/jar/model/common.rs

@@ -6,7 +6,7 @@ use near_sdk::{
 use sweat_jar_model::{jar::JarId, Timezone, TokenAmount};
 
 use crate::{
-    common::Timestamp, jar::model::Jar, product::model::v2::Terms, score::AccountScore, Contract, JarsStorage,
+    common::Timestamp, jar::model::Jar, product::model::v2::Terms, Contract, JarsStorage,
 };
 
 /// The `JarTicket` struct represents a request to create a deposit jar for a corresponding product.
@@ -69,21 +69,6 @@ impl Contract {
         account.deposit(product_id, amount);
     }
 
-    pub(crate) fn get_score(&self, account: &AccountId) -> Option<&AccountScore> {
-        self.accounts.get(account).and_then(|a| a.score())
-    }
-
-    pub(crate) fn get_score_mut(&mut self, account: &AccountId) -> Option<&mut AccountScore> {
-        self.accounts.get_mut(account).and_then(|a| a.score_mut())
-    }
-
-    pub(crate) fn get_jar_mut_internal(&mut self, account: &AccountId, id: JarId) -> &mut Jar {
-        self.accounts
-            .get_mut(account)
-            .unwrap_or_else(|| env::panic_str(&format!("Account '{account}' doesn't exist")))
-            .get_jar_mut(id)
-    }
-
     #[mutants::skip]
     pub(crate) fn get_jar_internal(&self, account: &AccountId, id: JarId) -> Jar {
         if let Some(jars) = self.account_jars_v1.get(account) {