mars-core 1.0.0

Mars is a fully automated, on-chain credit protocol built on Terra and governed by a decentralised community of users and developers
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

use crate::math::decimal::Decimal;
use cosmwasm_std::{to_binary, Binary, ContractResult, QuerierResult, Uint128};
use std::collections::HashMap;
use terra_cosmwasm::{
    ExchangeRateItem, ExchangeRatesResponse, TaxCapResponse, TaxRateResponse, TerraQuery,
    TerraRoute,
};

pub struct NativeQuerier {
    /// maps denom to exchange rates
    pub exchange_rates: HashMap<String, HashMap<String, Decimal>>,
    /// maps denom to tax caps
    pub tax_caps: HashMap<String, Uint128>,
    pub tax_rate: Decimal,
}

impl Default for NativeQuerier {
    fn default() -> Self {
        NativeQuerier {
            exchange_rates: HashMap::new(),
            tax_caps: HashMap::new(),
            tax_rate: Decimal::zero(),
        }
    }
}

impl NativeQuerier {
    pub fn handle_query(&self, route: &TerraRoute, query_data: &TerraQuery) -> QuerierResult {
        match route {
            TerraRoute::Oracle => {
                if let TerraQuery::ExchangeRates {
                    base_denom,
                    quote_denoms,
                } = query_data
                {
                    return self.query_oracle(base_denom, quote_denoms);
                }
                let err: ContractResult<Binary> = Err(format!(
                    "[mock]: Unsupported query data for QueryRequest::Custom : {:?}",
                    query_data
                ))
                .into();

                Ok(err).into()
            }

            TerraRoute::Treasury => {
                let ret: ContractResult<Binary> = match query_data {
                    TerraQuery::TaxRate {} => {
                        let res = TaxRateResponse {
                            rate: self.tax_rate.to_std_decimal(),
                        };
                        to_binary(&res).into()
                    }

                    TerraQuery::TaxCap { denom } => match self.tax_caps.get(denom) {
                        Some(cap) => {
                            let res = TaxCapResponse { cap: *cap };
                            to_binary(&res).into()
                        }
                        None => Err(format!(
                            "no tax cap available for provided denom: {}",
                            denom
                        ))
                        .into(),
                    },

                    _ => Err(format!(
                        "[mock]: Unsupported query data for QueryRequest::Custom : {:?}",
                        query_data
                    ))
                    .into(),
                };

                Ok(ret).into()
            }

            _ => {
                let err: ContractResult<Binary> = Err(format!(
                    "[mock]: Unsupported query data for QueryRequest::Custom : {:?}",
                    query_data
                ))
                .into();

                Ok(err).into()
            }
        }
    }

    fn query_oracle(&self, base_denom: &str, quote_denoms: &[String]) -> QuerierResult {
        let base_exchange_rates = match self.exchange_rates.get(base_denom) {
            Some(res) => res,
            None => {
                let err: ContractResult<Binary> = Err(format!(
                    "no exchange rates available for provided base denom: {}",
                    base_denom
                ))
                .into();
                return Ok(err).into();
            }
        };

        let exchange_rate_items: Result<Vec<ExchangeRateItem>, String> = quote_denoms
            .iter()
            .map(|denom| {
                let exchange_rate = match base_exchange_rates.get(denom) {
                    Some(rate) => rate,
                    None => return Err(format!("no exchange rate available for {}", denom)),
                };

                Ok(ExchangeRateItem {
                    quote_denom: denom.into(),
                    exchange_rate: exchange_rate.to_std_decimal(),
                })
            })
            .collect();

        let res = ExchangeRatesResponse {
            base_denom: base_denom.into(),
            exchange_rates: exchange_rate_items.unwrap(),
        };
        let cr: ContractResult<Binary> = to_binary(&res).into();
        Ok(cr).into()
    }
}