mirror of
https://github.com/ton-blockchain/ton
synced 2025-03-09 15:40:10 +00:00
Add legacy_tester for existing funC contracts (#588)
* Add legacy_tester for existing funC contracts * Add storage-contracts and pragma options
This commit is contained in:
EmelyanenkoK
GitHub
parent
13b9f460af
commit
6b49d6a382
70 changed files with 14495 additions and 0 deletions
|
|
@ -0,0 +1,17 @@
|
|||
;; operations (constant values taken from crc32 on op message in the companion .tlb files and appear during build)
|
||||
int op::increment() asm "0x37491f2f PUSHINT";
|
||||
int op::deposit() asm "0x47d54391 PUSHINT";
|
||||
int op::withdraw() asm "0x41836980 PUSHINT";
|
||||
int op::transfer_ownership() asm "0x2da38aaf PUSHINT";
|
||||
|
||||
;; errors
|
||||
int error::unknown_op() asm "101 PUSHINT";
|
||||
int error::access_denied() asm "102 PUSHINT";
|
||||
int error::insufficient_balance() asm "103 PUSHINT";
|
||||
|
||||
;; other
|
||||
int const::min_tons_for_storage() asm "10000000 PUSHINT"; ;; 0.01 TON
|
||||
|
||||
;; 6905(computational_gas_price) * 1000(cur_gas_price) = 6905000
|
||||
;; ceil(6905000) = 10000000 ~= 0.01 TON
|
||||
int const::provide_address_gas_consumption() asm "10000000 PUSHINT";
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
cell pack_jetton_wallet_data(int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) inline {
|
||||
return begin_cell()
|
||||
.store_coins(balance)
|
||||
.store_slice(owner_address)
|
||||
.store_slice(jetton_master_address)
|
||||
.store_ref(jetton_wallet_code)
|
||||
.end_cell();
|
||||
}
|
||||
|
||||
cell calculate_jetton_wallet_state_init(slice owner_address, slice jetton_master_address, cell jetton_wallet_code) inline {
|
||||
return begin_cell()
|
||||
.store_uint(0, 2)
|
||||
.store_dict(jetton_wallet_code)
|
||||
.store_dict(pack_jetton_wallet_data(0, owner_address, jetton_master_address, jetton_wallet_code))
|
||||
.store_uint(0, 1)
|
||||
.end_cell();
|
||||
}
|
||||
|
||||
slice calculate_jetton_wallet_address(cell state_init) inline {
|
||||
return begin_cell().store_uint(4, 3)
|
||||
.store_int(workchain(), 8)
|
||||
.store_uint(cell_hash(state_init), 256)
|
||||
.end_cell()
|
||||
.begin_parse();
|
||||
}
|
||||
|
||||
slice calculate_user_jetton_wallet_address(slice owner_address, slice jetton_master_address, cell jetton_wallet_code) inline {
|
||||
return calculate_jetton_wallet_address(calculate_jetton_wallet_state_init(owner_address, jetton_master_address, jetton_wallet_code));
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
int op::transfer() asm "0xf8a7ea5 PUSHINT";
|
||||
int op::transfer_notification() asm "0x7362d09c PUSHINT";
|
||||
int op::internal_transfer() asm "0x178d4519 PUSHINT";
|
||||
int op::excesses() asm "0xd53276db PUSHINT";
|
||||
int op::burn() asm "0x595f07bc PUSHINT";
|
||||
int op::burn_notification() asm "0x7bdd97de PUSHINT";
|
||||
|
||||
;; Minter
|
||||
int op::mint() asm "21 PUSHINT";
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
int workchain() asm "0 PUSHINT";
|
||||
|
||||
() force_chain(slice addr) impure {
|
||||
(int wc, _) = parse_std_addr(addr);
|
||||
throw_unless(333, wc == workchain());
|
||||
}
|
||||
|
|
@ -0,0 +1,215 @@
|
|||
;; Standard library for funC
|
||||
;;
|
||||
|
||||
forall X -> tuple cons(X head, tuple tail) asm "CONS";
|
||||
forall X -> (X, tuple) uncons(tuple list) asm "UNCONS";
|
||||
forall X -> (tuple, X) list_next(tuple list) asm( -> 1 0) "UNCONS";
|
||||
forall X -> X car(tuple list) asm "CAR";
|
||||
tuple cdr(tuple list) asm "CDR";
|
||||
tuple empty_tuple() asm "NIL";
|
||||
forall X -> tuple tpush(tuple t, X value) asm "TPUSH";
|
||||
forall X -> (tuple, ()) ~tpush(tuple t, X value) asm "TPUSH";
|
||||
forall X -> [X] single(X x) asm "SINGLE";
|
||||
forall X -> X unsingle([X] t) asm "UNSINGLE";
|
||||
forall X, Y -> [X, Y] pair(X x, Y y) asm "PAIR";
|
||||
forall X, Y -> (X, Y) unpair([X, Y] t) asm "UNPAIR";
|
||||
forall X, Y, Z -> [X, Y, Z] triple(X x, Y y, Z z) asm "TRIPLE";
|
||||
forall X, Y, Z -> (X, Y, Z) untriple([X, Y, Z] t) asm "UNTRIPLE";
|
||||
forall X, Y, Z, W -> [X, Y, Z, W] tuple4(X x, Y y, Z z, W w) asm "4 TUPLE";
|
||||
forall X, Y, Z, W -> (X, Y, Z, W) untuple4([X, Y, Z, W] t) asm "4 UNTUPLE";
|
||||
forall X -> X first(tuple t) asm "FIRST";
|
||||
forall X -> X second(tuple t) asm "SECOND";
|
||||
forall X -> X third(tuple t) asm "THIRD";
|
||||
forall X -> X fourth(tuple t) asm "3 INDEX";
|
||||
forall X, Y -> X pair_first([X, Y] p) asm "FIRST";
|
||||
forall X, Y -> Y pair_second([X, Y] p) asm "SECOND";
|
||||
forall X, Y, Z -> X triple_first([X, Y, Z] p) asm "FIRST";
|
||||
forall X, Y, Z -> Y triple_second([X, Y, Z] p) asm "SECOND";
|
||||
forall X, Y, Z -> Z triple_third([X, Y, Z] p) asm "THIRD";
|
||||
forall X -> X null() asm "PUSHNULL";
|
||||
forall X -> (X, ()) ~impure_touch(X x) impure asm "NOP";
|
||||
|
||||
int now() asm "NOW";
|
||||
slice my_address() asm "MYADDR";
|
||||
[int, cell] get_balance() asm "BALANCE";
|
||||
int cur_lt() asm "LTIME";
|
||||
int block_lt() asm "BLOCKLT";
|
||||
|
||||
int cell_hash(cell c) asm "HASHCU";
|
||||
int slice_hash(slice s) asm "HASHSU";
|
||||
int string_hash(slice s) asm "SHA256U";
|
||||
|
||||
int check_signature(int hash, slice signature, int public_key) asm "CHKSIGNU";
|
||||
int check_data_signature(slice data, slice signature, int public_key) asm "CHKSIGNS";
|
||||
|
||||
(int, int, int) compute_data_size(cell c, int max_cells) impure asm "CDATASIZE";
|
||||
(int, int, int) slice_compute_data_size(slice s, int max_cells) impure asm "SDATASIZE";
|
||||
(int, int, int, int) compute_data_size?(cell c, int max_cells) asm "CDATASIZEQ NULLSWAPIFNOT2 NULLSWAPIFNOT";
|
||||
(int, int, int, int) slice_compute_data_size?(cell c, int max_cells) asm "SDATASIZEQ NULLSWAPIFNOT2 NULLSWAPIFNOT";
|
||||
|
||||
;; () throw_if(int excno, int cond) impure asm "THROWARGIF";
|
||||
|
||||
() dump_stack() impure asm "DUMPSTK";
|
||||
|
||||
cell get_data() asm "c4 PUSH";
|
||||
() set_data(cell c) impure asm "c4 POP";
|
||||
cont get_c3() impure asm "c3 PUSH";
|
||||
() set_c3(cont c) impure asm "c3 POP";
|
||||
cont bless(slice s) impure asm "BLESS";
|
||||
|
||||
() accept_message() impure asm "ACCEPT";
|
||||
() set_gas_limit(int limit) impure asm "SETGASLIMIT";
|
||||
() commit() impure asm "COMMIT";
|
||||
() buy_gas(int gram) impure asm "BUYGAS";
|
||||
|
||||
int min(int x, int y) asm "MIN";
|
||||
int max(int x, int y) asm "MAX";
|
||||
(int, int) minmax(int x, int y) asm "MINMAX";
|
||||
int abs(int x) asm "ABS";
|
||||
|
||||
slice begin_parse(cell c) asm "CTOS";
|
||||
() end_parse(slice s) impure asm "ENDS";
|
||||
(slice, cell) load_ref(slice s) asm( -> 1 0) "LDREF";
|
||||
cell preload_ref(slice s) asm "PLDREF";
|
||||
;; (slice, int) ~load_int(slice s, int len) asm(s len -> 1 0) "LDIX";
|
||||
;; (slice, int) ~load_uint(slice s, int len) asm( -> 1 0) "LDUX";
|
||||
;; int preload_int(slice s, int len) asm "PLDIX";
|
||||
;; int preload_uint(slice s, int len) asm "PLDUX";
|
||||
;; (slice, slice) load_bits(slice s, int len) asm(s len -> 1 0) "LDSLICEX";
|
||||
;; slice preload_bits(slice s, int len) asm "PLDSLICEX";
|
||||
(slice, int) load_grams(slice s) asm( -> 1 0) "LDGRAMS";
|
||||
slice skip_bits(slice s, int len) asm "SDSKIPFIRST";
|
||||
(slice, ()) ~skip_bits(slice s, int len) asm "SDSKIPFIRST";
|
||||
slice first_bits(slice s, int len) asm "SDCUTFIRST";
|
||||
slice skip_last_bits(slice s, int len) asm "SDSKIPLAST";
|
||||
(slice, ()) ~skip_last_bits(slice s, int len) asm "SDSKIPLAST";
|
||||
slice slice_last(slice s, int len) asm "SDCUTLAST";
|
||||
(slice, cell) load_dict(slice s) asm( -> 1 0) "LDDICT";
|
||||
cell preload_dict(slice s) asm "PLDDICT";
|
||||
slice skip_dict(slice s) asm "SKIPDICT";
|
||||
|
||||
(slice, cell) load_maybe_ref(slice s) asm( -> 1 0) "LDOPTREF";
|
||||
cell preload_maybe_ref(slice s) asm "PLDOPTREF";
|
||||
builder store_maybe_ref(builder b, cell c) asm(c b) "STOPTREF";
|
||||
|
||||
int cell_depth(cell c) asm "CDEPTH";
|
||||
|
||||
int slice_refs(slice s) asm "SREFS";
|
||||
int slice_bits(slice s) asm "SBITS";
|
||||
(int, int) slice_bits_refs(slice s) asm "SBITREFS";
|
||||
int slice_empty?(slice s) asm "SEMPTY";
|
||||
int slice_data_empty?(slice s) asm "SDEMPTY";
|
||||
int slice_refs_empty?(slice s) asm "SREMPTY";
|
||||
int slice_depth(slice s) asm "SDEPTH";
|
||||
|
||||
int builder_refs(builder b) asm "BREFS";
|
||||
int builder_bits(builder b) asm "BBITS";
|
||||
int builder_depth(builder b) asm "BDEPTH";
|
||||
|
||||
builder begin_cell() asm "NEWC";
|
||||
cell end_cell(builder b) asm "ENDC";
|
||||
builder store_ref(builder b, cell c) asm(c b) "STREF";
|
||||
;; builder store_uint(builder b, int x, int len) asm(x b len) "STUX";
|
||||
;; builder store_int(builder b, int x, int len) asm(x b len) "STIX";
|
||||
builder store_slice(builder b, slice s) asm "STSLICER";
|
||||
builder store_grams(builder b, int x) asm "STGRAMS";
|
||||
builder store_dict(builder b, cell c) asm(c b) "STDICT";
|
||||
|
||||
(slice, slice) load_msg_addr(slice s) asm( -> 1 0) "LDMSGADDR";
|
||||
tuple parse_addr(slice s) asm "PARSEMSGADDR";
|
||||
(int, int) parse_std_addr(slice s) asm "REWRITESTDADDR";
|
||||
(int, slice) parse_var_addr(slice s) asm "REWRITEVARADDR";
|
||||
|
||||
cell idict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTISETREF";
|
||||
(cell, ()) ~idict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTISETREF";
|
||||
cell udict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETREF";
|
||||
(cell, ()) ~udict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETREF";
|
||||
cell idict_get_ref(cell dict, int key_len, int index) asm(index dict key_len) "DICTIGETOPTREF";
|
||||
(cell, int) idict_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIGETREF";
|
||||
(cell, int) udict_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUGETREF";
|
||||
(cell, cell) idict_set_get_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTISETGETOPTREF";
|
||||
(cell, cell) udict_set_get_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETGETOPTREF";
|
||||
(cell, int) idict_delete?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIDEL";
|
||||
(cell, int) udict_delete?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUDEL";
|
||||
(slice, int) idict_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIGET" "NULLSWAPIFNOT";
|
||||
(slice, int) udict_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUGET" "NULLSWAPIFNOT";
|
||||
(cell, slice, int) idict_delete_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIDELGET" "NULLSWAPIFNOT";
|
||||
(cell, slice, int) udict_delete_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUDELGET" "NULLSWAPIFNOT";
|
||||
(cell, (slice, int)) ~idict_delete_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIDELGET" "NULLSWAPIFNOT";
|
||||
(cell, (slice, int)) ~udict_delete_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUDELGET" "NULLSWAPIFNOT";
|
||||
cell udict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUSET";
|
||||
(cell, ()) ~udict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUSET";
|
||||
cell idict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTISET";
|
||||
(cell, ()) ~idict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTISET";
|
||||
cell dict_set(cell dict, int key_len, slice index, slice value) asm(value index dict key_len) "DICTSET";
|
||||
(cell, ()) ~dict_set(cell dict, int key_len, slice index, slice value) asm(value index dict key_len) "DICTSET";
|
||||
(cell, int) udict_add?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUADD";
|
||||
(cell, int) udict_replace?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUREPLACE";
|
||||
(cell, int) idict_add?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTIADD";
|
||||
(cell, int) idict_replace?(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTIREPLACE";
|
||||
cell udict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUSETB";
|
||||
(cell, ()) ~udict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUSETB";
|
||||
cell idict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTISETB";
|
||||
(cell, ()) ~idict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTISETB";
|
||||
cell dict_set_builder(cell dict, int key_len, slice index, builder value) asm(value index dict key_len) "DICTSETB";
|
||||
(cell, ()) ~dict_set_builder(cell dict, int key_len, slice index, builder value) asm(value index dict key_len) "DICTSETB";
|
||||
(cell, int) udict_add_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUADDB";
|
||||
(cell, int) udict_replace_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUREPLACEB";
|
||||
(cell, int) idict_add_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTIADDB";
|
||||
(cell, int) idict_replace_builder?(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTIREPLACEB";
|
||||
(cell, int, slice, int) udict_delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTUREMMIN" "NULLSWAPIFNOT2";
|
||||
(cell, (int, slice, int)) ~udict::delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTUREMMIN" "NULLSWAPIFNOT2";
|
||||
(cell, int, slice, int) idict_delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTIREMMIN" "NULLSWAPIFNOT2";
|
||||
(cell, (int, slice, int)) ~idict::delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTIREMMIN" "NULLSWAPIFNOT2";
|
||||
(cell, slice, slice, int) dict_delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTREMMIN" "NULLSWAPIFNOT2";
|
||||
(cell, (slice, slice, int)) ~dict::delete_get_min(cell dict, int key_len) asm(-> 0 2 1 3) "DICTREMMIN" "NULLSWAPIFNOT2";
|
||||
(cell, int, slice, int) udict_delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTUREMMAX" "NULLSWAPIFNOT2";
|
||||
(cell, (int, slice, int)) ~udict::delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTUREMMAX" "NULLSWAPIFNOT2";
|
||||
(cell, int, slice, int) idict_delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTIREMMAX" "NULLSWAPIFNOT2";
|
||||
(cell, (int, slice, int)) ~idict::delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTIREMMAX" "NULLSWAPIFNOT2";
|
||||
(cell, slice, slice, int) dict_delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTREMMAX" "NULLSWAPIFNOT2";
|
||||
(cell, (slice, slice, int)) ~dict::delete_get_max(cell dict, int key_len) asm(-> 0 2 1 3) "DICTREMMAX" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) udict_get_min?(cell dict, int key_len) asm (-> 1 0 2) "DICTUMIN" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) udict_get_max?(cell dict, int key_len) asm (-> 1 0 2) "DICTUMAX" "NULLSWAPIFNOT2";
|
||||
(int, cell, int) udict_get_min_ref?(cell dict, int key_len) asm (-> 1 0 2) "DICTUMINREF" "NULLSWAPIFNOT2";
|
||||
(int, cell, int) udict_get_max_ref?(cell dict, int key_len) asm (-> 1 0 2) "DICTUMAXREF" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) idict_get_min?(cell dict, int key_len) asm (-> 1 0 2) "DICTIMIN" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) idict_get_max?(cell dict, int key_len) asm (-> 1 0 2) "DICTIMAX" "NULLSWAPIFNOT2";
|
||||
(int, cell, int) idict_get_min_ref?(cell dict, int key_len) asm (-> 1 0 2) "DICTIMINREF" "NULLSWAPIFNOT2";
|
||||
(int, cell, int) idict_get_max_ref?(cell dict, int key_len) asm (-> 1 0 2) "DICTIMAXREF" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) udict_get_next?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTUGETNEXT" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) udict_get_nexteq?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTUGETNEXTEQ" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) udict_get_prev?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTUGETPREV" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) udict_get_preveq?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTUGETPREVEQ" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) idict_get_next?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTIGETNEXT" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) idict_get_nexteq?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTIGETNEXTEQ" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) idict_get_prev?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTIGETPREV" "NULLSWAPIFNOT2";
|
||||
(int, slice, int) idict_get_preveq?(cell dict, int key_len, int pivot) asm(pivot dict key_len -> 1 0 2) "DICTIGETPREVEQ" "NULLSWAPIFNOT2";
|
||||
cell new_dict() asm "NEWDICT";
|
||||
int dict_empty?(cell c) asm "DICTEMPTY";
|
||||
|
||||
(slice, slice, slice, int) pfxdict_get?(cell dict, int key_len, slice key) asm(key dict key_len) "PFXDICTGETQ" "NULLSWAPIFNOT2";
|
||||
(cell, int) pfxdict_set?(cell dict, int key_len, slice key, slice value) asm(value key dict key_len) "PFXDICTSET";
|
||||
(cell, int) pfxdict_delete?(cell dict, int key_len, slice key) asm(key dict key_len) "PFXDICTDEL";
|
||||
|
||||
cell config_param(int x) asm "CONFIGOPTPARAM";
|
||||
int cell_null?(cell c) asm "ISNULL";
|
||||
|
||||
() raw_reserve(int amount, int mode) impure asm "RAWRESERVE";
|
||||
() raw_reserve_extra(int amount, cell extra_amount, int mode) impure asm "RAWRESERVEX";
|
||||
() send_raw_message(cell msg, int mode) impure asm "SENDRAWMSG";
|
||||
() set_code(cell new_code) impure asm "SETCODE";
|
||||
|
||||
int random() impure asm "RANDU256";
|
||||
int rand(int range) impure asm "RAND";
|
||||
int get_seed() impure asm "RANDSEED";
|
||||
int set_seed() impure asm "SETRAND";
|
||||
() randomize(int x) impure asm "ADDRAND";
|
||||
() randomize_lt() impure asm "LTIME" "ADDRAND";
|
||||
|
||||
builder store_coins(builder b, int x) asm "STVARUINT16";
|
||||
(slice, int) load_coins(slice s) asm( -> 1 0) "LDVARUINT16";
|
||||
|
||||
int equal_slices (slice a, slice b) asm "SDEQ";
|
||||
int builder_null?(builder b) asm "ISNULL";
|
||||
builder store_builder(builder to, builder from) asm "STBR";
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
() send_grams(slice address, int amount) impure {
|
||||
cell msg = begin_cell()
|
||||
.store_uint (0x18, 6) ;; bounce
|
||||
.store_slice(address) ;; 267 bit address
|
||||
.store_grams(amount)
|
||||
.store_uint(0, 107) ;; 106 zeroes + 0 as an indicator that there is no cell with the data
|
||||
.end_cell();
|
||||
send_raw_message(msg, 3); ;; mode, 2 for ignoring errors, 1 for sender pays fees, 64 for returning inbound message value
|
||||
}
|
||||
|
|
@ -0,0 +1,250 @@
|
|||
;; Jetton Wallet Smart Contract
|
||||
|
||||
#include "imports/stdlib.fc";
|
||||
#include "imports/params.fc";
|
||||
#include "imports/constants.fc";
|
||||
#include "imports/jetton-utils.fc";
|
||||
#include "imports/op-codes.fc";
|
||||
#include "imports/utils.fc";
|
||||
#pragma version >=0.2.0;
|
||||
|
||||
{-
|
||||
|
||||
NOTE that this tokens can be transferred within the same workchain.
|
||||
|
||||
This is suitable for most tokens, if you need tokens transferable between workchains there are two solutions:
|
||||
|
||||
1) use more expensive but universal function to calculate message forward fee for arbitrary destination (see `misc/forward-fee-calc.cs`)
|
||||
|
||||
2) use token holder proxies in target workchain (that way even 'non-universal' token can be used from any workchain)
|
||||
|
||||
-}
|
||||
|
||||
const min_tons_for_storage = 10000000; ;; 0.01 TON
|
||||
const gas_consumption = 10000000; ;; 0.01 TON
|
||||
|
||||
{-
|
||||
Storage
|
||||
storage#_ balance:Coins owner_address:MsgAddressInt jetton_master_address:MsgAddressInt jetton_wallet_code:^Cell = Storage;
|
||||
-}
|
||||
|
||||
(int, slice, slice, cell) load_data() inline {
|
||||
slice ds = get_data().begin_parse();
|
||||
return (ds~load_coins(), ds~load_msg_addr(), ds~load_msg_addr(), ds~load_ref());
|
||||
}
|
||||
|
||||
() save_data (int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) impure inline {
|
||||
set_data(pack_jetton_wallet_data(balance, owner_address, jetton_master_address, jetton_wallet_code));
|
||||
}
|
||||
|
||||
{-
|
||||
transfer query_id:uint64 amount:(VarUInteger 16) destination:MsgAddress
|
||||
response_destination:MsgAddress custom_payload:(Maybe ^Cell)
|
||||
forward_ton_amount:(VarUInteger 16) forward_payload:(Either Cell ^Cell)
|
||||
= InternalMsgBody;
|
||||
internal_transfer query_id:uint64 amount:(VarUInteger 16) from:MsgAddress
|
||||
response_address:MsgAddress
|
||||
forward_ton_amount:(VarUInteger 16)
|
||||
forward_payload:(Either Cell ^Cell)
|
||||
= InternalMsgBody;
|
||||
-}
|
||||
|
||||
() send_tokens (slice in_msg_body, slice sender_address, int msg_value, int fwd_fee) impure {
|
||||
int query_id = in_msg_body~load_uint(64);
|
||||
int jetton_amount = in_msg_body~load_coins();
|
||||
slice to_owner_address = in_msg_body~load_msg_addr();
|
||||
force_chain(to_owner_address);
|
||||
(int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) = load_data();
|
||||
balance -= jetton_amount;
|
||||
|
||||
throw_unless(705, equal_slices(owner_address, sender_address));
|
||||
throw_unless(706, balance >= 0);
|
||||
|
||||
cell state_init = calculate_jetton_wallet_state_init(to_owner_address, jetton_master_address, jetton_wallet_code);
|
||||
slice to_wallet_address = calculate_jetton_wallet_address(state_init);
|
||||
slice response_address = in_msg_body~load_msg_addr();
|
||||
cell custom_payload = in_msg_body~load_dict();
|
||||
int forward_ton_amount = in_msg_body~load_coins();
|
||||
throw_unless(708, slice_bits(in_msg_body) >= 1);
|
||||
slice either_forward_payload = in_msg_body;
|
||||
var msg = begin_cell()
|
||||
.store_uint(0x18, 6)
|
||||
.store_slice(to_wallet_address)
|
||||
.store_coins(0)
|
||||
.store_uint(4 + 2 + 1, 1 + 4 + 4 + 64 + 32 + 1 + 1 + 1)
|
||||
.store_ref(state_init);
|
||||
var msg_body = begin_cell()
|
||||
.store_uint(op::internal_transfer(), 32)
|
||||
.store_uint(query_id, 64)
|
||||
.store_coins(jetton_amount)
|
||||
.store_slice(owner_address)
|
||||
.store_slice(response_address)
|
||||
.store_coins(forward_ton_amount)
|
||||
.store_slice(either_forward_payload)
|
||||
.end_cell();
|
||||
|
||||
msg = msg.store_ref(msg_body);
|
||||
int fwd_count = forward_ton_amount ? 2 : 1;
|
||||
throw_unless(709, msg_value >
|
||||
forward_ton_amount +
|
||||
;; 3 messages: wal1->wal2, wal2->owner, wal2->response
|
||||
;; but last one is optional (it is ok if it fails)
|
||||
fwd_count * fwd_fee +
|
||||
(2 * gas_consumption + min_tons_for_storage)); ;; TODO(shahar) ?
|
||||
;; universal message send fee calculation may be activated here
|
||||
;; by using this instead of fwd_fee
|
||||
;; msg_fwd_fee(to_wallet, msg_body, state_init, 15)
|
||||
|
||||
send_raw_message(msg.end_cell(), 64); ;; revert on errors
|
||||
save_data(balance, owner_address, jetton_master_address, jetton_wallet_code);
|
||||
}
|
||||
|
||||
{-
|
||||
internal_transfer query_id:uint64 amount:(VarUInteger 16) from:MsgAddress
|
||||
response_address:MsgAddress
|
||||
forward_ton_amount:(VarUInteger 16)
|
||||
forward_payload:(Either Cell ^Cell)
|
||||
= InternalMsgBody;
|
||||
-}
|
||||
|
||||
() receive_tokens (slice in_msg_body, slice sender_address, int my_ton_balance, int fwd_fee, int msg_value) impure {
|
||||
;; NOTE we can not allow fails in action phase since in that case there will be
|
||||
;; no bounce. Thus check and throw in computation phase.
|
||||
(int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) = load_data();
|
||||
int query_id = in_msg_body~load_uint(64);
|
||||
int jetton_amount = in_msg_body~load_coins();
|
||||
balance += jetton_amount;
|
||||
slice from_address = in_msg_body~load_msg_addr();
|
||||
slice response_address = in_msg_body~load_msg_addr();
|
||||
throw_unless(707,
|
||||
equal_slices(jetton_master_address, sender_address)
|
||||
|
|
||||
equal_slices(calculate_user_jetton_wallet_address(from_address, jetton_master_address, jetton_wallet_code), sender_address)
|
||||
);
|
||||
int forward_ton_amount = in_msg_body~load_coins();
|
||||
|
||||
int ton_balance_before_msg = my_ton_balance - msg_value;
|
||||
int storage_fee = min_tons_for_storage - min(ton_balance_before_msg, min_tons_for_storage);
|
||||
msg_value -= (storage_fee + gas_consumption);
|
||||
if(forward_ton_amount) {
|
||||
msg_value -= (forward_ton_amount + fwd_fee);
|
||||
slice either_forward_payload = in_msg_body;
|
||||
|
||||
var msg_body = begin_cell()
|
||||
.store_uint(op::transfer_notification(), 32)
|
||||
.store_uint(query_id, 64)
|
||||
.store_coins(jetton_amount)
|
||||
.store_slice(from_address)
|
||||
.store_slice(either_forward_payload)
|
||||
.end_cell();
|
||||
|
||||
var msg = begin_cell()
|
||||
.store_uint(0x10, 6) ;; we should not bounce here cause receiver can have uninitialized contract
|
||||
.store_slice(owner_address)
|
||||
.store_coins(forward_ton_amount)
|
||||
.store_uint(1, 1 + 4 + 4 + 64 + 32 + 1 + 1)
|
||||
.store_ref(msg_body);
|
||||
|
||||
send_raw_message(msg.end_cell(), 1);
|
||||
}
|
||||
|
||||
if ((response_address.preload_uint(2) != 0) & (msg_value > 0)) {
|
||||
var msg = begin_cell()
|
||||
.store_uint(0x10, 6) ;; nobounce - int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 010000
|
||||
.store_slice(response_address)
|
||||
.store_coins(msg_value)
|
||||
.store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1)
|
||||
.store_uint(op::excesses(), 32)
|
||||
.store_uint(query_id, 64);
|
||||
send_raw_message(msg.end_cell(), 2);
|
||||
}
|
||||
|
||||
save_data(balance, owner_address, jetton_master_address, jetton_wallet_code);
|
||||
}
|
||||
|
||||
() burn_tokens (slice in_msg_body, slice sender_address, int msg_value, int fwd_fee) impure {
|
||||
;; NOTE we can not allow fails in action phase since in that case there will be
|
||||
;; no bounce. Thus check and throw in computation phase.
|
||||
(int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) = load_data();
|
||||
int query_id = in_msg_body~load_uint(64);
|
||||
int jetton_amount = in_msg_body~load_coins();
|
||||
slice response_address = in_msg_body~load_msg_addr();
|
||||
;; ignore custom payload
|
||||
;; slice custom_payload = in_msg_body~load_dict();
|
||||
balance -= jetton_amount;
|
||||
throw_unless(705, equal_slices(owner_address, sender_address));
|
||||
throw_unless(706, balance >= 0);
|
||||
throw_unless(707, msg_value > fwd_fee + 2 * gas_consumption);
|
||||
|
||||
var msg_body = begin_cell()
|
||||
.store_uint(op::burn_notification(), 32)
|
||||
.store_uint(query_id, 64)
|
||||
.store_coins(jetton_amount)
|
||||
.store_slice(owner_address)
|
||||
.store_slice(response_address)
|
||||
.end_cell();
|
||||
|
||||
var msg = begin_cell()
|
||||
.store_uint(0x18, 6)
|
||||
.store_slice(jetton_master_address)
|
||||
.store_coins(0)
|
||||
.store_uint(1, 1 + 4 + 4 + 64 + 32 + 1 + 1)
|
||||
.store_ref(msg_body);
|
||||
|
||||
send_raw_message(msg.end_cell(), 64);
|
||||
|
||||
save_data(balance, owner_address, jetton_master_address, jetton_wallet_code);
|
||||
}
|
||||
|
||||
() on_bounce (slice in_msg_body) impure {
|
||||
in_msg_body~skip_bits(32); ;; 0xFFFFFFFF
|
||||
(int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) = load_data();
|
||||
int op = in_msg_body~load_uint(32);
|
||||
throw_unless(709, (op == op::internal_transfer()) | (op == op::burn_notification()));
|
||||
int query_id = in_msg_body~load_uint(64);
|
||||
int jetton_amount = in_msg_body~load_coins();
|
||||
balance += jetton_amount;
|
||||
save_data(balance, owner_address, jetton_master_address, jetton_wallet_code);
|
||||
}
|
||||
|
||||
() recv_internal(int my_balance, int msg_value, cell in_msg_full, slice in_msg_body) impure {
|
||||
if (in_msg_body.slice_empty?()) { ;; ignore empty messages
|
||||
return ();
|
||||
}
|
||||
|
||||
slice cs = in_msg_full.begin_parse();
|
||||
int flags = cs~load_uint(4);
|
||||
if (flags & 1) {
|
||||
on_bounce(in_msg_body);
|
||||
return ();
|
||||
}
|
||||
slice sender_address = cs~load_msg_addr();
|
||||
cs~load_msg_addr(); ;; skip dst
|
||||
cs~load_coins(); ;; skip value
|
||||
cs~skip_bits(1); ;; skip extracurrency collection
|
||||
cs~load_coins(); ;; skip ihr_fee
|
||||
int fwd_fee = muldiv(cs~load_coins(), 3, 2); ;; we use message fwd_fee for estimation of forward_payload costs
|
||||
|
||||
int op = in_msg_body~load_uint(32);
|
||||
|
||||
if (op == op::transfer()) { ;; outgoing transfer
|
||||
send_tokens(in_msg_body, sender_address, msg_value, fwd_fee);
|
||||
return ();
|
||||
}
|
||||
|
||||
if (op == op::internal_transfer()) { ;; incoming transfer
|
||||
receive_tokens(in_msg_body, sender_address, my_balance, fwd_fee, msg_value);
|
||||
return ();
|
||||
}
|
||||
|
||||
if (op == op::burn()) { ;; burn
|
||||
burn_tokens(in_msg_body, sender_address, msg_value, fwd_fee);
|
||||
return ();
|
||||
}
|
||||
|
||||
throw(0xffff);
|
||||
}
|
||||
|
||||
(int, slice, slice, cell) get_wallet_data() method_id {
|
||||
return load_data();
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue