@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.29

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

package/src/classes/msgdata/MdAddress.fc

@@ -15,4 +15,46 @@ cell md::MdAddress::New(cell $md, int address) inline method_id {
             [cl::t::address, address]   ;; md::MdAddress::address
         ])
     );
+}
+
+;; ========================== Object Builders ==========================
+
+const int md::MdAddress::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 2);
+const int md::MdAddress::_headerFillerBits = _HEADER_WIDTH - md::MdAddress::_headerInfoBits;
+const int md::MdAddress::_headerInfo = 5847545689438192720283003;
+
+cell md::MdAddress::build(cell $md, int address) impure inline method_id {
+    return begin_cell()
+        .store_uint(md::MdAddress::_headerInfo, md::MdAddress::_headerInfoBits) ;; header info
+        .store_ones(md::MdAddress::_headerFillerBits)                          ;; header filler
+        .store_uint256(address)                                                 ;; md::MdAddress::address
+        .store_ref($md)                                                         ;; md::MdAddress::md = ref[0]
+        .end_cell();
+}
+
+;; ========================== Object Getters ==========================
+
+const int md::MdAddress::_addressOffset = _HEADER_WIDTH;
+
+cell md::MdAddress::getMd(cell $self) impure inline {
+    return $self.cellPreloadRefAt(0);
+}
+
+;; ========================== Object Multi-Getters ==========================
+
+(cell, int) md::MdAddress::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadRefAt(0),
+        selfSlice.preloadAddressAt(md::MdAddress::_addressOffset)
+    );
+}
+
+;; ========================== Sanitize ==========================
+
+cell md::MdAddress::sanitize(cell $self) impure inline_ref {
+    int address = $self.cl::get<uint256>(md::MdAddress::address);
+    cell $md = $self.cl::get<objRef>(md::MdAddress::md);
+
+    return md::MdAddress::New($md, address);
 }

package/src/classes/msgdata/MdEid.fc

@@ -15,4 +15,12 @@ cell md::MdEid::New(cell $md, int eid) inline method_id {
             [cl::t::uint32, eid]    ;; md::MdEid::eid
         ])
     );
+}
+
+
+cell md::MdEid::sanitize(cell $mdEid) impure inline_ref {
+    cell $md = $mdEid.cl::get<objRef>(md::MdEid::md);
+    int eid = $mdEid.cl::get<uint32>(md::MdEid::eid);
+
+    return md::MdEid::New($md, eid);
 }

package/src/classes/msgdata/MdObj.fc

@@ -15,4 +15,36 @@ cell md::MdObj::New(cell $md, cell $obj) inline method_id {
             [cl::t::objRef, $obj]   ;; md::MdObj::obj
         ])
     );
+}
+
+
+;; ========================== Object Builders ==========================
+const int md::MdObj::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 2);
+const int md::MdObj::_headerFillerBits = _HEADER_WIDTH - md::MdObj::_headerInfoBits;
+const int md::MdObj::_headerInfo = 22842038364999638994941;
+
+cell md::MdObj::build(cell $md, cell $obj) impure inline {
+    return begin_cell()
+        .store_uint(md::MdObj::_headerInfo, md::MdObj::_headerInfoBits) ;; header info
+        .store_ones(md::MdObj::_headerFillerBits)                       ;; header filler
+        .store_ref($md)                                                  ;; ref[0]
+        .store_ref($obj)                                                 ;; ref[1]
+        .end_cell();
+} 
+
+;; ========================== Object Multi-Getters ==========================
+
+(cell, cell) md::MdObj::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadRefAt(0),
+        selfSlice.preloadRefAt(1)
+    );
+}
+
+cell md::MdObj::sanitize(cell $mdObj) impure {
+    cell $md = $mdObj.cl::get<objRef>(md::MdObj::md);
+    cell $obj = $mdObj.cl::get<objRef>(md::MdObj::obj);
+
+    return md::MdObj::New($md, $obj);
 }

package/src/classes/msgdata/MessagingReceipt.fc

@@ -1,7 +1,7 @@
 #include "../../funC++/classlib.fc";
 
 ;; required storage name
-const int  md::MessagingReceipt::NAME = "msgreceipt"u;
+const int md::MessagingReceipt::NAME = "MsgReceipt"u;
 
 ;; field names
 const int md::MessagingReceipt::lzSend = 0;
@@ -20,3 +20,36 @@ cell md::MessagingReceipt::New(cell $lzSend, int nativeFee, int zroFee, int erro
         ])
     );
 }
