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

package/src/workers/msgdata/SetQuorum.fc

@@ -0,0 +1,20 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int md::SetQuorum::NAME = "setQuorum"u;
+
+;; field names
+const int md::SetQuorum::nonce = 0;
+const int md::SetQuorum::opcode = 1;
+const int md::SetQuorum::quorum = 2;
+
+cell md::SetQuorum::New(int nonce, int opcode, int quorum) inline method_id {
+    return cl::declare(
+        md::SetQuorum::NAME,
+        unsafeTuple([
+            [cl::t::uint64, nonce],     ;; md::SetQuorum::nonce
+            [cl::t::uint64, opcode],    ;; md::SetQuorum::opcode
+            [cl::t::uint64, quorum]     ;; md::SetQuorum::quorum
+        ])
+    );
+}

package/src/workers/msgdata/SignedRequest.fc

@@ -0,0 +1,18 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int md::SignedRequest::NAME = "sgndReq"u;
+
+;; field names
+const int md::SignedRequest::request = 0;
+const int md::SignedRequest::signatures = 1;
+
+cell md::SignedRequest::New(cell $request, cell signatures) method_id {
+    return cl::declare(
+        md::SignedRequest::NAME,
+        unsafeTuple([
+            [cl::t::objRef, $request],      ;; md::SignedRequest::request
+            [cl::t::dict256, signatures]    ;; md::SignedRequest::signaturesk
+        ])
+    );
+}

package/src/workers/priceFeedCache/handler.fc

@@ -0,0 +1,114 @@
+#include "../core/abstract/workerHandler.fc";
+
+#include "../core/interface.fc";
+
+#include "../../funC++/handlerCore.fc";
+
+#include "../../classes/msgdata/MdAddress.fc";
+
+#include "../msgdata/ExecuteParams.fc";
+
+#include "../proxy/interface.fc";
+#include "../../protocol/channel/interface.fc";
+#include "../../protocol/msglibs/ultralightnode/uln/interface.fc";
+
+#include "../../protocol/msglibs/ultralightnode/workerFeeLibs/priceFeedFeeLib/storage.fc";
+
+#include "interface.fc";
+#include "storage.fc";
+
+;;; ==========================PERMISSION FUNCTIONS=================================
+
+;; any of the admins can update the priceFeed cache -> priceFeedFeeLib
+;; but only the owner can call "callContract" from the priceFeedCache
+() _checkPermissions(int op, cell $md) impure inline {
+    if (op == Proxy::OP::HANDLE_CALLBACK) {
+        return ();
+    }
+    return assertAdmin();
+}
+
+;;; ==========================HANDLERS=====================================
+
+tuple claimTon(cell $coinsAmount) impure inline {
+    return _claimTon(emptyActions(), $coinsAmount);
+}
+
+tuple updatePrice(cell $mdAddress) impure inline {
+    (cell $storage, tuple actions) = preamble(); 
+
+    cell $ulnPriceFeed = $mdAddress.cl::get<objRef>(md::MdAddress::md);
+
+    cell $pfStorage = $storage
+        .cl::get<objRef>(PriceFeedCache::priceFeedFeeLibStorage)
+            .cl::set(
+                PriceFeedFeelib::priceRatio,
+                $ulnPriceFeed.cl::get<coins>(PriceFeedFeelib::priceRatio)
+            )
+            .cl::set(
+                PriceFeedFeelib::gasPriceInUnit,
+                $ulnPriceFeed.cl::get<uint64>(PriceFeedFeelib::gasPriceInUnit)
+            )
+            .cl::set(
+                PriceFeedFeelib::gasPerByte,
+                $ulnPriceFeed.cl::get<uint32>(PriceFeedFeelib::gasPerByte)
+            );
+
+    setContractStorage(
+        $storage.cl::set(PriceFeedCache::priceFeedFeeLibStorage, $pfStorage)
+    );
+
+    ;; call into the proxy to update the priceFeedFeeLib
+    return _callViaProxy(
+        actions,
+        md::ExecuteParams::New(
+            $mdAddress.cl::get<address>(md::MdAddress::address), ;; target address, usually the uln
+            $pfStorage, ;; new priceFeedFeeLib storage
+            0,
+            Uln::OP::UPDATE_WORKER_FEELIB
+        )
+    );
+}
+
+tuple updateNativePrice(cell $mdAddress) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $ulnPriceFeed = $mdAddress.cl::get<objRef>(md::MdAddress::md);
+
+    cell $pfStorage = $storage
+        .cl::get<objRef>(PriceFeedCache::priceFeedFeeLibStorage)
+        .cl::set(
+            PriceFeedFeelib::nativePriceUsd,
+            $ulnPriceFeed.cl::get<coins>(PriceFeedFeelib::nativePriceUsd)
+        );
+
+    setContractStorage(
+        $storage.cl::set(PriceFeedCache::priceFeedFeeLibStorage, $pfStorage)
+    );
+
+    ;; call into the proxy to update the priceFeedFeeLib
+    return _callViaProxy(
+        actions,
+        md::ExecuteParams::New(
+            $mdAddress.cl::get<address>(md::MdAddress::address), ;; target address, usually the uln
+            $pfStorage, ;; new priceFeedFeeLib storage
+            0,
+            Uln::OP::UPDATE_WORKER_FEELIB
+        )
+    );
+}
+
+tuple callViaProxy(cell $executeParams) impure inline {
+    return _callViaProxy(emptyActions(), $executeParams);
+}
+
+tuple setAdmins(cell $addressList) impure inline {
+    return _setAdmins(emptyActions(), $addressList);
+}
+
+tuple setProxy(cell $setAddress) impure inline {
+    return _setProxyAddress(
+        emptyActions(),
+        $setAddress.cl::get<address>(md::SetAddress::address)
+    );
+}

