@layerzerolabs/layerzero-v2-ton 3.0.28 → 3.0.29

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @layerzerolabs/layerzero-v2-ton
 
+## 3.0.29
+
+### Patch Changes
+
+- 6d435ec: fix sdk
+
 ## 3.0.28
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/layerzero-v2-ton",
-  "version": "3.0.28",
+  "version": "3.0.29",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -36,6 +36,7 @@
     "src/jettons/zro/*.fc",
     "tests/testMain.fc",
     "tests/baseContractTest.fc",
+    "tests/baseSerdeTest.fc",
     "src/multisig/bocs/MultiSig.compiled.json",
     "src/multisig/bocs/MultiSigOrder.compiled.json"
   ],

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, "");
+}