Update flat rate whitelist to support multiple admins

contracts/whitelist-updatable-flatrate/src/contract.rs

@@ -2,8 +2,8 @@
 #[cfg(not(feature = "library"))]
 use cosmwasm_std::entry_point;
 use cosmwasm_std::{
-    to_json_binary, Addr, Binary, Deps, DepsMut, Empty, Env, Event, MessageInfo, Order, StdError,
-    StdResult,
+    ensure, to_json_binary, Addr, Binary, Deps, DepsMut, Empty, Env, Event, MessageInfo, Order,
+    StdError, StdResult,
 };
 use cw2::set_contract_version;
 use semver::Version;
@@ -27,8 +27,19 @@
 ) -> Result<Response, ContractError> {
     nonpayable(&info)?;
     set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
+
+    let admin_list: Vec<Addr> = msg.admin_list.as_ref().map_or_else(
+        || Ok(vec![info.sender.clone()]),
+        |admins| {
+            admins
+                .iter()
+                .map(|addr| deps.api.addr_validate(addr))
+                .collect()
+        },
+    )?;
+
     let config = Config {
-        admin: info.sender,
+        admins: admin_list,
         per_address_limit: msg.per_address_limit,
         mint_discount_amount: msg.mint_discount_amount,
     };
@@ -60,7 +71,9 @@
     msg: ExecuteMsg,
 ) -> Result<Response, ContractError> {
     match msg {
-        ExecuteMsg::UpdateAdmin { new_admin } => execute_update_admin(deps, info, new_admin),
+        ExecuteMsg::UpdateAdmins { new_admin_list } => {
+            execute_update_admins(deps, info, new_admin_list)
+        }
         ExecuteMsg::AddAddresses { addresses } => execute_add_addresses(deps, info, addresses),
         ExecuteMsg::RemoveAddresses { addresses } => {
             execute_remove_addresses(deps, info, addresses)
@@ -73,21 +86,33 @@
     }
 }
 
-pub fn execute_update_admin(
+pub fn execute_update_admins(
     deps: DepsMut,
     info: MessageInfo,
-    new_admin: String,
+    new_admin_list: Vec<String>,
 ) -> Result<Response, ContractError> {
     nonpayable(&info)?;
     let mut config = CONFIG.load(deps.storage)?;
-    if config.admin != info.sender {
-        return Err(ContractError::Unauthorized {});
-    }
+    ensure!(
+        config.admins.contains(&info.sender),
+        ContractError::Unauthorized {}
+    );
+
+    config.admins = new_admin_list
+        .into_iter()
+        .map(|address| deps.api.addr_validate(&address))
+        .collect::<StdResult<Vec<Addr>>>()?;
 
-    config.admin = deps.api.addr_validate(&new_admin)?;
     CONFIG.save(deps.storage, &config)?;
     let event = Event::new("update-admin")
-        .add_attribute("new_admin", config.admin)
+        .add_attribute(
+            "new_admin_list",
+            config
+                .admins
+                .into_iter()
+                .map(|x| x.to_string())
+                .collect::<String>(),
+        )
         .add_attribute("sender", info.sender);
     Ok(Response::new().add_event(event))
 }
@@ -99,9 +124,10 @@
 ) -> Result<Response, ContractError> {
     let config = CONFIG.load(deps.storage)?;
     let mut count = TOTAL_ADDRESS_COUNT.load(deps.storage)?;
-    if config.admin != info.sender {
-        return Err(ContractError::Unauthorized {});
-    }
+    ensure!(
+        config.admins.contains(&info.sender),
+        ContractError::Unauthorized {}
+    );
 
     // dedupe
     addresses.sort_unstable();
@@ -135,9 +161,10 @@
     nonpayable(&info)?;
     let config = CONFIG.load(deps.storage)?;
     let mut count = TOTAL_ADDRESS_COUNT.load(deps.storage)?;
-    if config.admin != info.sender {
-        return Err(ContractError::Unauthorized {});
-    }
+    ensure!(
+        config.admins.contains(&info.sender),
+        ContractError::Unauthorized {}
+    );
 
     // dedupe
     addresses.sort_unstable();
@@ -208,9 +235,10 @@
 ) -> Result<Response, ContractError> {
     nonpayable(&info)?;
     let mut config = CONFIG.load(deps.storage)?;
-    if config.admin != info.sender {
-        return Err(ContractError::Unauthorized {});
-    }
+    ensure!(
+        config.admins.contains(&info.sender),
+        ContractError::Unauthorized {}
+    );
 
     config.per_address_limit = limit;
     CONFIG.save(deps.storage, &config)?;
@@ -224,9 +252,10 @@
 pub fn execute_purge(deps: DepsMut, info: MessageInfo) -> Result<Response, ContractError> {
     nonpayable(&info)?;
     let config = CONFIG.load(deps.storage)?;
-    if config.admin != info.sender {
-        return Err(ContractError::Unauthorized {});
-    }
+    ensure!(
+        config.admins.contains(&info.sender),
+        ContractError::Unauthorized {}
+    );
 
     let keys = WHITELIST
         .keys(deps.as_ref().storage, None, None, Order::Ascending)
@@ -251,7 +280,7 @@
             to_json_binary(&query_includes_address(deps, address)?)
         }
         QueryMsg::MintCount { address } => to_json_binary(&query_mint_count(deps, address)?),
-        QueryMsg::Admin {} => to_json_binary(&query_admin(deps)?),
+        QueryMsg::Admins {} => to_json_binary(&query_admins(deps)?),
         QueryMsg::AddressCount {} => to_json_binary(&query_address_count(deps)?),
         QueryMsg::PerAddressLimit {} => to_json_binary(&query_per_address_limit(deps)?),
         QueryMsg::IsProcessable { address } => {
@@ -274,9 +303,13 @@
     WHITELIST.load(deps.storage, addr)
 }
 
-pub fn query_admin(deps: Deps) -> StdResult<String> {
+pub fn query_admins(deps: Deps) -> StdResult<Vec<String>> {
     let config = CONFIG.load(deps.storage)?;
-    Ok(config.admin.to_string())
+    Ok(config
+        .admins
+        .iter()
+        .map(|x| x.to_string())
+        .collect::<Vec<String>>())
 }
 
 pub fn query_address_count(deps: Deps) -> StdResult<u64> {

contracts/whitelist-updatable-flatrate/src/integration_tests.rs

@@ -11,6 +11,7 @@ mod tests {
     use sg_multi_test::StargazeApp;
 
     const CREATOR: &str = "creator";
+    const TEMP_ADMIN: &str = "temp_admin";
     const OTHER_ADMIN: &str = "other_admin";
     const PER_ADDRESS_LIMIT: u32 = 10;
 
@@ -63,7 +64,7 @@ mod tests {
 
     #[test]
     pub fn init() {
-        let addrs: Vec<String> = vec![
+        let addrs = vec![
             "addr0001".to_string(),
             "addr0002".to_string(),
             "addr0003".to_string(),
@@ -75,6 +76,7 @@ mod tests {
             per_address_limit: PER_ADDRESS_LIMIT,
             addresses: addrs.clone(),
             mint_discount_amount: None,
+            admin_list: Some(vec![CREATOR.to_string(), TEMP_ADMIN.to_string()]),
         };
 
         let mut app = custom_mock_app();
@@ -106,11 +108,11 @@ mod tests {
             )
             .unwrap();
 
-        let admin: String = app
+        let admins: Vec<String> = app
             .wrap()
-            .query_wasm_smart(&wl_addr, &QueryMsg::Admin {})
+            .query_wasm_smart(&wl_addr, &QueryMsg::Admins {})
             .unwrap();
-        assert_eq!(admin, CREATOR.to_string());
+        assert_eq!(admins, [CREATOR.to_string(), TEMP_ADMIN.to_string()]);
 
         let count: u64 = app
             .wrap()
@@ -174,7 +176,7 @@ mod tests {
 
     #[test]
     fn exec() {
-        let addrs: Vec<String> = vec![
+        let addrs = vec![
             "addr0001".to_string(),
             "addr0002".to_string(),
             "addr0003".to_string(),
@@ -186,6 +188,7 @@ mod tests {
             per_address_limit: 10,
             addresses: addrs,
             mint_discount_amount: None,
+            admin_list: None,
         };
 
         let mut app = custom_mock_app();
@@ -217,16 +220,18 @@ mod tests {
             )
             .unwrap();
 
-        let msg = ExecuteMsg::UpdateAdmin {
-            new_admin: OTHER_ADMIN.to_string(),
+        let msg = ExecuteMsg::UpdateAdmins {
+            new_admin_list: vec![OTHER_ADMIN.to_string(), TEMP_ADMIN.to_string()],
         };
+        let res = app.execute_contract(Addr::unchecked(TEMP_ADMIN), wl_addr.clone(), &msg, &[]);
+        assert!(res.is_err());
         let res = app.execute_contract(Addr::unchecked(CREATOR), wl_addr.clone(), &msg, &[]);
         assert!(res.is_ok());
-        let res: String = app
+        let res: Vec<String> = app
             .wrap()
-            .query_wasm_smart(&wl_addr, &QueryMsg::Admin {})
+            .query_wasm_smart(&wl_addr, &QueryMsg::Admins {})
             .unwrap();
-        assert_eq!(res, OTHER_ADMIN.to_string());
+        assert_eq!(res, [OTHER_ADMIN.to_string(), TEMP_ADMIN.to_string()]);
 
         // add addresses
         let msg = ExecuteMsg::AddAddresses {
@@ -397,7 +402,10 @@ mod tests {
             .wrap()
             .query_wasm_smart(&wl_addr, &QueryMsg::Config {})
             .unwrap();
-        assert_eq!(res.admin, Addr::unchecked(OTHER_ADMIN).to_string());
+        assert_eq!(
+            res.admins,
+            vec![OTHER_ADMIN.to_string(), TEMP_ADMIN.to_string()]
+        );
         assert_eq!(res.per_address_limit, new_per_address_limit);
     }
 }

contracts/whitelist-updatable-flatrate/src/msg.rs

@@ -7,12 +7,13 @@ pub struct InstantiateMsg {
     pub addresses: Vec<String>,
     pub per_address_limit: u32,
     pub mint_discount_amount: Option<u64>,
+    pub admin_list: Option<Vec<String>>,
 }
 
 #[cw_serde]
 pub enum ExecuteMsg {
-    UpdateAdmin {
-        new_admin: String,
+    UpdateAdmins {
+        new_admin_list: Vec<String>,
     },
     AddAddresses {
         addresses: Vec<String>,
@@ -43,7 +44,7 @@ pub enum QueryMsg {
     #[returns(bool)]
     IsProcessable { address: String },
     #[returns(cw_controllers::AdminResponse)]
-    Admin {},
+    Admins {},
     #[returns(u64)]
     AddressCount {},
     #[returns(u64)]

contracts/whitelist-updatable-flatrate/src/state.rs

@@ -4,7 +4,7 @@ use cw_storage_plus::{Item, Map};
 
 #[cw_serde]
 pub struct Config {
-    pub admin: Addr,
+    pub admins: Vec<Addr>,
     pub per_address_limit: u32,
     pub mint_discount_amount: Option<u64>,
 }