@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.28

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

package/src/classes/msgdata/LzSend.fc

@@ -1,31 +1,34 @@
 #include "../../funC++/classlib.fc";
+#include "../lz/Packet.fc";
 
 ;; required storage name
 const int md::LzSend::NAME = "lzSend"u;
 
 ;; field names
 const int md::LzSend::sendRequestId = 0;
-const int md::LzSend::sendMsglib = 1;
-const int md::LzSend::sendMsglibConnection = 2;
-const int md::LzSend::packet = 3;
-const int md::LzSend::nativeFee = 4;
-const int md::LzSend::zroFee = 5;
-const int md::LzSend::extraOptions = 6;
-const int md::LzSend::enforcedOptions = 7;
-const int md::LzSend::callbackData = 8;
+const int md::LzSend::sendMsglibManager = 1;
+const int md::LzSend::sendMsglib = 2;
+const int md::LzSend::sendMsglibConnection = 3;
+const int md::LzSend::packet = 4;
+const int md::LzSend::nativeFee = 5;
+const int md::LzSend::zroFee = 6;
+const int md::LzSend::extraOptions = 7;
+const int md::LzSend::enforcedOptions = 8;
+const int md::LzSend::callbackData = 9;
 
 cell md::LzSend::New(
-    int nativeFee,
-    int zroFee,
-    cell $extraOptions,
-    cell $enforcedOptions,
-    cell $packet,
-    cell callbackData
+int nativeFee,
+int zroFee,
+cell $extraOptions,
+cell $enforcedOptions,
+cell $packet,
+cell callbackData
 ) inline method_id {
     return cl::declare(
         md::LzSend::NAME,
         unsafeTuple([
             [cl::t::uint64, 0],                 ;; md::LzSend::sendRequestId
+            [cl::t::address, NULLADDRESS],      ;; md::LzSend::sendMsglibManager
             [cl::t::address, NULLADDRESS],      ;; md::lzSend::sendMsglib
             [cl::t::address, NULLADDRESS],      ;; md::lzSend::sendMsglibConnection
             [cl::t::objRef, $packet],           ;; md::LzSend::packet
@@ -38,21 +41,137 @@ cell md::LzSend::New(
     );
 }
 
-const md::lzSend::requestInfoWidth = _HEADER_WIDTH + 64 + 256 + 256;
-;; low-level hacking to set these 3 fields in LzSend
-;; saves about 7000 gas
-cell md::lzSend::fillRequestInfo(
-    cell $lzSend,
+const int md::LzSend::_headerPostNameBits = 180;
+const int md::LzSend::_headerFillerBits = _HEADER_WIDTH - (md::LzSend::_headerPostNameBits + _NAME_WIDTH);
+const int md::LzSend::_headerInfo = 582890735024998957421269964955452773563747974476099581;
+
+;; ========================== Object Builders ==========================
+
+;; this function is unused by the protocol but will be used by OApps
+cell md::LzSend::build(
+    int nativeFee,
+    int zroFee,
+    cell $extraOptions,
+    cell $enforcedOptions,
+    cell $packet,
+    cell callbackData
+) impure inline {
+    return begin_cell()
+        .store_uint(md::LzSend::NAME, _NAME_WIDTH)
+        .store_uint(md::LzSend::_headerInfo, md::LzSend::_headerPostNameBits)
+        .store_ones(md::LzSend::_headerFillerBits)
+        .store_uint64(0)                       ;; sendRequestId
+        .store_uint256(NULLADDRESS)            ;; sendMsglibManager
+        .store_uint256(NULLADDRESS)            ;; sendMsglib
+        .store_ref($packet)
+        .store_ref($extraOptions)
+        .store_ref(
+            begin_cell()
+                .store_uint256(NULLADDRESS)    ;; sendMsglibConnection
+                .store_uint128(nativeFee)      ;; nativeFee
+                .store_uint128(zroFee)         ;; zroFee
+                .store_ref($enforcedOptions)   ;; enforcedOptions
+                .store_ref(callbackData)       ;; callbackData
+                .end_cell()
+        )
+        .end_cell();
+}
+
+;; ====================== Object Accessors =====================
+
+;; in root cell
+const int md::LzSend::_sendRequestIdffset = _HEADER_WIDTH;
+const int md::LzSend::_sendMsglibManagerOffset = md::LzSend::_sendRequestIdffset + 64;
+const int md::LzSend::_sendMsglibOffset = md::LzSend::_sendMsglibManagerOffset + 256;
+
+;; in ref[2]
+const int md::LzSend::_sendMsglibConnectionOffset = 0;
+const int md::LzSend::_nativeFeeOffset = md::LzSend::_sendMsglibConnectionOffset + 256;
+const int md::LzSend::_zroFeeOffset = md::LzSend::_nativeFeeOffset + 128;
+
+int md::LzSend::getSendMsglib(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(md::LzSend::_sendMsglibOffset);
+}
+
+cell md::LzSend::getPacket(cell $self) impure inline {
+    return $self.cellPreloadRefAt(0);
+}
+
+;; gets the path from the packet inside the LzSend
+cell md::LzSend::getPath(cell $self) impure inline {
+    return $self.cellPreloadRefAt(0).cellPreloadRefAt(0);
+}
+
+;; (requestId, nativeFee, zroFee, extraOptions, enforcedOptions)
+(int, int, int, cell, cell) md::LzSend::deserializeSendCallback(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2Slice = selfSlice.preloadRefSliceAt(2);
+    return (
+        selfSlice.preloadUint64At(md::LzSend::_sendRequestIdffset),
+        ref2Slice.preloadCoinsAt(md::LzSend::_nativeFeeOffset),
+        ref2Slice.preloadCoinsAt(md::LzSend::_zroFeeOffset),
+        selfSlice.preloadRefAt(1),
+        ref2Slice.preloadRefAt(0)
+    );
+}
+
+;; (packet, extraOptions, enforcedOptions)
+(cell, cell, cell) md::LzSend::getQuoteInformation(cell $self) impure inline {
+    return (
+        $self.cellPreloadRefAt(0),
+        $self.cellPreloadRefAt(1),
+        $self.cellPreloadRefAt(2).cellPreloadRefAt(0)
+    );
+}
+
+int md::LzSend::getSendMsglibManager(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(md::LzSend::_sendMsglibManagerOffset);
+}
+
+;; ====================== Object Composite Modifiers =====================
+
+const int md::lzSend::requestInfoWidth = _HEADER_WIDTH + 64 + 256 + 256;
+;; Can't easily store a slice constant because the header isn't byte-aligned
+const int md::lzSend::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 10);
+const int md::lzSend::_headerPrefix = 11424049401754228397633815938683071207390004427712457772775726065407;
+const int md::lzSend::_headerSuffix = 17331160549995323848587739135;
+const int md::lzSend::_headerTrailingBits = _HEADER_WIDTH - 256;
+
+cell md::LzSend::fillRequestInfo(
+    cell $self,
     int requestId,
+    int sendMsglibManager,
     int sendMsglib,
     int sendMsglibConnection
-) inline method_id {
-    slice lzSendSlice = $lzSend.begin_parse();
+) impure inline method_id {
+    slice selfslice = $self.begin_parse();
+    slice ref2Slice = selfslice.preloadRefSliceAt(2);
+
+    ;; Fill in the fields AND overwrite the entire header to match the expected format
     return begin_cell()
-        .store_slice(lzSendSlice.scutfirst(_HEADER_WIDTH, 0))
+        .store_uint256(md::lzSend::_headerPrefix)
+        .store_uint(md::lzSend::_headerSuffix, md::lzSend::_headerTrailingBits)
+        .store_slice(selfslice.scutfirst(0, 2))
         .store_uint64(requestId)
+        .store_uint256(sendMsglibManager)
         .store_uint256(sendMsglib)
-        .store_uint256(sendMsglibConnection)
-        .store_slice(lzSendSlice.sskipfirst(md::lzSend::requestInfoWidth, 0))
+        .store_ref(
+            begin_cell()
+                .store_uint256(sendMsglibConnection)
+                .store_slice(ref2Slice.sskipfirst(md::LzSend::_nativeFeeOffset, 0))
+                .end_cell()
+        )
+        .end_cell();
+}
+
+cell md::LzSend::setPacketNonceAndGuid(cell $self, int packetNonce, int packetGuid) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    cell $newPacket = selfSlice~load_ref()
+        .lz::Packet::setNonceAndGuid(packetNonce, packetGuid);
+
+    return begin_cell()
+        .store_ref($newPacket)
+        .store_slice(selfSlice)
         .end_cell();
 }