add some refactors to airdrop contract

contracts/airdrop/src/contract.rs

@@ -52,48 +52,48 @@
 }
 
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn migrate(
     deps: DepsMut,
     _env: Env,
     _msg: Empty,
 ) -> Result<Response, StdError> {
     let new_version: Version = CONTRACT_VERSION
         .parse()
         .map_err(|_| StdError::generic_err("Invalid contract version format"))?;
     let current_version = get_contract_version(deps.storage)?;
 
     if current_version.contract != CONTRACT_NAME {
         return Err(StdError::generic_err(
             "Can only upgrade from same contract type",
         ));
     }
 
     if current_version.version.parse::<Version>().unwrap() >= new_version {
         return Err(StdError::generic_err(
             "Cannot upgrade from a newer contract version",
         ));
     }
 
     set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
 
     Ok(Response::new().add_attribute("method", "migrate"))
 }
 
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn execute(
     deps: DepsMut,
     env: Env,
     info: MessageInfo,
     msg: ExecuteMsg,
 ) -> Result<Response, StdError> {
     match msg {
         ExecuteMsg::RewardUsers { requests } => {
             reward_users(deps, env, info, requests)
         }
         ExecuteMsg::Claim {} => claim(deps, env, info),
         ExecuteMsg::Withdraw { amount } => withdraw(deps, env, info, amount),
     }
 }
 
 pub fn reward_users(
     deps: DepsMut,
@@ -103,39 +103,32 @@
 ) -> Result<Response, StdError> {
     let mut res = vec![];
 
+    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"));
+    }
+
     for req in requests {
-        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)
-        {
-            res.push(RewardUserResponse {
-                user_address: req.user_address.clone(),
-                success: false,
-                error_msg: "Unauthorized".to_string(),
-            });
-            continue;
-        }
 
         if campaign.unallocated_amount < req.amount {
-            res.push(RewardUserResponse {
-                user_address: req.user_address.clone(),
-                success: false,
-                error_msg: "Not enough funds in campaign".to_string(),
-            });
-            continue;
+            return Err(StdError::generic_err(
+                "Not enough funds in the campaign",
+            ));
         }
 
         match USER_REWARDS.may_load(deps.storage, req.user_address.clone())? {
             Some(mut user_reward) => {
                 user_reward += req.amount;
                 USER_REWARDS.save(
                     deps.storage,
                     req.user_address.clone(),
                     &user_reward,
                 )?;
             }
             None => {
                 USER_REWARDS.save(
@@ -224,20 +217,20 @@
 }
 
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
     match msg {
         QueryMsg::Campaign {} => query_campaign(deps, env),
         QueryMsg::GetUserReward { user_address } => {
             query_user_reward(deps, env, user_address)
         }
     }
 }
 
 pub fn query_campaign(deps: Deps, _env: Env) -> StdResult<Binary> {
     match CAMPAIGN.load(deps.storage) {
         Ok(campaign) => return to_json_binary(&campaign),
         Err(_) => {
             return Err(StdError::generic_err("Failed to load campaign data"))
         }
     }
 }

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

@@ -2,7 +2,7 @@ use crate::contract::{instantiate, 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};
+use cosmwasm_std::{coins, from_json, Addr, Uint128, StdError};
 use std::vec;
 
 #[test]
@@ -171,3 +171,46 @@ fn test_reward_users_as_manager() {
         Uint128::new(250)
     );
 }
+
+#[test]
+fn test_fails_when_we_try_to_allocate_more_than_available() {
+    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();
+
+    let resp = reward_users(
+        deps.as_mut(),
+        env.clone(),
+        mock_info("manager1", &[]),
+        vec![
+            RewardUserRequest {
+                user_address: Addr::unchecked("user1"),
+                amount: Uint128::new(750),
+            },
+            RewardUserRequest {
+                user_address: Addr::unchecked("user2"),
+                amount: Uint128::new(250),
+            },
+            RewardUserRequest {
+                user_address: Addr::unchecked("user3"),
+                amount: Uint128::new(251),
+            },
+        ],
+    );
+
+    assert_eq!(resp, Err(StdError::generic_err(
+        "Not enough funds in the campaign",
+    )));
+}

nibiru-std/src/proto/mod.rs

@@ -5,8 +5,6 @@ mod type_url_cosmos;
 mod type_url_nibiru;
 
 pub use traits::*;
-pub use type_url_cosmos::*;
-pub use type_url_nibiru::*;
 
 pub mod cosmos {
     /// Authentication of accounts and transactions.