cosm-orc 2.5.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

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

use super::error::ContractMapError;

pub type ContractName = String;

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

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

impl ContractMap {
    /// Creates a new ContractMap from an existing configured ContractMap
    pub fn new(contract_deploys: HashMap<ContractName, DeployInfo>) -> Self {
        Self {
            map: contract_deploys,
        }
    }

    /// 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
    }
}