@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.29

package/src/classes/lz/Packet.fc

@@ -31,66 +31,58 @@ cell lz::Packet::New(cell $path, cell message, int nonce) inline method_id {
     );
 }
 
-cell lz::Packet::nonceless(cell $path, cell message) inline method_id {
-    return lz::Packet::New($path, message, 0);
+const int lz::Packet::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 4);
+const int lz::Packet::_headerFillerBits = _HEADER_WIDTH - lz::Packet::_headerInfoBits;
+const int lz::Packet::_headerInfo = 417359019239977417716476838698419835;
+
+;; this function is unused by the protocol but will be used by OApps
+cell lz::Packet::build(cell $path, cell message, int nonce) inline method_id {
+    return begin_cell()
+        .store_uint(lz::Packet::_headerInfo, lz::Packet::_headerInfoBits) ;; header info
+        .store_ones(lz::Packet::_headerFillerBits)                        ;; header filler
+        .store_ref($path)                                                  ;; path
+        .store_ref(message)                                                ;; message
+        .store_uint64(nonce)                                               ;; nonce
+        .store_uint256(0)                                                  ;; guid (default = 0)
+        .end_cell();
 }
 
-;; assumes that the message is a valid single-linked list
-int lz::Packet::_messageBytes(cell $self) impure inline {
-    slice messageSlice = $self.cl::get<cellRef>(lz::Packet::message).begin_parse();
-    (int sliceBits, int sliceRefs) = messageSlice.slice_bits_refs();
-    int messageBytes = sliceBits / 8;
-    while (sliceRefs > 0) {
-        messageSlice = messageSlice.preload_first_ref().begin_parse();
-        (sliceBits, sliceRefs) = messageSlice.slice_bits_refs();
-        messageBytes += (sliceBits / 8);
-    }
-    return messageBytes;
+;; this function is unused by the protocol but will be used by OApps
+cell lz::Packet::nonceless(cell $path, cell message) inline method_id {
+    return lz::Packet::build($path, message, 0);
 }
 
-() lz::Packet::_assertValidLinkedList(cell head, int maxLen) impure inline {
-    slice messageSlice = head.begin_parse();
-    repeat (maxLen) {
-        (int sliceBits, int sliceRefs) = messageSlice.slice_bits_refs();
-        if (sliceRefs == 0) {
-            throw_if(lz::Packet::ERROR::INVALID_MESSAGE, sliceBits % 8 != 0);
-            return ();
-        } else {
-            throw_if(
-                lz::Packet::ERROR::INVALID_MESSAGE,
-                (sliceRefs != 1) | (sliceBits != MAX_CELL_WHOLE_BYTE_BITS)
-            );
-        }
-        messageSlice = messageSlice.preload_first_ref().begin_parse();
-    }
-    throw(lz::Packet::ERROR::INVALID_MESSAGE);
+;; ====================== Object Accessors =====================
+
+const int lz::Packet::_nonceOffset = _HEADER_WIDTH;
+const int lz::Packet::_guidOffset = lz::Packet::_nonceOffset + 64;
+
+cell lz::Packet::getPath(cell $self) impure inline {
+    return $self.cellPreloadRefAt(0);
 }
 
-() lz::Packet::assertValidSendMessage(cell $self) impure inline {
-    lz::Packet::_assertValidLinkedList(
-        $self.cl::get<cellRef>(lz::Packet::message),
-        lz::Packet::MAX_SEND_MESSAGE_CELLS
-    );
+;; this function is unused by the protocol but will be used by OApps
+cell lz::Packet::getMessage(cell $self) impure inline {
+    return $self.cellPreloadRefAt(1);
 }
 
-() lz::Packet::assertValidReceiveMessage(cell $self) impure inline {
-    lz::Packet::_assertValidLinkedList(
-        $self.cl::get<cellRef>(lz::Packet::message),
-        lz::Packet::MAX_RECEIVE_MESSAGE_CELLS
-    );
+int lz::Packet::getNonce(cell $self) impure inline {
+    return $self.cellPreloadUint64At(lz::Packet::_nonceOffset);
 }
 
-int lz::Packet::calculateGuid(cell $path, int nonce) inline method_id {
-    return keccak256Builder(
-        begin_cell()
-            .store_uint64(nonce)
-            .store_uint32($path.cl::get<uint32>(lz::Path::srcEid))
-            .store_uint256($path.cl::get<address>(lz::Path::srcOApp))
-            .store_uint32($path.cl::get<uint32>(lz::Path::dstEid))
-            .store_uint256($path.cl::get<address>(lz::Path::dstOApp))
+;; returns (path, message, nonce, guid)
+(cell, cell, int, int) lz::Packet::deserialize(cell $self) impure inline {
+    slice $selfSlice = $self.begin_parse();
+    return (
+        $selfSlice.preloadRefAt(0),
+        $selfSlice.preloadRefAt(1),
+        $selfSlice.preloadUint64At(lz::Packet::_nonceOffset),
+        $selfSlice.preloadUint256At(lz::Packet::_guidOffset)
     );
 }
 
+;; ====================== Object Composite Modifiers =====================
+
 ;; NOTE: this assumes that the placement of the first field is before the second field
 cell lz::Packet::replaceTwoFieldsAtOffsets(
     cell encodedPacket,
@@ -212,4 +204,73 @@ cell lz::Packet::replaceTwoFieldsAtOffsets(
     }
 
     return curCell;
-}
+}
+
+cell lz::Packet::setNonceAndGuid(cell $self, int nonce, int guid) impure inline {
+    return begin_cell()
+            .store_slice($self.begin_parse().scutfirst(lz::Packet::_nonceOffset, 2))  ;; keep the header and the first two refs
+            .store_uint64(nonce)
+            .store_uint256(guid)
+            .end_cell();
+}
+
+;; ====================== Object Utilities =====================
+
+int lz::Packet::calculateGuid(cell $path, int nonce) inline method_id {
+    (int srcEid, int srcOApp, int dstEid, int dstOApp) = $path.lz::Path::deserialize();
+    return keccak256Builder(
+        begin_cell()
+            .store_uint64(nonce)
+            .store_uint32(srcEid)
+            .store_uint256(srcOApp)
+            .store_uint32(dstEid)
+            .store_uint256(dstOApp)
+    );
+}
+
+;; ====================== Object Validators =====================
+
+;; assumes that the message is a valid single-linked list
+int lz::Packet::_messageBytes(cell $self) impure inline {
+    slice messageSlice = $self.lz::Packet::getMessage().begin_parse();
+    (int sliceBits, int sliceRefs) = messageSlice.slice_bits_refs();
+    int messageBytes = sliceBits / 8;
+    while (sliceRefs > 0) {
+        messageSlice = messageSlice.preload_first_ref().begin_parse();
+        (sliceBits, sliceRefs) = messageSlice.slice_bits_refs();
+        messageBytes += (sliceBits / 8);
+    }
+    return messageBytes;
+}
+
+() lz::Packet::_assertValidLinkedList(cell head, int maxLen) impure inline {
+    slice messageSlice = head.begin_parse();
+    repeat (maxLen) {
+        (int sliceBits, int sliceRefs) = messageSlice.slice_bits_refs();
+        if (sliceRefs == 0) {
+            throw_if(lz::Packet::ERROR::INVALID_MESSAGE, sliceBits % 8 != 0);
+            return ();
+        } else {
+            throw_if(
+                lz::Packet::ERROR::INVALID_MESSAGE,
+                (sliceRefs != 1) | (sliceBits != MAX_CELL_WHOLE_BYTE_BITS)
+            );
+        }
+        messageSlice = messageSlice.preload_first_ref().begin_parse();
+    }
+    throw(lz::Packet::ERROR::INVALID_MESSAGE);
+}
+
+() lz::Packet::assertValidSendMessage(cell $self) impure inline {
+    lz::Packet::_assertValidLinkedList(
+        $self.lz::Packet::getMessage(),
+        lz::Packet::MAX_SEND_MESSAGE_CELLS
+    );
+}
+
+() lz::Packet::assertValidReceiveMessage(cell $self) impure inline {
+    lz::Packet::_assertValidLinkedList(
+        $self.lz::Packet::getMessage(),
+        lz::Packet::MAX_RECEIVE_MESSAGE_CELLS
+    );
+}

package/src/classes/lz/Path.fc

@@ -15,7 +15,7 @@ const int lz::Path::dstOApp = 3;
 ;; a context-free way to refer to the two ends of the channel.
 ;; The direction is inferred by the context of the contract (send vs receive).
 ;; The srcOApp is the 256-bit hashpart of a standard address.
-cell lz::Path::New(int srcEid, int srcOApp, int dstEid, int dstOApp) inline method_id {
+cell lz::Path::New(int srcEid, int srcOApp, int dstEid, int dstOApp) impure inline method_id {
     return cl::declare(
         lz::Path::NAME,
         unsafeTuple([
@@ -27,7 +27,23 @@ cell lz::Path::New(int srcEid, int srcOApp, int dstEid, int dstOApp) inline meth
     );
 }
 
-cell lz::Path::endpointPath(int srcEid, int dstEid) inline {
+const int lz::Path::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 4);
+const int lz::Path::_headerFillerBits = _HEADER_WIDTH - lz::Path::_headerInfoBits;
+const int lz::Path::_headerInfo = 8903714975572488637007080065659;
+
+;; this function is unused by the protocol but will be used by OApps
+cell lz::Path::build(int srcEid, int srcOApp, int dstEid, int dstOApp) impure inline {
+    return begin_cell()
+        .store_uint(lz::Path::_headerInfo, lz::Path::_headerInfoBits)    ;; header info
+        .store_ones(lz::Path::_headerFillerBits)                         ;; header filler
+        .store_uint32(srcEid)
+        .store_uint256(srcOApp)
+        .store_uint32(dstEid)
+        .store_uint256(dstOApp)
+        .end_cell();
+}
+
+cell lz::Path::endpointPath(int srcEid, int dstEid) impure inline {
     return lz::Path::New(srcEid, NULLADDRESS, dstEid, NULLADDRESS);
 }
 
@@ -37,12 +53,47 @@ cell lz::Path::reverse(cell $path) inline {
     int dstEid = $path.cl::get<uint32>(lz::Path::dstEid);
     int dstOapp = $path.cl::get<address>(lz::Path::dstOApp);
     return lz::Path::New(dstEid, dstOapp, srcEid, srcOapp);
-
 }
 
+;; ====================== Object Getters =====================
+
 const int lz::Path::_srcEidOffset = _HEADER_WIDTH;
 const int lz::Path::_srcOAppOffset = lz::Path::_srcEidOffset + 32;
 const int lz::Path::_dstEidOffset = lz::Path::_srcOAppOffset + 256;
+const int lz::Path::_dstOAppOffset = lz::Path::_dstEidOffset + 32;
+
+int lz::Path::getSrcOApp(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(lz::Path::_srcOAppOffset);
+}
+
+;; ====================== Storage Composite Accessors =====================
+
+int lz::Path::getDstEid(cell $self) impure inline {
+    return $self.cellPreloadUint32At(lz::Path::_dstEidOffset);
+}
+
+;; (srcEid, dstEid)
+(int, int) lz::Path::getEidAndDstEid(cell $self) impure inline {
+    slice $selfSlice = $self.begin_parse();
+    return (
+        $selfSlice.preloadUint32At(lz::Path::_srcEidOffset),
+        $selfSlice.preloadUint32At(lz::Path::_dstEidOffset)
+    );
+}
+
+;; (srcEid, srcOApp, dstEid, dstOApp)
+(int, int, int, int) lz::Path::deserialize(cell $self) impure inline {
+    slice $selfSlice = $self.begin_parse();
+    return (
+        $selfSlice.preloadUint32At(lz::Path::_srcEidOffset),
+        $selfSlice.preloadAddressAt(lz::Path::_srcOAppOffset),
+        $selfSlice.preloadUint32At(lz::Path::_dstEidOffset),
+        $selfSlice.preloadAddressAt(lz::Path::_dstOAppOffset)
+    );
+}
+
+;; ====================== Object Mutators =====================
+
 ;; low-level optimized version
 ;; original: 12k gas
 ;; optimized: 1k gas
@@ -62,4 +113,4 @@ cell lz::Path::sanitize(cell $path) impure {
         $path.cl::get<uint32>(lz::Path::dstEid),
         $path.cl::get<address>(lz::Path::dstOApp)
     );
-}
+}

package/src/classes/lz/ReceiveEpConfig.fc

@@ -4,21 +4,52 @@
 const int lz::ReceiveEpConfig::NAME = "RcvEpCfg"u;
 
 ;; field names
-const int lz::ReceiveEpConfig::receiveMsglibConnectionAddress = 0;
-const int lz::ReceiveEpConfig::timeoutReceiveMsglibConnectionAddress = 1;
+const int lz::ReceiveEpConfig::receiveMsglibConnection = 0;
+const int lz::ReceiveEpConfig::timeoutReceiveMsglibConnection = 1;
 const int lz::ReceiveEpConfig::expiry = 2;
 
 cell lz::ReceiveEpConfig::New(
     int receiveMsglibConnectionAddress,
     int timeoutReceiveMsglibConnectionAddress,
     int expiry
-) inline method_id {
+) impure inline method_id {
     return cl::declare(
         lz::ReceiveEpConfig::NAME,
         unsafeTuple([
-            [cl::t::address, receiveMsglibConnectionAddress],        ;; lz::ReceiveEpConfig::receiveMsglibConnectionAddress
-            [cl::t::address, timeoutReceiveMsglibConnectionAddress], ;; lz::ReceiveEpConfig::timeoutReceiveMsglibConnectionAddress
+            [cl::t::address, receiveMsglibConnectionAddress],        ;; lz::ReceiveEpConfig::receiveMsglibConnection
+            [cl::t::address, timeoutReceiveMsglibConnectionAddress], ;; lz::ReceiveEpConfig::timeoutReceiveMsglibConnection
             [cl::t::uint64, expiry]                                  ;; lz::ReceiveEpConfig::expiry
         ])
     );
 }
+
+;; ====================== Object Builders =====================
+
+
+const int lz::ReceiveEpConfig::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 3);
+const int lz::ReceiveEpConfig::_headerFillerBits = _HEADER_WIDTH - lz::ReceiveEpConfig::_headerInfoBits;
+const int lz::ReceiveEpConfig::_headerInfo = 106946417840994430288387571463327099;
+
+cell lz::ReceiveEpConfig::build(
+    int receiveMsglibConnectionAddress,
+    int timeoutReceiveMsglibConnectionAddress,
+    int expiry
+) impure inline {
+    return begin_cell()
+        .store_uint(lz::ReceiveEpConfig::_headerInfo, lz::ReceiveEpConfig::_headerInfoBits) ;; header info
+        .store_ones(lz::ReceiveEpConfig::_headerFillerBits)                                 ;; header filler
+        .store_uint256(receiveMsglibConnectionAddress)                                       ;; cl::t::uint256
+        .store_uint256(timeoutReceiveMsglibConnectionAddress)                                ;; cl::t::uint256
+        .store_uint64(expiry)                                                                ;; cl::t::uint64
+        .end_cell();
+}
+
+;; ====================== Object Getters =====================
+
+const int lz::ReceiveEpConfig::_receiveMsglibConnectionOffset = _HEADER_WIDTH;
+const int lz::ReceiveEpConfig::_timeoutReceiveMsglibConnectionOffset = lz::ReceiveEpConfig::_receiveMsglibConnectionOffset + 256;
+const int lz::ReceiveEpConfig::_expiryOffset = lz::ReceiveEpConfig::_timeoutReceiveMsglibConnectionOffset + 256;
+
+int lz::ReceiveEpConfig::getReceiveMsglibConnection(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(lz::ReceiveEpConfig::_receiveMsglibConnectionOffset);
+}

package/src/classes/lz/SendEpConfig.fc

@@ -4,15 +4,65 @@
 const int lz::SendEpConfig::NAME = "SendEpCfg"u;
 
 ;; field names
-const int lz::SendEpConfig::sendMsglibAddress = 0;
-const int lz::SendEpConfig::sendMsglibConnectionAddress = 1;
+const int lz::SendEpConfig::sendMsglibManager = 0;
+const int lz::SendEpConfig::sendMsglib = 1;
+const int lz::SendEpConfig::sendMsglibConnection = 2;
 
-cell lz::SendEpConfig::New(int sendMsglibAddress, int sendMsglibConnectionAddress) inline method_id {
+cell lz::SendEpConfig::New(int sendMsglibManager, int sendMsglib, int sendMsglibConnection) inline method_id {
     return cl::declare(
         lz::SendEpConfig::NAME,
         unsafeTuple([
-            [cl::t::address, sendMsglibAddress],                     ;; lz::SendEpConfig::sendMsglibAddress
-            [cl::t::address, sendMsglibConnectionAddress]            ;; lz::SendEpConfig::sendMsglibConnectionAddress
+            [cl::t::address, sendMsglibManager],        ;; lz::SendEpConfig::sendMsglibManager
+            [cl::t::address, sendMsglib],               ;; lz::SendEpConfig::sendMsglib
+            [cl::t::address, sendMsglibConnection]      ;; lz::SendEpConfig::sendMsglibConnection
         ])
     );
 }
+
+;; ====================== Object Builders =====================
+
+;; everything fits in the root cell
+const int lz::SendEpConfig::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 3);
+const int lz::SendEpConfig::_headerFillerBits = _HEADER_WIDTH - lz::SendEpConfig::_headerInfoBits;
+const int lz::SendEpConfig::_headerInfo = 27713146160555717952182050613837570051;
+
+cell lz::SendEpConfig::build(int sendMsglibManager, int sendMsglib, int sendMsglibConnection) impure inline {
+    return begin_cell()
+        .store_uint(lz::SendEpConfig::_headerInfo, lz::SendEpConfig::_headerInfoBits)
+        .store_ones(lz::SendEpConfig::_headerFillerBits)
+        .store_uint256(sendMsglibManager)
+        .store_uint256(sendMsglib)
+        .store_ref(empty_cell())
+        .store_ref(empty_cell())
+        .store_ref(
+            begin_cell()
+                .store_uint256(sendMsglibConnection)
+            .end_cell()
+        )
+        .end_cell();
+}
+
+;; root cell offsets
+const int lz::SendEpConfig::_sendMsglibManagerOffset = _HEADER_WIDTH;
+const int lz::SendEpConfig::_sendMsglibOffset = _HEADER_WIDTH + 256;
+
+;; ref[2] offsets
+const int lz::SendEpConfig::_sendMsglibConnectionOffset = 0;
+
+;; ====================== Object Getters =====================
+
+int lz::SendEpConfig::getSendMsglib(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(lz::SendEpConfig::_sendMsglibOffset);
+}
+
+;; ====================== Object Multi-Getters =====================
+
+;; (sendMsglibManager, sendMsglib, sendMsglibConnection)
+(int, int, int) lz::SendEpConfig::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadAddressAt(lz::SendEpConfig::_sendMsglibManagerOffset),
+        selfSlice.preloadAddressAt(lz::SendEpConfig::_sendMsglibOffset),
+        selfSlice.preloadRefAt(2).cellPreloadAddressAt(lz::SendEpConfig::_sendMsglibConnectionOffset)
+    );
+}

package/src/classes/msgdata/AddMsglib.fc

@@ -15,4 +15,15 @@ cell md::AddMsglib::New(int msglibManagerAddress, int dstEid) inline method_id {
             [cl::t::uint32, dstEid]                 ;; md::AddMsglib::dstEid
         ])
     );
+}
+
+;; Ensure AddMsglib doesn't have garbage bits that would cause undefined behaviors in the protocol
+cell md::AddMsglib::sanitize(cell $addMsglib) impure inline_ref {
+    int msglibManagerAddress = $addMsglib.cl::get<address>(md::AddMsglib::msglibManagerAddress);
+    int dstEid = $addMsglib.cl::get<uint32>(md::AddMsglib::dstEid);
+
+    return md::AddMsglib::New(
+        msglibManagerAddress,
+        dstEid
+    );
 }

