@layerzerolabs/layerzero-v2-ton 3.0.28 → 3.0.30-ton.0

package/src/workers/dvn/main.fc

@@ -24,6 +24,8 @@ tuple _executeOpcode(int op, cell $md) impure inline {
         return setProxy($md);
     } elseif (op == Worker::OP::CLAIM_TON) {
         return claimTon($md);
+    } elseif (op == Worker::OP::CLAIM_TON_FROM_PROXY) {
+        return claimTonFromProxy($md);
     } elseif (op == Dvn::OP::SET_PROXY_ADMINS) {
         return setProxyAdmins($md);
     } elseif (op == Worker::OP::CALL_VIA_PROXY) {

package/src/workers/executor/handler.fc

@@ -106,8 +106,12 @@ tuple setAdmins(cell $addressList) impure inline {
     return _setAdmins(emptyActions(), $addressList);
 }
 
-tuple claimTon(cell $coinsAmount) impure inline {
-    return _claimTon(emptyActions(), $coinsAmount);
+tuple claimTon(cell $claimTon) impure inline {
+    return _claimTon(emptyActions(), $claimTon);
+}
+
+tuple claimTonFromProxy(cell $claimTon) impure inline {
+    return _claimTonFromProxy(emptyActions(), $claimTon);
 }
 
 tuple setProxy(cell $setAddress) impure inline {

package/src/workers/executor/main.fc

@@ -14,6 +14,8 @@ tuple _executeOpcode(int op, cell $md) impure inline {
         return setAdmins($md);
     } elseif (op == Worker::OP::CLAIM_TON) {
         return claimTon($md);
+    } elseif (op == Worker::OP::CLAIM_TON_FROM_PROXY) {
+        return claimTonFromProxy($md);
     } elseif (op == Worker::OP::CALL_VIA_PROXY) {
         return callViaProxy($md);
     } elseif (op == Worker::OP::SET_PROXY) {

package/src/workers/msgdata/ClaimTon.fc

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

package/src/workers/proxy/handler.fc

@@ -38,8 +38,8 @@ tuple setAdmins(cell $addressList) impure inline {
     return _setAdmins(emptyActions(), $addressList);
 }
 
-tuple claimTon(cell $coinsAmount) impure inline {
-    return _claimTon(emptyActions(), $coinsAmount);
+tuple claimTon(cell $claimTon) impure inline {
+    return _claimTon(emptyActions(), $claimTon);
 }
 
 tuple callContract(cell $executeParams) impure inline {

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