@layerzerolabs/layerzero-v2-ton 3.0.41 → 3.0.43

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/priceFeedFeeLib/optimism/main.fc

@@ -0,0 +1,2 @@
+#include "handler.fc";
+() main() { }

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

@@ -6,31 +6,37 @@ const int PRICE_RATIO_DENOMINATOR = 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 10
 
 ;; Bytecodes
 const int PriceFeedFeelib::priceRatio = 0;
-const int PriceFeedFeelib::gasPriceInUnit = 1;
+const int PriceFeedFeelib::gasPriceInRemoteUnit = 1;
 const int PriceFeedFeelib::gasPerByte = 2;
 const int PriceFeedFeelib::nativePriceUsd = 3;
+const int PriceFeedFeelib::arbitrumExtension = 4;
+const int PriceFeedFeelib::optimismExtension = 5;
 
 ;; @owner LayerZero admin EOA
 cell PriceFeedFeelib::New(
     int priceRatio,
-    int gasPriceInUnit,
+    int gasPriceInRemoteUnit,
     int gasPerByte,
-    int nativePriceUsd
+    int nativePriceUsd,
+    cell arbitrumExtension,
+    cell optimismExtension
 ) method_id {
     return cl::declare(
         PriceFeedFeelib::NAME,
         unsafeTuple([
-            [cl::t::coins, priceRatio],         ;; PriceFeedFeelib::priceRatio
-            [cl::t::uint64, gasPriceInUnit],    ;; PriceFeedFeelib::gasPriceInUnit
-            [cl::t::uint32, gasPerByte],        ;; PriceFeedFeelib::gasPerByte
-            [cl::t::coins, nativePriceUsd]      ;; PriceFeedFeelib::nativePriceUsd
+            [cl::t::coins, priceRatio],                ;; PriceFeedFeelib::priceRatio
+            [cl::t::uint64, gasPriceInRemoteUnit],     ;; PriceFeedFeelib::gasPriceInRemoteUnit
+            [cl::t::uint32, gasPerByte],               ;; PriceFeedFeelib::gasPerByte
+            [cl::t::coins, nativePriceUsd],            ;; PriceFeedFeelib::nativePriceUsd
+            [cl::t::objRef, arbitrumExtension],        ;; PriceFeedFeelib::arbitrumExtension
+            [cl::t::objRef, optimismExtension]         ;; PriceFeedFeelib::optimismExtension
         ])
     );
 }
 
 const int PriceFeedFeelib::_priceRatioOffset = _HEADER_WIDTH;
-const int PriceFeedFeelib::_gasPriceInUnitOffset = PriceFeedFeelib::_priceRatioOffset + 128;
-const int PriceFeedFeelib::_gasPerByteOffset = PriceFeedFeelib::_gasPriceInUnitOffset + 64;
+const int PriceFeedFeelib::_gasPriceInRemoteUnitOffset = PriceFeedFeelib::_priceRatioOffset + 128;
+const int PriceFeedFeelib::_gasPerByteOffset = PriceFeedFeelib::_gasPriceInRemoteUnitOffset + 64;
 const int PriceFeedFeelib::_nativePriceUsdOffset = PriceFeedFeelib::_gasPerByteOffset + 32;
 
 
