Update min reserve price management logic

contracts/reserve-auction/src/error.rs

@@ -41,6 +41,9 @@ pub enum ContractError {
     #[error("InvalidReservePrice: {min}")]
     InvalidReservePrice { min: Coin },
 
+    #[error("InvalidMinReservePriceManagerAddress")]
+    InvalidMinReservePriceManagerAddress {},
+
     #[error("BidTooLow: {0}")]
     BidTooLow(Uint128),
 

contracts/reserve-auction/src/execute.rs

@@ -3,7 +3,7 @@ use std::vec;
 use crate::error::ContractError;
 use crate::helpers::{only_no_auction, settle_auction, validate_reserve_price};
 use crate::msg::ExecuteMsg;
-use crate::state::{auctions, Auction, HighBid};
+use crate::state::{auctions, Auction, HighBid, MIN_RESERVE_PRICES, MIN_RESERVE_PRICE_MANAGER};
 use crate::state::{CONFIG, HALT_MANAGER};
 use cosmwasm_std::{
     attr, coin, ensure, ensure_eq, has_coins, Addr, Coin, DepsMut, Env, Event, MessageInfo,
@@ -76,6 +76,15 @@ pub fn execute(
             api.addr_validate(&collection)?,
             &token_id,
         ),
+        ExecuteMsg::SetMinReservePrices { min_reserve_prices } => {
+            execute_set_min_reserve_prices(deps, info, min_reserve_prices)
+        }
+        ExecuteMsg::UnsetMinReservePrices { denoms } => {
+            execute_unset_min_reserve_prices(deps, info, denoms)
+        }
+        ExecuteMsg::UpdateMinReservePriceManager { manager } => {
+            execute_update_min_reserve_price_manager(deps, info, manager)
+        }
     }
 }
 
@@ -372,3 +381,81 @@ pub fn execute_settle_auction(
 
     settle_auction(deps, block_time, auction, &config, &halt_manager, response)
 }
+
+pub fn execute_set_min_reserve_prices(
+    deps: DepsMut,
+    info: MessageInfo,
+    min_reserve_prices: Vec<Coin>,
+) -> Result<Response, ContractError> {
+    let min_reserve_price_manager = MIN_RESERVE_PRICE_MANAGER.load(deps.storage)?;
+    ensure_eq!(
+        info.sender,
+        min_reserve_price_manager,
+        ContractError::Unauthorized {}
+    );
+
+    let mut response = Response::new();
+
+    for min_reserve_price in min_reserve_prices {
+        ensure!(
+            !MIN_RESERVE_PRICES.has(deps.storage, min_reserve_price.denom.clone()),
+            ContractError::InvalidInput("found duplicate denom".to_string())
+        );
+
+        MIN_RESERVE_PRICES.save(
+            deps.storage,
+            min_reserve_price.denom.clone(),
+            &min_reserve_price.amount,
+        )?;
+        response = response.add_event(
+            Event::new("set-min-reserve-price")
+                .add_attribute("denom", min_reserve_price.denom)
+                .add_attribute("amount", min_reserve_price.amount),
+        );
+    }
+    Ok(response)
+}
+
+pub fn execute_unset_min_reserve_prices(
+    deps: DepsMut,
+    info: MessageInfo,
+    denoms: Vec<String>,
+) -> Result<Response, ContractError> {
+    let min_reserve_price_manager = MIN_RESERVE_PRICE_MANAGER.load(deps.storage)?;
+    ensure_eq!(
+        info.sender,
+        min_reserve_price_manager,
+        ContractError::Unauthorized {}
+    );
+
+    let mut response = Response::new();
+
+    for denom in denoms {
+        ensure!(
+            MIN_RESERVE_PRICES.has(deps.storage, denom.clone()),
+            ContractError::InvalidInput("denom not found".to_string())
+        );
+
+        MIN_RESERVE_PRICES.remove(deps.storage, denom.clone());
+        response =
+            response.add_event(Event::new("unset-min-reserve-price").add_attribute("denom", denom));
+    }
+    Ok(response)
+}
+
+pub fn execute_update_min_reserve_price_manager(
+    deps: DepsMut,
+    info: MessageInfo,
+    manager: String,
+) -> Result<Response, ContractError> {
+    let min_reserve_price_manager = MIN_RESERVE_PRICE_MANAGER.load(deps.storage)?;
+    ensure_eq!(
+        info.sender,
+        min_reserve_price_manager,
+        ContractError::Unauthorized {}
+    );
+
+    MIN_RESERVE_PRICE_MANAGER.save(deps.storage, &deps.api.addr_validate(&manager)?)?;
+
+    Ok(Response::new().add_attribute("action", "update-min-reserve-price-manager"))
+}

