ABS-166: Create accountability module

modules/Cargo.toml

@@ -51,6 +51,7 @@ thiserror = { version = "1.0" }
 protobuf = { version = "2", features = ["with-bytes"] }
 
 clap = { version = "4.0.32", features = ["derive"] }
+chrono = "0.4" 
 semver = "1.0"
 cw-semver = { version = "1.0" }
 cw-orch = { version = "~0.13" }

modules/contracts/apps/challenge/Cargo.toml

@@ -41,6 +41,8 @@ abstract-core = { workspace = true }
 abstract-app = { workspace = true }
 abstract-sdk = { workspace = true }
 
+chrono = { workspace = true }
+
 # Dependencies for interface
 abstract-interface = { workspace = true, optional = true }
 cw-orch = { workspace = true, optional = true }

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

@@ -3,7 +3,7 @@ use abstract_core::objects::{AssetEntry, DexName};
 use abstract_dex_adapter::msg::OfferAsset;
 use abstract_sdk::features::AbstractResponse;
 use cosmwasm_std::{
-    wasm_execute, CosmosMsg, Decimal, DepsMut, Env, MessageInfo, Response, Uint128,
+    wasm_execute, CosmosMsg, Decimal, DepsMut, Env, Error, MessageInfo, Order, Response, Uint128,
 };
 use cw_asset::{Asset, AssetList};
 
@@ -16,6 +16,7 @@ use crate::state::{
 };
 use abstract_dex_adapter::api::DexInterface;
 use abstract_sdk::AbstractSdkResult;
+use chrono::NaiveTime;
 use croncat_app::croncat_intergration_utils::{CronCatAction, CronCatTaskRequest};
 use croncat_app::{CronCat, CronCatInterface};
 
@@ -139,18 +140,20 @@ fn add_friend_for_challenge(
     app.admin.assert_admin(deps.as_ref(), &info.sender)?;
 
     if CHALLENGE_FRIENDS
-        .may_load(deps.storage, (&friend_address, challlenge_id))?
+        .may_load(deps.storage, (friend_address, challlenge_id))?
         .is_some()
     {
-        return AppError::generic_err("Friend already added for this challenge").into();
+        return AppError::Std(Error::generic_err(
+            "Friend already added for this challenge",
+        ));
     }
 
     let friend = Friend {
         address: friend_address.clone(),
         name: friend_name,
     };
 
-    CHALLENGE_FRIENDS.save(deps.storage, (&friend_address, challlenge_id), &friend)?;
+    CHALLENGE_FRIENDS.save(deps.storage, (friend_address, challlenge_id), &friend)?;
     Ok(Response::new())
 }
 
@@ -166,15 +169,15 @@ pub fn remove_friend_from_challenge(
 
     // Ensure the friend exists for this challenge before removing
     if CHALLENGE_FRIENDS
-        .may_load(deps.storage, (&friend_address, challenge_id))?
+        .may_load(deps.storage, (friend_address, challenge_id))?
         .is_none()
     {
-        return Err(AppError::NotFound {
-            kind: "Friend".to_string(),
-        });
+        return Err(AppError::Std(Error::generic_err(
+            "Friend not found for this challenge",
+        )));
     }
 
-    CHALLENGE_FRIENDS.remove(deps.storage, (&friend_address, challenge_id));
+    CHALLENGE_FRIENDS.remove(deps.storage, (friend_address, challenge_id));
     Ok(Response::new())
 }
 
