@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.29

package/tests/baseSerdeTest.fc

@@ -0,0 +1,117 @@
+#include "./testMain.fc";
+#include "../src/funC++/classlib.fc";
+#include "../src/funC++/stringlib.fc";
+
+cell baseTest::prepare(tuple args) impure {
+    return cl::nullObject();
+}
+
+;;; ===============================TEST HANDLERS===============================
+
+;; int TEST_SUCCESS or TEST_FAILURE, slice (optional) error_message
+(int, slice) test::build::equal(cell $newObject, cell $buildObject) impure {
+    if ($newObject.cl::hash() != $buildObject.cl::hash()) {
+        ~strdump("::new output does not match ::build");
+        int wrongField = compareObjectFields($newObject, $buildObject);
+        if (wrongField == INVALID_CLASS_MEMBER) {
+            return (
+                TEST_FAILED,
+                "Object and expected object not of the same type"
+            );
+        } elseif (wrongField != -1) {
+            return (
+                TEST_FAILED,
+                "malformed field ".str::concatInt(wrongField)
+            );
+        }
+    }
+    return (TEST_SUCCESS, "");
+}
+
+(int, slice) test::getBool::equal(cell $obj, (cell -> int) getter, int field) impure {
+    int expected = $obj.cl::get<bool>(field);
+    int actual = getter($obj);
+    if (expected != actual) {
+        return (TEST_FAILED, "expected: ".str::concatInt(expected).str::concat(" != actual: ").str::concatInt(actual));
+    }
+    return (TEST_SUCCESS, "");
+}
+
+(int, slice) test::getData::equal(cell $obj, (cell -> int) getter, int field) impure {
+    int width = _getTypeWidth(typeofField($obj, field));
+    int expected = $obj.cl::get<uint>(field, width);
+    int actual = getter($obj);
+    if (expected != actual) {
+        return (TEST_FAILED, "expected: ".str::concatInt(expected).str::concat(" != actual: ").str::concatInt(actual));
+    }
+    return (TEST_SUCCESS, "");
+}
+
+(int, slice) test::getRef::equal(cell $obj, (cell -> cell) getter, int fieldId) impure {
+    cell expected = $obj.cl::get<cellRef>(fieldId);
+    cell actual = getter($obj);
+    if (expected.cell_hash() != actual.cell_hash()) {
+        return (TEST_FAILED, "expected != actual");
+    }
+    return (TEST_SUCCESS, "");
+}
+
+(int, slice) test::multiget::equal(cell $object, tuple keys, tuple expected) impure {
+    tuple actual = empty_tuple();
+    int idx = 0;
+
+    while (idx < keys.tlen()) {
+        int key = keys.int_at(idx);
+        int typeOfKey = typeofField($object, key);
+        int fieldBits = _getTypeWidth(typeOfKey);
+        if (typeOfKey == cl::t::bool) {
+            actual~tpush($object.cl::get<bool>(key));
+        } elseif (typeOfKey <= cl::t::uint256) {
+            actual~tpush($object.cl::get<uint>(key, fieldBits));
+        } else {
+            actual~tpush($object.cl::get<cellRef>(key));
+        }
+        idx += 1;
+    }
+
+    if (expected.tlen() != actual.tlen()) {
+        return (TEST_FAILED, "expected length: ".str::concatInt(expected.tlen()).str::concat(" != actual length: ").str::concatInt(actual.tlen()));
+    }
+
+    int idx = 0;
+    while (idx < expected.tlen()) {
+        if (expected.at(idx).is_cell() & actual.at(idx).is_cell()) {
+            if (expected.at(idx).cell_hash() != actual.at(idx).cell_hash()) {
+                return (TEST_FAILED, "expected cell != actual cell");
+            }
+        } elseif (expected.at(idx).is_int() & actual.at(idx).is_int()) {
+            if (expected.at(idx) != actual.at(idx)) {
+                return (TEST_FAILED, "expected: ".str::concatInt(expected.at(idx)).str::concat(" != actual: ").str::concatInt(actual.at(idx)));
+            }
+        } else {
+            return (TEST_FAILED, "type mismatch at idx ".str::concatInt(idx));
+        }
+        idx += 1;
+    }
+
+    return (TEST_SUCCESS, "");
+}
+
+(int, slice) test::set::equal(cell $expected, cell $actual) impure {
+    if ($expected.cl::hash() != $actual.cl::hash()) {
+        ~strdump("::set output does not match ::get");
+        int wrongField = compareObjectFields($expected, $actual);
+        if (wrongField == INVALID_CLASS_MEMBER) {
+            return (
+                TEST_FAILED,
+                "Object and expected object not of the same type"
+            );
+        } elseif (wrongField != -1) {
+            return (
+                TEST_FAILED,
+                "malformed field ".str::concatInt(wrongField)
+            );
+        }
+    }
+    return (TEST_SUCCESS, "");
+}

package/tests/testMain.fc

@@ -121,7 +121,7 @@ tuple _get_c7() impure asm "c7 PUSH";
     }
 }
 
-(int, slice) test::shouldBeTrue(int condition) {
+(int, slice) test::shouldBeTrue(int condition) impure {
     ifnot (condition) {
         return (TEST_FAILED, "test::shouldBeTrue");
     } else {
@@ -129,6 +129,6 @@ tuple _get_c7() impure asm "c7 PUSH";
     }
 }
 
-(int, slice) test::shouldBeFalse(int condition) {
+(int, slice) test::shouldBeFalse(int condition) impure {
     return test::shouldBeTrue(condition == false);
 }

package/src/classes/msgdata/Amount.fc

@@ -1,16 +0,0 @@
-#include "../../funC++/classlib.fc";
-
-;; required storage name
-const int md::Amount::NAME = "Amount"u;
-
-;; field names
-const int md::Amount::amount = 0;
-
-cell md::Amount::New(int amount) inline method_id {
-    return cl::declare(
-        md::Amount::NAME,
-        unsafeTuple([
-            [cl::t::coins, amount] ;; md::Amount::amount
-        ])
-    );
-}

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

@@ -1,27 +0,0 @@
-#include "utils.fc";
-
-const int action::destroy::NAME = "destroy"u;
-
-const int action::destroy::to = 1;
-const int action::destroy::opcode = 2;
-const int action::destroy::md = 3;
-
-;; @terminal
-tuple action::destroy::create(int to, int opcode, cell $md) inline {
-    return unsafeTuple([action::destroy::NAME, to, opcode, $md]);
-}
-
-;; returns true if equals
-int action::destroy::equals(tuple self, tuple other) {
-    int equalMdField = compareObjectFields(
-        self.cell_at(action::destroy::md),
-        other.cell_at(action::destroy::md)
-    );
-
-    return (
-        (self.int_at(0) == other.int_at(0)) ;; NAME
-        & (self.int_at(action::destroy::to) == other.int_at(action::destroy::to))
-        & (self.int_at(action::destroy::opcode) == other.int_at(action::destroy::opcode))
-        & (equalMdField == -1)
-    );
-}