@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.29

package/src/workers/core/interface.fc

@@ -15,11 +15,12 @@ const int Worker::OP::SET_PROXY = "Worker::OP::SET_PROXY"c;
 const int Worker::OP::SET_ADMINS = "Worker::OP::SET_ADMINS"c;
 
 ;;; ==========================ERRORS=====================================
+const int Worker::ERROR::invalidForwardingAddress = 2016;
 const int Worker::ERROR::onlyAdmin = 2015;
 const int Worker::ERROR::invalidOpcode = 2014;
 
 const int Worker::ERROR::invalidSignedOpcode = 2013;
-const int Worker::ERROR::invalidInnerTarget = 2012;
+const int Worker::ERROR::invalidTarget = 2012;
 
 ;;; ==========================EVENTS=====================================
 const int Worker::event::ADMINS_SET = "Worker::event::ADMINS_SET"u;

package/src/workers/core/workerCoreStorage.fc

@@ -39,6 +39,21 @@ cell setCoreStorage(cell $storage, cell $newCoreStorage) impure inline {
     return $storage.cl::set(WORKER_CORE_STORAGE_IDX, $newCoreStorage);
 }
 
+const int WorkerCoreStorage::_proxyOffset = _HEADER_WIDTH;
+const int WorkerCoreStorage::_versionOffset = WorkerCoreStorage::_proxyOffset + 256;
+
+cell WorkerCoreStorage::getAdmins(cell $self) impure inline {
+    return $self.cellPreloadRefAt(0);
+}
+
+int WorkerCoreStorage::getProxy(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(WorkerCoreStorage::_proxyOffset);
+}
+
 int getProxyAddress() impure inline {
-    return getCoreStorage().cl::get<address>(WorkerCoreStorage::proxy);
+    return getCoreStorage().WorkerCoreStorage::getProxy();
+}
+
+cell getAdmins() impure inline {
+    return getCoreStorage().WorkerCoreStorage::getAdmins();
 }

package/src/workers/dvn/handler.fc

@@ -135,10 +135,16 @@ tuple setVerifiers(cell $signedRequest) impure {
         incomingNonce != $storage.cl::get<uint64>(Dvn::setVerifiersNonce)
     );
     