+
+
+;; ========================== Object Builders ==========================
+
+const int md::MessagingReceipt::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 4);
+const int md::MessagingReceipt::_headerFillerBits = _HEADER_WIDTH - md::MessagingReceipt::_headerInfoBits;
+const int md::MessagingReceipt::_headerInfo = 1727210451775936897226519655289233983117527419;
+
+cell md::MessagingReceipt::build(cell $lzSend, int nativeFee, int zroFee, int errorCode) impure inline {
+    return begin_cell()
+        .store_uint(md::MessagingReceipt::_headerInfo, md::MessagingReceipt::_headerInfoBits) ;; header info
+        .store_ones(md::MessagingReceipt::_headerFillerBits)                                  ;; header filler
+        .store_ref($lzSend)                                                                   ;; ref[0]
+        .store_uint128(nativeFee)                                                             ;; coins[1]
+        .store_uint128(zroFee)                                                                ;; coins[2]
+        .store_uint16(errorCode)                                                              ;; uint16[3]
+        .end_cell();
+}
+
+;; ========================== Object Accessors ==========================
+
+const int md::MessagingReceipt::_nativeFeeOffset = _HEADER_WIDTH;
+const int md::MessagingReceipt::_zroFeeOffset = _HEADER_WIDTH + 128;
+const int md::MessagingReceipt::_errorCodeOffset = _HEADER_WIDTH + 256;
+
+;; this function is unused by the protocol but will be used by OApps
+(int, cell) md::MessagingReceipt::getErrorCodeAndLzSend(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadUint16At(md::MessagingReceipt::_errorCodeOffset),
+        selfSlice.preloadRefAt(0)
+    );
+}

package/src/classes/msgdata/MsglibSendCallback.fc

@@ -47,6 +47,88 @@ cell md::MsglibSendCallback::New(
     );
 }
 
+;; ========================== Object Builders ==========================
+
+const int md::MsglibSendCallback::_headerInfoBits = 198;
+const int md::MsglibSendCallback::_headerFillerBits = _HEADER_WIDTH - (198 + _NAME_WIDTH);
+const int md::MsglibSendCallback::_headerInfo = 177909621499943220462532613625031755041688677811453802367547;
+
+cell md::MsglibSendCallback::build(
+    int nativeFee,
+    int zroFee,
+    cell $lzSend,
+    cell packetEncoded,
+    cell payees,
+    int nonceByteOffset,
+    int nonceBytes,
+    int guidByteOffset,
+    int guidBytes,
+    cell $msglibSendEvents,
+    int errorCode
+) impure inline {
+    return begin_cell()
+        .store_uint(md::MsglibSendCallback::NAME, _NAME_WIDTH)                                    ;; name
+        .store_uint(md::MsglibSendCallback::_headerInfo, md::MsglibSendCallback::_headerInfoBits) ;; rest of the header
+        .store_ones(md::MsglibSendCallback::_headerFillerBits)                                    ;; header filler
+        .store_uint128(nativeFee)                                                                 ;; nativeFee
+        .store_uint128(zroFee)                                                                    ;; zroFee
+        .store_uint16(nonceByteOffset)                                                            ;; nonceByteOffset
+        .store_uint8(nonceBytes)                                                                  ;; nonceBytes
+        .store_uint16(guidByteOffset)                                                             ;; guidByteOffset
+        .store_uint8(guidBytes)                                                                   ;; guidBytes
+        .store_uint8(errorCode)                                                                   ;; errorCode
+        .store_ref($lzSend)                                                                       ;; lzSend
+        .store_ref(packetEncoded)                                                                 ;; packetEncoded
+        .store_ref(
+            begin_cell()
+                .store_ref(payees)                                                                ;; payees
+                .store_ref($msglibSendEvents)                                                     ;; msglibSendEvents
+            .end_cell()
+        )
+        .end_cell();
+}
+
+;; ========================== Object Getters ==========================
+
+const int md::MsglibSendCallback::_nativeFeeOffset = _HEADER_WIDTH;
+const int md::MsglibSendCallback::_zroFeeOffset = md::MsglibSendCallback::_nativeFeeOffset + 128;
+const int md::MsglibSendCallback::_nonceByteOffsetOffset = md::MsglibSendCallback::_zroFeeOffset + 128;
+const int md::MsglibSendCallback::_nonceBytesOffset = md::MsglibSendCallback::_nonceByteOffsetOffset + 16;
+const int md::MsglibSendCallback::_guidByteOffsetOffset = md::MsglibSendCallback::_nonceBytesOffset + 8;
+const int md::MsglibSendCallback::_guidBytesOffset = md::MsglibSendCallback::_guidByteOffsetOffset + 16;
+const int md::MsglibSendCallback::_errorCodeOffset = md::MsglibSendCallback::_guidBytesOffset + 8;
+
+
+cell md::MsglibSendCallback::getLzSend(cell $self) impure inline {
+    return $self
+        .begin_parse()
+        .preload_ref_at(0);
+}
+
+;; ========================== Object Multi-Getters ==========================
+
+;; (errorCode, nativeFee, zroFee, lzSend, payees, encodedPacket, nonceByteOffset, nonceBytes, guidByteOffset, guidBytes, sendEvents)
+(int, int, int, cell, cell, cell, int, int, int, int, cell) md::MsglibSendCallback::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2 = selfSlice.preloadRefSliceAt(2);
+    
+    return (
+        selfSlice.preloadUint8At(md::MsglibSendCallback::_errorCodeOffset),       ;; errorCode
+        selfSlice.preloadCoinsAt(md::MsglibSendCallback::_nativeFeeOffset),       ;; nativeFee
+        selfSlice.preloadCoinsAt(md::MsglibSendCallback::_zroFeeOffset),          ;; zroFee
+        selfSlice.preloadRefAt(0),                                                ;; lzSend
+        ref2.preloadRefAt(0),                                                     ;; payees
+        selfSlice.preloadRefAt(1),                                                ;; encodedPacket
+        selfSlice.preloadUint16At(md::MsglibSendCallback::_nonceByteOffsetOffset),;; nonceByteOffset
+        selfSlice.preloadUint8At(md::MsglibSendCallback::_nonceBytesOffset),      ;; nonceBytes
+        selfSlice.preloadUint16At(md::MsglibSendCallback::_guidByteOffsetOffset), ;; guidByteOffset
+        selfSlice.preloadUint8At(md::MsglibSendCallback::_guidBytesOffset),       ;; guidBytes
+        ref2.preloadRefAt(1)
+    );
+}
+
+;; ========================== Payees Utilities ==========================
+
 const int payeesTuple::addressIdx = 0;
 const int payeesTuple::nativeAmountIdx = 1;
 const int payees::addressBits = 256;

