@layerzerolabs/layerzero-v2-ton 3.0.12-ton.0

package/src/funC++/stringlib.fc

@@ -0,0 +1,75 @@
+#include "constants.fc";
+#include "stdlib.fc";
+#include "utils.fc";
+
+;;; ===============================STRING MANIPULATION FUNCTIONS===========================
+;; note that these functions are NOT optimized and should NOT be used in production code
+
+const int ASCII_ZERO = 48;
+const int ASCII_MASK = 0x1313131313131313131313131313131313131313131313131313131313131313;
+const int ASCII_A = 65;
+
+slice str::asciiUint256ToStr(int asciiUint256) {
+    int leading_zeroes = _SDCNTLEAD0(begin_cell().store_uint256(asciiUint256).end_cell().begin_parse());
+    int trailing_bits = 256 - leading_zeroes;
+    int mask = POW2(trailing_bits) - 1;
+    return begin_cell().store_uint256(asciiUint256 | (ASCII_MASK & (~ mask))).end_cell().begin_parse();
+}
+
+(slice, ()) ~str::concat(slice self, slice other) {
+    if(self.slice_bits() + other.slice_bits() > 127 * MAX_U8) {
+        throwError("Cannot concatenate: string too long");
+    }
+    return (begin_cell().store_slice(self).store_slice(other).end_cell().begin_parse(), ());
+}
+
+slice str::concat(slice self, slice other) {
+    self~str::concat(other);
+    return self;
+}
+
+(slice, ()) ~str::concatInt(slice self, int val) {
+    slice intSlice = empty_slice();
+    if (val < 0) {
+        self~str::concat("-");
+        val = -1 * val;
+    }
+    if (val == 0) {
+        intSlice~str::concat(begin_cell().store_uint8(ASCII_ZERO).end_cell().begin_parse());
+    }
+    while (val > 0) {
+        intSlice = begin_cell().store_uint8(ASCII_ZERO + val % 10).end_cell().begin_parse().str::concat(intSlice);
+        val /= 10;
+    }
+    return (self.str::concat(intSlice), ());
+}
+
+slice str::concatInt(slice self, int val) {
+    self~str::concatInt(val);
+    return self;
+}
+
+(slice, ()) ~str::concatHex(slice self, int val) {
+    slice hexSlice = empty_slice();
+    if (val == 0) {
+        hexSlice~str::concat(begin_cell().store_uint8(ASCII_ZERO).end_cell().begin_parse());
+    }
+    while (val > 0) {
+        if (val % 16 <= 9) {
+            hexSlice = begin_cell().store_uint8(ASCII_ZERO + val % 16).end_cell().begin_parse().str::concat(hexSlice);
+        } else {
+            hexSlice = begin_cell().store_uint8(ASCII_A + val % 16 - 10).end_cell().begin_parse().str::concat(hexSlice);
+        }
+        val = (val >> 4); ;; val /= 16
+    }
+    return (self.str::concat(hexSlice), ());
+}
+
+slice str::concatHex(slice self, int val) {
+    self~str::concatHex(val);
+    return self;
+}
+
+() str::console::log<int>(slice string, int val) impure {
+    ~strdump(string.str::concat(": ").str::concatInt(val));
+}

package/src/funC++/txnContext.fc