-    int opcode = $setDict.cl::get<uint64>(md::SetDict::opcode);
+    int signedOpcode = $setDict.cl::get<uint64>(md::SetDict::opcode);
     throw_if(
         Worker::ERROR::invalidSignedOpcode,
-        opcode != Dvn::OP::SET_VERIFIERS
+        signedOpcode != Dvn::OP::SET_VERIFIERS
+    );
+
+    int target = $setDict.cl::get<address>(md::SetDict::target);
+    throw_if(
+        Worker::ERROR::invalidTarget,
+        target != getContractAddress()
     );
 
     actions = _verifySignatures(
@@ -172,10 +178,10 @@ tuple setQuorum(cell $signedRequest) impure {
         incomingNonce != $storage.cl::get<uint64>(Dvn::setQuorumNonce)
     );
 
-    int opcode = $setQuorum.cl::get<uint64>(md::SetQuorum::opcode);
+    int signedOpcode = $setQuorum.cl::get<uint64>(md::SetQuorum::opcode);
     throw_if(
         Worker::ERROR::invalidSignedOpcode,
-        opcode != Dvn::OP::SET_QUORUM
+        signedOpcode != Dvn::OP::SET_QUORUM
     );
 
     int newQuorum = $setQuorum.cl::get<uint64>(md::SetQuorum::quorum);
@@ -186,6 +192,12 @@ tuple setQuorum(cell $signedRequest) impure {
         (newQuorum < 1) | (newQuorum > cl::dict256::size($verifiers))
     );
 
+    int target = $setQuorum.cl::get<address>(md::SetQuorum::target);
+    throw_if(
+        Worker::ERROR::invalidTarget,
+        target != getContractAddress()
+    );
+
     actions = _verifySignatures(
         actions,
         $setQuorum.cl::hash(),
@@ -217,10 +229,16 @@ tuple setAdminsByQuorum(cell $signedRequest) impure {
         incomingNonce != $storage.cl::get<uint64>(Dvn::setAdminsByQuorumNonce)
     );
 
-    int opcode = $setDict.cl::get<uint64>(md::SetDict::opcode);
+    int signedOpcode = $setDict.cl::get<uint64>(md::SetDict::opcode);
     throw_if(
         Worker::ERROR::invalidSignedOpcode,
-        opcode != Dvn::OP::SET_ADMINS_BY_QUORUM
+        signedOpcode != Dvn::OP::SET_ADMINS_BY_QUORUM
+    );
+
+    int target = $setDict.cl::get<address>(md::SetDict::target);
+    throw_if(
+        Worker::ERROR::invalidTarget,
+        target != getContractAddress()
     );
 
     actions = _verifySignatures(
@@ -251,37 +269,51 @@ tuple setAdminsByQuorum(cell $signedRequest) impure {
 tuple verify(cell $signedRequest) impure inline {
     (cell $storage, tuple actions) = preamble();
 
-    cell $executeParams = $signedRequest.cl::get<objRef>(md::SignedRequest::request);
+    cell $executeParams = $signedRequest.md::SignedRequest::getRequest();
+
+    (
+        int expiration,
+        int target,
+        int signedOpcode,
+        int forwardingAddress
+    ) = $executeParams.md::ExecuteParams::deserialize();
 
     throw_if(
         Dvn::ERROR::expired,
         ;; now() counts as expired, per the EVM spec
-        $executeParams.cl::get<uint64>(md::ExecuteParams::expiration) <= now()
+        expiration <= now()
     );
-
-    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    
     throw_if(
         Worker::ERROR::invalidSignedOpcode,
-        opcode != Uln::OP::ULN_VERIFY
+        signedOpcode != Uln::OP::ULN_VERIFY
     );
 
+    throw_if(
+        Worker::ERROR::invalidTarget,
+        target != getContractAddress()
+    );
+
+    (int quorum, cell verifiers) = $storage.Dvn::getQuorumAndVerifiers();
+
     actions = _verifySignatures(
         actions,
         $executeParams.cl::hash(),
-        $signedRequest.cl::get<dict256>(md::SignedRequest::signatures),
-        $storage.cl::get<dict256>(Dvn::verifiers),
-        $storage.cl::get<uint64>(Dvn::quorum)
+        $signedRequest.md::SignedRequest::getSignatures(),
+        verifiers,
+        quorum
     );
 
-    return _callContract(
-        actions,
-        md::ExecuteParams::New(
-            getProxyAddress(),
-            $executeParams,
-            0,
-            Proxy::OP::CALL_CONTRACT
-        )
+    ;; for the inside call, the target is the proxy address
+    $executeParams = $executeParams.cl::set(md::ExecuteParams::target, forwardingAddress);
+
+    actions~pushAction<call>(
+        getProxyAddress(),
+        Proxy::OP::CALL_CONTRACT,
+        $executeParams
     );
+
+    return actions;
 }
 
 tuple verifyCallback(cell $verifyStatus) impure inline {
@@ -300,16 +332,22 @@ tuple setProxyAdmins(cell $signedRequest) impure inline {
         $executeParams.cl::get<uint64>(md::ExecuteParams::expiration) <= now()
     );
 
-    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    int signedOpcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
     throw_if(
         Worker::ERROR::invalidSignedOpcode,
-        opcode != Worker::OP::SET_ADMINS
+        signedOpcode != Worker::OP::SET_ADMINS
     );
 
     int target = $executeParams.cl::get<address>(md::ExecuteParams::target);
     throw_if(
-        Worker::ERROR::invalidInnerTarget,
-        target != getProxyAddress()
+        Worker::ERROR::invalidTarget,
+        target != getContractAddress()
+    );
+
+    int forwardingAddress = $executeParams.cl::get<address>(md::ExecuteParams::forwardingAddress);
+    throw_if(
+        Worker::ERROR::invalidForwardingAddress,
+        forwardingAddress != getProxyAddress()
     );
 
     cell $newAdminList = $executeParams.cl::get<objRef>(md::ExecuteParams::callData);
@@ -326,6 +364,9 @@ tuple setProxyAdmins(cell $signedRequest) impure inline {
         $storage.cl::get<uint64>(Dvn::quorum)
     );
 
+    ;; for the inside call, the target is the proxy address
+    $executeParams = $executeParams.cl::set(md::ExecuteParams::target, forwardingAddress);
+
     return _callContract(actions, $executeParams);
 }
 

package/src/workers/dvn/storage.fc

@@ -21,7 +21,20 @@ cell Dvn::New(cell admins, int version, int quorum, cell verifiers) method_id {
             [cl::t::dict256, verifiers],                                               ;; Dvn::verifiers
             [cl::t::uint64, 1],                                                        ;; Dvn::setQuorumNonce
             [cl::t::uint64, 1],                                                        ;; Dvn::setVerifiersNonce
-            [cl::t::uint64, 1]                                                        ;; Dvn::setAdminsByQuorumNonce
+            [cl::t::uint64, 1]                                                         ;; Dvn::setAdminsByQuorumNonce
         ])
     );
-}
+}
+
+const int Dvn::_quorumOffset = _HEADER_WIDTH;
+const int Dvn::_setQuorumNonceOffset = Dvn::_quorumOffset + 64;
+const int Dvn::_setVerifiersNonceOffset = Dvn::_setQuorumNonceOffset + 64;
+const int Dvn::_setAdminsByQuorumNonceOffset = Dvn::_setVerifiersNonceOffset + 64;
+
+(int, cell) Dvn::getQuorumAndVerifiers(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadUint64At(Dvn::_quorumOffset),
+        selfSlice.preloadRefAt(1)
+    );
+}

