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

package/src/protocol/msglibs/BytesDecoder.fc

@@ -0,0 +1,135 @@
+#include "../../classes/lz/Packet.fc";
+
+const int BytesDecoder::ERROR::invalidOptionSize = 1121;
+const int BytesDecoder::ERROR::malformedOptions = 1122;
+const int BytesDecoder::ERROR::malformedArray = 1123;
+
+;; n_bytes should be <= 32
+(slice, int) BytesDecoder::loadBytes(slice decoder, int nBytes) inline method_id {
+    int sliceBits = decoder.slice_bits();
+    if ((decoder.slice_refs() > 1) | (sliceBits % 8 != 0)) {
+        throw(BytesDecoder::ERROR::malformedOptions);
+    }
+    int sliceBytes = sliceBits / 8;
+    if (sliceBytes >= nBytes) {
+        return decoder.load_uint(nBytes * 8);
+    } else {
+        (decoder, int valueHeader) = decoder.load_uint(sliceBits);
+        int remainingBytes = nBytes - sliceBytes;
+        (slice next_data, int valueTail) = BytesDecoder::loadBytes(
+            decoder.preload_first_ref().begin_parse(),
+            remainingBytes
+        );
+        slice fullData = begin_cell()
+            .store_uint(valueHeader, sliceBits)
+            .store_uint(valueTail, remainingBytes * 8)
+            .as_slice();
+        return (next_data, fullData.preload_uint(nBytes * 8));
+    }
+}
+
+;; byte- and cell- align the data
+cell BytesDecoder::compactRemainder(slice data) impure inline {
+    int moduloBits = data.slice_bits(); ;; "misaligned" portion
+    throw_unless(
+        BytesDecoder::ERROR::malformedArray,
+        (data.slice_refs() <= 1) & ((moduloBits % 8) == 0)
+    );
+
+    if (moduloBits == 0) {
+        return empty_cell();
+    }
+
+    if (data.slice_refs() == 0) {
+        return begin_cell().store_slice(data).end_cell();
+    }
+
+    tuple retData = empty_tuple();
+
+    while (data.slice_refs() > 0) {
+        slice nextData = data.preload_first_ref().begin_parse();
+        int sliceBits = nextData.slice_bits();
+        int remainingBits = ((sliceBits + moduloBits) <= 1016) ? sliceBits : (1016 - moduloBits);
+        if (nextData.slice_refs() > 0) {
+            throw_if(BytesDecoder::ERROR::malformedArray, nextData.slice_bits() != 1016);
+        }
+        throw_unless(
+            BytesDecoder::ERROR::malformedArray,
+            (nextData.slice_refs() <= 1) & (sliceBits > 0) & (sliceBits % 8 == 0)
+        );
+        retData~tpush(
+            begin_cell()
+                .store_slice(data.scutlast(moduloBits, 0))
+                .store_slice(nextData.scutfirst(remainingBits, 0))
+        );
+        if ((nextData.slice_refs() == 0) & ((sliceBits - remainingBits) > 0)) {
+            retData~tpush(
+                begin_cell().store_slice(nextData.sskipfirst(remainingBits, 0))
+            );
+        }
+        data = nextData;
+    }
+    int idx = retData.tlen() - 1;
+    builder ret = retData.at(idx);
+    while (idx > 0) {
+        idx -= 1;
+        ret = retData.at(idx).store_ref(ret.end_cell());
+    }
+    return ret.end_cell();
+}
+
+;; returns (optionType, option, optionsTail)
+(int, cell, cell) BytesDecoder::nextOption(cell options) inline {
+    slice parsingOptions = options.begin_parse();
+    (parsingOptions, int executorId) = BytesDecoder::loadBytes(parsingOptions, 1);
+    (parsingOptions, int optionSizeInBytes) = BytesDecoder::loadBytes(parsingOptions, 2);
+    (parsingOptions, int optionType) = BytesDecoder::loadBytes(parsingOptions, 1);
+    (parsingOptions, int option) = BytesDecoder::loadBytes(parsingOptions, optionSizeInBytes);
+    return (
+        optionType, 
+        begin_cell().store_uint(option, optionSizeInBytes * 8).end_cell(),
+        begin_cell().store_slice(parsingOptions).end_cell() ;; should retain the ref
+    );
+}
+
+;; (gas, value)
+(int, int) BytesDecoder::decode<LzReceiveOption>(cell option) inline {
+    slice optionSlice = option.begin_parse();
+    int optionSizeInBytes = optionSlice.slice_bits() / 8;
+    if ((optionSizeInBytes != 16) & (optionSizeInBytes != 32)) {
+        throw(BytesDecoder::ERROR::invalidOptionSize);
+    }
+    if (optionSizeInBytes == 256 / 8) {
+        return (optionSlice~load_uint128(), optionSlice~load_uint128());
+    }
+    return (optionSlice~load_uint128(), 0);
+}
+
+;; (amount, receiver)
+(int, int) BytesDecoder::decode<NativeDropOption>(cell option) inline {
+    slice parsingOption = option.begin_parse();
+    int optionBytes = parsingOption.slice_bits() * 8;
+    throw_unless(BytesDecoder::ERROR::invalidOptionSize, optionBytes == (32 + 16));
+    return (
+        parsingOption~load_uint128(), ;; amount
+        parsingOption~load_uint256() ;; receiver
+    );
+}
+
+;; returns lz::Packet
+cell BytesDecoder::decode<PacketV1>(cell encodedPacket) inline method_id {
+    slice parsingPacket = encodedPacket.begin_parse();
+    (parsingPacket, int packetVersion) = BytesDecoder::loadBytes(parsingPacket, 1);
+    (parsingPacket, int nonce) = BytesDecoder::loadBytes(parsingPacket, 8);
+    (parsingPacket, int srcEid) = BytesDecoder::loadBytes(parsingPacket, 4);
+    (parsingPacket, int srcOApp) = BytesDecoder::loadBytes(parsingPacket, 32);
+    (parsingPacket, int dstEid) = BytesDecoder::loadBytes(parsingPacket, 4);
+    (parsingPacket, int dstOApp) = BytesDecoder::loadBytes(parsingPacket, 32);
+    (parsingPacket, int guid) = BytesDecoder::loadBytes(parsingPacket, 32);
+
+    return lz::Packet::New(
+        lz::Path::New(srcEid, srcOApp, dstEid, dstOApp),
+        BytesDecoder::compactRemainder(parsingPacket),
+        nonce
+    ).cl::set(lz::Packet::guid, guid);
+}