@@ -0,0 +1,126 @@
+#include "classlib.fc";
+
+global tuple txnContext;
+
+const _IS_BOUNCED = 0;
+const _CALLER = 1;
+const _FWD_FEE = 2;
+const _OPCODE = 3;
+const _QUERY_ID = 4;
+const _BALANCE = 5;
+const _MSG_VALUE = 6;
+const _BODY = 7;
+const _RAW_MSG = 8;
+const _ORIGIN = 9;
+const _DONATION_NANOS = 10;
+const _MD = 11;
+const _VALUE_OUTFLOW = 12;
+
+int getMsgValue() inline {
+    return txnContext.int_at(_MSG_VALUE);
+}
+
+int getOpcode() inline {
+    return txnContext.int_at(_OPCODE);
+}
+
+int txnIsBounced() inline {
+    return txnContext.int_at(_IS_BOUNCED);
+}
+
+int getContractBalance() inline {
+    return txnContext.int_at(_BALANCE);
+}
+
+int getInitialContractBalance() inline {
+    return getContractBalance() - getMsgValue();
+}
+
+int getCaller() inline {
+    return txnContext.int_at(_CALLER);
+}
+
+int getOrigin() inline {
+    return txnContext.int_at(_ORIGIN);
+}
+
+slice getOriginStd() inline {
+    return hashpartToBasechainAddressStd(getOrigin());
+}
+
+int getDonationNanos() inline {
+    return txnContext.int_at(_DONATION_NANOS);
+}
+
+() setDonationNanos(int nanos) impure inline {
+    txnContext~tset(_DONATION_NANOS, nanos);
+}
+
+cell getMsgData() inline {
+    return txnContext.cell_at(_MD);
+}
+
+() setOrigin(int newOrigin) impure inline {
+    txnContext~tset(_ORIGIN, newOrigin);
+}
+
+;; returns if slice empty
+;; if empty body, sets opcode=-1 & query_id=-1, so it cannot be faked
+() initTxnContext(int myBalance, int msgValue, cell inMsgValue, slice inMsgBody) impure inline {
+    slice cs = inMsgValue.begin_parse();
+    int flags = cs~load_uint(4);
+
+    int _is_bounced = false;
+    if flags & 1 {
+        _is_bounced = true;
+        inMsgBody~skip_bits(32); ;; 0xFFFFFFFF
+    }
+
+    int opcode = -1;
+    int query_id = -1;
+    int donationNanos = 0;
+    cell md = null();
+
+    slice _sender_address = cs~load_msg_addr();
+    cs~load_msg_addr();
+    cs~load_coins();
+    cs~skip_bits(1);
+    cs~load_coins();
+    int senderAddress = basechainAddressStdToHashpart(_sender_address);
+
+    ;; by default, the origin is the sender address
+    int origin = senderAddress;
+
+    ;; the inMsgBody parsing is technically compatible with the reference jetton implementation
+    ;; where donationNanos == the amount of tokens received
+    ;; and and the origin will contain garbage data
+    ifnot (inMsgBody.slice_empty?()) {
+        opcode = inMsgBody~load_uint(32);
+        query_id = inMsgBody~load_uint(64);
+        donationNanos = inMsgBody~load_coins();
+        ;; if the origin is explicitly overriden in the body, use that
+        if (inMsgBody.slice_bits() >= 267) {
+            origin = inMsgBody.preload_bits_offset(11, 256).preload_uint(256);
+        }
+        ifnot (inMsgBody.slice_refs_empty?()) {
+            md = inMsgBody.preload_ref();
+        }
+    }
+
+    txnContext = castToTuple([
+        _is_bounced,
+        senderAddress,
+        muldiv(cs~load_coins(), 3, 2),
+        opcode,
+        query_id,
+        myBalance,
+        msgValue,
+        inMsgBody, ;; could be an empty slice
+        inMsgValue,
+        origin,
+        donationNanos,
+        md
+    ]);
+}
+
+(builder) beginTonMessage(int _opcode) asm "txnContext GETGLOB 4 INDEX SWAP NEWC 32 STU 64 STU";

package/src/funC++/utils.fc

