fix: fixed bugs discovered while testing the mobile app on testnet (#72)

* test: testnet migration

* test: sandbox jar creation after migration

* test: create jar on testnet wip

* fix: restore event format

* fix: migrate in signature verification

* fix: skip new filed only in event

* fix: simpler event serialization

Author: VladasZ

contract/src/event.rs

@@ -4,9 +4,15 @@ use near_sdk::{
     serde::{Deserialize, Serialize},
     serde_json, AccountId,
 };
-use sweat_jar_model::{jar::JarId, ProductId};
-
-use crate::{common::Timestamp, env, jar::model::Jar, product::model::Product, PACKAGE_NAME, VERSION};
+use sweat_jar_model::{jar::JarId, ProductId, TokenAmount};
+
+use crate::{
+    common::Timestamp,
+    env,
+    jar::model::{JarCache, JarV1},
+    product::model::Product,
+    PACKAGE_NAME, VERSION,
+};
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(
@@ -17,7 +23,7 @@ use crate::{common::Timestamp, env, jar::model::Jar, product::model::Product, PA
 )]
 pub enum EventKind {
     RegisterProduct(Product),
-    CreateJar(Jar),
+    CreateJar(EventJar),
     Claim(Vec<ClaimEventItem>),
     Withdraw(WithdrawData),
     Migration(Vec<MigrationEventItem>),
@@ -29,6 +35,36 @@ pub enum EventKind {
     TopUp(TopUpData),
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(crate = "near_sdk::serde", rename_all = "snake_case")]
+pub struct EventJar {
+    id: JarId,
+    account_id: AccountId,
+    product_id: ProductId,
+    created_at: Timestamp,
+    principal: TokenAmount,
+    cache: Option<JarCache>,
+    claimed_balance: TokenAmount,
+    is_pending_withdraw: bool,
+    is_penalty_applied: bool,
+}
+
+impl From<JarV1> for EventJar {
+    fn from(value: JarV1) -> Self {
+        Self {
+            id: value.id,
+            account_id: value.account_id,
+            product_id: value.product_id,
+            created_at: value.created_at,
+            principal: value.principal,
+            cache: value.cache,
+            claimed_balance: value.claimed_balance,
+            is_pending_withdraw: value.is_pending_withdraw,
+            is_penalty_applied: value.is_penalty_applied,
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(crate = "near_sdk::serde", rename_all = "snake_case")]
 struct SweatJarEvent {
@@ -142,16 +178,19 @@ impl SweatJarEvent {
 
 #[cfg(test)]
 mod test {
-    use near_sdk::json_types::U128;
+    use near_sdk::{json_types::U128, AccountId};
 
-    use crate::event::{EventKind, SweatJarEvent, TopUpData};
+    use crate::{
+        event::{EventKind, SweatJarEvent, TopUpData},
+        jar::model::JarV1,
+    };
 
     #[test]
     fn event_to_string() {
         assert_eq!(
             SweatJarEvent::from(EventKind::TopUp(TopUpData {
                 id: 10,
-                amount: U128(50)
+                amount: U128(50),
             }))
             .to_json_event_string(),
             r#"EVENT_JSON:{
@@ -163,6 +202,41 @@ mod test {
     "amount": "50"
   }
 }"#
-        )
+        );
+
+        assert_eq!(
+            SweatJarEvent::from(EventKind::CreateJar(
+                JarV1 {
+                    id: 555,
+                    account_id: AccountId::new_unchecked("bob.near".to_string()),
+                    product_id: "some_product".to_string(),
+                    created_at: 1234324235,
+                    principal: 78685678567,
+                    cache: None,
+                    claimed_balance: 4324,
+                    is_pending_withdraw: false,
+                    is_penalty_applied: false,
+                    claim_remainder: 55555,
+                }
+                .into()
+            ))
+            .to_json_event_string(),
+            r#"EVENT_JSON:{
+  "standard": "sweat_jar",
+  "version": "1.0.0",
+  "event": "create_jar",
+  "data": {
+    "id": 555,
+    "account_id": "bob.near",
+    "product_id": "some_product",
+    "created_at": 1234324235,
+    "principal": 78685678567,
+    "cache": null,
+    "claimed_balance": 4324,
+    "is_pending_withdraw": false,
+    "is_penalty_applied": false
+  }
+}"#
+        );
     }
 }

contract/src/jar/model/v1.rs

@@ -236,7 +236,7 @@ impl Contract {
 
         self.add_new_jar(&account_id, jar.clone());
 
-        emit(EventKind::CreateJar(jar.clone()));
+        emit(EventKind::CreateJar(jar.inner().into()));
 
         jar.into()
     }
@@ -314,6 +314,8 @@ impl Contract {
         ticket: &JarTicket,
         signature: Option<Base64VecU8>,
     ) {
+        self.migrate_account_jars_if_needed(account_id.clone());
+
         let last_jar_id = self.account_jars.get(account_id).map(|jars| jars.last_id);
         let product = self.get_product(&ticket.product_id);
 

contract/src/jar/model/versioned.rs

@@ -70,7 +70,7 @@ impl JarVersioned {
         .into()
     }
 
-    fn inner(&self) -> JarV1 {
+    pub fn inner(&self) -> JarV1 {
         match self {
             Self::V1(jar) => jar.clone(),
         }

integration-tests/src/jar_contract_extensions.rs

@@ -108,7 +108,7 @@ impl JarContractExtensions for SweatJarContract<'_> {
         product_id: String,
         amount: u128,
         ft_contract_id: &near_workspaces::AccountId,
-    ) -> anyhow::Result<U128> {
+    ) -> Result<U128> {
         println!(
             "▶️ Create jar(product = {:?}) for user {:?} with {:?} tokens",
             product_id,
@@ -137,7 +137,7 @@ impl JarContractExtensions for SweatJarContract<'_> {
         signature: String,
         valid_until: u64,
         ft_contract_id: &near_workspaces::AccountId,
-    ) -> anyhow::Result<U128> {
+    ) -> Result<U128> {
         println!(
             "▶️ Create premium jar(product = {:?}) for user {:?} with {:?} tokens",
             product_id,
@@ -165,7 +165,7 @@ impl JarContractExtensions for SweatJarContract<'_> {
         jar_id: JarId,
         amount: U128,
         ft_contract_id: &near_workspaces::AccountId,
-    ) -> anyhow::Result<U128> {
+    ) -> Result<U128> {
         let msg = json!({
             "type": "top_up",
             "data": jar_id,
@@ -229,7 +229,7 @@ impl JarContractExtensions for SweatJarContract<'_> {
             receiver_id.id(),
             product_id,
             amount,
-            last_jar_id.map_or_else(String::new, |value| value,),
+            last_jar_id.map_or_else(String::new, |value| value),
             valid_until,
         )
     }

integration-tests/src/migrations/claim_rounding.rs

@@ -1,18 +1,23 @@
 use anyhow::Result;
 use fake::Fake;
-use integration_utils::contract_call::set_integration_logs_enabled;
+use integration_utils::{contract_call::set_integration_logs_enabled, misc::ToNear};
 use near_sdk::AccountId;
 use near_workspaces::types::NearToken;
-use sweat_jar_model::api::{IntegrationTestMethodsIntegration, MigrationToClaimRemainderIntegration, SweatJarContract};
+use sweat_jar_model::{
+    api::{
+        IntegrationTestMethodsIntegration, JarApiIntegration, MigrationToClaimRemainderIntegration, SweatJarContract,
+    },
+    jar::JarView,
+};
 
 use crate::{
     context::{prepare_contract, IntegrationContext},
+    jar_contract_extensions::JarContractExtensions,
     migrations::helpers::load_wasm,
     product::RegisterProductCommand,
 };
 
 #[tokio::test]
-#[ignore]
 async fn migrate_to_claim_roundings() -> Result<()> {
     use std::time::Instant;
     let now = Instant::now();
@@ -21,18 +26,20 @@ async fn migrate_to_claim_roundings() -> Result<()> {
 
     let jar_before_rounding = load_wasm("res/sweat_jar_before_rounding.wasm");
 
-    let context = prepare_contract(
+    let mut context = prepare_contract(
         jar_before_rounding.into(),
         [
             RegisterProductCommand::Locked12Months12Percents,
             RegisterProductCommand::Locked6Months6Percents,
             RegisterProductCommand::Locked6Months6PercentsWithWithdrawFee,
         ],
     )
-        .await?;
+    .await?;
 
     let jar_account = context.sweat_jar().contract.as_account().clone();
 
+    let alice = context.alice().await?;
+
     let elapsed = now.elapsed();
     println!("Elapsed: {:.2?}", elapsed);
 
@@ -66,6 +73,23 @@ async fn migrate_to_claim_roundings() -> Result<()> {
     let elapsed = now.elapsed();
     println!("Created jars elapsed: {:.2?}", elapsed);
 
+    const PRINCIPAL: u128 = 100000;
+
+    context
+        .sweat_jar()
+        .create_jar(
+            &alice,
+            RegisterProductCommand::Locked6Months6Percents.id(),
+            PRINCIPAL,
+            context.ft_contract().contract.as_account().id(),
+        )
+        .await?;
+
+    let alice_jars_before = context.sweat_jar().get_jars_for_account(alice.to_near()).await?;
+    let alice_principal = context.sweat_jar().get_total_principal(alice.to_near()).await?;
+
+    assert_eq!(alice_principal.total.0, PRINCIPAL);
+
     let jar_after_rounding = load_wasm("res/sweat_jar.wasm");
     let jar_after_rounding = jar_account.deploy(&jar_after_rounding).await?.into_result()?;
     let jar_after_rounding = SweatJarContract {
@@ -79,6 +103,42 @@ async fn migrate_to_claim_roundings() -> Result<()> {
 
     jar_after_rounding.migrate_state_to_claim_remainder().await?;
 
+    let alice_jars_after = context.sweat_jar().get_jars_for_account(alice.to_near()).await?;
+    let alice_principal_after = context.sweat_jar().get_total_principal(alice.to_near()).await?;
+
+    assert_eq!(alice_jars_before, alice_jars_after);
+    assert_eq!(alice_principal, alice_principal_after);
+    assert_eq!(alice_principal_after.total.0, PRINCIPAL);
+
+    context
+        .sweat_jar()
+        .create_jar(
+            &alice,
+            RegisterProductCommand::Locked6Months6Percents.id(),
+            PRINCIPAL,
+            context.ft_contract().contract.as_account().id(),
+        )
+        .await?;
+
+    let alice_principal_2_jars = context.sweat_jar().get_total_principal(alice.to_near()).await?;
+    assert_eq!(alice_principal_2_jars.total.0, PRINCIPAL * 2);
+
+    let alice_2_jars = context.sweat_jar().get_jars_for_account(alice.to_near()).await?;
+
+    let jar = alice_jars_before.into_iter().next().unwrap();
+
+    assert_eq!(
+        alice_2_jars.clone(),
+        vec![
+            jar.clone(),
+            JarView {
+                id: alice_2_jars[1].id,
+                created_at: alice_2_jars[1].created_at,
+                ..jar
+            },
+        ]
+    );
+
     for accs in accounts.chunks(600) {
         jar_after_rounding
             .migrate_accounts_to_claim_remainder(accs.to_vec())

model/src/jar.rs

@@ -14,7 +14,7 @@ pub type JarId = u32;
 
 pub type JarIdView = U32;
 
-#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 #[serde(crate = "near_sdk::serde")]
 pub struct JarView {
     pub id: JarIdView,