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

package/src/jettons/zro/wallet.fc

@@ -0,0 +1,261 @@
+#include "op-codes.fc";
+#include "utils.fc";
+#include "../../../node_modules/@ston-fi/funcbox/autoload.fc";
+
+;; Jetton Wallet Smart Contract
+
+{-
+
+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)
+
+-}
+
+int min_tons_for_storage() asm "10000000 PUSHINT"; ;; 0.01 TON
+;; Note that 2 * gas_consumptions is expected to be able to cover fees on both wallets (sender and receiver)
+;; and also constant fees on inter-wallet interaction, in particular fwd fee on state_init transfer
+;; that means that you need to reconsider this fee when:
+;; a) jetton logic become more gas-heavy
+;; b) jetton-wallet code (sent with inter-wallet message) become larger or smaller
+;; c) global fee changes / different workchain
+int gas_consumption() asm "15000000 PUSHINT"; ;; 0.015 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(BASECHAIN, to_owner_address, 101);
+
+    (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()));
+    ;; 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());
+    slice either_forward_payload = in_msg_body;
+    if(forward_ton_amount) {
+        msg_value -= (forward_ton_amount + fwd_fee);
+
+        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_body = begin_cell()
+            .store_uint(op::excesses, 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) ;; 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(1, 1 + 4 + 4 + 64 + 32 + 1 + 1)
+            .store_ref(msg_body);
+        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();
+}

package/tests/baseContractTest.fc

