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

use fadroma::{prelude::*, derive_contract::*};

mod state;
use state::State;

pub mod interface;
use interface::StateResponse;

#[contract_impl(entry, path = "interface")]
pub trait Contract {
    #[init]
    fn new(initial_value: u64) -> StdResult<InitResponse> {
        State::save_state(
            &mut deps.storage,
            &State {
                value: initial_value,
            },
        )?;
        Ok(InitResponse::default())
    }

    #[handle]
    fn add(value: u64) -> StdResult<HandleResponse> {
        let mut state = State::load_state(&deps.storage)?;

        state.value += value;
        State::save_state(&mut deps.storage, &state)?;

        Ok(HandleResponse::default())
    }

    #[handle]
    fn sub(value: u64) -> StdResult<HandleResponse> {
        let mut state = State::load_state(&deps.storage)?;

        state.value -= value;
        State::save_state(&mut deps.storage, &state)?;

        Ok(HandleResponse::default())
    }

    #[handle]
    fn mul(value: u64) -> StdResult<HandleResponse> {
        let mut state = State::load_state(&deps.storage)?;

        state.value *= value;
        State::save_state(&mut deps.storage, &state)?;

        Ok(HandleResponse::default())
    }

    #[handle]
    fn div(value: u64) -> StdResult<HandleResponse> {
        let mut state = State::load_state(&deps.storage)?;

        state.value /= value;
        State::save_state(&mut deps.storage, &state)?;

        Ok(HandleResponse::default())
    }

    #[query]
    fn state() -> StdResult<StateResponse> {
        let state = State::load_state(&deps.storage)?;

        Ok(StateResponse { value: state.value })
    }
}