package/src/classes/msgdata/ChannelNonceInfo.fc

@@ -16,3 +16,23 @@ cell md::ChannelNonceInfo::New(int nonce, int firstUnexecutedNonce) inline metho
         ])
     );
 }
+
+;; ====================== Object Getters =====================
+
+const int md::ChannelNonceInfo::_nonceOffset = _HEADER_WIDTH;
+const int md::ChannelNonceInfo::_firstUnexecutedNonceOffset = md::ChannelNonceInfo::_nonceOffset + 64;
+
+(int, int) md::ChannelNonceInfo::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadUint64At(md::ChannelNonceInfo::_nonceOffset),
+        selfSlice.preloadUint64At(md::ChannelNonceInfo::_firstUnexecutedNonceOffset)
+    );
+}
+
+cell md::ChannelNonceInfo::sanitize(cell $self) impure inline_ref {
+    int nonce = $self.cl::get<uint64>(md::ChannelNonceInfo::nonce);
+    int firstUnexecutedNonce = $self.cl::get<uint64>(md::ChannelNonceInfo::firstUnexecutedNonce);
+
+    return md::ChannelNonceInfo::New(nonce, firstUnexecutedNonce);
+}

package/src/classes/msgdata/CoinsAmount.fc

@@ -13,4 +13,12 @@ cell md::CoinsAmount::New(int amount) inline method_id {
             [cl::t::coins, amount] ;; md::CoinsAmount::amount
         ])
     );