@@ -43,46 +49,113 @@ int PriceFeedFeelib::getNativePriceUsd(cell $self) impure inline {
 
 ;; ============================== Object Multi-Getters =========================================
 
-;; (priceRatio, gasPriceInUnit, gasPerByte)
+;; (priceRatio, gasPriceInRemoteUnit, 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 (
         selfSlice.preloadCoinsAt(PriceFeedFeelib::_priceRatioOffset),
-        selfSlice.preloadUint64At(PriceFeedFeelib::_gasPriceInUnitOffset),
+        selfSlice.preloadUint64At(PriceFeedFeelib::_gasPriceInRemoteUnitOffset),
         selfSlice.preloadUint32At(PriceFeedFeelib::_gasPerByteOffset)
     );
 }
 
-;; (priceRatio, gasPriceInUnit, gasPerByte, nativePriceUsd)
-(int, int, int, int) PriceFeedFeelib::deserialize(cell $storage) impure inline {
+cell PriceFeedFeelib::getArbitrumExtension(cell $self) impure inline {
+    return $self.cellPreloadRefAt(0);
+}
+
+cell PriceFeedFeelib::getOptimismExtension(cell $self) impure inline {
+    return $self.cellPreloadRefAt(1);
+}
+
+;; (priceRatio, gasPriceInRemoteUnit, gasPerByte, nativePriceUsd)
+(int, int, int, int) PriceFeedFeelib::deserializeInts(cell $storage) impure inline {
     slice selfSlice = $storage.begin_parse();
     return (
         selfSlice.preloadCoinsAt(PriceFeedFeelib::_priceRatioOffset),
-        selfSlice.preloadUint64At(PriceFeedFeelib::_gasPriceInUnitOffset),
+        selfSlice.preloadUint64At(PriceFeedFeelib::_gasPriceInRemoteUnitOffset),
         selfSlice.preloadUint32At(PriceFeedFeelib::_gasPerByteOffset),
         selfSlice.preloadCoinsAt(PriceFeedFeelib::_nativePriceUsdOffset)
     );
 }
 
+;; (priceRatio, gasPriceInRemoteUnit, gasPerByte, nativePriceUsd, arbitrumExtension, optimismExtension)
+(int, int, int, int, cell, cell) PriceFeedFeelib::deserialize(cell $storage) impure inline {
+    slice selfSlice = $storage.begin_parse();
+    return (
+        selfSlice.preloadCoinsAt(PriceFeedFeelib::_priceRatioOffset),
+        selfSlice.preloadUint64At(PriceFeedFeelib::_gasPriceInRemoteUnitOffset),
+        selfSlice.preloadUint32At(PriceFeedFeelib::_gasPerByteOffset),
+        selfSlice.preloadCoinsAt(PriceFeedFeelib::_nativePriceUsdOffset),
+        selfSlice.preloadRefAt(0),
+        selfSlice.preloadRefAt(1)
+    );
+}
+
+;; ============================== Object Setters =========================================
+
+;; (priceRatio, gasPriceInRemoteUnit, gasPerByte)
+cell PriceFeedFeelib::setFirstThreeFields(
+    cell $self, 
+    int priceRatio, 
+    int gasPriceInRemoteUnit, 
+    int gasPerByte
+) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(_HEADER_WIDTH, 2)) ;; header + refs
+        .store_uint128(priceRatio)                          ;; new priceRatio
+        .store_uint64(gasPriceInRemoteUnit)                 ;; new gasPriceInRemoteUnit
+        .store_uint32(gasPerByte)                           ;; new gasPerByte
+        .store_slice(selfSlice.scutlast(128, 0))            ;; last 128 bits = old nativePriceUsd
+        .end_cell();
+}
+
 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_slice(selfSlice.scutfirst(PriceFeedFeelib::_nativePriceUsdOffset, 2)) ;; 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 {
+cell PriceFeedFeelib::setPricesAndOptimismExtension(
+    cell $self, 
+    int priceRatio, 
+    int gasPriceInRemoteUnit, 
+    int gasPerByte,
+    cell $optimismExtension
+) impure inline {
     slice selfSlice = $self.begin_parse();
     return begin_cell()
-        .store_slice(selfSlice.scutfirst(_HEADER_WIDTH, 0)) ;; header
+        .store_slice(selfSlice.scutfirst(_HEADER_WIDTH, 1)) ;; header + old arbitrumExtension
         .store_uint128(priceRatio)                          ;; new priceRatio
-        .store_uint64(gasPriceInUnit)                       ;; new gasPriceInUnit
+        .store_uint64(gasPriceInRemoteUnit)                 ;; new gasPriceInRemoteUnit
         .store_uint32(gasPerByte)                           ;; new gasPerByte
         .store_slice(selfSlice.scutlast(128, 0))            ;; last 128 bits = old nativePriceUsd
+        .store_ref($optimismExtension)                     ;; new optimismExtension
+        .end_cell();
+}
+
+cell PriceFeedFeelib::setNativePriceUsdAndOptimismExtension(
+    cell $self, 
+    int nativePriceUsd,
+    cell $optimismExtension
+) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(PriceFeedFeelib::_nativePriceUsdOffset, 1))  ;; bits up to nativePriceUsd + old arbitrumExtension
+        .store_uint128(nativePriceUsd)                       ;; new nativePriceUsd
+        .store_ref($optimismExtension)                       ;; new optimismExtension
+        .end_cell();
+}
+
+
+cell PriceFeedFeelib::setArbitrumExtension(cell $self, cell $arbitrumExtension) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return begin_cell()
+        .store_slice(selfSlice.sskipfirst(0, 2))           ;; same bits, no refs
+        .store_ref($arbitrumExtension)                     ;; new arbitrumExtension
+        .store_ref(selfSlice.preloadRefAt(1))              ;; same optimismExtension
         .end_cell();
 }

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