@@ -191,18 +194,18 @@ fn add_friends_for_challenge(
     // Ensure the friends don't already exist for this challenge before adding
     for friend in friends.iter() {
         if CHALLENGE_FRIENDS
-            .may_load(deps.storage, (&friend.address, challenge_id))?
+            .may_load(deps.storage, (friend.address, challenge_id))?
             .is_some()
         {
-            return Err(AppError::generic_err(
+            return Err(AppError::Std(Error::generic_err(
                 "Friend already added for this challenge",
-            ));
+            )));
         }
     }
 
     // Add the friends
     for friend in friends.iter() {
-        CHALLENGE_FRIENDS.save(deps.storage, (&friend.address, challenge_id), &friend)?;
+        CHALLENGE_FRIENDS.save(deps.storage, (friend.address, challenge_id), &friend)?;
     }
 
     Ok(Response::new())
@@ -211,15 +214,8 @@ fn add_friends_for_challenge(
 fn daily_check_in(deps: DepsMut, env: Env, info: MessageInfo, app: &ChallengeApp) -> AppResult {
     app.admin.assert_admin(deps.as_ref(), &info.sender)?;
 
-    let today = format!(
-        "{}-{}-{}",
-        env.block.time.year(),
-        env.block.time.month(),
-        env.block.time.day()
-    );
-
     // Check if Admin has already checked in today
-    if let Ok(check_in) = DAILY_CHECKINS.load(deps.storage, &today) {
+    if let Ok(check_in) = DAILY_CHECKINS.load(deps.storage, &date_from_block(env)) {
         if check_in.last_checked_in == today {
             return Err(StdError::generic_err("Already checked in today."));
         }
@@ -256,16 +252,8 @@ fn cast_vote(
         return Err(StdError::generic_err("Only registered friends can vote."));
     }
 
-    // Check Admin's last check-in
-    let today = format!(
-        "{}-{}-{}",
-        env.block.time.year(),
-        env.block.time.month(),
-        env.block.time.day()
-    );
-
     // If Admin checked in today, friends can't vote
-    if let Ok(check_in) = DAILY_CHECKINS.load(deps.storage, &today) {
+    if let Ok(check_in) = DAILY_CHECKINS.load(deps.storage, &date_from_block(env)) {
         if check_in.last_checked_in == today {
             return Err(StdError::generic_err(
                 "Joe checked in today, no need to vote.",
@@ -324,3 +312,13 @@ fn count_votes(deps: DepsMut, env: Env, challenge_id: u64) -> Result<Response, S
         .add_attribute("failed_votes", failed_votes.to_string())
         .add_attribute("result", result))
 }
+
+fn date_from_block(env: Env) -> String {
+    // Convert the block's timestamp to NaiveDateTime
+    let seconds = env.block.time.seconds();
+    let nano_seconds = env.block.time.subsec_nanos();
+    let dt = NaiveDateTime::from_timestamp(seconds as i64, nano_seconds as u32);
+
+    // Format the date using the NaiveDateTime object
+    format!("{:04}-{:02}-{:02}", dt.year(), dt.month(), dt.day())
+}

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

@@ -1,6 +1,6 @@
 use abstract_sdk::features::AbstractNameService;
-use abstract_sdk::AbstractSdfkError;
-use cosmwasm_std::{env, DepsMut, MessageInfo, Response};
+use abstract_sdk::AbstractSdkError;
+use cosmwasm_std::{DepsMut, Env, MessageInfo, Response};
 use cw_asset::AssetInfoBase;
 
 use crate::contract::{AccApp, AppResult};
@@ -14,7 +14,7 @@ pub fn instantiate_handler(
     app: AccApp,
     msg: AppInstantiateMsg,
 ) -> AppResult {
-    let ans_host = app.ans_host(deps.asref())?;
+    let ans_host = app.ans_host(deps.as_ref())?;
     let asset = ans_host.query_asset(&deps.querier, &msg.native_asset)?;
     let native_denom = match asset {
         AssetInfoBase::Native(denom) => denom,

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

@@ -1,6 +1,6 @@
 use crate::contract::{AccApp, AppResult};
-use crate::msg::{AccQueryMsg, AccResponse, ConfigResponse};
-use crate::state::{ACC_LIST, CONFIG};
+use crate::msg::{AccQueryMsg, AccResponse, ChallengeResponse, ConfigResponse};
+use crate::state::{CHALLENGE_LIST, CONFIG};
 use abstract_core::objects::DexAssetPairing;
 use abstract_sdk::features::AbstractNameService;
 use abstract_sdk::Resolve;
@@ -10,7 +10,7 @@ use cw_asset::AssetInfo;
 pub fn query_handler(deps: Deps, _env: Env, app: &AccApp, msg: AccQueryMsg) -> AppResult<Binary> {
     match msg {
         AccQueryMsg::Config {} => to_binary(&query_config(deps, app)?),
-        AccQueryMsg::Acc { acc_id } => to_binary(&query_acc(deps, app, acc_id)?),
+        AccQueryMsg::Acc { acc_id } => unimplemented!(),
     }
     .map_err(Into::into)
 }
@@ -24,15 +24,16 @@ fn query_config(deps: Deps, app: &AccApp) -> AppResult<ConfigResponse> {
     Ok(ConfigResponse {
         native_asset,
         forfeit_amount: config.forfeit_amount,
-        refill_threshold: config.refill_threshold,
     })
 }
 
 /// Get accountability
 fn query_accountability(deps: Deps, app: &AccApp, acc_id: String) -> AppResult<AccResponse> {
-    let dca = ACC_LIST.may_load(deps.storage, acc_id)?;
+    let challenge = CHALLENGE_LIST.may_load(deps.storage, acc_id)?;
     let ans_host = app.ans_host(deps)?;
-    let pool_references = if let Some(entry) = dca.as_ref() {
+
+    // don't need this
+    let pool_references = if let Some(entry) = challenge.as_ref() {
         DexAssetPairing::new(
             entry.source_asset.name.clone(),
             entry.target_asset.clone(),
@@ -42,8 +43,8 @@ fn query_accountability(deps: Deps, app: &AccApp, acc_id: String) -> AppResult<A
     } else {
         vec![]
     };
-    Ok(AccResponse {
-        acc,
+    Ok(ChallengeResponse {
+        challenge: Some(challenge),
         pool_references,
     })
 }

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

@@ -1,8 +1,9 @@
-use crate::{contract::AccApp, state::AccEntry};
-use abstract_core::objects::PoolReference;
+use crate::{contract::AccApp, state::ChallengeEntry};
+use abstract_core::objects::{AssetEntry, PoolReference};
 use cosmwasm_std::{Decimal, Uint128};
+use croncat_app::croncat_intergration_utils::CronCatInterval;
 
-abstract_app::app_msg_types!(AccApp, AccExecuteMsg, AccQueryMsg);
+abstract_app::app_msg_types!(AccApp, ChallengeExecuteMsg, ChallengeQueryMsg);
 
 #[cosmwasm_schema::cw_serde]
 pub enum Frequency {
@@ -29,16 +30,24 @@ pub struct AppInstantiateMsg {
     /// Native gas/stake asset for this chain
     pub native_asset: AssetEntry,
     /// Amount in native coins for accountability creation task and refill amount
-    pub forfeit_creation_amount: Uint128,
+    pub forfeit_amount: Uint128,
     /// Task balance threshold to trigger refill, put it at zero if you consider to never refill your tasks
     pub refill_threshold: Uint128,
 }
 
+/// App execute messages
+#[cosmwasm_schema::cw_serde]
+#[cfg_attr(feature = "interface", derive(cw_orch::ExecuteFns))]
+#[cfg_attr(feature = "interface", impl_into(ExecuteMsg))]
+pub enum ChallengeExecuteMsg {
+    //@Todo: Add ExecuteMsgs
+}
+
 #[cosmwasm_schema::cw_serde]
 #[cfg_attr(feature = "interface", derive(cw_orch::QueryFns))]
 #[cfg_attr(feature = "interface", impl_into(QueryMsg))]
 #[derive(QueryResponses)]
-pub enum AccQueryMsg {
+pub enum ChallengeQueryMsg {
     #[returns(ConfigResponse)]
     Config {},
     #[returns(AccResponse)]
@@ -49,11 +58,10 @@ pub enum AccQueryMsg {
 pub struct ConfigResponse {
     pub native_asset: AssetEntry,
     pub forfeit_amount: Uint128,
-    pub refill_threshold: Uint128,
 }
 
 #[cosmwasm_schema::cw_serde]
-pub struct AccResponse {
-    pub acc: Option<AccEntry>,
+pub struct ChallengeResponse {
+    pub challenge: Option<ChallengeEntry>,
     pub pool_references: Vec<PoolReference>,
 }