package/src/workers/priceFeedCache/interface.fc

@@ -0,0 +1,4 @@
+;;; ==========================OPCODES=====================================
+
+const int PriceFeedCache::OP::UPDATE_PRICE = "PriceFeedCache::OP::UPDATE_PRICE"c;
+const int PriceFeedCache::OP::UPDATE_NATIVE_PRICE = "PriceFeedCache::OP::UPDATE_NATIVE_PRICE"c;

package/src/workers/priceFeedCache/main.fc

@@ -0,0 +1,25 @@
+#include "../../protocol/core/abstract/protocolMain.fc";
+
+#include "handler.fc";
+#include "interface.fc";
+
+
+tuple _executeOpcode(int op, cell $md) impure inline {
+    if (op == PriceFeedCache::OP::UPDATE_PRICE) {
+        return updatePrice($md);
+    } elseif (op == PriceFeedCache::OP::UPDATE_NATIVE_PRICE) {
+        return updateNativePrice($md);
+    } elseif (op == Worker::OP::CALL_VIA_PROXY) {
+        return callViaProxy($md);
+    } elseif (op == Worker::OP::SET_ADMINS) {
+        return setAdmins($md);
+    } elseif (op == Worker::OP::CLAIM_TON) {
+        return claimTon($md);
+    } elseif (op == Worker::OP::SET_PROXY) {
+        return setProxy($md);
+    } elseif (op == Proxy::OP::HANDLE_CALLBACK) {
+        return emptyActions();
+    }
+    throw(BaseInterface::ERROR::invalidOpcode);
+    return empty_tuple();
+}

package/src/workers/priceFeedCache/storage.fc

@@ -0,0 +1,21 @@
+#include "../../funC++/classlib.fc";
+
+#include "../core/workerCoreStorage.fc";
+
+;; required object name
+const int PriceFeedCache::NAME = "pfCache"u;
+
+;; field names
+const int PriceFeedCache::workerCoreStorage = 0;
+const int PriceFeedCache::priceFeedFeeLibStorage = 1;
+
+;; @owner manager
+cell PriceFeedCache::New(cell admins, int version, cell $priceFeedFeeLib) method_id {
+    return cl::declare(
+        PriceFeedCache::NAME,
+        unsafeTuple([
+            [cl::t::objRef, WorkerCoreStorage::New(admins, NULLADDRESS, version)], ;; PriceFeedCache::workerCoreStorage
+            [cl::t::objRef, $priceFeedFeeLib]                                      ;; PriceFeedCache::priceFeedFeeLibStorage
+        ])
+    );
+}

package/src/workers/proxy/handler.fc