package/src/classes/msgdata/Nonce.fc

@@ -13,4 +13,34 @@ cell md::Nonce::New(int nonce) inline method_id {
             [cl::t::uint64, nonce] ;; md::Nonce::nonce
         ])
     );
+}
+
+;; ========================== Object Builders ==========================
+const int md::Nonce::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 1);
+const int md::Nonce::_headerFillerBits = _HEADER_WIDTH - md::Nonce::_headerInfoBits;
+const int md::Nonce::_headerInfo = 124339069371385211;
+
+;; this function is unused by the protocol but will be used by OApps
+cell md::Nonce::build(int nonce) impure inline {
+    return begin_cell()
+        .store_uint(md::Nonce::_headerInfo, md::Nonce::_headerInfoBits) ;; header info
+        .store_ones(md::Nonce::_headerFillerBits)                       ;; header filler
+        .store_uint64(nonce)
+        .end_cell();
+}
+
+
+;; ========================== Object Getters ==========================
+const int md::Nonce::_nonceOffset = _HEADER_WIDTH;
+
+int md::Nonce::getNonce(cell $self) impure inline {
+    return $self.cellPreloadUint64At(md::Nonce::_nonceOffset);
+}
+
+;; ========================== Sanitize ==========================
+
+cell md::Nonce::sanitize(cell $self) impure inline_ref {
+    int nonce = $self.cl::get<uint64>(md::Nonce::nonce);
+
+    return md::Nonce::New(nonce);
 }

package/src/classes/msgdata/OptionsV1.fc

@@ -24,4 +24,24 @@ cell md::OptionsV1::New(
             [cl::t::uint256, nativeDropAmount]       ;; md::OptionsV1::nativeDropAmount
         ])
     );
