@layerzerolabs/protocol-stellar-v2 0.2.46 → 0.2.48

package/contracts/workers/dvn/src/tests/dvn.rs

@@ -348,4 +348,8 @@ impl IDvnFeeLib for MockFeeLib {
             params.multiplier_bps as i128
         }
     }
+
+    fn version(_env: &Env) -> (u64, u32) {
+        (1, 1)
+    }
 }

package/contracts/workers/dvn-fee-lib/src/dvn_fee_lib.rs

@@ -63,6 +63,10 @@ impl IDvnFeeLib for DvnFeeLib {
             fee_result.native_price_usd,
         )
     }
+
+    fn version(_env: &Env) -> (u64, u32) {
+        (1, 1)
+    }
 }
 
 // ============================================================================

package/contracts/workers/fee-lib-interfaces/src/dvn_fee_lib.rs

@@ -73,4 +73,10 @@ pub trait IDvnFeeLib {
     /// # Returns
     /// The calculated fee in native token units (stroops for Stellar).
     fn get_fee(env: &Env, dvn: &Address, params: &DvnFeeParams) -> i128;
+
+    /// Returns the fee library contract version.
+    ///
+    /// # Returns
+    /// Tuple of (major version, minor version).
+    fn version(env: &Env) -> (u64, u32);
 }

package/contracts/workers/price-feed/src/price_feed.rs

@@ -1,6 +1,7 @@
 use common_macros::{contract_impl, lz_contract, only_auth};
 use fee_lib_interfaces::{FeeEstimate, ILayerZeroPriceFeed, Price};