package/src/workers/executor/handler.fc

@@ -12,6 +12,7 @@
 #include "../proxy/interface.fc";
 
 #include "../msgdata/NativeDrop.fc";
+#include "../msgdata/DropEvent.fc";
 
 
 #include "interface.fc";
@@ -32,28 +33,34 @@ tuple _executorNativeDrop(tuple actions, cell $mdNativeDrop) impure inline {
     cell $storage = getContractStorage();
 
     int totalAmount = 0;
-    tuple payees = deserializePayees($mdNativeDrop.cl::get<cellRef>(md::NativeDrop::payees));
+    tuple payees = deserializePayees($mdNativeDrop.md::NativeDrop::getPayees());
 
     repeat (payees.tlen()) {
         [int payeeAddress, int nativeAmount] = payees~tpopPayee();
+        
         actions~pushAction<payment>(
             payeeAddress,
             nativeAmount,
             0
         );
+
+        actions~pushAction<event>(
+            Executor::event::NATIVE_DROP,
+            md::DropEvent::New(nativeAmount, payeeAddress)
+        );
         totalAmount += nativeAmount;
     }
 
     throw_if(
         Executor::ERROR::nativeDropTotalCapExceeded,
-        totalAmount > $storage.cl::get<coins>(Executor::nativeDropTotalCap)
+        totalAmount > $storage.Executor::getNativeDropTotalCap()
     );
 
     return actions;
 }
 
 tuple _executorLzReceivePrepare(tuple actions, cell $executeParams) impure inline {
-    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    int opcode = $executeParams.md::ExecuteParams::getOpcode();
     throw_unless(
         Worker::ERROR::invalidSignedOpcode,
         opcode == Channel::OP::LZ_RECEIVE_PREPARE
@@ -73,15 +80,20 @@ tuple executorLzReceivePrepare(cell $executeParams) impure inline {
 ;; md: $mdNativeDrop
 ;; obj: $executeParams for lzReceivePrepare
 tuple executorNativeDropAndLzReceivePrepare(cell $mdObj) impure inline {
+    (
+        cell $lzReceivePrepareMd,
+        cell $nativeDropMd
+    ) = $mdObj.md::MdObj::deserialize();
+    
     return emptyActions()
-        ._executorNativeDrop($mdObj.cl::get<objRef>(md::MdObj::obj))
-        ._executorLzReceivePrepare($mdObj.cl::get<objRef>(md::MdObj::md));
+        ._executorNativeDrop($nativeDropMd)
+        ._executorLzReceivePrepare($lzReceivePrepareMd);
 }
 
 tuple executorLzReceiveAlert(cell $executeParams) impure inline {
     tuple actions = emptyActions();
 
-    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    int opcode = $executeParams.md::ExecuteParams::getOpcode();
     throw_unless(
         Worker::ERROR::invalidSignedOpcode,
         opcode == Channel::OP::EMIT_LZ_RECEIVE_ALERT

package/src/workers/executor/interface.fc

@@ -14,6 +14,7 @@ const int Executor::OP::LZ_RECEIVE_ALERT = "Executor::OP::LZ_RECEIVE_ALERT"c;
 
 ;; --------- Events ---------
 const int Executor::event::LZ_RECEIVE_ALERT = "Executor::event::LZ_RCV_ALERT"u;
+const int Executor::event::NATIVE_DROP = "Executor::event::NATIVE_DROP"u;
 
 ;; --------- Errors ---------
 const int Executor::ERROR::nativeDropTotalCapExceeded = 1951;

package/src/workers/executor/storage.fc

@@ -16,4 +16,11 @@ cell Executor::New(cell admins, int version, int nativeDropTotalCap) method_id {
             [cl::t::coins, nativeDropTotalCap]                                     ;; Executor::nativeDropTotalCap
         ])
     );
-}
+}
+
+const int Executor::_nativeDropTotalCapOffset = _HEADER_WIDTH;
+
+int Executor::getNativeDropTotalCap(cell $self) impure inline {
+    return $self.cellPreloadCoinsAt(Executor::_nativeDropTotalCapOffset);
+}
+

package/src/workers/msgdata/DropEvent.fc

@@ -0,0 +1,18 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int md::DropEvent::NAME = "DropEvent"u;
+
+;; field names
+const int md::DropEvent::nativeAmount = 0;
+const int md::DropEvent::receiver = 1;
+
+cell md::DropEvent::New(int nativeAmount, int receiver) inline method_id {
+    return cl::declare(
+        md::DropEvent::NAME,
+        unsafeTuple([   
+            [cl::t::coins, nativeAmount],
+            [cl::t::address, receiver]
+        ])
+    );
+}

package/src/workers/msgdata/ExecuteParams.fc

@@ -15,15 +15,78 @@ const int md::ExecuteParams::target = 0;
 const int md::ExecuteParams::callData = 1;
 const int md::ExecuteParams::expiration = 2;
 const int md::ExecuteParams::opcode = 3;
+const int md::ExecuteParams::forwardingAddress = 4;
 
-cell md::ExecuteParams::New(int target, cell callData, int expiration, int opcode) method_id {
+cell md::ExecuteParams::New(
+    int target,
+    cell callData,
+    int expiration,
+    int opcode,
+    int forwardingAddress
+) method_id {
     return cl::declare(
         md::ExecuteParams::NAME,
         unsafeTuple([
             [cl::t::address, target],             ;; md::ExecuteParams::target
             [cl::t::objRef, callData],            ;; md::ExecuteParams::callData
             [cl::t::uint64, expiration],          ;; md::ExecuteParams::expiration
-            [cl::t::uint32, opcode]               ;; md::ExecuteParams::opcode
+            [cl::t::uint32, opcode],              ;; md::ExecuteParams::opcode
+            [cl::t::address, forwardingAddress]    ;; md::ExecuteParams::forwardingAddress
         ])
     );
-}
+}
+
+;; ========================== Object Builders=====================================
+
+const int md::ExecuteParams::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 5);
+const int md::ExecuteParams::_headerFillerBits = _HEADER_WIDTH - md::ExecuteParams::_headerInfoBits;
+
+cell md::ExecuteParams::build(
+    int target,
+    cell callData,
+    int expiration,
+    int opcode,
+    int forwardingAddress
+) inline {
+    return begin_cell()
+        .store_uint(593196021158614130743421175296147950525415477349115, md::ExecuteParams::_headerInfoBits)
+        .store_ones(md::ExecuteParams::_headerFillerBits)
+        .store_uint256(target)
+        .store_ref(callData)
+        .store_uint64(expiration)
+        .store_uint32(opcode)
+        .store_uint256(forwardingAddress)
+        .end_cell();
+}
+
+;; ========================== Object Getters=====================================
+
+const int md::ExecuteParams::_targetOffset = _HEADER_WIDTH;
+const int md::ExecuteParams::_expirationOffset = md::ExecuteParams::_targetOffset + 256;
+const int md::ExecuteParams::_opcodeOffset = md::ExecuteParams::_expirationOffset + 64;
+const int md::ExecuteParams::_forwardingAddressOffset = md::ExecuteParams::_opcodeOffset + 32;
+
+int md::ExecuteParams::getOpcode(cell $self) impure inline {
+    return $self.cellPreloadUint32At(md::ExecuteParams::_opcodeOffset);
+}
+
+;; (expiration, target, opcode, forwardingAddress)
+(int, int, int, int) md::ExecuteParams::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadUint64At(md::ExecuteParams::_expirationOffset),
+        selfSlice.preloadAddressAt(md::ExecuteParams::_targetOffset),
+        selfSlice.preloadUint32At(md::ExecuteParams::_opcodeOffset),
+        selfSlice.preloadAddressAt(md::ExecuteParams::_forwardingAddressOffset)
+    );
+}
+
+;; (target, opcode, callData)
+(int, int, cell) md::ExecuteParams::getActionArgs(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadAddressAt(md::ExecuteParams::_targetOffset),
+        selfSlice.preloadUint32At(md::ExecuteParams::_opcodeOffset),
+        selfSlice.preload_ref_at(0)
+    );
+}