-}
+}
+
+;; ========================== Object Multi-Getters ==========================
+
+const int md::OptionsV1::_lzReceiveGasOffset = _HEADER_WIDTH;
+const int md::OptionsV1::_lzReceiveValueOffset = md::OptionsV1::_lzReceiveGasOffset + 256;
+
+const int md::OptionsV1::_nativeDropAddressOffset = 0;
+const int md::OptionsV1::_nativeDropAmountOffset = md::OptionsV1::_nativeDropAddressOffset + 256;
+
+
+;; (lzReceiveGas, lzReceiveValue, nativeDropAmount)
+(int, int, int) md::OptionsV1::decodeCoins(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2 = selfSlice.preloadRefSliceAt(2);
+    return (
+        selfSlice.preloadUint256At(md::OptionsV1::_lzReceiveGasOffset),
+        selfSlice.preloadUint256At(md::OptionsV1::_lzReceiveValueOffset),
+        ref2.preloadUint256At(md::OptionsV1::_nativeDropAmountOffset)
+    );
+}

package/src/classes/msgdata/OptionsV2.fc

@@ -34,4 +34,31 @@ cell md::OptionsV2::New(
             [cl::t::uint256, nativeDropAmount]       ;; md::OptionsV2::nativeDropAmount
         ])
     );
+}
+
+;; ========================== Object Multi-Getters ==========================
+
+const int md::OptionsV2::_lzReceiveGasOffset = _HEADER_WIDTH;
+const int md::OptionsV2::_lzReceiveValueOffset = md::OptionsV2::_lzReceiveGasOffset + 256;
+
+const int md::OptionsV2::_lzComposeGasOffset = 0;
+const int md::OptionsV2::_lzComposeValueOffset = md::OptionsV2::_lzComposeGasOffset + 256;
+const int md::OptionsV2::_nativeDropAddressOffset = md::OptionsV2::_lzComposeValueOffset + 256;
+
+const int md::OptionsV2::_nativeDropAmountOffset = 0;
+
+;; (lzComposeGas, lzComposeValue, lzReceiveGas, lzReceiveValue, nativeDropAmount)
+(int, int, int, int, int) md::OptionsV2::decodeCoins(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    slice ref2 = selfSlice.preloadRefSliceAt(2);
+    slice ref3 = selfSlice.preloadRefSliceAt(3);
+
+    return (
+        ref2.preloadUint256At(md::OptionsV2::_lzComposeGasOffset),
+        ref2.preloadUint256At(md::OptionsV2::_lzComposeValueOffset),
+        selfSlice.preloadUint256At(md::OptionsV2::_lzReceiveGasOffset),
+        selfSlice.preloadUint256At(md::OptionsV2::_lzReceiveValueOffset),
+        ref3.preloadUint256At(md::OptionsV2::_nativeDropAmountOffset)
+    );
 }

package/src/classes/msgdata/PacketId.fc

@@ -15,4 +15,28 @@ cell md::PacketId::New(cell $path, int nonce) inline method_id {
             [cl::t::uint64, nonce]  ;; md::PacketId::nonce
         ])
     );
+}
+
+;; ========================== Object Builders ==========================
+
+const int md::PacketId::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 2);
+const int md::PacketId::_headerFillerBits = _HEADER_WIDTH - md::PacketId::_headerInfoBits;
+const int md::PacketId::_headerInfo = 33180451689778480514427;
+
+cell md::PacketId::build(cell $path, int nonce) impure inline {
+    return begin_cell()
+        .store_uint(md::PacketId::_headerInfo, md::PacketId::_headerInfoBits) ;; header info
+        .store_ones(md::PacketId::_headerFillerBits)                          ;; header filler
+        .store_ref($path)                                                     ;; ref[0]
+        .store_uint(nonce, 64)                                                ;; uint[1]
+        .end_cell();
+}
+
+;; ========================== Sanitize ==========================
+
+cell md::PacketId::sanitize(cell $self) impure {
+    cell $path = $self.cl::get<objRef>(md::PacketId::path);
+    int nonce = $self.cl::get<uint64>(md::PacketId::nonce);
+
+    return md::PacketId::New($path, nonce);
 }

package/src/classes/msgdata/PacketSent.fc

