ve3-shared 0.9.1

ve(3,3) msgs in cosmwasm
Documentation 
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use cosmwasm_std::{Addr, QuerierWrapper};
use cw_ownable::Ownership;
use cw_storage_plus::{Item, Map};

use crate::error::SharedError;

pub struct GlobalConfig(pub Addr);

pub const OWNERSHIP: Item<Ownership<Addr>> = Item::new("ownership");
pub const ADDRESSES: Map<String, Addr> = Map::new("addresses");
pub const ADDRESS_LIST: Map<String, Vec<Addr>> = Map::new("address_list");

impl GlobalConfig {
  pub fn assert_owner(&self, querier: &QuerierWrapper, sender: &Addr) -> Result<(), SharedError> {
    let ownership = OWNERSHIP.query(querier, self.0.clone())?;

    match ownership.owner {
      Some(owner) => {
        if *sender == owner {
          Ok(())
        } else {
          Err(SharedError::Unauthorized {})
        }
      },
      None => Err(SharedError::Unauthorized {}),
    }
  }

  pub fn assert_owner_or_address_type(
    &self,
    querier: &QuerierWrapper,
    address_type: &str,
    sender: &Addr,
  ) -> Result<(), SharedError> {
    let ownership = OWNERSHIP.query(querier, self.0.clone())?;
    if let Some(owner) = ownership.owner {
      if *sender == owner {
        return Ok(());
      }
    }

    self.assert_has_access(querier, address_type, sender)
  }

  pub fn get_address(
    &self,
    querier: &QuerierWrapper,
    address_type: &str,
  ) -> Result<Addr, SharedError> {
    let address = ADDRESSES.query(querier, self.0.clone(), address_type.to_string())?;

    match address {
      Some(addr) => Ok(addr),
      None => Err(SharedError::NotFound(format!("Address Type {0}", address_type))),
    }
  }

  pub fn is_in_list(
    &self,
    querier: &QuerierWrapper,
    address_type: &str,
    sender: &Addr,
  ) -> Result<bool, SharedError> {
    let address_list = ADDRESS_LIST.query(querier, self.0.clone(), address_type.to_string())?;
    if let Some(allowed) = address_list {
      if allowed.contains(sender) {
        return Ok(true);
      }
    }

    Ok(false)
  }

  pub fn assert_has_access(
    &self,
    querier: &QuerierWrapper,
    address_type: &str,
    sender: &Addr,
  ) -> Result<(), SharedError> {
    // check if the address_type is allowed through the address
    let address = ADDRESSES.query(querier, self.0.clone(), address_type.to_string())?;
    if let Some(allowed) = address {
      if allowed == *sender {
        return Ok(());
      }
    }

    // fallback check if the address_type is allowed through the address list
    let address_list = ADDRESS_LIST.query(querier, self.0.clone(), address_type.to_string())?;
    if let Some(allowed) = address_list {
      if allowed.contains(sender) {
        return Ok(());
      }
    }
    Err(SharedError::UnauthorizedMissingRight(address_type.to_string(), sender.to_string()))
  }
}

pub trait ConfigExt {
  fn get_address(&self, querier: &QuerierWrapper, address_type: &str) -> Result<Addr, SharedError>;

  fn global_config(&self) -> GlobalConfig;
}

impl ConfigExt for crate::msgs_asset_staking::Config {
  fn get_address(&self, querier: &QuerierWrapper, address_type: &str) -> Result<Addr, SharedError> {
    GlobalConfig(self.global_config_addr.clone()).get_address(querier, address_type)
  }

  fn global_config(&self) -> GlobalConfig {
    GlobalConfig(self.global_config_addr.clone())
  }
}
impl ConfigExt for crate::msgs_voting_escrow::Config {
  fn get_address(&self, querier: &QuerierWrapper, address_type: &str) -> Result<Addr, SharedError> {
    GlobalConfig(self.global_config_addr.clone()).get_address(querier, address_type)
  }

  fn global_config(&self) -> GlobalConfig {
    GlobalConfig(self.global_config_addr.clone())
  }
}

impl ConfigExt for crate::msgs_asset_gauge::Config {
  fn get_address(&self, querier: &QuerierWrapper, address_type: &str) -> Result<Addr, SharedError> {
    GlobalConfig(self.global_config_addr.clone()).get_address(querier, address_type)
  }

  fn global_config(&self) -> GlobalConfig {
    GlobalConfig(self.global_config_addr.clone())
  }
}

impl ConfigExt for crate::msgs_connector_alliance::Config {
  fn get_address(&self, querier: &QuerierWrapper, address_type: &str) -> Result<Addr, SharedError> {
    GlobalConfig(self.global_config_addr.clone()).get_address(querier, address_type)
  }

  fn global_config(&self) -> GlobalConfig {
    GlobalConfig(self.global_config_addr.clone())
  }
}

impl ConfigExt for crate::msgs_bribe_manager::Config {
  fn get_address(&self, querier: &QuerierWrapper, address_type: &str) -> Result<Addr, SharedError> {
    GlobalConfig(self.global_config_addr.clone()).get_address(querier, address_type)
  }

  fn global_config(&self) -> GlobalConfig {
    GlobalConfig(self.global_config_addr.clone())
  }
}

impl ConfigExt for crate::msgs_connector_emission::Config {
  fn get_address(&self, querier: &QuerierWrapper, address_type: &str) -> Result<Addr, SharedError> {
    GlobalConfig(self.global_config_addr.clone()).get_address(querier, address_type)
  }

  fn global_config(&self) -> GlobalConfig {
    GlobalConfig(self.global_config_addr.clone())
  }
}