feat: add option to deactivate a campaign

contracts/airdrop/Cargo.toml

@@ -5,9 +5,9 @@ edition = "2021"
 homepage = "https://nibiru.fi"
 repository = "https://github.com/NibiruChain/cw-nibiru"
 exclude = [
-    # Those files are rust-optimizer artifacts. You might want to commit them for convenience but they should not be part of the source code publication.
-    "contract.wasm",
-    "hash.txt",
+  # Those files are rust-optimizer artifacts. You might want to commit them for convenience but they should not be part of the source code publication.
+  "contract.wasm",
+  "hash.txt",
 ]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -52,4 +52,5 @@ cw2 = { workspace = true }
 semver = "1"
 
 [dev-dependencies]
-anyhow = { workspace = true }
+anyhow = { workspace = true }
+serde-json-wasm = "1.0.0"

contracts/airdrop/src/contract.rs

@@ -37,12 +37,12 @@
     }
 
     let campaign = Campaign {
-        campaign_id: msg.campaign_id,
         campaign_name: msg.campaign_name,
         campaign_description: msg.campaign_description,
         owner: info.sender.clone(),
         managers: msg.managers,
         unallocated_amount: coin.amount,
+        is_active: true,
     };
     CAMPAIGN.save(deps.storage, &campaign)?;
 
@@ -92,6 +92,7 @@
         }
         ExecuteMsg::Claim {} => claim(deps, env, info),
         ExecuteMsg::Withdraw { amount } => withdraw(deps, env, info, amount),
+        ExecuteMsg::DeactivateCampaign {} => deactivate(deps, env, info),
     }
 }
 