@@ -0,0 +1,119 @@
+#include "constants.fc";
+#include "stdlib.fc";
+
+forall X -> tuple unsafeTuple(X x) asm "NOP";
+(slice) as_slice(builder b) asm "ENDC CTOS";
+(slice, int) load_uint8(slice s) asm "8 LDU SWAP";
+(builder) store_uint8(builder b, int t) inline asm(t b) "8 STU";
+(slice, int) load_uint16(slice s) asm "16 LDU SWAP";
+(builder) store_uint16(builder b, int t) inline asm(t b) "16 STU";
+(slice, int) load_uint32(slice s) asm "32 LDU SWAP";
+(builder) store_uint32(builder b, int t) inline asm(t b) "32 STU";
+(slice, int) load_uint64(slice s) asm "64 LDU SWAP";
+(builder) store_uint64(builder b, int t) inline asm(t b) "64 STU";
+(slice, int) load_uint128(slice s) asm "128 LDU SWAP";
+(builder) store_uint128(builder b, int t) inline asm(t b) "128 STU";
+(slice, int) load_uint256(slice s) asm "256 LDU SWAP";
+(builder) store_uint256(builder b, int t) inline asm(t b) "256 STU";
+forall X -> int   is_null(X x) asm "ISNULL";
+forall X -> int   is_int(X x) asm "<{ TRY:<{ 0 PUSHINT ADD DROP -1 PUSHINT }>CATCH<{ 2DROP 0 PUSHINT }> }>CONT 1 1 CALLXARGS";
+forall X -> int   is_cell(X x) asm "<{ TRY:<{ CTOS DROP -1 PUSHINT }>CATCH<{ 2DROP 0 PUSHINT }> }>CONT 1 1 CALLXARGS";
+forall X -> int   is_slice(X x) asm "<{ TRY:<{ SBITS DROP -1 PUSHINT }>CATCH<{ 2DROP 0 PUSHINT }> }>CONT 1 1 CALLXARGS";
+forall X -> int   is_tuple(X x) asm "ISTUPLE";
+forall X -> cell  cast_to_cell(X x) asm "NOP";
+forall X -> slice cast_to_slice(X x) asm "NOP";
+forall X -> int   cast_to_int(X x) asm "NOP";
+forall X -> tuple cast_to_tuple(X x) asm "NOP";
+(cell) my_code() asm "MYCODE";
+(tuple) get_values() asm "INCOMINGVALUE";
+int storage_fees() asm "STORAGEFEES";
+(int, slice) ldones(slice s) asm "LDONES";
+
+(int) get_gas_consumed() asm "GASCONSUMED";
+
+builder store_zeroes(builder b, int x) asm "STZEROES";
+builder store_ones(builder b, int x) asm "STONES";
+cell preload_first_ref(slice s) asm "0 PLDREFIDX";
+slice preload_bits_offset(slice s, int offset, int len) asm "SDSUBSTR";
+(slice, int) load_bool(slice s) asm(-> 1 0) "1 LDI";
+(builder) store_bool(builder b, int v) asm(v b) "1 STI";
+cell empty_cell() asm "<b b> PUSHREF";
+forall X -> tuple tset(tuple t, int k, X x) asm(t x k) "SETINDEXVAR";
+forall X -> (tuple, ()) ~tset(tuple t, int k, X x) asm(t x k) "SETINDEXVAR";
+forall X -> (tuple, X) tpop(tuple t) asm "TPOP";
+int tlen(tuple t) asm "TLEN";
+int keccak256Builder(builder b) asm "1 PUSHINT HASHEXT_KECCAK256";
+
+int cell_is_empty(cell c) inline {
+    return c.cell_hash() == 68134197439415885698044414435951397869210496020759160419881882418413283430343;
+}
+
+int get_compute_fee(int workchain, int gas_used) asm(gas_used workchain) "GETGASFEE";
+int get_storage_fee(int workchain, int seconds, int bits, int cells) asm(cells bits seconds workchain) "GETSTORAGEFEE";
+int get_forward_fee(int workchain, int bits, int cells) asm(cells bits workchain) "GETFORWARDFEE";
+
+int ilog4(int x) asm(x) "UBITSIZE 4 PUSHINT DIV";
+cell preload_ref_at(slice s, int idx) inline asm "PLDREFVAR";
+slice scutfirst(slice s, int bits, int refs) inline asm "SCUTFIRST";
+slice scutlast(slice s, int bits, int refs) inline asm "SCUTLAST";
+slice subslice(slice s, int start_bits, int start_refs, int bits, int refs) inline asm "SUBSLICE";
+slice sskipfirst(slice s, int bits, int refs) inline asm "SSKIPFIRST";
+slice sdskipfirst(slice s, int bits) inline asm "SDSKIPFIRST";
+forall X -> builder cast_to_builder(X x) inline asm "NOP";
+int abs(int x) inline asm "ABS";
+
+() throwError(slice reason) impure inline {
+    ~strdump(reason);
+    throw(reason.slice_hash() & ERRORCODE_MASK);
+}
+
+() throwErrorUnless(int condition, slice reason) inline {
+    ifnot (condition) {
+        throwError(reason);
+    }
+}
+int _SDCNTLEAD0(slice x) asm "SDCNTLEAD0";
+int POW2(int y) asm "POW2";
+
+;; numCells, num_bits
+(int, int) getContractStateSize(cell code, cell init_storage) inline {
+    cell stateInit = begin_cell()
+        .store_uint(6, 5)
+        .store_ref(code)
+        .store_ref(init_storage)
+        .end_cell();
+    (int cellsCount, int bitsCount, _) = stateInit.compute_data_size(MAX_U16);
+    return (cellsCount, bitsCount);
+}
+
+int calculateStorageFees(int cellsCount, int bitsCount, int timeDelta) inline {
+    return get_storage_fee(BASECHAIN, timeDelta, bitsCount, cellsCount);
+}
+
+forall X -> tuple castToTuple(X x) asm "NOP";
+
+slice empty_slice() asm "<b b> <s PUSHSLICE";
+
+int treeShapeEqual(cell lhs, cell rhs) inline {
+    slice lhsSlice = lhs.begin_parse();
+    slice rhsSlice = rhs.begin_parse();
+    (int lhsBits, int lhsRefs) = lhsSlice.slice_bits_refs();
+    (int rhsBits, int rhsRefs) = rhsSlice.slice_bits_refs();
+    if ((lhsBits != rhsBits) | (lhsRefs != rhsRefs)) {
+        return false;
+    }
+    if (lhsRefs == 0) {
+        return true;
+    }
+    int subtreeShapeEqual = true;
+    int refIdx = 0;
+    while (refIdx < lhsRefs) {
+        subtreeShapeEqual &= treeShapeEqual(
+            lhsSlice.preload_ref_at(refIdx),
+            rhsSlice.preload_ref_at(refIdx)
+        );
+    }
+    return subtreeShapeEqual;
+}
+
+int _globvarIsNull(int idx) impure asm "GETGLOBVAR ISNULL";