package/src/protocol/msglibs/BytesEncoder.fc

@@ -0,0 +1,150 @@
+#include "../../classes/lz/Path.fc";
+#include "../../classes/lz/Packet.fc";
+
+const int BytesEncoder::ERROR::malformed_subtree = 1217;
+const int BytesEncoder::ERROR::malformed_data = 1218;
+;; these are calculated relative to their position in the BytesEncoder::build<PacketV1> function
+const int PacketV1::nonceOffsetBytes = 1;
+const int PacketV1::nonceBytes = 8;
+const int PacketV1::guidOffsetBytes = 81;
+const int PacketV1::guidBytes = 32;
+
+;; keeps a stack of builders on a tuple
+tuple BytesEncoder::New() inline {
+    return unsafeTuple([begin_cell()]);
+}
+
+;; appends a slice to the bytes encoder
+tuple BytesEncoder::feed(tuple self, slice data) impure inline {
+    while (~ data.is_null()) {
+        ;; verifies it is a linked list and only has one reference
+        throw_if(BytesEncoder::ERROR::malformed_subtree,data.slice_refs() > 1);
+
+        ;; grabs the last builder on the tuple stack
+        int curBuilderIdx = self.tlen() - 1;
+        builder curBuilder = self.at(curBuilderIdx);
+
+        ;; calculates the size in bytes of the current builder and the data
+        int curBuilderBytes = curBuilder.builder_bits() / 8;
+        int dataWidthBytes = data.slice_bits() / 8;
+        int fillsCurrentBuilder = (curBuilderBytes + dataWidthBytes) == 127;
+
+        ;; if there is a partail byte at the end the check below makes it throw if it is
+        throw_if(BytesEncoder::ERROR::malformed_data, (data.slice_bits() % 8) != 0);
+
+        ;; if the current builder + the size of data are greater
+        ;; than 127 bytes, we need to break it up into multiple builders
+        if ((curBuilderBytes + dataWidthBytes) > 127) {
+            ;; calculate the first X bytes to add to the current builder to fill it
+            int partialDataWidth = 127 - curBuilderBytes;
+
+            ;; the remaining bytes length inside data after we move the reference to
+            ;; where the partialDataWidth left off
+            dataWidthBytes = dataWidthBytes - partialDataWidth;
+
+            ;; store the leading X bytes and saves to the tuple stack
+            self = self.tset(
+                curBuilderIdx,
+                curBuilder
+                    .store_slice(data.preload_bits(partialDataWidth * 8))
+            );
+
+            ;; moves the pointer
+            data = data.skip_bits(partialDataWidth * 8);
+            curBuilderIdx += 1;
+
+            ;; adds a new builder to the tuple stack
+            curBuilder = begin_cell();
+            self~tpush(curBuilder);
+        }
+        ;; If we entered the previous if statement, we have a fresh builder and less than
+        ;; 127 bytes remaining at this slice in the data linked list. This will take the remaining
+        ;; data inside the data slice and store in the builder.
+        ;; If we didn't enter the previous if statement it will append the remaining bytes
+        ;; of the data slice to the builder.
+        ;; THhen updates the tuple stack with the updated writes
+        self = self.tset(curBuilderIdx, curBuilder.store_slice(data.sdskipfirst(0)));
+
+        ;; if data linked list has more data extend the data stack and move the pointer of
+        ;; data to the next item in the list.
+        ifnot (data.slice_refs_empty?()) {
+
+            ;; if the current builder is full add a new builer on the tuple stack
+            if (fillsCurrentBuilder) {
+                self = self.tpush(begin_cell());
+            }
+            ;; move the pointer
+            data = data.preload_first_ref().begin_parse();
+        } else {
+            ;; cue to end the while loop, the data has been stored in the bytes encoded tuple stack
+            data = null();
+        }
+    }
+
+    return self;
+}
+
+;; builds from the bottom up (of the stack) since data is built from the leaf node of a tree
+cell BytesEncoder::serialize(tuple self) impure inline {
+    int idx = self.tlen() - 1;
+    ;; if we're at the head
+    if (idx == 0) {
+        return self.at(idx).end_cell();
+    }
+    ;; if second to last
+    if (idx == 1) {
+        return self.at(0).store_ref(self.at(1).end_cell()).end_cell();
+    }
+    builder last = self.at(idx);
+    builder secondLast = self.at(idx - 1);
+    while (idx > 1) {
+        idx -= 1;
+        last = secondLast.store_ref(last.end_cell());
+        secondLast = self.at(idx);
+    }
+    return secondLast.store_ref(last.end_cell()).end_cell();
+}
+
+tuple BytesEncoder::feed<uint8>(tuple self, int data) inline {
+    return self.BytesEncoder::feed(begin_cell().store_uint8(data).as_slice());
+}
+
+tuple BytesEncoder::feed<uint16>(tuple self, int data) inline {
+    return self.BytesEncoder::feed(begin_cell().store_uint16(data).as_slice());
+}
+
+tuple BytesEncoder::feed<uint32>(tuple self, int data) inline {
+    return self.BytesEncoder::feed(begin_cell().store_uint32(data).as_slice());
+}
+
+tuple BytesEncoder::feed<uint64>(tuple self, int data) inline {
+    return self.BytesEncoder::feed(begin_cell().store_uint64(data).as_slice());
+}
+
+tuple BytesEncoder::feed<coins>(tuple self, int data) inline {
+    return self.BytesEncoder::feed(begin_cell().store_uint128(data).as_slice());
+}
+
+tuple BytesEncoder::feed<uint256>(tuple self, int data) inline {
+    return self.BytesEncoder::feed(begin_cell().store_uint256(data).as_slice());
+}
+
+tuple BytesEncoder::feed<cellRef>(tuple self, cell data) inline {
+    return self.BytesEncoder::feed(data.begin_parse());
+}
+
+tuple BytesEncoder::build<PacketV1>(cell $packet) inline {
+    cell $path = $packet.cl::get<objRef>(lz::Packet::path);
+    return unsafeTuple([
+        begin_cell()    ;; 113 bytes of the 127
+            .store_uint8(1) ;; packetVersion uint8
+            .store_uint64($packet.cl::get<uint64>(lz::Packet::nonce)) ;; nonce uint64
+            .store_uint32($path.cl::get<uint32>(lz::Path::srcEid)) ;; srcEid uint32
+            .store_uint256($path.cl::get<uint256>(lz::Path::srcOApp)) ;; sender bytes32
+            .store_uint32($path.cl::get<uint32>(lz::Path::dstEid)) ;; dstEid uint32
+            .store_uint256($path.cl::get<uint256>(lz::Path::dstOApp))  ;; receiver bytes32
+            .store_uint256($packet.cl::get<uint256>(lz::Packet::guid))  ;; guid bytes32
+    ]).BytesEncoder::feed<cellRef>(
+        $packet.cl::get<cellRef>(lz::Packet::message) ;; message []bytes
+    );
+}

