1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use abstract_os::{
    manager::state::OS_ID,
    objects::module::{Module, ModuleInfo},
    version_control::{state::OS_ADDRESSES, Core, ModuleResponse, QueryMsg},
};
use cosmwasm_std::{Addr, QuerierWrapper, StdError};

use cosmwasm_std::StdResult;

/// Get the [`abstract_os::version_control::Core`] object for an os-id.
pub fn get_os_core(
    querier: &QuerierWrapper,
    os_id: u32,
    version_control_addr: &Addr,
) -> StdResult<Core> {
    let maybe_os = OS_ADDRESSES.query(querier, version_control_addr.clone(), os_id)?;
    match maybe_os {
        None => Err(StdError::generic_err(format!(
            "OS with id {} is not active.",
            os_id
        ))),
        Some(core) => Ok(core),
    }
}

/// Verify if the provided manager address is indeed a user.
pub fn verify_os_manager(
    querier: &QuerierWrapper,
    maybe_manager: &Addr,
    version_control_addr: &Addr,
) -> StdResult<Core> {
    let os_id = OS_ID.query(querier, maybe_manager.clone())?;
    let maybe_os = OS_ADDRESSES.query(querier, version_control_addr.clone(), os_id)?;
    match maybe_os {
        None => Err(StdError::generic_err(format!(
            "OS with id {} is not active.",
            os_id
        ))),
        Some(core) => {
            if &core.manager != maybe_manager {
                Err(StdError::generic_err(
                    "Proposed manager is not the manager of this instance.",
                ))
            } else {
                Ok(core)
            }
        }
    }
}

/// Verify if the provided proxy address is indeed a user.
pub fn verify_os_proxy(
    querier: &QuerierWrapper,
    maybe_proxy: &Addr,
    version_control_addr: &Addr,
) -> StdResult<Core> {
    let os_id = OS_ID.query(querier, maybe_proxy.clone())?;
    let maybe_os = OS_ADDRESSES.query(querier, version_control_addr.clone(), os_id)?;
    match maybe_os {
        None => Err(StdError::generic_err(format!(
            "OS with id {} is not active.",
            os_id
        ))),
        Some(core) => {
            if &core.proxy != maybe_proxy {
                Err(StdError::generic_err(
                    "Proposed proxy is not the proxy of this instance.",
                ))
            } else {
                Ok(core)
            }
        }
    }
}

/// Query module information
pub fn get_module(
    querier: &QuerierWrapper,
    module_info: ModuleInfo,
    version_control_addr: &Addr,
) -> StdResult<Module> {
    let resp: ModuleResponse = querier.query_wasm_smart(
        version_control_addr,
        &QueryMsg::Module {
            module: module_info,
        },
    )?;
    Ok(resp.module)
}