@@ -1,8 +1,10 @@
+#include "../interface.fc";
 #include "../../../funC++/handlerCore.fc";
 
 #include "../../../funC++/actions/call.fc";
 #include "../../../funC++/actions/event.fc";
 #include "../../../funC++/actions/payment.fc";
+#include "../../../funC++/actions/dispatch.fc";
 
 #include "../../../classes/msgdata/CoinsAmount.fc";
 #include "../../../classes/msgdata/SetAddress.fc";
@@ -15,6 +17,7 @@
 #include "../../../protocol/msglibs/ultralightnode/ulnManager/interface.fc";
 #include "../../proxy/interface.fc";
 #include "../workerCoreStorage.fc";
+#include "../../../funC++/utils.fc";
 
 cell getInitialStorage() impure inline {
     return empty_cell();
@@ -73,12 +76,28 @@ int verifyEventOrigin(int address) method_id {
 
 ;;; =================================== (HANDLER) HELPER FUNCTIONS =================================
 
+const int ONE_TON = 1000000000; ;; 1 ton is equivalent to 10^9 nanotons
+
 tuple _claimTon(tuple actions, cell $claimTon) impure {
+
+    int contractBalance = getInitialContractBalance();
+    int claimAmount = $claimTon.cl::get<coins>(md::ClaimTon::amount);
+
+    throw_unless(
+        Worker::ERROR::insufficientBalance,
+        (contractBalance >= (claimAmount + ONE_TON))
+    );
+
     ;; this amount will be paid from the contract balance
     actions~pushAction<payment>(
         $claimTon.cl::get<address>(md::ClaimTon::target),
-        $claimTon.cl::get<coins>(md::ClaimTon::amount),
-        $claimTon.cl::get<coins>(md::ClaimTon::amount)
+        claimAmount,
+        claimAmount
+    );
+
+    actions~pushAction<event>(
+        Worker::event::CLAIMED_TON,
+        $claimTon
     );
 
     return actions;
@@ -91,6 +110,11 @@ tuple _claimTonFromProxy(tuple actions, cell $claimTon) impure {
         $claimTon
     );
 
+    actions~pushAction<event>(
+        Worker::event::CLAIMED_TON_FROM_PROXY,
+        $claimTon
+    );
+
     return actions;
 }
 
@@ -153,6 +177,17 @@ tuple _callViaProxy(tuple actions, cell $executeParams) impure {
     return actions;
 }
 
+tuple _emitViaProxy(tuple actions, int topic, cell $body) impure {
+    actions~pushAction<dispatch>(
+        getProxyAddress(),
+        Proxy::OP::EMIT_EVENT,
+        action::event::build(topic, $body, cl::nullObject()),
+        _gasToNanoton(PROXY_CALL_DEFAULT_GAS)
+    );
+
+    return actions;
+}
+
 ;;; =================================== VIEW FUNCTIONS =================================
 
 int getLatestAdmin() impure method_id {

package/src/workers/core/interface.fc

@@ -22,6 +22,10 @@ const int Worker::ERROR::invalidOpcode = 2014;
 
 const int Worker::ERROR::invalidSignedOpcode = 2013;
 const int Worker::ERROR::invalidTarget = 2012;
-
+const int Worker::ERROR::insufficientBalance = 2011;
 ;;; ==========================EVENTS=====================================
-const int Worker::event::ADMINS_SET = "Worker::event::ADMINS_SET"u;
+const int Worker::event::ADMINS_SET = "Worker::event::ADMINS_SET"u;
+const int Worker::event::CLAIMED_TON = "Worker::event::CLAIMED_TON"u;
+const int Worker::event::CLAIMED_TON_FROM_PROXY = "Worker::event::CLAIMED_TON_PROXY"u;
+
+const int PROXY_CALL_DEFAULT_GAS = 1000000;

package/src/workers/dvn/handler.fc

@@ -75,6 +75,7 @@ tuple _verifySignatures(tuple actions, int hash, cell signatures, cell verifiers
                     validSignatures += 1;
                 }
             } else {
+                ;; emitting this from the proxy will cause the double-call issue
                 actions~pushAction<event>(
                     Dvn::event::INVALID_SIGNATURE,
                     begin_cell().store_uint256(indexedPublicKeyHash).end_cell()
@@ -162,7 +163,10 @@ tuple setVerifiers(cell $signedRequest) impure {
             .cl::set(Dvn::setVerifiersNonce, incomingNonce + 1)
     );
 
-    actions~pushAction<event>(Dvn::event::SET_VERIFIERS, $setDict);
+    actions = actions._emitViaProxy(
+        Dvn::event::SET_VERIFIERS,
+        $setDict
+    );
 
     return actions;
 }
@@ -213,7 +217,10 @@ tuple setQuorum(cell $signedRequest) impure {
             .cl::set(Dvn::setQuorumNonce, incomingNonce + 1)
     );
 
-    actions~pushAction<event>(Dvn::event::SET_QUORUM, $setQuorum);
+    actions = actions._emitViaProxy(
+        Dvn::event::SET_QUORUM,
+        $setQuorum
+    );
 
     return actions;
 }
@@ -250,7 +257,10 @@ tuple setAdminsByQuorum(cell $signedRequest) impure {
         $storage.cl::get<uint64>(Dvn::quorum)
     );
 
-    actions~pushAction<event>(Dvn::event::SET_ADMINS_BY_QUORUM, $setDict);
+    actions = actions._emitViaProxy(
+        Dvn::event::SET_ADMINS_BY_QUORUM,
+        $setDict
+    );
 
     setContractStorage(
         $storage

package/src/workers/executor/handler.fc

@@ -12,8 +12,6 @@
 #include "../proxy/interface.fc";
 
 #include "../msgdata/NativeDrop.fc";
-#include "../msgdata/DropEvent.fc";
-
 
 #include "interface.fc";
 #include "storage.fc";
@@ -30,12 +28,15 @@
 ;;; ==========================HANDLERS=====================================
 
 tuple _executorNativeDrop(tuple actions, cell $mdNativeDrop) impure inline {
+
     cell $storage = getContractStorage();
 
     int totalAmount = 0;
     tuple payees = deserializePayees($mdNativeDrop.md::NativeDrop::getPayees());
 
-    repeat (payees.tlen()) {
+    int numPayees = payees.tlen();
+
+    repeat (numPayees) {
         [int payeeAddress, int nativeAmount] = payees~tpopPayee();
         
         actions~pushAction<payment>(
@@ -44,11 +45,14 @@ tuple _executorNativeDrop(tuple actions, cell $mdNativeDrop) impure inline {
             0
         );
 
-        actions~pushAction<event>(
+        totalAmount += nativeAmount;
+    }
+
+    if (numPayees > 0) {
+        actions = actions._emitViaProxy(
             Executor::event::NATIVE_DROP,
-            md::DropEvent::New(nativeAmount, payeeAddress)
+            $mdNativeDrop
         );
-        totalAmount += nativeAmount;
     }
 
     throw_if(

package/src/workers/msgdata/ClaimTon.fc

@@ -11,7 +11,7 @@ cell md::ClaimTon::New(int amount, int target) inline method_id {
     return cl::declare(
         md::ClaimTon::NAME,
         unsafeTuple([
-            [cl::t::coins, amount], ;; md::ClaimTon::amount
+            [cl::t::coins, amount],  ;; md::ClaimTon::amount
             [cl::t::address, target] ;; md::ClaimTon::target
         ])
     );

package/src/workers/msgdata/NativeDrop.fc

@@ -5,12 +5,16 @@ const int md::NativeDrop::NAME = "NativeDrop"u;
 
 ;; field names
 const int md::NativeDrop::payees = 0;
+const int md::NativeDrop::packetId = 1;
+const int md::NativeDrop::msglib = 2;
 
-cell md::NativeDrop::New(cell payees) inline method_id {
+cell md::NativeDrop::New(cell payees, cell $packetId, int msglib) inline method_id {
     return cl::declare(
         md::NativeDrop::NAME,
         unsafeTuple([   
-            [cl::t::cellRef, payees]  ;; md::NativeDrop::payees
+            [cl::t::cellRef, payees],   ;; md::NativeDrop::payees
+            [cl::t::objRef, $packetId], ;; md::NativeDrop::packetId
+            [cl::t::address, msglib]    ;; md::NativeDrop::msgLib
         ])
     );
 }

package/src/workers/priceFeedCache/handler.fc

@@ -55,7 +55,7 @@ tuple updatePrice(cell $mdAddress) impure inline {
     ;; call into the proxy to update the priceFeedFeeLib
     return _callViaProxy(
         actions,
-        md::ExecuteParams::New(
+        md::ExecuteParams::build(
             targetAddress, ;; usually the uln
             $pfStorage, ;; new priceFeedFeeLib storage
             0,
@@ -71,12 +71,12 @@ tuple updateNativePrice(cell $mdAddress) impure inline {
     (cell $ulnPriceFeed, int targetAddress) = $mdAddress.md::MdAddress::deserialize();
     int nativePriceUsd = $ulnPriceFeed.PriceFeedFeelib::getNativePriceUsd();
 
-    cell $pfStorage = $storage
+    cell $newPfStorage = $storage
         .PriceFeedCache::getPriceFeedFeeLibStorage()
         .PriceFeedFeelib::setNativePriceUsd(nativePriceUsd);
 
     setContractStorage(
-        $storage.PriceFeedCache::setPriceFeedFeeLibStorage($pfStorage)
+        $storage.PriceFeedCache::setPriceFeedFeeLibStorage($newPfStorage)
     );
 
     ;; call into the proxy to update the priceFeedFeeLib
@@ -84,7 +84,127 @@ tuple updateNativePrice(cell $mdAddress) impure inline {
         actions,
         md::ExecuteParams::build(
             targetAddress, ;; usually the uln
-            $pfStorage, ;; new priceFeedFeeLib storage
+            $newPfStorage, ;; new priceFeedFeeLib storage
+            0,
+            Uln::OP::UPDATE_WORKER_FEELIB,
+            NULLADDRESS
+        )
+    );
+}
+
+;; ------- custom handlers for op/arb price feed caches -------
+
+;; update base price and op price
+tuple updateOpPrices(cell $mdAddress) impure inline {
+    (cell $storage, tuple actions) = preamble(); 
+
+    cell $oldPfStorage = $storage.PriceFeedCache::getPriceFeedFeeLibStorage();
+    cell $oldOpExtension = $oldPfStorage.PriceFeedFeelib::getOptimismExtension();
+
+    (cell $ulnPriceFeed, int targetAddress) = $mdAddress.md::MdAddress::deserialize();
+    (
+        int priceRatio,
+        int gasPriceInUnit,
+        int gasPerByte
+    ) = PriceFeedFeelib::utils::getFirstThreeFields($ulnPriceFeed);
+
+    cell $incomingOpExtension = $ulnPriceFeed.PriceFeedFeelib::getOptimismExtension();
+    (
+        int opPriceRatio,
+        int opGasPriceInUnit,
+        int opGasPerByte
+    ) = PriceFeedFeelib::utils::getFirstThreeFields($incomingOpExtension);
+
+    cell $newOpExtension = $oldOpExtension.PriceFeedFeelib::setFirstThreeFields(
+        opPriceRatio,
+        opGasPriceInUnit,
+        opGasPerByte
+    );
+
+    cell $newPfStorage = $oldPfStorage
+        .PriceFeedFeelib::setPricesAndOptimismExtension(
+            priceRatio,
+            gasPriceInUnit,
+            gasPerByte,
+            $newOpExtension
+        );
+
+    setContractStorage(
+        $storage.PriceFeedCache::setPriceFeedFeeLibStorage($newPfStorage)
+    );
+
+    ;; call into the proxy to update the priceFeedFeeLib
+    return _callViaProxy(
+        actions,
+        md::ExecuteParams::build(
+            targetAddress, ;; usually the uln
+            $newPfStorage, ;; new priceFeedFeeLib storage
+            0,
+            Uln::OP::UPDATE_WORKER_FEELIB,
+            NULLADDRESS
+        )
+    );
+}
+
+;; update base native price and op native price
+tuple updateOpNativePrices(cell $mdAddress) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $oldPfStorage = $storage.PriceFeedCache::getPriceFeedFeeLibStorage();
+    cell $oldOpExtension = $oldPfStorage.PriceFeedFeelib::getOptimismExtension();
+
+    (cell $ulnPriceFeed, int targetAddress) = $mdAddress.md::MdAddress::deserialize();
+
+    int nativePriceUsd = $ulnPriceFeed.PriceFeedFeelib::getNativePriceUsd();
+    cell $incomingOpExtension = $ulnPriceFeed.PriceFeedFeelib::getOptimismExtension();
+
+    int opNativePriceUsd = $incomingOpExtension.PriceFeedFeelib::getNativePriceUsd();
+    cell $newOpExtension = $oldOpExtension.PriceFeedFeelib::setNativePriceUsd(opNativePriceUsd);
+
+    cell $newPfStorage = $oldPfStorage
+        .PriceFeedFeelib::setNativePriceUsdAndOptimismExtension(
+            nativePriceUsd,
+            $newOpExtension
+        );
+
+    setContractStorage(
+        $storage.PriceFeedCache::setPriceFeedFeeLibStorage($newPfStorage)
+    );
+
+    ;; call into the proxy to update the priceFeedFeeLib
+    return _callViaProxy(
+        actions,
+        md::ExecuteParams::build(
+            targetAddress, ;; usually the uln
+            $newPfStorage, ;; new priceFeedFeeLib storage
+            0,
+            Uln::OP::UPDATE_WORKER_FEELIB,
+            NULLADDRESS
+        )
+    );
+}
+
+;; update arb extension
+tuple updateArbExtension(cell $mdAddress) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    (cell $ulnPriceFeed, int targetAddress) = $mdAddress.md::MdAddress::deserialize();
+    cell $arbExtension = $ulnPriceFeed.PriceFeedFeelib::getArbitrumExtension();
+
+    cell $newPfStorage = $storage
+        .PriceFeedCache::getPriceFeedFeeLibStorage()
+        .PriceFeedFeelib::setArbitrumExtension($arbExtension);
+
+    setContractStorage(
+        $storage.PriceFeedCache::setPriceFeedFeeLibStorage($newPfStorage)
+    );
+
+    ;; call into the proxy to update the priceFeedFeeLib
+    return _callViaProxy(
+        actions,
+        md::ExecuteParams::build(
+            targetAddress, ;; usually the uln
+            $newPfStorage, ;; new priceFeedFeeLib storage
             0,
             Uln::OP::UPDATE_WORKER_FEELIB,
             NULLADDRESS

package/src/workers/priceFeedCache/interface.fc

@@ -1,4 +1,7 @@
 ;;; ==========================OPCODES=====================================
 
 const int PriceFeedCache::OP::UPDATE_PRICE = "PriceFeedCache::OP::UPDATE_PRICE"c;
-const int PriceFeedCache::OP::UPDATE_NATIVE_PRICE = "PriceFeedCache::OP::UPDATE_NATIVE_PRICE"c;
+const int PriceFeedCache::OP::UPDATE_NATIVE_PRICE = "PriceFeedCache::OP::UPDATE_NATIVE_PRICE"c;
+const int PriceFeedCache::OP::UPDATE_OP_PRICES = "PriceFeedCache::OP::UPDATE_OP_PRICES"c;
+const int PriceFeedCache::OP::UPDATE_OP_NATIVE_PRICES = "PriceFeedCache::OP::UPDATE_OP_NATIVE_PRICES"c;
+const int PriceFeedCache::OP::UPDATE_ARB_EXTENSION = "PriceFeedCache::OP::UPDATE_ARB_EXTENSION"c;

package/src/workers/priceFeedCache/main.fc

@@ -9,6 +9,12 @@ tuple _executeOpcode(int op, cell $md) impure inline {
         return updatePrice($md);
     } elseif (op == PriceFeedCache::OP::UPDATE_NATIVE_PRICE) {
         return updateNativePrice($md);
+    } elseif (op == PriceFeedCache::OP::UPDATE_OP_PRICES) {
+        return updateOpPrices($md);
+    } elseif (op == PriceFeedCache::OP::UPDATE_OP_NATIVE_PRICES) {
+        return updateOpNativePrices($md);
+    } elseif (op == PriceFeedCache::OP::UPDATE_ARB_EXTENSION) {
+        return updateArbExtension($md);
     } elseif (op == Worker::OP::CALL_VIA_PROXY) {
         return callViaProxy($md);
     } elseif (op == Worker::OP::SET_ADMINS) {

package/src/workers/priceFeedCache/storage.fc

@@ -1,24 +1,25 @@
-#include "../../funC++/classlib.fc";
+    #include "../../funC++/classlib.fc";
 
 #include "../core/workerCoreStorage.fc";
 
 #include "../../protocol/msglibs/ultralightnode/workerFeeLibs/priceFeedFeeLib/storage.fc";
 
-
 ;; required object name
 const int PriceFeedCache::NAME = "pfCache"u;
 
 ;; field names
 const int PriceFeedCache::workerCoreStorage = 0;
 const int PriceFeedCache::priceFeedFeeLibStorage = 1;
+const int PriceFeedCache::dstEid = 2; ;; sharding key, unused in actual logic
 
 ;; @owner manager
-cell PriceFeedCache::New(cell admins, int version, cell $priceFeedFeeLib) method_id {
+cell PriceFeedCache::New(cell admins, int version, cell $priceFeedFeeLib, int dstEid) method_id {
     return cl::declare(
         PriceFeedCache::NAME,
         unsafeTuple([
-            [cl::t::objRef, WorkerCoreStorage::New(admins, NULLADDRESS, version)], ;; PriceFeedCache::workerCoreStorage
-            [cl::t::objRef, $priceFeedFeeLib]                                      ;; PriceFeedCache::priceFeedFeeLibStorage
+            [cl::t::objRef, WorkerCoreStorage::New(admins, NULLADDRESS, version)],  ;; PriceFeedCache::workerCoreStorage
+            [cl::t::objRef, $priceFeedFeeLib],                                      ;; PriceFeedCache::priceFeedFeeLibStorage
+            [cl::t::uint32, dstEid]                                                 ;; PriceFeedCache::dstEid
         ])
     );
 }
@@ -32,5 +33,6 @@ cell PriceFeedCache::setPriceFeedFeeLibStorage(cell $self, cell $priceFeedFeeLib
     return begin_cell()
         .store_slice(selfSlice.scutfirst(_HEADER_WIDTH, 1)) ;; header + refs[0]
         .store_ref($priceFeedFeeLibStorage)                 ;; new refs[1]
+        .store_uint32(selfSlice.preloadUint32At(_HEADER_WIDTH)) ;; dstEid
         .end_cell();
 }

package/src/workers/proxy/handler.fc

@@ -20,7 +20,10 @@
 
 ;; this is special in proxy, only the people in the address book can call 'callContract'
 () _checkPermissions(int op, cell $md) impure inline {
-    if (op == Proxy::OP::CALL_CONTRACT) {
+    if (
+        (op == Proxy::OP::CALL_CONTRACT)
+        | (op == Proxy::OP::EMIT_EVENT)
+    ) {
         return assertLatestAdmin();
     } elseif (
         (op == Worker::OP::SET_ADMINS)
@@ -46,6 +49,17 @@ tuple callContract(cell $executeParams) impure inline {
     return _callContract(emptyActions(), $executeParams);
 }
 
+tuple emitEvent(cell $event) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    actions~pushAction<event>(
+        $event.cl::get<uint256>(action::event::topic),
+        $event.cl::get<objRef>(action::event::body)
+    );
+
+    return actions;
+}
+
 tuple callback(cell $md) impure inline {
     (cell $storage, tuple actions) = preamble();
 

package/src/workers/proxy/interface.fc

@@ -1,5 +1,6 @@
 ;;; ==========================OPCODES=====================================
 const int Proxy::OP::CALL_CONTRACT = "Proxy::OP::CALL_CONTRACT"c;
+const int Proxy::OP::EMIT_EVENT = "Proxy::OP::EMIT_EVENT"c;
 
 ;; this is the opcode that we will "send out" of proxy to specify the callback
 ;; note that every other opcode that's namespaced by some contract is handled by the contract itself

package/src/workers/proxy/main.fc

@@ -12,6 +12,8 @@ tuple _executeOpcode(int op, cell $md) impure inline {
         return callContract($md);
     } elseif (op == Proxy::OP::TOGGLE_CALLBACK) {
         return toggleCallback($md);
+    } elseif (op == Proxy::OP::EMIT_EVENT) {
+        return emitEvent($md);
     }
     return callback($md);
 }

package/build/PriceFeedFeeLib.compiled.json

@@ -1 +0,0 @@
-{"hash":"62bac6fb0b72b3cf50109a7a7f531b7241a040673d985747a9c7def7451f43bc","hashBase64":"YrrG+wtys89QEJp6f1MbckGgQGc9mFdHqcfe90UfQ7w=","hex":"b5ee9c72410102010010000114ff00f4a413f4bcf2c80b010002d375051ca1"}