contracts/reserve-auction/src/instantiate.rs

@@ -2,7 +2,7 @@
 use cosmwasm_std::entry_point;
 
 use crate::msg::InstantiateMsg;
-use crate::state::{Config, HaltManager, HALT_MANAGER};
+use crate::state::{Config, HaltManager, HALT_MANAGER, MIN_RESERVE_PRICE_MANAGER};
 use crate::{error::ContractError, state::MIN_RESERVE_PRICES};
 use cosmwasm_std::{DepsMut, Env, Event, MessageInfo};
 use cw2::set_contract_version;
@@ -20,6 +20,12 @@ pub fn instantiate(
     msg: InstantiateMsg,
 ) -> Result<Response, ContractError> {
     set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
+
+    MIN_RESERVE_PRICE_MANAGER.save(
+        deps.storage,
+        &deps.api.addr_validate(&msg.min_reserve_price_manager)?,
+    )?;
+
     let config = Config {
         fair_burn: deps.api.addr_validate(&msg.fair_burn)?,
         trading_fee_percent: msg.trading_fee_percent,

contracts/reserve-auction/src/msg.rs

@@ -37,6 +37,7 @@ pub struct InstantiateMsg {
     /// The minimum reserve prices for the various denoms. Denoms
     /// no defined are not supported.
     pub min_reserve_prices: Vec<Coin>,
+    pub min_reserve_price_manager: String,
 }
 
 #[cw_serde]
@@ -65,6 +66,15 @@ pub enum ExecuteMsg {
         collection: String,
         token_id: String,
     },
+    SetMinReservePrices {
+        min_reserve_prices: Vec<Coin>,
+    },
+    UnsetMinReservePrices {
+        denoms: Vec<String>,
+    },
+    UpdateMinReservePriceManager {
+        manager: String,
+    },
 }
 
 #[cw_serde]
@@ -106,6 +116,8 @@ pub enum QueryMsg {
         end_time: u64,
         query_options: Option<QueryOptions<AuctionKeyOffset>>,
     },
+    #[returns(String)]
+    MinReservePriceManager {},
 }
 
 #[allow(clippy::large_enum_variant)]
@@ -125,10 +137,4 @@ pub enum SudoMsg {
         halt_buffer_duration: Option<u64>,
         halt_postpone_duration: Option<u64>,
     },
-    SetMinReservePrices {
-        min_reserve_prices: Vec<Coin>,
-    },
-    UnsetMinReservePrices {
-        denoms: Vec<String>,
-    },
 }

contracts/reserve-auction/src/query.rs

@@ -1,5 +1,7 @@
 use crate::msg::{AuctionKeyOffset, MinReservePriceOffset, QueryMsg};
-use crate::state::{auctions, Auction, Config, HaltManager, HALT_MANAGER};
+use crate::state::{
+    auctions, Auction, Config, HaltManager, HALT_MANAGER, MIN_RESERVE_PRICE_MANAGER,
+};
 use crate::state::{CONFIG, MIN_RESERVE_PRICES};
 
 use cosmwasm_std::{coin, to_json_binary, Addr, Binary, Coin, Deps, Env, StdResult};
@@ -42,6 +44,9 @@ pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
             end_time,
             query_options.unwrap_or_default(),
         )?),
+        QueryMsg::MinReservePriceManager {} => {
+            to_json_binary(&query_min_reserve_price_manager(deps)?)
+        }
     }
 }
 
@@ -75,6 +80,11 @@ pub fn query_min_reserve_prices(
     Ok(coins)
 }
 