package/src/protocol/msglibs/interface.fc

@@ -0,0 +1,16 @@
+;; All msglibs must have the path in their storage as field 1
+const int MsglibConnection::PathFieldIdx = 1;
+
+;; All msglibs are required to have a connection and a manager
+const int MsglibManager::OP::GET_MSGLIB_INFO = "MsglibManager::OP::GET_MSGLIB_INFO"c;
+
+const int MsglibManager::OP::DEPLOY_CONNECTION = "MsglibManager::OP::DEPLOY_CONNECTION"c;
+
+const int Msglib::OP::RETURN_QUOTE = "Msglib::OP::RETURN_QUOTE"c;
+
+const int MsglibConnection::OP::MSGLIB_CONNECTION_QUOTE = "MsglibConnection::OP::MSGLIB_CONNECTION_QUOTE"c;
+const int MsglibConnection::OP::MSGLIB_CONNECTION_SEND = "MsglibConnection::OP::MSGLIB_CONNECTION_SEND"c;
+const int MsglibConnection::OP::MSGLIB_CONNECTION_COMMIT_PACKET_CALLBACK = "MsglibConnection::OP::MSGLIB_CONNECTION_COMMIT_PACKET_CALLBACK"c;
+const int MsglibConnection::OP::MSGLIB_CONNECTION_SYNC_CHANNEL_STATE = "MsglibConnection::OP::MSGLIB_CONNECTION_SYNC_CHANNEL_STATE"c;
+
+const int Msglib::ERROR::onlyChannel = 288;