package/src/workers/msgdata/NativeDrop.fc

@@ -13,4 +13,8 @@ cell md::NativeDrop::New(cell payees) inline method_id {
             [cl::t::cellRef, payees]  ;; md::NativeDrop::payees
         ])
     );
+}
+
+cell md::NativeDrop::getPayees(cell $self) impure inline {
+    return $self.cellPreloadRefAt(0);
 }

package/src/workers/msgdata/SetDict.fc

@@ -7,14 +7,16 @@ const int md::SetDict::NAME = "setDct"u;
 const int md::SetDict::nonce = 0;
 const int md::SetDict::opcode = 1;
 const int md::SetDict::dict = 2;
+const int md::SetDict::target = 3;
 
-cell md::SetDict::New(int nonce, int opcode, cell _dict) inline method_id {
+cell md::SetDict::New(int nonce, int opcode, cell _dict, int target) inline method_id {
     return cl::declare(
         md::SetDict::NAME,
         unsafeTuple([
-            [cl::t::uint64, nonce],  ;; md::SetDict::nonce
-            [cl::t::uint64, opcode], ;; md::SetDict::opcode
-            [cl::t::dict256, _dict]  ;; md::SetDict::dict
+            [cl::t::uint64, nonce],   ;; md::SetDict::nonce
+            [cl::t::uint64, opcode],  ;; md::SetDict::opcode
+            [cl::t::dict256, _dict],  ;; md::SetDict::dict
+            [cl::t::address, target]   ;; md::SetDict::target
         ])
     );
 }

package/src/workers/msgdata/SetQuorum.fc

@@ -7,14 +7,16 @@ const int md::SetQuorum::NAME = "setQuorum"u;
 const int md::SetQuorum::nonce = 0;
 const int md::SetQuorum::opcode = 1;
 const int md::SetQuorum::quorum = 2;
+const int md::SetQuorum::target = 3;
 
-cell md::SetQuorum::New(int nonce, int opcode, int quorum) inline method_id {
+cell md::SetQuorum::New(int nonce, int opcode, int quorum, int target) inline method_id {
     return cl::declare(
         md::SetQuorum::NAME,
         unsafeTuple([
             [cl::t::uint64, nonce],     ;; md::SetQuorum::nonce
             [cl::t::uint64, opcode],    ;; md::SetQuorum::opcode
-            [cl::t::uint64, quorum]     ;; md::SetQuorum::quorum
+            [cl::t::uint64, quorum],   ;; md::SetQuorum::quorum
+            [cl::t::address, target]    ;; md::SetQuorum::target
         ])
     );
 }

package/src/workers/msgdata/SignedRequest.fc

@@ -16,3 +16,11 @@ cell md::SignedRequest::New(cell $request, cell signatures) method_id {
         ])
     );
 }
