@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.29

package/src/protocol/channel/handler.fc

@@ -38,9 +38,7 @@
 ;;; ================INTERFACE FUNCTIONS=====================
 
 int _getEventSink() inline {
-    return getContractStorage()
-        .cl::get<objRef>(Channel::baseStorage)
-        .cl::get<address>(BaseStorage::owner);
+    return getOwner();
 }
 
 ;;; ==========================HELPER FUNCTIONS=====================================
@@ -72,11 +70,11 @@ int _readSendRequestQueueEntry(cell contents) inline method_id {
 
     cell $storage = getContractStorage();
 
-    cell $executePOOO = $storage.cl::get<objRef>(Channel::executePOOO);
-    int firstUnexecutedNonce = $executePOOO.cl::get<uint64>(POOO::nextEmpty);
+    cell $executePOOO = $storage.Channel::getExecutePOOO();
+    int firstUnexecutedNonce = $executePOOO.POOO::getNextEmpty();
 
     (int actualKey, cell $packet, int status, int exists) = DeterministicInsertionCircularQueue::get(
-        $storage.cl::get<cellRef>(Channel::executionQueue),
+        $storage.Channel::getExecutionQueue(),
         incomingNonce
     );
 
@@ -106,11 +104,48 @@ int _readSendRequestQueueEntry(cell contents) inline method_id {
     return (false, null());
 }
 
+;; returns boolean committable
+int _optimizedNonceCommittable(cell $executePOOO, cell executionQueue, int incomingNonce) impure inline {
+    throw_if(Channel::ERROR::invalidNonce, incomingNonce <= 0);
+
+    int firstUnexecutedNonce = $executePOOO.POOO::getNextEmpty();
+
+    (int actualKey, _, int status, int exists) = DeterministicInsertionCircularQueue::get(
+        executionQueue,
+        incomingNonce
+    );
+
+    if (
+        (incomingNonce == firstUnexecutedNonce)
+        & (actualKey == incomingNonce)
+        & (status != ExecutionQueue::executing)
+    ) {
+        ;; short-circuit for efficiency in the common case
+        return true;
+    }
+
+    ;; condition 1 & 2: must be within the window
+    ;; condition 3: must not be executing
+    if (
+        (incomingNonce >= firstUnexecutedNonce)
+        & (incomingNonce <= POOO::maxSettableBit($executePOOO))
+        & (status != ExecutionQueue::executing)
+    ) {
+        ;; this is nested because funC doesn't support short-circuiting boolean/bitwise ops
+        ;; condition 4: must not be executed
+        ifnot (POOO::isBitSet($executePOOO, incomingNonce)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 cell _getExecutablePacket(int incomingNonce) impure inline method_id {
     (int isCommittable, cell $packet) = _nonceCommittable(incomingNonce);
     int firstUncommittedNonce = getContractStorage()
-        .cl::get<objRef>(Channel::commitPOOO)
-        .cl::get<uint64>(POOO::nextEmpty);
+        .Channel::getCommitPOOO()
+        .POOO::getNextEmpty();
 
     throw_if(
         Channel::ERROR::notExecutable,
@@ -134,8 +169,8 @@ cell _getExecutablePacket(int incomingNonce) impure inline method_id {
 
 int _viewInboundNonce() impure method_id {
     return getContractStorage()
-        .cl::get<objRef>(Channel::commitPOOO)
-        .cl::get<uint64>(POOO::nextEmpty) - 1;
+        .Channel::getCommitPOOO()
+        .POOO::getNextEmpty() - 1;
 }
 
 int _viewExecutionStatus(int incomingNonce) impure method_id {
@@ -202,22 +237,19 @@ int _viewExecutionStatus(int incomingNonce) impure method_id {
 () _assertEndpoint() impure inline {
     throw_unless(
         Channel::ERROR::onlyEndpoint,
-        getCaller() == getContractStorage().cl::get<address>(Channel::endpointAddress)
+        getCaller() == getContractStorage().Channel::getEndpointAddress()
     );
 }
 
 ;; this function is purposely designed to be maximally efficient when using a
 ;; custom configuration and less efficient when using a default configuration
-() _assertSendMsglib(cell $mdAddress) impure inline {
-    cell epConfigOApp = getContractStorage().cl::get<objRef>(Channel::epConfigOApp);
-
+() _assertSendMsglib(cell $mdMsglibSendCallback) impure inline {
     ;; Resolve the actual sendMsglib address at the time of request.
     ;; This function assumes the messagelib is not malicious or man-in-the-middle attacking,
     ;; as those cases are asserted in the handler itself.
-    int sendMsglibAddress = $mdAddress
-            .cl::get<objRef>(md::MdAddress::md)
-            .cl::get<objRef>(md::MsglibSendCallback::lzSend)
-            .cl::get<address>(md::LzSend::sendMsglib);
+    int sendMsglibAddress = $mdMsglibSendCallback
+        .md::MsglibSendCallback::getLzSend()
+        .md::LzSend::getSendMsglib();
 
     throw_unless(Channel::ERROR::onlyApprovedSendMsglib, getCaller() == sendMsglibAddress);
 }
@@ -226,8 +258,8 @@ int _viewExecutionStatus(int incomingNonce) impure method_id {
     throw_unless(
         Channel::ERROR::onlyOApp,
         getCaller() == getContractStorage()
-            .cl::get<objRef>(Channel::path)
-            .cl::get<address>(lz::Path::srcOApp)
+            .Channel::getPath()
+            .lz::Path::getSrcOApp()
     );
 }
 
@@ -280,10 +312,9 @@ int _viewExecutionStatus(int incomingNonce) impure method_id {
 tuple setEpConfigOApp(cell $epConfigOApp) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    int configValidity = $epConfigOApp.lz::EpConfig::isValid();
-    throw_if(configValidity, configValidity != lz::EpConfig::VALID);
-
-    setContractStorage($storage.cl::set(Channel::epConfigOApp, $epConfigOApp));
+    setContractStorage(
+        $storage.cl::set(Channel::epConfigOApp, $epConfigOApp.lz::EpConfig::sanitize())
+    );
 
     actions~pushAction<event>(Channel::event::EP_CFG_OAPP_SET, $epConfigOApp);
     return actions;
@@ -298,28 +329,38 @@ tuple setEpConfigOApp(cell $epConfigOApp) impure inline method_id {
 tuple channelSend(cell $mdObj) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell $lzSend = $mdObj.cl::get<objRef>(md::MdObj::md);
-    ;; assert the size and structure of the incoming lzSend message
-    lz::Packet::assertValidSendMessage($lzSend.cl::get<objRef>(md::LzSend::packet));
-
-    ;; Resolve the desired send msglib and send msglib connection
-    cell $epConfigOApp = $storage.cl::get<objRef>(Channel::epConfigOApp);
-    int sendMsglib = $epConfigOApp.cl::get<address>(lz::EpConfig::sendMsglib);
-    int sendMsglibConnection = $epConfigOApp.cl::get<address>(lz::EpConfig::sendMsglibConnection);
-    cell $sendPath = $storage.cl::get<objRef>(Channel::path);
+    (
+        cell $lzSend, 
+        cell $defaultSendEpConfig
+    ) = $mdObj.md::MdObj::deserialize();
 
-    if ($epConfigOApp.cl::get<bool>(lz::EpConfig::isNull)) {
-        cell $defaultSendEpConfig = $mdObj.cl::get<objRef>(md::MdObj::obj);
+    ;; assert the size and structure of the incoming lzSend message
+    lz::Packet::assertValidSendMessage(
+        $lzSend.md::LzSend::getPacket()
+    );
 
-        sendMsglib = $defaultSendEpConfig.cl::get<address>(lz::SendEpConfig::sendMsglibAddress);
+    (
+        cell $epConfigOApp, 
+        cell $sendPath, 
+        cell sendRequestQueue, 
+        int lastSendRequestId
+    ) = $storage.Channel::getSendInformation();
 
-        sendMsglibConnection = $defaultSendEpConfig
-            .cl::get<address>(lz::SendEpConfig::sendMsglibConnectionAddress);
+    ;; Resolve the desired send msglib and send msglib connection
+    (
+        int isEpConfigNull,
+        int sendMsglibManager,
+        int sendMsglib, 
+        int sendMsglibConnection
+    ) = $epConfigOApp.lz::EpConfig::deserializeSendConfig();
+
+    if (isEpConfigNull) {
+        (sendMsglibManager, sendMsglib, sendMsglibConnection) = $defaultSendEpConfig.lz::SendEpConfig::deserialize();
     }
 
-    if ((sendMsglib == NULLADDRESS) | (sendMsglibConnection == NULLADDRESS)) {
+    if ((sendMsglibManager == NULLADDRESS) | (sendMsglib == NULLADDRESS) | (sendMsglibConnection == NULLADDRESS)) {
         actions~pushAction<call>(
-            $sendPath.cl::get<address>(lz::Path::srcOApp),
+            $sendPath.lz::Path::getSrcOApp(),
             Layerzero::OP::CHANNEL_SEND_CALLBACK,
             md::MdObj::New(
                 md::MessagingReceipt::New(
@@ -336,26 +377,23 @@ tuple channelSend(cell $mdObj) impure inline method_id {
 
     ;; Each send request is assigned a unique request ID, which is also used as the key into
     ;; the sendRequestQueue
-    int curRequestId = $storage.cl::get<uint64>(Channel::lastSendRequestId) + 1;
+    int curRequestId = lastSendRequestId + 1;
 
-    $lzSend = md::lzSend::fillRequestInfo($lzSend, curRequestId, sendMsglib, sendMsglibConnection);
+    $lzSend = md::LzSend::fillRequestInfo($lzSend, curRequestId, sendMsglibManager, sendMsglib, sendMsglibConnection);
 
-    cell sendRequestQueue = $storage.cl::get<cellRef>(Channel::sendRequestQueue);
     (_, _, _, int exists) = DeterministicInsertionCircularQueue::get(sendRequestQueue, curRequestId);
     ifnot (exists) {
         ;; submit to the msglib
         setContractStorage(
-            $storage
-                .cl::set(Channel::lastSendRequestId, curRequestId)
-                .cl::set(
-                    Channel::sendRequestQueue,
-                    DeterministicInsertionCircularQueue::set(
-                        sendRequestQueue,
-                        curRequestId,
-                        _buildSendRequestQueueEntry($lzSend),
-                        SendRequestQueue::sending
-                    )
+            $storage.Channel::setSendRequestQueueAndLastSendRequestId(
+                curRequestId,
+                DeterministicInsertionCircularQueue::set(
+                    sendRequestQueue,
+                    curRequestId,
+                    _buildSendRequestQueueEntry($lzSend),
+                    SendRequestQueue::sending
                 )
+            )
         );
 
         actions~pushAction<call>(
@@ -367,7 +405,7 @@ tuple channelSend(cell $mdObj) impure inline method_id {
         ;; callback to the oApp with a failure and emit an event
         actions~pushAction<event>(Channel::ERROR::sendQueueCongested, $lzSend);
         actions~pushAction<call>(
-            $storage.cl::get<objRef>(Channel::path).cl::get<address>(lz::Path::srcOApp),
+            $sendPath.lz::Path::getSrcOApp(),
             Layerzero::OP::CHANNEL_SEND_CALLBACK,
             md::MdObj::New(
                 md::MessagingReceipt::New($lzSend, 0, 0, Channel::ERROR::sendQueueCongested),
@@ -382,17 +420,37 @@ tuple channelSend(cell $mdObj) impure inline method_id {
 ;; in: msglib/handler.fc/msglibSend
 ;; in_md: MsglibSendCallback
 ;; out: OApp/handler.fc/sendCallback
-tuple msglibSendCallback(cell $mdAddress) impure inline method_id {
+tuple msglibSendCallback(cell $mdMsglibSendCallback) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell $mdMsglibSendCallback = $mdAddress.cl::get<objRef>(md::MdAddress::md);
-
-    int errorCode = $mdMsglibSendCallback.cl::get<uint8>(md::MsglibSendCallback::errorCode);
+    (
+        int errorCode,
+        int nativeQuote,
+        int zroQuote,
+        cell $lzSend,
+        cell serializedPayees,
+        cell encodedPacket,
+        int nonceByteOffset,
+        int nonceBytes,
+        int guidByteOffset,
+        int guidBytes,
+        cell $sendEvents
+    ) = $mdMsglibSendCallback.md::MsglibSendCallback::deserialize();
 
-    cell $lzSend = $mdMsglibSendCallback.cl::get<objRef>(md::MsglibSendCallback::lzSend);
-    cell sendRequestQueue = $storage.cl::get<cellRef>(Channel::sendRequestQueue);
+    (
+        int requestId,
+        int lzSendNativeFee,
+        int lzSendZroFee,
+        cell $extraOptions,
+        cell $enforceOptions
+    ) = $lzSend.md::LzSend::deserializeSendCallback();
 
-    int requestId = $lzSend.cl::get<uint64>(md::LzSend::sendRequestId);
+    (
+        cell sendRequestQueue,
+        int zroBalance,
+        cell $sendPath,
+        int outboundNonce
+    ) = $storage.Channel::getSendCallbackInformation();
 
     ;; Read the requestId from the sendRequestQueue to ensure this send request is genuine
     ;; and is not being double-executed
@@ -403,8 +461,7 @@ tuple msglibSendCallback(cell $mdAddress) impure inline method_id {
 
     if (exists) {
         if (_readSendRequestQueueEntry(contents) == $lzSend.cl::hash()) {
-            $storage = $storage.cl::set(
-                Channel::sendRequestQueue,
+            $storage = $storage.Channel::setSendRequestQueue(
                 DeterministicInsertionCircularQueue::delete(sendRequestQueue, requestId)
             );
         } else {
@@ -425,36 +482,29 @@ tuple msglibSendCallback(cell $mdAddress) impure inline method_id {
     }
 
     ;; verify that cumulative fees quoted by the msglib <= the fee cap specified by the user/app
-    int zroQuote = $mdMsglibSendCallback.cl::get<coins>(md::MsglibSendCallback::zroFee);
-    int nativeQuote = $mdMsglibSendCallback.cl::get<coins>(md::MsglibSendCallback::nativeFee);
-
-    if ($lzSend.cl::get<coins>(md::LzSend::nativeFee) < nativeQuote) {
+    if (lzSendNativeFee < nativeQuote) {
         errorCode = Channel::ERROR::notEnoughNative;
     }
-    if ($lzSend.cl::get<coins>(md::LzSend::zroFee) < zroQuote) {
+    if (lzSendZroFee < zroQuote) {
         errorCode = Channel::ERROR::notEnoughZroToken;
     }
 
     ;; Verify that the ZRO token credits in the Channel is sufficient to cover the
     ;; quoted ZRO cost of the message.
-    int zroBalance = $storage.cl::get<coins>(Channel::zroBalance);
     if (zroBalance < zroQuote) {
         errorCode = Channel::ERROR::notEnoughZroTokenBalance;
     }
 
-    cell $sendPath = $storage.cl::get<objRef>(Channel::path);
-
-    int packetNonce = 0;
     int packetGuid = 0;
+    int packetNonce = 0;
+
     if (errorCode == Channel::NO_ERROR) {
         ;; Assign a nonce to the packet and calculate the resulting GUID
-        packetNonce = $storage.cl::get<uint64>(Channel::outboundNonce) + 1;
+        packetNonce = outboundNonce + 1;
         packetGuid = lz::Packet::calculateGuid($sendPath, packetNonce);
 
         ;; native payments
-        tuple payees = deserializePayees(
-            $mdMsglibSendCallback.cl::get<cellRef>(md::MsglibSendCallback::payees)
-        );
+        tuple payees = deserializePayees(serializedPayees);
 
         ;; If the TON message does not contain sufficient value to perform the payments,
         ;; the transaction will revert and the send channel will eventually get blocked.
@@ -466,20 +516,7 @@ tuple msglibSendCallback(cell $mdAddress) impure inline method_id {
         }
 
         ;; Due to asynchrony between the Msglib and the Channel, the nonce and guid
-        ;; cannot be
-        cell encodedPacket = $mdMsglibSendCallback
-            .cl::get<cellRef>(md::MsglibSendCallback::packetEncoded);
-
-        int nonceByteOffset = $mdMsglibSendCallback
-            .cl::get<uint16>(md::MsglibSendCallback::nonceByteOffset);
-
-        int nonceBytes = $mdMsglibSendCallback
-            .cl::get<uint8>(md::MsglibSendCallback::nonceBytes);
-
-        int guidByteOffset = $mdMsglibSendCallback
-            .cl::get<uint16>(md::MsglibSendCallback::guidByteOffset);
-
-        int guidBytes = $mdMsglibSendCallback.cl::get<uint8>(md::MsglibSendCallback::guidBytes);
+        ;; cannot be ... ?
 
         cell completedEncodedPacket = null();
 
@@ -507,21 +544,22 @@ tuple msglibSendCallback(cell $mdAddress) impure inline method_id {
 
         actions~pushAction<event>(
             Channel::event::PACKET_SENT,
-            md::PacketSent::New(
+            md::PacketSent::build(
                 nativeQuote,
                 zroQuote,
-                $lzSend.cl::get<objRef>(md::LzSend::extraOptions),
-                $lzSend.cl::get<objRef>(md::LzSend::enforcedOptions),
+                $extraOptions,
+                $enforceOptions,
                 completedEncodedPacket,
                 packetNonce,
-                $mdAddress.cl::get<address>(md::MdAddress::address), ;; msglib manager address
-                $mdMsglibSendCallback.cl::get<objRef>(md::MsglibSendCallback::msglibSendEvents)
+                $lzSend.md::LzSend::getSendMsglibManager(),
+                $sendEvents
             )
         );
 
-        $storage = $storage
-            .cl::set(Channel::zroBalance, zroBalance - zroQuote)
-            .cl::set(Channel::outboundNonce, packetNonce);
+        $storage = $storage.Channel::setOutboundNonceAndZroBalance(
+            packetNonce,
+            zroBalance - zroQuote
+        );
     }
 
     ;; If the quote was unsuccessful, delete the hash from storage to prevent hol blocking
@@ -529,17 +567,11 @@ tuple msglibSendCallback(cell $mdAddress) impure inline method_id {
     setContractStorage($storage);
 
     actions~pushAction<call>(
-        $sendPath.cl::get<address>(lz::Path::srcOApp),
+        $sendPath.lz::Path::getSrcOApp(),
         Layerzero::OP::CHANNEL_SEND_CALLBACK,
-        md::MdObj::New(
-            md::MessagingReceipt::New(
-                $lzSend.cl::set(
-                    md::LzSend::packet,
-                    $lzSend
-                        .cl::get<objRef>(md::LzSend::packet)
-                        .cl::set(lz::Packet::nonce, packetNonce)
-                        .cl::set(lz::Packet::guid, packetGuid)
-                ),
+        md::MdObj::build(
+            md::MessagingReceipt::build(
+                $lzSend.md::LzSend::setPacketNonceAndGuid(packetNonce, packetGuid),
                 nativeQuote,
                 zroQuote,
                 errorCode
@@ -561,33 +593,38 @@ tuple msglibSendCallback(cell $mdAddress) impure inline method_id {
 tuple channelCommitPacket(cell $mdExtended) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell $packet = $mdExtended.cl::get<objRef>(md::ExtendedMd::md);
+    cell $sanitizeMdExtended = $mdExtended.md::ExtendedMd::sanitize();
+
+    (
+        cell $packet,
+        int callerMsglibConnectionAddress
+    ) = $sanitizeMdExtended.md::ExtendedMd::getMdAndForwardingAddress();
     ;; assert the size of the incoming packet
     lz::Packet::assertValidReceiveMessage($packet);
 
-    cell $epConfigOApp = $storage.cl::get<objRef>(Channel::epConfigOApp);
-    int receiveMsglibConnection = $epConfigOApp.cl::get<address>(
-        lz::EpConfig::receiveMsglibConnection
-    );
+    (
+        cell $epConfigOApp,
+        cell $commitPOOO,
+        cell $executePOOO,
+        cell executionQueue
+    ) = $storage.Channel::getCommitPacketInformation();
 
-    int useDefaults = $epConfigOApp.cl::get<bool>(lz::EpConfig::isNull);
+    (
+        int useDefaults,
+        int receiveMsglibConnection
+    ) = $epConfigOApp.lz::EpConfig::deserializeReceiveConfig();
 
     if (useDefaults) {
-        cell $defaultConfig = $mdExtended.cl::get<objRef>(md::MdObj::obj);
-        receiveMsglibConnection = $defaultConfig
-            .cl::get<address>(lz::ReceiveEpConfig::receiveMsglibConnectionAddress);
+        cell $defaultConfig = $sanitizeMdExtended.md::ExtendedMd::getObj();
+        receiveMsglibConnection = $defaultConfig.lz::ReceiveEpConfig::getReceiveMsglibConnection();
     }
 
-    int callerMsglibConnectionAddress = $mdExtended
-        .cl::get<address>(md::ExtendedMd::forwardingAddress);
-
     if (receiveMsglibConnection != callerMsglibConnectionAddress) {
         ;; grossly inefficient, but this will (almost) never happen
         ;; so we can optimize the happy path by isolating this logic into this block
-        cell $defaultConfig = $mdExtended.cl::get<objRef>(md::MdObj::obj);
+        cell $defaultConfig = $sanitizeMdExtended.cl::get<objRef>(md::MdObj::obj);
         int timeoutReceiveMsglibConnection = useDefaults
-            ? $defaultConfig
-                .cl::get<address>(lz::ReceiveEpConfig::timeoutReceiveMsglibConnectionAddress)
+            ? $defaultConfig.cl::get<address>(lz::ReceiveEpConfig::timeoutReceiveMsglibConnection)
             : $epConfigOApp.cl::get<address>(lz::EpConfig::timeoutReceiveMsglibConnection);
 
         int expiry = useDefaults
@@ -599,21 +636,21 @@ tuple channelCommitPacket(cell $mdExtended) impure inline method_id {
         }
     }
 
-    int incomingNonce = $packet.cl::get<uint64>(lz::Packet::nonce);
-    cell $commitPOOO = $storage.cl::get<objRef>(Channel::commitPOOO);
+    int incomingNonce = $packet.lz::Packet::getNonce();
 
-    (
-        int isCommittable,
-        _
-    ) = _nonceCommittable(incomingNonce);
+    int isCommittable = _optimizedNonceCommittable(
+        $executePOOO,
+        executionQueue,
+        incomingNonce
+    );
 
     if (isCommittable) {
         setContractStorage(
             $storage
-                .cl::set(Channel::commitPOOO, POOO::set($commitPOOO, incomingNonce))
-                .cl::set(Channel::executionQueue,
+                .Channel::setCommitPOOOAndExecutionQueue(
+                    POOO::set($commitPOOO, incomingNonce),
                     DeterministicInsertionCircularQueue::set(
-                        $storage.cl::get<cellRef>(Channel::executionQueue),
+                        executionQueue,
                         incomingNonce,
                         $packet,
                         ExecutionQueue::committed
@@ -623,7 +660,7 @@ tuple channelCommitPacket(cell $mdExtended) impure inline method_id {
         actions~pushAction<event>(Channel::event::PACKET_COMMITTED, $packet);
     }
 
-    if (incomingNonce <= POOO::maxSettableBit($storage.cl::get<objRef>(Channel::executePOOO))) {
+    if (incomingNonce <= POOO::maxSettableBit($executePOOO)) {
         ;; Cannot respond back to msglib if the packet is not currently committable but
         ;; will be committable in the future
         ;; Caveat: if the packet is currently executing, we treat it as uncommittable.
@@ -636,12 +673,11 @@ tuple channelCommitPacket(cell $mdExtended) impure inline method_id {
             MsglibConnection::OP::MSGLIB_CONNECTION_COMMIT_PACKET_CALLBACK,
             md::ChannelNonceInfo::New(
                 incomingNonce,
-                $storage.cl::get<objRef>(Channel::executePOOO).cl::get<uint64>(POOO::nextEmpty)
+                $storage.Channel::getExecutePOOO().POOO::getNextEmpty()
             )
         );
     }
 
-
     return actions;
 }
 
@@ -656,12 +692,12 @@ tuple channelCommitPacket(cell $mdExtended) impure inline method_id {
 ;; @permissions: permissonless
 tuple lzReceivePrepare(cell $lzReceivePrepareMd) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
-    int nonce = $lzReceivePrepareMd.cl::get<uint64>(md::LzReceivePrepare::nonce);
-    int nanotons = $lzReceivePrepareMd.cl::get<coins>(md::LzReceivePrepare::nanotons);
+
+    (int nonce, int nanotons) = $lzReceivePrepareMd.md::LzReceivePrepare::deserialize();
 
     ;; extract oApp from path
     actions~pushAction<dispatch>(
-        $storage.cl::get<objRef>(Channel::path).cl::get<address>(lz::Path::srcOApp),
+        $storage.Channel::getPath().lz::Path::getSrcOApp(),
         Layerzero::OP::LZ_RECEIVE_PREPARE,
         ;; Throws if the Packet is not executable
         _getExecutablePacket(nonce),
@@ -681,19 +717,21 @@ tuple lzReceivePrepare(cell $lzReceivePrepareMd) impure inline method_id {
 tuple lzReceiveLock(cell $nonceMd) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    int incomingNonce = $nonceMd.cl::get<uint64>(md::Nonce::nonce);
-
+    int incomingNonce = $nonceMd.md::Nonce::getNonce();
     throw_if(Channel::ERROR::invalidNonce, incomingNonce <= 0);
-    cell executionQueue = $storage.cl::get<cellRef>(Channel::executionQueue);
+
+    (
+        cell executionQueue,
+        cell $commitPOOO,
+        cell $path
+    ) = $storage.Channel::getLzReceiveLockInformation();
 
     (int actualKey, cell $packet, int status, _) = DeterministicInsertionCircularQueue::get(
         executionQueue,
         incomingNonce
     );
 
-    int firstUncommittedNonce = getContractStorage()
-        .cl::get<objRef>(Channel::commitPOOO)
-        .cl::get<uint64>(POOO::nextEmpty);
+    int firstUncommittedNonce = $commitPOOO.POOO::getNextEmpty();
 
     ;; executable if present and all preceding nonces are committed, executing, or executed
     if (
@@ -703,8 +741,7 @@ tuple lzReceiveLock(cell $nonceMd) impure inline method_id {
     ) {
         ;; set state to executing
         setContractStorage(
-            $storage.cl::set(
-                Channel::executionQueue,
+            $storage.Channel::setExecutionQueue(
                 DeterministicInsertionCircularQueue::set(
                     executionQueue,
                     incomingNonce,
@@ -715,14 +752,14 @@ tuple lzReceiveLock(cell $nonceMd) impure inline method_id {
         );
 
         actions~pushAction<call>(
-            $storage.cl::get<objRef>(Channel::path).cl::get<address>(lz::Path::srcOApp),
+            $path.lz::Path::getSrcOApp(),
             Layerzero::OP::LZ_RECEIVE_EXECUTE,
-            md::MdObj::New($packet, getInitialStorage())
+            md::MdObj::build($packet, getInitialStorage())
         );
     } else {
         actions~pushAction<event>(
             Channel::event::NOT_EXECUTABLE,
-            md::PacketId::New($storage.cl::get<objRef>(Channel::path), incomingNonce)
+            md::PacketId::New($storage.Channel::getPath(), incomingNonce)
         );
     }
 
@@ -741,8 +778,10 @@ tuple lzReceiveLock(cell $nonceMd) impure inline method_id {
 tuple lzReceiveExecuteCallback(cell $lzReceiveStatus) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    int packetNonce = $lzReceiveStatus.cl::get<uint64>(md::LzReceiveStatus::nonce);
-    cell executionQueue = $storage.cl::get<cellRef>(Channel::executionQueue);
+    (int lzReceiveSuccess, int packetNonce) = $lzReceiveStatus
+        .md::LzReceiveStatus::getSuccessAndNonce();
+    (cell $executePOOO, cell executionQueue, cell $path) = $storage
+        .Channel::getExecutePOOOAndExecutionQueueAndPath();
 
     (int actualKey, cell $packet, int status, _) = DeterministicInsertionCircularQueue::get(
         executionQueue,
@@ -755,18 +794,17 @@ tuple lzReceiveExecuteCallback(cell $lzReceiveStatus) impure inline method_id {
     );
 
     ;; check for success/failure
-    if ($lzReceiveStatus.cl::get<bool>(md::LzReceiveStatus::success)) {
+    if (lzReceiveSuccess) {
         executionQueue = DeterministicInsertionCircularQueue::delete(executionQueue, packetNonce);
 
-        $storage = $storage.cl::set(
-            Channel::executePOOO,
-            POOO::set($storage.cl::get<objRef>(Channel::executePOOO), packetNonce)
+        $storage = $storage.Channel::setExecutePOOO(
+            POOO::set($executePOOO, packetNonce)
         );
 
         ;; emit Packet in the manager
         actions~pushAction<event>(
             Channel::event::DELIVERED,
-            md::PacketId::New($storage.cl::get<objRef>(Channel::path), packetNonce)
+            md::PacketId::build($path, packetNonce)
         );
     } else {
         executionQueue = DeterministicInsertionCircularQueue::set(
@@ -781,18 +819,18 @@ tuple lzReceiveExecuteCallback(cell $lzReceiveStatus) impure inline method_id {
             Channel::event::LZ_RECEIVE_ALERT,
             md::LzReceiveStatus::NewFull(
                 false,
-                packetNonce,
-                $lzReceiveStatus.cl::get<coins>(md::LzReceiveStatus::value),
-                $lzReceiveStatus.cl::get<cellRef>(md::LzReceiveStatus::extraData),
-                $lzReceiveStatus.cl::get<cellRef>(md::LzReceiveStatus::reason),
-                getOrigin(),
-                $packet,
+                packetNonce, ;; unforgeable
+                $lzReceiveStatus.cl::get<coins>(md::LzReceiveStatus::value), ;; can be arbitrary/unsafe
+                $lzReceiveStatus.cl::get<cellRef>(md::LzReceiveStatus::extraData), ;; can be arbitrary/unsafe
+                $lzReceiveStatus.cl::get<cellRef>(md::LzReceiveStatus::reason), ;; can be arbitrary/unsafe
+                getOrigin(), ;; unforgeable
+                $packet, ;; unforgeable
                 ExecutionStatus::executable
             )
         );
     }
 
-    setContractStorage($storage.cl::set(Channel::executionQueue, executionQueue));
+    setContractStorage($storage.Channel::setExecutionQueue(executionQueue));
 
     return actions;
 }
@@ -829,10 +867,13 @@ tuple lzReceiveExecuteCallback(cell $lzReceiveStatus) impure inline method_id {
 tuple nilify(cell $packetId) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell $receivePath = $storage.cl::get<objRef>(Channel::path).lz::Path::optimizedReverse();
-    _assertEqualPaths($receivePath, $packetId.cl::get<objRef>(md::PacketId::path));
+    cell $sanitizedPacketId = $packetId.md::PacketId::sanitize();
+
+    ;; reverse the path because this is from a receive perspective
+    cell $receivePath = $storage.Channel::getPath().lz::Path::optimizedReverse();
+    _assertEqualPaths($receivePath, $sanitizedPacketId.cl::get<objRef>(md::PacketId::path));
 
-    int incomingNonce = $packetId.cl::get<uint64>(md::PacketId::nonce);
+    int incomingNonce = $sanitizedPacketId.cl::get<uint64>(md::PacketId::nonce);
     _assertNonceCommittable(incomingNonce);
 
     (_, cell $previousPacket) = _nonceCommittable(incomingNonce);
@@ -843,7 +884,7 @@ tuple nilify(cell $packetId) impure inline method_id {
         getContractStorage().cl::set(
             Channel::executionQueue,
             DeterministicInsertionCircularQueue::delete(
-                $storage.cl::get<cellRef>(Channel::executionQueue),
+                $storage.Channel::getExecutionQueue(),
                 incomingNonce
             )
         )
@@ -857,7 +898,7 @@ tuple nilify(cell $packetId) impure inline method_id {
     actions~pushAction<call>(
         $receivePath.cl::get<address>(lz::Path::dstOApp),
         Layerzero::OP::NILIFY_CALLBACK,
-        md::MdObj::New($packetId, getInitialStorage())
+        md::MdObj::build($sanitizedPacketId, getInitialStorage())
     );
 
     return actions;
@@ -866,11 +907,13 @@ tuple nilify(cell $packetId) impure inline method_id {
 tuple burn(cell $packetId) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    cell $sanitizedPacketId = $packetId.md::PacketId::sanitize();
+
     ;; reverse the path because this is from a receive perspective
-    cell $receivePath = lz::Path::reverse($storage.cl::get<objRef>(Channel::path));
-    _assertEqualPaths($receivePath, $packetId.cl::get<objRef>(md::PacketId::path));
+    cell $receivePath = lz::Path::reverse($storage.Channel::getPath());
+    _assertEqualPaths($receivePath, $sanitizedPacketId.cl::get<objRef>(md::PacketId::path));
 
-    int nonce = $packetId.cl::get<uint64>(md::PacketId::nonce);
+    int nonce = $sanitizedPacketId.cl::get<uint64>(md::PacketId::nonce);
 
     cell $nonceMd = md::Nonce::New(nonce);
 
@@ -895,11 +938,13 @@ tuple burn(cell $packetId) impure inline method_id {
         $previousPacket
     );
 
-    cell $packetId = md::PacketId::New($receivePath, nonce);
     actions~pushAction<call>(
         $receivePath.cl::get<address>(lz::Path::dstOApp),
         Layerzero::OP::BURN_CALLBACK,
-        md::MdObj::New($packetId, getInitialStorage())
+        md::MdObj::build(
+            md::PacketId::New($receivePath, nonce),
+            getInitialStorage()
+        )
     );
 
     return actions;
@@ -911,15 +956,17 @@ tuple burn(cell $packetId) impure inline method_id {
 tuple depositZro(cell $coinsAmount) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    cell $sanitizedCoinsAmount = $coinsAmount.md::CoinsAmount::sanitize();
+
     setContractStorage(
         $storage.cl::set(
             Channel::zroBalance,
-            $storage.cl::get<coins>(Channel::zroBalance)
-            + $coinsAmount.cl::get<coins>(md::CoinsAmount::amount)
+            $storage.Channel::getZroBalance()
+            + $sanitizedCoinsAmount.cl::get<coins>(md::CoinsAmount::amount)
         )
     );
 
-   actions~pushAction<event>(Channel::event::ZRO_DEPOSITED, $coinsAmount);
+   actions~pushAction<event>(Channel::event::ZRO_DEPOSITED, $sanitizedCoinsAmount);
     
     return actions;
 }
@@ -936,6 +983,8 @@ tuple forceAbort(cell $lzSend) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
     cell $path = $storage.cl::get<objRef>(Channel::path);
+    ;; $lzSend does not need to be sanitized, as it must be correct to match
+    ;; the stored hash
     _assertEqualPaths(
         $path,
         $lzSend
@@ -981,8 +1030,10 @@ tuple forceAbort(cell $lzSend) impure inline method_id {
 tuple syncMsglibConnection(cell $mdAddress) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    cell $sanitizedMdAddress = $mdAddress.md::MdAddress::sanitize();
+
     actions~pushAction<call>(
-        $mdAddress.cl::get<address>(md::MdAddress::address), ;; msglibConnectionAddress
+        $sanitizedMdAddress.cl::get<address>(md::MdAddress::address), ;; msglibConnectionAddress
         MsglibConnection::OP::MSGLIB_CONNECTION_SYNC_CHANNEL_STATE,
         md::MdObj::New(
             md::ChannelNonceInfo::New(
@@ -1003,32 +1054,39 @@ tuple syncMsglibConnection(cell $mdAddress) impure inline method_id {
 tuple notifyPacketExecuted(cell $mdAddress) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell $nonceMd = $mdAddress.cl::get<objRef>(md::MdAddress::md);
+    cell $sanitizedMdAddress = $mdAddress.md::MdAddress::sanitize();
+    cell $sanitizedNonceMd = $sanitizedMdAddress
+        .cl::get<objRef>(md::MdAddress::md)
+        .md::Nonce::sanitize();
 
-    int executionStatus = _viewExecutionStatus($nonceMd.cl::get<uint64>(md::Nonce::nonce));
+    int executionStatus = _viewExecutionStatus($sanitizedNonceMd.cl::get<uint64>(md::Nonce::nonce));
 
     if (executionStatus != ExecutionStatus::executed) {
         return actions;
     }
 
     actions~pushAction<call>(
-        $mdAddress.cl::get<address>(md::MdAddress::address),
+        $sanitizedMdAddress.cl::get<address>(md::MdAddress::address),
         MsglibConnection::OP::MSGLIB_CONNECTION_COMMIT_PACKET_CALLBACK,
         md::ChannelNonceInfo::New(
-            $nonceMd.cl::get<uint64>(md::Nonce::nonce),
+            $sanitizedNonceMd.cl::get<uint64>(md::Nonce::nonce),
             $storage.cl::get<objRef>(Channel::executePOOO).cl::get<uint64>(POOO::nextEmpty)
         )
     );
+
     return actions;
 }
 
 tuple emitLzReceiveAlert(cell $lzReceiveStatus) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
-    int nonce = $lzReceiveStatus.cl::get<uint64>(md::LzReceiveStatus::nonce);
+
+    cell $saniztizedLzReceiveStatus = $lzReceiveStatus.md::LzReceiveStatus::NewFull::sanitize();
+
+    int nonce = $saniztizedLzReceiveStatus.cl::get<uint64>(md::LzReceiveStatus::nonce);
     throw_if(Channel::ERROR::invalidNonce, nonce == 0);
-    int executionStatus = _viewExecutionStatus(nonce);
+    
     (int actualNonce, cell $packet, _, int exists) = DeterministicInsertionCircularQueue::get(
-        $storage.cl::get<cellRef>(Channel::executionQueue),
+        $storage.Channel::getExecutionQueue(),
         nonce
     );
 
@@ -1040,14 +1098,14 @@ tuple emitLzReceiveAlert(cell $lzReceiveStatus) impure inline method_id {
     actions~pushAction<event>(
         Channel::event::LZ_RECEIVE_ALERT,
         md::LzReceiveStatus::NewFull(
-            $lzReceiveStatus.cl::get<bool>(md::LzReceiveStatus::success),
+            $saniztizedLzReceiveStatus.cl::get<bool>(md::LzReceiveStatus::success),
             nonce,
-            $lzReceiveStatus.cl::get<coins>(md::LzReceiveStatus::value),
-            $lzReceiveStatus.cl::get<cellRef>(md::LzReceiveStatus::extraData),
-            $lzReceiveStatus.cl::get<cellRef>(md::LzReceiveStatus::reason),
+            $saniztizedLzReceiveStatus.cl::get<coins>(md::LzReceiveStatus::value),
+            $saniztizedLzReceiveStatus.cl::get<cellRef>(md::LzReceiveStatus::extraData),
+            $saniztizedLzReceiveStatus.cl::get<cellRef>(md::LzReceiveStatus::reason),
             getCaller(),
             $packet,
-            executionStatus
+            _viewExecutionStatus(nonce)
         )
     );
     return actions;