package/src/protocol/msglibs/simpleMsglib/smlConnection/handler.fc

@@ -0,0 +1,125 @@
+#include "../../../core/abstract/protocolHandler.fc";
+
+#include "../../../../classes/msgdata/ExtendedMd.fc";
+#include "../../../../classes/msgdata/InitSmlConnection.fc";
+#include "../../../../classes/msgdata/MdAddress.fc";
+#include "../../../../classes/msgdata/MdObj.fc";
+
+
+#include "../../../endpoint/interface.fc";
+#include "../../interface.fc";
+#include "../smlManager/interface.fc";
+#include "interface.fc";
+#include "../../../../funC++/classlib.fc";
+
+;;; ================HELPER FUNCTIONS========================
+
+int getChannelAddress() impure inline {
+    return getContractStorage().cl::get<address>(SmlConnection::channelAddress);
+}
+
+() assertChannel() impure inline {
+    throw_unless(
+        Msglib::ERROR::onlyChannel,
+        getCaller() == getChannelAddress()
+    );
+}
+
+;;; ================INTERFACE FUNCTIONS=====================
+
+(cell, tuple) _initialize(cell $initSmlConnection) impure inline {
+    (cell $storage, tuple actions) = preamble();
+    int channelAddress = $initSmlConnection
+        .cl::get<address>(md::InitSmlConnection::channelAddress);
+    return (
+        $storage.cl::set(SmlConnection::channelAddress, channelAddress),
+        actions
+    );
+}
+
+int _getEventSink() inline {
+    return getContractAddress();
+}
+
+;;; ================PERMISSION FUNCTIONS=====================
+
+() _checkPermissions(int op, cell $md) impure inline method_id {
+    if (op == MsglibConnection::OP::MSGLIB_CONNECTION_SEND) {
+        return assertChannel();
+    } elseif (op == MsglibConnection::OP::MSGLIB_CONNECTION_COMMIT_PACKET_CALLBACK) {
+        return assertChannel();
+    } elseif (op == SmlConnection::OP::SML_CONNECTION_COMMIT_PACKET) {
+        return assertOwner();
+    } elseif (op == MsglibConnection::OP::MSGLIB_CONNECTION_SYNC_CHANNEL_STATE) {
+        return assertChannel();
+    } else {
+        ;; we must put a check for all opcodes to make sure we don't
+        ;; mistakenly miss an opp code's permissions
+        throw(BaseInterface::ERROR::invalidOpcode);
+    }
+}
+
+;;; =================HANDLERS================================
+
+;; @in channel/handler.fc/send
+;; @in_md LzSend
+;; @out smlManager/handler.fc/msglibSend
+;; @out_md ExtendedMd(LzSend, initialStorage, channelAddress)
+tuple msglibConnectionSend(cell $lzSend) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    actions~pushAction<call>(
+        getOwner(), ;; smlManager
+        SmlManager::OP::SML_MANAGER_SEND,
+        md::ExtendedMd::New(
+            $lzSend,
+            getInitialStorage(),
+            $storage.cl::get<address>(SmlConnection::channelAddress)
+        )
+    );
+
+    return actions;
+}
+
+;; @in smlManager/handler.fc/smlManagerCommitPacket
+;; @in_md msglibCommitPacket
+;; @out endpoint/handler.fc/commitPacket
+;; @out_md MdObj { packet, initialStorage }
+tuple smlConnectionCommitPacket(cell $mdAddress) impure inline method_id {
+    (_, tuple actions) = preamble();
+
+    actions~pushAction<call>(
+        $mdAddress.cl::get<address>(md::MdAddress::address),
+        Endpoint::OP::ENDPOINT_COMMIT_PACKET,
+        $mdAddress.cl::get<objRef>(md::MdAddress::md)
+    );
+
+    return actions;
+}
+
+;; @in channel/handler.fc/commitPacket
+;; @in_md msglibCommitPacketCallback
+;; @out smlManager/handler.fc/smlManagerCommitPacketCallback
+tuple msglibConnectionCommitPacketCallback(cell $mdObj) impure inline method_id {
+    (_, tuple actions) = preamble();
+
+    actions~pushAction<call>(
+        getOwner(),
+        SmlManager::OP::SML_MANAGER_COMMIT_PACKET_CALLBACK,
+        $mdObj
+    );
+
+    return actions;
+}
+
+tuple syncChannelState(cell $mdObj) impure inline method_id {
+    (_, tuple actions) = preamble();
+
+    actions~pushAction<call>(
+        getChannelAddress(),
+        MsglibConnection::OP::MSGLIB_CONNECTION_SYNC_CHANNEL_STATE,
+        $mdObj
+    );
+
+    return actions;
+}

