@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.29

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

@@ -108,69 +108,155 @@ cell UlnReceiveConfig::NewWithDefaults() inline method_id {
     );
 }
 
-int UlnReceiveConfig::utils::getConfirmations(
+;; ========================== Object getters ===========================
+
+const int UlnReceiveConfig::_minCommitPacketGasNullOffset = _HEADER_WIDTH;
+const int UlnReceiveConfig::_minCommitPacketGasOffset = UlnReceiveConfig::_minCommitPacketGasNullOffset + 1;
+const int UlnReceiveConfig::_confirmationsNullOffset = UlnReceiveConfig::_minCommitPacketGasOffset + 32;
+const int UlnReceiveConfig::_confirmationsOffset = UlnReceiveConfig::_confirmationsNullOffset + 1;
+const int UlnReceiveConfig::_requiredDVNsNullOffset = UlnReceiveConfig::_confirmationsOffset + 64;
+const int UlnReceiveConfig::_optionalDVNsNullOffset = UlnReceiveConfig::_requiredDVNsNullOffset + 1;
+const int UlnReceiveConfig::_optionalDVNThresholdOffset = UlnReceiveConfig::_optionalDVNsNullOffset + 1;
+
+
+int UlnReceiveConfig::getMinCommitPacketGas(cell $self) impure inline {
+    return $self.cellPreloadUint32At(UlnReceiveConfig::_minCommitPacketGasOffset);
+}
+
+int UlnReceiveConfig::getConfirmationsNull(cell $self) impure inline {
+    return $self.cellPreloadBoolAt(UlnReceiveConfig::_confirmationsNullOffset);
+}
+
+int UlnReceiveConfig::getConfirmations(cell $self) impure inline {
+    return $self.cellPreloadUint64At(UlnReceiveConfig::_confirmationsOffset);
+}
+
+int UlnReceiveConfig::getOptionalDVNThreshold(cell $self) impure inline {
+    return $self.cellPreloadUint8At(UlnReceiveConfig::_optionalDVNThresholdOffset);
+}
+
+;; ========================== Object multi - getters ======================
+
+(int, cell) UlnReceiveConfig::getRequiredDVNsAndNull(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadBoolAt(UlnReceiveConfig::_requiredDVNsNullOffset),
+        selfSlice.preloadRefAt(0)
+    );
+}
+
+(int, cell) UlnReceiveConfig::getOptionalDVNsAndNull(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadBoolAt(UlnReceiveConfig::_optionalDVNsNullOffset),
+        selfSlice.preloadRefAt(1)
+    );
+}
+
+;; returns (requiredDVNsNull, requiredDVNs, optionalDVNsNull, optionalDVNs)
+(int, cell, int, cell) UlnReceiveConfig::getRequiredAndOptionalDVNsAndNull(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadBoolAt(UlnReceiveConfig::_requiredDVNsNullOffset),
+        selfSlice.preloadRefAt(0),
+        selfSlice.preloadBoolAt(UlnReceiveConfig::_optionalDVNsNullOffset),
+        selfSlice.preloadRefAt(1)
+    );
+}
+
+;; (minCommitPacketGasNull, minCommitPacketGas, OptionalDvnNull, optionalDvnThreshold)
+(int, int, int, int) UlnReceiveConfig::getCommitInfo(cell $self) impure inline {
+    slice $selfSlice = $self.begin_parse();
+    ;; Could save a bit of gas by using self-modifying parse but
+    ;; it makes the code a lot less readable
+    return (
+        $selfSlice.preloadBoolAt(UlnReceiveConfig::_minCommitPacketGasNullOffset),
+        $selfSlice.preloadUint32At(UlnReceiveConfig::_minCommitPacketGasOffset),
+        $selfSlice.preloadBoolAt(UlnReceiveConfig::_optionalDVNsNullOffset),
+        $selfSlice.preloadUint8At(UlnReceiveConfig::_optionalDVNThresholdOffset)
+    );
+}
+
+;; ============== Object Utils ==============
+
+int UlnReceiveConfig::utils::resolveConfirmations(
     cell $UlnReceiveConfig,
     cell $defaultUlnReceiveConfig
 ) impure inline {
-    if ($UlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::confirmationsNull)) {
-        return $defaultUlnReceiveConfig.cl::get<uint64>(UlnReceiveConfig::confirmations);
+    if ($UlnReceiveConfig.UlnReceiveConfig::getConfirmationsNull()) {
+        return $defaultUlnReceiveConfig.UlnReceiveConfig::getConfirmations();
     }
-    return $UlnReceiveConfig.cl::get<uint64>(UlnReceiveConfig::confirmations);
+    return $UlnReceiveConfig.UlnReceiveConfig::getConfirmations();
 }
 