package/src/jettons/zro/minter.fc

@@ -0,0 +1,120 @@
+#include "../../../node_modules/@ston-fi/funcbox/autoload.fc";
+#include "utils.fc";
+#include "op-codes.fc";
+#include "../../../node_modules/@ston-fi/funcbox/contracts/stdlib.fc";
+;; It is recommended to use https://github.com/ton-blockchain/token-contract/blob/main/ft/jetton-minter-discoverable.fc
+;; instead of this contract, see https://github.com/ton-blockchain/TEPs/blob/master/text/0089-jetton-wallet-discovery.md
+
+;; Jettons minter smart contract
+
+;; storage scheme
+;; storage#_ total_supply:Coins admin_address:MsgAddress content:^Cell jetton_wallet_code:^Cell = Storage;
+
+(int, slice, cell, cell) load_data() inline {
+    slice ds = get_data().begin_parse();
+    return (
+        ds~load_coins(), ;; total_supply
+        ds~load_msg_addr(), ;; admin_address
+        ds~load_ref(), ;; content
+        ds~load_ref()  ;; jetton_wallet_code
+    );
+}
+
+() save_data(int total_supply, slice admin_address, cell content, cell jetton_wallet_code) impure inline {
+    set_data(begin_cell()
+        .store_coins(total_supply)
+        .store_slice(admin_address)
+        .store_ref(content)
+        .store_ref(jetton_wallet_code)
+        .end_cell()
+    );
+}
+
+() mint_tokens(slice to_address, cell jetton_wallet_code, int amount, cell master_msg) impure {
+    cell state_init = calculate_jetton_wallet_state_init(to_address, my_address(), jetton_wallet_code);
+    slice to_wallet_address = calculate_jetton_wallet_address(state_init);
+    var msg = begin_cell()
+        .store_uint(0x18, 6)
+        .store_slice(to_wallet_address)
+        .store_coins(amount)
+        .store_uint(4 + 2 + 1, 1 + 4 + 4 + 64 + 32 + 1 + 1 + 1)
+        .store_ref(state_init)
+        .store_ref(master_msg);
+    send_raw_message(msg.end_cell(), 64); ;; pay transfer fees separately, revert on errors
+}
+
+() recv_internal(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) { ;; ignore all bounced messages
+        return ();
+    }
+    slice sender_address = cs~load_msg_addr();
+    int op = in_msg_body~load_uint(32);
+    int query_id = in_msg_body~load_uint(64);
+    (int total_supply, slice admin_address, cell content, cell jetton_wallet_code) = load_data();
+    if (op == op::mint()) {
+        throw_unless(73, equal_slices(sender_address, admin_address));
+
+        slice to_address = in_msg_body~load_msg_addr();
+        int amount = in_msg_body~load_coins();
+        cell master_msg = in_msg_body~load_ref();
+        slice master_msg_cs = master_msg.begin_parse();
+        master_msg_cs~skip_bits(32 + 64); ;; op + query_id
+        int jetton_amount = master_msg_cs~load_coins();
+        mint_tokens(to_address, jetton_wallet_code, amount, master_msg);
+        save_data(total_supply + jetton_amount, to_address, content, jetton_wallet_code);
+        return ();
+    }
+
+    if (op == op::burn_notification()) {
+        int jetton_amount = in_msg_body~load_coins();
+        slice from_address = in_msg_body~load_msg_addr();
+        throw_unless(74,
+            equal_slices(calculate_user_jetton_wallet_address(from_address, my_address(), jetton_wallet_code), sender_address)
+        );
+        save_data(total_supply - jetton_amount, admin_address, content, jetton_wallet_code);
+        slice response_address = in_msg_body~load_msg_addr();
+        if (response_address.preload_uint(2) != 0) {
+            var msg = begin_cell()
+                .store_uint(0x10, 6) ;; nobounce - int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 011000
+                .store_slice(response_address)
+                .store_coins(0)
+                .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 + 64);
+        }
+        return ();
+    }
+
+    if (op == 3) { ;; change admin
+        throw_unless(73, equal_slices(sender_address, admin_address));
+        slice new_admin_address = in_msg_body~load_msg_addr();
+        save_data(total_supply, new_admin_address, content, jetton_wallet_code);
+        return ();
+    }
+
+    if (op == 4) { ;; change content, delete this for immutable tokens
+        throw_unless(73, equal_slices(sender_address, admin_address));
+        save_data(total_supply, admin_address, in_msg_body~load_ref(), jetton_wallet_code);
+        return ();
+    }
+
+    throw(0xffff);
+}
+
+(int, int, slice, cell, cell) get_jetton_data() method_id {
+    (int total_supply, slice admin_address, cell content, cell jetton_wallet_code) = load_data();
+    return (total_supply, -1, admin_address, content, jetton_wallet_code);
+}
+
+slice get_wallet_address(slice owner_address) method_id {
+    (int total_supply, slice admin_address, cell content, cell jetton_wallet_code) = load_data();
+    return calculate_user_jetton_wallet_address(owner_address, my_address(), jetton_wallet_code);
+}