@@ -0,0 +1,192 @@
+#include "./testMain.fc";
+#include "../src/funC++/classlib.fc";
+#include "../src/funC++/stringlib.fc";
+#include "../src/funC++/utils.fc";
+
+#include "../src/funC++/actions/event.fc";
+#include "../src/funC++/actions/sendJettons.fc";
+#include "../src/funC++/actions/call.fc";
+#include "../src/funC++/actions/deploy.fc";
+#include "../src/funC++/actions/destroy.fc";
+#include "../src/funC++/actions/dispatch.fc";
+#include "../src/funC++/actions/payment.fc";
+
+;;; ===============================INTERFACE FUNCTIONS===========================
+int _callCheckPermissions(int op, cell $md) impure;
+
+;;; ===============================BASE TEST INTERFACE IMPLEMENTATIONS===========================
+
+;; authenticates and initializes a base storage for an LZ contract
+() forceAuthenticate(int base_storage_idx) impure;
+
+cell createInitializedStorage() impure;
+
+cell baseTest::prepare(tuple args) impure {
+    return createInitializedStorage();
+}
+
+;;; ===============================HELPER FUNCTIONS===========================
+() spoofCaller(int address_hashpart) impure inline {
+    setCaller(address_hashpart);
+}
+
+;;; ===============================TEST HANDLERS===============================
+;; An empty test, when inserted at the top of a test list it allows initialization of storage
+;; then returns success. Helps to avoid OOG for big contracts
+(int, slice) initializeTestStorage(cell $storage) impure {
+    return (TEST_SUCCESS, "");
+}
+
+;; int TEST_SUCCESS or TEST_FAILURE, slice (optional) error_message
+(int, slice) test::handler::shouldPass((cell -> tuple) handler, cell $md, tuple expectedActions, cell $expectedStorage, tuple expectedTxnContext) impure {
+    ;; Checkpoint the current gas meter
+    int start = get_gas_consumed();
+
+    ;; Run the actual handler
+    tuple actions = handler($md);
+
+    ;; Optionally profile gas
+    if (do_profile) {
+        ;; Should not inline gasConsumed because the string construction costs gas
+        int gasConsumed = get_gas_consumed() - start;
+        ~strdump(base_error_msg.str::concat(" consumed gas: ").str::concatInt(gasConsumed));
+    }
+
+    ;; Check the number of actions matches the expected
+    int numActions = actions.tlen();
+    if (numActions != expectedActions.tlen()) {
+        return (
+            TEST_FAILED,
+            "action length incorrect:"
+                .str::concatInt(actions.tlen())
+                .str::concat(" !== ")
+                .str::concatInt(expectedActions.tlen())
+        );
+    }
+
+    if (actions.int_at(0) != expectedActions.int_at(0)) {
+        return (TEST_FAILED, "action value outflow incorrect");
+    }
+
+    ;; Check that each action matches the expected action
+    int index = 1;
+    tuple terminalIndices = empty_tuple();
+    while (index < numActions) {
+        tuple actualAction = actions.tuple_at(index);
+        tuple expectedAction = expectedActions.tuple_at(index);
+        if (actualAction.int_at(0) != expectedAction.int_at(0)) {
+            test::throwError("action type incorrect: ".str::concatInt(index));
+        }
+        int actionType = actualAction.int_at(0);
+        int equal = false;
+
+        if (actionType == action::destroy::NAME) {
+            terminalIndices = terminalIndices.tpush(index);
+            equal = action::destroy::equals(actualAction, expectedAction);
+        } elseif (actionType == action::deploy::NAME) {
+            terminalIndices = terminalIndices.tpush(index);
+            equal = action::deploy::equals(actualAction, expectedAction);
+        } elseif (actionType == action::call::NAME) {
+            terminalIndices = terminalIndices.tpush(index);
+            equal = action::call::equals(actualAction, expectedAction);
+        } elseif (actionType == action::dispatch::NAME) {
+            equal = action::dispatch::equals(actualAction, expectedAction);
+        } elseif (actionType == action::payment::NAME) {
+            equal = action::payment::equals(actualAction, expectedAction);
+        } elseif (actionType == action::event::NAME) {
+            equal = action::event::equals(actualAction, expectedAction);
+        } elseif (actionType == action::sendJettons::NAME) {
+            equal = action::sendJettons::equals(actualAction, expectedAction);
+        }
+        ifnot (equal) {
+            test::throwError("action incorrect: ".str::concatInt(index));
+        }
+        index += 1;
+    }
+    if (terminalIndices.tlen() > 1) {
+        test::throwError("Multiple terminal actions");
+    }
+
+    ;; Check that the storage after running the handler matches the expected storage
+    int wrongField = compareObjectFields(getContractStorage(), $expectedStorage);
+    if (wrongField == INVALID_CLASS_MEMBER) {
+        return (
+            TEST_FAILED,
+            "Storage and expected storage not of the same type"
+        );
+    } elseif (wrongField != -1) {
+        return (
+            TEST_FAILED,
+            "malformed field ".str::concatInt(wrongField)
+        );
+    }
+    if (expectedTxnContext.tlen() != txnContext.tlen()) {
+        return (TEST_FAILED, "malformed txn context");
+    }
+    ;; check context
+    int index = 0;
+    while (index < txnContext.tlen()) {
+        int mismatch = false;
+        if (txnContext.at(index).is_int()) {
+            mismatch = (txnContext.int_at(index) != expectedTxnContext.int_at(index));
+        } elseif (txnContext.at(index).is_cell()) {
+            mismatch = (txnContext.cell_at(index).cell_hash() != expectedTxnContext.cell_at(index).cell_hash());
+        } elseif (txnContext.at(index).is_slice()) {
+            mismatch = (~ txnContext.slice_at(index).equal_slices(expectedTxnContext.slice_at(index)));
+        } else {
+            mismatch = (~ txnContext.cell_at(index).cl::hash() == expectedTxnContext.cell_at(index).cl::hash());
+        }
+        if (mismatch) {
+            return (TEST_FAILED, "txn context mismatch at index".str::concatInt(index));
+        }
+        index += 1;
+    }
+
+    ;; If all checks pass, return success
+    return (TEST_SUCCESS, "");
+}
+
+(int, slice) test::handler::shouldFail((cell -> tuple) fn, cell $md, int expected_error) impure {
+    int failed = false;
+    try {
+        if (fn($md).tlen() >= 0) {
+            failed = true;
+            return (TEST_FAILED, "test::handler::shouldFail never throws");
+        }
+    } catch(x, n) {
+        if (n != expected_error) {
+            return (
+                TEST_FAILED,
+                "actual error: "
+                    .str::concatInt(n)
+                    .str::concat(" != expected: ")
+                    .str::concatInt(expected_error)
+            );
+        }
+    }
+
+    return (TEST_SUCCESS, "");
+}
+
+(int, slice) test::permissions::shouldPass(int op, cell $md) impure {
+    int failed = false;
+    try {
+        _callCheckPermissions(op, $md);
+    } catch(x, n) {
+        failed = true;
+    }
+    return failed ? (TEST_FAILED, "permissions check should not have thrown") : (TEST_SUCCESS, "");
+}
+
+(int, slice) test::permissions::shouldFail(int op, cell $md) impure {
+    int failed = false;
+    try {
+        _callCheckPermissions(op, $md);
+        failed = true;
+    } catch(x, n) {
+        ;; Catch is a function that executes in its own context
+        ;; so if you try to return here, it will actually
+        ;; return execution to the try block, not the caller of test::permissions::shouldFail
+    }
+    return failed ? (TEST_FAILED, "permissions check should have thrown") : (TEST_SUCCESS, "");
+}