+
+cell md::SignedRequest::getRequest(cell $self) impure inline {
+    return $self.begin_parse().preload_ref_at(0);
+}
+
+cell md::SignedRequest::getSignatures(cell $self) impure inline {
+    return $self.begin_parse().preload_ref_at(1);
+}

package/src/workers/priceFeedCache/handler.fc

@@ -37,35 +37,30 @@ tuple claimTon(cell $coinsAmount) impure inline {
 tuple updatePrice(cell $mdAddress) impure inline {
     (cell $storage, tuple actions) = preamble(); 
 
-    cell $ulnPriceFeed = $mdAddress.cl::get<objRef>(md::MdAddress::md);
+    (cell $ulnPriceFeed, int targetAddress) = $mdAddress.md::MdAddress::deserialize();
+    (
+        int priceRatio,
+        int gasPriceInUnit,
+        int gasPerByte
+    ) = PriceFeedFeelib::utils::getFirstThreeFields($ulnPriceFeed);
 
     cell $pfStorage = $storage
-        .cl::get<objRef>(PriceFeedCache::priceFeedFeeLibStorage)
-            .cl::set(
-                PriceFeedFeelib::priceRatio,
-                $ulnPriceFeed.cl::get<coins>(PriceFeedFeelib::priceRatio)
-            )
-            .cl::set(
-                PriceFeedFeelib::gasPriceInUnit,
-                $ulnPriceFeed.cl::get<uint64>(PriceFeedFeelib::gasPriceInUnit)
-            )
-            .cl::set(
-                PriceFeedFeelib::gasPerByte,
-                $ulnPriceFeed.cl::get<uint32>(PriceFeedFeelib::gasPerByte)
-            );
+        .PriceFeedCache::getPriceFeedFeeLibStorage()
+        .PriceFeedFeelib::setFirstThreeFields(priceRatio, gasPriceInUnit, gasPerByte);
 
     setContractStorage(
-        $storage.cl::set(PriceFeedCache::priceFeedFeeLibStorage, $pfStorage)
+        $storage.PriceFeedCache::setPriceFeedFeeLibStorage($pfStorage)
     );
 
     ;; call into the proxy to update the priceFeedFeeLib
     return _callViaProxy(
         actions,
         md::ExecuteParams::New(
-            $mdAddress.cl::get<address>(md::MdAddress::address), ;; target address, usually the uln
+            targetAddress, ;; usually the uln
             $pfStorage, ;; new priceFeedFeeLib storage
             0,
-            Uln::OP::UPDATE_WORKER_FEELIB
+            Uln::OP::UPDATE_WORKER_FEELIB,
+            NULLADDRESS
         )
     );
 }
@@ -73,27 +68,26 @@ tuple updatePrice(cell $mdAddress) impure inline {
 tuple updateNativePrice(cell $mdAddress) impure inline {
     (cell $storage, tuple actions) = preamble();
 
-    cell $ulnPriceFeed = $mdAddress.cl::get<objRef>(md::MdAddress::md);
+    (cell $ulnPriceFeed, int targetAddress) = $mdAddress.md::MdAddress::deserialize();
+    int nativePriceUsd = $ulnPriceFeed.PriceFeedFeelib::getNativePriceUsd();
 
     cell $pfStorage = $storage
-        .cl::get<objRef>(PriceFeedCache::priceFeedFeeLibStorage)
-        .cl::set(
-            PriceFeedFeelib::nativePriceUsd,
-            $ulnPriceFeed.cl::get<coins>(PriceFeedFeelib::nativePriceUsd)
-        );
+        .PriceFeedCache::getPriceFeedFeeLibStorage()
+        .PriceFeedFeelib::setNativePriceUsd(nativePriceUsd);
 
     setContractStorage(
-        $storage.cl::set(PriceFeedCache::priceFeedFeeLibStorage, $pfStorage)
+        $storage.PriceFeedCache::setPriceFeedFeeLibStorage($pfStorage)
     );
 
     ;; call into the proxy to update the priceFeedFeeLib
     return _callViaProxy(
         actions,
-        md::ExecuteParams::New(
-            $mdAddress.cl::get<address>(md::MdAddress::address), ;; target address, usually the uln
+        md::ExecuteParams::build(
+            targetAddress, ;; usually the uln
             $pfStorage, ;; new priceFeedFeeLib storage
             0,
-            Uln::OP::UPDATE_WORKER_FEELIB
+            Uln::OP::UPDATE_WORKER_FEELIB,
+            NULLADDRESS
         )
     );
 }

package/src/workers/priceFeedCache/storage.fc

@@ -2,6 +2,9 @@
 
 #include "../core/workerCoreStorage.fc";
 
+#include "../../protocol/msglibs/ultralightnode/workerFeeLibs/priceFeedFeeLib/storage.fc";
+
+
 ;; required object name
 const int PriceFeedCache::NAME = "pfCache"u;
 
@@ -18,4 +21,16 @@ cell PriceFeedCache::New(cell admins, int version, cell $priceFeedFeeLib) method
             [cl::t::objRef, $priceFeedFeeLib]                                      ;; PriceFeedCache::priceFeedFeeLibStorage
         ])
     );