@@ -103,18 +104,20 @@
 ) -> Result<Response, StdError> {
     let mut res = vec![];
 
-    let mut campaign = CAMPAIGN.load(deps.storage).map_err(|_| {
-        StdError::generic_err("Failed to load campaign data")
-    })?;
+    let mut campaign = CAMPAIGN
+        .load(deps.storage)
+        .map_err(|_| StdError::generic_err("Failed to load campaign data"))?;
 
-    if campaign.owner != info.sender
-        && !campaign.managers.contains(&info.sender)
+    if campaign.owner != info.sender && !campaign.managers.contains(&info.sender)
     {
         return Err(StdError::generic_err("Unauthorized"));
     }
 
-    for req in requests {
+    if !campaign.is_active {
+        return Err(StdError::generic_err("Campaign is not active"));
+    }
 
+    for req in requests {
         if campaign.unallocated_amount < req.amount {
             return Err(StdError::generic_err(
                 "Not enough funds in the campaign",
@@ -160,10 +163,15 @@
 ) -> Result<Response, StdError> {
     let bond_denom = deps.querier.query_bonded_denom()?;
 
+    let campaign = CAMPAIGN.load(deps.storage)?;
+
+    if !campaign.is_active {
+        return Err(StdError::generic_err("Campaign is not active"));
+    }
+
     match USER_REWARDS.may_load(deps.storage, info.sender.clone())? {
         Some(user_reward) => {
-            USER_REWARDS
-                .remove(deps.storage, info.sender.clone());
+            USER_REWARDS.remove(deps.storage, info.sender.clone());
 
             Ok(Response::new()
                 .add_attribute("method", "claim")
@@ -179,6 +187,37 @@
     }
 }
 
+pub fn deactivate(
+    deps: DepsMut,
+    env: Env,
+    info: MessageInfo,
+) -> Result<Response, StdError> {
+    let mut campaign = CAMPAIGN
+        .load(deps.storage)
+        .map_err(|_| StdError::generic_err("Failed to load campaign data"))?;
+
+    if campaign.owner != info.sender && !campaign.managers.contains(&info.sender)
+    {
+        return Err(StdError::generic_err("Unauthorized"));
+    }
+
+    if !campaign.is_active {
+        return Err(StdError::generic_err("Campaign is not active"));
+    }
+
+    campaign.is_active = false;
+    CAMPAIGN.save(deps.storage, &campaign)?;
+
+    let bond_denom = deps.querier.query_bonded_denom()?;
+    let own_balance: Uint128 = deps
+        .querier
+        .query_balance(&env.contract.address, bond_denom.clone())
+        .map_err(|_| StdError::generic_err("Failed to query contract balance"))?
+        .amount;
+
+    return withdraw(deps, env, info, own_balance);
+}
+
 pub fn withdraw(
     deps: DepsMut,
     env: Env,
@@ -213,6 +252,25 @@
             }],
         }));
 
+    // Update campaign unallocated amount
+    if amount > campaign.unallocated_amount {
+        CAMPAIGN.update(
+            deps.storage,
+            |mut campaign| -> StdResult<Campaign> {
+                campaign.unallocated_amount = Uint128::zero();
+                Ok(campaign)
+            },
+        )?;
+    } else {
+        CAMPAIGN.update(
+            deps.storage,
+            |mut campaign| -> StdResult<Campaign> {
+                campaign.unallocated_amount -= amount;
+                Ok(campaign)
+            },
+        )?;
+    }
+
     return Ok(res);
 }
 
@@ -240,6 +298,11 @@
     _env: Env,
     user_address: Addr,
 ) -> StdResult<Binary> {
+    let campaign = CAMPAIGN.load(deps.storage)?;
+    if !campaign.is_active {
+        return Err(StdError::generic_err("Campaign is not active"));
+    }
+
     match USER_REWARDS.load(deps.storage, user_address) {
         Ok(user_reward) => return to_json_binary(&user_reward),
         Err(_) => {

contracts/airdrop/src/msg.rs

@@ -1,4 +1,4 @@
-use cosmwasm_std::{Uint128, Addr};
+use cosmwasm_std::{Addr, Uint128};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
@@ -25,19 +25,15 @@ pub struct RewardUserResponse {
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
-    RewardUsers {
-        requests: Vec<RewardUserRequest>
-    },
+    RewardUsers { requests: Vec<RewardUserRequest> },
     Claim {},
-    Withdraw {
-        amount: Uint128,
-    },
+    Withdraw { amount: Uint128 },
+    DeactivateCampaign {},
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(rename_all = "snake_case")]
 pub enum QueryMsg {
-    Campaign { },
+    Campaign {},
     GetUserReward { user_address: Addr },
 }
-

contracts/airdrop/src/state.rs

@@ -1,17 +1,18 @@
 use cosmwasm_std::{Addr, Uint128};
-use cw_storage_plus::{Map, Item};
+use cw_storage_plus::{Item, Map};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct Campaign {
-    pub campaign_id: String,
     pub campaign_name: String,
     pub campaign_description: String,
 
     pub unallocated_amount: Uint128,
     pub owner: Addr,
     pub managers: Vec<Addr>,
+
+    pub is_active: bool,
 }
 
 pub const CAMPAIGN: Item<Campaign> = Item::new("campaign");

contracts/airdrop/src/tests/execute/reward_users.rs

@@ -1,8 +1,10 @@
-use crate::contract::{instantiate, reward_users};
+use crate::contract::{
+    claim, deactivate, instantiate, query_user_reward, reward_users,
+};
 use crate::msg::{InstantiateMsg, RewardUserRequest, RewardUserResponse};
 use crate::state::{Campaign, CAMPAIGN, USER_REWARDS};
 use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
-use cosmwasm_std::{coins, from_json, Addr, Uint128, StdError};
+use cosmwasm_std::{coins, from_json, Addr, StdError, Uint128};
 use std::vec;
 
 #[test]
@@ -18,7 +20,10 @@ fn test_reward_users_fully_allocated() {
             campaign_id: "campaign_id".to_string(),
             campaign_name: "campaign_name".to_string(),
             campaign_description: "campaign_description".to_string(),
-            managers: vec![Addr::unchecked("manager1"), Addr::unchecked("manager2")],
+            managers: vec![
+                Addr::unchecked("manager1"),
+                Addr::unchecked("manager2"),
+            ],
         },
     )
     .unwrap();
@@ -66,10 +71,13 @@ fn test_reward_users_fully_allocated() {
         Campaign {
             owner: Addr::unchecked("owner"),
             unallocated_amount: Uint128::zero(),
-            campaign_id: "campaign_id".to_string(),
             campaign_name: "campaign_name".to_string(),
             campaign_description: "campaign_description".to_string(),
-            managers: vec![Addr::unchecked("manager1"), Addr::unchecked("manager2")],
+            managers: vec![
+                Addr::unchecked("manager1"),
+                Addr::unchecked("manager2")
+            ],
+            is_active: true,
         }
     );
 
@@ -88,7 +96,6 @@ fn test_reward_users_fully_allocated() {
     );
 }
 
-
 #[test]
 fn test_reward_users_as_manager() {
     let mut deps = mock_dependencies();
@@ -102,7 +109,10 @@ fn test_reward_users_as_manager() {
             campaign_id: "campaign_id".to_string(),
             campaign_name: "campaign_name".to_string(),
             campaign_description: "campaign_description".to_string(),
-            managers: vec![Addr::unchecked("manager1"), Addr::unchecked("manager2")],
+            managers: vec![
+                Addr::unchecked("manager1"),
+                Addr::unchecked("manager2"),
+            ],
         },
     )
     .unwrap();
@@ -150,10 +160,13 @@ fn test_reward_users_as_manager() {
         Campaign {
             owner: Addr::unchecked("owner"),
             unallocated_amount: Uint128::zero(),
-            campaign_id: "campaign_id".to_string(),
             campaign_name: "campaign_name".to_string(),
             campaign_description: "campaign_description".to_string(),
-            managers: vec![Addr::unchecked("manager1"), Addr::unchecked("manager2")],
+            managers: vec![
+                Addr::unchecked("manager1"),
+                Addr::unchecked("manager2")
+            ],
+            is_active: true,
         }
     );
 
@@ -185,7 +198,10 @@ fn test_fails_when_we_try_to_allocate_more_than_available() {
             campaign_id: "campaign_id".to_string(),
             campaign_name: "campaign_name".to_string(),
             campaign_description: "campaign_description".to_string(),
-            managers: vec![Addr::unchecked("manager1"), Addr::unchecked("manager2")],
+            managers: vec![
+                Addr::unchecked("manager1"),
+                Addr::unchecked("manager2"),
+            ],
         },
     )
     .unwrap();
@@ -210,7 +226,67 @@ fn test_fails_when_we_try_to_allocate_more_than_available() {
         ],
     );
 
