Fix challange app

modules/contracts/apps/challenge/src/handlers/execute.rs

@@ -58,7 +58,6 @@ fn create_challenge(
     app.admin.assert_admin(deps.as_ref(), &info.sender)?;
 
     let mut challenge = ChallengeEntry::new(challenge_req);
-    challenge.set_total_check_ins(&env)?;
 
     //check that the challenge status is ChallengeStatus::Uninitialized
     if challenge.status != ChallengeStatus::Uninitialized {
@@ -256,7 +255,7 @@ fn daily_check_in(
     let mut challenge = CHALLENGE_LIST.load(deps.storage, challenge_id)?;
 
     // If the challenge has ended, we set the status to Over and return
-    if env.block.time > challenge.end {
+    if challenge.end.is_expired(&env.block) {
         match challenge.status {
             ChallengeStatus::Active => {
                 challenge.status = ChallengeStatus::Over;
@@ -271,9 +270,8 @@ fn daily_check_in(
             }
             _ => {
                 return Err(AppError::Std(StdError::generic_err(format!(
-                    "Challenge has ended. Challenge end_timestamp is {:?} current timestamp is {:?}",
-                    challenge.end.seconds(),
-                    env.block.time.seconds()
+                    "Challenge has ended. Challenge end is {:?} current block is {:?}",
+                    challenge.end, env.block
                 ))));
             }
         }
@@ -458,15 +456,13 @@ fn charge_penalty(deps: DepsMut, app: &ChallengeApp, challenge_id: u64) -> AppRe
     }
 
     let compute_amount_per_friend = || -> Result<u128, AppError> {
-        if challenge.total_check_ins == 0 || num_friends == 0 {
+        if num_friends == 0 {
             return Err(AppError::Std(StdError::generic_err(format!(
-                "Cannot compute amount per friend. total_check_ins: {}, num_friends: {}",
-                challenge.total_check_ins, num_friends
+                "Cannot compute amount per friend. num_friends: {}",
+                num_friends
             ))));
         }
-        let amount_per_friend =
-            (challenge.collateral.amount.u128() / challenge.total_check_ins) / num_friends;
-        Ok(amount_per_friend)
+        Ok(challenge.strike_amount)
     };
 
     let reaminder = challenge.collateral.amount.u128() % num_friends;

modules/contracts/apps/challenge/src/msg.rs

@@ -7,6 +7,7 @@ use crate::{
 use abstract_dex_adapter::msg::OfferAsset;
 use cosmwasm_schema::QueryResponses;
 use cosmwasm_std::Addr;
+use cw_utils::Expiration;
 
 abstract_app::app_msg_types!(ChallengeApp, ChallengeExecuteMsg, ChallengeQueryMsg);
 
@@ -122,29 +123,15 @@ pub struct ChallengeRequest {
     /// Desciption of the challenge
     pub description: String,
     /// In what period challenge should end
-    pub end: DurationChoice,
+    pub end: Expiration,
+    /// How much should be paid out when challenge fails.
+    pub strike_amount: u128,
 }
 
 /// Response for check_ins query
 /// Returns a list of check ins
 #[cosmwasm_schema::cw_serde]
 pub struct CheckInsResponse(pub Vec<CheckIn>);
-
-/// Duration for challenge
-#[cosmwasm_schema::cw_serde]
-pub enum DurationChoice {
-    /// One week
-    Week,
-    /// One month
-    Month,
-    /// Quarter of the year
-    Quarter,
-    /// One year
-    Year,
-    /// 100 years
-    OneHundredYears,
-}
-
 /// Response for vote query
 #[cosmwasm_schema::cw_serde]
 pub struct VoteResponse {

modules/contracts/apps/challenge/src/state.rs

@@ -3,8 +3,9 @@ use chrono::Duration;
 use cosmwasm_std::{Addr, Deps, Env, StdError, StdResult, Timestamp};
 use cw_address_like::AddressLike;
 use cw_storage_plus::{Item, Map};
+use cw_utils::Expiration;
 
-use crate::msg::{ChallengeRequest, DurationChoice};
+use crate::msg::ChallengeRequest;
 
 pub const DAY: u64 = 86400;
 
@@ -18,8 +19,9 @@ pub struct ChallengeEntry {
     pub name: String,
     pub collateral: OfferAsset,
     pub description: String,
-    pub end: Timestamp,
-    pub total_check_ins: u128,
+    pub end: Expiration,
+    /// Amount charged when a user fails a challenge.
+    pub strike_amount: u128,
     pub status: ChallengeStatus,
     pub admin_strikes: StrikeConfig,
 }
@@ -48,54 +50,12 @@ impl ChallengeEntry {
             name: request.name,
             collateral: request.collateral,
             description: request.description,
-            end: Self::to_timestamp(request.end),
-            total_check_ins: 0,
+            end: request.end,
+            strike_amount: 10,
             status: ChallengeStatus::default(),
             admin_strikes: StrikeConfig::default(),
         }
     }
-
-    /// Sets the total number of check-ins based on the end time.
-    pub fn set_total_check_ins(&mut self, env: &Env) -> StdResult<()> {
-        let now = env.block.time;
-
-        match self.end.seconds().checked_sub(now.seconds()) {
-            Some(duration_secs) => {
-                // Calculate the total number of check-ins
-                self.total_check_ins = duration_secs as u128 / DAY as u128;
-                Ok(())
-            }
-            None => {
-                // If the end time is in the past, set the total check ins to 0.
-                self.total_check_ins = 0;
-                // If the end time is in the past or there's an overflow in calculation, return an error.
-                Err(StdError::generic_err(format!(
-                    "Cannot compute. challenge.end time is in the past: {}, now is: {}",
-                    self.end, now
-                )))
-            }
-        }
-    }
-
-    pub fn to_timestamp(end: DurationChoice) -> Timestamp {
-        match end {
-            DurationChoice::Week => {
-                Timestamp::from_seconds(Duration::weeks(1).to_std().unwrap().as_secs())
-            }
-            DurationChoice::Month => {
-                Timestamp::from_seconds(Duration::days(30).to_std().unwrap().as_secs())
-            }
-            DurationChoice::Quarter => {
-                Timestamp::from_seconds(Duration::days(90).to_std().unwrap().as_secs())
-            }
-            DurationChoice::Year => {
-                Timestamp::from_seconds(Duration::days(365).to_std().unwrap().as_secs())
-            }
-            DurationChoice::OneHundredYears => {
-                Timestamp::from_seconds(Duration::days(365 * 100).to_std().unwrap().as_secs())
-            }
-        }
-    }
 }
 
 /// The status of a challenge. This can be used to trigger an automated Croncat job

modules/contracts/apps/challenge/tests/integrations.rs

@@ -12,15 +12,15 @@ use challenge_app::{
     contract::{CHALLENGE_APP_ID, CHALLENGE_APP_VERSION},
     msg::{
         ChallengeQueryMsg, ChallengeRequest, ChallengeResponse, ChallengesResponse,
-        CheckInsResponse, DurationChoice, FriendsResponse, InstantiateMsg, VoteResponse,
+        CheckInsResponse, FriendsResponse, InstantiateMsg, VoteResponse,
     },
     state::{
         ChallengeEntryUpdate, ChallengeStatus, CheckInStatus, Friend, UpdateFriendsOpKind, Vote,
         DAY,
     },
     *,
 };
-use cosmwasm_std::{coin, Uint128};
+use cosmwasm_std::{coin, Timestamp, Uint128};
 use cw_asset::AssetInfo;
 use cw_orch::{anyhow, deploy::Deploy, prelude::*};
 use lazy_static::lazy_static;
@@ -35,7 +35,10 @@ lazy_static! {
         name: "test".to_string(),
         collateral: OfferAsset::new("denom", Uint128::new(100_000_000_000)),
         description: "Test Challenge".to_string(),
-        end: DurationChoice::OneHundredYears,
+        end: cw_utils::Expiration::AtTime(Timestamp::from_nanos(
+            1571975019879305533 + 100000000000
+        )),
+        strike_amount: 100,
     };
     static ref ALICE_ADDRESS: String = "alice0x".to_string();
     static ref BOB_ADDRESS: String = "bob0x".to_string();