abstract-app 0.26.1

base app contract implementation
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

pub use abstract_std::app;
pub use cosmwasm_std::testing::*;
use cosmwasm_std::{Response, StdError};

pub type CounterResult<T = Response> = Result<T, CounterError>;

#[cosmwasm_schema::cw_serde]
pub struct CounterInitMsg;

#[cosmwasm_schema::cw_serde]
pub enum CounterExecMsg {
    UpdateConfig {},
}

#[cosmwasm_schema::cw_serde]
pub struct CounterQueryMsg;

#[cosmwasm_schema::cw_serde]
pub struct CounterMigrateMsg;

#[cosmwasm_schema::cw_serde]
pub struct CounterReceiveMsg;

#[cosmwasm_schema::cw_serde]
pub struct CounterSudoMsg;

abstract_app::app_msg_types!(CounterApp, CounterExecMsg, CounterQueryMsg);

use abstract_app::{AppContract, AppError};
use abstract_sdk::AbstractSdkError;
use cw_controllers::AdminError;
use thiserror::Error;

// ANCHOR: error
#[derive(Error, Debug, PartialEq)]
pub enum CounterError {
    #[error(transparent)]
    Std(#[from] StdError),

    #[error(transparent)]
    DappError(#[from] AppError),

    #[error(transparent)]
    Abstract(#[from] abstract_std::AbstractError),

    #[error(transparent)]
    AbstractSdk(#[from] AbstractSdkError),

    #[error(transparent)]
    Unauthorized(#[from] AdminError),
}
// ANCHOR_END: error

// ANCHOR: counter_app
pub type CounterApp = AppContract<
    CounterError,
    CounterInitMsg,
    CounterExecMsg,
    CounterQueryMsg,
    CounterMigrateMsg,
    CounterSudoMsg,
>;
// ANCHOR_END: counter_app

const COUNTER_ID: &str = "example:counter";
const APP_VERSION: &str = "1.0.0";

// ANCHOR: handlers
// ANCHOR: new
pub const COUNTER_APP: CounterApp = CounterApp::new(COUNTER_ID, APP_VERSION, None)
    // ANCHOR_END: new
    .with_instantiate(handlers::instantiate)
    .with_execute(handlers::execute)
    .with_query(handlers::query)
    .with_sudo(handlers::sudo)
    .with_replies(&[(1u64, handlers::reply)])
    .with_migrate(handlers::migrate);
// ANCHOR_END: handlers

// ANCHOR: export
abstract_app::export_endpoints!(COUNTER_APP, CounterApp);
// ANCHOR_END: export

// ANCHOR: interface
abstract_app::cw_orch_interface!(COUNTER_APP, CounterApp, CounterAppInterface);
// ANCHOR_END: interface

mod handlers {
    #![allow(non_upper_case_globals)]
    use abstract_sdk::{base::*, AbstractResponse};
    use cosmwasm_std::*;

    use super::*;

    pub const instantiate: InstantiateHandlerFn<CounterApp, CounterInitMsg, CounterError> =
        |_, _, _, _, _| Ok(Response::new().set_data("counter_init".as_bytes()));
    pub const query: QueryHandlerFn<CounterApp, CounterQueryMsg, CounterError> =
        |_, _, _, _| to_json_binary("counter_query").map_err(Into::into);
    pub const sudo: SudoHandlerFn<CounterApp, CounterSudoMsg, CounterError> =
        |_, _, _, _| Ok(Response::new().set_data("counter_sudo".as_bytes()));
    pub const reply: ReplyHandlerFn<CounterApp, CounterError> = |_, _, _, msg| {
        #[allow(deprecated)]
        Ok(Response::new().set_data(msg.result.unwrap().data.unwrap()))
    };
    pub const migrate: MigrateHandlerFn<CounterApp, CounterMigrateMsg, CounterError> =
        |_, _, _, _| Ok(Response::new().set_data("counter_migrate".as_bytes()));
    // ANCHOR: execute
    pub fn execute(
        deps: DepsMut,
        env: Env,
        info: MessageInfo,
        module: CounterApp, // <-- Notice how the `CounterApp` is available here
        msg: CounterExecMsg,
    ) -> CounterResult {
        match msg {
            CounterExecMsg::UpdateConfig {} => update_config(deps, env, info, module),
        }
    }

    /// Update the configuration of the app
    fn update_config(
        deps: DepsMut,
        env: Env,
        msg_info: MessageInfo,
        module: CounterApp,
    ) -> CounterResult {
        // Only the admin should be able to call this
        module
            .admin
            .assert_admin(deps.as_ref(), &env, &msg_info.sender)?;

        Ok(module
            .response("update_config")
            .set_data("counter_exec".as_bytes()))
    }
    // ANCHOR_END: execute
}

fn main() {}