@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.28

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

@@ -1,5 +1,6 @@
 #include "../../BytesEncoder.fc";
 
+
 #include "../feeLibInterface.fc";
 #include "../feeLibUtils.fc";
 
@@ -64,14 +65,12 @@ int _getEventSink() impure {
 }
 
 () assertConnection(cell $ulnSendMd) impure inline {
-    cell connectionCode = getContractStorage().cl::get<cellRef>(Uln::connectionCode);
+    cell connectionCode = getContractStorage().Uln::getConnectionCode();
 
-    cell $connectionInitialStorage = $ulnSendMd
-        .cl::get<objRef>(md::UlnSend::connectionInitialStorage);
+    cell $connectionInitialStorage = $ulnSendMd.md::UlnSend::getConnectionInitialStorage();
 
-    int providedUlnManagerAddress = $connectionInitialStorage
-        .cl::get<objRef>(BASE_STORAGE_INDEX)
-        .cl::get<address>(BaseStorage::owner);
+    int providedUlnManagerAddress =
+        UlnConnection::getBaseStorage($connectionInitialStorage).BaseStorage::getOwner();
 
     ;; By construction, if the bytecode is valid and the uln manager address is correct,
     ;; then the uln address cannot be incorrect (assuming no bug in the ULN connection bytecode).
@@ -99,11 +98,12 @@ cell _failedMsglibSendCallback(cell $lzSend) impure inline {
 }
 
 cell _quote(cell $ulnSendMd, cell $storage) impure inline {
-    cell $lzSend = $ulnSendMd.cl::get<objRef>(md::UlnSend::lzSend);
+    (
+        cell $lzSend,
+        cell $customUlnSendConfig
+    ) = $ulnSendMd.md::UlnSend::getLzSendAndCustomUlnSendConfig();
 
-    int ownerAddress = $storage
-        .cl::get<objRef>(BASE_STORAGE_INDEX)
-        .cl::get<address>(BaseStorage::owner);
+    cell $defaultUlnSendConfig = $storage.Uln::getDefaultUlnSendConfig();
 
     (
         int quoteGasLimit,
@@ -114,18 +114,21 @@ cell _quote(cell $ulnSendMd, cell $storage) impure inline {
         int confirmations,
         int isValid
     ) = lz::UlnSendConfig::resolveUlnSendConfig(
-        $ulnSendMd.cl::get<objRef>(md::UlnSend::customUlnSendConfig),
-        $storage.cl::get<objRef>(Uln::defaultUlnSendConfig)
+        $customUlnSendConfig,
+        $defaultUlnSendConfig
     );
 
     ifnot (isValid) {
-        return md::MdAddress::New(
-            _failedMsglibSendCallback($lzSend),
-            ownerAddress
-        );
+        return _failedMsglibSendCallback($lzSend);
     }
 
-    int messageBytes = lz::Packet::_messageBytes($lzSend.cl::get<objRef>(md::LzSend::packet));
+    (
+        cell $packet,
+        cell $extraOptions,
+        cell $enforcedOptions
+    ) = $lzSend.md::LzSend::getQuoteInformation();
+
+    int messageBytes = lz::Packet::_messageBytes($packet);
 
     tuple returnStack = unsafeTuple([null()]);
 
@@ -139,8 +142,8 @@ cell _quote(cell $ulnSendMd, cell $storage) impure inline {
                 optionalDVNs,
                 confirmations,
                 messageBytes,
-                $lzSend.cl::get<objRef>(md::LzSend::extraOptions),
-                $lzSend.cl::get<objRef>(md::LzSend::enforcedOptions)
+                $extraOptions,
+                $enforcedOptions
             ]),
             _quoteWorkersMethodId,
             1,
@@ -151,16 +154,10 @@ cell _quote(cell $ulnSendMd, cell $storage) impure inline {
 
     cell $msglibSendCallback = returnStack.cell_at(0);
     ifnot ($msglibSendCallback.is_cell()) {
-        return md::MdAddress::New(
-            _failedMsglibSendCallback($lzSend),
-            ownerAddress
-        );
+        return _failedMsglibSendCallback($lzSend);
     }
 
-    return md::MdAddress::New(
-        $msglibSendCallback,
-        ownerAddress
-    );
+    return $msglibSendCallback;
 }
 
 ;; caller is responsible for asserting the worker exists
@@ -183,23 +180,22 @@ cell _removeWorker(cell $storage, cell $workerFeelibInfo) impure inline {
     cell $extraOptions,
     cell $enforcedOptions
 ) impure inline_ref method_id {
-    (cell $workerInfo, int workerExists) = $storage.cl::nestedDict256::get<cellRef>(
-        Uln::workerFeelibInfos,
-        workerAddress
-    );
+    cell $workerFeelibInfos = $storage.Uln::getWorkerFeelibInfos();
+
+    (cell $workerInfo, int workerExists) = $workerFeelibInfos.cl::dict256::get<cellRef>(workerAddress);
     ifnot (workerExists) {
         return (-1, null());
     }
 
+    (   int friendWorkerAddress,
+        cell $workerFeelibStorage,
+        cell workerFeelibBytecode
+    ) = $workerInfo.UlnWorkerFeelibInfo::getQuoteWorkerInformation();
+
     (cell $friendInfo, int friendExists) = ($workerInfo, true);
-    int friendWorkerAddress = $workerInfo
-        .cl::get<address>(UlnWorkerFeelibInfo::friendWorkerAddress);
 
     ifnot (friendWorkerAddress == NULLADDRESS) {
-        ($friendInfo, friendExists) = $storage.cl::nestedDict256::get<cellRef>(
-            Uln::workerFeelibInfos,
-            friendWorkerAddress
-        );
+        ($friendInfo, friendExists) = $workerFeelibInfos.cl::dict256::get<cellRef>(friendWorkerAddress);
     }
     ifnot (friendExists) {
         return (-1, null());
@@ -208,7 +204,7 @@ cell _removeWorker(cell $storage, cell $workerFeelibInfo) impure inline {
     tuple returnStack = safePackedInputsRunVm(
         unsafeTuple(
             [
-                $workerInfo.cl::get<objRef>(UlnWorkerFeelibInfo::workerFeelibStorage),
+                $workerFeelibStorage,
                 $friendInfo,
                 $path,
                 confirmations,
@@ -219,7 +215,7 @@ cell _removeWorker(cell $storage, cell $workerFeelibInfo) impure inline {
         ),
         UlnWorkerInterface::quote,
         1,
-        $workerInfo.cl::get<cellRef>(UlnWorkerFeelibInfo::workerFeelibBytecode).begin_parse(),
+        workerFeelibBytecode.begin_parse(),
         MAX_U32 ;; gas limit doesn't matter for the inner call
     );
 
@@ -267,8 +263,8 @@ cell _quoteWorkers(tuple args) impure inline method_id(23432) {
     slice requiredDVNs = requiredDVNsCell.begin_parse();
     slice optionalDVNs = optionalDVNsCell.begin_parse();
 
-    cell $packet = $lzSend.cl::get<objRef>(md::LzSend::packet);
-    cell $path = $packet.cl::get<cellRef>(lz::Packet::path);
+    cell $packet = $lzSend.md::LzSend::getPacket();
+    cell $path = $packet.lz::Packet::getPath();
 
     tuple payeesInfo = empty_tuple();
     tuple workerEvents = UlnWorkerFeelibEventsBuilder::create();
@@ -319,7 +315,7 @@ cell _quoteWorkers(tuple args) impure inline method_id(23432) {
     }
 
     ;; create the dvnPaidEvent
-    cell $dvnsFeesPaidEvent = DvnFeesPaidEvent::New(
+    cell $dvnsFeesPaidEvent = DvnFeesPaidEvent::build(
         requiredDVNsCell,
         optionalDVNsCell,
         serializePayees(payeesInfo)
@@ -348,18 +344,16 @@ cell _quoteWorkers(tuple args) impure inline method_id(23432) {
         .UlnWorkerFeelibEventsBuilder::push(executor, eventBody);
 
     ;; create the executorPaidEvent
-    cell $executorFeePaidEvent = ExecutorFeePaidEvent::New(executor, executorFee);
+    cell $executorFeePaidEvent = ExecutorFeePaidEvent::build(executor, executorFee);
 
     ;; Handle treasury fee
-    int treasuryFee = totalNativeFee * $storage.cl::get<uint16>(Uln::treasuryFeeBps) / 10000;
+    (int owner, int treasuryFeeBps) = $storage.Uln::getQuoteWorkersInformation();
+    int treasuryFee = totalNativeFee * treasuryFeeBps / 10000;
     payeesInfo = payeesInfo.tpush(
-        unsafeTuple([
-            $storage.cl::get<objRef>(BASE_STORAGE_INDEX).cl::get<address>(BaseStorage::owner),
-            treasuryFee
-        ])
+        unsafeTuple([owner, treasuryFee])
     );
 
-    cell ret = md::MsglibSendCallback::New(
+    cell ret = md::MsglibSendCallback::build(
         totalNativeFee + treasuryFee,
         0,
         $lzSend,
@@ -369,7 +363,7 @@ cell _quoteWorkers(tuple args) impure inline method_id(23432) {
         PacketV1::nonceBytes,
         PacketV1::guidOffsetBytes,
         PacketV1::guidBytes,
-        UlnEvents::New(
+        UlnEvents::build(
             UlnWorkerFeelibEvents::FromBuilder(workerEvents),
             $dvnsFeesPaidEvent,
             $executorFeePaidEvent
@@ -418,7 +412,7 @@ tuple ulnQuote(cell $ulnSendMd) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
     actions~pushAction<call>(
-        $ulnSendMd.cl::get<address>(md::UlnSend::forwardingAddress),
+        $ulnSendMd.md::UlnSend::getForwardingAddress(),
         Msglib::OP::RETURN_QUOTE,
         _quote($ulnSendMd, $storage)
     );
@@ -430,7 +424,7 @@ tuple ulnSend(cell $ulnSendMd) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
     actions~pushAction<call>(
-        $ulnSendMd.cl::get<address>(md::UlnSend::forwardingAddress),
+        $ulnSendMd.md::UlnSend::getForwardingAddress(),
         Channel::OP::MSGLIB_SEND_CALLBACK,
         _quote($ulnSendMd, $storage)
     );
@@ -446,12 +440,14 @@ tuple ulnSend(cell $ulnSendMd) impure inline method_id {
 tuple ulnCommitPacket(cell $mdAddress) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    (cell $packet, int ulnConnectionAddress) = $mdAddress.md::MdAddress::deserialize();
+
     actions~pushAction<call>(
-        $mdAddress.cl::get<address>(md::MdAddress::address),
+        ulnConnectionAddress,
         UlnConnection::OP::ULN_CONNECTION_COMMIT_PACKET,
-        md::MdObj::New(
-            $mdAddress.cl::get<objRef>(md::MdAddress::md),
-            $storage.cl::get<objRef>(Uln::defaultUlnReceiveConfig)
+        md::MdObj::build(
+            $packet,
+            $storage.Uln::getDefaultUlnReceiveConfig()
         )
     );
 
@@ -468,12 +464,14 @@ tuple ulnCommitPacket(cell $mdAddress) impure inline method_id {
 tuple ulnVerify(cell $mdAddress) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    (cell $md, int ulnConnectionAddress) = md::MdAddress::deserialize($mdAddress);
+
     actions~pushAction<call>(
-        $mdAddress.cl::get<address>(md::MdAddress::address),
+        ulnConnectionAddress,
         UlnConnection::OP::ULN_CONNECTION_VERIFY,
-        md::ExtendedMd::New(
-            $mdAddress.cl::get<objRef>(md::MdAddress::md),
-            $storage.cl::get<objRef>(Uln::defaultUlnReceiveConfig),
+        md::ExtendedMd::build(
+            $md,
+            $storage.Uln::getDefaultUlnReceiveConfig(),
             getCaller()
         )
     );
@@ -481,28 +479,26 @@ tuple ulnVerify(cell $mdAddress) impure inline method_id {
     return actions;
 }
 
-() _setWorkerInfo(cell $workerFeelibInfo) impure inline_ref {
+() _setWorkerInfo(cell $workerFeelibInfos, cell $workerInfo) impure inline_ref {
     cell $storage = getContractStorage();
-    int workerAddress = $workerFeelibInfo.cl::get<address>(UlnWorkerFeelibInfo::workerAddress);
+    int workerAddress = $workerInfo.UlnWorkerFeelibInfo::getWorkerAddress();
 
     ;; Restrict the size of the new storage to prevent DoS of our contract storage.
     ;; The total worker bytecode size is capped by UlnManager::CONST::MAX_CUMULATIVE_BYTECODE_CELLS
     ;; and enforced by the UlnManager, so here the only thing we need to check is the storage size
     ;; of the workers, excluding their bytecode
     (_, _, _, int success) = compute_data_size?(
-        $workerFeelibInfo.cl::set(UlnWorkerFeelibInfo::workerFeelibBytecode, empty_cell()),
+        $workerInfo.UlnWorkerFeelibInfo::setWorkerFeeLibBytecode(empty_cell()),
         Uln::WorkerFeelibInfo::MaxCells
     );
 
     throw_unless(Uln::ERROR::invalidWorkerStorage, success);
 
     setContractStorage(
-        $storage
-            .cl::nestedDict256::setRef(
-                Uln::workerFeelibInfos,
-                workerAddress,
-                $workerFeelibInfo
-            )
+        $storage.Uln::updateWorkerFeelibInfos(
+            workerAddress,
+            $workerInfo
+        )
     );
 }
 
@@ -510,11 +506,9 @@ tuple updateWorkerFeelib(cell $UlnWorkerFeelibInfo) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
     int workerAddress = $UlnWorkerFeelibInfo.cl::get<address>(UlnWorkerFeelibInfo::workerAddress);
 
-    (cell $existingWorkerFeelibInfo, int exists) = cl::nestedDict256::get<cellRef>(
-        $storage,
-        Uln::workerFeelibInfos,
-        workerAddress
-    );
+    cell $workerFeelibInfos = $storage.Uln::getWorkerFeelibInfos();
+
+    (cell $existingWorkerFeelibInfo, int exists) = $workerFeelibInfos.cl::dict256::get<cellRef>(workerAddress);
 
     ifnot (exists) {
         int isAdmin = $UlnWorkerFeelibInfo.cl::get<bool>(UlnWorkerFeelibInfo::isAdmin);
@@ -564,7 +558,7 @@ tuple updateWorkerFeelib(cell $UlnWorkerFeelibInfo) impure inline method_id {
             );
     }
 
-    _setWorkerInfo($UlnWorkerFeelibInfo);
+    _setWorkerInfo($workerFeelibInfos, $UlnWorkerFeelibInfo);
 
     actions~pushAction<event>(
         Uln::event::ULN_WORKER_REGISTERED,
@@ -601,31 +595,17 @@ tuple deregisterWorkerFeelib(cell $empty) impure inline method_id {
 tuple setWorkerFeelibStorage(cell $newStorage) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    int workerAddress = getCaller();
+    cell $workerFeelibInfos = $storage.Uln::getWorkerFeelibInfos();
 
-    (cell $workerInfo, int exists) = $storage.cl::nestedDict256::get<cellRef>(
-        Uln::workerFeelibInfos,
-        workerAddress
-    );
+    int workerAddress = getCaller();
 
+    (cell $workerInfo, int exists) = $workerFeelibInfos.cl::dict256::get<cellRef>(workerAddress);
     throw_unless(Uln::ERROR::nonexistentWorker, exists);
 
-    cell $updatedWorkerInfo = $workerInfo.cl::set(
-        UlnWorkerFeelibInfo::workerFeelibStorage,
-        $newStorage
-    );
+    cell $updatedWorkerInfo = $workerInfo
+        .UlnWorkerFeelibInfo::setWorkerFeeLibStorage($newStorage);
 
-    ;; _setWorkerInfo does size assertions on worker storage
-    _setWorkerInfo($updatedWorkerInfo);
-
-    setContractStorage(
-        $storage
-            .cl::nestedDict256::setRef(
-                Uln::workerFeelibInfos,
-                workerAddress,
-                $updatedWorkerInfo
-            )
-    );
+    _setWorkerInfo($workerFeelibInfos, $updatedWorkerInfo);
 
     actions~pushAction<event>(
         Uln::event::ULN_WORKER_STORAGE_SET,
@@ -644,19 +624,18 @@ tuple setWorkerFeelibStorage(cell $newStorage) impure inline method_id {
 tuple refillWorkerRent(cell $rentRefill) {
     (cell $storage, tuple actions) = preamble();
 
+    cell $workerFeelibInfos = $storage.Uln::getWorkerFeelibInfos();
+
     int workerAddress = $rentRefill.cl::get<address>(md::RentRefill::address);
     int amount = $rentRefill.cl::get<coins>(md::RentRefill::amount);
-    (cell $workerInfo, int exists) = cl::nestedDict256::get<cellRef>(
-        $storage,
-        Uln::workerFeelibInfos,
-        workerAddress
-    );
+    (cell $workerInfo, int exists) = $workerFeelibInfos.cl::dict256::get<cellRef>(workerAddress);
 
     throw_unless(Uln::ERROR::nonexistentWorker, exists);
 
     int currentRentBalance = $workerInfo.cl::get<coins>(UlnWorkerFeelibInfo::rentBalance);
 
     _setWorkerInfo(
+        $workerFeelibInfos,
         $workerInfo.cl::set(UlnWorkerFeelibInfo::rentBalance, currentRentBalance + amount)
     );
 
@@ -677,9 +656,9 @@ tuple refillWorkerRent(cell $rentRefill) {
 tuple collectWorkerRent(cell $setAddress) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    (cell $workerInfo, int exists) = cl::nestedDict256::get<cellRef>(
-        $storage,
-        Uln::workerFeelibInfos,
+    cell $workerFeelibInfos = $storage.Uln::getWorkerFeelibInfos();
+
+    (cell $workerInfo, int exists) = $workerFeelibInfos.cl::dict256::get<cellRef>(
         $setAddress.cl::get<address>(md::SetAddress::address)
     );
 
@@ -704,7 +683,7 @@ tuple collectWorkerRent(cell $setAddress) impure inline method_id {
             .cl::set(UlnWorkerFeelibInfo::lastRentTimestamp, currentTimestamp);
 
         ;; update workerInfo in storage
-        _setWorkerInfo($workerInfo);
+        _setWorkerInfo($workerFeelibInfos, $workerInfo);
 
         actions~pushAction<event>(
             Uln::event::ULN_COLLECT_WORKER_RENT,
@@ -795,7 +774,7 @@ tuple garbageCollectInvalidAttestations(cell $mdAddress) impure inline method_id
     actions~pushAction<call>(
         $mdAddress.cl::get<address>(md::MdAddress::address),
         UlnConnection::OP::GARBAGE_COLLECT_INVALID_ATTESTATIONS,
-        md::MdObj::New(
+        md::MdObj::build(
             $mdAddress.cl::get<objRef>(md::MdAddress::md),
             $storage.cl::get<objRef>(Uln::defaultUlnReceiveConfig)
         )
@@ -804,8 +783,6 @@ tuple garbageCollectInvalidAttestations(cell $mdAddress) impure inline method_id
     return actions;
 }
 
-;; todo-thomas: I'm not sure if we can read tensors (or tuples for that matter)
-;; from the view functions using the RPC call, maybe it should be one integer?
 (int, int, int) version() impure method_id {
     return (3, 0, 2);
 }

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

@@ -40,4 +40,80 @@ cell Uln::New(int owner, int eid, int dstEid) method_id {
             [cl::t::uint16, 0]                                     ;; Uln::remainingAdminWorkerSlots
         ])
     );
-}
+}
+
+;; ============================== Object Getters ==============================
+
+const int Uln::_eidOffset = _HEADER_WIDTH;
+const int Uln::_dstEidOffset = Uln::_eidOffset + 32;
+const int Uln::_treasuryFeeBpsOffset = Uln::_dstEidOffset + 32;
+const int Uln::_remainingWorkerSlotsOffset = Uln::_treasuryFeeBpsOffset + 16;
+const int Uln::_remainingAdminWorkerSlotsOffset = Uln::_remainingWorkerSlotsOffset + 16;
+const int Uln::_sliceBits = Uln::_remainingAdminWorkerSlotsOffset + 16;
+
+cell Uln::getDefaultUlnReceiveConfig(cell $self) impure inline {
+    return $self.cellPreloadRefAt(1);
+}
+
+cell Uln::getConnectionCode(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(1);
+}
+
+cell Uln::getWorkerFeelibInfos(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(2);
+}
+
+;; ============================== Object Multi-Getters ==============================
+
+;; (owner, defaultUlnSendConfig) 
+cell Uln::getDefaultUlnSendConfig(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return selfSlice.preloadRefAt(2).cellPreloadRefAt(0); ;; defaultUlnSendConfig
+}
+
+;; (treasuryFeeBps, owner)
+(int, int) Uln::getQuoteWorkersInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadRefAt(0).BaseStorage::getOwner(),                   ;; baseStorage.Owner
+        selfSlice.preloadUint16At(Uln::_treasuryFeeBpsOffset)               ;; treasuryFeeBps
+    );
+}
+
+;; ============================== Object Setters ==============================
+
+cell Uln::setWorkerFeelibInfos(cell $self, cell $workerFeelibInfos) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    slice ref2_slice = selfSlice.preloadRefSliceAt(2);
+    cell new_ref2 = begin_cell()
+        .store_slice(ref2_slice.scutfirst(0, 2))
+        .store_ref($workerFeelibInfos)
+        .end_cell();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(Uln::_sliceBits, 2))
+        .store_ref(new_ref2)
+        .end_cell();
+}
+
+;; updates the worker feelib info for the given [worker address, new worker feelib info]
+;; and returns the new storage
+cell Uln::updateWorkerFeelibInfos(cell $self, int workerAddress, cell $workerFeelibInfo) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    slice ref2_slice = selfSlice.preloadRefSliceAt(2);
+    cell $workerFeelibInfos = ref2_slice
+        .preloadRefAt(2)
+        .cl::dict256::setRef(workerAddress, $workerFeelibInfo);
+
+    cell new_ref2 = begin_cell()
+        .store_slice(ref2_slice.scutfirst(0, 2))
+        .store_ref($workerFeelibInfos)
+        .end_cell();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(Uln::_sliceBits, 2))
+        .store_ref(new_ref2)
+        .end_cell();
+}