+pub fn query_min_reserve_price_manager(deps: Deps) -> StdResult<String> {
+    let manager = MIN_RESERVE_PRICE_MANAGER.load(deps.storage)?;
+    Ok(manager.to_string())
+}
+
 pub fn query_auction(
     deps: Deps,
     collection: String,

contracts/reserve-auction/src/state.rs

@@ -58,6 +58,7 @@ pub const CONFIG: Item<Config> = Item::new("cfg");
 // A map of acceptable denoms to their minimum reserve price.
 // Denoms not found in the Map are not accepted.
 pub const MIN_RESERVE_PRICES: Map<String, Uint128> = Map::new("mrp");
+pub const MIN_RESERVE_PRICE_MANAGER: Item<Addr> = Item::new("mrpm");
 
 #[cw_serde]
 pub struct HighBid {

contracts/reserve-auction/src/sudo.rs

@@ -1,7 +1,7 @@
 use crate::error::ContractError;
 use crate::helpers::settle_auction;
 use crate::msg::SudoMsg;
-use crate::state::{auctions, Auction, HaltWindow, CONFIG, HALT_MANAGER, MIN_RESERVE_PRICES};
+use crate::state::{auctions, Auction, HaltWindow, CONFIG, HALT_MANAGER};
 
 use cosmwasm_std::{Addr, Coin, Decimal, DepsMut, Env, Event, Order, StdResult};
 use cw_storage_plus::Bound;
@@ -40,10 +40,6 @@ pub fn sudo(deps: DepsMut, env: Env, msg: SudoMsg) -> Result<Response, ContractE
             halt_buffer_duration,
             halt_postpone_duration,
         ),
-        SudoMsg::SetMinReservePrices { min_reserve_prices } => {
-            sudo_set_min_reserve_prices(deps, min_reserve_prices)
-        }
-        SudoMsg::UnsetMinReservePrices { denoms } => sudo_unset_min_reserve_prices(deps, denoms),
     }
 }
 
@@ -205,46 +201,3 @@ pub fn sudo_update_params(
 
     Ok(Response::new().add_event(event))
 }
-
-pub fn sudo_set_min_reserve_prices(
-    deps: DepsMut,
-    min_reserve_prices: Vec<Coin>,
-) -> Result<Response, ContractError> {
-    let mut response = Response::new();
-
-    for min_reserve_price in min_reserve_prices {
-        if MIN_RESERVE_PRICES.has(deps.storage, min_reserve_price.denom.clone()) {
-            return Err(ContractError::InvalidInput(
-                "found duplicate denom".to_string(),
-            ));
-        }
-        MIN_RESERVE_PRICES.save(
-            deps.storage,
-            min_reserve_price.denom.clone(),
-            &min_reserve_price.amount,
-        )?;
-        response = response.add_event(
-            Event::new("set-min-reserve-price")
-                .add_attribute("denom", min_reserve_price.denom)
-                .add_attribute("amount", min_reserve_price.amount),
-        );
-    }
-    Ok(response)
-}
-
-pub fn sudo_unset_min_reserve_prices(
-    deps: DepsMut,
-    denoms: Vec<String>,
-) -> Result<Response, ContractError> {
-    let mut response = Response::new();
-
-    for denom in denoms {
-        if !MIN_RESERVE_PRICES.has(deps.storage, denom.clone()) {
-            return Err(ContractError::InvalidInput("denom not found".to_string()));
-        }
-        MIN_RESERVE_PRICES.remove(deps.storage, denom.clone());
-        response =
-            response.add_event(Event::new("unset-min-reserve-price").add_attribute("denom", denom));
-    }
-    Ok(response)
-}

contracts/reserve-auction/src/tests/setup/setup_auctions.rs

@@ -16,6 +16,7 @@ use super::setup_contracts::*;
 
 pub const DUMMY_DENOM: &str =
     "ibc/773B5B5E24EC48005205A2EB35E6C0743EE47C9147E94BD5A4E0CBB63082314D";
+pub const DUMMY_MIN_RESERVE_PRICE_MANAGER: &str = "min-reserve-price-manager";
 
 pub fn setup_reserve_auction(
     router: &mut StargazeApp,
@@ -39,6 +40,7 @@ pub fn setup_reserve_auction(
             coin(MIN_RESERVE_PRICE, NATIVE_DENOM),
             coin(MIN_RESERVE_PRICE, DUMMY_DENOM),
         ],
+        min_reserve_price_manager: DUMMY_MIN_RESERVE_PRICE_MANAGER.to_string(),
     };
     let auction = router
         .instantiate_contract(