-    assert_eq!(resp, Err(StdError::generic_err(
-        "Not enough funds in the campaign",
-    )));
-}
+    assert_eq!(
+        resp,
+        Err(StdError::generic_err("Not enough funds in the campaign",))
+    );
+}
+
+#[test]
+fn test_fails_we_allocate_inactive() {
+    let mut deps = mock_dependencies();
+    let env = mock_env();
+
+    instantiate(
+        deps.as_mut(),
+        env.clone(),
+        mock_info("owner", &coins(1000, "")),
+        InstantiateMsg {
+            campaign_id: "campaign_id".to_string(),
+            campaign_name: "campaign_name".to_string(),
+            campaign_description: "campaign_description".to_string(),
+            managers: vec![
+                Addr::unchecked("manager1"),
+                Addr::unchecked("manager2"),
+            ],
+        },
+    )
+    .unwrap();
+
+    reward_users(
+        deps.as_mut(),
+        env.clone(),
+        mock_info("manager1", &[]),
+        vec![RewardUserRequest {
+            user_address: Addr::unchecked("user1"),
+            amount: Uint128::new(1),
+        }],
+    )
+    .unwrap();
+
+    // deactivate campaign -- fail because not owner
+    let resp = deactivate(deps.as_mut(), env.clone(), mock_info("user1", &[]));
+    assert_eq!(resp, Err(StdError::generic_err("Unauthorized")));
+
+    deactivate(deps.as_mut(), env.clone(), mock_info("owner", &[])).unwrap();
+
+    let resp = reward_users(
+        deps.as_mut(),
+        env.clone(),
+        mock_info("manager1", &[]),
+        vec![RewardUserRequest {
+            user_address: Addr::unchecked("user2"),
+            amount: Uint128::new(1),
+        }],
+    );
+    assert_eq!(resp, Err(StdError::generic_err("Campaign is not active",)));
+
+    // user1 should not be able to claim anymore
+    let resp = claim(deps.as_mut(), env.clone(), mock_info("user1", &[]));
+    assert_eq!(resp, Err(StdError::generic_err("Campaign is not active")));
+
+    // user1 query reward says campaign is not active
+    let resp =
+        query_user_reward(deps.as_ref(), env.clone(), Addr::unchecked("user1"));
+    assert_eq!(resp, Err(StdError::generic_err("Campaign is not active")));
+}