-}
+}
+
+cell PriceFeedCache::getPriceFeedFeeLibStorage(cell $self) impure inline {
+    return $self.cellPreloadRefAt(1);
+}
+
+cell PriceFeedCache::setPriceFeedFeeLibStorage(cell $self, cell $priceFeedFeeLibStorage) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(_HEADER_WIDTH, 1)) ;; header + refs[0]
+        .store_ref($priceFeedFeeLibStorage)                 ;; new refs[1]
+        .end_cell();
+}

package/src/workers/proxy/handler.fc

@@ -57,7 +57,8 @@ tuple callback(cell $md) impure inline {
                 getCaller(),
                 $md,
                 0,
-                getOpcode()
+                getOpcode(),
+                NULLADDRESS
             )
         );
     }

package/src/workers/proxy/storage.fc

@@ -18,4 +18,4 @@ cell Proxy::New(cell admins, int version) method_id {
             [cl::t::bool, false] ;; Proxy::callbackEnabled
         ])
     );
-}
+}

package/tests/baseContractTest.fc

@@ -7,7 +7,6 @@
 #include "../src/funC++/actions/sendJettons.fc";
 #include "../src/funC++/actions/call.fc";
 #include "../src/funC++/actions/deploy.fc";
-#include "../src/funC++/actions/destroy.fc";
 #include "../src/funC++/actions/dispatch.fc";
 #include "../src/funC++/actions/payment.fc";
 