package/tests/testMain.fc

@@ -0,0 +1,135 @@
+#include "../src/funC++/classlib.fc";
+#include "../src/funC++/txnContext.fc";
+#include "../src/funC++/utils.fc";
+
+global slice base_error_msg;
+;; const int do_profile = -1; ;; doesn't compile with true
+const int do_profile = 0; ;; doesn't compile with false
+
+const int TEST_SUCCESS = -1;
+const int TEST_FAILED = 0;
+
+const int TEST_FN_IDX = 0;
+const int TEST_NAME_IDX = 1;
+
+;;; ===============================INTERFACE FUNCTIONS===========================
+slice _testName();
+tuple baseTest::getTests() impure;
+cell baseTest::prepare(tuple testCase) impure inline;
+
+;;; ===============================HELPER FUNCTIONS===========================
+const int DONE = 1;
+() emitDone() impure inline {
+    var msg = begin_cell()
+        .store_uint (12, 4) ;; ext_out_msg_info$11 src:MsgAddressInt ()
+        .store_uint (1, 2)
+        .store_uint (256, 9)
+        .store_uint(DONE, 256)
+        .store_uint(0, 64 + 32 + 2) ;; created_lt, created_at, init:Maybe, body:Either
+        .end_cell();
+    send_raw_message(msg, 0);
+}
+
+() test::throwError(slice msg) impure {
+    ~strdump(_testName()
+        .str::concat(": ")
+        .str::concat(base_error_msg)
+        .str::concat(": ")
+        .str::concat(msg)
+    );
+    throwError(
+        _testName()
+            .str::concat(": ")
+            .str::concat(base_error_msg)
+            .str::concat(": ")
+            .str::concat(msg)
+    );
+}
+
+() test::throwErrorUnless(int condition, slice msg) impure {
+    ifnot (condition) {
+        test::throwError(msg);
+    }
+}
+
+slice get_test_name(int index) impure method_id {
+    tuple tests = baseTest::getTests();
+    tuple testCase = tests.at(index);
+    return testCase.slice_at(TEST_NAME_IDX);
+}
+
+;;; ===============================Txn Context Manipulation===========================
+
+() setCaller(int caller) impure inline {
+    txnContext~tset(_CALLER, caller);
+}
+
+() setContractBalance(int balance) impure inline {
+    txnContext~tset(_BALANCE, balance);
+}
+
+;;; Returns the current value of `c7`.
+tuple _get_c7() impure asm "c7 PUSH";
+
+;;; Updates the current value of `c7`.
+() _set_c7(tuple c) impure asm "c7 POP";
+
+;; *Testing function only. Do not use in production code!*
+() setNewTime(int newTime) impure {
+    tuple c7 = _get_c7();
+    _set_c7(
+        c7.tset(0,
+            c7.tuple_at(0)
+                .tset(3, newTime)
+        )
+    );
+}
+
+
+;;; ===============================MAIN DRIVER FOR ALL TESTS===========================
+() main(int myBalance, int msgValue, cell inMsgFull, slice inMsgBody) impure {
+    ;; ignore empty messages
+    if (inMsgBody.slice_empty?()) {
+        return ();
+    }
+
+    initTxnContext(
+        myBalance,
+        msgValue,
+        inMsgFull,
+        inMsgBody
+    );
+
+    base_error_msg = "base_error_msg NOT set... ";
+
+    int index = getOpcode();
+
+    ;; Allow the test framework to prank arbitrary caller
+    setCaller(getOrigin());
+
+    tuple tests = baseTest::getTests();
+    if (index >= tests.tlen()) {
+        emitDone();
+    } else {
+        tuple testCase = tests.at(index);
+        var test_fn = testCase.at(TEST_FN_IDX);
+        base_error_msg = testCase.at(TEST_NAME_IDX);
+        cell input = baseTest::prepare(testCase);
+        cell $storage = getContractStorage();
+        (int success, slice reason) = test_fn(input);
+        setContractStorage($storage);
+        test::throwErrorUnless(success == TEST_SUCCESS, reason);
+    }
+}
+
+(int, slice) test::shouldBeTrue(int condition) {
+    ifnot (condition) {
+        return (TEST_FAILED, "test::shouldBeTrue");
+    } else {
+        return (TEST_SUCCESS, "");
+    }
+}
+
+(int, slice) test::shouldBeFalse(int condition) {
+    return test::shouldBeTrue(condition == false);
+}