package/src/protocol/msglibs/simpleMsglib/smlConnection/interface.fc

@@ -0,0 +1,3 @@
+#include "storage.fc";
+
+const int SmlConnection::OP::SML_CONNECTION_COMMIT_PACKET = "SmlConnection::OP::SML_CONNECTION_COMMIT_PACKET"c;

package/src/protocol/msglibs/simpleMsglib/smlConnection/main.fc

@@ -0,0 +1,19 @@
+#include "../../../core/abstract/protocolMain.fc";
+#include "../../interface.fc";
+
+#include "handler.fc";
+#include "interface.fc";
+
+tuple _executeOpcode(int op, cell $md) impure inline {
+    if (op == MsglibConnection::OP::MSGLIB_CONNECTION_SEND) {
+        return msglibConnectionSend($md);
+    } elseif (op == SmlConnection::OP::SML_CONNECTION_COMMIT_PACKET) {
+        return smlConnectionCommitPacket($md);
+    } elseif (op == MsglibConnection::OP::MSGLIB_CONNECTION_COMMIT_PACKET_CALLBACK) {
+        return msglibConnectionCommitPacketCallback($md);
+    } elseif (op == MsglibConnection::OP::MSGLIB_CONNECTION_SYNC_CHANNEL_STATE) {
+        return syncChannelState($md);
+    }
+    throw(BaseInterface::ERROR::invalidOpcode);
+    return empty_tuple();
+}

package/src/protocol/msglibs/simpleMsglib/smlConnection/storage.fc

@@ -0,0 +1,20 @@
+#include "../../../core/baseStorage.fc";
+#include "../../../../funC++/classlib.fc";
+
+const int SmlConnection::NAME = "smlConn"u;
+
+const int SmlConnection::baseStorage = 0;
+const int SmlConnection::path = 1;
+const int SmlConnection::channelAddress = 2;
+
+;; @owner LayerZero admin EOA
+cell SmlConnection::New(int owner, cell $path) method_id {
+    return cl::declare(
+        SmlConnection::NAME,
+        unsafeTuple([
+            [cl::t::objRef, BaseStorage::New(owner)], ;; SmlConnection::baseStorage
+            [cl::t::objRef, $path], ;; SmlConnection::path
+            [cl::t::address, NULLADDRESS] ;; SmlConnection::channelAddress
+        ])
+    );
+}