@@ -80,10 +79,7 @@ cell baseTest::prepare(tuple args) impure {
         int actionType = actualAction.int_at(0);
         int equal = false;
 
-        if (actionType == action::destroy::NAME) {
-            terminalIndices = terminalIndices.tpush(index);
-            equal = action::destroy::equals(actualAction, expectedAction);
-        } elseif (actionType == action::deploy::NAME) {
+        if (actionType == action::deploy::NAME) {
             terminalIndices = terminalIndices.tpush(index);
             equal = action::deploy::equals(actualAction, expectedAction);
         } elseif (actionType == action::call::NAME) {
@@ -135,7 +131,7 @@ cell baseTest::prepare(tuple args) impure {
         } elseif (txnContext.at(index).is_cell()) {
             mismatch = (txnContext.cell_at(index).cell_hash() != expectedTxnContext.cell_at(index).cell_hash());
         } elseif (txnContext.at(index).is_slice()) {
-            mismatch = (~ txnContext.slice_at(index).equal_slices(expectedTxnContext.slice_at(index)));
+            mismatch = (~ txnContext.slice_at(index).equal_slice_bits(expectedTxnContext.slice_at(index)));
         } else {
             mismatch = (~ txnContext.cell_at(index).cl::hash() == expectedTxnContext.cell_at(index).cl::hash());
         }