+}
+
+;; ========================== Sanitize ==========================
+
+cell md::CoinsAmount::sanitize(cell $self) impure {
+    int amount = $self.cl::get<coins>(md::CoinsAmount::amount);
+
+    return md::CoinsAmount::New(amount);
 }

package/src/classes/msgdata/Deploy.fc

@@ -30,3 +30,22 @@ cell md::Deploy::NewWithExtraInfo(
     return md::Deploy::New(initialDeposit, dstEid, dstOApp)
         .cl::set(md::Deploy::extraInfo, $extraInfo);
 }
+
+;; ========================== Sanitize ==========================
+
+cell md::Deploy::sanitize(cell $self) impure {
+    int initialDeposit = $self.cl::get<coins>(md::Deploy::initialDeposit);
+    int dstEid = $self.cl::get<uint32>(md::Deploy::dstEid);
+    int dstOApp = $self.cl::get<uint256>(md::Deploy::dstOApp);
+
+    return md::Deploy::New(initialDeposit, dstEid, dstOApp);
+}
+
+cell md::Deploy::NewWithExtraInfo::sanitize(cell $self) impure {
+    int initialDeposit = $self.cl::get<coins>(md::Deploy::initialDeposit);
+    int dstEid = $self.cl::get<uint32>(md::Deploy::dstEid);
+    int dstOApp = $self.cl::get<uint256>(md::Deploy::dstOApp);
+    cell $extraInfo = $self.cl::get<objRef>(md::Deploy::extraInfo);
+
+    return md::Deploy::NewWithExtraInfo(initialDeposit, dstEid, dstOApp, $extraInfo);
+}

