@layerzerolabs/layerzero-v2-ton 3.0.19-ton.0 → 3.0.19-ton.1

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/ulnSendWorkerV1.fc

@@ -0,0 +1,363 @@
+#include "../../../../funC++/classlib.fc";
+#include "../../../../funC++/stdlib.fc";
+#include "../../../../funC++/utils.fc";
+#include "../../../../classes/msgdata/LzSend.fc";
+;; updated storage
+cell ulnWorker::setConfig(cell $storage, cell $md) method_id {
+    return $storage;
+}
+
+tuple ulnWorker::quote(tuple inputs) method_id {
+    cell $lzSend = inputs.cell_at(2);
+
+    int maxCount = $lzSend.cl::get<uint64>(md::LzSend::sendRequestId);
+    throw_if(1000, maxCount == 111);
+
+    int count = 0;
+    while (count < maxCount) {
+        count += 1;
+    }
+
+    return unsafeTuple(
+        [42, begin_cell().store_uint256(42).end_cell()]
+    );
+}
+
+tuple ulnWorker::simpleQuote(tuple inputs) method_id {
+    return inputs;
+}
+
+int ulnWorker::tooManyInputs(tuple one, tuple two, tuple three) method_id {
+    return 100;
+}
+
+int ulnWorker::tooFewInputs() method_id {
+    return 200;
+}
+
+(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int) ulnWorker::sixtyFourOutputs(tuple inputs) method_id {
+    return (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+}
+
+int ulnWorker::put16ItemsBeforeOOG(tuple inputs) method_id {
+    int a = 1;
+    int b = 2;
+    int c = 3;
+    int d = 4;
+    int e = 5;
+    int f = 6;
+    int g = 7;
+    int h = 8;
+    int i = 9;
+    int j = 10;
+    int k = 11;
+    int l = 12;
+    int m = 13;
+    int n = 14;
+    int o = 15;
+    int p = 16;
+
+    int counter = 10 * 1000;
+
+    while (counter > 0) {
+        counter -= 1;
+    }
+
+    return (a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p);
+}
+
+int ulnWorker::put32ItemsBeforeOOG(tuple inputs) method_id { 
+    int a0 = 100;
+    int a1 = 101;
+    int a2 = 102;
+    int a3 = 103;
+    int a4 = 104;
+    int a5 = 105;
+    int a6 = 106;
+    int a7 = 107;
+    int a8 = 108;
+    int a9 = 109;
+    int a10 = 110;
+    int a11 = 111;
+    int a12 = 112;
+    int a13 = 113;
+    int a14 = 114;
+    int a15 = 115;
+    int a16 = 116;
+    int a17 = 117;
+    int a18 = 118;
+    int a19 = 119;
+    int a20 = 120;
+    int a21 = 121;
+    int a22 = 122;
+    int a23 = 123;
+    int a24 = 124;
+    int a25 = 125;
+    int a26 = 126;
+    int a27 = 127;
+    int a28 = 128;
+    int a29 = 129;
+    int a30 = 130;
+    int a31 = 131;
+    int a32 = 132;
+
+    int counter = 20 * 1000;
+    
+    while (counter > 0) {
+        counter -= 1;
+    }
+
+    return (a0 + a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 + a14 + a15 + a16 + a17 + a18 + a19 + a20 + a21 + a22 + a23 + a24 + a25 + a26 + a27 + a28 + a29 + a30 + a31 + a32);
+}
+
+int ulnWorker::put64ItemsBeforeOOG(tuple inputs) method_id {
+    cell a0 = begin_cell().store_uint(100, 64).end_cell();
+    cell a1 = begin_cell().store_uint(101, 64).end_cell();
+    cell a2 = begin_cell().store_uint(102, 64).end_cell();
+    cell a3 = begin_cell().store_uint(103, 64).end_cell();
+    cell a4 = begin_cell().store_uint(104, 64).end_cell();
+    cell a5 = begin_cell().store_uint(105, 64).end_cell();
+    cell a6 = begin_cell().store_uint(106, 64).end_cell();
+    cell a7 = begin_cell().store_uint(107, 64).end_cell();
+    cell a8 = begin_cell().store_uint(108, 64).end_cell();
+    cell a9 = begin_cell().store_uint(109, 64).end_cell();
+    cell a10 = begin_cell().store_uint(110, 64).end_cell();
+    cell a11 = begin_cell().store_uint(111, 64).end_cell();
+    cell a12 = begin_cell().store_uint(112, 64).end_cell();
+    cell a13 = begin_cell().store_uint(113, 64).end_cell();
+    cell a14 = begin_cell().store_uint(114, 64).end_cell();
+    cell a15 = begin_cell().store_uint(115, 64).end_cell();
+    cell a16 = begin_cell().store_uint(116, 64).end_cell();
+    cell a17 = begin_cell().store_uint(117, 64).end_cell();
+    cell a18 = begin_cell().store_uint(118, 64).end_cell();
+    cell a19 = begin_cell().store_uint(119, 64).end_cell();
+    cell a20 = begin_cell().store_uint(120, 64).end_cell();
+    cell a21 = begin_cell().store_uint(121, 64).end_cell();
+    cell a22 = begin_cell().store_uint(122, 64).end_cell();
+    cell a23 = begin_cell().store_uint(123, 64).end_cell();
+    cell a24 = begin_cell().store_uint(124, 64).end_cell();
+    cell a25 = begin_cell().store_uint(125, 64).end_cell();
+    cell a26 = begin_cell().store_uint(126, 64).end_cell();
+    cell a27 = begin_cell().store_uint(127, 64).end_cell();
+    cell a28 = begin_cell().store_uint(128, 64).end_cell();
+    cell a29 = begin_cell().store_uint(129, 64).end_cell();
+    cell a30 = begin_cell().store_uint(130, 64).end_cell();
+    cell a31 = begin_cell().store_uint(131, 64).end_cell();
+    cell a32 = begin_cell().store_uint(132, 64).end_cell();
+    cell a33 = begin_cell().store_uint(133, 64).end_cell();
+    cell a34 = begin_cell().store_uint(134, 64).end_cell();
+    cell a35 = begin_cell().store_uint(135, 64).end_cell();
+    cell a36 = begin_cell().store_uint(136, 64).end_cell();
+    cell a37 = begin_cell().store_uint(137, 64).end_cell();
+    cell a38 = begin_cell().store_uint(138, 64).end_cell();
+    cell a39 = begin_cell().store_uint(139, 64).end_cell();
+    cell a40 = begin_cell().store_uint(140, 64).end_cell();
+    cell a41 = begin_cell().store_uint(141, 64).end_cell();
+    cell a42 = begin_cell().store_uint(142, 64).end_cell();
+    cell a43 = begin_cell().store_uint(143, 64).end_cell();
+    cell a44 = begin_cell().store_uint(144, 64).end_cell();
+    cell a45 = begin_cell().store_uint(145, 64).end_cell();
+    cell a46 = begin_cell().store_uint(146, 64).end_cell();
+    cell a47 = begin_cell().store_uint(147, 64).end_cell();
+    cell a48 = begin_cell().store_uint(148, 64).end_cell();
+    cell a49 = begin_cell().store_uint(149, 64).end_cell();
+    cell a50 = begin_cell().store_uint(150, 64).end_cell();
+    cell a51 = begin_cell().store_uint(151, 64).end_cell();
+    cell a52 = begin_cell().store_uint(152, 64).end_cell();
+    cell a53 = begin_cell().store_uint(153, 64).end_cell();
+    cell a54 = begin_cell().store_uint(154, 64).end_cell();
+    cell a55 = begin_cell().store_uint(155, 64).end_cell();
+    cell a56 = begin_cell().store_uint(156, 64).end_cell();
+    cell a57 = begin_cell().store_uint(157, 64).end_cell();
+    cell a58 = begin_cell().store_uint(158, 64).end_cell();
+    cell a59 = begin_cell().store_uint(159, 64).end_cell();
+    cell a60 = begin_cell().store_uint(160, 64).end_cell();
+    cell a61 = begin_cell().store_uint(161, 64).end_cell();
+    cell a62 = begin_cell().store_uint(162, 64).end_cell();
+    cell a63 = begin_cell().store_uint(163, 64).end_cell();
+    cell a64 = begin_cell().store_uint(164, 64).end_cell();
+
+    int counter = 30 * 1000;
+    
+    while (counter > 0) {
+        counter -= 1;
+    }
+
+    return (
+        a0.begin_parse().preload_uint(64) +
+        a1.begin_parse().preload_uint(64) +
+        a2.begin_parse().preload_uint(64) +
+        a3.begin_parse().preload_uint(64) +
+        a4.begin_parse().preload_uint(64) +
+        a5.begin_parse().preload_uint(64) +
+        a6.begin_parse().preload_uint(64) +
+        a7.begin_parse().preload_uint(64) +
+        a8.begin_parse().preload_uint(64) +
+        a9.begin_parse().preload_uint(64) +
+        a10.begin_parse().preload_uint(64) +
+        a11.begin_parse().preload_uint(64) +
+        a12.begin_parse().preload_uint(64) +
+        a13.begin_parse().preload_uint(64) +
+        a14.begin_parse().preload_uint(64) +
+        a15.begin_parse().preload_uint(64) +
+        a16.begin_parse().preload_uint(64) +
+        a17.begin_parse().preload_uint(64) +
+        a18.begin_parse().preload_uint(64) +
+        a19.begin_parse().preload_uint(64) +
+        a20.begin_parse().preload_uint(64) +
+        a21.begin_parse().preload_uint(64) +
+        a22.begin_parse().preload_uint(64) +
+        a23.begin_parse().preload_uint(64) +
+        a24.begin_parse().preload_uint(64) +
+        a25.begin_parse().preload_uint(64) +
+        a26.begin_parse().preload_uint(64) +
+        a27.begin_parse().preload_uint(64) +
+        a28.begin_parse().preload_uint(64) +
+        a29.begin_parse().preload_uint(64) +
+        a30.begin_parse().preload_uint(64) +
+        a31.begin_parse().preload_uint(64) +
+        a32.begin_parse().preload_uint(64) +
+        a33.begin_parse().preload_uint(64) +
+        a34.begin_parse().preload_uint(64) +
+        a35.begin_parse().preload_uint(64) +
+        a36.begin_parse().preload_uint(64) +
+        a37.begin_parse().preload_uint(64) +
+        a38.begin_parse().preload_uint(64) +
+        a39.begin_parse().preload_uint(64) +
+        a40.begin_parse().preload_uint(64) +
+        a41.begin_parse().preload_uint(64) +
+        a42.begin_parse().preload_uint(64) +
+        a43.begin_parse().preload_uint(64) +
+        a44.begin_parse().preload_uint(64) +
+        a45.begin_parse().preload_uint(64) +
+        a46.begin_parse().preload_uint(64) +
+        a47.begin_parse().preload_uint(64) +
+        a48.begin_parse().preload_uint(64) +
+        a49.begin_parse().preload_uint(64) +
+        a50.begin_parse().preload_uint(64) +
+        a51.begin_parse().preload_uint(64) +
+        a52.begin_parse().preload_uint(64) +
+        a53.begin_parse().preload_uint(64) +
+        a54.begin_parse().preload_uint(64) +
+        a55.begin_parse().preload_uint(64) +
+        a56.begin_parse().preload_uint(64) +
+        a57.begin_parse().preload_uint(64) +
+        a58.begin_parse().preload_uint(64) +
+        a59.begin_parse().preload_uint(64) +
+        a60.begin_parse().preload_uint(64) +
+        a61.begin_parse().preload_uint(64) +
+        a62.begin_parse().preload_uint(64) +
+        a63.begin_parse().preload_uint(64) +
+        a64.begin_parse().preload_uint(64)
+    );
+}
+
+;; this is the other case, we could run out of gas by stack overflowing or by the gas limit
+int ulnWorker::fibonacci(tuple inputs) method_id {
+    int n = inputs.int_at(0);
+
+    if (n <= 0) {
+        return 0;
+    }
+    if (n == 1) {
+        return 1;
+    }
+    return ulnWorker::fibonacci(unsafeTuple([n - 1])) + ulnWorker::fibonacci(unsafeTuple([n - 2]));
+}
+
+int ulnWorker::tooFewInputs1() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs2() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs3() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs4() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs5() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs6() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs7() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs8() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs9() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs10() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs11() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs12() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs13() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs14() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs15() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs16() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs17() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs18() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs19() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs20() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs21() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs22() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs23() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs24() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs25() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs26() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs27() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs28() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs29() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs30() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs31() method_id {
+    return 200;
+}
+int ulnWorker::tooFewInputs32() method_id {
+    return 200;
+}

package/src/workers/core/abstract/workerHandler.fc

@@ -0,0 +1,150 @@
+#include "../../../funC++/handlerCore.fc";
+
+#include "../../../funC++/actions/call.fc";
+#include "../../../funC++/actions/event.fc";
+#include "../../../funC++/actions/payment.fc";
+
+#include "../../../classes/msgdata/CoinsAmount.fc";
+#include "../../../classes/msgdata/SetAddress.fc";
+#include "../../../classes/msgdata/MdObj.fc";
+
+#include "../../msgdata/ExecuteParams.fc";
+
+#include "../../../protocol/msglibs/ultralightnode/uln/interface.fc";
+#include "../../../protocol/msglibs/ultralightnode/ulnManager/interface.fc";
+#include "../../proxy/interface.fc";
+#include "../workerCoreStorage.fc";
+
+cell getInitialStorage() impure inline {
+    return empty_cell();
+}
+
+;; declared inside of the actions/event.fc
+;; We declare it here because it saves the need for declaring initialStorage everytime we call event
+tuple _newAction<event>(int topic, cell $body) impure inline {
+    return action::event::New(topic, $body, cl::nullObject());
+}
+
+;;; ==========================================
+;; Modifiers
+() assertAuthenticated() impure inline { }
+
+() assertInitialized() impure inline { }
+
+() assertAdmin() impure inline {
+    cell $admins = getCoreStorage().cl::get<cellRef>(WorkerCoreStorage::admins);
+    throw_unless(
+        Worker::ERROR::onlyAdmin, 
+        AddressList::includes(getCaller(), $admins.begin_parse())
+    );
+}
+
+;; Step 1: authenticate
+() authenticate() impure { }
+
+() authenticateIfNecessary() impure inline { }
+
+;; Step 2: initialize
+;; mdAddress: (md=null, address=proxy), they're both 256.
+tuple initialize(cell $mdAddress) impure inline {
+    return emptyActions();
+}
+
+() assertOwner() impure inline { }
+
+;;; =================================== EVENT FUNCTIONS =================================
+
+int _getEventSink() impure inline method_id {
+    int eventSink = getCoreStorage().cl::get<address>(WorkerCoreStorage::proxy);
+    if (eventSink == NULLADDRESS) {
+        return getContractAddress();
+    }
+    return eventSink;
+}
+
+int verifyEventOrigin(int address) method_id {
+    return AddressList::includes(
+        address, getCoreStorage().cl::get<objRef>(WorkerCoreStorage::admins).begin_parse()
+    );
+}
+
+;;; =================================== (HANDLER) HELPER FUNCTIONS =================================
+
+tuple _claimTon(tuple actions, cell $coinsAmount) impure {
+    ;; this amount will be paid from the contract balance
+    actions~pushAction<payment>(
+        getCaller(),
+        $coinsAmount.cl::get<coins>(md::CoinsAmount::amount),
+        $coinsAmount.cl::get<coins>(md::CoinsAmount::amount)
+    );
+
+    return actions;
+}
+
+tuple _callContract(tuple actions, cell $executeParams) impure inline {
+    actions~pushAction<call>(
+        $executeParams.cl::get<address>(md::ExecuteParams::target),
+        $executeParams.cl::get<uint32>(md::ExecuteParams::opcode),
+        $executeParams.cl::get<objRef>(md::ExecuteParams::callData)
+    );
+
+    return actions;
+}
+
+tuple _setAdmins(tuple actions, cell $addressList) impure {
+    actions~pushAction<event>(
+        Worker::event::ADMINS_SET,
+        $addressList
+    );
+
+    setContractStorage(
+        getContractStorage().setCoreStorage(
+            getCoreStorage().cl::set(
+                WorkerCoreStorage::admins,
+                $addressList
+            )
+        )
+    );
+
+    return actions;
+}
+
+tuple _setProxyAddress(tuple actions, int newProxyAddress) impure {
+    setContractStorage(
+        getContractStorage().setCoreStorage(
+            getCoreStorage().cl::set(WorkerCoreStorage::proxy, newProxyAddress)
+        )
+    );
+    return actions;
+}
+
+tuple _callViaProxy(tuple actions, cell $executeParams) impure {
+    ;; only these opcodes are allowed to be called from the worker to the proxy
+    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    throw_unless(
+        Worker::ERROR::DISALLOWED_INNER_OPCODE, 
+        (opcode == Uln::OP::UPDATE_WORKER_FEELIB)
+        | (opcode == Uln::OP::DEREGISTER_WORKER_FEELIB)
+        | (opcode == UlnManager::OP::ADD_ULN_WORKER)
+        | (opcode == Worker::OP::CLAIM_TON)
+    );
+
+    return _callContract(
+        actions,
+        md::ExecuteParams::New(
+            getProxyAddress(),
+            $executeParams,
+            0,
+            Proxy::OP::CALL_CONTRACT
+        )
+    );
+}
+
+;;; =================================== VIEW FUNCTIONS =================================
+
+int getLatestAdmin() impure method_id {
+    slice adminSlice = getCoreStorage()
+        .cl::get<cellRef>(WorkerCoreStorage::admins)
+        .begin_parse();
+    return adminSlice~AddressList::next();
+}

package/src/workers/core/interface.fc

@@ -0,0 +1,25 @@
+;;; ==========================OPCODES=====================================
+;; Any authorized signer can call CLAIM_TON to claim funds in the executor contract.
+const int Worker::OP::CLAIM_TON = "Worker::OP::CLAIM_TON"c;
+
+;; Send an arbitrary command to an arbitrary contract
+;; only owner
+const int Worker::OP::CALL_VIA_PROXY = "Worker::OP::CALL_VIA_PROXY"c;
+
+;; Change the proxy address
+;; only admins
+const int Worker::OP::SET_PROXY = "Worker::OP::SET_PROXY"c;
+
+;; Change the list of admins
+;; only admins
+const int Worker::OP::SET_ADMINS = "Worker::OP::SET_ADMINS"c;
+
+;;; ==========================ERRORS=====================================
+const int Worker::ERROR::onlyAdmin = 2015;
+const int Worker::ERROR::invalidOpcode = 2014;
+
+const int Worker::ERROR::DISALLOWED_INNER_OPCODE = 2013;
+const int Worker::ERROR::DISALLOWED_INNER_TARGET = 2012;
+
+;;; ==========================EVENTS=====================================
+const int Worker::event::ADMINS_SET = "Worker::event::ADMINS_SET"u;

package/src/workers/core/workerCoreStorage.fc

@@ -0,0 +1,44 @@
+#include "../../funC++/classlib.fc";
+
+#include "interface.fc";
+
+;; !!! If you put this storage anywhere other than index 0 of your custom contract storage,
+;; you are gunna have a bad time
+const int WORKER_CORE_STORAGE_IDX = 0;
+
+;; required object name
+const int WorkerCoreStorage::NAME = "wrkCorStor"u;
+
+;; field names
+const int WorkerCoreStorage::admins = 0;
+const int WorkerCoreStorage::proxy = 1;
+const int WorkerCoreStorage::version = 2;
+
+;; In all blockchains with atomic cross-contract call, we can use src/dst/sender/receiver
+;; because the send channel doesn't exist (it's just a nonce).
+;; In TON, we need both send/receive channels, so we use local/remote to provide
+;; a context-free way to refer to the two ends of the channel.
+;; The direction is inferred by the context of the contract (send vs receive).
+;; The srcOApp is the 256-bit hashpart of a standard address.
+cell WorkerCoreStorage::New(cell admins, int proxy, int version) inline method_id {
+    return cl::declare(
+        WorkerCoreStorage::NAME,
+        unsafeTuple([
+            [cl::t::cellRef, admins],       ;; WorkerCoreStorage::admins
+            [cl::t::address, proxy],        ;; WorkerCoreStorage::proxy
+            [cl::t::uint256, version]       ;; WorkerCoreStorage::version
+        ])
+    );
+}
+
+cell getCoreStorage() impure inline {
+    return getContractStorage().cl::get<objRef>(WORKER_CORE_STORAGE_IDX);
+}
+
+cell setCoreStorage(cell $storage, cell $newCoreStorage) impure inline {
+    return $storage.cl::set(WORKER_CORE_STORAGE_IDX, $newCoreStorage);
+}
+
+int getProxyAddress() impure inline {
+    return getCoreStorage().cl::get<address>(WorkerCoreStorage::proxy);
+}