cosm-orc 1.0.0

Cosmwasm smart contract orchestration and gas profiling library
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

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

use super::error::ContractMapError;

pub type ContractName = String;

#[derive(Debug, Serialize, Deserialize)]
pub struct ContractMap {
    map: HashMap<ContractName, DeployInfo>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct DeployInfo {
    pub code_id: u64,
    pub address: Option<String>,
}

impl ContractMap {
    /// Creates a new ContractMap from a given map of ContractName -> CodeIDs
    pub fn new(code_map: &HashMap<String, u64>) -> Self {
        let mut map = HashMap::new();
        for (name, code_id) in code_map {
            map.insert(
                name.clone(),
                DeployInfo {
                    code_id: *code_id,
                    address: None,
                },
            );
        }
        Self { map }
    }

    /// Registers a new code id and contract name with the contract map
    pub fn register_contract<S: Into<String>>(&mut self, name: S, code_id: u64) {
        self.map.insert(
            name.into(),
            DeployInfo {
                code_id,
                address: None,
            },
        );
    }

    /// Returns the stored code id for a given contract name
    pub fn code_id(&self, name: &str) -> Result<u64, ContractMapError> {
        let info = self
            .map
            .get(name)
            .ok_or(ContractMapError::NotStored { name: name.into() })?;
        Ok(info.code_id)
    }

    /// Returns the stored contract address for a given contract name
    pub fn address(&self, name: &str) -> Result<String, ContractMapError> {
        self.map
            .get(name)
            .ok_or(ContractMapError::NotStored { name: name.into() })?
            .address
            .clone()
            .ok_or(ContractMapError::NotDeployed { name: name.into() })
    }

    /// Registers a contract address with an already stored contract
    pub fn add_address<S: Into<String>>(
        &mut self,
        name: &str,
        address: S,
    ) -> Result<(), ContractMapError> {
        self.map
            .get_mut(name)
            .ok_or(ContractMapError::NotStored { name: name.into() })?
            .address = Some(address.into());
        Ok(())
    }

    /// Returns current deploy info
    pub fn deploy_info(&self) -> &HashMap<String, DeployInfo> {
        &self.map
    }
}