package/src/classes/msgdata/ExtendedMd.fc

@@ -8,7 +8,7 @@ const int md::ExtendedMd::md = 0;
 const int md::ExtendedMd::obj = 1;
 const int md::ExtendedMd::forwardingAddress = 2;
 
-cell md::ExtendedMd::New(cell $md, cell $obj, int forwardingAddress) inline method_id {
+cell md::ExtendedMd::New(cell $md, cell $obj, int forwardingAddress) impure inline method_id {
     return cl::declare(
         md::ExtendedMd::NAME,
         unsafeTuple([
@@ -17,4 +17,55 @@ cell md::ExtendedMd::New(cell $md, cell $obj, int forwardingAddress) inline meth
             [cl::t::address, forwardingAddress]  ;; md::ExtendedMd::forwardingAddress
         ])
     );
+}
+
+const int md::ExtendedMd::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 3);
+const int md::ExtendedMd::_headerFillerBits = _HEADER_WIDTH - md::ExtendedMd::_headerInfoBits;
+const int md::ExtendedMd::_headerInfo = 8632157695553525919024050567799415113083;
+
+cell md::ExtendedMd::build(cell $md, cell $obj, int forwardingAddress) impure inline {
+    return begin_cell()
+        .store_uint(md::ExtendedMd::_headerInfo, md::ExtendedMd::_headerInfoBits)     ;; header info
+        .store_ones(md::ExtendedMd::_headerFillerBits)                                ;; header filler
+        .store_ref($md)                                                                ;; md::ExtendedMd::md
+        .store_ref($obj)                                                               ;; md::ExtendedMd::obj
+        .store_uint256(forwardingAddress)                                              ;; md::ExtendedMd::forwardingAddress
+        .end_cell();
+}   
+
+;; ====================== Object Getters =====================
+
+const int md::ExtendedMd::_forwardingAddressOffset = _HEADER_WIDTH;
+
+cell md::ExtendedMd::getObj(cell $self) impure inline {
+    return $self.cellPreloadRefAt(1);
+}
+
+;; ====================== Object Multi-Getters =====================
+
+(cell, int) md::ExtendedMd::getMdAndForwardingAddress(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadRefAt(0),
+        selfSlice.preloadAddressAt(md::ExtendedMd::_forwardingAddressOffset)
+    );
+}
+
+(cell, cell, int) md::ExtendedMd::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadRefAt(0),
+        selfSlice.preloadRefAt(1),
+        selfSlice.preloadAddressAt(md::ExtendedMd::_forwardingAddressOffset)
+    );
+}
+
+;; ====================== Sanitize =====================
+
+cell md::ExtendedMd::sanitize(cell $extendedMd) impure {
+    cell $md = $extendedMd.cl::get<objRef>(md::ExtendedMd::md);
+    cell $obj = $extendedMd.cl::get<objRef>(md::ExtendedMd::obj);
+    int forwardingAddress = $extendedMd.cl::get<address>(md::ExtendedMd::forwardingAddress);
+
+    return md::ExtendedMd::New($md, $obj, forwardingAddress);
 }