@@ -0,0 +1,81 @@
+#include "../core/abstract/workerHandler.fc";
+#include "../core/interface.fc";
+
+#include "../../classes/msgdata/MdAddress.fc";
+#include "../../classes/msgdata/Bool.fc";
+
+#include "../msgdata/ProxyMessage.fc";
+
+#include "../../protocol/msglibs/ultralightnode/uln/interface.fc";
+
+#include "./interface.fc";
+#include "./storage.fc";
+
+;;; ==========================PERMISSION FUNCTIONS=================================
+
+() assertLatestAdmin() impure inline {
+    throw_unless(
+        Proxy::ERROR::NOT_LATEST_ADMIN,
+        getCaller() == getLatestAdmin()
+    );
+}
+
+;; this is special in proxy, only the people in the address book can call 'callContract'
+() _checkPermissions(int op, cell $md) impure inline {
+    if (op == Proxy::OP::CALL_CONTRACT) {
+        return assertLatestAdmin();
+    } elseif (
+        (op == Worker::OP::SET_ADMINS)
+        | (op == Worker::OP::CLAIM_TON)
+        | (op == Proxy::OP::TOGGLE_CALLBACK)
+    ) {
+        return assertAdmin();
+    }
+    return ();
+}
+
+;;; ==========================HANDLERS=====================================
+
+tuple setAdmins(cell $addressList) impure inline {
+    return _setAdmins(emptyActions(), $addressList);
+}
+
+tuple claimTon(cell $coinsAmount) impure inline {
+    return _claimTon(emptyActions(), $coinsAmount);
+}
+
+tuple callContract(cell $executeParams) impure inline {
+    return _callContract(emptyActions(), $executeParams);
+}
+
+tuple callback(cell $md) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    if ($storage.cl::get<bool>(Proxy::callbackEnabled)) {
+        actions~pushAction<call>(
+            getLatestAdmin(),
+            Proxy::OP::HANDLE_CALLBACK,
+            md::ExecuteParams::New(
+                getCaller(),
+                $md,
+                0,
+                getOpcode()
+            )
+        );
+    }
+
+    return actions;
+}
+
+tuple toggleCallback(cell $boolMd) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    setContractStorage(
+        $storage.cl::set(
+            Proxy::callbackEnabled,
+            $boolMd.cl::get<bool>(md::Bool::bool)
+        )
+    );
+
+    return actions;
+}

package/src/workers/proxy/interface.fc

@@ -0,0 +1,11 @@
+;;; ==========================OPCODES=====================================
+const int Proxy::OP::CALL_CONTRACT = "Proxy::OP::CALL_CONTRACT"c;
+
+;; this is the opcode that we will "send out" of proxy to specify the callback
+;; note that every other opcode that's namespaced by some contract is handled by the contract itself
+;; but in this case, this opcode is handled by the target contract
+const int Proxy::OP::HANDLE_CALLBACK = "Proxy::OP::HANDLE_CALLBACK"c;
+
+const int Proxy::OP::TOGGLE_CALLBACK = "Proxy::OP::TOGGLE_CALLBACK"c;
+
+const int Proxy::ERROR::NOT_LATEST_ADMIN = 1919;

package/src/workers/proxy/main.fc

@@ -0,0 +1,17 @@
+#include "../../protocol/core/abstract/protocolMain.fc";
+
+#include "handler.fc";
+#include "interface.fc";
+
+tuple _executeOpcode(int op, cell $md) impure inline {
+    if (op == Worker::OP::SET_ADMINS) {
+        return setAdmins($md);
+    } elseif (op == Worker::OP::CLAIM_TON) {
+        return claimTon($md);
+    } elseif (op == Proxy::OP::CALL_CONTRACT) {
+        return callContract($md);
+    } elseif (op == Proxy::OP::TOGGLE_CALLBACK) {
+        return toggleCallback($md);
+    }
+    return callback($md);
+}

package/src/workers/proxy/storage.fc

@@ -0,0 +1,21 @@
+#include "../../funC++/classlib.fc";
+
+#include "../core/workerCoreStorage.fc";
+
+;; required object name
+const int Proxy::NAME = "pfProxy"u;
+
+;; field names
+const int Proxy::workerCoreStorage = 0; ;; = WORKER_CORE_STORAGE_IDX
+const int Proxy::callbackEnabled = 1;
+
+;; @owner manager
+cell Proxy::New(cell admins, int version) method_id {
+    return cl::declare(
+        Proxy::NAME,
+        unsafeTuple([
+            [cl::t::objRef, WorkerCoreStorage::New(admins, NULLADDRESS, version)], ;; Proxy::workerCoreStorage
+            [cl::t::bool, false] ;; Proxy::callbackEnabled
+        ])
+    );
+}

package/tests/testMain.fc

@@ -1,6 +1,5 @@
 #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