-use soroban_sdk::{assert_with_error, panic_with_error, Address, Env, Vec};
+use soroban_sdk::{assert_with_error, Address, Env, Vec};
+use utils::option_ext::OptionExt;
 
 use crate::{
     errors::PriceFeedError,
@@ -110,7 +111,7 @@ impl LzPriceFeed {
 
     /// Set prices for multiple destinations (price updater or owner)
     pub fn set_price(env: &Env, price_updater: &Address, prices: &Vec<UpdatePrice>) {
-        Self::require_price_updater(env, price_updater);
+        Self::require_owner_or_price_updater(env, price_updater);
 
         prices.iter().for_each(|update| Self::set_price_internal(env, update.eid, &update.price));
     }
@@ -118,7 +119,7 @@ impl LzPriceFeed {
     /// Set price for Arbitrum with extension (price updater or owner)
     /// Corresponds to setPriceForArbitrum in PriceFeed.sol
     pub fn set_price_for_arbitrum(env: &Env, price_updater: &Address, update: &UpdatePriceExt) {
-        Self::require_price_updater(env, price_updater);
+        Self::require_owner_or_price_updater(env, price_updater);
 
         Self::set_price_internal(env, update.eid, &update.price);
 
@@ -131,7 +132,7 @@ impl LzPriceFeed {
     ///
     /// Kept as a standalone contract function (not part of the canonical `fee_lib_interfaces::ILayerZeroPriceFeed` interface).
     pub fn set_native_token_price_usd(env: &Env, price_updater: &Address, native_token_price_usd: u128) {
-        Self::require_price_updater(env, price_updater);
+        Self::require_owner_or_price_updater(env, price_updater);
         PriceFeedStorage::set_native_price_usd(env, &native_token_price_usd);
     }
 
@@ -171,7 +172,7 @@ impl LzPriceFeed {
 
     /// Estimate fee with default model
     fn estimate_fee_with_default_model(env: &Env, dst_eid: u32, calldata_size: u32, gas: u128) -> (u128, u128) {
-        let price = Self::get_price(env, dst_eid).unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice));
+        let price = Self::get_price(env, dst_eid).unwrap_or_panic(env, PriceFeedError::NoPrice);
 
         // assuming the _gas includes (1) the 21,000 overhead and (2) not the calldata gas
         let gas_for_calldata = (calldata_size as u128) * (price.gas_per_byte as u128);
@@ -183,17 +184,14 @@ impl LzPriceFeed {
 
     /// Estimate fee with Optimism model
     fn estimate_fee_with_optimism_model(env: &Env, dst_eid: u32, calldata_size: u32, gas: u128) -> (u128, u128) {
-        let ethereum_id = Self::get_l1_lookup_id_for_optimism_model(env, dst_eid);
-
         // L1 fee (Ethereum)
-        let ethereum_price =
-            Self::get_price(env, ethereum_id).unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice));
+        let ethereum_id = Self::get_l1_lookup_id_for_optimism_model(env, dst_eid);
+        let ethereum_price = Self::get_price(env, ethereum_id).unwrap_or_panic(env, PriceFeedError::NoPrice);
         let gas_for_l1_calldata = ((calldata_size as u128) * (ethereum_price.gas_per_byte as u128)) + 3188; // 2100 + 68 * 16
         let l1_fee = gas_for_l1_calldata * (ethereum_price.gas_price_in_unit as u128);
 
         // L2 fee (Optimism)
-        let optimism_price =
-            Self::get_price(env, dst_eid).unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice));
+        let optimism_price = Self::get_price(env, dst_eid).unwrap_or_panic(env, PriceFeedError::NoPrice);
         let gas_for_l2_calldata = (calldata_size as u128) * (optimism_price.gas_per_byte as u128);
         let l2_fee = (gas_for_l2_calldata + gas) * (optimism_price.gas_price_in_unit as u128);
 
@@ -207,16 +205,13 @@ impl LzPriceFeed {
 
     /// Estimate fee with Arbitrum model
     fn estimate_fee_with_arbitrum_model(env: &Env, dst_eid: u32, calldata_size: u32, gas: u128) -> (u128, u128) {
-        let arbitrum_price =
-            Self::get_price(env, dst_eid).unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice));
-
-        let arbitrum_price_ext = Self::arbitrum_price_ext(env);
-
         // L1 fee (compressed calldata)
+        let arbitrum_price_ext = Self::arbitrum_price_ext(env);
         let gas_for_l1_calldata = (((calldata_size as u128) * Self::arbitrum_compression_percent(env)) / 100)
             * (arbitrum_price_ext.gas_per_l1_calldata_byte as u128);
 
         // L2 fee
+        let arbitrum_price = Self::get_price(env, dst_eid).unwrap_or_panic(env, PriceFeedError::NoPrice);
         let gas_for_l2_calldata = (calldata_size as u128) * (arbitrum_price.gas_per_byte as u128);
         let gas_fee = (gas + (arbitrum_price_ext.gas_per_l2_tx as u128) + gas_for_l1_calldata + gas_for_l2_calldata)
             * (arbitrum_price.gas_price_in_unit as u128);
@@ -251,18 +246,12 @@ impl LzPriceFeed {
     }
 
     /// Check if caller is price updater or owner
-    fn require_price_updater(env: &Env, caller: &Address) {
+    fn require_owner_or_price_updater(env: &Env, caller: &Address) {
         caller.require_auth();
-
-        // Owner is always approved
-        if let Some(owner) = Self::owner(env) {
-            if &owner == caller {
-                return;
-            }
-        }
-
-        // Check if caller is an active price updater
-        assert_with_error!(env, Self::is_price_updater(env, caller), PriceFeedError::OnlyPriceUpdater);
+        assert_with_error!(
+            env,
+            Self::owner(env).as_ref() == Some(caller) || Self::is_price_updater(env, caller),
+            PriceFeedError::OnlyPriceUpdater
+        );
     }
 }
-

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@layerzerolabs/protocol-stellar-v2",
-  "version": "0.2.46",
+  "version": "0.2.48",
   "private": false,
   "license": "LZBL-1.2",
   "devDependencies": {
     "@types/node": "^22.18.6",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
-    "@layerzerolabs/common-node-utils": "0.2.46",
-    "@layerzerolabs/stellar-ts-bindings-gen": "0.2.46",
-    "@layerzerolabs/vm-tooling-stellar": "0.2.46"
+    "@layerzerolabs/stellar-ts-bindings-gen": "0.2.48",
+    "@layerzerolabs/common-node-utils": "0.2.48",
+    "@layerzerolabs/vm-tooling-stellar": "0.2.48"
   },
   "publishConfig": {
     "access": "restricted",