Ton

1
() op_deposit(int member, int value) impure {
2

3
    ;; Read extras
4
    var (enabled, udpates_enabled, min_stake, deposit_fee, withdraw_fee, pool_fee, receipt_price) = ctx_extras;
5
    throw_unless(error::invalid_message(), enabled);
6
    
7
    ;; Read stake value
8
    int fee = receipt_price + deposit_fee;
9
    int stake = value - fee;
10
    throw_unless(error::invalid_stake_value(), stake >= min_stake);
11

12
    ;; Load nominators
13
    load_member(member);
14

15
    ;; Add deposit
16
    member_stake_deposit(stake);
17

18
    ;; Resolve address
19
    var address = ctx_owner;
20
    if (member != owner_id()) {
21
        address = serialize_work_addr(member);
22
    }
23

24
    ;; Send receipt
25
    if (ctx_query_id == 0) {
26
        send_text_message(
27
            address,
28
            receipt_price,
29
            send_mode::default(),
30
            begin_cell()
31
                .store_accepted_stake(stake)
32
        );
33
    } else {
34
        send_empty_std_message(
35
            address,
36
            receipt_price,
37
            send_mode::default(),
38
            op::stake_deposit::response(),
39
            ctx_query_id
40
        );
41
    }
42

43
    ;; Persist
44
    store_member();
45
    store_base_data();
46
}
47

48
() op_withdraw(int member, int value, int stake) impure {
49

50
    ;; Read extras
51
    var (enabled, udpates_enabled, min_stake, deposit_fee, withdraw_fee, pool_fee, receipt_price) = ctx_extras;
52

53
    ;; Check fee
54
    int fee = receipt_price + withdraw_fee;
55

56
    ;; Check value
57
    throw_unless(error::too_low_value(), value == fee);
58

59
    ;; Load member
60
    load_member(member);
61

62
    ;; Try to withdraw immediatelly
63
    var (withdrawed, all) = member_stake_withdraw(stake);
64

65
    ;; Resolve address
66
    var address = ctx_owner;
67
    if (member != owner_id()) {
68
        address = serialize_work_addr(member);
69
    }
70
    
71
    ;; Send receipt
72
    if (ctx_query_id == 0) {
73
        send_text_message(
74
            address,
75
            withdrawed + receipt_price,
76
            send_mode::default(),
77
            all ? begin_cell().store_withdraw_completed() : begin_cell().store_withdraw_delayed()
78
        );
79
    } else {    
80
        send_empty_std_message(
81
            address,
82
            withdrawed + receipt_price,
83
            send_mode::default(),
84
            all ? op::stake_withdraw::response() : op::stake_withdraw::delayed(),
85
            ctx_query_id
86
        );
87
    }
88

89
    ;; Persist
90
    store_member();
91
    store_base_data();
92
}
93

94
() op_donate(int value) impure {
95
    
96
    ;; Check value
97
    throw_unless(error::invalid_message(), value >= 2 * coins::1());
98
    
99
    ;; Distribute profit to everyone
100
    distribute_profit(value - coins::1());
101

102
    ;; Persist
103
    store_base_data();
104
}
105

106
() op_upgrade(int value, slice in_msg) impure {
107

108
    ;; Read extras
109
    var (enabled, udpates_enabled, min_stake, deposit_fee, withdraw_fee, pool_fee, receipt_price) = ctx_extras;
110
    throw_unless(error::invalid_message(), udpates_enabled);
111
    
112
    ;; Check value
113
    throw_unless(error::too_low_value(), value >= fees::deploy());
114

115
    ;; Upgrade code
116
    var code = in_msg~load_ref();
117
    in_msg.end_parse();
118
    set_code(code);
119

120
    ;; Send receipt
121
    send_empty_std_message(
122
        ctx_owner,
123
        0,
124
        send_mode::carry_remaining_value(),
125
        op::upgrade::response(),
126
        ctx_query_id
127
    );
128
}
129

130
() op_update(int value, slice in_msg) impure {
131

132
    ;; Read extras
133
    var (enabled, udpates_enabled, min_stake, deposit_fee, withdraw_fee, pool_fee, receipt_price) = ctx_extras;
134

135
    ;; Check value
136
    throw_unless(error::too_low_value(), value >= fees::deploy());
137

138
    ;; Check extras
139
    var newExtras = in_msg~load_ref();
140
    var es = newExtras.begin_parse();
141
    var new_enabled = es~load_int(1);
142
    var new_udpates_enabled = es~load_int(1);
143
    var new_min_stake = es~load_coins();
144
    var new_deposit_fee = es~load_coins();
145
    var new_withdraw_fee = es~load_coins();
146
    var new_pool_fee = es~load_coins();
147
    var new_receipt_price = es~load_coins();
148
    es.end_parse();
149

150
    ;; Once upgrades are disabled: prohibit re-enabling
151
    throw_if(error::invalid_message(), (~ udpates_enabled) & new_udpates_enabled);
152

153
    ;; At least min_stake
154
    throw_unless(error::invalid_message(), new_min_stake >= params::min_stake());
155
    ;; At least op fee
156
    throw_unless(error::invalid_message(), new_deposit_fee >= fees::op());
157
    throw_unless(error::invalid_message(), new_withdraw_fee >= fees::op());
158
    ;; Must be in 0...10000
159
    throw_unless(error::invalid_message(), new_pool_fee <= 100 * 100);
160
    ;; At least receipt price
161
    throw_unless(error::invalid_message(), new_receipt_price >= fees::receipt());
162

163
    ;; Persist extras
164
    ctx_extras = (new_enabled, new_udpates_enabled, new_min_stake, new_deposit_fee, new_withdraw_fee, new_pool_fee, new_receipt_price);
165
    store_base_data();
166

167
    ;; Send receipt
168
    send_empty_std_message(
169
        ctx_owner,
170
        0,
171
        send_mode::carry_remaining_value(),
172
        op::update::response(),
173
        ctx_query_id
174
    );
175
}