synnax 0.1.4

Cosmos-SDK multichain client
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

use crate::cosmos::types::Coin;
use crate::cosmos::wasm::{StateEntry, WasmContractResponse};
use crate::cosmos::Cosmos;
use core::str;
use log::info;
use std::collections::BTreeMap;

#[derive(Clone)]
pub enum ItemOrMap {
    Item { value: String },
    Map { map: BTreeMap<String, String> },
}

#[derive(Clone)]
pub struct Contract {
    pub contract: WasmContractResponse,
    pub funds: Vec<Coin>,
    pub state: BTreeMap<String, ItemOrMap>,
}

impl Contract {
    fn get_string_or_int(key: String) -> Result<String, anyhow::Error> {
        if &key.as_str()[0..2] == "00" {
            let possible_int = vec![2usize, 4usize, 8usize, 16usize, 32usize];
            if possible_int.contains(&key.len()) {
                let num = match key.len() {
                    2usize => i128::from_str_radix(&key.as_str()[0..2], 16),
                    4usize => i128::from_str_radix(&key.as_str()[0..4], 16),
                    8usize => i128::from_str_radix(&key.as_str()[0..8], 16),
                    16usize => i128::from_str_radix(&key.as_str()[0..16], 16),
                    32usize => i128::from_str_radix(&key.as_str()[0..32], 16),
                    64usize => i128::from_str_radix(&key.as_str()[0..32], 16),
                    _ => i128::from_str_radix(key.as_str(), 16),
                };

                if let Ok(valid_number) = num {
                    return Ok(valid_number.to_string());
                }
            }
        }

        let data = hex::decode(key.as_str()).expect("Decoding failed");
        Ok(str::from_utf8(&data).expect("DECODE FAILURE").to_string())
    }

    fn get_map_key_index(key: String) -> Result<Option<(String, String)>, anyhow::Error> {
        if key.len() > 4 {
            let size = u16::from_str_radix(&key.as_str()[0..4], 16);

            if let Ok(len) = size {
                // to digit by character in hexa
                let hex_len = ((len + 2) * 2) as usize;

                if hex_len < key.len() {
                    let value = &key.as_str()[hex_len as usize..key.len()];
                    let key = &key.as_str()[4usize..hex_len as usize];
                    let parsed_key = str::from_utf8(&hex::decode(&key)?)
                        .expect("INVALID_VALUE")
                        .to_string();

                    return Ok(Some((
                        parsed_key,
                        Contract::get_string_or_int(value.to_string())?,
                    )));
                }
            }
        }
        Ok(None)
    }

    pub fn new(cosmos: Cosmos, address: String) -> Result<Self, anyhow::Error> {
        let mut all_data: Vec<StateEntry> = vec![];
        let contract = cosmos.wasm.contract(address.clone())?;
        let mut cosmos_data = cosmos.wasm.contract_state(address.to_string(), None)?;
        let funds = cosmos.bank.balances(address.to_string())?.balances;
        all_data.append(&mut cosmos_data.models);

        while let Some(key) = cosmos_data.pagination.next_key {
            info!("key");
            cosmos_data = cosmos.wasm.contract_state(address.to_string(), Some(key))?;
            all_data.append(&mut cosmos_data.models);
        }

        info!("found {} elems", all_data.len());

        let mut state = BTreeMap::new();

        for data in all_data {
            log::trace!("decoding {} => {}", data.key, data.value);
            let res = Contract::get_map_key_index(data.key.clone());

            let base64_data = base64::decode(data.value.as_str()).expect("INVALID_VALUE");
            let decoded_value = str::from_utf8(&base64_data).expect("INVALID_VALUE");
            let decoded_key;

            if let Ok(Some((key, index))) = res {
                let entry = state.entry(key.clone()).or_insert(ItemOrMap::Map {
                    map: BTreeMap::new(),
                });
                match entry {
                    ItemOrMap::Map { map } => {
                        map.insert(index.clone(), decoded_value.to_string());
                    }
                    ItemOrMap::Item { value } => log::error!("invalid item for map {}", value),
                }
            } else {
                let temp = hex::decode(data.key.as_str()).expect("Decoding failed");
                decoded_key = str::from_utf8(&temp).expect("INVALID_KEY").to_string();
                if state.contains_key(&decoded_key) {
                    log::error!("error overwriting {}", decoded_key);
                }
                state.insert(
                    decoded_key.clone(),
                    ItemOrMap::Item {
                        value: decoded_value.to_string(),
                    },
                );
            }
        }

        for (key, val) in &state {
            match val {
                ItemOrMap::Item { value } => log::info!("{} => {}", key, value),
                ItemOrMap::Map { map } => log::info!("{} => {} entries", key, map.len()),
            }
        }

        Ok(Contract {
            contract,
            state,
            funds,
        })
    }
}