+;; (requiredDVNs, optionalDVNs, isValid)
 (cell, cell, int) UlnReceiveConfig::utils::getVerifyConfig(
     cell $customUlnReceiveConfig,
     cell $defaultUlnReceiveConfig
 ) impure inline {
     int isValid = true;
 
-    cell requiredDVNs = $customUlnReceiveConfig.cl::get<cellRef>(UlnReceiveConfig::requiredDVNs);
-    cell optionalDVNs = $customUlnReceiveConfig.cl::get<cellRef>(UlnReceiveConfig::optionalDVNs);
-
-    if ($customUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::requiredDVNsNull)) {
-        isValid &= ($defaultUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::requiredDVNsNull) == false);
-        requiredDVNs = $defaultUlnReceiveConfig.cl::get<cellRef>(UlnReceiveConfig::requiredDVNs);
+    (
+        int customRequiredDVNsNull, 
+        cell requiredDVNs, 
+        int customOptionalDVNsNull, 
+        cell optionalDVNs
+    ) = UlnReceiveConfig::getRequiredAndOptionalDVNsAndNull($customUlnReceiveConfig);
+
+    if (customRequiredDVNsNull) {
+        (
+            int defaultRequiredDVNsNull, 
+            requiredDVNs
+        ) = UlnReceiveConfig::getRequiredDVNsAndNull($defaultUlnReceiveConfig);
+        isValid &= (defaultRequiredDVNsNull == false);
     }
 
-    if ($customUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::optionalDVNsNull)) {
-        isValid &= ($defaultUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::optionalDVNsNull) == false);
-        optionalDVNs = $defaultUlnReceiveConfig.cl::get<cellRef>(UlnReceiveConfig::optionalDVNs);
+    if (customOptionalDVNsNull) {
+        (
+            int defaultOptionalDVNsNull, 
+            optionalDVNs
+        ) = UlnReceiveConfig::getOptionalDVNsAndNull($defaultUlnReceiveConfig);
+        isValid &= (defaultOptionalDVNsNull == false);
     }
 
     return (requiredDVNs, optionalDVNs, isValid);
 }
 
+;; (requiredDVNs, optionalDVNs, optionalDVNThreshold, confirmations, commitPacketGas, isValid)
 (cell, cell, int, int, int, int) UlnReceiveConfig::utils::getCommitConfig(
     cell $customUlnReceiveConfig,
     cell $defaultUlnReceiveConfig
-) inline method_id {
-    (cell $requiredDVNs, cell $optionalDVNs, int isValid) = UlnReceiveConfig::utils::getVerifyConfig(
+) impure inline method_id {
+    (
+        cell requiredDVNs, 
+        cell optionalDVNs, 
+        int isValid
+    ) = UlnReceiveConfig::utils::getVerifyConfig(
         $customUlnReceiveConfig,
         $defaultUlnReceiveConfig
     );
 
-    int optionalDVNThreshold = $customUlnReceiveConfig
-        .cl::get<uint8>(UlnReceiveConfig::optionalDVNThreshold);
-    int commitPacketGas = $customUlnReceiveConfig
-        .cl::get<uint32>(UlnReceiveConfig::minCommitPacketGas);
-
+    (
+        int minCommitPacketGasNull, 
+        int commitPacketGas, 
+        int optionalDVNsNull, 
+        int optionalDVNThreshold
+    ) = UlnReceiveConfig::getCommitInfo($customUlnReceiveConfig);
 
-    if ($customUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::optionalDVNsNull)) {
-        optionalDVNThreshold = $defaultUlnReceiveConfig
-            .cl::get<uint8>(UlnReceiveConfig::optionalDVNThreshold);
+    if (optionalDVNsNull) {
+        optionalDVNThreshold = $defaultUlnReceiveConfig.UlnReceiveConfig::getOptionalDVNThreshold();
     }
 
-    if ($customUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::minCommitPacketGasNull)) {
-        commitPacketGas = $defaultUlnReceiveConfig
-            .cl::get<uint32>(UlnReceiveConfig::minCommitPacketGas);
+    if (minCommitPacketGasNull) {
+        commitPacketGas = $defaultUlnReceiveConfig.UlnReceiveConfig::getMinCommitPacketGas();
     }
 
-    int confirmations = UlnReceiveConfig::utils::getConfirmations(
+    int confirmations = UlnReceiveConfig::utils::resolveConfirmations(
         $customUlnReceiveConfig,
         $defaultUlnReceiveConfig
     );
 
-    return ($requiredDVNs, $optionalDVNs, optionalDVNThreshold, confirmations, commitPacketGas, isValid);
+    return (requiredDVNs, optionalDVNs, optionalDVNThreshold, confirmations, commitPacketGas, isValid);
 }
 
 ;; Ensure the Uln receive config does not contain garbage bits etc. that would cause

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

@@ -24,4 +24,54 @@ cell md::UlnSend::New(
             [cl::t::address, forwardingAddress]         ;; md::UlnSend::forwardingAddress
         ])
     );
