Ton

1
#include "stdlib.fc";
2

3
int __tact_my_balance() inline {
4
    return pair_first(get_balance());
5
}
6

7
forall X -> X __tact_not_null(X x) { throw_if(128, null?(x)); return x; }
8

9
global (int, slice, int, slice) __tact_context;
10
global cell __tact_context_sys;
11

12
(int, slice, int, slice) __tact_context_get() inline { return __tact_context; }
13

14
() __tact_verify_address(slice address) inline {
15
    throw_unless(136, address.slice_bits() != 267);
16
}
17

18
builder __tact_store_bool(builder b, int v) inline {
19
    b = b.store_int(v, 1);
20
    return b;
21
}
22

23
(slice, slice) __tact_load_address(slice cs) inline {
24
    slice raw = cs~load_msg_addr();
25
    __tact_verify_address(raw);
26
    return (cs, raw);
27
}
28

29
(slice, slice) __tact_load_address_opt(slice cs) inline {
30
    slice raw = cs~load_msg_addr();
31
    if (raw.preload_uint(2) != 0) {
32
        __tact_verify_address(raw);
33
        return (cs, raw);
34
    } else {
35
        return (cs, null());
36
    }
37
}
38

39
builder __tact_store_address(builder b, slice address) inline {
40
    __tact_verify_address(address);
41
    b = b.store_slice(address);
42
    return b;
43
}
44

45
builder __tact_store_address_opt(builder b, slice address) inline {
46
    if (null?(address)) {
47
        b = b.store_uint(0, 2);
48
        return b;
49
    } else {
50
        return __tact_store_address(b, address);
51
    }
52
}
53

54
slice __tact_create_address(int chain, int hash) inline {
55
    var b = begin_cell();
56
    b = b.store_uint(2, 2);
57
    b = b.store_uint(0, 1);
58
    b = b.store_int(chain, 8);
59
    b = b.store_uint(hash, 256);
60
    return b.end_cell().begin_parse();
61
}
62

63
slice __tact_compute_contract_address(int chain, cell code, cell data) inline {
64
    var b = begin_cell();
65
    b = b.store_uint(0, 2);
66
    b = b.store_uint(3, 2);
67
    b = b.store_uint(0, 1);
68
    b = b.store_ref(code);
69
    b = b.store_ref(data);
70
    var hash = cell_hash(b.end_cell());
71
    return __tact_create_address(chain, hash);
72
}
73

74
int __tact_address_eq(slice a, slice b) inline {
75
    return equal_slice_bits(a, b);
76
}
77

78
int __tact_address_neq(slice a, slice b) inline {
79
    return ~ equal_slice_bits(a, b);
80
}
81

82
cell __tact_dict_set_code(cell dict, int id, cell code) inline {
83
    return udict_set_ref(dict, 16, id, code);
84
}
85

86
cell __tact_dict_get_code(cell dict, int id) inline {
87
    var (data, ok) = udict_get_ref?(dict, 16, id);
88
    throw_unless(135, ok);
89
    return data;
90
}
91

