@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.28

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

@@ -57,7 +57,8 @@ int _getEventSink() impure inline {
 }
 
 () _assertOAppPath(cell $mdObj) impure inline {
-    cell $path = $mdObj.cl::get<objRef>(md::MdObj::obj);
+    cell $sanitizedMdObj = $mdObj.md::MdObj::sanitize();
+    cell $path = $sanitizedMdObj.cl::get<objRef>(md::MdObj::obj);
     cell $sanitizedPath = lz::Path::sanitize($path);
     throw_unless(
         UlnManager::ERROR::invalidPath,
@@ -164,8 +165,9 @@ int _calculateUlnConnectionAddress(cell $storage, cell $path) impure inline meth
 ;; @out_actions deploy the uln for this particular eid
 tuple deployUln(cell $deploy) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
+    cell $sanitizedDeploy = $deploy.md::Deploy::NewWithExtraInfo::sanitize();
 
-    int dstEid = $deploy.cl::get<uint32>(md::Deploy::dstEid);
+    int dstEid = $sanitizedDeploy.cl::get<uint32>(md::Deploy::dstEid);
     throw_if(UlnManager::ERROR::invalidEid, dstEid == 0);
 
     actions~pushAction<deployAndCall>(
@@ -175,9 +177,9 @@ tuple deployUln(cell $deploy) impure inline method_id {
             $storage.cl::get<uint32>(UlnManager::eid),
             dstEid
         ),
-        $deploy.cl::get<coins>(md::Deploy::initialDeposit),
+        $sanitizedDeploy.cl::get<coins>(md::Deploy::initialDeposit),
         BaseInterface::OP::INITIALIZE,
-        $deploy.cl::get<objRef>(md::Deploy::extraInfo).cl::set(
+        $sanitizedDeploy.cl::get<objRef>(md::Deploy::extraInfo).cl::set(
             md::InitUln::connectionCode,
             $storage.cl::get<cellRef>(UlnManager::ulnConnectionCode)
         ),
@@ -192,8 +194,9 @@ tuple deployUln(cell $deploy) impure inline method_id {
 ;; @out_actions deploy the connection for this particular oApp path
 tuple deployUlnConnection(cell $deploy) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
+    cell $sanitizedDeploy = $deploy.md::Deploy::NewWithExtraInfo::sanitize();
 
-    int dstEid = $deploy.cl::get<uint32>(md::Deploy::dstEid);
+    int dstEid = $sanitizedDeploy.cl::get<uint32>(md::Deploy::dstEid);
 
     throw_if(UlnManager::ERROR::invalidEid, dstEid == 0);
 
@@ -201,7 +204,7 @@ tuple deployUlnConnection(cell $deploy) impure inline method_id {
         $storage.cl::get<uint32>(UlnManager::eid),
         getCaller(),
         dstEid,
-        $deploy.cl::get<address>(md::Deploy::dstOApp)
+        $sanitizedDeploy.cl::get<address>(md::Deploy::dstOApp)
     );
 
     cell $ulnConnection = UlnConnection::New(
@@ -210,26 +213,27 @@ tuple deployUlnConnection(cell $deploy) impure inline method_id {
         _calculateUlnAddress($storage, dstEid)
     );
 
-    cell $initUlnConnection = $deploy.cl::get<objRef>(md::Deploy::extraInfo)
+    cell $initUlnConnection = $sanitizedDeploy.cl::get<objRef>(md::Deploy::extraInfo)
         .cl::set(md::InitUlnConnection::endpointAddress, _calculateEndpointAddress($storage, dstEid))
         .cl::set(md::InitUlnConnection::channelAddress, _calculateChannelAddress($storage, $path));
 
     actions~pushAction<deployAndCall>(
         $storage.cl::get<cellRef>(UlnManager::ulnConnectionCode),
         $ulnConnection,
-        $deploy.cl::get<coins>(md::Deploy::initialDeposit),
+        $sanitizedDeploy.cl::get<coins>(md::Deploy::initialDeposit),
         BaseInterface::OP::INITIALIZE,
-        InitUlnConnection::sanitize($initUlnConnection),
+        md::InitUlnConnection::sanitize($initUlnConnection),
         0
     );
 
     return actions;
 }
 
-tuple getMsglibInfo(cell $addMsglibMd) impure inline method_id {
+tuple getMsglibInfo(cell $addMsglib) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
+    cell $sanitizedAddMsglib = $addMsglib.md::AddMsglib::sanitize();
 
-    int dstEid = $addMsglibMd.cl::get<uint32>(md::AddMsglib::dstEid);
+    int dstEid = $sanitizedAddMsglib.cl::get<uint32>(md::AddMsglib::dstEid);
     throw_if(UlnManager::ERROR::invalidEid, dstEid == 0);
 
     int ulnAddress = _calculateUlnAddress(
@@ -260,10 +264,12 @@ tuple getMsglibInfo(cell $addMsglibMd) impure inline method_id {
 ;; @in_opcode UlnManager::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG
 tuple setDefaultUlnSendConfig(cell $mdEid) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
-    cell $UlnSendConfig = $mdEid.cl::get<objRef>(md::MdEid::md);
+    cell $sanitizedMdEid = $mdEid.md::MdEid::sanitize();
+    
+    cell $UlnSendConfig = $sanitizedMdEid.cl::get<objRef>(md::MdEid::md);
 
     actions~pushAction<call>(
-        _calculateUlnAddress($storage, $mdEid.cl::get<uint32>(md::MdEid::eid)),
+        _calculateUlnAddress($storage, $sanitizedMdEid.cl::get<uint32>(md::MdEid::eid)),
         Uln::OP::SET_DEFAULT_ULN_SEND_CONFIG,
         $UlnSendConfig
     );
@@ -274,10 +280,12 @@ tuple setDefaultUlnSendConfig(cell $mdEid) impure inline method_id {
 ;; @in_opcode UlnManager::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG
 tuple setDefaultUlnReceiveConfig(cell $mdEid) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
-    cell $UlnReceiveConfig = $mdEid.cl::get<objRef>(md::MdEid::md);
+    cell $sanitizedMdEid = $mdEid.md::MdEid::sanitize();
+    
+    cell $UlnReceiveConfig = $sanitizedMdEid.cl::get<objRef>(md::MdEid::md);
 
     actions~pushAction<call>(
-        _calculateUlnAddress($storage, $mdEid.cl::get<uint32>(md::MdEid::eid)),
+        _calculateUlnAddress($storage, $sanitizedMdEid.cl::get<uint32>(md::MdEid::eid)),
         Uln::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG,
         $UlnReceiveConfig
     );
@@ -288,13 +296,16 @@ tuple setDefaultUlnReceiveConfig(cell $mdEid) impure inline method_id {
 ;; @in_opcode UlnManager::OP::SET_CONNECTION_ULN_CONFIG
 tuple setOAppUlnReceiveConfig(cell $mdObj) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
+    cell $sanitizedMdObj = $mdObj.md::MdObj::sanitize();
 
-    cell $sendPath = $mdObj.cl::get<objRef>(md::MdObj::obj);
+    cell $sendPath = $sanitizedMdObj
+        .cl::get<objRef>(md::MdObj::obj)
+        .lz::Path::sanitize();
 
     actions~pushAction<call>(
         _calculateUlnConnectionAddress($storage, $sendPath),
         UlnConnection::OP::SET_OAPP_ULN_RECEIVE_CONFIG,
-        $mdObj.cl::get<objRef>(md::MdObj::md)
+        $sanitizedMdObj.cl::get<objRef>(md::MdObj::md)
     );
 
     return actions;
@@ -303,13 +314,16 @@ tuple setOAppUlnReceiveConfig(cell $mdObj) impure inline method_id {
 ;; @in_opcode UlnManager::OP::SET_CONNECTION_ULN_CONFIG
 tuple setOAppUlnSendConfig(cell $mdObj) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
-
-    cell $sendPath = $mdObj.cl::get<objRef>(md::MdObj::obj);
+    cell $sanitizedMdObj = $mdObj.md::MdObj::sanitize();
+    
+    cell $sendPath = $sanitizedMdObj
+        .cl::get<objRef>(md::MdObj::obj)
+        .lz::Path::sanitize();
 
     actions~pushAction<call>(
         _calculateUlnConnectionAddress($storage, $sendPath),
         UlnConnection::OP::SET_OAPP_ULN_SEND_CONFIG,
-        $mdObj.cl::get<objRef>(md::MdObj::md)
+        $sanitizedMdObj.cl::get<objRef>(md::MdObj::md)
     );
 
     return actions;
@@ -319,7 +333,10 @@ tuple setOAppUlnSendConfig(cell $mdObj) impure inline method_id {
 tuple registerWorkerFeelibBytecode(cell $ulnWorkerFeelibBytecode) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell bytecode = $ulnWorkerFeelibBytecode
+    cell $sanitizedUlnWorkerFeelibBytecode = $ulnWorkerFeelibBytecode
+        .md::UlnWorkerFeelibBytecode::sanitize();
+
+    cell bytecode = $sanitizedUlnWorkerFeelibBytecode
         .cl::get<cellRef>(md::UlnWorkerFeelibBytecode::bytecode);
 
     cell $newStorage = $storage
@@ -344,9 +361,10 @@ tuple registerWorkerFeelibBytecode(cell $ulnWorkerFeelibBytecode) impure inline
 tuple addWorkerFeelibToUln(cell $UlnWorkerFeelibInfo) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    cell $sanitizedUlnWorkerFeelibInfo = UlnWorkerFeelibInfo::sanitize(
-        $UlnWorkerFeelibInfo
-    ).cl::set(UlnWorkerFeelibInfo::workerAddress, getCaller());
+    cell $sanitizedUlnWorkerFeelibInfo = $UlnWorkerFeelibInfo
+        .UlnWorkerFeelibInfo::sanitize()
+        .cl::set(UlnWorkerFeelibInfo::workerAddress, getCaller());
+
     ;; invariant: checkPermissions guarantees that getCaller() == $UlnWorkerFeelibInfo.workerAddress
     int bytecodeId = $sanitizedUlnWorkerFeelibInfo
         .cl::get<cellRef>(UlnWorkerFeelibInfo::workerFeelibBytecode)
@@ -383,7 +401,9 @@ tuple addWorkerFeelibToUln(cell $UlnWorkerFeelibInfo) impure inline method_id {
 
 tuple setAdminWorkers(cell $setAdminWorkerAddresses) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
-    cell adminWorkers = $setAdminWorkerAddresses
+    cell $sanitizedSetAdminWorkerAddresses = $setAdminWorkerAddresses.md::SetAdminWorkerAddresses::sanitize();
+
+    cell adminWorkers = $sanitizedSetAdminWorkerAddresses
         .cl::get<cellRef>(md::SetAdminWorkerAddresses::adminWorkers);
 
     throw_unless(
@@ -397,7 +417,7 @@ tuple setAdminWorkers(cell $setAdminWorkerAddresses) impure inline method_id {
 
     actions~pushAction<event>(
         UlnManager::event::ADMIN_WORKERS_SET,
-        $setAdminWorkerAddresses
+        $sanitizedSetAdminWorkerAddresses
     );
 
     return actions;
@@ -405,8 +425,9 @@ tuple setAdminWorkers(cell $setAdminWorkerAddresses) impure inline method_id {
 
 tuple claimTreasuryFees(cell $coinsAmount) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
+    cell $sanitizedCoinsAmount = $coinsAmount.md::CoinsAmount::sanitize();
 
-    int claimAmount = $coinsAmount.cl::get<coins>(md::CoinsAmount::amount);
+    int claimAmount = $sanitizedCoinsAmount.cl::get<coins>(md::CoinsAmount::amount);
     (int myStateCellCount, int myStateBitCount) = getContractStateSize(
         my_code(),
         getContractStorage()
@@ -432,8 +453,10 @@ tuple claimTreasuryFees(cell $coinsAmount) impure inline method_id {
 
 tuple setUlnTreasuryFeeBps(cell $mdEid) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
-    int ulnAddress = _calculateUlnAddress($storage, $mdEid.cl::get<uint32>(md::MdEid::eid));
-    cell $treasuryFeeBps = $mdEid.cl::get<objRef>(md::MdAddress::md);
+    cell $sanitizedMdEid = $mdEid.md::MdEid::sanitize();
+
+    int ulnAddress = _calculateUlnAddress($storage, $sanitizedMdEid.cl::get<uint32>(md::MdEid::eid));
+    cell $treasuryFeeBps = $sanitizedMdEid.cl::get<objRef>(md::MdEid::md);
     actions~pushAction<call>(
         ulnAddress,
         Uln::OP::SET_TREASURY_FEE_BPS,
@@ -448,17 +471,18 @@ tuple setUlnTreasuryFeeBps(cell $mdEid) impure inline method_id {
 ;; claim, but nothing else. This effectively burns it.
 tuple transferOwnership(cell $setAddress) impure inline {
     (cell $storage, tuple actions) = preamble();
+    cell $sanitizedSetAddress = $setAddress.md::SetAddress::sanitize();
 
     setContractStorage(
         $storage.cl::set(
             UlnManager::tentativeOwner,
-            $setAddress.cl::get<address>(md::SetAddress::address)
+            $sanitizedSetAddress.cl::get<address>(md::SetAddress::address)
         )
     );
 
     actions~pushAction<event>(
         UlnManager::event::OWNER_SET_TENTATIVE,
-        $setAddress
+        $sanitizedSetAddress
     );
 
     return actions;

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/dvnFeeLib/handler.fc

@@ -14,10 +14,11 @@ const int DvnFeelib::VERIFY_BYTES_ULN = 288;
 
 ;; just validate options
 () _decodeOption(cell $options) impure inline_ref {
+    int optionsType = cl::typeof($options);
     if (
-        (cl::typeof($options) == md::OptionsV1::NAME)
-        | (cl::typeof($options) == md::OptionsV2::NAME)
-        | cl::isNullObject($options)
+        (optionsType == md::OptionsV1::NAME)
+        | (optionsType == md::OptionsV2::NAME)
+        | (optionsType == cl::NULL_CLASS_NAME)
     ) {
         return ();
     } else {
@@ -33,7 +34,7 @@ const int DvnFeelib::VERIFY_BYTES_ULN = 288;
 }
 
 int _getCallDataSize(cell $myStorage) impure inline_ref {
-    int quorum = $myStorage.cl::get<uint64>(DvnFeelib::quorum);
+    int quorum = $myStorage.DvnFeelib::getQuorum();
 
     int totalSignatureBytes = DvnFeelib::SIGNATURE_RAW_BYTES * quorum;
     ;; align on 32-byte boundary
@@ -47,7 +48,7 @@ int _getCallDataSize(cell $myStorage) impure inline_ref {
 tuple ulnWorker::quote(tuple inputs) method_id {
     cell $myStorage = inputs.cell_at(0);
     cell $priceFeedInfo = inputs.cell_at(1);
-    cell $priceFeedStorage = $priceFeedInfo.cl::get<objRef>(UlnWorkerFeelibInfo::workerFeelibStorage);
+    cell $priceFeedStorage = $priceFeedInfo.UlnWorkerFeelibInfo::getWorkerFeeLibStorage();
     ;; cell $path = inputs.cell_at(2);
     ;; int confirmations = inputs.int_at(3);
     ;; int packetBytes = inputs.int_at(4);
@@ -61,16 +62,19 @@ tuple ulnWorker::quote(tuple inputs) method_id {
         int gasPriceInUnit,
         int gasPerByte,
         int nativePriceUsd
-    ) = PriceFeedFeelib::utils::deserializeStorage($priceFeedStorage);
+    ) = PriceFeedFeelib::deserialize($priceFeedStorage);
 
-    int totalGas = $myStorage.cl::get<uint64>(DvnFeelib::gas) + (_getCallDataSize($myStorage) * gasPerByte);
+    (int gas, int multiplierBps, int floorMarginUSD) = DvnFeelib::getGasMultiplierBpsAndFloorMarginUSD($myStorage);
+
+    int totalGas = gas + (_getCallDataSize($myStorage) * gasPerByte);
     ;; the gas fee in units of remote gas token (e.g., WEI for ETH)
     int gasFeeInUnit = totalGas * gasPriceInUnit;
 
+
     int totalGasFee = _applyPremiumAndFloor(
         _remoteToNanoton(gasFeeInUnit, priceRatio),
-        $myStorage.cl::get<uint16>(DvnFeelib::multiplierBps),
-        $myStorage.cl::get<coins>(DvnFeelib::floorMarginUSD),
+        multiplierBps,
+        floorMarginUSD,
         nativePriceUsd
     );
 

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/dvnFeeLib/storage.fc

@@ -1,4 +1,6 @@
 #include "../../../../../funC++/classlib.fc";
+#include "../../../../../funC++/stdlib.fc";
+#include "../../../../../funC++/utils.fc";
 
 const int DvnFeelib::NAME = "UlnDvnFl"u;
 
@@ -24,3 +26,24 @@ cell DvnFeelib::New(
         ])
     );
 }
+
+;; ============================== Object Getters ==============================
+
+const int DvnFeeLib::_quorumOffset = _HEADER_WIDTH;
+const int DvnFeeLib::_gasOffset = DvnFeeLib::_quorumOffset + 64;
+const int DvnFeeLib::_multiplierBpsOffset = DvnFeeLib::_gasOffset + 64;
+const int DvnFeeLib::_floorMarginUSDOffset = DvnFeeLib::_multiplierBpsOffset + 16;
+
+int DvnFeelib::getQuorum(cell $self) impure inline {
+    return $self.cellPreloadUint64At(DvnFeeLib::_quorumOffset);
+}
+
+;; (gas, multiplierBps, floorMarginUSD)
+(int, int, int) DvnFeelib::getGasMultiplierBpsAndFloorMarginUSD(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadUint64At(DvnFeeLib::_gasOffset),
+        selfSlice.preloadUint16At(DvnFeeLib::_multiplierBpsOffset),
+        selfSlice.preloadCoinsAt(DvnFeeLib::_floorMarginUSDOffset)
+    );
+}

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/executorFeeLib/handler.fc

@@ -1,3 +1,4 @@
+#include "../../../../../classes/lz/Path.fc";
 #include "../../../../../classes/msgdata/OptionsV1.fc";
 #include "../../../../../classes/msgdata/OptionsV2.fc";
 
@@ -8,35 +9,57 @@
 #include "../common.fc";
 #include "storage.fc";
 
-(int, int) _decodeOption(int lzReceiveBaseGas, int lzComposeBaseGas, cell $options) impure inline {
+int isV1Eid(int eid) impure inline {
+    return (eid < 30000);
+}
+
+(int, int) _decodeOption(int lzReceiveBaseGas, int lzComposeBaseGas, cell $options, cell $path) impure inline {
     int totalGas = 0;
     int totalDstAmount = 0;
 
-    if (cl::typeof($options) == md::OptionsV1::NAME) {
-        totalGas += lzReceiveBaseGas
-            + $options.cl::get<uint256>(md::OptionsV1::lzReceiveGas);
+    int optionsType = cl::typeof($options);
 
-        totalDstAmount += $options.cl::get<uint256>(md::OptionsV1::lzReceiveValue)
-            + $options.cl::get<uint256>(md::OptionsV1::nativeDropAmount);
-    } elseif (cl::typeof($options) == md::OptionsV2::NAME) {
-        int lzComposeGas = $options.cl::get<uint256>(md::OptionsV2::lzComposeGas);
-        int lzComposeValue = $options.cl::get<uint256>(md::OptionsV2::lzComposeValue);
+    if (optionsType == md::OptionsV1::NAME) {
+        (
+            int lzReceiveGas,
+            int lzReceiveValue,
+            int nativeDropAmount
+        ) = $options.md::OptionsV1::decodeCoins();
+
+        ;; LayerZero V1 does not support value on lzReceive
+        throw_if(
+            UlnWorkerInterface::ERROR::INVALID_OPTIONS,
+            (lzReceiveValue > 0) & isV1Eid($path.lz::Path::getDstEid())
+        );
+
+        totalGas += lzReceiveBaseGas + lzReceiveGas;
+
+        totalDstAmount += lzReceiveValue + nativeDropAmount;
+
+    } elseif (optionsType == md::OptionsV2::NAME) {
+        (
+            int lzComposeGas,
+            int lzComposeValue,
+            int lzReceiveGas,
+            int lzReceiveValue,
+            int nativeDropAmount
+        ) = $options.md::OptionsV2::decodeCoins();
 
         throw_if(
             UlnWorkerInterface::ERROR::ZERO_LZ_COMPOSE_GAS_PROVIDED,
             (lzComposeGas == 0) & (lzComposeValue > 0)
         );
 
-        totalGas += lzReceiveBaseGas + $options.cl::get<uint256>(md::OptionsV2::lzReceiveGas);
+        totalGas += lzReceiveBaseGas + lzReceiveGas;
 
-        totalDstAmount += $options.cl::get<uint256>(md::OptionsV2::lzReceiveValue)
-            + $options.cl::get<uint256>(md::OptionsV2::nativeDropAmount);
+        totalDstAmount += lzReceiveValue + nativeDropAmount;
 
         if (lzComposeGas > 0) {
             totalGas += lzComposeGas + lzComposeBaseGas;
             totalDstAmount += lzComposeValue;
         }
-    } elseif (cl::isNullObject($options)) {
+        
+    } elseif (optionsType == cl::NULL_CLASS_NAME) {
         return (0, 0);
     } else {
         throw(UlnWorkerInterface::ERROR::UNKNOWN_OPTIONS);
@@ -49,19 +72,31 @@
     int lzReceiveBaseGas,
     int lzComposeBaseGas,
     cell $extraOptions,
-    cell $enforcedOptions
+    cell $enforcedOptions,
+    cell $path
 ) impure inline {
     int totalGas = 0;
     int totalDstAmount = 0;
 
     ifnot ($extraOptions.cl::isNullObject()) {
-        (int _totalGas, int _totalDstAmount) = _decodeOption(lzReceiveBaseGas, lzComposeBaseGas, $extraOptions);
+        (int _totalGas, int _totalDstAmount) = _decodeOption(
+            lzReceiveBaseGas,
+            lzComposeBaseGas,
+            $extraOptions,
+            $path
+        );
+
         totalGas += _totalGas;
         totalDstAmount += _totalDstAmount;
     }
 
     ifnot ($enforcedOptions.cl::isNullObject()) {
-        (int _totalGas, int _totalDstAmount) = _decodeOption(lzReceiveBaseGas, lzComposeBaseGas, $enforcedOptions);
+        (int _totalGas, int _totalDstAmount) = _decodeOption(
+            lzReceiveBaseGas,
+            lzComposeBaseGas,
+            $enforcedOptions,
+            $path
+        );
         totalGas += _totalGas;
         totalDstAmount += _totalDstAmount;
     }
@@ -73,31 +108,32 @@
 tuple ulnWorker::quote(tuple inputs) impure method_id {
     cell $myStorage = inputs.cell_at(0);
     cell $priceFeedInfo = inputs.cell_at(1);
-    cell $priceFeedStorage = $priceFeedInfo.cl::get<objRef>(UlnWorkerFeelibInfo::workerFeelibStorage);
-    ;; cell $path = inputs.cell_at(2);
+    cell $priceFeedStorage = $priceFeedInfo.UlnWorkerFeelibInfo::getWorkerFeeLibStorage();
+    cell $path = inputs.cell_at(2);
     ;; int confirmations = inputs.int_at(3);
     int packetBytes = inputs.int_at(4);
     cell $extraOptions = inputs.cell_at(5);
     cell $enforcedOptions = inputs.cell_at(6);
 
-    int multiplierBps = $myStorage.cl::get<uint16>(ExecutorFeelib::multiplierBps);
+    (
+        int lzReceiveBaseGas,
+        int multiplierBps,
+        int floorMarginUSD,
+        _,
+        int lzComposeBaseGas
+    ) = ExecutorFeelib::deserializeStorage($myStorage);
 
     (
         int totalRemoteGas,
         int totalRemoteValue
-    ) = _decodeOptions(
-        $myStorage.cl::get<uint64>(ExecutorFeelib::lzReceiveBaseGas),
-        $myStorage.cl::get<uint64>(ExecutorFeelib::lzComposeBaseGas),
-        $extraOptions,
-        $enforcedOptions
-    );
+    ) = _decodeOptions(lzReceiveBaseGas, lzComposeBaseGas, $extraOptions, $enforcedOptions, $path);
 
     (
         int priceRatio,
         int gasPriceInUnit,
         int gasPerByte,
         int nativePriceUsd
-    ) = PriceFeedFeelib::utils::deserializeStorage($priceFeedStorage);
+    ) = PriceFeedFeelib::deserialize($priceFeedStorage);
 
     ;; simple calculation of gas per byte
     int gasForCalldata = packetBytes * gasPerByte;
@@ -107,7 +143,7 @@ tuple ulnWorker::quote(tuple inputs) impure method_id {
     int totalGasFeeInNanoton = _applyPremiumAndFloor(
         _remoteToNanoton(totalGasFeeInUnit, priceRatio),
         multiplierBps,
-        $myStorage.cl::get<coins>(ExecutorFeelib::floorMarginUSD),
+        floorMarginUSD,
         nativePriceUsd
     );
 

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/executorFeeLib/storage.fc

@@ -27,3 +27,22 @@ cell ExecutorFeelib::New(
         ])
     );
 }
+
+;; ============================== Object Getters =========================================
+
+const int ExecutorFeelib::_lzReceiveBaseGasOffset = _HEADER_WIDTH;
+const int ExecutorFeelib::_multiplierBpsOffset = ExecutorFeelib::_lzReceiveBaseGasOffset + 64;
+const int ExecutorFeelib::_floorMarginUSDOffset = ExecutorFeelib::_multiplierBpsOffset + 16;
+const int ExecutorFeelib::_nativeCapOffset = ExecutorFeelib::_floorMarginUSDOffset + 128;
+const int ExecutorFeelib::_lzComposeBaseGasOffset = ExecutorFeelib::_nativeCapOffset + 128;
+
+(int, int, int, int, int) ExecutorFeelib::deserializeStorage(cell $storage) impure inline {
+    slice selfSlice = $storage.begin_parse();
+    return (
+        selfSlice.preloadUint64At(ExecutorFeelib::_lzReceiveBaseGasOffset),
+        selfSlice.preloadUint16At(ExecutorFeelib::_multiplierBpsOffset),
+        selfSlice.preloadCoinsAt(ExecutorFeelib::_floorMarginUSDOffset),
+        selfSlice.preloadCoinsAt(ExecutorFeelib::_nativeCapOffset),
+        selfSlice.preloadUint64At(ExecutorFeelib::_lzComposeBaseGasOffset)
+    );
+}

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/priceFeedFeeLib/storage.fc

@@ -28,12 +28,61 @@ cell PriceFeedFeelib::New(
     );
 }
 
-(int, int, int, int) PriceFeedFeelib::utils::deserializeStorage(cell $storage) inline {
-    ;; todo: optimize
+const int PriceFeedFeelib::_priceRatioOffset = _HEADER_WIDTH;
+const int PriceFeedFeelib::_gasPriceInUnitOffset = PriceFeedFeelib::_priceRatioOffset + 128;
+const int PriceFeedFeelib::_gasPerByteOffset = PriceFeedFeelib::_gasPriceInUnitOffset + 64;
+const int PriceFeedFeelib::_nativePriceUsdOffset = PriceFeedFeelib::_gasPerByteOffset + 32;
+
+
+;; ============================== Object Getters =========================================
+
+;; nativePriceUsd
+int PriceFeedFeelib::getNativePriceUsd(cell $self) impure inline {
+    return $self.cellPreloadCoinsAt(PriceFeedFeelib::_nativePriceUsdOffset);
+}
+
+;; ============================== Object Multi-Getters =========================================
+
+;; (priceRatio, gasPriceInUnit, gasPerByte)
+(int, int, int) PriceFeedFeelib::utils::getFirstThreeFields(cell $self) impure inline {
+    ;; slice selfSlice = $self.begin_parse().skip_bits(_HEADER_WIDTH);
+    slice selfSlice = $self.begin_parse();
     return (
-        $storage.cl::get<coins>(PriceFeedFeelib::priceRatio),
-        $storage.cl::get<uint64>(PriceFeedFeelib::gasPriceInUnit),
-        $storage.cl::get<uint32>(PriceFeedFeelib::gasPerByte),
-        $storage.cl::get<coins>(PriceFeedFeelib::nativePriceUsd)
+        selfSlice.preloadCoinsAt(PriceFeedFeelib::_priceRatioOffset),
+        selfSlice.preloadUint64At(PriceFeedFeelib::_gasPriceInUnitOffset),
+        selfSlice.preloadUint32At(PriceFeedFeelib::_gasPerByteOffset)
     );
+}
+
+;; (priceRatio, gasPriceInUnit, gasPerByte, nativePriceUsd)
+(int, int, int, int) PriceFeedFeelib::deserialize(cell $storage) impure inline {
+    slice selfSlice = $storage.begin_parse();
+    return (
+        selfSlice.preloadCoinsAt(PriceFeedFeelib::_priceRatioOffset),
+        selfSlice.preloadUint64At(PriceFeedFeelib::_gasPriceInUnitOffset),
+        selfSlice.preloadUint32At(PriceFeedFeelib::_gasPerByteOffset),
+        selfSlice.preloadCoinsAt(PriceFeedFeelib::_nativePriceUsdOffset)
+    );
+}
+
+cell PriceFeedFeelib::setNativePriceUsd(cell $self, int nativePriceUsd) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(PriceFeedFeelib::_nativePriceUsdOffset, 0)) ;; everything up to nativePriceUsd
+        .store_uint128(nativePriceUsd) ;; new nativePriceUsd
+        .end_cell();
+}
+
+;; ============================== Object Setters =========================================
+
+;; (priceRatio, gasPriceInUnit, gasPerByte)
+cell PriceFeedFeelib::setFirstThreeFields(cell $self, int priceRatio, int gasPriceInUnit, int gasPerByte) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(_HEADER_WIDTH, 0)) ;; header
+        .store_uint128(priceRatio)                          ;; new priceRatio
+        .store_uint64(gasPriceInUnit)                       ;; new gasPriceInUnit
+        .store_uint32(gasPerByte)                           ;; new gasPerByte
+        .store_slice(selfSlice.scutlast(128, 0))            ;; last 128 bits = old nativePriceUsd
+        .end_cell();
 }

package/src/workers/core/abstract/workerHandler.fc

@@ -32,10 +32,12 @@ tuple _newAction<event>(int topic, cell $body) impure inline {
 () assertInitialized() impure inline { }
 
 () assertAdmin() impure inline {
-    cell $admins = getCoreStorage().cl::get<cellRef>(WorkerCoreStorage::admins);
     throw_unless(
         Worker::ERROR::onlyAdmin, 
-        AddressList::includes(getCaller(), $admins.begin_parse())
+        AddressList::includes(
+            getCaller(), 
+            getAdmins().begin_parse()
+        )
     );
 }
 
@@ -55,7 +57,7 @@ tuple initialize(cell $mdAddress) impure inline {
 ;;; =================================== EVENT FUNCTIONS =================================
 
 int _getEventSink() impure inline method_id {
-    int eventSink = getCoreStorage().cl::get<address>(WorkerCoreStorage::proxy);
+    int eventSink = getProxyAddress();
     if (eventSink == NULLADDRESS) {
         return getContractAddress();
     }
@@ -64,7 +66,7 @@ int _getEventSink() impure inline method_id {
 
 int verifyEventOrigin(int address) method_id {
     return AddressList::includes(
-        address, getCoreStorage().cl::get<objRef>(WorkerCoreStorage::admins).begin_parse()
+        address, getAdmins().begin_parse()
     );
 }
 
@@ -82,10 +84,12 @@ tuple _claimTon(tuple actions, cell $coinsAmount) impure {
 }
 
 tuple _callContract(tuple actions, cell $executeParams) impure inline {
+    (int target, int opcode, cell callData) = $executeParams.md::ExecuteParams::getActionArgs();
+
     actions~pushAction<call>(
-        $executeParams.cl::get<address>(md::ExecuteParams::target),
-        $executeParams.cl::get<uint32>(md::ExecuteParams::opcode),
-        $executeParams.cl::get<objRef>(md::ExecuteParams::callData)
+        target,
+        opcode,
+        callData
     );
 
     return actions;
@@ -120,7 +124,8 @@ tuple _setProxyAddress(tuple actions, int newProxyAddress) impure {
 
 tuple _callViaProxy(tuple actions, cell $executeParams) impure {
     ;; only these opcodes are allowed to be called from the worker to the proxy
-    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    int opcode = $executeParams.md::ExecuteParams::getOpcode();
+
     throw_unless(
         Worker::ERROR::invalidSignedOpcode, 
         (opcode == Uln::OP::UPDATE_WORKER_FEELIB)
@@ -129,22 +134,18 @@ tuple _callViaProxy(tuple actions, cell $executeParams) impure {
         | (opcode == Worker::OP::CLAIM_TON)
     );
 
-    return _callContract(
-        actions,
-        md::ExecuteParams::New(
-            getProxyAddress(),
-            $executeParams,
-            0,
-            Proxy::OP::CALL_CONTRACT
-        )
+    actions~pushAction<call>(
+        getProxyAddress(),
+        Proxy::OP::CALL_CONTRACT,
+        $executeParams
     );
+
+    return actions;
 }
 
 ;;; =================================== VIEW FUNCTIONS =================================
 
 int getLatestAdmin() impure method_id {
-    slice adminSlice = getCoreStorage()
-        .cl::get<cellRef>(WorkerCoreStorage::admins)
-        .begin_parse();
+    slice adminSlice = getAdmins().begin_parse();
     return adminSlice~AddressList::next();
 }