@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.28

package/src/protocol/endpoint/handler.fc

@@ -56,13 +56,19 @@
 }
 
 ;; Derive the channel address for a given path
-int _getChannelAddress(cell $path) inline method_id {
-    cell $storage = getContractStorage();
+int _getChannelAddress(cell $storage, cell $path) inline method_id {
     return computeContractAddress(
         $storage
-            .cl::get<objRef>(Endpoint::channelStorageInit)
-            .cl::set(Channel::path, $path),
-        $storage.cl::get<cellRef>(Endpoint::channelCode)
+            .Endpoint::getChannelStorageInit()
+            .Channel::setPath($path),
+        $storage.Endpoint::getChannelCode()
+    );
+}
+
+int _getChannelAddressUnpacked(cell $channelStorage, cell channelCode, cell $path) impure inline {
+    return computeContractAddress(
+        $channelStorage.Channel::setPath($path),
+        channelCode
     );
 }
 
@@ -94,6 +100,7 @@ cell _getEpConfigFromManagerAddresses(cell $setEpConfigMd, cell $path) inline me
 
     return lz::EpConfig::NewWithConnection(
         $setEpConfigMd.cl::get<bool>(md::SetEpConfig::useDefaults),
+        sendMsglibManager,
         sendMsglib,
         sendMsglibConnection,
         receiveMsglib,
@@ -104,32 +111,42 @@ cell _getEpConfigFromManagerAddresses(cell $setEpConfigMd, cell $path) inline me
     );
 }
 
