asi-migration preparation

fetch/cosmwasm_contract/src/access_control.rs

@@ -1,4 +1,4 @@
-use cosmwasm_std::{Addr, StdError, StdResult, Storage};
+use cosmwasm_std::{Addr, Order, StdError, StdResult, Storage};
 use cosmwasm_storage::{PrefixedStorage, ReadonlyPrefixedStorage};
 use std::str::FromStr;
 
@@ -95,3 +95,71 @@ pub fn ac_revoke_role(
     addr_roles.remove(role.as_bytes());
     Ok(true)
 }
+
+pub fn wipe_all_roles_from_storage(storage: &mut dyn Storage) {
+    let mut roles_storage = PrefixedStorage::new(storage, ACCESS_CONTROL_KEY);
+    let res: Vec<_> = roles_storage.range(None, None, Order::Ascending).collect();
+
+    // Because address is stored as first key it is impossible to clear only specific roles without manually filtering it
+    for val in res {
+        roles_storage.remove(&val.0);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use cosmwasm_std::testing::mock_dependencies;
+
+    #[test]
+    fn test_wipe_all_roles_from_storage() {
+        let mut deps = mock_dependencies();
+
+        let addresses = vec!["a", "b", "c", "d"];
+        let roles = vec![
+            AccessRole::Admin,
+            AccessRole::Approver,
+            AccessRole::Monitor,
+            AccessRole::Relayer,
+        ];
+
+        // Add every role and address combination
+        for address in &addresses {
+            for role in &roles {
+                ac_add_role(
+                    deps.as_mut().storage,
+                    &Addr::unchecked(address.to_string()),
+                    role,
+                )
+                .unwrap();
+            }
+        }
+
+        // Every role and address combination is present
+        for address in &addresses {
+            for role in &roles {
+                assert!(ac_have_role(
+                    deps.as_ref().storage,
+                    &Addr::unchecked(address.to_string()),
+                    role
+                )
+                .unwrap());
+            }
+        }
+
+        // Remove all roles
+        wipe_all_roles_from_storage(deps.as_mut().storage);
+
+        // Every role and address combination was removed
+        for address in &addresses {
+            for role in &roles {
+                assert!(!ac_have_role(
+                    deps.as_ref().storage,
+                    &Addr::unchecked(address.to_string()),
+                    role
+                )
+                .unwrap());
+            }
+        }
+    }
+}

fetch/cosmwasm_contract/src/contract.rs

@@ -17,7 +17,9 @@ use crate::msg::{
 };
 use crate::state::{config, config_read, refunds_add, refunds_have, State};
 
-pub const DEFAULT_DENOM: &str = "afet";
+pub const DEFAULT_DENOM: &str = "aasi";
+pub const DEFAULT_RELAY_EON: u64 = 0;
+pub const DEFAULT_FEES_ACCRUED: Uint128 = Uint128::zero();
 
 /* ***************************************************
  * **************    Initialization      *************
@@ -30,7 +32,29 @@ pub fn instantiate(
     info: MessageInfo,
     msg: InstantiateMsg,
 ) -> StdResult<Response> {
-    let env_message_sender = info.sender;
+    let supply = amount_from_funds(&info.funds, msg.get_denom()).unwrap_or(Uint128::zero());
+    initialise_contract_state(
+        deps.storage,
+        &env,
+        &info.sender,
+        supply,
+        DEFAULT_RELAY_EON,
+        DEFAULT_FEES_ACCRUED,
+        &msg,
+    )?;
+
+    Ok(Response::default())
+}
+
+pub fn initialise_contract_state(
+    storage: &mut dyn Storage,
+    env: &Env,
+    admin: &Addr,
+    supply: Uint128,
+    relay_eon: u64,
+    fees_accrued: Uint128,
+    msg: &InstantiateMsg,
+) -> StdResult<()> {
     let current_block_number = env.block.height;
 
     let mut paused_since_block_public_api = msg.paused_since_block.unwrap_or(u64::MAX);
@@ -39,24 +63,20 @@ pub fn instantiate(
     }
     let paused_since_block_relayer_api = paused_since_block_public_api;
 
-    let contract_addr_human = env.contract.address;
-
     if msg.lower_swap_limit > msg.upper_swap_limit || msg.lower_swap_limit <= msg.swap_fee {
         return Err(StdError::generic_err(ERR_SWAP_LIMITS_INCONSISTENT));
     }
 
-    let denom = msg.denom.unwrap_or_else(|| DEFAULT_DENOM.to_string());
+    let denom = msg.denom.as_deref().unwrap_or(DEFAULT_DENOM);
 
-    ac_add_role(deps.storage, &env_message_sender, &AccessRole::Admin)?;
-
-    let supply = amount_from_funds(&info.funds, denom.clone());
+    ac_add_role(storage, admin, &AccessRole::Admin)?;
 
     let state = State {
-        supply: supply.unwrap_or_else(|_| Uint128::zero()),
-        fees_accrued: Uint128::zero(),
+        supply,
+        fees_accrued,
         next_swap_id: msg.next_swap_id,
         sealed_reverse_swap_id: 0,
-        relay_eon: 0,
+        relay_eon,
         upper_swap_limit: msg.upper_swap_limit,
         lower_swap_limit: msg.lower_swap_limit,
         reverse_aggregated_allowance: msg.reverse_aggregated_allowance,
@@ -65,13 +85,12 @@ pub fn instantiate(
         swap_fee: msg.swap_fee,
         paused_since_block_public_api,
         paused_since_block_relayer_api,
-        denom,
-        contract_addr_human, // optimization FIXME(LR) not needed any more (version 0.10.0)
+        denom: denom.to_string(),
     };
 
-    config(deps.storage).save(&state)?;
+    config(storage).save(&state)?;
 
-    Ok(Response::default())
+    Ok(())
 }
 
 /* ***************************************************
@@ -83,7 +102,7 @@ pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> S
 
     match msg {
         ExecuteMsg::Swap { destination } => {
-            let amount = amount_from_funds(&info.funds, state.denom.clone())?;
+            let amount = amount_from_funds(&info.funds, &state.denom)?;
             try_swap(deps, &env, &state, amount, destination)
         }
         ExecuteMsg::ReverseSwap {
@@ -481,7 +500,7 @@ fn try_deposit(deps: DepsMut, info: &MessageInfo, state: &State) -> StdResult<Re
 
     let env_message_sender = &info.sender;
 
-    let amount = amount_from_funds(&info.funds, state.denom.clone())?;
+    let amount = amount_from_funds(&info.funds, &state.denom)?;
     config(deps.storage).update(|mut state| -> StdResult<_> {
         state.supply += amount;
         Ok(state)
@@ -719,7 +738,7 @@ fn try_renounce_role(deps: DepsMut, info: &MessageInfo, role: String) -> StdResu
  * *****************    Helpers      *****************
  * ***************************************************/
 
-pub fn amount_from_funds(funds: &[Coin], denom: String) -> StdResult<Uint128> {
+pub fn amount_from_funds(funds: &[Coin], denom: &str) -> StdResult<Uint128> {
     for coin in funds {
         if coin.denom == denom {
             return Ok(coin.amount);

fetch/cosmwasm_contract/src/error.rs

@@ -30,6 +30,8 @@ pub const ERR_EON: &str = "[FET_ERR_EON] Tx doesn't belong to current relayEon";
 // refund
 pub const ERR_INVALID_SWAP_ID: &str = "[FET_ERR_INVALID_SWAP_ID] Invalid swap id";
 pub const ERR_ALREADY_REFUNDED: &str = "[FET_ERR_ALREADY_REFUNDED] Refund was already processed";
+pub const ERR_STATE_ERROR: &str = "[FET_ERR_STATE_ERR] Contract state not properly initialised";
+
 #[derive(Error, Debug)]
 pub enum ContractError {
     #[error("{0}")]

fetch/cosmwasm_contract/src/lib.rs

@@ -4,5 +4,6 @@ pub mod error;
 pub mod msg;
 pub mod state;
 
+pub mod migration;
 #[cfg(test)]
 pub mod tests;

fetch/cosmwasm_contract/src/migration.rs

@@ -0,0 +1,29 @@
+use crate::access_control::wipe_all_roles_from_storage;
+use crate::contract::initialise_contract_state;
+use crate::error::ERR_ALREADY_REFUNDED;
+use crate::msg::MigrateMsg;
+use crate::state::is_state_valid;
+use cosmwasm_std::{entry_point, DepsMut, Env, Response, StdError, StdResult};
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn migrate(deps: DepsMut, env: Env, msg: MigrateMsg) -> StdResult<Response> {
+    // Remove all previously registered roles
+    wipe_all_roles_from_storage(deps.storage);
+
+    // Ensure correct contract state
+    if let Some(re_init) = msg.re_init {
+        initialise_contract_state(
+            deps.storage,
+            &env,
+            &re_init.admin,
+            re_init.supply,
+            re_init.relay_eon,
+            re_init.fees_accrued,
+            &re_init.init_msg,
+        )?;
+    } else if !is_state_valid(deps.storage) {
+        return Err(StdError::generic_err(ERR_ALREADY_REFUNDED));
+    }
+
+    Ok(Response::default())
+}

fetch/cosmwasm_contract/src/msg.rs

@@ -1,6 +1,7 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+use crate::contract::DEFAULT_DENOM;
 use cosmwasm_std::Addr;
 
 //use crate::cosmwasm_bignumber::{Uint256};
@@ -20,6 +21,12 @@ pub struct InstantiateMsg {
     pub denom: Option<String>,
 }
 
+impl InstantiateMsg {
+    pub fn get_denom(&self) -> &str {
+        self.denom.as_deref().unwrap_or(DEFAULT_DENOM)
+    }
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
@@ -155,3 +162,17 @@ pub struct PausedSinceBlockResponse {
 pub struct DenomResponse {
     pub denom: String,
 }
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+pub struct ReInitMsg {
+    pub init_msg: InstantiateMsg,
+    pub admin: Addr,
+    pub supply: Uint128,
+    pub relay_eon: u64,
+    pub fees_accrued: Uint128,
+}
+
+#[derive(Serialize, Deserialize, JsonSchema)]
+pub struct MigrateMsg {
+    pub re_init: Option<ReInitMsg>,
+}

fetch/cosmwasm_contract/src/state.rs

@@ -2,7 +2,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use crate::msg::Uint128;
-use cosmwasm_std::{Addr, Storage};
+use cosmwasm_std::Storage;
 use cosmwasm_storage::{
     singleton, singleton_read, PrefixedStorage, ReadonlyPrefixedStorage, ReadonlySingleton,
     Singleton,
@@ -28,9 +28,6 @@ pub struct State {
     pub paused_since_block_public_api: u64,
     pub paused_since_block_relayer_api: u64,
     pub denom: String,
-
-    // optimization FIXME(LR) Not needed any more with version 0.10.0
-    pub contract_addr_human: Addr,
 }
 
 pub fn config(storage: &mut dyn Storage) -> Singleton<State> {
@@ -50,3 +47,7 @@ pub fn refunds_have(swap_id: u64, storage: &dyn Storage) -> bool {
     let store = ReadonlyPrefixedStorage::new(storage, REFUNDS_KEY);
     store.get(&swap_id.to_be_bytes()).is_some()
 }
+
+pub fn is_state_valid(storage: &dyn Storage) -> bool {
+    config_read(storage).load().is_ok()
+}