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

package/src/funC++/actions/call.fc

@@ -1,4 +1,5 @@
 #include "utils.fc";
+#include "../classlib.fc";
 
 const int action::call::NAME = "actionCall"u;
 
@@ -9,7 +10,7 @@ const int action::call::md = 3;
 ;; Call a method on the contract at address `to` with the given message data `md`
 ;; optionally provide value provisioned from this contract's balance
 ;; @terminal
-tuple action::call::New(int to, int opcode, cell $md) inline {
+tuple action::call::create(int to, int opcode, cell $md) inline {
     return unsafeTuple([action::call::NAME, to, opcode, $md]);
 }
 
@@ -30,7 +31,7 @@ int action::call::equals(tuple self, tuple other) inline {
 
 ;; overloaded when you want to pass 0 outflowNanos
 tuple _newAction<call>(int to, int opcode, cell $body) inline {
-    return action::call::New(to, opcode, $body);
+    return action::call::create(to, opcode, $body);
 }
 
 ;; overloaded when you want to pass 0 outflowNanos

package/src/funC++/actions/deploy.fc

@@ -1,5 +1,4 @@
 #include "utils.fc";
-#include "../stdlib.fc";
 
 ;;; =======================================================
 ;; Deploys a contract defined by the given code and storage object,
@@ -21,7 +20,7 @@ const int action::deploy::md = 5;
 const int action::deploy::outflowNanos = 6;
 
 ;; @terminal
-tuple action::deploy::New(
+tuple action::deploy::create(
     cell code,
     cell $storage,
     int donationNanos,
@@ -62,7 +61,7 @@ tuple _newAction<deployAndCall>(
     cell $md,
     int outflowNanos
 ) inline {
-    return action::deploy::New(
+    return action::deploy::create(
         code,
         $storage,
         donationNanos,

package/src/funC++/actions/destroy.fc

@@ -1,5 +1,4 @@
 #include "utils.fc";
-#include "../stdlib.fc";
 
 const int action::destroy::NAME = "destroy"u;
 
@@ -8,7 +7,7 @@ const int action::destroy::opcode = 2;
 const int action::destroy::md = 3;
 
 ;; @terminal
-tuple action::destroy::New(int to, int opcode, cell $md) inline {
+tuple action::destroy::create(int to, int opcode, cell $md) inline {
     return unsafeTuple([action::destroy::NAME, to, opcode, $md]);
 }
 

package/src/funC++/actions/dispatch.fc

@@ -1,5 +1,4 @@
 #include "utils.fc";
-#include "../stdlib.fc";
 
 #include "call.fc";
 
@@ -13,7 +12,7 @@ const int action::dispatch::gasNanos = 4;
 ;; Call a method on the contract at address `to` with the given message data `md`
 ;; optionally provide value provisioned from this contract's balance
 ;; @terminal
-tuple action::dispatch::New(int to, int opcode, cell $md, int gasNanos) inline {
+tuple action::dispatch::create(int to, int opcode, cell $md, int gasNanos) inline {
     return unsafeTuple([action::dispatch::NAME, to, opcode, $md, gasNanos]);
 }
 
@@ -33,7 +32,7 @@ int action::dispatch::equals(tuple self, tuple other) {
 }
 
 tuple _newAction<dispatch>(int to, int opcode, cell $body, int gasNanos) inline {
-    return action::dispatch::New(to, opcode, $body, gasNanos);
+    return action::dispatch::create(to, opcode, $body, gasNanos);
 }
 
 ;; overloaded when you want to pass 0 outflowNanos

package/src/funC++/actions/event.fc

@@ -1,5 +1,4 @@
 #include "../baseInterface.fc";
-#include "../classlib.fc";
 #include "utils.fc";
 
 const int action::event::NAME = "event"u;
@@ -16,8 +15,8 @@ int _getEventSink() impure inline;
 ;; @info Events in LZ contracts are internal messages to an event sink
 ;; where the resulting transaction always reverts
 ;; @non-terminal
-tuple action::event::New(int topic, cell $body, cell $initialStorage) inline method_id {
-    cell $eventObj = cl::declare(
+cell action::event::New(int topic, cell $body, cell $initialStorage) inline method_id {
+    return cl::declare(
         action::event::NAME,
         unsafeTuple([
             [cl::t::uint256, topic],
@@ -25,7 +24,13 @@ tuple action::event::New(int topic, cell $body, cell $initialStorage) inline met
             [cl::t::objRef, $initialStorage]
         ])
     );
-    return unsafeTuple([action::event::NAME, $eventObj]);
+}
+
+tuple action::event::create(int topic, cell $body, cell $initialStorage) inline {
+    return unsafeTuple([
+        action::event::NAME, 
+        action::event::New(topic, $body, $initialStorage)
+    ]);
 }
 
 ;; returns true if equals
@@ -43,7 +48,7 @@ int action::event::equals(tuple self, tuple other) {
 
 ;; interface this function because it requires passing the 'getInitialStorage' from the baseHandler
 ;; tuple _newAction<event>(int topic, cell $body) impure inline {
-;;     return action::event::New(topic, $body, getInitialStorage());
+;;     return action::event::create(topic, $body, getInitialStorage());
 ;; }
 
 tuple _newAction<event>(int topic, cell $body) impure inline;

package/src/funC++/actions/payment.fc

@@ -1,5 +1,4 @@
 #include "utils.fc";
-#include "../stdlib.fc";
 
 const int action::payment::NAME = "payment"u;
 
@@ -11,7 +10,7 @@ const int action::payment::amount = 2;
 const int action::payment::outflowNanos = 3;
 
 ;; @non-terminal
-tuple action::payment::New(int toAddress, int amount, int outflowNanos) inline {
+tuple action::payment::create(int toAddress, int amount, int outflowNanos) inline {
     return unsafeTuple([action::payment::NAME, toAddress, amount, outflowNanos]);
 }
 
@@ -26,7 +25,7 @@ int action::payment::equals(tuple self, tuple other) {
 }
 
 tuple _newAction<payment>(int toAddress, int amount, int outflowNanos) inline {
-    return action::payment::New(toAddress, amount, outflowNanos);
+    return action::payment::create(toAddress, amount, outflowNanos);
 }
 
 (tuple, ()) ~pushAction<payment>(tuple actions, int toAddress, int amount, int outflowNanos) inline {

package/src/funC++/actions/sendJettons.fc

@@ -1,4 +1,3 @@
-#include "../stdlib.fc";
 #include "utils.fc";
 
 const int action::sendJettons::NAME = "sendJetton"u;
@@ -21,7 +20,7 @@ const int Jetton::OP::TRANSFER_NOTIFICATION = 0x7362d09c;
 const int Jetton::OP::TRANSFER = 0xf8a7ea5;
 
 ;; @terminal
-tuple action::sendJettons::New(int walletAddress, int toAddress, int amount, int responseAddress) inline {
+tuple action::sendJettons::create(int walletAddress, int toAddress, int amount, int responseAddress) inline {
     return unsafeTuple([action::sendJettons::NAME, walletAddress, toAddress, amount, responseAddress]);
 }
 
@@ -37,7 +36,7 @@ int action::sendJettons::equals(tuple self, tuple other) {
 }
 
 tuple _newAction<sendJettons>(int walletAddress, int toAddress, int amount, int responseAddress) inline {
-    return action::sendJettons::New(walletAddress, toAddress, amount, responseAddress);
+    return action::sendJettons::create(walletAddress, toAddress, amount, responseAddress);
 }
 
 (tuple, ()) ~pushAction<sendJettons>(

package/src/funC++/actions/utils.fc

@@ -1,5 +1,3 @@
-#include "../utils.fc";
-#include "../stdlib.fc";
 #include "../txnContext.fc";
 
 ;; Small file for now, but a placeholder for generic actions utility functions

package/src/funC++/baseInterface.fc

@@ -1,5 +1,3 @@
-#include "constants.fc";
-
 const int BaseInterface::event::AUTHENTICATED = "AUTHENTICATED"u;
 const int BaseInterface::event::INITIALIZED = "INITIALIZED"u;
 

package/src/funC++/classlib.fc

@@ -1,6 +1,4 @@
 #include "utils.fc";
-#include "constants.fc";
-#include "stdlib.fc";
 #include "stringlib.fc";
 
 ;; Types for storage abstraction
@@ -45,23 +43,6 @@ const int _HEADER_WIDTH = _BASIC_HEADER_WIDTH + _MAX_CLASS_FIELDS * _FIELD_INFO_
 const int FIELD_TYPE_IDX = 0;
 const int FIELD_VAL_IDX = 1;
 
-;;; ====================== Address functions ======================
-int basechainAddressStdToHashpart(slice full_address) inline {
-    (int wc, int hp) = parseStdAddress(full_address);
-    return hp;
-}
-
-slice hashpartToBasechainAddressStd(int hashpart) inline {
-    return begin_cell()
-        .store_uint(4, 3) ;; 0b100
-        .store_int(BASECHAIN, 8)
-        .store_uint(hashpart, 256)
-        .as_slice();
-}
-
-int getContractAddress() impure inline {
-    return my_address().preload_bits_offset(11, 256).preload_uint(256);
-}
 
 ;;; ====================== Class functions ======================
 ;; returns type width in bits
@@ -140,23 +121,6 @@ int cl::equalObjTypeShallow(cell $a, cell $b) {
     return true;
 }
 
-() setContractStorage(cell $obj) impure inline {
-    set_data($obj);
-}
-
-cell getContractStorage() impure inline method_id {
-    return get_data();
-}
-
-int computeContractAddress(cell $storage, cell code) impure inline {
-    return begin_cell()
-        .store_uint(6, 5)
-        .store_ref(code)
-        .store_ref($storage)
-        .end_cell()
-        .cell_hash();
-}
-
 int cl::typeof(cell $obj) inline method_id {
     if (cl::isNull($obj)) {
         return cl::NULL_CLASS_NAME;
@@ -625,7 +589,11 @@ cell cl::dict256::New() inline {
     if (dict.cell_is_empty()) {
         return (empty_cell(), false);
     }
-    return dict.udict_get_ref?(DICT256_KEYLEN, key);
+    (cell ret, int exists) = dict.udict_get_ref?(DICT256_KEYLEN, key);
+    ifnot (exists) {
+        return (empty_cell(), false);
+    }
+    return (ret, true);
 }
 
 cell cl::dict256::setRef(cell dict, int key, cell val) inline method_id {

package/src/funC++/constants.fc

@@ -1,6 +1,6 @@
 const int ERRORCODE_MASK = 0x7ff;
-const int CLASSLIB::ERROR::INVALID_FIELD_TYPE = 1058;
-const int CLASSLIB::ERROR::WRONG_ORDER_CONSTRUCTOR = 1059;
+const int CLASSLIB::ERROR::INVALID_FIELD_TYPE = 1059;
+const int CLASSLIB::ERROR::WRONG_ORDER_CONSTRUCTOR = 1060;
 
 const int MAX_U8    = 0xFF;
 const int MAX_U16   = 0xFFFF;

package/src/funC++/contractMain.fc

@@ -1,15 +1,9 @@
 ;;; ================================================================
 ;; The base main function for LayerZero Endpoint, UltraLightNode, and OApp
 ;;; ================================================================
-#include "baseInterface.fc";
-#include "classlib.fc";
-#include "constants.fc";
-#include "stdlib.fc";
-#include "stringlib.fc";
-#include "txnContext.fc";
-#include "actions/utils.fc";
-#include "abstract/contractMainAbstract.fc";
+
 #include "handlerCore.fc";
+#include "abstract/contractMainAbstract.fc";
 
 ;;; ===============================
 ;; Base main - low-level builtin context

package/src/funC++/dataStructures/AddressList.fc

@@ -44,7 +44,8 @@ int AddressList::isValid(cell addressList, int maxCount) {
     int count = 0;
     while (addressListSlice.slice_empty?() == false) {
         (int bits, int refs) = addressListSlice.slice_bits_refs();
-        if ((refs > 1) | ((refs == 1) & ((bits % 256) != 0))) {
+        ;; todo: more test coverage
+        if ((refs > 1) | ((bits % 256) != 0)) {
             return false;
         }
         repeat (bits / 256) {

package/src/funC++/dataStructures/DeterministicInsertionCircularQueue.fc

@@ -2,7 +2,6 @@
 ;; the DeterministicInsertionCircularQueue is a deterministic-gas circular buffer
 ;; that stores key-value pairs along with one piece of metadata (8-bits) per entry.
 #include "../utils.fc";
-#include "../stdlib.fc";
 
 const int DeterministicInsertionCircularQueue::statusBits = 8;
 const int DeterministicInsertionCircularQueue::keyBits = 64;

package/src/funC++/dataStructures/PipelinedOutOfOrder.fc

@@ -3,7 +3,6 @@
 ;; this data structure defines a bitmap that is used to track a stream of
 ;; commands that are executed out-of-order in a bounded-depth pipeline
 #include "../classlib.fc";
-#include "../utils.fc";
 
 const int POOO::NAME = "POOO"u;
 

package/src/funC++/handlerCore.fc

@@ -2,16 +2,12 @@
 ;; This file contains the utility functions for all handler functions that follow
 ;; LayerZero Labs handler convention.
 ;;; ==========================================
+#include "abstract/handlerAbstract.fc";
+
 #include "actions/utils.fc";
 
 #include "baseInterface.fc";
 
-#include "constants.fc";
-#include "stringlib.fc";
-#include "txnContext.fc";
-
-#include "abstract/handlerAbstract.fc";
-
 ;;; ===================REQUIRED VIRTUAL FUNCTIONS=======================
 ;; todo: split into permissions and utils?
 

package/src/funC++/stringlib.fc

@@ -1,5 +1,3 @@
-#include "constants.fc";
-#include "stdlib.fc";
 #include "utils.fc";
 
 ;;; ===============================STRING MANIPULATION FUNCTIONS===========================

package/src/funC++/testutils.fc

@@ -1,4 +1,3 @@
-#include "stdlib.fc";
 #include "utils.fc";
 
 cell _garbageFilledCell() {

package/src/funC++/txnContext.fc

@@ -1,4 +1,4 @@
-#include "classlib.fc";
+#include "utils.fc";
 
 global tuple txnContext;
 

package/src/funC++/utils.fc

@@ -181,3 +181,38 @@ int _gasToNanoton(int gas) inline {
         deleteDueLimit
     );
 }
+
+;;; ====================== Address functions ======================
+int basechainAddressStdToHashpart(slice full_address) inline {
+    (int wc, int hp) = parseStdAddress(full_address);
+    return hp;
+}
+
+slice hashpartToBasechainAddressStd(int hashpart) inline {
+    return begin_cell()
+        .store_uint(4, 3) ;; 0b100
+        .store_int(BASECHAIN, 8)
+        .store_uint(hashpart, 256)
+        .as_slice();
+}
+
+int getContractAddress() impure inline {
+    return my_address().preload_bits_offset(11, 256).preload_uint(256);
+}
+
+() setContractStorage(cell $obj) impure inline {
+    set_data($obj);
+}
+
+cell getContractStorage() impure inline method_id {
+    return get_data();
+}
+
+int computeContractAddress(cell $storage, cell code) impure inline {
+    return begin_cell()
+        .store_uint(6, 5)
+        .store_ref(code)
+        .store_ref($storage)
+        .end_cell()
+        .cell_hash();
+}

package/src/protocol/channel/callbackOpcodes.fc

@@ -0,0 +1,10 @@
+;; Send flow
+const int Layerzero::OP::CHANNEL_SEND_CALLBACK = "Layerzero::OP::CHANNEL_SEND_CALLBACK"c;
+
+;; Receive flow
+const int Layerzero::OP::LZ_RECEIVE_PREPARE = "Layerzero::OP::LZ_RECEIVE_PREPARE"c;
+const int Layerzero::OP::LZ_RECEIVE_EXECUTE = "Layerzero::OP::LZ_RECEIVE_EXECUTE"c;
+
+;; Receive flow management
+const int Layerzero::OP::BURN_CALLBACK = "Layerzero::OP::BURN_CALLBACK"c;
+const int Layerzero::OP::NILIFY_CALLBACK = "Layerzero::OP::NILIFY_CALLBACK"c;