-(int, int) _getMsglibAndConnectionDefaults(int key, cell $path) inline method_id {
-    cell $msglibInfo = getContractStorage().cl::get<objRef>(key);
+(int, int) _getMsglibAndConnectionDefaults(cell $msglibInfo, cell $path) impure inline method_id {
     if (cl::isNullObject($msglibInfo)) {
         return (NULLADDRESS, NULLADDRESS);
     }
+
     return (
-        $msglibInfo.cl::get<address>(lz::MsglibInfo::msglibAddress),
+        lz::MsglibInfo::getMsglibAddress($msglibInfo),
         lz::MsglibInfo::getMsglibConnectionAddress($msglibInfo, $path)
     );
 }
 
-(int, int) _getSendMsglibAndConnectionDefaults(cell $path) inline method_id {
-    return _getMsglibAndConnectionDefaults(Endpoint::defaultSendLibInfo, $path);
+(int, int) getSendMsglibAndConnectionDefaults(cell $storage, cell $path) inline method_id {
+    return _getMsglibAndConnectionDefaults(
+        $storage.Endpoint::getDefaultSendLibInfo(), 
+        $path
+    );
 }
 
-(int, int) getReceiveMsglibAndConnectionDefaults(cell $path) inline method_id {
-    return _getMsglibAndConnectionDefaults(Endpoint::defaultReceiveLibInfo, $path);
+(int, int) getReceiveMsglibAndConnectionDefaults(cell $storage, cell $path) inline method_id {
+    return _getMsglibAndConnectionDefaults(
+        $storage.Endpoint::getDefaultReceiveLibInfo(), 
+        $path
+    );
 }
 
-(int, int) getTimeoutReceiveMsglibAndConnectionDefaults(cell $path) inline method_id {
-    return _getMsglibAndConnectionDefaults(Endpoint::defaultTimeoutReceiveLibInfo, $path);
+(int, int) getTimeoutReceiveMsglibAndConnectionDefaults(cell $storage, cell $path) inline method_id {
+    return _getMsglibAndConnectionDefaults(
+        $storage.Endpoint::getDefaultTimeoutReceiveLibInfo(), 
+        $path
+    );
 }
 
 () _assertAuthorizedMsglib() impure inline method_id {
     (_, int exists) = getContractStorage()
-        .cl::nestedDict256::get<cellRef>(Endpoint::msglibs, getCaller());
+        .Endpoint::getMsglibs()
+        .cl::dict256::get<cellRef>(getCaller());
 
     throw_unless(Endpoint::ERROR::unauthorizedMsglib, exists);
 }
@@ -161,20 +178,18 @@ cell _getEpConfigFromManagerAddresses(cell $setEpConfigMd, cell $path) inline me
 
 int _getEventSink() impure inline {
     return getContractStorage()
-        .cl::get<objRef>(Endpoint::baseStorage)
-        .cl::get<address>(BaseStorage::owner);
+        .Endpoint::getBaseStorage()
+        .BaseStorage::getOwner();
 }
 
-
 ;;; ================PERMISSION FUNCTIONS=====================
 
 () _checkPermissions(int op, cell $md) impure inline {
     if (op == Endpoint::OP::ENDPOINT_SEND) {
         throw_unless(Endpoint::ERROR::notOApp,
             getCaller() == $md
-                .cl::get<objRef>(md::LzSend::packet)
-                .cl::get<objRef>(lz::Packet::path)
-                .cl::get<address>(lz::Path::srcOApp)
+                .md::LzSend::getPath()
+                .lz::Path::getSrcOApp()
         );
     } elseif (op == Endpoint::OP::ENDPOINT_COMMIT_PACKET) {
         ;; open and public calls
@@ -203,18 +218,20 @@ int _getEventSink() impure inline {
 tuple setEpConfigDefaults(cell $setEpConfigMd) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    cell $sanitizedSetEpConfig = $setEpConfigMd.md::SetEpConfig::sanitize();
+
     cell $path = lz::Path::endpointPath(
         $storage.cl::get<uint32>(Endpoint::eid),
         $storage.cl::get<uint32>(Endpoint::dstEid)
     );
 
-    int sendLibManager = $setEpConfigMd
+    int sendLibManager = $sanitizedSetEpConfig
         .cl::get<address>(md::SetEpConfig::sendMsglibManager);
 
-    int receiveLibManager = $setEpConfigMd
+    int receiveLibManager = $sanitizedSetEpConfig
         .cl::get<address>(md::SetEpConfig::receiveMsglibManager);
     
-    int timeoutReceiveLibManager = $setEpConfigMd
+    int timeoutReceiveLibManager = $sanitizedSetEpConfig
         .cl::get<address>(md::SetEpConfig::timeoutReceiveMsglibManager);
 
     (cell $sendLibInfo, int sendLibExists) = getContractStorage()
@@ -226,7 +243,7 @@ tuple setEpConfigDefaults(cell $setEpConfigMd) impure inline method_id {
     (cell $timeoutReceiveLibInfo, int timeoutReceiveLibExists) = getContractStorage()
         .cl::nestedDict256::get<cellRef>(Endpoint::msglibs, timeoutReceiveLibManager);
 
-    int expiry = $setEpConfigMd.cl::get<uint64>(md::SetEpConfig::timeoutReceiveMsglibExpiry);
+    int expiry = $sanitizedSetEpConfig.cl::get<uint64>(md::SetEpConfig::timeoutReceiveMsglibExpiry);
     throw_unless(
         Endpoint::ERROR::unauthorizedMsglib,
           (sendLibExists | (sendLibManager == NULLADDRESS))
@@ -244,7 +261,7 @@ tuple setEpConfigDefaults(cell $setEpConfigMd) impure inline method_id {
     );
 
     ;; make sure the manager addresses can be resolved
-    int validity = _getEpConfigFromManagerAddresses($setEpConfigMd, $path).lz::EpConfig::isValid();
+    int validity = _getEpConfigFromManagerAddresses($sanitizedSetEpConfig, $path).lz::EpConfig::isValid();
     ;; The above block validates *all* the inputs, meaning this throw_if will actually never
     ;; throw. We leave it in because it doesn't hurt, might as well keep it.
     ;; The extra gas cost is inconsequential because this is a configuration flow.
@@ -262,6 +279,7 @@ tuple setEpConfigDefaults(cell $setEpConfigMd) impure inline method_id {
 
     setContractStorage(
         $storage
+            .cl::set(Endpoint::defaultSendMsglibManager, sendLibManager)
             .cl::set(Endpoint::defaultSendLibInfo, $sendLibInfo)
             .cl::set(Endpoint::defaultReceiveLibInfo, $receiveLibInfo)
             .cl::set(Endpoint::defaultTimeoutReceiveLibInfo, $timeoutReceiveLibInfo)
@@ -269,7 +287,7 @@ tuple setEpConfigDefaults(cell $setEpConfigMd) impure inline method_id {
     );
 
     ;; push the event
-    actions~pushAction<event>(Endpoint::event::EP_CONFIG_DEFAULTS_SET, $setEpConfigMd);
+    actions~pushAction<event>(Endpoint::event::EP_CONFIG_DEFAULTS_SET, $sanitizedSetEpConfig);
 
     return actions;
 }
@@ -280,16 +298,16 @@ tuple setEpConfigDefaults(cell $setEpConfigMd) impure inline method_id {
 ;; @out_md ExtendedMd(defaultEpConfig, setEpConfig)
 ;; @permissions owner
 tuple setEpConfigOApp(cell $mdObj) impure inline method_id {
-    (_, tuple actions) = preamble();
+    (cell $storage, tuple actions) = preamble();
 
     ;; extract the md params
-    cell $setEpConfigOApp = $mdObj.cl::get<objRef>(md::MdObj::md);
-    cell $path = $mdObj.cl::get<objRef>(md::MdObj::obj);
-    cell $resolvedEpConfigOApp = _getEpConfigFromManagerAddresses($setEpConfigOApp, $path);
+    cell $sanitizedSetEpConfigOApp = $mdObj.cl::get<objRef>(md::MdObj::md).md::SetEpConfig::sanitize();
+    cell $sanitizedPath = $mdObj.cl::get<objRef>(md::MdObj::obj).lz::Path::sanitize();
+    cell $resolvedEpConfigOApp = _getEpConfigFromManagerAddresses($sanitizedSetEpConfigOApp, $sanitizedPath);
 
     ;; send message to channel and forward the ep config defaults
     actions~pushAction<call>(
-        _getChannelAddress($path),
+        _getChannelAddress($storage, $sanitizedPath),
         Channel::OP::SET_EP_CONFIG_OAPP,
         $resolvedEpConfigOApp
     );
@@ -303,20 +321,33 @@ tuple setEpConfigOApp(cell $mdObj) impure inline method_id {
 ;; @out_md MdObj(lzSend, defaultSendConfig)
 ;; @permissions OApp
 tuple endpointSend(cell $lzSend) impure inline method_id {
-    (_, tuple actions) = preamble();
+    (cell $storage, tuple actions) = preamble();
     ;; already asserted caller identity matches the request contents in checkPermissions()
-    cell $packet = $lzSend.cl::get<objRef>(md::LzSend::packet);
-    cell $path = $packet.cl::get<objRef>(lz::Packet::path);
+    cell $path = $lzSend.md::LzSend::getPath();
+
+    (
+        cell $channelStorageInit,
+        cell channelCode,
+        int defaultSendMsglibManager,
+        cell $defaultSendLibInfo
+    ) = $storage.Endpoint::getSendConfiguration();
 
     ;; Invariant: if a msglib is set as a default msglib, it must be resolved
-    ;; thus, _getSendMsglibAndConnectionDefaults should never revert
-    (int sendMsglib, int sendMsglibConnection) = _getSendMsglibAndConnectionDefaults($path);
+    ;; thus, getSendMsglibAndConnectionDefaults should never revert
+    (
+        int sendMsglib, 
+        int sendMsglibConnection
+    ) = _getMsglibAndConnectionDefaults($defaultSendLibInfo, $path);
 
     actions~pushAction<call>(
-        _getChannelAddress($path),
+        _getChannelAddressUnpacked($channelStorageInit, channelCode, $path),
         Channel::OP::CHANNEL_SEND,
-        md::MdObj::New($lzSend, lz::SendEpConfig::New(sendMsglib, sendMsglibConnection))
+        md::MdObj::build(
+            $lzSend, 
+            lz::SendEpConfig::build(defaultSendMsglibManager, sendMsglib, sendMsglibConnection)
+        )
     );
+
     return actions;
 }
 
@@ -327,38 +358,45 @@ tuple endpointSend(cell $lzSend) impure inline method_id {
 tuple endpointCommitPacket(cell $packet) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell $receivePath = $packet.cl::get<objRef>(lz::Packet::path);
+    cell $receivePath = $packet.lz::Packet::getPath();
+    (int recvPathSrcEid, int recvPathDstEid) = $receivePath.lz::Path::getEidAndDstEid();
+    (
+        int storageEid, 
+        int storageDstEid, 
+        int defaultExpiry,
+        cell $defaultReceiveLibInfo,
+        cell $timeoutReceiveLibInfo
+    ) = $storage.Endpoint::getCommitPacketInformation();
 
     ;; Assert we are the correct endpoint for this commit request
     ;; the srcEid of the packet should match the dstEid of the endpoint contract
     throw_if(
         Endpoint::ERROR::wrongPath,
-        ($receivePath.cl::get<uint32>(lz::Path::srcEid) != $storage.cl::get<uint32>(Endpoint::dstEid))
-        | ($receivePath.cl::get<uint32>(lz::Path::dstEid) != $storage.cl::get<uint32>(Endpoint::eid))
+        (recvPathSrcEid != storageDstEid) | (recvPathDstEid != storageEid)
     );
 
     cell $sendPath = $receivePath.lz::Path::optimizedReverse();
-    int channelAddress = computeContractAddress(
-        $storage
-            .cl::get<objRef>(Endpoint::channelStorageInit)
-            .cl::set(Channel::path, $sendPath),
-        $storage.cl::get<cellRef>(Endpoint::channelCode)
+    int channelAddress = _getChannelAddress($storage, $sendPath);
+
+    (_, int receiveMsglibConnection) = _getMsglibAndConnectionDefaults(
+        $defaultReceiveLibInfo,
+        $sendPath
     );
 
-    (_, int receiveMsglibConnection) = getReceiveMsglibAndConnectionDefaults($sendPath);
-    (_, int timeoutReceiveMsglibConnection) = getTimeoutReceiveMsglibAndConnectionDefaults(
+    (_, int timeoutReceiveMsglibConnection) = _getMsglibAndConnectionDefaults(
+        $timeoutReceiveLibInfo,
         $sendPath
     );
 
     actions~pushAction<call>(
         channelAddress,
         Channel::OP::CHANNEL_COMMIT_PACKET,
-        md::ExtendedMd::New(
+        md::ExtendedMd::build(
             $packet,
-            lz::ReceiveEpConfig::New(
+            lz::ReceiveEpConfig::build(
                 receiveMsglibConnection,
                 timeoutReceiveMsglibConnection,
-                $storage.cl::get<uint64>(Endpoint::defaultExpiry)
+                defaultExpiry
             ),
             getCaller()
         )
@@ -375,10 +413,12 @@ tuple endpointCommitPacket(cell $packet) impure inline method_id {
 tuple addMsglib(cell $addMsglib) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    cell $sanitizedAddMsglibMd = $addMsglib.md::AddMsglib::sanitize();
+
     ;; Not necessary to check dstEid in $addMsglib is correct, because
     ;; the controller derives our address based on dstEid, so it cannot be wrong.
 
-    int msglibManagerAddress = $addMsglib.cl::get<address>(md::AddMsglib::msglibManagerAddress);
+    int msglibManagerAddress = $sanitizedAddMsglibMd.cl::get<address>(md::AddMsglib::msglibManagerAddress);
     (cell $msglibInfo, int exists) = $storage.cl::nestedDict256::get<cellRef>(
         Endpoint::msglibs,
         msglibManagerAddress
@@ -404,15 +444,15 @@ tuple addMsglib(cell $addMsglib) impure inline method_id {
         actions~pushAction<call>(
             msglibManagerAddress,
             MsglibManager::OP::GET_MSGLIB_INFO,
-            $addMsglib
+            $sanitizedAddMsglibMd
         );
     } else {
-    ;; if the previous addMsglib ran out of gas, it can be retried
+        ;; if the previous addMsglib ran out of gas, it can be retried
         if (cl::isNullObject($msglibInfo)) {
             actions~pushAction<call>(
                 msglibManagerAddress,
                 MsglibManager::OP::GET_MSGLIB_INFO,
-                $addMsglib
+                $sanitizedAddMsglibMd
             );
         }
     }
@@ -426,6 +466,8 @@ tuple addMsglib(cell $addMsglib) impure inline method_id {
 tuple getMsglibInfoCallback(cell $msglibInfo) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    cell $sanitizedMsglibInfo = $msglibInfo.lz::MsglibInfo::sanitize();
+
     ;; the storedMsglibInfo is asserted to exist in checkPermissions
     (cell $storedMsglibInfo, _) = $storage.cl::nestedDict256::get<cellRef>(
         Endpoint::msglibs,
@@ -435,7 +477,7 @@ tuple getMsglibInfoCallback(cell $msglibInfo) impure inline method_id {
     throw_unless(Endpoint::ERROR::msglibInfoExists, cl::isNullObject($storedMsglibInfo));
 
     setContractStorage(
-        $storage.cl::nestedDict256::setRef(Endpoint::msglibs, getCaller(), $msglibInfo)
+        $storage.cl::nestedDict256::setRef(Endpoint::msglibs, getCaller(), $sanitizedMsglibInfo)
     );
 
     return actions;

package/src/protocol/endpoint/storage.fc

@@ -11,13 +11,14 @@ const int Endpoint::msglibs = 3;
 const int Endpoint::numMsglibs = 4;
 const int Endpoint::channelCode = 5;
 const int Endpoint::channelStorageInit = 6;
-const int Endpoint::defaultSendLibInfo = 7;
-const int Endpoint::defaultReceiveLibInfo = 8;
-const int Endpoint::defaultTimeoutReceiveLibInfo = 9;
-const int Endpoint::defaultExpiry = 10;
+const int Endpoint::defaultSendMsglibManager = 7;
+const int Endpoint::defaultSendLibInfo = 8;
+const int Endpoint::defaultReceiveLibInfo = 9;
+const int Endpoint::defaultTimeoutReceiveLibInfo = 10;
+const int Endpoint::defaultExpiry = 11;
 
 ;; @owner manager
-cell Endpoint::New(int eid, int dstEid, int owner) inline method_id {
+cell Endpoint::New(int eid, int dstEid, int owner) impure inline method_id {
     return cl::declare(
         Endpoint::NAME,
         unsafeTuple([
@@ -28,10 +29,73 @@ cell Endpoint::New(int eid, int dstEid, int owner) inline method_id {
             [cl::t::uint8, 0],                          ;; Endpoint::numMsglibs
             [cl::t::cellRef, empty_cell()],             ;; Endpoint::channelCode
             [cl::t::objRef, cl::nullObject()],          ;; Endpoint::channelStorageInit
+            [cl::t::address, NULLADDRESS],              ;; Endpoint::defaultSendMsglibManager
             [cl::t::objRef, cl::nullObject()],          ;; Endpoint::defaultSendLibInfo
             [cl::t::objRef, cl::nullObject()],          ;; Endpoint::defaultReceiveLibInfo
             [cl::t::objRef, cl::nullObject()],          ;; Endpoint::defaultTimeoutReceiveLibInfo
             [cl::t::uint64, 0]                          ;; Endpoint::defaultExpiry
         ])
     );
+}
+
+;; ====================== Storage Accessors =====================
+
+const int Endpoint::_eidOffset = _HEADER_WIDTH;
+const int Endpoint::_dstEidOffset = Endpoint::_eidOffset + 32;
+const int Endpoint::_numMsglibsOffset = Endpoint::_dstEidOffset + 32;
+const int Endpoint::_defaultSendMsglibManagerOffset = Endpoint::_numMsglibsOffset + 8;
+const int Endpoint::_defaultExpiryOffset = Endpoint::_defaultSendMsglibManagerOffset + 256;
+
+cell Endpoint::getBaseStorage(cell $self) impure inline {
+    return $self.cellPreloadRefAt(0);
+}
+
+cell Endpoint::getMsglibs(cell $self) impure inline {
+    return $self.cellPreloadRefAt(1);
+}
+
+cell Endpoint::getChannelCode(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(0);
+}
+
+cell Endpoint::getChannelStorageInit(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(1);
+}
+
+cell Endpoint::getDefaultSendLibInfo(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(2);
+}
+
+cell Endpoint::getDefaultReceiveLibInfo(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(3);
+}
+
+cell Endpoint::getDefaultTimeoutReceiveLibInfo(cell $self) impure inline {
+    return $self.cellPreloadRefAt(3).cellPreloadRefAt(0);
+}
+
+;; ====================== Composite Storage Accessors =====================
+
+;; (channelStorageInit, channelCode, defaultSendMsglibManager, defaultSendLibInfo)
+(cell, cell, int, cell) Endpoint::getSendConfiguration(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2Slice = selfSlice.preloadRefSliceAt(2);
+    return (
+        ref2Slice.preloadRefAt(1),
+        ref2Slice.preloadRefAt(0),
+        selfSlice.preloadAddressAt(Endpoint::_defaultSendMsglibManagerOffset),
+        ref2Slice.preloadRefAt(2)
+    );
+}
+
+;; (eid, dstEid, defaultExpiry, defaultReceiveLibInfo, timeoutReceiveLibInfo)
+(int, int, int, cell, cell) Endpoint::getCommitPacketInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadUint32At(Endpoint::_eidOffset),
+        selfSlice.preloadUint32At(Endpoint::_dstEidOffset),
+        selfSlice.preloadUint64At(Endpoint::_defaultExpiryOffset),
+        selfSlice.preloadRefAt(2).cellPreloadRefAt(3),
+        selfSlice.preloadRefAt(3).cellPreloadRefAt(0)
+    );
 }

package/src/protocol/msglibs/BytesEncoder.fc

@@ -18,7 +18,7 @@ tuple BytesEncoder::New() inline {
 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);
+        throw_if(BytesEncoder::ERROR::malformed_subtree, data.slice_refs() > 1);
 
         ;; grabs the last builder on the tuple stack
         int curBuilderIdx = self.tlen() - 1;
@@ -133,18 +133,19 @@ 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);
+tuple BytesEncoder::build<PacketV1>(cell $packet) impure inline {
+    (cell $path, cell $message, int nonce, int guid) = $packet.lz::Packet::deserialize();
+    (int srcEid, int srcOApp, int dstEid, int dstOApp) = $path.lz::Path::deserialize();
     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<address>(lz::Path::srcOApp)) ;; sender bytes32
-            .store_uint32($path.cl::get<uint32>(lz::Path::dstEid)) ;; dstEid uint32
-            .store_uint256($path.cl::get<address>(lz::Path::dstOApp))  ;; receiver bytes32
-            .store_uint256($packet.cl::get<uint256>(lz::Packet::guid))  ;; guid bytes32
+            .store_uint64(nonce) ;; nonce uint64
+            .store_uint32(srcEid) ;; srcEid uint32
+            .store_uint256(srcOApp) ;; sender bytes32
+            .store_uint32(dstEid) ;; dstEid uint32
+            .store_uint256(dstOApp)  ;; receiver bytes32
+            .store_uint256(guid)  ;; guid bytes32
     ]).BytesEncoder::feed<cellRef>(
-        $packet.cl::get<cellRef>(lz::Packet::message) ;; message []bytes
+        $message ;; message []bytes
     );
 }

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

@@ -188,10 +188,7 @@ tuple smlManagerSend(cell $extendedMd) impure inline method_id {
     actions~pushAction<call>(
         $extendedMd.cl::get<address>(md::ExtendedMd::forwardingAddress), ;; channelAddress
         Channel::OP::MSGLIB_SEND_CALLBACK,
-        md::MdAddress::New(
-            $msglibSendCallbackMd,
-            getContractAddress()
-        )
+        $msglibSendCallbackMd
     );
 
     return actions;

package/src/protocol/msglibs/ultralightnode/feeLibInterface.fc

@@ -8,3 +8,4 @@ const int UlnWorkerInterface::setConfig = 95983; ;; ulnWorker::setConfig
 
 const int UlnWorkerInterface::ERROR::UNKNOWN_OPTIONS = 2100;
 const int UlnWorkerInterface::ERROR::ZERO_LZ_COMPOSE_GAS_PROVIDED = 2101;
+const int UlnWorkerInterface::ERROR::INVALID_OPTIONS = 2102;

package/src/protocol/msglibs/ultralightnode/msgdata/Attestation.fc

@@ -35,15 +35,14 @@ cell lz::Attestation::New(int hash, int confirmations) inline method_id {
     );
 }
 
-int lz::Attestation::confirmable(cell $self, int hash, int confirmations) impure inline method_id {
-    ;; low-level destructuring for efficiency
-    slice selfSlice = $self.begin_parse().sdskipfirst(_HEADER_WIDTH);
-
-    ;; Equivalent to the below
-    ;;      ($self.cl::get<uint256>(lz::Attestation::hash) == hash)
-    ;;    & ($self.cl::get<uint64>(lz::Attestation::confirmations) <= confirmations);
+const int lz::Attestation::_hashOffset = _HEADER_WIDTH;
+const int lz::Attestation::_confirmationsOffset = lz::Attestation::_hashOffset + 256;
 
+;; (hash, confirmations)
+(int, int) lz::Attestation::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
     return (
-        (selfSlice~load_uint256() == hash) & (selfSlice~load_uint64() <= confirmations)
+        selfSlice.preloadUint256At(lz::Attestation::_hashOffset),
+        selfSlice.preloadUint64At(lz::Attestation::_confirmationsOffset)
     );
 }

package/src/protocol/msglibs/ultralightnode/msgdata/DvnFeesPaidEvent.fc

@@ -23,4 +23,24 @@ cell DvnFeesPaidEvent::New(
             [cl::t::objRef, serializedPayees]         ;; DvnFeesPaidEvent::serializedPayees
         ])
     );
+}
+
+;; ========================= Object Builders =========================
+
+const int DvnFeesPaidEvent::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 3);
+const int DvnFeesPaidEvent::_headerFillerBits = _HEADER_WIDTH - DvnFeesPaidEvent::_headerInfoBits;
+const int DvnFeesPaidEvent::_headerInfo = 5824155608645736562295029517863768977404;
+
+cell DvnFeesPaidEvent::build(cell requiredDVNs, cell optionalDVNs, cell serializedPayees) impure inline {
+    return begin_cell()
+        .store_uint(DvnFeesPaidEvent::_headerInfo, DvnFeesPaidEvent::_headerInfoBits) ;; header info
+        .store_ones(DvnFeesPaidEvent::_headerFillerBits)                              ;; header filler
+        .store_ref(requiredDVNs)                                                      ;; refs[0]
+        .store_ref(optionalDVNs)                                                      ;; refs[1]
+        .store_ref(
+            begin_cell()
+                .store_ref(serializedPayees)                                          ;; refs[2]
+            .end_cell()
+        )
+        .end_cell();
 }

package/src/protocol/msglibs/ultralightnode/msgdata/ExecutorFeePaidEvent.fc

@@ -20,4 +20,19 @@ cell ExecutorFeePaidEvent::New(
             [cl::t::coins, feePaid]              ;; ExecutorFeePaidEvent::feePaid
         ])
     );
+}
+
+;; ========================= Object Builders =========================
+
+const int ExecutorFeePaidEvent::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 2);
+const int ExecutorFeePaidEvent::_headerFillerBits = _HEADER_WIDTH - ExecutorFeePaidEvent::_headerInfoBits;
+const int ExecutorFeePaidEvent::_headerInfo = 22544389860372553502354985441937787;
+
+cell ExecutorFeePaidEvent::build(int executorAddress, int feePaid) impure inline {
+    return begin_cell()
+        .store_uint(ExecutorFeePaidEvent::_headerInfo, ExecutorFeePaidEvent::_headerInfoBits) ;; header info
+        .store_ones(ExecutorFeePaidEvent::_headerFillerBits)                                  ;; header filler
+        .store_uint256(executorAddress)
+        .store_uint128(feePaid)
+        .end_cell();
 }

package/src/protocol/msglibs/ultralightnode/msgdata/InitUln.fc

@@ -15,4 +15,4 @@ cell md::InitUln::New(cell connectionCode, int treasuryFeeBps) inline method_id
             [cl::t::uint16, treasuryFeeBps]    ;; md::InitUln::treasuryFeeBps
         ])
     );
-}
+}

package/src/protocol/msglibs/ultralightnode/msgdata/InitUlnConnection.fc

@@ -43,7 +43,7 @@ cell md::InitUlnConnection::NewOnlyConfig(
 
 ;; Ensure the Uln receive config does not contain garbage bits etc. that would cause
 ;; undefined behaviors in the protocol
-cell InitUlnConnection::sanitize(cell $initUlnConnection) impure {
+cell md::InitUlnConnection::sanitize(cell $initUlnConnection) impure {
     cell $ulnSendConfigOApp = $initUlnConnection
         .cl::get<objRef>(md::InitUlnConnection::ulnSendConfigOApp);
     cell $ulnReceiveConfigOApp = $initUlnConnection

package/src/protocol/msglibs/ultralightnode/msgdata/SetAdminWorkerAddresses.fc

@@ -16,3 +16,9 @@ cell md::SetAdminWorkerAddresses::New(cell adminWorkers) inline method_id {
         ])
     );
 }
+
+cell md::SetAdminWorkerAddresses::sanitize(cell $setAdminWorkerAddresses) impure inline_ref {
+    cell adminWorkers = $setAdminWorkerAddresses.cl::get<cellRef>(md::SetAdminWorkerAddresses::adminWorkers);
+
+    return md::SetAdminWorkerAddresses::New(adminWorkers);
+}

package/src/protocol/msglibs/ultralightnode/msgdata/UlnEvents.fc

@@ -23,4 +23,24 @@ cell UlnEvents::New(
             [cl::t::objRef, executorFeePaidEvent]   ;; UlnEvents::executorFeePaidEvent
         ])
     );
+}
+
+;; ========================= Object Builders =========================
+
+const int UlnEvents::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 3);
+const int UlnEvents::_headerFillerBits = _HEADER_WIDTH - UlnEvents::_headerInfoBits;
+const int UlnEvents::_headerInfo = 28386846067720270005963581604331155452;
+
+cell UlnEvents::build(cell workerEvents, cell dvnFeesPaidEvent, cell executorFeePaidEvent) impure inline {
+    return begin_cell()
+        .store_uint(UlnEvents::_headerInfo, UlnEvents::_headerInfoBits)  ;; header info
+        .store_ones(UlnEvents::_headerFillerBits)                        ;; header filler
+        .store_ref(workerEvents)                                         ;; refs[0]
+        .store_ref(dvnFeesPaidEvent)                                     ;; refs[1]
+        .store_ref(
+            begin_cell()
+                .store_ref(executorFeePaidEvent)                         ;; refs[2]
+            .end_cell()                                                                      
+        )
+    .end_cell();
 }