-}
+}
+
+;; ==================================== Object Builders =============================
+
+const int md::UlnSend::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 4);
+const int md::UlnSend::_headerFillerBits = _HEADER_WIDTH - md::UlnSend::_headerInfoBits;
+const int md::UlnSend::_headerInfo = 113547385374824943747209776028946924923;
+
+cell md::UlnSend::build(
+    cell $lzSend,
+    cell $customUlnSendConfig,
+    cell $connectionInitialStorage,
+    int forwardingAddress
+) impure inline method_id {
+    return begin_cell()
+        .store_uint(md::UlnSend::_headerInfo, md::UlnSend::_headerInfoBits)   ;; header info
+        .store_ones(md::UlnSend::_headerFillerBits)                           ;; header filler
+        .store_uint256(forwardingAddress)                                     ;; numerical field
+        .store_ref($lzSend)                                                   ;; refs[0]
+        .store_ref($customUlnSendConfig)                                      ;; refs[1]
+        .store_ref(
+            begin_cell()
+                .store_ref($connectionInitialStorage)                         ;; refs[2]
+                .end_cell()
+        )
+        .end_cell();
+}
+
+
+;; ==================================== Object Getters =============================
+
+const int md::UlnSend::_forwardingAddressOffset = _HEADER_WIDTH;
+
+cell md::UlnSend::getConnectionInitialStorage(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(0);
+}
+
+int md::UlnSend::getForwardingAddress(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(md::UlnSend::_forwardingAddressOffset);
+}
+
+;; ==================================== Object Multi-Getters =============================
+
+(cell, cell) md::UlnSend::getLzSendAndCustomUlnSendConfig(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice~load_ref(),
+        selfSlice~load_ref()
+    );
+}
+

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

@@ -137,7 +137,7 @@ cell UlnSendConfig::NewWithDefaults() impure method_id {
 
 ;; Ensure the Uln send config does not contain garbage bits etc. that would cause
 ;; undefined behaviors in the protocol
-cell UlnSendConfig::sanitize(cell $ulnSendConfig) impure inline_ref {
+cell UlnSendConfig::sanitize(cell $ulnSendConfig) impure {
     int workerQuoteGasLimit = $ulnSendConfig.cl::get<uint32>(UlnSendConfig::workerQuoteGasLimit);
     int maxMessageBytes = $ulnSendConfig.cl::get<uint32>(UlnSendConfig::maxMessageBytes);
     int useDefaultExecutor = $ulnSendConfig.cl::get<bool>(UlnSendConfig::executorNull);

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

@@ -18,4 +18,14 @@ cell md::UlnVerification::New(int nonce, int hash, int confirmations) inline met
             )]                      ;; md::UlnVerification::attestation
         ])
     );
+}
+
+;; ==================================== Object Getters =============================
+const int md::UlnVerification::_nonceOffset = _HEADER_WIDTH;
+
+(int, cell) md::UlnVerification::deserialize(cell $self) impure inline {
+    return (
+        $self.cellPreloadUint64At(md::UlnVerification::_nonceOffset),
+        $self.cellPreloadRefAt(0)
+    );
 }

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

@@ -13,4 +13,10 @@ cell md::UlnWorkerFeelibBytecode::New(cell bytecode) inline method_id {
             [cl::t::cellRef, bytecode] ;; md::UlnWorkerFeelibBytecode::nonce
         ])
     );
