feat: claim batch

fix: integration test and document

Author: VladasZ

Cargo.lock

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

contract/Cargo.toml

@@ -1,16 +1,15 @@
+use std::collections::HashMap;
+
 use near_sdk::{env, ext_contract, is_promise_success, json_types::U128, near_bindgen, AccountId, PromiseOrValue};
 use sweat_jar_model::{
-    api::ClaimApi,
-    claimed_amount_view::ClaimedAmountView,
-    jar::{AggregatedTokenAmountView, JarIdView},
-    U32,
+    api::ClaimApi, claimed_amount_view::ClaimedAmountView, jar::AggregatedTokenAmountView, ProductId, TokenAmount,
 };
 
 use crate::{
     common::Timestamp,
     event::{emit, ClaimEventItem, EventKind},
     jar::model::Jar,
-    Contract, ContractExt, JarsStorage,
+    Contract, ContractExt, JarsStorage, Product,
 };
 
 #[ext_contract(ext_self)]
@@ -29,52 +28,61 @@ impl ClaimApi for Contract {
     fn claim_total(&mut self, detailed: Option<bool>) -> PromiseOrValue<ClaimedAmountView> {
         let account_id = env::predecessor_account_id();
         self.migrate_account_jars_if_needed(account_id.clone());
-        let jar_ids = self.account_jars(&account_id).iter().map(|a| U32(a.id)).collect();
-        self.claim_jars_internal(account_id, jar_ids, detailed)
+        self.claim_jars_internal(account_id, detailed)
     }
 }
 
 impl Contract {
     fn claim_jars_internal(
         &mut self,
         account_id: AccountId,
-        jar_ids: Vec<JarIdView>,
         detailed: Option<bool>,
     ) -> PromiseOrValue<ClaimedAmountView> {
         let now = env::block_timestamp_ms();
         let mut accumulator = ClaimedAmountView::new(detailed);
 
-        let unlocked_jars: Vec<Jar> = self
-            .account_jars(&account_id)
+        let account_jars = self.account_jars(&account_id);
+
+        // UnorderedMap doesn't have cache and deserializes `Product` on each get
+        // This cache significantly reduces gas usage
+        let mut products_cache: HashMap<ProductId, Product> = HashMap::new();
+
+        let mut unlocked_jars: Vec<((TokenAmount, u64), &Jar)> = account_jars
             .iter()
-            .filter(|jar| !jar.is_pending_withdraw && jar_ids.contains(&U32(jar.id)))
-            .cloned()
+            .filter(|jar| !jar.is_pending_withdraw)
+            .map(|jar| {
+                let product = products_cache
+                    .entry(jar.product_id.clone())
+                    .or_insert_with(|| self.get_product(&jar.product_id));
+                (jar.get_interest(product, now), jar)
+            })
             .collect();
 
-        let mut event_data: Vec<ClaimEventItem> = vec![];
+        unlocked_jars.sort_by(|a, b| b.0 .0.cmp(&a.0 .0));
+
+        let jars_to_claim: Vec<_> = unlocked_jars.into_iter().take(100).collect();
 
-        for jar in &unlocked_jars {
-            let product = self.get_product(&jar.product_id);
-            let (available_interest, remainder) = jar.get_interest(&product, now);
+        let mut event_data: Vec<ClaimEventItem> = vec![];
 
-            if available_interest > 0 {
+        for ((available_interest, remainder), jar) in &jars_to_claim {
+            if *available_interest > 0 {
                 let jar = self.get_jar_mut_internal(&jar.account_id, jar.id);
 
-                jar.claim_remainder = remainder;
+                jar.claim_remainder = *remainder;
 
-                jar.claim(available_interest, available_interest, now).lock();
+                jar.claim(*available_interest, *available_interest, now).lock();
 
-                accumulator.add(jar.id, available_interest);
+                accumulator.add(jar.id, *available_interest);
 
-                event_data.push((jar.id, U128(available_interest)));
+                event_data.push((jar.id, U128(*available_interest)));
             }
         }
 
         if accumulator.get_total().0 > 0 {
             self.claim_interest(
                 &account_id,
                 accumulator,
-                unlocked_jars,
+                jars_to_claim.into_iter().map(|a| a.1).cloned().collect(),
                 EventKind::Claim(event_data),
                 now,
             )

contract/src/claim/api.rs

@@ -189,7 +189,7 @@ mod test {
     fn test_contract_version() {
         let admin = admin();
         let context = Context::new(admin);
-        assert_eq!(context.contract().contract_version(), "sweat_jar-3.0.0");
+        assert_eq!(context.contract().contract_version(), "sweat_jar-3.0.1");
     }
 
     #[test]
@@ -202,7 +202,7 @@ mod test {
             .to_json_event_string(),
             r#"EVENT_JSON:{
   "standard": "sweat_jar",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "event": "top_up",
   "data": {
     "id": 10,
@@ -230,7 +230,7 @@ mod test {
             .to_json_event_string(),
             r#"EVENT_JSON:{
   "standard": "sweat_jar",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "event": "create_jar",
   "data": {
     "id": 555,
@@ -250,7 +250,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.0.0",
+  "version": "3.0.1",
   "event": "claim",
   "data": [
     [

contract/src/event.rs

@@ -1,7 +1,7 @@
 #![cfg(feature = "integration-test")]
 
 use near_sdk::{env, near_bindgen, AccountId, Timestamp};
-use sweat_jar_model::{api::IntegrationTestMethods, jar::JarView, ProductId};
+use sweat_jar_model::{api::IntegrationTestMethods, ProductId};
 
 use crate::{jar::model::Jar, Contract, ContractExt};
 
@@ -12,17 +12,11 @@ impl IntegrationTestMethods for Contract {
         env::block_timestamp_ms()
     }
 
-    fn bulk_create_jars(
-        &mut self,
-        account_id: AccountId,
-        product_id: ProductId,
-        principal: u128,
-        number_of_jars: u16,
-    ) -> Vec<JarView> {
+    fn bulk_create_jars(&mut self, account_id: AccountId, product_id: ProductId, principal: u128, number_of_jars: u16) {
         self.assert_manager();
+        let now = env::block_timestamp_ms();
         (0..number_of_jars)
-            .map(|_| self.create_jar_for_integration_tests(&account_id, &product_id, principal))
-            .collect()
+            .for_each(|_| self.create_jar_for_integration_tests(&account_id, &product_id, principal, now));
     }
 }
 
@@ -33,18 +27,11 @@ impl Contract {
         account_id: &AccountId,
         product_id: &ProductId,
         amount: u128,
-    ) -> JarView {
-        let product = self.get_product(&product_id);
-
-        product.assert_enabled();
-        product.assert_cap(amount);
-
+        now: u64,
+    ) {
         let id = self.increment_and_get_last_jar_id();
-        let now = env::block_timestamp_ms();
         let jar = Jar::create(id, account_id.clone(), product_id.clone(), amount, now);
 
-        self.add_new_jar(account_id, jar.clone());
-
-        jar.into()
+        self.add_new_jar(account_id, jar);
     }
 }

contract/src/integration_test/integration_test.rs

@@ -4,12 +4,13 @@ use near_sdk::{env, env::panic_str, json_types::U128, near_bindgen, require, Acc
 use sweat_jar_model::{
     api::JarApi,
     jar::{AggregatedInterestView, AggregatedTokenAmountView, JarId, JarIdView, JarView},
-    TokenAmount, U32,
+    ProductId, TokenAmount, U32,
 };
 
 use crate::{
     event::{emit, EventKind, RestakeData},
     jar::model::Jar,
+    product::model::Product,
     Contract, ContractExt, JarsStorage,
 };
 
@@ -127,8 +128,16 @@ impl JarApi for Contract {
         let mut detailed_amounts = HashMap::<JarIdView, U128>::new();
         let mut total_amount: TokenAmount = 0;
 
+        // UnorderedMap doesn't have cache and deserializes `Product` on each get
+        // This cache significantly reduces gas usage
+        let mut products_cache: HashMap<ProductId, Product> = HashMap::new();
+
         for jar in self.account_jars_with_ids(&account_id, &jar_ids) {
-            let interest = jar.get_interest(&self.get_product(&jar.product_id), now).0;
+            let product = products_cache
+                .entry(jar.product_id.clone())
+                .or_insert_with(|| self.get_product(&jar.product_id));
+
+            let interest = jar.get_interest(product, now).0;
 
             detailed_amounts.insert(U32(jar.id), U128(interest));
             total_amount += interest;

contract/src/jar/api.rs

@@ -21,22 +21,27 @@ pub const SWEAT_JAR: &str = "sweat_jar";
 pub trait IntegrationContext {
     async fn manager(&mut self) -> Result<Account>;
     async fn alice(&mut self) -> Result<Account>;
+    async fn bob(&mut self) -> Result<Account>;
     async fn fee(&mut self) -> Result<Account>;
     fn sweat_jar(&self) -> SweatJarContract;
     fn ft_contract(&self) -> SweatContract;
 }
 
 impl IntegrationContext for Context {
     async fn manager(&mut self) -> Result<Account> {
-        self.account("manager").await
+        self.account("manager_longer_name_to_be_closer_to_real").await
     }
 
     async fn alice(&mut self) -> Result<Account> {
-        self.account("alice").await
+        self.account("alice_longer_name_to_be_closer_to_real").await
+    }
+
+    async fn bob(&mut self) -> Result<Account> {
+        self.account("bob_longer_name_to_be_closer_to_real").await
     }
 
     async fn fee(&mut self) -> Result<Account> {
-        self.account("fee").await
+        self.account("fee_longer_name_to_be_closer_to_real").await
     }
 
     fn sweat_jar(&self) -> SweatJarContract {
@@ -70,7 +75,7 @@ pub(crate) async fn prepare_contract(
     }
 
     let alice = context.alice().await?;
-    let bob = context.account("bob").await?;
+    let bob = context.bob().await?;
     let manager = context.manager().await?;
     let fee_account = context.fee().await?;
 
@@ -138,7 +143,7 @@ pub trait ContextHelpers {
         product_id: &ProductId,
         principal: u128,
         number_of_jars: u16,
-    ) -> Result<Vec<JarView>>;
+    ) -> Result<()>;
     async fn account_balance(&self, account: &Account) -> Result<u128>;
 }
 
@@ -159,7 +164,7 @@ impl ContextHelpers for Context {
         product_id: &ProductId,
         principal: u128,
         number_of_jars: u16,
-    ) -> Result<Vec<JarView>> {
+    ) -> Result<()> {
         let total_amount = principal * number_of_jars as u128;
 
         self.ft_contract()

integration-tests/src/context.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use nitka::misc::ToNear;
+use nitka::{misc::ToNear, set_integration_logs_enabled};
 use sweat_jar_model::api::{ClaimApiIntegration, IntegrationTestMethodsIntegration, JarApiIntegration};
 
 use crate::{
@@ -12,32 +12,66 @@ use crate::{
 async fn claim_many_jars() -> Result<()> {
     println!("👷🏽 Claim many jars test");
 
+    set_integration_logs_enabled(false);
+
     let mut context = prepare_contract(None, [Locked5Minutes60000Percents]).await?;
 
     let alice = context.alice().await?;
     let manager = context.manager().await?;
 
     context
         .sweat_jar()
-        .bulk_create_jars(alice.to_near(), Locked5Minutes60000Percents.id(), 10000, 450)
+        .bulk_create_jars(alice.to_near(), Locked5Minutes60000Percents.id(), 1000, 4000)
         .with_user(&manager)
         .await?;
 
+    dbg!(context.sweat_jar().get_jars_for_account(alice.to_near()).await?.len());
+
     context.fast_forward_minutes(5).await?;
 
-    context
-        .sweat_jar()
-        .claim_total(true.into())
-        .with_user(&alice)
-        .result()
-        .await?;
+    let claimed = context.sweat_jar().claim_total(true.into()).with_user(&alice).await?;
 
-    assert!(context
-        .sweat_jar()
-        .get_jars_for_account(alice.to_near())
-        .await?
-        .iter()
-        .all(|j| j.is_pending_withdraw == false));
+    let batch_claim_summ = claimed.get_total().0;
+
+    dbg!(&batch_claim_summ);
+
+    assert_eq!(
+        batch_claim_summ * 39,
+        context
+            .sweat_jar()
+            .get_total_interest(alice.to_near())
+            .await?
+            .amount
+            .total
+            .0
+    );
+
+    for i in 1..40 {
+        let claimed = context.sweat_jar().claim_total(true.into()).with_user(&alice).await?;
+        assert_eq!(claimed.get_total().0, batch_claim_summ);
+
+        assert_eq!(
+            batch_claim_summ * (39 - i),
+            context
+                .sweat_jar()
+                .get_total_interest(alice.to_near())
+                .await?
+                .amount
+                .total
+                .0
+        );
+    }
+
+    assert_eq!(
+        context
+            .sweat_jar()
+            .get_total_interest(alice.to_near())
+            .await?
+            .amount
+            .total
+            .0,
+        0
+    );
 
     Ok(())
 }