92
(slice, ((int, int, slice, slice, cell, int, slice))) __gen_read_TokenTransfer(slice sc_0) inline_ref {
93
    throw_unless(129, sc_0~load_uint(32) == 260734629);
94
    var v'queryId = sc_0~load_uint(64);
95
    var v'amount = sc_0~load_coins();
96
    var v'destination = sc_0~__tact_load_address();
97
    var v'responseDestination = sc_0~__tact_load_address_opt();
98
    var v'customPayload = sc_0~load_int(1) ? sc_0~load_ref() : null();
99
    var v'forwardTonAmount = sc_0~load_coins();
100
    var v'forwardPayload = sc_0;
101
    return (sc_0, (v'queryId, v'amount, v'destination, v'responseDestination, v'customPayload, v'forwardTonAmount, v'forwardPayload));
102
}
103

104
builder __gen_write_TokenTransferInternal(builder build_0, (int, int, slice, slice, int, slice) v) inline_ref {
105
    var (v'queryId, v'amount, v'from, v'responseAddress, v'forwardTonAmount, v'forwardPayload) = v;
106
    build_0 = store_uint(build_0, 395134233, 32);
107
    build_0 = build_0.store_uint(v'queryId, 64);
108
    build_0 = build_0.store_coins(v'amount);
109
    build_0 = __tact_store_address(build_0, v'from);
110
    build_0 = __tact_store_address_opt(build_0, v'responseAddress);
111
    build_0 = build_0.store_coins(v'forwardTonAmount);
112
    build_0 = build_0.store_slice(v'forwardPayload);
113
    return build_0;
114
}
115

116
cell __gen_writecell_TokenTransferInternal((int, int, slice, slice, int, slice) v) inline_ref {
117
    return __gen_write_TokenTransferInternal(begin_cell(), v).end_cell();
118
}
119

120
(slice, ((int, int, slice, slice, int, slice))) __gen_read_TokenTransferInternal(slice sc_0) inline_ref {
121
    throw_unless(129, sc_0~load_uint(32) == 395134233);
122
    var v'queryId = sc_0~load_uint(64);
123
    var v'amount = sc_0~load_coins();
124
    var v'from = sc_0~__tact_load_address();
125
    var v'responseAddress = sc_0~__tact_load_address_opt();
126
    var v'forwardTonAmount = sc_0~load_coins();
127
    var v'forwardPayload = sc_0;
128
    return (sc_0, (v'queryId, v'amount, v'from, v'responseAddress, v'forwardTonAmount, v'forwardPayload));
129
}
130

131
builder __gen_write_TokenNotification(builder build_0, (int, int, slice, slice) v) inline_ref {
132
    var (v'queryId, v'amount, v'from, v'forwardPayload) = v;
133
    build_0 = store_uint(build_0, 1935855772, 32);
134
    build_0 = build_0.store_uint(v'queryId, 64);
135
    build_0 = build_0.store_coins(v'amount);
136
    build_0 = __tact_store_address(build_0, v'from);
137
    build_0 = build_0.store_slice(v'forwardPayload);
138
    return build_0;
139
}
140

141
cell __gen_writecell_TokenNotification((int, int, slice, slice) v) inline_ref {
142
    return __gen_write_TokenNotification(begin_cell(), v).end_cell();
143
}
144

145
(slice, ((int, int, slice, slice))) __gen_read_TokenBurn(slice sc_0) inline_ref {
146
    throw_unless(129, sc_0~load_uint(32) == 1499400124);
147
    var v'queryId = sc_0~load_uint(64);
148
    var v'amount = sc_0~load_coins();
149
    var v'owner = sc_0~__tact_load_address();
150
    var v'responseAddress = sc_0~__tact_load_address_opt();
151
    return (sc_0, (v'queryId, v'amount, v'owner, v'responseAddress));
152
}
153

154
builder __gen_write_TokenBurnNotification(builder build_0, (int, int, slice, slice) v) inline_ref {
155
    var (v'queryId, v'amount, v'owner, v'responseAddress) = v;
156
    build_0 = store_uint(build_0, 2078119902, 32);
157
    build_0 = build_0.store_uint(v'queryId, 64);
158
    build_0 = build_0.store_coins(v'amount);
159
    build_0 = __tact_store_address(build_0, v'owner);
160
    build_0 = __tact_store_address_opt(build_0, v'responseAddress);
161
    return build_0;
162
}
163

164
cell __gen_writecell_TokenBurnNotification((int, int, slice, slice) v) inline_ref {
165
    return __gen_write_TokenBurnNotification(begin_cell(), v).end_cell();
166
}
167

168
builder __gen_write_TokenExcesses(builder build_0, (int) v) inline_ref {
169
    var (v'queryId) = v;
170
    build_0 = store_uint(build_0, 3576854235, 32);
171
    build_0 = build_0.store_uint(v'queryId, 64);
172
    return build_0;
173
}
174

175
cell __gen_writecell_TokenExcesses((int) v) inline_ref {
176
    return __gen_write_TokenExcesses(begin_cell(), v).end_cell();
177
}
178

179
builder __gen_write_JettonDefaultWallet(builder build_0, (int, slice, slice) v) inline_ref {
180
    var (v'balance, v'owner, v'master) = v;
181
    build_0 = build_0.store_int(v'balance, 257);
182
    build_0 = __tact_store_address(build_0, v'owner);
183
    build_0 = __tact_store_address(build_0, v'master);
184
    return build_0;
185
}
186

187
(slice, ((int, slice, slice))) __gen_read_JettonDefaultWallet(slice sc_0) inline_ref {
188
    var v'balance = sc_0~load_int(257);
189
    var v'owner = sc_0~__tact_load_address();
190
    var v'master = sc_0~__tact_load_address();
191
    return (sc_0, (v'balance, v'owner, v'master));
192
}
193

194
_ __gen_StateInit_get_code((cell, cell) v) inline {
195
    var (v'code, v'data) = v;
196
    return v'code;
197
}
198

199
(int, slice, slice, cell) __gen_JettonWalletData_to_external(((int, slice, slice, cell)) v) {
200
    var (v'balance, v'owner, v'master, v'walletCode) = v; 
201
    return (v'balance, v'owner, v'master, v'walletCode);
202
}
203

204
(int, slice, slice) __gen_load_JettonDefaultWallet() inline_ref {
205
    slice sc = get_data().begin_parse();
206
    __tact_context_sys = sc~load_ref();
207
    return sc~__gen_read_JettonDefaultWallet();
208
}
209

210
() __gen_store_JettonDefaultWallet((int, slice, slice) v) impure inline_ref {
211
    builder b = begin_cell();
212
    b = b.store_ref(__tact_context_sys);
213
    b = __gen_write_JettonDefaultWallet(b, v);
214
    set_data(b.end_cell());
215
}
216

217
slice $contractAddress((cell, cell) $s) impure {
218
    var (($s'code, $s'data)) = $s;
219
    return __tact_compute_contract_address(0, $s'code, $s'data);
220
}
221

222
() $send((int, slice, int, int, cell, cell, cell) $params) impure {
223
    var (($params'bounce, $params'to, $params'value, $params'mode, $params'body, $params'code, $params'data)) = $params;
224
    builder $b = begin_cell();
225
    $b = store_int($b, 1, 2);
226
    $b = __tact_store_bool($b, $params'bounce);
227
    $b = store_int($b, 0, 3);
228
    $b = __tact_store_address($b, $params'to);
229
    $b = store_coins($b, $params'value);
230
    $b = store_int($b, 0, ((((1 + 4) + 4) + 64) + 32));
231
    if (((~ null?($params'code)) | (~ null?($params'data)))) {
232
        $b = __tact_store_bool($b, true);
233
        builder $bc = begin_cell();
234
        $bc = __tact_store_bool($bc, false);
235
        $bc = __tact_store_bool($bc, false);
236
        if ((~ null?($params'code))) {
237
            $bc = __tact_store_bool($bc, true);
238
            $bc = store_ref($bc, __tact_not_null($params'code));
239
        } else {
240
            $bc = __tact_store_bool($bc, false);
241
        }
242
        if ((~ null?($params'data))) {
243
            $bc = __tact_store_bool($bc, true);
244
            $bc = store_ref($bc, __tact_not_null($params'data));
245
        } else {
246
            $bc = __tact_store_bool($bc, false);
247
        }
248
        $bc = __tact_store_bool($bc, false);
249
        $b = __tact_store_bool($b, true);
250
        $b = store_ref($b, end_cell($bc));
251
    } else {
252
        $b = __tact_store_bool($b, false);
253
    }
254
    cell $body = $params'body;
255
    if ((~ null?($body))) {
256
        $b = __tact_store_bool($b, true);
257
        $b = store_ref($b, __tact_not_null($body));
258
    } else {
259
        $b = __tact_store_bool($b, false);
260
    }
261
    cell $c = end_cell($b);
262
    send_raw_message($c, $params'mode);
263
}
264

265
int $__gen_Context_readForwardFee((int, slice, int, slice) $self) impure {
266
    var (($self'bounced, $self'sender, $self'value, $self'raw)) = $self;
267
    var (($self'bounced, $self'sender, $self'value, $self'raw)) = $self;
268
    slice $sc = $self'raw;
269
    $sc~load_coins();
270
    $sc~skip_bits(1);
271
    $sc~load_coins();
272
    return (($sc~load_coins() * 3) / 2);
273
}
274

275
cell $__gen_JettonDefaultWallet_init(cell sys', slice $master, slice $owner) {
276
    var (($self'balance, $self'owner, $self'master)) = (null(), null(), null());
277
    $self'balance = 0;
278
    $self'owner = $owner;
279
    $self'master = $master;
280
    var b' = begin_cell();
281
    b' = b'.store_ref(sys');
282
    b' = __gen_write_JettonDefaultWallet(b', ($self'balance, $self'owner, $self'master));
283
    return b'.end_cell();
284
}
285

286
(cell, cell) $__gen_JettonDefaultWallet_init_child(cell sys', slice $master, slice $owner) {
287
    slice sc' = sys'.begin_parse();
288
    cell source = sc'~load_dict();
289
    cell contracts = new_dict();
290
    
291
    ;; Contract Code: JettonDefaultWallet
292
    cell mine = __tact_dict_get_code(source, 55471);
293
    contracts = __tact_dict_set_code(contracts, 55471, mine);
294
    cell sys = begin_cell().store_dict(contracts).end_cell();
295
    return (mine, $__gen_JettonDefaultWallet_init(sys, $master, $owner));
296
}
297

298
(int, slice, slice, cell) $__gen_JettonDefaultWallet_get_wallet_data((int, slice, slice) $self) impure {
299
    var (($self'balance, $self'owner, $self'master)) = $self;
300
    return ($self'balance, $self'owner, $self'master, __gen_StateInit_get_code($__gen_JettonDefaultWallet_init_child(__tact_context_sys, $self'master, $self'owner)));
301
}
302

303
_ $__gen_get_get_wallet_data() method_id(97026) {
304
    var self = __gen_load_JettonDefaultWallet();
305
    var res = $__gen_JettonDefaultWallet_get_wallet_data(self);
306
    return __gen_JettonWalletData_to_external(res);
307
}
308

309
(((int, slice, slice)), ()) $__gen_JettonDefaultWallet_receive_TokenTransfer((int, slice, slice) $self, (int, int, slice, slice, cell, int, slice) $msg) impure {
310
    var ($self'balance, $self'owner, $self'master) = $self;
311
    var ($msg'queryId, $msg'amount, $msg'destination, $msg'responseDestination, $msg'customPayload, $msg'forwardTonAmount, $msg'forwardPayload) = $msg;
312
    var ($ctx'bounced, $ctx'sender, $ctx'value, $ctx'raw) = __tact_context_get();
313
    throw_unless(4429, __tact_address_eq($ctx'sender, $self'owner));
314
    $self'balance = ($self'balance - $msg'amount);
315
    throw_unless(62972, ($self'balance >= 0));
316
    int $fwdFee = $__gen_Context_readForwardFee(($ctx'bounced, $ctx'sender, $ctx'value, $ctx'raw));
317
    int $fwdCount = 1;
318
    if (($msg'forwardTonAmount > 0)) {
319
        $fwdCount = 2;
320
    }
321
    throw_unless(16059, ($ctx'value > ((($fwdCount * $fwdFee) + (2 * 10000000)) + 10000000)));
322
    var ($init'code, $init'data) = $__gen_JettonDefaultWallet_init_child(__tact_context_sys, $self'master, $msg'destination);
323
    slice $walletAddress = $contractAddress(($init'code, $init'data));
324
    $send((true, $walletAddress, 0, 64, __gen_writecell_TokenTransferInternal(($msg'queryId, $msg'amount, $self'owner, $self'owner, $msg'forwardTonAmount, $msg'forwardPayload)), $init'code, $init'data));
325
    return (($self'balance, $self'owner, $self'master), ());
326
}
327

328
(((int, slice, slice)), ()) $__gen_JettonDefaultWallet_receive_TokenTransferInternal((int, slice, slice) $self, (int, int, slice, slice, int, slice) $msg) impure {
329
    var ($self'balance, $self'owner, $self'master) = $self;
330
    var ($msg'queryId, $msg'amount, $msg'from, $msg'responseAddress, $msg'forwardTonAmount, $msg'forwardPayload) = $msg;
331
    var ($ctx'bounced, $ctx'sender, $ctx'value, $ctx'raw) = __tact_context_get();
332
    if (__tact_address_neq($ctx'sender, $self'master)) {
333
        var ($sinit'code, $sinit'data) = $__gen_JettonDefaultWallet_init_child(__tact_context_sys, $self'master, $msg'from);
334
        throw_unless(4429, __tact_address_eq($contractAddress(($sinit'code, $sinit'data)), $ctx'sender));
335
    }
336
    $self'balance = ($self'balance + $msg'amount);
337
    throw_unless(62972, ($self'balance >= 0));
338
    int $msgValue = $ctx'value;
339
    int $tonBalanceBeforeMsg = (__tact_my_balance() - $msgValue);
340
    int $storageFee = (10000000 - min($tonBalanceBeforeMsg, 10000000));
341
    $msgValue = ($msgValue - ($storageFee + 10000000));
342
    if (($msg'forwardTonAmount > 0)) {
343
        int $fwdFee = $__gen_Context_readForwardFee(($ctx'bounced, $ctx'sender, $ctx'value, $ctx'raw));
344
        $msgValue = ($msgValue - ($msg'forwardTonAmount + $fwdFee));
345
        $send((false, $self'owner, $msg'forwardTonAmount, 0, __gen_writecell_TokenNotification(($msg'queryId, $msg'amount, $msg'from, $msg'forwardPayload)), null(), null()));
346
    }
347
    if (((~ null?($msg'responseAddress)) & ($msgValue > 0))) {
348
        $send((false, __tact_not_null($msg'responseAddress), $msgValue, 0, __gen_writecell_TokenExcesses(($msg'queryId)), null(), null()));
349
    }
350
    return (($self'balance, $self'owner, $self'master), ());
351
}
352

353
(((int, slice, slice)), ()) $__gen_JettonDefaultWallet_receive_TokenBurn((int, slice, slice) $self, (int, int, slice, slice) $msg) impure {
354
    var ($self'balance, $self'owner, $self'master) = $self;
355
    var ($msg'queryId, $msg'amount, $msg'owner, $msg'responseAddress) = $msg;
356
    var ($ctx'bounced, $ctx'sender, $ctx'value, $ctx'raw) = __tact_context_get();
357
    throw_unless(4429, __tact_address_eq($ctx'sender, $self'owner));
358
    $self'balance = ($self'balance - $msg'amount);
359
    throw_unless(62972, ($self'balance >= 0));
360
    int $fwdFee = $__gen_Context_readForwardFee(($ctx'bounced, $ctx'sender, $ctx'value, $ctx'raw));
361
    throw_unless(16059, ($ctx'value > (($fwdFee + (2 * 10000000)) + 10000000)));
362
    $send((true, $self'master, 0, 64, __gen_writecell_TokenBurnNotification(($msg'queryId, $msg'amount, $self'owner, $self'owner)), null(), null()));
363
    return (($self'balance, $self'owner, $self'master), ());
364
}
365

366
((int, slice, slice), ()) $__gen_JettonDefaultWallet_receive_bounced((int, slice, slice) $self, slice $msg) impure {
367
    var ($self'balance, $self'owner, $self'master) = $self;
368
    $msg~skip_bits(32);
369
    int $op = $msg~load_uint(32);
370
    int $queryId = $msg~load_uint(64);
371
    int $jettonAmount = $msg~load_coins();
372
    throw_unless(13650, (($op == 395134233) | ($op == 2078119902)));
373
    $self'balance = ($self'balance + $jettonAmount);
374
    return (($self'balance, $self'owner, $self'master), ());
375
}
376

377

378
() recv_internal(int msg_value, cell in_msg_cell, slice in_msg) impure {
379
    
380
    ;; Parse incoming message
381
    int op = 0;
382
    if (slice_bits(in_msg) >= 32) {
383
        op = in_msg.preload_uint(32);
384
    }
385
    var cs = in_msg_cell.begin_parse();
386
    var msg_flags = cs~load_uint(4);
387
    var msg_bounced = ((msg_flags & 1) == 1 ? true : false);
388
    slice msg_sender_addr = cs~load_msg_addr();
389
    __tact_context = (msg_bounced, msg_sender_addr, msg_value, cs);
390
    
391
    ;; Handle bounced messages
392
    if (msg_bounced) {
393
        var self = __gen_load_JettonDefaultWallet();
394
        self~$__gen_JettonDefaultWallet_receive_bounced(in_msg);
395
        __gen_store_JettonDefaultWallet(self);
396
        return ();
397
    }
398
    
399
    ;; Receive TokenTransfer message
400
    if (op == 260734629) {
401
        var self = __gen_load_JettonDefaultWallet();
402
        var msg = in_msg~__gen_read_TokenTransfer();
403
        self~$__gen_JettonDefaultWallet_receive_TokenTransfer(msg);
404
        __gen_store_JettonDefaultWallet(self);
405
        return ();
406
    }
407
    
408
    ;; Receive TokenTransferInternal message
409
    if (op == 395134233) {
410
        var self = __gen_load_JettonDefaultWallet();
411
        var msg = in_msg~__gen_read_TokenTransferInternal();
412
        self~$__gen_JettonDefaultWallet_receive_TokenTransferInternal(msg);
413
        __gen_store_JettonDefaultWallet(self);
414
        return ();
415
    }
416
    
417
    ;; Receive TokenBurn message
418
    if (op == 1499400124) {
419
        var self = __gen_load_JettonDefaultWallet();
420
        var msg = in_msg~__gen_read_TokenBurn();
421
        self~$__gen_JettonDefaultWallet_receive_TokenBurn(msg);
422
        __gen_store_JettonDefaultWallet(self);
423
        return ();
424
    }
425
    
426
    throw(130);
427
}
428

429
_ supported_interfaces() method_id {
430
    return (
431
        "org.ton.introspection.v0"H >> 128,
432
        "org.ton.abi.ipfs.v0"H >> 128,
433
        "org.ton.jetton.wallet"H >> 128
434
    );
435
}
436

437
_ get_abi_ipfs() {
438
    return "ipfs://QmXBfqbQzeN1uT55MyYpwhU9RV47Sq3quVt3qFLgWH8NhD";
439
}
440