package/src/jettons/zro/op-codes.fc

@@ -0,0 +1,10 @@
+int op::transfer() asm "0xf8a7ea5 PUSHINT";
+int op::transfer_notification() asm "0x7362d09c PUSHINT";
+int op::internal_transfer() asm "0x178d4519 PUSHINT";
+;; this is "copied" because it's already imported in funcbox
+int op::excesses_copy() asm "0xd53276db PUSHINT";
+int op::burn() asm "0x595f07bc PUSHINT";
+int op::burn_notification() asm "0x7bdd97de PUSHINT";
+
+;; Minter
+int op::mint() asm "0x642b7d07 PUSHINT";

package/src/jettons/zro/params.fc

@@ -0,0 +1,18 @@
+#include "../../../node_modules/@ston-fi/funcbox/autoload.fc";
+
+int workchain() asm "0 PUSHINT";
+
+;; () force_chain(slice addr) impure {
+;;     (int wc, _) = parse_std_addr(addr);
+;;     throw_unless(333, wc == workchain());
+;; }
+
+(int) get_workchain(slice address) inline {
+    (int wc, _) = parse_std_addr(address);
+    return wc;
+}
+
+() force_chain(int workchain, slice address, int error_code) impure inline {
+    (int wc) = get_workchain(address);
+    throw_unless(error_code, wc == workchain);
+}

package/src/jettons/zro/utils.fc

@@ -0,0 +1,33 @@
+#include "../../../node_modules/@ston-fi/funcbox/autoload.fc";
+#include "params.fc";
+
+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));
+}
+