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

#[cfg(not(feature = "library"))]
pub mod contract;
pub mod error;
pub mod msg;
pub mod state;

pub type InstantiateMsg = sg721::InstantiateMsg;

pub mod entry {
    use super::*;
    use crate::error::ContractError;
    use crate::msg::QueryMsg;
    use crate::{
        contract::{
            _instantiate, _migrate, execute_enable_updatable, execute_freeze_token_metadata,
            execute_update_token_metadata, query_enable_updatable, query_enable_updatable_fee,
            query_frozen_token_metadata, Sg721UpdatableContract,
        },
        msg::ExecuteMsg,
    };
    use cosmwasm_std::{entry_point, to_json_binary, Empty};
    use cosmwasm_std::{Binary, Deps, DepsMut, Env, MessageInfo, StdResult};
    use cw721_base::Extension;

    use sg_std::Response;

    #[entry_point]
    pub fn instantiate(
        deps: DepsMut,
        env: Env,
        info: MessageInfo,
        msg: InstantiateMsg,
    ) -> Result<Response, ContractError> {
        _instantiate(deps, env, info, msg)
    }

    #[entry_point]
    pub fn execute(
        deps: DepsMut,
        env: Env,
        info: MessageInfo,
        msg: ExecuteMsg<Extension, Empty>,
    ) -> Result<Response, ContractError> {
        match msg {
            ExecuteMsg::FreezeTokenMetadata {} => execute_freeze_token_metadata(deps, env, info),
            ExecuteMsg::EnableUpdatable {} => execute_enable_updatable(deps, env, info),
            ExecuteMsg::UpdateTokenMetadata {
                token_id,
                token_uri,
            } => execute_update_token_metadata(deps, env, info, token_id, token_uri),
            _ => Sg721UpdatableContract::default()
                .execute(deps, env, info, msg.into())
                .map_err(|e| e.into()),
        }
    }

    #[entry_point]
    pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
        match msg {
            QueryMsg::EnableUpdatable {} => to_json_binary(&query_enable_updatable(deps)?),
            QueryMsg::EnableUpdatableFee {} => to_json_binary(&query_enable_updatable_fee()?),
            QueryMsg::FreezeTokenMetadata {} => to_json_binary(&query_frozen_token_metadata(deps)?),
            _ => Sg721UpdatableContract::default().query(deps, env, msg.into()),
        }
    }

    #[entry_point]
    pub fn migrate(deps: DepsMut, env: Env, msg: Empty) -> Result<Response, ContractError> {
        _migrate(deps, env, msg)
    }
}