package/src/classes/msgdata/LzReceivePrepare.fc

@@ -15,4 +15,24 @@ cell md::LzReceivePrepare::New(int nonce, int nanotons) method_id {
             [cl::t::coins, nanotons] ;; md::LzReceivePrepare::nanotons
         ])
     );
-}
+}
+
+;; ====================== Object Getters =====================
+
+const int md::LzReceivePrepare::_nonceOffset = _HEADER_WIDTH;
+const int md::LzReceivePrepare::_nanotonsOffset = md::LzReceivePrepare::_nonceOffset + 64;
+
+;; this function is unused by the protocol but will be used by OApps
+int md::LzReceivePrepare::getNanotons(cell $self) impure inline {
+    return $self.cellPreloadCoinsAt(md::LzReceivePrepare::_nanotonsOffset);
+}
+
+;; ====================== Object Multi-Getters =====================
+
+(int, int) md::LzReceivePrepare::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadUint64At(md::LzReceivePrepare::_nonceOffset),
+        selfSlice.preloadCoinsAt(md::LzReceivePrepare::_nanotonsOffset)
+    );
+}

package/src/classes/msgdata/LzReceiveStatus.fc

@@ -13,7 +13,7 @@ const int md::LzReceiveStatus::sender = 5;
 const int md::LzReceiveStatus::packet = 6;
 const int md::LzReceiveStatus::executionStatus = 7;
 
