entropycli 1.0.8

Entropy CLI for developing using the Entropic Labs Entropy Beacon
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

use cosmrs::{cosmwasm::MsgStoreCodeResponse};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use super::tx::TxError;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Event {
    #[serde(rename = "type")]
    pub type_: String,
    #[serde(serialize_with = "serialization::serialize_attributes")]
    #[serde(deserialize_with = "serialization::deserialize_attributes")]
    pub attributes: HashMap<String, String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TxLogEntry {
    pub msg_index: u32,
    pub log: String,
    pub events: Vec<Event>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TxResponse {
    pub code: u32,
    pub codespace: String,
    pub data: String,
    pub gas_wanted: String,
    pub gas_used: String,
    pub height: String,
    pub info: String,
    pub txhash: String,
    pub logs: Vec<TxLogEntry>,
    pub timestamp: String,
}

mod serialization {
    use std::collections::HashMap;

    use serde::{ser::SerializeSeq, Deserialize};
    use serde_json::json;

    pub(crate) fn serialize_attributes<S>(
        attrs: &HashMap<String, String>,
        serializer: S,
    ) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        // Serialize each kv as {"key": k, "value": v}
        let attrs = attrs
            .iter()
            .map(|(k, v)| json!({"key": k, "value": v}))
            .collect::<Vec<_>>();
        let mut seq = serializer.serialize_seq(Some(attrs.len()))?;
        for attr in attrs {
            seq.serialize_element(&attr)?;
        }
        seq.end()
    }

    pub(crate) fn deserialize_attributes<'de, D>(
        deserializer: D,
    ) -> Result<HashMap<String, String>, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        // Deserialize each kv in the list from {"key": k, "value": v} to HashMap
        #[derive(Deserialize)]
        struct Attr {
            key: String,
            value: String,
        }
        let attrs = Vec::<Attr>::deserialize(deserializer)?;
        Ok(attrs
            .into_iter()
            .map(|attr| (attr.key, attr.value))
            .collect::<HashMap<_, _>>())
    }
}

impl TryFrom<TxResponse> for MsgStoreCodeResponse {
    type Error = TxError;
    fn try_from(tx: TxResponse) -> Result<Self, Self::Error> {
        let code_id = tx
            .logs
            .iter()
            .find(|log| {
                log.events.iter().any(|event| {
                    event.attributes.get("action")
                        == Some(&"/cosmwasm.wasm.v1.MsgStoreCode".to_string())
                })
            })
            .and_then(|log| {
                log.events
                    .iter()
                    .find_map(|event| event.attributes.get("code_id").cloned())
            })
            .map(|code_id| {
                code_id
                    .parse::<u64>()
                    .map_err(|_| TxError::Parse("Unable to parse code_id".to_string()))
            })
            .transpose()?
            .ok_or_else(|| TxError::Parse("Unable to find code_id in logs".to_string()))?;

        Ok(MsgStoreCodeResponse { code_id })
    }
}

// #[derive(Debug, Clone, Serialize, Deserialize)]
// pub struct MsgInstantiateContractResponse {
//     pub address: AccountId,

// }