andromeda-std 1.0.0

The standard library for creating an Andromeda Digital Object
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

use crate::ado_contract::state::ADOContract;
use crate::{
    ado_base::{
        ado_type::TypeResponse,
        block_height::BlockHeightResponse,
        kernel_address::KernelAddressResponse,
        ownership::{ContractOwnerResponse, PublisherResponse},
        version::VersionResponse,
        AndromedaQuery,
    },
    common::encode_binary,
    error::ContractError,
};
use cosmwasm_std::{from_json, to_json_binary, Binary, Deps, Env};
use cw2::get_contract_version;
use serde::Serialize;

impl<'a> ADOContract<'a> {
    #[allow(unreachable_patterns)]
    pub fn query(
        &self,
        deps: Deps,
        _env: Env,
        msg: impl Serialize,
    ) -> Result<Binary, ContractError> {
        let msg = to_json_binary(&msg)?;

        match from_json::<AndromedaQuery>(&msg) {
            Ok(msg) => match msg {
                AndromedaQuery::Owner {} => encode_binary(&self.query_contract_owner(deps)?),
                AndromedaQuery::OriginalPublisher {} => {
                    encode_binary(&self.query_original_publisher(deps)?)
                }
                AndromedaQuery::Type {} => encode_binary(&self.query_type(deps)?),
                AndromedaQuery::BlockHeightUponCreation {} => {
                    encode_binary(&self.query_block_height_upon_creation(deps)?)
                }
                AndromedaQuery::KernelAddress {} => {
                    encode_binary(&self.query_kernel_address(deps)?)
                }
                AndromedaQuery::Version {} => encode_binary(&self.query_version(deps)?),
                AndromedaQuery::OwnershipRequest {} => {
                    encode_binary(&self.ownership_request(deps.storage)?)
                }
                #[cfg(feature = "modules")]
                AndromedaQuery::Module { id } => encode_binary(&self.query_module(deps, id)?),
                #[cfg(feature = "modules")]
                AndromedaQuery::ModuleIds {} => encode_binary(&self.query_module_ids(deps)?),
                AndromedaQuery::AppContract {} => {
                    encode_binary(&self.get_app_contract(deps.storage)?)
                }
                AndromedaQuery::Permissions {
                    actor,
                    limit,
                    start_after,
                } => encode_binary(&self.query_permissions(deps, actor, limit, start_after)?),
                AndromedaQuery::PermissionedActions {} => {
                    encode_binary(&self.query_permissioned_actions(deps)?)
                }
                _ => Err(ContractError::UnsupportedOperation {}),
            },
            Err(_) => Err(ContractError::UnsupportedOperation {}),
        }
    }
}

impl<'a> ADOContract<'a> {
    #[inline]
    pub fn query_contract_owner(&self, deps: Deps) -> Result<ContractOwnerResponse, ContractError> {
        let owner = self.owner.load(deps.storage)?;

        Ok(ContractOwnerResponse {
            owner: owner.to_string(),
        })
    }

    #[inline]
    pub fn query_kernel_address(&self, deps: Deps) -> Result<KernelAddressResponse, ContractError> {
        let kernel_address = self.kernel_address.load(deps.storage)?;
        Ok(KernelAddressResponse { kernel_address })
    }

    #[inline]
    pub fn query_original_publisher(&self, deps: Deps) -> Result<PublisherResponse, ContractError> {
        let original_publisher = self.original_publisher.load(deps.storage)?.to_string();
        Ok(PublisherResponse { original_publisher })
    }

    #[inline]
    pub fn query_block_height_upon_creation(
        &self,
        deps: Deps,
    ) -> Result<BlockHeightResponse, ContractError> {
        let block_height = self.block_height.load(deps.storage)?;
        Ok(BlockHeightResponse { block_height })
    }

    #[inline]
    pub fn query_type(&self, deps: Deps) -> Result<TypeResponse, ContractError> {
        let ado_type = self.ado_type.load(deps.storage)?;
        Ok(TypeResponse { ado_type })
    }

    #[inline]
    pub fn query_version(&self, deps: Deps) -> Result<VersionResponse, ContractError> {
        let contract_version = get_contract_version(deps.storage)?;
        Ok(VersionResponse {
            version: contract_version.version,
        })
    }
}