-cell md::LzReceiveStatus::New(int success, int nonce) inline method_id {
+cell md::LzReceiveStatus::New(int success, int nonce) impure inline method_id {
     return cl::declare(
         md::LzReceiveStatus::NAME,
         unsafeTuple([
@@ -54,4 +54,75 @@ cell md::LzReceiveStatus::NewFull(
             [cl::t::uint8, executionStatus] ;; md::LzReceiveAlert::executionStatus
         ])
     );
+}
+
+;; ====================== Object Builders =====================
+
+const int md::LzReceiveStatus::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 8);
+const int md::LzReceiveStatus::_headerFillerBits = _HEADER_WIDTH - md::LzReceiveStatus::_headerInfoBits;
+const int md::LzReceiveStatus::_headerInfo = 31461150238884194531671275676859177915085721713836393515717807231;
+
+;; this function is unused by the protocol but will be used by OApps
+cell md::LzReceiveStatus::build(
+    int success,
+    int nonce
+) impure inline method_id {
+    return begin_cell()
+        .store_uint(md::LzReceiveStatus::_headerInfo, md::LzReceiveStatus::_headerInfoBits) ;; header info
+        .store_ones(md::LzReceiveStatus::_headerFillerBits)                                 ;; header filler
+        .store_bool(success)                                                                 ;; bool[0]
+        .store_uint64(nonce)                                                                 ;; uint64[1]
+        .store_uint128(0)                                                                    ;; coins[2]
+        .store_uint256(NULLADDRESS)                                                          ;; address[3]
+        .store_uint8(0)                                                                      ;; uint8[4]
+        .store_ref(cl::nullObject())                                                         ;; ref[0]
+        .store_ref(cl::nullObject())                                                         ;; ref[1]
+        .store_ref(
+            begin_cell()
+                .store_ref(cl::nullObject())                                                 ;; ref[2]
+            .end_cell()
+        )
+        .end_cell();
+}
+
+
+;; ====================== Object Multi-Getters =====================
+
+const int md::LzReceiveStatus::_successOffset = _HEADER_WIDTH;
+const int md::LzReceiveStatus::_nonceOffset = md::LzReceiveStatus::_successOffset + 1;
+const int md::LzReceiveStatus::_valueOffset = md::LzReceiveStatus::_nonceOffset + 64;
+const int md::LzReceiveStatus::_senderOffset = md::LzReceiveStatus::_valueOffset + 128;
+const int md::LzReceiveStatus::_executionStatusOffset = md::LzReceiveStatus::_senderOffset + 256;
+const int md::LzReceiveStatus::_extraDataOffset = md::LzReceiveStatus::_executionStatusOffset + 8;
+
+(int, int) md::LzReceiveStatus::getSuccessAndNonce(cell $self) impure inline {
+    slice $selfSlice = $self.begin_parse(); 
+    return (
+        $selfSlice.preloadBoolAt(md::LzReceiveStatus::_successOffset),
+        $selfSlice.preloadUint64At(md::LzReceiveStatus::_nonceOffset)
+    );
+}
+
+;; ========================== Sanitize ==========================
+
+cell md::LzReceiveStatus::NewFull::sanitize(cell $self) impure {
+    int success = $self.cl::get<bool>(md::LzReceiveStatus::success);
+    int nonce = $self.cl::get<uint64>(md::LzReceiveStatus::nonce);
+    int value = $self.cl::get<coins>(md::LzReceiveStatus::value);
+    cell extraData = $self.cl::get<cellRef>(md::LzReceiveStatus::extraData);
+    cell reason = $self.cl::get<cellRef>(md::LzReceiveStatus::reason);
+    int sender = $self.cl::get<address>(md::LzReceiveStatus::sender);
+    cell $packet = $self.cl::get<objRef>(md::LzReceiveStatus::packet);
+    int executionStatus = $self.cl::get<uint8>(md::LzReceiveStatus::executionStatus);
+
+    return md::LzReceiveStatus::NewFull(
+        success,
+        nonce,
+        value,
+        extraData,
+        reason,
+        sender,
+        $packet,
+        executionStatus
+    );
 }