@@ -22,7 +22,7 @@ cell md::PacketSent::New(
     int nonce,
     int msglibAddress,
     cell $msglibSendEvents
-) inline method_id {
+) impure inline method_id {
     return cl::declare(
         md::PacketSent::NAME,
         unsafeTuple([
@@ -37,3 +37,37 @@ cell md::PacketSent::New(
         ])
     );
 }
+
+;; ========================== Object Builders ==========================
+
+const int md::PacketSent::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 8);
+const int md::PacketSent::_headerFillerBits = _HEADER_WIDTH - md::PacketSent::_headerInfoBits;
+const int md::PacketSent::_headerInfo = 705670168524170966093988960735291442056898952154447392698365;
+
+cell md::PacketSent::build(
+    int nativeFee,
+    int zroFee,
+    cell $extraOptions,
+    cell $enforcedOptions,
+    cell packetEncoded,
+    int nonce,
+    int msglibAddress,
+    cell $msglibSendEvents
+) impure inline {
+    return begin_cell()
+        .store_uint(md::PacketSent::_headerInfo, md::PacketSent::_headerInfoBits)
+        .store_ones(md::PacketSent::_headerFillerBits)
+        .store_uint128(nativeFee)
+        .store_uint128(zroFee)
+        .store_uint64(nonce)
+        .store_uint256(msglibAddress)
+        .store_ref($extraOptions)
+        .store_ref($enforcedOptions)
+        .store_ref(
+            begin_cell()
+            .store_ref(packetEncoded)
+            .store_ref($msglibSendEvents)
+            .end_cell()
+        )
+        .end_cell();
+}

package/src/classes/msgdata/SetAddress.fc

@@ -13,4 +13,11 @@ cell md::SetAddress::New(int address) inline method_id {
             [cl::t::address, address] ;; md::SetAddress::owner
         ])
     );
+}
+
+;; Ensure SetAddress doesn't have garbage bits that would cause undefined behaviors in the protocol
+cell md::SetAddress::sanitize(cell $setAddress) impure {
+    return md::SetAddress::New(
+        $setAddress.cl::get<address>(md::SetAddress::address)
+    );
 }

package/src/classes/msgdata/SetEpConfig.fc

@@ -30,4 +30,21 @@ cell md::SetEpConfig::New(
             [cl::t::uint64, timeoutReceiveMsglibExpiry]     ;; md::SetEpConfig::timeoutReceiveMsglibExpiry
         ])
     );
+}
+
+;; Ensure SetEpConfig doesn't have garbage bits that would cause undefined behaviors in the protocol
+cell md::SetEpConfig::sanitize(cell $setEpConfig) impure inline_ref {
+    int useDefaults = $setEpConfig.cl::get<bool>(md::SetEpConfig::useDefaults);
+    int sendMsglibManager = $setEpConfig.cl::get<address>(md::SetEpConfig::sendMsglibManager);
+    int receiveMsglibManager = $setEpConfig.cl::get<address>(md::SetEpConfig::receiveMsglibManager);
+    int timeoutReceiveMsglibManager = $setEpConfig.cl::get<address>(md::SetEpConfig::timeoutReceiveMsglibManager);
+    int timeoutReceiveMsglibExpiry = $setEpConfig.cl::get<uint64>(md::SetEpConfig::timeoutReceiveMsglibExpiry);
+
+    return md::SetEpConfig::New(
+        useDefaults,
+        sendMsglibManager,
+        receiveMsglibManager,
+        timeoutReceiveMsglibManager,
+        timeoutReceiveMsglibExpiry
+    );
 }

package/src/funC++/actions/event.fc

@@ -1,4 +1,5 @@
 #include "../baseInterface.fc";
+#include "../classlib.fc";
 #include "utils.fc";
 
 const int action::event::NAME = "event"u;
@@ -15,7 +16,7 @@ int _getEventSink() impure inline;
 ;; @info Events in LZ contracts are internal messages to an event sink
 ;; where the resulting transaction always reverts
 ;; @non-terminal
-cell action::event::New(int topic, cell $body, cell $initialStorage) inline method_id {
+cell action::event::New(int topic, cell $body, cell $initialStorage) impure inline method_id {
     return cl::declare(
         action::event::NAME,
         unsafeTuple([
@@ -26,10 +27,24 @@ cell action::event::New(int topic, cell $body, cell $initialStorage) inline meth
     );
 }
 
+const int action::event::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 3);
+const int action::event::_headerFillerBits = _HEADER_WIDTH - action::event::_headerInfoBits;
+const int action::event::_headerInfo = 7850279558805522911016931325;
+
+cell action::event::build(int topic, cell $body, cell $initialStorage) impure inline method_id {
+    return begin_cell()
+        .store_uint(action::event::_headerInfo, action::event::_headerInfoBits)     ;; header info
+        .store_ones(action::event::_headerFillerBits)                               ;; header filler
+        .store_uint256(topic)
+        .store_ref($body)
+        .store_ref($initialStorage)
+        .end_cell();
+}
+
 tuple action::event::create(int topic, cell $body, cell $initialStorage) inline {
     return unsafeTuple([
         action::event::NAME, 
-        action::event::New(topic, $body, $initialStorage)
+        action::event::build(topic, $body, $initialStorage)
     ]);
 }