@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.28

package/src/protocol/msglibs/ultralightnode/ulnConnection/handler.fc

@@ -64,21 +64,22 @@ int _getEventSink() impure inline {
     return getOwner();
 }
 
-() assertChannel(cell $md) impure inline {
+() assertChannel() impure inline {
     throw_unless(
         UlnConnection::ERROR::onlyChannel,
-        getCaller() == getContractStorage().cl::get<address>(UlnConnection::channelAddress)
+        getCaller() == getContractStorage().UlnConnection::getChannelAddress()
     );
 }
 
 () assertUln() impure inline {
     throw_unless(
         UlnConnection::ERROR::onlyUln,
-        getCaller() == getContractStorage().cl::get<address>(UlnConnection::ulnAddress)
+        getCaller() == getContractStorage().UlnConnection::getUlnAddress()
     );
 }
 
 int _committable(
+    cell hashlookups,
     int nonce,
     int packetHash,
     cell requiredDVNs,
@@ -86,8 +87,6 @@ int _committable(
     int optionalDVNThreshold,
     int requiredConfirmations
 ) impure inline {
-    cell $storage = getContractStorage();
-
     slice requiredDVNsSlice = requiredDVNs.begin_parse();
     ;; iterate through each of the required DVNs
 
@@ -95,16 +94,18 @@ int _committable(
 
     while (dvnAddress > NULLADDRESS) {
         cell $attestation = UlnConnection::utils::getHashLookup(
-            $storage,
+            hashlookups,
             nonce,
             dvnAddress
         );
         if ($attestation.cl::isNullObject()) {
             return false;
         }
+        
+        (int hash, int confirmations) = $attestation.lz::Attestation::deserialize();
         if (
-            ($attestation.cl::get<uint64>(lz::Attestation::confirmations) < requiredConfirmations)
-            | ($attestation.cl::get<uint256>(lz::Attestation::hash) != packetHash)
+            (confirmations < requiredConfirmations)
+            | (hash != packetHash)
         ) {
             return false;
         }
@@ -113,21 +114,24 @@ int _committable(
 
     int optionalDVNAttestations = 0;
 
+    if (optionalDVNThreshold == 0) {
+        ;; Short-circuit for the common case of 0 optional DVN
+        return true;
+    }
+
     slice optionalDVNsSlice = optionalDVNs.begin_parse();
     dvnAddress = optionalDVNsSlice~AddressList::next();
     while ((dvnAddress > NULLADDRESS) & (optionalDVNAttestations < optionalDVNThreshold)) {
         cell $attestation = UlnConnection::utils::getHashLookup(
-            $storage,
+            hashlookups,
             nonce,
             dvnAddress
         );
 
         ;; Nested if, else case is simply to do nothing
         ifnot ($attestation.cl::isNullObject()) {
-            if (
-                ($attestation.cl::get<uint64>(lz::Attestation::confirmations) >= requiredConfirmations)
-                & ($attestation.cl::get<uint256>(lz::Attestation::hash) == packetHash)
-            ) {
+            (int hash, int confirmations) = $attestation.lz::Attestation::deserialize();
+            if ((confirmations >= requiredConfirmations) & (hash == packetHash)) {
                 optionalDVNAttestations += 1;
             }
         }
@@ -144,8 +148,7 @@ int _committable(
 }
 
 int committableView(int nonce, cell $packet, cell $defaultUlnReceiveConfig) impure method_id {
-    int firstUnexecutedNonce = getContractStorage()
-        .cl::get<uint64>(UlnConnection::firstUnexecutedNonce);
+    int firstUnexecutedNonce = getContractStorage().cl::get<uint64>(UlnConnection::firstUnexecutedNonce);
     if (nonce < firstUnexecutedNonce) {
         return UlnConnection::verificationStatus::EXECUTED;
     }
@@ -176,7 +179,10 @@ int committableView(int nonce, cell $packet, cell $defaultUlnReceiveConfig) impu
         return UlnConnection::verificationStatus::CONFIGURATION_ERROR;
     }
 
+    cell hashLookups = getContractStorage().cl::get<dict256>(UlnConnection::hashLookups);
+
     if (_committable(
+        hashLookups,
         nonce,
         $packet.cl::hash(),
         requiredDVNs,
@@ -190,8 +196,9 @@ int committableView(int nonce, cell $packet, cell $defaultUlnReceiveConfig) impu
 }
 
 int verifiedView(int dvnAddress, int nonce, int packetHash, int requiredConfirmations) impure method_id {
+    cell hashLookups = getContractStorage().cl::get<dict256>(UlnConnection::hashLookups);
     cell $attestation = UlnConnection::utils::getHashLookup(
-        getContractStorage(),
+        hashLookups,
         nonce,
         dvnAddress
     );
@@ -214,10 +221,7 @@ int _dvnIsRequiredOrOptional(slice requiredDVNsSlice, slice optionalDVNsSlice, i
     return AddressList::includes(dvnAddress, optionalDVNsSlice);
 }
 
-int _isDvnConfigured(int dvnAddress, cell $defaultUlnReceiveConfigOApp) impure inline {
-    cell $customUlnReceiveConfigOApp = getContractStorage()
-        .cl::get<objRef>(UlnConnection::UlnReceiveConfigOApp);
-
+int _isDvnConfigured(int dvnAddress, cell $customUlnReceiveConfigOApp, cell $defaultUlnReceiveConfigOApp) impure inline {
     (cell requiredDVNs, cell optionalDVNs, int isValid) = UlnReceiveConfig::utils::getVerifyConfig(
         $customUlnReceiveConfigOApp,
         $defaultUlnReceiveConfigOApp
@@ -240,7 +244,7 @@ int _isDvnConfigured(int dvnAddress, cell $defaultUlnReceiveConfigOApp) impure i
         (op == MsglibConnection::OP::MSGLIB_CONNECTION_SEND)
         | (op == MsglibConnection::OP::MSGLIB_CONNECTION_COMMIT_PACKET_CALLBACK)
     ) {
-        return assertChannel($md);
+        return assertChannel();
     } elseif (
         (op == UlnConnection::OP::ULN_CONNECTION_VERIFY)
         | (op == UlnConnection::OP::ULN_CONNECTION_COMMIT_PACKET)
@@ -253,7 +257,7 @@ int _isDvnConfigured(int dvnAddress, cell $defaultUlnReceiveConfigOApp) impure i
     } elseif (op == UlnConnection::OP::GARBAGE_COLLECT_INVALID_ATTESTATIONS){
         return assertUln();
     } elseif (op == MsglibConnection::OP::MSGLIB_CONNECTION_SYNC_CHANNEL_STATE) {
-        return assertChannel($md);
+        return assertChannel();
     } elseif (
         (op == UlnConnection::OP::SET_OAPP_ULN_SEND_CONFIG)
         | (op == UlnConnection::OP::SET_OAPP_ULN_RECEIVE_CONFIG)
@@ -292,14 +296,20 @@ tuple msglibConnectionQuote(cell $lzSend) impure inline method_id {
 tuple msglibConnectionSend(cell $lzSend) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    (
+        int ulnAddress,
+        int channelAddress,
+        cell $ulnSendConfigOApp
+    ) = $storage.UlnConnection::getSendInformation();
+
     actions~pushAction<call>(
-        $storage.cl::get<address>(UlnConnection::ulnAddress),
+        ulnAddress,
         Uln::OP::ULN_SEND,
-        md::UlnSend::New(
+        md::UlnSend::build(
             $lzSend,
-            $storage.cl::get<objRef>(UlnConnection::UlnSendConfigOApp),
+            $ulnSendConfigOApp,
             getInitialStorage(),
-            $storage.cl::get<address>(UlnConnection::channelAddress)
+            channelAddress
         )
     );
 
@@ -311,13 +321,24 @@ tuple msglibConnectionSend(cell $lzSend) impure inline method_id {
 tuple ulnConnectionVerify(cell $extendedMd) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    int dvnAddress = $extendedMd.cl::get<address>(md::ExtendedMd::forwardingAddress);
-    cell $defaultUlnReceiveConfigOApp = $extendedMd.cl::get<objRef>(md::ExtendedMd::obj);
-    cell $ulnVerification = $extendedMd.cl::get<objRef>(md::ExtendedMd::md);
+    cell $sanitizedExtendedMd = $extendedMd.md::ExtendedMd::sanitize();
 
-    int nonce = $ulnVerification.cl::get<uint64>(md::UlnVerification::nonce);
+    (
+        cell $ulnVerification,
+        cell $defaultUlnReceiveConfigOApp,
+        int dvnAddress
+    ) = $sanitizedExtendedMd.md::ExtendedMd::deserialize();
 
-    int firstUnexecutedNonce = $storage.cl::get<uint64>(UlnConnection::firstUnexecutedNonce);
+    (
+        int nonce,
+        cell $attestation
+    ) = $ulnVerification.md::UlnVerification::deserialize();
+
+    (
+        int firstUnexecutedNonce,
+        cell hashLookups,
+        cell $ulnReceiveConfigOApp
+    ) = $storage.UlnConnection::getVerifyInformation();
 
     ;; assume success unless something fails in the verification logic
     int statusCode = UlnConnection::ULN_CONNECTION_VERIFY_SUCCEEDED;
@@ -329,16 +350,16 @@ tuple ulnConnectionVerify(cell $extendedMd) impure inline method_id {
         ;; if the nonce has already been executed, or if it is invalid (== 0),
         ;; do not allow verification of the packet
         statusCode = UlnConnection::ULN_CONNECTION_VERIFY_FAILED::NONCE_OUT_OF_RANGE;
-    } elseifnot (_isDvnConfigured(dvnAddress, $defaultUlnReceiveConfigOApp)) {
+    } elseifnot (_isDvnConfigured(dvnAddress, $ulnReceiveConfigOApp, $defaultUlnReceiveConfigOApp)) {
         statusCode = UlnConnection::ULN_CONNECTION_VERIFY_FAILED::DVN_NOT_CONFIGURED;
     } else {
-        cell $attestation = $ulnVerification.cl::get<objRef>(md::UlnVerification::attestation);
         ;; Ensure the DVN is not passing a malicious attestation that is bigger than expected
         lz::Attestation::validate($attestation);
 
         setContractStorage(
             UlnConnection::utils::setHashLookup(
                 $storage,
+                hashLookups,
                 nonce,
                 dvnAddress,
                 $attestation
@@ -353,8 +374,8 @@ tuple ulnConnectionVerify(cell $extendedMd) impure inline method_id {
     actions~pushAction<call>(
         dvnAddress,
         UltraLightNode::OP::ULN_CONNECTION_VERIFY_CALLBACK,
-        md::MdObj::New(
-            md::VerificationStatus::New(nonce, statusCode),
+        md::MdObj::build(
+            md::VerificationStatus::build(nonce, statusCode),
             getInitialStorage()
         )
     );
@@ -366,10 +387,12 @@ tuple ulnConnectionVerify(cell $extendedMd) impure inline method_id {
 tuple garbageCollectInvalidAttestations(cell $mdObj) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell $mdNonce = $mdObj.cl::get<objRef>(md::MdObj::md);
+    cell $sanitizedMdObj = md::MdObj::sanitize($mdObj);
+
+    cell $mdNonce = $sanitizedMdObj.cl::get<objRef>(md::MdObj::md).md::Nonce::sanitize();
     int nonce = $mdNonce.cl::get<uint64>(md::Nonce::nonce);
 
-    cell $defaultUlnReceiveConfigOApp = $mdObj.cl::get<objRef>(md::MdObj::obj);
+    cell $defaultUlnReceiveConfigOApp = $sanitizedMdObj.cl::get<objRef>(md::MdObj::obj);
 
     cell $customUlnReceiveConfigOApp = $storage.cl::get<objRef>(UlnConnection::UlnReceiveConfigOApp);
     (cell requiredDVNs, cell optionalDVNs, int isValid) = UlnReceiveConfig::utils::getVerifyConfig(
@@ -388,15 +411,18 @@ tuple garbageCollectInvalidAttestations(cell $mdObj) impure inline method_id {
         $mdNonce
     );
 
-    cell $newStorage = UlnConnection::utils::deleteNonceAttestations($storage, nonce);
+    cell hashLookups = $storage.cl::get<dict256>(UlnConnection::hashLookups);
+
+    cell $newStorage = UlnConnection::utils::deleteNonceAttestations($storage, hashLookups, nonce);
 
     ;; iterate the required DVNs
     int requiredDVNAddress = requiredDVNsSlice~AddressList::next();
     while (requiredDVNAddress > NULLADDRESS) {
-        cell $attestation = UlnConnection::utils::getHashLookup($storage, nonce, requiredDVNAddress);
+        cell $attestation = UlnConnection::utils::getHashLookup(hashLookups, nonce, requiredDVNAddress);
         ifnot (cl::isNullObject($attestation)) {
             $newStorage = UlnConnection::utils::setHashLookup(
                 $newStorage,
+                hashLookups,
                 nonce,
                 requiredDVNAddress,
                 $attestation
@@ -407,10 +433,11 @@ tuple garbageCollectInvalidAttestations(cell $mdObj) impure inline method_id {
 
    int optionalDVNAddress = optionalDVNsSlice~AddressList::next();
     while (optionalDVNAddress > NULLADDRESS) {
-        cell $attestation = UlnConnection::utils::getHashLookup($storage, nonce, optionalDVNAddress);
+        cell $attestation = UlnConnection::utils::getHashLookup(hashLookups, nonce, optionalDVNAddress);
         ifnot (cl::isNullObject($attestation)) {
             $newStorage = UlnConnection::utils::setHashLookup(
                 $newStorage,
+                hashLookups,
                 nonce,
                 optionalDVNAddress,
                 $attestation
@@ -434,7 +461,7 @@ tuple garbageCollectExecutedNonces(cell $empty) impure inline method_id {
 
     if ((minNonce > 0) & (minNonce < firstUnexecutedNonce)) {
         setContractStorage(
-            UlnConnection::utils::deleteNonceAttestations($storage, minNonce)
+            UlnConnection::utils::deleteNonceAttestations($storage, hashLookups, minNonce)
         );
         actions~pushAction<call>(
             getContractAddress(),
@@ -451,11 +478,15 @@ tuple garbageCollectExecutedNonces(cell $empty) impure inline method_id {
 tuple ulnConnectionCommitPacket(cell $mdObj) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell $packet = $mdObj.cl::get<objRef>(md::MdObj::md);
+    (cell $packet, cell $defaultUlnReceiveConfig) = $mdObj.md::MdObj::deserialize();
     int packetHash = $packet.cl::hash();
-    int nonce = $packet.cl::get<uint64>(lz::Packet::nonce);
+    int nonce = $packet.lz::Packet::getNonce();
 
-    cell $defaultUlnReceiveConfig = $mdObj.cl::get<objRef>(md::MdObj::obj);
+    (
+        int endpointAddress, 
+        cell $ulnReceiveConfigOApp,
+        cell hashLookups
+    ) = $storage.UlnConnection::getCommitPacketInformation();
 
     (
         cell requiredDVNs,
@@ -465,7 +496,7 @@ tuple ulnConnectionCommitPacket(cell $mdObj) impure inline method_id {
         int commitPacketGas,
         int isValid
     ) = UlnReceiveConfig::utils::getCommitConfig(
-        $storage.cl::get<objRef>(UlnConnection::UlnReceiveConfigOApp),
+        $ulnReceiveConfigOApp,
         $defaultUlnReceiveConfig
     );
 
@@ -474,8 +505,10 @@ tuple ulnConnectionCommitPacket(cell $mdObj) impure inline method_id {
     }
 
     ifnot (
-        _committable(nonce,packetHash, requiredDVNs, optionalDVNs, optionalDVNThreshold, requiredConfirmations)
-        & ((getMsgValue() - _gasToNanoton(get_gas_consumed())) >= _gasToNanoton(commitPacketGas))
+        _committable(hashLookups, nonce, packetHash, requiredDVNs, optionalDVNs, optionalDVNThreshold, requiredConfirmations)
+        & (
+            (getMsgValue() - _gasToNanoton(get_gas_consumed())) >= _gasToNanoton(commitPacketGas)
+        )
     ) {
         return actions;
     }
@@ -483,7 +516,7 @@ tuple ulnConnectionCommitPacket(cell $mdObj) impure inline method_id {
     ;; If all above checks pass (no early return)
     ;; commit the packet to the endpoint
     actions~pushAction<call>(
-        $storage.cl::get<address>(UlnConnection::endpointAddress),
+        endpointAddress,
         Endpoint::OP::ENDPOINT_COMMIT_PACKET,
         $packet
     );
@@ -495,27 +528,15 @@ tuple ulnConnectionCommitPacket(cell $mdObj) impure inline method_id {
 tuple msglibConnectionCommitPacketCallback(cell $channelNonceInfo) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    int committedNonce = $channelNonceInfo.cl::get<uint64>(md::ChannelNonceInfo::nonce);
-    ;; invariant:
-    ;; firstUnexecutedNonce >= $storage.cl::get<uint64>(UlnConnection::firstUnexecutedNonce)
-    int firstUnexecutedNonce = $channelNonceInfo
-        .cl::get<uint64>(md::ChannelNonceInfo::firstUnexecutedNonce);
+    (int committedNonce, int firstUnexecutedNonce) = $channelNonceInfo.md::ChannelNonceInfo::deserialize();
 
-    cell $commitPOOO = $storage.cl::get<objRef>(UlnConnection::commitPOOO);
+    cell $commitPOOO = $storage.UlnConnection::getCommitPOOO();
     if (committedNonce <= POOO::maxSettableBit($commitPOOO)) {
         $commitPOOO = POOO::set($commitPOOO, committedNonce);
     }
+
     setContractStorage(
-        $storage
-            .UlnConnection::utils::deleteNonceAttestations(committedNonce)
-            .cl::set(
-                UlnConnection::firstUnexecutedNonce,
-                firstUnexecutedNonce
-            )
-            .cl::set(
-                UlnConnection::commitPOOO,
-                $commitPOOO
-            )
+        $storage.UlnConnection::updateCommittmentInfo(committedNonce, firstUnexecutedNonce, $commitPOOO)
     );
     
     return actions;
@@ -524,11 +545,16 @@ tuple msglibConnectionCommitPacketCallback(cell $channelNonceInfo) impure inline
 ;; only channel
 tuple msglibConnectionSyncChannelState(cell $channelNonceInfo) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
+
+    cell $sanitizedChannelNonceInfo = md::ChannelNonceInfo::sanitize($channelNonceInfo);
+    
     ;; invariant:
     ;; firstUnexecutedNonce >= $storage.cl::get<uint64>(UlnConnection::firstUnexecutedNonce)
-    int firstUnexecutedNonce = $channelNonceInfo
+    int firstUnexecutedNonce = $sanitizedChannelNonceInfo
         .cl::get<uint64>(md::ChannelNonceInfo::firstUnexecutedNonce);
-    int firstUncommittedNonce = $channelNonceInfo.cl::get<uint64>(md::ChannelNonceInfo::nonce);
+    int firstUncommittedNonce = $sanitizedChannelNonceInfo
+        .cl::get<uint64>(md::ChannelNonceInfo::nonce);
+    
     cell $commitPOOO = $storage.cl::get<objRef>(UlnConnection::commitPOOO);
     int maxNonce = POOO::maxSettableBit($commitPOOO);
 

package/src/protocol/msglibs/ultralightnode/ulnConnection/storage.fc

@@ -16,17 +16,17 @@ const int UlnConnection::path = 1;
 ;; the channel address is set during the initialize call
 const int UlnConnection::endpointAddress = 2;
 const int UlnConnection::channelAddress = 3;
-const int UlnConnection::ulnAddress = 4;
+const int UlnConnection::firstUnexecutedNonce = 4; ;; first nonce that has not been executed
+const int UlnConnection::ulnAddress = 5;
 
 ;; EVM struct ExecutorConfig
 ;; uint32 maxMessageSize;
 ;; address executor;
-const int UlnConnection::UlnSendConfigOApp = 5; ;; UlnSendConfig
-const int UlnConnection::UlnReceiveConfigOApp = 6; ;; UlnReceiveConfig
+const int UlnConnection::UlnSendConfigOApp = 6; ;; UlnSendConfig
+const int UlnConnection::UlnReceiveConfigOApp = 7; ;; UlnReceiveConfig
 ;; breaking from EVM, we are using a fixed size array for the DVN verifications, and DVNs can
 ;; only verify a packet for a specific inbound nonce range.
-const int UlnConnection::hashLookups = 7; ;; map nonce -> map dvnAddress -> {hash,confirmations}
-const int UlnConnection::firstUnexecutedNonce = 8; ;; first nonce that has not been executed
+const int UlnConnection::hashLookups = 8; ;; map nonce -> map dvnAddress -> {hash,confirmations}
 const int UlnConnection::commitPOOO = 9;
 
 ;; @owner ulnManager
@@ -38,12 +38,119 @@ cell UlnConnection::New(int owner, cell $path, int ulnAddress) method_id {
             [cl::t::objRef, $path],                               ;; UlnConnection::path
             [cl::t::address, NULLADDRESS],                        ;; UlnConnection::endpointAddress
             [cl::t::address, NULLADDRESS],                        ;; UlnConnection::channelAddress
+            [cl::t::uint64, 1],                                   ;; UlnConnection::firstUnexecutedNonce
             [cl::t::address, ulnAddress],                         ;; UlnConnection::ulnAddress
             [cl::t::objRef, UlnSendConfig::NewWithDefaults()],    ;; UlnConnection::UlnSendConfigOApp
             [cl::t::objRef, UlnReceiveConfig::NewWithDefaults()], ;; UlnConnection::UlnReceiveConfigOApp
             [cl::t::dict256, cl::dict256::New()],                 ;; UlnConnection::hashLookups
-            [cl::t::uint64, 1],                                   ;; UlnConnection::firstUnexecutedNonce
             [cl::t::objRef, empty_cell()]                         ;; UlnConnection::commitPOOO
         ])
     );
+}
+
+;; ====================== Storage Accessors =====================
+
+
+const int UlnConnection::_endpointAddressOffset = _HEADER_WIDTH;
+const int UlnConnection::_channelAddressOffset = UlnConnection::_endpointAddressOffset + 256;
+const int UlnConnection::_firstUnexecutedNonceOffset = UlnConnection::_channelAddressOffset + 256;
+const int UlnConnection::_rootSliceBits = UlnConnection::_firstUnexecutedNonceOffset + 64;
+
+const int UlnConnection::_ulnAddressOffset = 0;
+
+cell UlnConnection::getBaseStorage(cell $self) impure inline {
+    return $self.cellPreloadRefAt(0);
+}
+
+int UlnConnection::getChannelAddress(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(UlnConnection::_channelAddressOffset);
+}
+
+int UlnConnection::getUlnAddress(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadAddressAt(UlnConnection::_ulnAddressOffset);
+}
+
+cell UlnConnection::getCommitPOOO(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(3);
+}
+
+;; ====================== Composite Storage Accessors =====================
+
+;; (ulnAddress, channelAddress, ulnSendConfigOApp)
+(int, int, cell) UlnConnection::getSendInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2_slice = selfSlice.preloadRefSliceAt(2);
+    return (
+        ref2_slice.preloadAddressAt(UlnConnection::_ulnAddressOffset),
+        selfSlice.preloadAddressAt(UlnConnection::_channelAddressOffset),
+        ref2_slice.preloadRefAt(0)
+    );
+}
+
+;; (firstUnexecutedNonce, hashLookups, ulnReceiveConfigOApp)
+(int, cell, cell) UlnConnection::getVerifyInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2Slice = selfSlice.preloadRefSliceAt(2);
+
+    return (
+        selfSlice.preloadUint64At(UlnConnection::_firstUnexecutedNonceOffset),
+        ref2Slice.preloadRefAt(2),
+        ref2Slice.preloadRefAt(1)
+    );
+}
+
+;; (endpointAddress, ulnReceiveConfigOApp, hashLookups)
+(int, cell, cell) UlnConnection::getCommitPacketInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2Slice = selfSlice.preloadRefSliceAt(2);
+    return (
+        selfSlice.preloadAddressAt(UlnConnection::_endpointAddressOffset),
+        ref2Slice.preloadRefAt(1),
+        ref2Slice.preloadRefAt(2)
+    );
+}
+
+;; ====================== Storage Modifiers =====================
+
+
+cell UlnConnection::updateCommittmentInfo(
+    cell $self,
+    int committedNonce,
+    int firstUnexecutedNonce,
+    cell $commitPOOO
+) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    slice ref2Slice = selfSlice.preloadRefSliceAt(2);
+
+    cell hashLookups = ref2Slice.preloadRefAt(2).cl::dict256::delete(committedNonce);
+
+    cell new_ref2 = begin_cell()
+        .store_slice(ref2Slice.scutfirst(256, 2))
+        .store_ref(hashLookups)
+        .store_ref($commitPOOO)
+        .end_cell();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(UlnConnection::_firstUnexecutedNonceOffset, 2))
+        .store_uint64(firstUnexecutedNonce)
+        .store_ref(new_ref2)
+        .end_cell();
+}
+
+cell UlnConnection::setHashLookups(cell $self, cell $hashLookups) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    slice originalStructuralCellSlice = selfSlice.preloadRefSliceAt(2);
+
+    cell newStructuralCell = begin_cell()
+        .store_slice(originalStructuralCellSlice.scutfirst(256, 2))
+        .store_ref($hashLookups)
+        .store_ref(originalStructuralCellSlice.preloadRefAt(3))
+        .end_cell();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(UlnConnection::_rootSliceBits, 2))
+        .store_ref(newStructuralCell)
+        .end_cell();
 }

package/src/protocol/msglibs/ultralightnode/ulnConnection/utils.fc

@@ -1,4 +1,5 @@
 #include "interface.fc";
+#include "storage.fc";
 
 #include "../msgdata/Attestation.fc";
 #include "../msgdata/UlnReceiveConfig.fc";
@@ -6,9 +7,7 @@
 
 ;;; ===============================GETTERS===========================
 
-cell UlnConnection::utils::getHashLookup(cell $self, int nonce, int dvnAddress) impure inline {
-    cell hashLookups = $self.cl::get<dict256>(UlnConnection::hashLookups);
-    
+cell UlnConnection::utils::getHashLookup(cell hashLookups, int nonce, int dvnAddress) impure inline {
     (cell addressLookup, int exists) = hashLookups.cl::dict256::get<cellRef>(nonce);
     ifnot (exists) {
         return cl::nullObject();
@@ -26,11 +25,11 @@ cell UlnConnection::utils::getHashLookup(cell $self, int nonce, int dvnAddress)
 
 cell UlnConnection::utils::setHashLookup(
     cell $self,
+    cell hashLookups,
     int nonce,
     int dvnAddress,
     cell $attestation
 ) impure inline {
-    cell hashLookups = $self.cl::get<dict256>(UlnConnection::hashLookups);
     (cell addressLookup, int exists) = hashLookups.cl::dict256::get<cellRef>(nonce);
 
     ifnot (exists) {
@@ -41,97 +40,13 @@ cell UlnConnection::utils::setHashLookup(
     addressLookup = addressLookup.cl::dict256::setRef(dvnAddress, $attestation);
 
     ;; save the attestation hash
-    return $self.cl::set(
-        UlnConnection::hashLookups,
+    return $self.UlnConnection::setHashLookups(
         hashLookups.cl::dict256::setRef(nonce, addressLookup)
     );
 }
 
-cell UlnConnection::utils::deleteNonceAttestations(cell $self, int nonce) impure inline {
-    cell hashLookups = $self.cl::get<dict256>(UlnConnection::hashLookups);
+cell UlnConnection::utils::deleteNonceAttestations(cell $self, cell hashLookups, int nonce) impure inline {
     ;; delete is safe to call on a non-existent key
     hashLookups = hashLookups.cl::dict256::delete(nonce);
-    return $self.cl::set(
-        UlnConnection::hashLookups,
-        hashLookups
-    );
-}
-
-;;; ===============================CHECKERS===========================
-
-;; returns true if the attestations are valid (meets the dvn threshold and confirmations)
-int UlnConnection::utils::isCommittable(
-    cell $self,
-    cell $defaultUlnReceiveConfig,
-    int nonce,
-    int hash
-) impure inline {
-    cell hashLookups = $self.cl::get<dict256>(UlnConnection::hashLookups);
-    (cell addressLookup, int exists) = hashLookups.cl::dict256::get<cellRef>(nonce);
-    ifnot (exists) {
-        return false;
-    }
-
-    ;; retrieve the DVNs from the config
-    (
-        cell requiredDVNs,
-        cell optionalDVNs,
-        int optionalDVNThreshold,
-        int requiredConfirmations,
-        _,
-        int isValid
-    ) = UlnReceiveConfig::utils::getCommitConfig(
-        $self.cl::get<objRef>(UlnConnection::UlnReceiveConfigOApp),
-        $defaultUlnReceiveConfig
-    );
-
-    ifnot (isValid) {
-        return false;
-    }
-
-    slice requiredDVNsSlice = requiredDVNs.begin_parse();
-    ;; iterate the requiredDVNs and make sure each has set the proper hash and confirmations
-    int address = requiredDVNsSlice~AddressList::next();
-    while (address > NULLADDRESS) {
-        (cell $attestation, int exists) = addressLookup.cl::dict256::get<cellRef>(address);
-        ;; if it doesn't exist it means we don't have the required DVN's attestation
-        ifnot (exists) {
-            return false;
-        } elseifnot ($attestation.lz::Attestation::confirmable(hash, requiredConfirmations)) {
-            ;; attestation hash...
-            ;; (1) doesn't match the hash passed in
-            ;; OR (2) the attestation confirmations are fewer than the required confirmations
-            return false;
-        }
-        address = requiredDVNsSlice~AddressList::next();
-    }
-
-    if (optionalDVNThreshold == 0) {
-        ;; if we don't have any optional DVNs, we're done
-        return true;
-    }
-
-    slice optionalDVNsSlice = optionalDVNs.begin_parse();
-    ;; iterate the optionalDVNs and make sure each has set the proper hash and confirmations
-    int address = optionalDVNsSlice~AddressList::next();
-    int count = 0;
-
-    while (address > NULLADDRESS) {
-        (cell $attestation, int attestationExists) = addressLookup.cl::dict256::get<cellRef>(address);
-        ;; if the attestation matches the hash and is greater than or equal to the confirmations
-        ;; we're looking for, increment the counter
-        if (attestationExists) {
-            if ($attestation.lz::Attestation::confirmable(hash, requiredConfirmations)) {
-                count = count + 1;
-            }
-            if (count == optionalDVNThreshold) {
-                ;; early exit if we hit the optional DVN threshold
-                return true;
-            }
-        }
-        address = optionalDVNsSlice~AddressList::next();
-    }
-
-    ;; threshold not met, return false
-    return false;
+    return $self.UlnConnection::setHashLookups(hashLookups);
 }