+}
+
+cell md::UlnWorkerFeelibBytecode::sanitize(cell $ulnWorkerFeelibBytecode) impure inline_ref {
+    cell bytecode = $ulnWorkerFeelibBytecode.cl::get<cellRef>(md::UlnWorkerFeelibBytecode::bytecode);
+
+    return md::UlnWorkerFeelibBytecode::New(bytecode);
 }

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

@@ -40,7 +40,57 @@ cell UlnWorkerFeelibInfo::New(
     );
 }
 
-cell UlnWorkerFeelibInfo::sanitize(cell $ulnWorkerFeelibInfo) {
+;; ==================================== Object Getters =============================
+
+const int UlnWorkerFeelibInfo::_workerAddressOffset = _HEADER_WIDTH;
+const int UlnWorkerFeelibInfo::_friendWorkerAddressOffset = UlnWorkerFeelibInfo::_workerAddressOffset + 256;
+const int UlnWorkerFeelibInfo::_dstEidOffset = UlnWorkerFeelibInfo::_friendWorkerAddressOffset + 256;
+const int UlnWorkerFeelibInfo::_rentBalanceOffset = UlnWorkerFeelibInfo::_dstEidOffset + 32;
+
+const int UlnWorkerFeelibInfo::_rootSliceBits = UlnWorkerFeelibInfo::_rentBalanceOffset + 128;
+
+int UlnWorkerFeelibInfo::getWorkerAddress(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(UlnWorkerFeelibInfo::_workerAddressOffset);
+}
+
+cell UlnWorkerFeelibInfo::getWorkerFeeLibStorage(cell $self) impure inline {
+    return $self.cellPreloadRefAt(1);
+}
+
+;; ==================================== Object Multi-Getters =============================
+
+;; (friendAddress, feelibStorage, feelibByteCode)
+(int, cell, cell) UlnWorkerFeelibInfo::getQuoteWorkerInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadAddressAt(UlnWorkerFeelibInfo::_friendWorkerAddressOffset),
+        selfSlice.preloadRefAt(1),
+        selfSlice.preloadRefAt(0)
+    );
+}
+
+;; ==================================== Object Setters =============================
+
+cell UlnWorkerFeelibInfo::setWorkerFeeLibBytecode(cell $self, cell $workerFeeLibBytecode) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    return begin_cell()
+        .store_ref($workerFeeLibBytecode)                ;; replace ref[0] with the new workerFeeLibBytecode
+        .store_slice(selfSlice.sskipfirst(0, 1))         ;; store the rest of the fields
+        .end_cell();
+}
+
+cell UlnWorkerFeelibInfo::setWorkerFeeLibStorage(cell $self, cell $workerFeeLibStorage) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(UlnWorkerFeelibInfo::_rootSliceBits, 1))         ;; store every bit in root and ref[0]
+        .store_ref($workerFeeLibStorage)                    ;; replace ref[1] with the new workerFeeLibStorage
+        .store_slice(selfSlice.scutlast(0, 1))              ;; store ref[2]
+        .end_cell();
+}
+
+cell UlnWorkerFeelibInfo::sanitize(cell $ulnWorkerFeelibInfo) impure {
     return UlnWorkerFeelibInfo::New(
         $ulnWorkerFeelibInfo.cl::get<address>(UlnWorkerFeelibInfo::workerAddress),
         $ulnWorkerFeelibInfo.cl::get<cellRef>(UlnWorkerFeelibInfo::workerFeelibBytecode),

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

@@ -15,4 +15,19 @@ cell md::VerificationStatus::New(int nonce, int status) inline method_id {
             [cl::t::uint32, status]    ;; md::VerificationStatus::status
         ])
     );
+}
+
+;; ==================================== Object Builders =============================
+
+const int md::VerificationStatus::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 2);
+const int md::VerificationStatus::_headerFillerBits = _HEADER_WIDTH - md::VerificationStatus::_headerInfoBits;
+const int md::VerificationStatus::_headerInfo = 38421788582694199859296615363593851;
+
+cell md::VerificationStatus::build(int nonce, int status) impure inline method_id {
+    return begin_cell()
+        .store_uint(md::VerificationStatus::_headerInfo, md::VerificationStatus::_headerInfoBits)     ;; header info
+        .store_ones(md::VerificationStatus::_headerFillerBits)                                        ;; header filler
+        .store_uint64(nonce)                                                                          ;; nonce
+        .store_uint32(status)                                                                         ;; status
+        .end_cell();
 }